| # Copyright 2021 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import math |
| import time |
| from enum import Enum |
| |
| import common |
| |
| from autotest_lib.server.cros.cellular.simulation_utils.BaseSimulation import BaseSimulation |
| from autotest_lib.server.cros.cellular.simulation_utils import BaseCellularDut |
| |
| |
| class TransmissionMode(Enum): |
| """ Transmission modes for LTE (e.g., TM1, TM4, ...) """ |
| TM1 = "TM1" |
| TM2 = "TM2" |
| TM3 = "TM3" |
| TM4 = "TM4" |
| TM7 = "TM7" |
| TM8 = "TM8" |
| TM9 = "TM9" |
| |
| |
| class MimoMode(Enum): |
| """ Mimo modes """ |
| MIMO_1x1 = "1x1" |
| MIMO_2x2 = "2x2" |
| MIMO_4x4 = "4x4" |
| |
| |
| class SchedulingMode(Enum): |
| """ Traffic scheduling modes (e.g., STATIC, DYNAMIC) """ |
| DYNAMIC = "DYNAMIC" |
| STATIC = "STATIC" |
| |
| |
| class DuplexMode(Enum): |
| """ DL/UL Duplex mode """ |
| FDD = "FDD" |
| TDD = "TDD" |
| |
| |
| class ModulationType(Enum): |
| """DL/UL Modulation order.""" |
| QPSK = 'QPSK' |
| Q16 = '16QAM' |
| Q64 = '64QAM' |
| Q256 = '256QAM' |
| |
| |
| class LteSimulation(BaseSimulation): |
| """ Single-carrier LTE simulation. """ |
| |
| # Simulation config keywords contained in the test name |
| PARAM_FRAME_CONFIG = "tddconfig" |
| PARAM_BW = "bw" |
| PARAM_SCHEDULING = "scheduling" |
| PARAM_SCHEDULING_STATIC = "static" |
| PARAM_SCHEDULING_DYNAMIC = "dynamic" |
| PARAM_PATTERN = "pattern" |
| PARAM_TM = "tm" |
| PARAM_UL_PW = 'pul' |
| PARAM_DL_PW = 'pdl' |
| PARAM_BAND = "band" |
| PARAM_MIMO = "mimo" |
| PARAM_DL_MCS = 'dlmcs' |
| PARAM_UL_MCS = 'ulmcs' |
| PARAM_SSF = 'ssf' |
| PARAM_CFI = 'cfi' |
| PARAM_PAGING = 'paging' |
| PARAM_PHICH = 'phich' |
| PARAM_RRC_STATUS_CHANGE_TIMER = "rrcstatuschangetimer" |
| PARAM_DRX = 'drx' |
| |
| # Test config keywords |
| KEY_TBS_PATTERN = "tbs_pattern_on" |
| KEY_DL_256_QAM = "256_qam_dl" |
| KEY_UL_64_QAM = "64_qam_ul" |
| |
| # Units in which signal level is defined in DOWNLINK_SIGNAL_LEVEL_DICTIONARY |
| DOWNLINK_SIGNAL_LEVEL_UNITS = "RSRP" |
| |
| # RSRP signal levels thresholds (as reported by Android) in dBm/15KHz. |
| # Excellent is set to -75 since callbox B Tx power is limited to -30 dBm |
| DOWNLINK_SIGNAL_LEVEL_DICTIONARY = { |
| 'excellent': -75, |
| 'high': -110, |
| 'medium': -115, |
| 'weak': -120, |
| 'disconnected': -170 |
| } |
| |
| # Transmitted output power for the phone (dBm) |
| UPLINK_SIGNAL_LEVEL_DICTIONARY = { |
| 'max': 24, |
| 'high': 13, |
| 'medium': 3, |
| 'low': -20 |
| } |
| |
| # Bandwidth [MHz] to total RBs mapping |
| total_rbs_dictionary = {20: 100, 15: 75, 10: 50, 5: 25, 3: 15, 1.4: 6} |
| |
| # Bandwidth [MHz] to RB group size |
| rbg_dictionary = {20: 4, 15: 4, 10: 3, 5: 2, 3: 2, 1.4: 1} |
| |
| # Bandwidth [MHz] to minimum number of DL RBs that can be assigned to a UE |
| min_dl_rbs_dictionary = {20: 16, 15: 12, 10: 9, 5: 4, 3: 4, 1.4: 2} |
| |
| # Bandwidth [MHz] to minimum number of UL RBs that can be assigned to a UE |
| min_ul_rbs_dictionary = {20: 8, 15: 6, 10: 4, 5: 2, 3: 2, 1.4: 1} |
| |
| # Allowed bandwidth for each band. |
| allowed_bandwidth_dictionary = { |
| 1: [5, 10, 15, 20], |
| 2: [1.4, 3, 5, 10, 15, 20], |
| 3: [1.4, 3, 5, 10, 15, 20], |
| 4: [1.4, 3, 5, 10, 15, 20], |
| 5: [1.4, 3, 5, 10], |
| 7: [5, 10, 15, 20], |
| 8: [1.4, 3, 5, 10], |
| 10: [5, 10, 15, 20], |
| 11: [5, 10], |
| 12: [1.4, 3, 5, 10], |
| 13: [5, 10], |
| 14: [5, 10], |
| 17: [5, 10], |
| 18: [5, 10, 15], |
| 19: [5, 10, 15], |
| 20: [5, 10, 15, 20], |
| 21: [5, 10, 15], |
| 22: [5, 10, 15, 20], |
| 24: [5, 10], |
| 25: [1.4, 3, 5, 10, 15, 20], |
| 26: [1.4, 3, 5, 10, 15], |
| 27: [1.4, 3, 5, 10], |
| 28: [3, 5, 10, 15, 20], |
| 29: [3, 5, 10], |
| 30: [5, 10], |
| 31: [1.4, 3, 5], |
| 32: [5, 10, 15, 20], |
| 33: [5, 10, 15, 20], |
| 34: [5, 10, 15], |
| 35: [1.4, 3, 5, 10, 15, 20], |
| 36: [1.4, 3, 5, 10, 15, 20], |
| 37: [5, 10, 15, 20], |
| 38: [20], |
| 39: [5, 10, 15, 20], |
| 40: [5, 10, 15, 20], |
| 41: [5, 10, 15, 20], |
| 42: [5, 10, 15, 20], |
| 43: [5, 10, 15, 20], |
| 44: [3, 5, 10, 15, 20], |
| 45: [5, 10, 15, 20], |
| 46: [10, 20], |
| 47: [10, 20], |
| 48: [5, 10, 15, 20], |
| 49: [10, 20], |
| 50: [3, 5, 10, 15, 20], |
| 51: [3, 5], |
| 52: [5, 10, 15, 20], |
| 65: [5, 10, 15, 20], |
| 66: [1.4, 3, 5, 10, 15, 20], |
| 67: [5, 10, 15, 20], |
| 68: [5, 10, 15], |
| 69: [5], |
| 70: [5, 10, 15], |
| 71: [5, 10, 15, 20], |
| 72: [1.4, 3, 5], |
| 73: [1.4, 3, 5], |
| 74: [1.4, 3, 5, 10, 15, 20], |
| 75: [5, 10, 15, 20], |
| 76: [5], |
| 85: [5, 10], |
| 252: [20], |
| 255: [20] |
| } |
| |
| # Peak throughput lookup tables for each TDD subframe |
| # configuration and bandwidth |
| # yapf: disable |
| tdd_config4_tput_lut = { |
| 0: { |
| 5: {'DL': 3.82, 'UL': 2.63}, |
| 10: {'DL': 11.31,'UL': 9.03}, |
| 15: {'DL': 16.9, 'UL': 20.62}, |
| 20: {'DL': 22.88, 'UL': 28.43} |
| }, |
| 1: { |
| 5: {'DL': 6.13, 'UL': 4.08}, |
| 10: {'DL': 18.36, 'UL': 9.69}, |
| 15: {'DL': 28.62, 'UL': 14.21}, |
| 20: {'DL': 39.04, 'UL': 19.23} |
| }, |
| 2: { |
| 5: {'DL': 5.68, 'UL': 2.30}, |
| 10: {'DL': 25.51, 'UL': 4.68}, |
| 15: {'DL': 39.3, 'UL': 7.13}, |
| 20: {'DL': 53.64, 'UL': 9.72} |
| }, |
| 3: { |
| 5: {'DL': 8.26, 'UL': 3.45}, |
| 10: {'DL': 23.20, 'UL': 6.99}, |
| 15: {'DL': 35.35, 'UL': 10.75}, |
| 20: {'DL': 48.3, 'UL': 14.6} |
| }, |
| 4: { |
| 5: {'DL': 6.16, 'UL': 2.30}, |
| 10: {'DL': 26.77, 'UL': 4.68}, |
| 15: {'DL': 40.7, 'UL': 7.18}, |
| 20: {'DL': 55.6, 'UL': 9.73} |
| }, |
| 5: { |
| 5: {'DL': 6.91, 'UL': 1.12}, |
| 10: {'DL': 30.33, 'UL': 2.33}, |
| 15: {'DL': 46.04, 'UL': 3.54}, |
| 20: {'DL': 62.9, 'UL': 4.83} |
| }, |
| 6: { |
| 5: {'DL': 6.13, 'UL': 4.13}, |
| 10: {'DL': 14.79, 'UL': 11.98}, |
| 15: {'DL': 23.28, 'UL': 17.46}, |
| 20: {'DL': 31.75, 'UL': 23.95} |
| } |
| } |
| |
| tdd_config3_tput_lut = { |
| 0: { |
| 5: {'DL': 5.04, 'UL': 3.7}, |
| 10: {'DL': 15.11, 'UL': 17.56}, |
| 15: {'DL': 22.59, 'UL': 30.31}, |
| 20: {'DL': 30.41, 'UL': 41.61} |
| }, |
| 1: { |
| 5: {'DL': 8.07, 'UL': 5.66}, |
| 10: {'DL': 24.58, 'UL': 13.66}, |
| 15: {'DL': 39.05, 'UL': 20.68}, |
| 20: {'DL': 51.59, 'UL': 28.76} |
| }, |
| 2: { |
| 5: {'DL': 7.59, 'UL': 3.31}, |
| 10: {'DL': 34.08, 'UL': 6.93}, |
| 15: {'DL': 53.64, 'UL': 10.51}, |
| 20: {'DL': 70.55, 'UL': 14.41} |
| }, |
| 3: { |
| 5: {'DL': 10.9, 'UL': 5.0}, |
| 10: {'DL': 30.99, 'UL': 10.25}, |
| 15: {'DL': 48.3, 'UL': 15.81}, |
| 20: {'DL': 63.24, 'UL': 21.65} |
| }, |
| 4: { |
| 5: {'DL': 8.11, 'UL': 3.32}, |
| 10: {'DL': 35.74, 'UL': 6.95}, |
| 15: {'DL': 55.6, 'UL': 10.51}, |
| 20: {'DL': 72.72, 'UL': 14.41} |
| }, |
| 5: { |
| 5: {'DL': 9.28, 'UL': 1.57}, |
| 10: {'DL': 40.49, 'UL': 3.44}, |
| 15: {'DL': 62.9, 'UL': 5.23}, |
| 20: {'DL': 82.21, 'UL': 7.15} |
| }, |
| 6: { |
| 5: {'DL': 8.06, 'UL': 5.74}, |
| 10: {'DL': 19.82, 'UL': 17.51}, |
| 15: {'DL': 31.75, 'UL': 25.77}, |
| 20: {'DL': 42.12, 'UL': 34.91} |
| } |
| } |
| |
| tdd_config2_tput_lut = { |
| 0: { |
| 5: {'DL': 3.11, 'UL': 2.55}, |
| 10: {'DL': 9.93, 'UL': 11.1}, |
| 15: {'DL': 13.9, 'UL': 21.51}, |
| 20: {'DL': 20.02, 'UL': 41.66} |
| }, |
| 1: { |
| 5: {'DL': 5.33, 'UL': 4.27}, |
| 10: {'DL': 15.14, 'UL': 13.95}, |
| 15: {'DL': 33.84, 'UL': 19.73}, |
| 20: {'DL': 44.61, 'UL': 27.35} |
| }, |
| 2: { |
| 5: {'DL': 6.87, 'UL': 3.32}, |
| 10: {'DL': 17.06, 'UL': 6.76}, |
| 15: {'DL': 49.63, 'UL': 10.5}, |
| 20: {'DL': 65.2, 'UL': 14.41} |
| }, |
| 3: { |
| 5: {'DL': 5.41, 'UL': 4.17}, |
| 10: {'DL': 16.89, 'UL': 9.73}, |
| 15: {'DL': 44.29, 'UL': 15.7}, |
| 20: {'DL': 53.95, 'UL': 19.85} |
| }, |
| 4: { |
| 5: {'DL': 8.7, 'UL': 3.32}, |
| 10: {'DL': 17.58, 'UL': 6.76}, |
| 15: {'DL': 51.08, 'UL': 10.47}, |
| 20: {'DL': 66.45, 'UL': 14.38} |
| }, |
| 5: { |
| 5: {'DL': 9.46, 'UL': 1.55}, |
| 10: {'DL': 19.02, 'UL': 3.48}, |
| 15: {'DL': 58.89, 'UL': 5.23}, |
| 20: {'DL': 76.85, 'UL': 7.1} |
| }, |
| 6: { |
| 5: {'DL': 4.74, 'UL': 3.9}, |
| 10: {'DL': 12.32, 'UL': 13.37}, |
| 15: {'DL': 27.74, 'UL': 25.02}, |
| 20: {'DL': 35.48, 'UL': 32.95} |
| } |
| } |
| |
| tdd_config1_tput_lut = { |
| 0: { |
| 5: {'DL': 4.25, 'UL': 3.35}, |
| 10: {'DL': 8.38, 'UL': 7.22}, |
| 15: {'DL': 12.41, 'UL': 13.91}, |
| 20: {'DL': 16.27, 'UL': 24.09} |
| }, |
| 1: { |
| 5: {'DL': 7.28, 'UL': 4.61}, |
| 10: {'DL': 14.73, 'UL': 9.69}, |
| 15: {'DL': 21.91, 'UL': 13.86}, |
| 20: {'DL': 27.63, 'UL': 17.18} |
| }, |
| 2: { |
| 5: {'DL': 10.37, 'UL': 2.27}, |
| 10: {'DL': 20.92, 'UL': 4.66}, |
| 15: {'DL': 31.01, 'UL': 7.04}, |
| 20: {'DL': 42.03, 'UL': 9.75} |
| }, |
| 3: { |
| 5: {'DL': 9.25, 'UL': 3.44}, |
| 10: {'DL': 18.38, 'UL': 6.95}, |
| 15: {'DL': 27.59, 'UL': 10.62}, |
| 20: {'DL': 34.85, 'UL': 13.45} |
| }, |
| 4: { |
| 5: {'DL': 10.71, 'UL': 2.26}, |
| 10: {'DL': 21.54, 'UL': 4.67}, |
| 15: {'DL': 31.91, 'UL': 7.2}, |
| 20: {'DL': 43.35, 'UL': 9.74} |
| }, |
| 5: { |
| 5: {'DL': 12.34, 'UL': 1.08}, |
| 10: {'DL': 24.78, 'UL': 2.34}, |
| 15: {'DL': 36.68, 'UL': 3.57}, |
| 20: {'DL': 49.84, 'UL': 4.81} |
| }, |
| 6: { |
| 5: {'DL': 5.76, 'UL': 4.41}, |
| 10: {'DL': 11.68, 'UL': 9.7}, |
| 15: {'DL': 17.34, 'UL': 17.95}, |
| 20: {'DL': 23.5, 'UL': 23.42} |
| } |
| } |
| # yapf: enable |
| |
| # Peak throughput lookup table dictionary |
| tdd_config_tput_lut_dict = { |
| 'TDD_CONFIG1': |
| tdd_config1_tput_lut, # DL 256QAM, UL 64QAM & TBS turned OFF |
| 'TDD_CONFIG2': |
| tdd_config2_tput_lut, # DL 256QAM, UL 64 QAM turned ON & TBS OFF |
| 'TDD_CONFIG3': |
| tdd_config3_tput_lut, # DL 256QAM, UL 64QAM & TBS turned ON |
| 'TDD_CONFIG4': |
| tdd_config4_tput_lut # DL 256QAM, UL 64 QAM turned OFF & TBS ON |
| } |
| |
| class BtsConfig(BaseSimulation.BtsConfig): |
| """ Extension of the BaseBtsConfig to implement parameters that are |
| exclusive to LTE. |
| |
| Attributes: |
| band: an integer indicating the required band number. |
| dlul_config: an integer indicating the TDD config number. |
| ssf_config: an integer indicating the Special Sub-Frame config. |
| bandwidth: a float indicating the required channel bandwidth. |
| mimo_mode: an instance of LteSimulation.MimoMode indicating the |
| required MIMO mode for the downlink signal. |
| transmission_mode: an instance of LteSimulation.TransmissionMode |
| indicating the required TM. |
| scheduling_mode: an instance of LteSimulation.SchedulingMode |
| indicating whether to use Static or Dynamic scheduling. |
| dl_rbs: an integer indicating the number of downlink RBs |
| ul_rbs: an integer indicating the number of uplink RBs |
| dl_mcs: an integer indicating the MCS for the downlink signal |
| ul_mcs: an integer indicating the MCS for the uplink signal |
| dl_modulation_order: a string indicating a DL modulation scheme |
| ul_modulation_order: a string indicating an UL modulation scheme |
| tbs_pattern_on: a boolean indicating whether full allocation mode |
| should be used or not |
| dl_channel: an integer indicating the downlink channel number |
| cfi: an integer indicating the Control Format Indicator |
| paging_cycle: an integer indicating the paging cycle duration in |
| milliseconds |
| phich: a string indicating the PHICH group size parameter |
| drx_connected_mode: a boolean indicating whether cDRX mode is |
| on or off |
| drx_on_duration_timer: number of PDCCH subframes representing |
| DRX on duration |
| drx_inactivity_timer: number of PDCCH subframes to wait before |
| entering DRX mode |
| drx_retransmission_timer: number of consecutive PDCCH subframes |
| to wait for retransmission |
| drx_long_cycle: number of subframes representing one long DRX cycle. |
| One cycle consists of DRX sleep + DRX on duration |
| drx_long_cycle_offset: number representing offset in range |
| 0 to drx_long_cycle - 1 |
| """ |
| |
| def __init__(self): |
| """ Initialize the base station config by setting all its |
| parameters to None. """ |
| super(LteSimulation.BtsConfig, self).__init__() |
| self.band = None |
| self.dlul_config = None |
| self.ssf_config = None |
| self.bandwidth = None |
| self.mimo_mode = None |
| self.transmission_mode = None |
| self.scheduling_mode = None |
| self.dl_rbs = None |
| self.ul_rbs = None |
| self.dl_mcs = None |
| self.ul_mcs = None |
| self.dl_modulation_order = None |
| self.ul_modulation_order = None |
| self.tbs_pattern_on = None |
| self.dl_channel = None |
| self.cfi = None |
| self.paging_cycle = None |
| self.phich = None |
| self.drx_connected_mode = None |
| self.drx_on_duration_timer = None |
| self.drx_inactivity_timer = None |
| self.drx_retransmission_timer = None |
| self.drx_long_cycle = None |
| self.drx_long_cycle_offset = None |
| |
| def __init__(self, simulator, log, dut, test_config, calibration_table): |
| """ Initializes the simulator for a single-carrier LTE simulation. |
| |
| Loads a simple LTE simulation environment with 1 basestation. |
| |
| Args: |
| simulator: a cellular simulator controller |
| log: a logger handle |
| dut: a device handler implementing BaseCellularDut |
| test_config: test configuration obtained from the config file |
| calibration_table: a dictionary containing path losses for |
| different bands. |
| |
| """ |
| |
| super(LteSimulation, self).__init__(simulator, log, dut, test_config, |
| calibration_table) |
| |
| self.dut.set_preferred_network_type( |
| BaseCellularDut.PreferredNetworkType.LTE_ONLY) |
| |
| # Get TBS pattern setting from the test configuration |
| if self.KEY_TBS_PATTERN not in test_config: |
| self.log.warning("The key '{}' is not set in the config file. " |
| "Setting to true by default.".format( |
| self.KEY_TBS_PATTERN)) |
| self.primary_config.tbs_pattern_on = test_config.get( |
| self.KEY_TBS_PATTERN, True) |
| |
| # Get the 256-QAM setting from the test configuration |
| if self.KEY_DL_256_QAM not in test_config: |
| self.log.warning("The key '{}' is not set in the config file. " |
| "Setting to false by default.".format( |
| self.KEY_DL_256_QAM)) |
| |
| self.dl_256_qam = test_config.get(self.KEY_DL_256_QAM, False) |
| |
| if self.dl_256_qam: |
| if not self.simulator.LTE_SUPPORTS_DL_256QAM: |
| self.log.warning("The key '{}' is set to true but the " |
| "simulator doesn't support that modulation " |
| "order.".format(self.KEY_DL_256_QAM)) |
| self.dl_256_qam = False |
| else: |
| self.primary_config.dl_modulation_order = ModulationType.Q256 |
| |
| else: |
| self.log.warning( |
| 'dl modulation 256QAM is not specified in config, ' |
| 'setting to default value 64QAM') |
| self.primary_config.dl_modulation_order = ModulationType.Q64 |
| # Get the 64-QAM setting from the test configuration |
| if self.KEY_UL_64_QAM not in test_config: |
| self.log.warning("The key '{}' is not set in the config file. " |
| "Setting to false by default.".format( |
| self.KEY_UL_64_QAM)) |
| |
| self.ul_64_qam = test_config.get(self.KEY_UL_64_QAM, False) |
| |
| if self.ul_64_qam: |
| if not self.simulator.LTE_SUPPORTS_UL_64QAM: |
| self.log.warning("The key '{}' is set to true but the " |
| "simulator doesn't support that modulation " |
| "order.".format(self.KEY_UL_64_QAM)) |
| self.ul_64_qam = False |
| else: |
| self.primary_config.ul_modulation_order = ModulationType.Q64 |
| else: |
| self.log.warning('ul modulation 64QAM is not specified in config, ' |
| 'setting to default value 16QAM') |
| self.primary_config.ul_modulation_order = ModulationType.Q16 |
| |
| self.simulator.configure_bts(self.primary_config) |
| |
| def setup_simulator(self): |
| """ Do initial configuration in the simulator. """ |
| self.simulator.setup_lte_scenario() |
| |
| def parse_parameters(self, parameters): |
| """ Configs an LTE simulation using a list of parameters. |
| |
| Calls the parent method first, then consumes parameters specific to LTE. |
| |
| Args: |
| parameters: list of parameters |
| """ |
| |
| # Instantiate a new configuration object |
| new_config = self.BtsConfig() |
| |
| # Setup band |
| |
| values = self.consume_parameter(parameters, self.PARAM_BAND, 1) |
| |
| if not values: |
| raise ValueError( |
| "The test name needs to include parameter '{}' followed by " |
| "the required band number.".format(self.PARAM_BAND)) |
| |
| new_config.band = values[1] |
| |
| # Set TDD-only configs |
| if self.get_duplex_mode(new_config.band) == DuplexMode.TDD: |
| |
| # Sub-frame DL/UL config |
| values = self.consume_parameter(parameters, |
| self.PARAM_FRAME_CONFIG, 1) |
| if not values: |
| raise ValueError( |
| "When a TDD band is selected the frame " |
| "structure has to be indicated with the '{}' " |
| "parameter followed by a number from 0 to 6.".format( |
| self.PARAM_FRAME_CONFIG)) |
| |
| new_config.dlul_config = int(values[1]) |
| |
| # Special Sub-Frame configuration |
| values = self.consume_parameter(parameters, self.PARAM_SSF, 1) |
| |
| if not values: |
| self.log.warning( |
| 'The {} parameter was not provided. Setting ' |
| 'Special Sub-Frame config to 6 by default.'.format( |
| self.PARAM_SSF)) |
| new_config.ssf_config = 6 |
| else: |
| new_config.ssf_config = int(values[1]) |
| |
| # Setup bandwidth |
| |
| values = self.consume_parameter(parameters, self.PARAM_BW, 1) |
| |
| if not values: |
| raise ValueError( |
| "The test name needs to include parameter {} followed by an " |
| "int value (to indicate 1.4 MHz use 14).".format( |
| self.PARAM_BW)) |
| |
| bw = float(values[1]) |
| |
| if bw == 14: |
| bw = 1.4 |
| |
| new_config.bandwidth = bw |
| |
| # Setup mimo mode |
| |
| values = self.consume_parameter(parameters, self.PARAM_MIMO, 1) |
| |
| if not values: |
| raise ValueError( |
| "The test name needs to include parameter '{}' followed by the " |
| "mimo mode.".format(self.PARAM_MIMO)) |
| |
| for mimo_mode in MimoMode: |
| if values[1] == mimo_mode.value: |
| new_config.mimo_mode = mimo_mode |
| break |
| else: |
| raise ValueError("The {} parameter needs to be followed by either " |
| "1x1, 2x2 or 4x4.".format(self.PARAM_MIMO)) |
| |
| if (new_config.mimo_mode == MimoMode.MIMO_4x4 |
| and not self.simulator.LTE_SUPPORTS_4X4_MIMO): |
| raise ValueError("The test requires 4x4 MIMO, but that is not " |
| "supported by the cellular simulator.") |
| |
| # Setup transmission mode |
| |
| values = self.consume_parameter(parameters, self.PARAM_TM, 1) |
| |
| if not values: |
| raise ValueError( |
| "The test name needs to include parameter {} followed by an " |
| "int value from 1 to 4 indicating transmission mode.". |
| format(self.PARAM_TM)) |
| |
| for tm in TransmissionMode: |
| if values[1] == tm.value[2:]: |
| new_config.transmission_mode = tm |
| break |
| else: |
| raise ValueError("The {} parameter needs to be followed by either " |
| "TM1, TM2, TM3, TM4, TM7, TM8 or TM9.".format( |
| self.PARAM_MIMO)) |
| |
| # Setup scheduling mode |
| |
| values = self.consume_parameter(parameters, self.PARAM_SCHEDULING, 1) |
| |
| if not values: |
| new_config.scheduling_mode = SchedulingMode.STATIC |
| self.log.warning( |
| "The test name does not include the '{}' parameter. Setting to " |
| "static by default.".format(self.PARAM_SCHEDULING)) |
| elif values[1] == self.PARAM_SCHEDULING_DYNAMIC: |
| new_config.scheduling_mode = SchedulingMode.DYNAMIC |
| elif values[1] == self.PARAM_SCHEDULING_STATIC: |
| new_config.scheduling_mode = SchedulingMode.STATIC |
| else: |
| raise ValueError( |
| "The test name parameter '{}' has to be followed by either " |
| "'dynamic' or 'static'.".format(self.PARAM_SCHEDULING)) |
| |
| if new_config.scheduling_mode == SchedulingMode.STATIC: |
| |
| values = self.consume_parameter(parameters, self.PARAM_PATTERN, 2) |
| |
| if not values: |
| self.log.warning( |
| "The '{}' parameter was not set, using 100% RBs for both " |
| "DL and UL. To set the percentages of total RBs include " |
| "the '{}' parameter followed by two ints separated by an " |
| "underscore indicating downlink and uplink percentages." |
| .format(self.PARAM_PATTERN, self.PARAM_PATTERN)) |
| dl_pattern = 100 |
| ul_pattern = 100 |
| else: |
| dl_pattern = int(values[1]) |
| ul_pattern = int(values[2]) |
| |
| if not (0 <= dl_pattern <= 100 and 0 <= ul_pattern <= 100): |
| raise ValueError( |
| "The scheduling pattern parameters need to be two " |
| "positive numbers between 0 and 100.") |
| |
| new_config.dl_rbs, new_config.ul_rbs = ( |
| self.allocation_percentages_to_rbs( |
| new_config.bandwidth, new_config.transmission_mode, |
| dl_pattern, ul_pattern)) |
| |
| # Look for a DL MCS configuration in the test parameters. If it is |
| # not present, use a default value. |
| dlmcs = self.consume_parameter(parameters, self.PARAM_DL_MCS, 1) |
| |
| if dlmcs: |
| new_config.dl_mcs = int(dlmcs[1]) |
| else: |
| self.log.warning( |
| 'The test name does not include the {} parameter. Setting ' |
| 'to the max value by default'.format( |
| self.PARAM_DL_MCS)) |
| if self.dl_256_qam and new_config.bandwidth == 1.4: |
| new_config.dl_mcs = 26 |
| elif (not self.dl_256_qam |
| and self.primary_config.tbs_pattern_on |
| and new_config.bandwidth != 1.4): |
| new_config.dl_mcs = 28 |
| else: |
| new_config.dl_mcs = 27 |
| |
| # Look for an UL MCS configuration in the test parameters. If it is |
| # not present, use a default value. |
| ulmcs = self.consume_parameter(parameters, self.PARAM_UL_MCS, 1) |
| |
| if ulmcs: |
| new_config.ul_mcs = int(ulmcs[1]) |
| else: |
| self.log.warning( |
| 'The test name does not include the {} parameter. Setting ' |
| 'to the max value by default'.format( |
| self.PARAM_UL_MCS)) |
| if self.ul_64_qam: |
| new_config.ul_mcs = 28 |
| else: |
| new_config.ul_mcs = 23 |
| |
| # Configure the simulation for DRX mode |
| |
| drx = self.consume_parameter(parameters, self.PARAM_DRX, 5) |
| |
| if drx and len(drx) == 6: |
| new_config.drx_connected_mode = True |
| new_config.drx_on_duration_timer = drx[1] |
| new_config.drx_inactivity_timer = drx[2] |
| new_config.drx_retransmission_timer = drx[3] |
| new_config.drx_long_cycle = drx[4] |
| try: |
| long_cycle = int(drx[4]) |
| long_cycle_offset = int(drx[5]) |
| if long_cycle_offset in range(0, long_cycle): |
| new_config.drx_long_cycle_offset = long_cycle_offset |
| else: |
| self.log.error( |
| ("The cDRX long cycle offset must be in the " |
| "range 0 to (long cycle - 1). Setting " |
| "long cycle offset to 0")) |
| new_config.drx_long_cycle_offset = 0 |
| |
| except ValueError: |
| self.log.error(("cDRX long cycle and long cycle offset " |
| "must be integers. Disabling cDRX mode.")) |
| new_config.drx_connected_mode = False |
| else: |
| self.log.warning(("DRX mode was not configured properly. " |
| "Please provide the following 5 values: " |
| "1) DRX on duration timer " |
| "2) Inactivity timer " |
| "3) Retransmission timer " |
| "4) Long DRX cycle duration " |
| "5) Long DRX cycle offset " |
| "Example: drx_2_6_16_20_0")) |
| |
| # Setup LTE RRC status change function and timer for LTE idle test case |
| values = self.consume_parameter(parameters, |
| self.PARAM_RRC_STATUS_CHANGE_TIMER, 1) |
| if not values: |
| self.log.info( |
| "The test name does not include the '{}' parameter. Disabled " |
| "by default.".format(self.PARAM_RRC_STATUS_CHANGE_TIMER)) |
| self.simulator.set_lte_rrc_state_change_timer(False) |
| else: |
| timer = int(values[1]) |
| self.simulator.set_lte_rrc_state_change_timer(True, timer) |
| self.rrc_sc_timer = timer |
| |
| # Channel Control Indicator |
| values = self.consume_parameter(parameters, self.PARAM_CFI, 1) |
| |
| if not values: |
| self.log.warning('The {} parameter was not provided. Setting ' |
| 'CFI to BESTEFFORT.'.format(self.PARAM_CFI)) |
| new_config.cfi = 'BESTEFFORT' |
| else: |
| new_config.cfi = values[1] |
| |
| # PHICH group size |
| values = self.consume_parameter(parameters, self.PARAM_PHICH, 1) |
| |
| if not values: |
| self.log.warning('The {} parameter was not provided. Setting ' |
| 'PHICH group size to 1 by default.'.format( |
| self.PARAM_PHICH)) |
| new_config.phich = '1' |
| else: |
| if values[1] == '16': |
| new_config.phich = '1/6' |
| elif values[1] == '12': |
| new_config.phich = '1/2' |
| elif values[1] in ['1/6', '1/2', '1', '2']: |
| new_config.phich = values[1] |
| else: |
| raise ValueError('The {} parameter can only be followed by 1,' |
| '2, 1/2 (or 12) and 1/6 (or 16).'.format( |
| self.PARAM_PHICH)) |
| |
| # Paging cycle duration |
| values = self.consume_parameter(parameters, self.PARAM_PAGING, 1) |
| |
| if not values: |
| self.log.warning('The {} parameter was not provided. Setting ' |
| 'paging cycle duration to 1280 ms by ' |
| 'default.'.format(self.PARAM_PAGING)) |
| new_config.paging_cycle = 1280 |
| else: |
| try: |
| new_config.paging_cycle = int(values[1]) |
| except ValueError: |
| raise ValueError( |
| 'The {} parameter has to be followed by the paging cycle ' |
| 'duration in milliseconds.'.format(self.PARAM_PAGING)) |
| |
| # Get uplink power |
| |
| ul_power = self.get_uplink_power_from_parameters(parameters) |
| |
| # Power is not set on the callbox until after the simulation is |
| # started. Saving this value in a variable for later |
| self.sim_ul_power = ul_power |
| |
| # Get downlink power |
| |
| dl_power = self.get_downlink_power_from_parameters(parameters) |
| |
| # Power is not set on the callbox until after the simulation is |
| # started. Saving this value in a variable for later |
| self.sim_dl_power = dl_power |
| |
| # Setup the base station with the obtained configuration and then save |
| # these parameters in the current configuration object |
| self.simulator.configure_bts(new_config) |
| self.primary_config.incorporate(new_config) |
| |
| # Now that the band is set, calibrate the link if necessary |
| self.load_pathloss_if_required() |
| |
| def calibrated_downlink_rx_power(self, bts_config, rsrp): |
| """ LTE simulation overrides this method so that it can convert from |
| RSRP to total signal power transmitted from the basestation. |
| |
| Args: |
| bts_config: the current configuration at the base station |
| rsrp: desired rsrp, contained in a key value pair |
| """ |
| |
| power = self.rsrp_to_signal_power(rsrp, bts_config) |
| |
| self.log.info( |
| "Setting downlink signal level to {} RSRP ({} dBm)".format( |
| rsrp, power)) |
| |
| # Use parent method to calculate signal level |
| return super(LteSimulation, |
| self).calibrated_downlink_rx_power(bts_config, power) |
| |
| def downlink_calibration(self, rat=None, power_units_conversion_func=None): |
| """ Computes downlink path loss and returns the calibration value. |
| |
| See base class implementation for details. |
| |
| Args: |
| rat: ignored, replaced by 'lteRsrp' |
| power_units_conversion_func: ignored, replaced by |
| self.rsrp_to_signal_power |
| |
| Returns: |
| Downlink calibration value and measured DL power. Note that the |
| phone only reports RSRP of the primary chain |
| """ |
| |
| return super().downlink_calibration( |
| rat='lteDbm', |
| power_units_conversion_func=self.rsrp_to_signal_power) |
| |
| def rsrp_to_signal_power(self, rsrp, bts_config): |
| """ Converts rsrp to total band signal power |
| |
| RSRP is measured per subcarrier, so total band power needs to be |
| multiplied by the number of subcarriers being used. |
| |
| Args: |
| rsrp: desired rsrp in dBm |
| bts_config: a base station configuration object |
| Returns: |
| Total band signal power in dBm |
| """ |
| |
| bandwidth = bts_config.bandwidth |
| |
| if bandwidth == 20: # 100 RBs |
| power = rsrp + 30.79 |
| elif bandwidth == 15: # 75 RBs |
| power = rsrp + 29.54 |
| elif bandwidth == 10: # 50 RBs |
| power = rsrp + 27.78 |
| elif bandwidth == 5: # 25 RBs |
| power = rsrp + 24.77 |
| elif bandwidth == 3: # 15 RBs |
| power = rsrp + 22.55 |
| elif bandwidth == 1.4: # 6 RBs |
| power = rsrp + 18.57 |
| else: |
| raise ValueError("Invalid bandwidth value.") |
| |
| return power |
| |
| def maximum_downlink_throughput(self): |
| """ Calculates maximum achievable downlink throughput in the current |
| simulation state. |
| |
| Returns: |
| Maximum throughput in mbps. |
| |
| """ |
| |
| return self.bts_maximum_downlink_throughtput(self.primary_config) |
| |
| def bts_maximum_downlink_throughtput(self, bts_config): |
| """ Calculates maximum achievable downlink throughput for a single |
| base station from its configuration object. |
| |
| Args: |
| bts_config: a base station configuration object. |
| |
| Returns: |
| Maximum throughput in mbps. |
| |
| """ |
| if bts_config.mimo_mode == MimoMode.MIMO_1x1: |
| streams = 1 |
| elif bts_config.mimo_mode == MimoMode.MIMO_2x2: |
| streams = 2 |
| elif bts_config.mimo_mode == MimoMode.MIMO_4x4: |
| streams = 4 |
| else: |
| raise ValueError('Unable to calculate maximum downlink throughput ' |
| 'because the MIMO mode has not been set.') |
| |
| bandwidth = bts_config.bandwidth |
| rb_ratio = bts_config.dl_rbs / self.total_rbs_dictionary[bandwidth] |
| mcs = bts_config.dl_mcs |
| |
| max_rate_per_stream = None |
| |
| tdd_subframe_config = bts_config.dlul_config |
| duplex_mode = self.get_duplex_mode(bts_config.band) |
| |
| if duplex_mode == DuplexMode.TDD: |
| if self.dl_256_qam: |
| if mcs == 27: |
| if bts_config.tbs_pattern_on: |
| max_rate_per_stream = self.tdd_config_tput_lut_dict[ |
| 'TDD_CONFIG3'][tdd_subframe_config][bandwidth][ |
| 'DL'] |
| else: |
| max_rate_per_stream = self.tdd_config_tput_lut_dict[ |
| 'TDD_CONFIG2'][tdd_subframe_config][bandwidth][ |
| 'DL'] |
| else: |
| if mcs == 28: |
| if bts_config.tbs_pattern_on: |
| max_rate_per_stream = self.tdd_config_tput_lut_dict[ |
| 'TDD_CONFIG4'][tdd_subframe_config][bandwidth][ |
| 'DL'] |
| else: |
| max_rate_per_stream = self.tdd_config_tput_lut_dict[ |
| 'TDD_CONFIG1'][tdd_subframe_config][bandwidth][ |
| 'DL'] |
| |
| elif duplex_mode == DuplexMode.FDD: |
| if (not self.dl_256_qam and bts_config.tbs_pattern_on |
| and mcs == 28): |
| max_rate_per_stream = { |
| 3: 9.96, |
| 5: 17.0, |
| 10: 34.7, |
| 15: 52.7, |
| 20: 72.2 |
| }.get(bandwidth, None) |
| if (not self.dl_256_qam and bts_config.tbs_pattern_on |
| and mcs == 27): |
| max_rate_per_stream = { |
| 1.4: 2.94, |
| }.get(bandwidth, None) |
| elif (not self.dl_256_qam and not bts_config.tbs_pattern_on |
| and mcs == 27): |
| max_rate_per_stream = { |
| 1.4: 2.87, |
| 3: 7.7, |
| 5: 14.4, |
| 10: 28.7, |
| 15: 42.3, |
| 20: 57.7 |
| }.get(bandwidth, None) |
| elif self.dl_256_qam and bts_config.tbs_pattern_on and mcs == 27: |
| max_rate_per_stream = { |
| 3: 13.2, |
| 5: 22.9, |
| 10: 46.3, |
| 15: 72.2, |
| 20: 93.9 |
| }.get(bandwidth, None) |
| elif self.dl_256_qam and bts_config.tbs_pattern_on and mcs == 26: |
| max_rate_per_stream = { |
| 1.4: 3.96, |
| }.get(bandwidth, None) |
| elif (self.dl_256_qam and not bts_config.tbs_pattern_on |
| and mcs == 27): |
| max_rate_per_stream = { |
| 3: 11.3, |
| 5: 19.8, |
| 10: 44.1, |
| 15: 68.1, |
| 20: 88.4 |
| }.get(bandwidth, None) |
| elif (self.dl_256_qam and not bts_config.tbs_pattern_on |
| and mcs == 26): |
| max_rate_per_stream = { |
| 1.4: 3.96, |
| }.get(bandwidth, None) |
| |
| if not max_rate_per_stream: |
| raise NotImplementedError( |
| "The calculation for tbs pattern = {} " |
| "and mcs = {} is not implemented.".format( |
| "FULLALLOCATION" |
| if bts_config.tbs_pattern_on else "OFF", mcs)) |
| |
| return max_rate_per_stream * streams * rb_ratio |
| |
| def maximum_uplink_throughput(self): |
| """ Calculates maximum achievable uplink throughput in the current |
| simulation state. |
| |
| Returns: |
| Maximum throughput in mbps. |
| |
| """ |
| |
| return self.bts_maximum_uplink_throughtput(self.primary_config) |
| |
| def bts_maximum_uplink_throughtput(self, bts_config): |
| """ Calculates maximum achievable uplink throughput for the selected |
| basestation from its configuration object. |
| |
| Args: |
| bts_config: an LTE base station configuration object. |
| |
| Returns: |
| Maximum throughput in mbps. |
| |
| """ |
| |
| bandwidth = bts_config.bandwidth |
| rb_ratio = bts_config.ul_rbs / self.total_rbs_dictionary[bandwidth] |
| mcs = bts_config.ul_mcs |
| |
| max_rate_per_stream = None |
| |
| tdd_subframe_config = bts_config.dlul_config |
| duplex_mode = self.get_duplex_mode(bts_config.band) |
| |
| if duplex_mode == DuplexMode.TDD: |
| if self.ul_64_qam: |
| if mcs == 28: |
| if bts_config.tbs_pattern_on: |
| max_rate_per_stream = self.tdd_config_tput_lut_dict[ |
| 'TDD_CONFIG3'][tdd_subframe_config][bandwidth][ |
| 'UL'] |
| else: |
| max_rate_per_stream = self.tdd_config_tput_lut_dict[ |
| 'TDD_CONFIG2'][tdd_subframe_config][bandwidth][ |
| 'UL'] |
| else: |
| if mcs == 23: |
| if bts_config.tbs_pattern_on: |
| max_rate_per_stream = self.tdd_config_tput_lut_dict[ |
| 'TDD_CONFIG4'][tdd_subframe_config][bandwidth][ |
| 'UL'] |
| else: |
| max_rate_per_stream = self.tdd_config_tput_lut_dict[ |
| 'TDD_CONFIG1'][tdd_subframe_config][bandwidth][ |
| 'UL'] |
| |
| elif duplex_mode == DuplexMode.FDD: |
| if mcs == 23 and not self.ul_64_qam: |
| max_rate_per_stream = { |
| 1.4: 2.85, |
| 3: 7.18, |
| 5: 12.1, |
| 10: 24.5, |
| 15: 36.5, |
| 20: 49.1 |
| }.get(bandwidth, None) |
| elif mcs == 28 and self.ul_64_qam: |
| max_rate_per_stream = { |
| 1.4: 4.2, |
| 3: 10.5, |
| 5: 17.2, |
| 10: 35.3, |
| 15: 53.0, |
| 20: 72.6 |
| }.get(bandwidth, None) |
| |
| if not max_rate_per_stream: |
| raise NotImplementedError( |
| "The calculation fir mcs = {} is not implemented.".format( |
| "FULLALLOCATION" |
| if bts_config.tbs_pattern_on else "OFF", mcs)) |
| |
| return max_rate_per_stream * rb_ratio |
| |
| def allocation_percentages_to_rbs(self, bw, tm, dl, ul): |
| """ Converts usage percentages to number of DL/UL RBs |
| |
| Because not any number of DL/UL RBs can be obtained for a certain |
| bandwidth, this function calculates the number of RBs that most |
| closely matches the desired DL/UL percentages. |
| |
| Args: |
| bw: the bandwidth for the which the RB configuration is requested |
| tm: the transmission in which the base station will be operating |
| dl: desired percentage of downlink RBs |
| ul: desired percentage of uplink RBs |
| Returns: |
| a tuple indicating the number of downlink and uplink RBs |
| """ |
| |
| # Validate the arguments |
| if (not 0 <= dl <= 100) or (not 0 <= ul <= 100): |
| raise ValueError("The percentage of DL and UL RBs have to be two " |
| "positive between 0 and 100.") |
| |
| # Get min and max values from tables |
| max_rbs = self.total_rbs_dictionary[bw] |
| min_dl_rbs = self.min_dl_rbs_dictionary[bw] |
| min_ul_rbs = self.min_ul_rbs_dictionary[bw] |
| |
| def percentage_to_amount(min_val, max_val, percentage): |
| """ Returns the integer between min_val and max_val that is closest |
| to percentage/100*max_val |
| """ |
| |
| # Calculate the value that corresponds to the required percentage. |
| closest_int = round(max_val * percentage / 100) |
| # Cannot be less than min_val |
| closest_int = max(closest_int, min_val) |
| # RBs cannot be more than max_rbs |
| closest_int = min(closest_int, max_val) |
| |
| return closest_int |
| |
| # Calculate the number of DL RBs |
| |
| # Get the number of DL RBs that corresponds to |
| # the required percentage. |
| desired_dl_rbs = percentage_to_amount(min_val=min_dl_rbs, |
| max_val=max_rbs, |
| percentage=dl) |
| |
| if tm == TransmissionMode.TM3 or tm == TransmissionMode.TM4: |
| |
| # For TM3 and TM4 the number of DL RBs needs to be max_rbs or a |
| # multiple of the RBG size |
| |
| if desired_dl_rbs == max_rbs: |
| dl_rbs = max_rbs |
| else: |
| dl_rbs = (math.ceil(desired_dl_rbs / self.rbg_dictionary[bw]) * |
| self.rbg_dictionary[bw]) |
| |
| else: |
| # The other TMs allow any number of RBs between 1 and max_rbs |
| dl_rbs = desired_dl_rbs |
| |
| # Calculate the number of UL RBs |
| |
| # Get the number of UL RBs that corresponds |
| # to the required percentage |
| desired_ul_rbs = percentage_to_amount(min_val=min_ul_rbs, |
| max_val=max_rbs, |
| percentage=ul) |
| |
| # Create a list of all possible UL RBs assignment |
| # The standard allows any number that can be written as |
| # 2**a * 3**b * 5**c for any combination of a, b and c. |
| |
| def pow_range(max_value, base): |
| """ Returns a range of all possible powers of base under |
| the given max_value. |
| """ |
| return range(int(math.ceil(math.log(max_value, base)))) |
| |
| possible_ul_rbs = [ |
| 2**a * 3**b * 5**c for a in pow_range(max_rbs, 2) |
| for b in pow_range(max_rbs, 3) |
| for c in pow_range(max_rbs, 5) |
| if 2**a * 3**b * 5**c <= max_rbs] # yapf: disable |
| |
| # Find the value in the list that is closest to desired_ul_rbs |
| differences = [abs(rbs - desired_ul_rbs) for rbs in possible_ul_rbs] |
| ul_rbs = possible_ul_rbs[differences.index(min(differences))] |
| |
| # Report what are the obtained RB percentages |
| self.log.info("Requested a {}% / {}% RB allocation. Closest possible " |
| "percentages are {}% / {}%.".format( |
| dl, ul, round(100 * dl_rbs / max_rbs), |
| round(100 * ul_rbs / max_rbs))) |
| |
| return dl_rbs, ul_rbs |
| |
| def calibrate(self, band): |
| """ Calculates UL and DL path loss if it wasn't done before |
| |
| Before running the base class implementation, configure the base station |
| to only use one downlink antenna with maximum bandwidth. |
| |
| Args: |
| band: the band that is currently being calibrated. |
| """ |
| |
| # Save initial values in a configuration object so they can be restored |
| restore_config = self.BtsConfig() |
| restore_config.mimo_mode = self.primary_config.mimo_mode |
| restore_config.transmission_mode = self.primary_config.transmission_mode |
| restore_config.bandwidth = self.primary_config.bandwidth |
| |
| # Set up a temporary calibration configuration. |
| temporary_config = self.BtsConfig() |
| temporary_config.mimo_mode = MimoMode.MIMO_1x1 |
| temporary_config.transmission_mode = TransmissionMode.TM1 |
| temporary_config.bandwidth = max( |
| self.allowed_bandwidth_dictionary[int(band)]) |
| self.simulator.configure_bts(temporary_config) |
| self.primary_config.incorporate(temporary_config) |
| |
| super().calibrate(band) |
| |
| # Restore values as they were before changing them for calibration. |
| self.simulator.configure_bts(restore_config) |
| self.primary_config.incorporate(restore_config) |
| |
| def start_traffic_for_calibration(self): |
| """ |
| If TBS pattern is set to full allocation, there is no need to start |
| IP traffic. |
| """ |
| if not self.primary_config.tbs_pattern_on: |
| super().start_traffic_for_calibration() |
| |
| def stop_traffic_for_calibration(self): |
| """ |
| If TBS pattern is set to full allocation, IP traffic wasn't started |
| """ |
| if not self.primary_config.tbs_pattern_on: |
| super().stop_traffic_for_calibration() |
| |
| def get_duplex_mode(self, band): |
| """ Determines if the band uses FDD or TDD duplex mode |
| |
| Args: |
| band: a band number |
| Returns: |
| an variable of class DuplexMode indicating if band is FDD or TDD |
| """ |
| |
| if 33 <= int(band) <= 46: |
| return DuplexMode.TDD |
| else: |
| return DuplexMode.FDD |
| |
| def get_measured_ul_power(self, samples=5, wait_after_sample=3): |
| """ Calculates UL power using measurements from the callbox and the |
| calibration data. |
| |
| Args: |
| samples: the numble of samples to average |
| wait_after_sample: time in seconds to wait in between samples |
| |
| Returns: |
| the ul power at the UE antenna ports in dBs |
| """ |
| ul_power_sum = 0 |
| samples_left = samples |
| |
| while samples_left > 0: |
| ul_power_sum += self.simulator.get_measured_pusch_power() |
| samples_left -= 1 |
| time.sleep(wait_after_sample) |
| |
| # Got enough samples, return calibrated average |
| if self.dl_path_loss: |
| return ul_power_sum / samples + self.ul_path_loss |
| else: |
| self.log.warning('No uplink calibration data. Returning ' |
| 'uncalibrated values as measured by the ' |
| 'callbox.') |
| return ul_power_sum / samples |
| |
| def send_sms(self, sms_message): |
| """ Sets the SMS message for the simulation. """ |
| self.simulator.send_sms(sms_message) |
