Google Git
Sign in
android / platform / tools / test / connectivity / 5c2daa1cea2c15a214d40035f98527f861b5bdcf / . / acts_tests / acts_contrib / test_utils / tel / anritsu_utils.py
blob: 2e04dacb1105908f43f8ba94a9dafeb3e9e08f81 [file] [log] [blame]
#!/usr/bin/env python3
#
# Copyright 2016 - The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import time
from queue import Empty
from datetime import datetime
from acts.controllers.anritsu_lib import band_constants
from acts.controllers.anritsu_lib._anritsu_utils import AnritsuUtils
from acts.controllers.anritsu_lib.md8475a import BtsNumber
from acts.controllers.anritsu_lib.md8475a import BtsNwNameEnable
from acts.controllers.anritsu_lib.md8475a import BtsServiceState
from acts.controllers.anritsu_lib.md8475a import BtsTechnology
from acts.controllers.anritsu_lib.md8475a import CsfbType
from acts.controllers.anritsu_lib.md8475a import ImsCscfCall
from acts.controllers.anritsu_lib.md8475a import ImsCscfStatus
from acts.controllers.anritsu_lib.md8475a import MD8475A
from acts.controllers.anritsu_lib.md8475a import ReturnToEUTRAN
from acts.controllers.anritsu_lib.md8475a import VirtualPhoneStatus
from acts.controllers.anritsu_lib.md8475a import TestProcedure
from acts.controllers.anritsu_lib.md8475a import TestPowerControl
from acts.controllers.anritsu_lib.md8475a import TestMeasurement
from acts.controllers.anritsu_lib.md8475a import Switch
from acts.controllers.anritsu_lib.md8475a import BtsPacketRate
from acts_contrib.test_utils.tel.tel_defines import CALL_TEARDOWN_PHONE
from acts_contrib.test_utils.tel.tel_defines import CALL_TEARDOWN_REMOTE
from acts_contrib.test_utils.tel.tel_defines import MAX_WAIT_TIME_CALL_DROP
from acts_contrib.test_utils.tel.tel_defines import RAT_1XRTT
from acts_contrib.test_utils.tel.tel_defines import WAIT_TIME_IN_CALL
from acts_contrib.test_utils.tel.tel_defines import WAIT_TIME_IN_CALL_LONG
from acts_contrib.test_utils.tel.tel_defines import WAIT_TIME_IN_CALL_FOR_IMS
from acts_contrib.test_utils.tel.tel_defines import EventCmasReceived
from acts_contrib.test_utils.tel.tel_defines import EventEtwsReceived
from acts_contrib.test_utils.tel.tel_defines import EventSmsDeliverSuccess
from acts_contrib.test_utils.tel.tel_defines import EventSmsSentSuccess
from acts_contrib.test_utils.tel.tel_defines import EventSmsReceived
from acts_contrib.test_utils.tel.tel_phone_setup_utils import ensure_phone_idle
from acts_contrib.test_utils.tel.tel_phone_setup_utils import wait_for_droid_not_in_call
from acts_contrib.test_utils.tel.tel_voice_utils import hangup_call
from acts_contrib.test_utils.tel.tel_voice_utils import initiate_call
from acts_contrib.test_utils.tel.tel_voice_utils import wait_and_answer_call
# Timers
# Time to wait after registration before sending a command to Anritsu
# to ensure the phone has sufficient time to reconfigure based on new
# network in Anritsu
WAIT_TIME_ANRITSU_REG_AND_OPER = 10
# Time to wait after registration to ensure the phone
# has sufficient time to reconfigure based on new network in Anritsu
WAIT_TIME_ANRITSU_REG_AND_CALL = 10
# Max time to wait for Anritsu's virtual phone state change
MAX_WAIT_TIME_VIRTUAL_PHONE_STATE = 45
# Time to wait for Anritsu's IMS CSCF state change
MAX_WAIT_TIME_IMS_CSCF_STATE = 30
# Time to wait for before aSRVCC
WAIT_TIME_IN_ALERT = 5
# SIM card names
P0250Ax = "P0250Ax"
VzW12349 = "VzW12349"
P0135Ax = "P0135Ax"
FiTMO = "FiTMO"
FiSPR = "FiSPR"
FiUSCC = "FiUSCC"
# Test PLMN information
TEST_PLMN_LTE_NAME = "MD8475A_LTE"
TEST_PLMN_WCDMA_NAME = "MD8475A_WCDMA"
TEST_PLMN_GSM_NAME = "MD8475A_GSM"
TEST_PLMN_1X_NAME = "MD8475A_1X"
TEST_PLMN_1_MCC = "001"
TEST_PLMN_1_MNC = "01"
DEFAULT_MCC = "310"
DEFAULT_MNC = "260"
DEFAULT_RAC = 1
DEFAULT_LAC = 1
VzW_MCC = "311"
VzW_MNC = "480"
TMO_MCC = "310"
TMO_MNC = "260"
Fi_TMO_MCC = "310"
Fi_TMO_MNC = "260"
Fi_SPR_MCC = "310"
Fi_SPR_MNC = "120"
Fi_USCC_MCC = "311"
Fi_USCC_MNC = "580"
# IP address information for internet sharing
#GATEWAY_IPV4_ADDR = "192.168.137.1"
#UE_IPV4_ADDR_1 = "192.168.137.2"
#UE_IPV4_ADDR_2 = "192.168.137.3"
#UE_IPV4_ADDR_3 = "192.168.137.4"
#DNS_IPV4_ADDR = "192.168.137.1"
#CSCF_IPV4_ADDR = "192.168.137.1"
# Default IP address in Smart Studio, work for Internet Sharing with and
# without WLAN ePDG server. Remember to add 192.168.1.2 to Ethernet 0
# on MD8475A after turn on Windows' Internet Coonection Sharing
GATEWAY_IPV4_ADDR = "192.168.1.2"
UE_IPV4_ADDR_1 = "192.168.1.1"
UE_IPV4_ADDR_2 = "192.168.1.11"
UE_IPV4_ADDR_3 = "192.168.1.21"
UE_IPV6_ADDR_1 = "2001:0:0:1::1"
UE_IPV6_ADDR_2 = "2001:0:0:2::1"
UE_IPV6_ADDR_3 = "2001:0:0:3::1"
DNS_IPV4_ADDR = "192.168.1.12"
CSCF_IPV4_ADDR = "192.168.1.2"
CSCF_IPV6_ADDR = "2001:0:0:1::2"
CSCF_IPV6_ADDR_2 = "2001:0:0:2::2"
CSCF_IPV6_ADDR_3 = "2001:0:0:3::2"
# Google Fi IP Config:
Fi_GATEWAY_IPV4_ADDR_Data = "100.107.235.94"
Fi_GATEWAY_IPV6_ADDR_Data = "fe80::aef2:c5ff:fe71:4b9"
Fi_GATEWAY_IPV4_ADDR_IMS_911 = "192.168.1.2"
Fi_GATEWAY_IPV6_ADDR_IMS_911 = "2001:0:0:1::2"
Fi_UE_IPV4_ADDR_Data = "100.107.235.81"
Fi_UE_IPV4_ADDR_IMS = "192.168.1.1"
Fi_UE_IPV4_ADDR_911 = "192.168.1.11"
Fi_UE_IPV6_ADDR_Data = "2620::1000:1551:1140:c0f9:d6a8:44eb"
Fi_UE_IPV6_ADDR_IMS = "2001:0:0:1::1"
Fi_UE_IPV6_ADDR_911 = "2001:0:0:2::1"
Fi_DNS_IPV4_ADDR_Pri = "8.8.8.8"
Fi_DNS_IPV4_ADDR_Sec = "8.8.8.4"
Fi_DNS_IPV6_ADDR = "2001:4860:4860::8888"
Fi_CSCF_IPV4_ADDR_Data = "192.168.1.2"
Fi_CSCF_IPV6_ADDR_Data = "2001:0:0:1::2"
Fi_CSCF_IPV4_ADDR_IMS = "192.168.1.2"
Fi_CSCF_IPV6_ADDR_IMS = "2001:0:0:1::3"
Fi_CSCF_IPV4_ADDR_911 = "192.168.1.12"
Fi_CSCF_IPV6_ADDR_911 = "2001:0:0:2::2"
# Default Cell Parameters
DEFAULT_OUTPUT_LEVEL = -30
DEFAULT_1X_OUTPUT_LEVEL = -35
DEFAULT_INPUT_LEVEL = 0
DEFAULT_LTE_BAND = [2, 4]
Fi_LTE_TMO_BAND = [4]
Fi_LTE_SPR_BAND = [25]
Fi_LTE_USCC_BAND = [12]
Fi_GSM_TMO_BAND = band_constants.GSM_BAND_PGSM900
DEFAULT_WCDMA_BAND = 1
DEFAULT_WCDMA_PACKET_RATE = BtsPacketRate.WCDMA_DLHSAUTO_REL7_ULHSAUTO
DEFAULT_GSM_BAND = band_constants.GSM_BAND_GSM850
#Google Fi CDMA Bands
Fi_USCC1X_MCC = 209
Fi_USCC1X_BAND = 1
Fi_USCC1X_CH = 600
Fi_USCC1X_SID = 5
Fi_USCC1X_NID = 21
Fi_SPR1X_MCC = 320
Fi_SPR1X_BAND = 1
Fi_SPR1X_CH = 600
Fi_SPR1X_SID = 4183
Fi_SPR1X_NID = 233
Fi_EVDO_BAND = 1
Fi_EVDO_CH = 625
Fi_EVDO_SECTOR_ID = "00000000,00000000,00000000,00000000"
DEFAULT_CDMA1X_BAND = 0
DEFAULT_CDMA1X_CH = 356
DEFAULT_CDMA1X_SID = 0
DEFAULT_CDMA1X_NID = 65535
DEFAULT_EVDO_BAND = 0
DEFAULT_EVDO_CH = 356
DEFAULT_EVDO_SECTOR_ID = "00000000,00000000,00000000,00000000"
VzW_CDMA1x_BAND = 1
VzW_CDMA1x_CH = 150
VzW_CDMA1X_SID = 26
VzW_CDMA1X_NID = 65535
VzW_EVDO_BAND = 0
VzW_EVDO_CH = 384
VzW_EVDO_SECTOR_ID = "12345678,00000000,00000000,00000000"
DEFAULT_T_MODE = "TM1"
DEFAULT_DL_ANTENNA = 1
# CMAS Message IDs
CMAS_MESSAGE_PRESIDENTIAL_ALERT = hex(0x1112)
CMAS_MESSAGE_EXTREME_IMMEDIATE_OBSERVED = hex(0x1113)
CMAS_MESSAGE_EXTREME_IMMEDIATE_LIKELY = hex(0x1114)
CMAS_MESSAGE_EXTREME_EXPECTED_OBSERVED = hex(0x1115)
CMAS_MESSAGE_EXTREME_EXPECTED_LIKELY = hex(0x1116)
CMAS_MESSAGE_SEVERE_IMMEDIATE_OBSERVED = hex(0x1117)
CMAS_MESSAGE_SEVERE_IMMEDIATE_LIKELY = hex(0x1118)
CMAS_MESSAGE_SEVERE_EXPECTED_OBSERVED = hex(0x1119)
CMAS_MESSAGE_SEVERE_EXPECTED_LIKELY = hex(0x111A)
CMAS_MESSAGE_CHILD_ABDUCTION_EMERGENCY = hex(0x111B)
CMAS_MESSAGE_MONTHLY_TEST = hex(0x111C)
CMAS_MESSAGE_CMAS_EXECERCISE = hex(0x111D)
# ETWS Message IDs
ETWS_WARNING_EARTHQUAKE = hex(0x1100)
ETWS_WARNING_TSUNAMI = hex(0x1101)
ETWS_WARNING_EARTHQUAKETSUNAMI = hex(0x1102)
ETWS_WARNING_TEST_MESSAGE = hex(0x1103)
ETWS_WARNING_OTHER_EMERGENCY = hex(0x1104)
# C2K CMAS Message Constants
CMAS_C2K_CATEGORY_PRESIDENTIAL = "Presidential"
CMAS_C2K_CATEGORY_EXTREME = "Extreme"
CMAS_C2K_CATEGORY_SEVERE = "Severe"
CMAS_C2K_CATEGORY_AMBER = "AMBER"
CMAS_C2K_CATEGORY_CMASTEST = "CMASTest"
CMAS_C2K_PRIORITY_NORMAL = "Normal"
CMAS_C2K_PRIORITY_INTERACTIVE = "Interactive"
CMAS_C2K_PRIORITY_URGENT = "Urgent"
CMAS_C2K_PRIORITY_EMERGENCY = "Emergency"
CMAS_C2K_RESPONSETYPE_SHELTER = "Shelter"
CMAS_C2K_RESPONSETYPE_EVACUATE = "Evacuate"
CMAS_C2K_RESPONSETYPE_PREPARE = "Prepare"
CMAS_C2K_RESPONSETYPE_EXECUTE = "Execute"
CMAS_C2K_RESPONSETYPE_MONITOR = "Monitor"
CMAS_C2K_RESPONSETYPE_AVOID = "Avoid"
CMAS_C2K_RESPONSETYPE_ASSESS = "Assess"
CMAS_C2K_RESPONSETYPE_NONE = "None"
CMAS_C2K_SEVERITY_EXTREME = "Extreme"
CMAS_C2K_SEVERITY_SEVERE = "Severe"
CMAS_C2K_URGENCY_IMMEDIATE = "Immediate"
CMAS_C2K_URGENCY_EXPECTED = "Expected"
CMAS_C2K_CERTIANTY_OBSERVED = "Observed"
CMAS_C2K_CERTIANTY_LIKELY = "Likely"
#PDN Numbers
PDN_NO_1 = 1
PDN_NO_2 = 2
PDN_NO_3 = 3
PDN_NO_4 = 4
PDN_NO_5 = 5
# IMS Services parameters
DEFAULT_VNID = 1
NDP_NIC_NAME = '"Intel(R) 82577LM Gigabit Network Connection"'
CSCF_Monitoring_UA_URI = '"sip:+11234567890@test.3gpp.com"'
TMO_CSCF_Monitoring_UA_URI = '"sip:001010123456789@msg.lab.t-mobile.com"'
CSCF_Virtual_UA_URI = '"sip:+11234567891@test.3gpp.com"'
TMO_CSCF_Virtual_UA_URI = '"sip:0123456789@ims.mnc01.mcc001.3gppnetwork.org"'
CSCF_HOSTNAME = '"ims.mnc01.mcc001.3gppnetwork.org"'
TMO_USERLIST_NAME = "310260123456789@msg.lab.t-mobile.com"
VZW_USERLIST_NAME = "001010123456789@test.3gpp.com"
# Google Fi IMS Services parameters
Fi_CSCF_Monitoring_UA_URI = '"sip:310260971239432@ims.mnc260.mcc310.3gppnetwork.org"'
Fi_CSCF_Virtual_UA_URI = '"sip:0123456789@msg.pc.t-mobile.com"'
Fi_CSCF_HOSTNAME = '"ims.mnc260.mcc310.3gppnetwork.org"'
Fi_USERLIST_NAME = "310260971239432@msg.pc.t-mobile.com"
#Cell Numbers
CELL_1 = 1
CELL_2 = 2
# default ims virtual network id for Anritsu ims call test.
DEFAULT_IMS_VIRTUAL_NETWORK_ID = 1
def cb_serial_number():
""" CMAS/ETWS serial number generator """
i = 0x3000
while True:
yield i
i += 1
def set_usim_parameters(anritsu_handle, sim_card):
""" set USIM parameters in MD8475A simulationn parameter
Args:
anritsu_handle: anritusu device object.
sim_card : "P0250Ax" or "12349"
Returns:
None
"""
if sim_card == P0250Ax:
anritsu_handle.usim_key = "000102030405060708090A0B0C0D0E0F"
elif sim_card == P0135Ax:
anritsu_handle.usim_key = "00112233445566778899AABBCCDDEEFF"
elif sim_card == VzW12349:
anritsu_handle.usim_key = "465B5CE8B199B49FAA5F0A2EE238A6BC"
anritsu_handle.send_command("IMSI 311480012345678")
anritsu_handle.send_command("SECURITY3G MILENAGE")
anritsu_handle.send_command(
"MILENAGEOP 5F1D289C5D354D0A140C2548F5F3E3BA")
elif sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
anritsu_handle.usim_key = "000102030405060708090A0B0C0D0E0F"
def save_anritsu_log_files(anritsu_handle, test_name, user_params):
""" saves the anritsu smart studio log files
The logs should be saved in Anritsu system. Need to provide
log folder path in Anritsu system
Args:
anritsu_handle: anritusu device object.
test_name: test case name
user_params : user supplied parameters list
Returns:
None
"""
md8475a_log_folder = user_params["anritsu_log_file_path"]
file_name = getfilenamewithtimestamp(test_name)
seq_logfile = "{}\\{}_seq.csv".format(md8475a_log_folder, file_name)
msg_logfile = "{}\\{}_msg.csv".format(md8475a_log_folder, file_name)
trace_logfile = "{}\\{}_trace.lgex".format(md8475a_log_folder, file_name)
anritsu_handle.save_sequence_log(seq_logfile)
anritsu_handle.save_message_log(msg_logfile)
anritsu_handle.save_trace_log(trace_logfile, "BINARY", 1, 0, 0)
anritsu_handle.clear_sequence_log()
anritsu_handle.clear_message_log()
def getfilenamewithtimestamp(test_name):
""" Gets the test name appended with current time
Args:
test_name : test case name
Returns:
string of test name appended with current time
"""
time_stamp = datetime.now().strftime("%m-%d-%Y_%H-%M-%S")
return "{}_{}".format(test_name, time_stamp)
def _init_lte_bts(bts, user_params, cell_no, sim_card):
""" initializes the LTE BTS
All BTS parameters should be set here
Args:
bts: BTS object.
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
None
"""
bts.nw_fullname_enable = BtsNwNameEnable.NAME_ENABLE
bts.nw_fullname = TEST_PLMN_LTE_NAME
bts.mcc = get_lte_mcc(user_params, cell_no, sim_card)
bts.mnc = get_lte_mnc(user_params, cell_no, sim_card)
bts.band = get_lte_band(user_params, cell_no, sim_card)
bts.transmode = get_transmission_mode(user_params, cell_no)
bts.dl_antenna = get_dl_antenna(user_params, cell_no)
bts.output_level = DEFAULT_OUTPUT_LEVEL
bts.input_level = DEFAULT_INPUT_LEVEL
def _init_wcdma_bts(bts, user_params, cell_no, sim_card):
""" initializes the WCDMA BTS
All BTS parameters should be set here
Args:
bts: BTS object.
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
None
"""
bts.nw_fullname_enable = BtsNwNameEnable.NAME_ENABLE
bts.nw_fullname = TEST_PLMN_WCDMA_NAME
bts.mcc = get_wcdma_mcc(user_params, cell_no, sim_card)
bts.mnc = get_wcdma_mnc(user_params, cell_no, sim_card)
bts.band = get_wcdma_band(user_params, cell_no)
bts.rac = get_wcdma_rac(user_params, cell_no)
bts.lac = get_wcdma_lac(user_params, cell_no)
bts.output_level = DEFAULT_OUTPUT_LEVEL
bts.input_level = DEFAULT_INPUT_LEVEL
bts.packet_rate = DEFAULT_WCDMA_PACKET_RATE
def _init_gsm_bts(bts, user_params, cell_no, sim_card):
""" initializes the GSM BTS
All BTS parameters should be set here
Args:
bts: BTS object.
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
None
"""
bts.nw_fullname_enable = BtsNwNameEnable.NAME_ENABLE
bts.nw_fullname = TEST_PLMN_GSM_NAME
bts.mcc = get_gsm_mcc(user_params, cell_no, sim_card)
bts.mnc = get_gsm_mnc(user_params, cell_no, sim_card)
bts.band = get_gsm_band(user_params, cell_no, sim_card)
bts.rac = get_gsm_rac(user_params, cell_no)
bts.lac = get_gsm_lac(user_params, cell_no)
bts.output_level = DEFAULT_OUTPUT_LEVEL
bts.input_level = DEFAULT_INPUT_LEVEL
def _init_1x_bts(bts, user_params, cell_no, sim_card):
""" initializes the 1X BTS
All BTS parameters should be set here
Args:
bts: BTS object.
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
None
"""
bts.sector1_mcc = get_1x_mcc(user_params, cell_no, sim_card)
bts.band = get_1x_band(user_params, cell_no, sim_card)
bts.dl_channel = get_1x_channel(user_params, cell_no, sim_card)
bts.sector1_sid = get_1x_sid(user_params, cell_no, sim_card)
bts.sector1_nid = get_1x_nid(user_params, cell_no, sim_card)
bts.output_level = DEFAULT_1X_OUTPUT_LEVEL
def _init_evdo_bts(bts, user_params, cell_no, sim_card):
""" initializes the EVDO BTS
All BTS parameters should be set here
Args:
bts: BTS object.
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
None
"""
bts.band = get_evdo_band(user_params, cell_no, sim_card)
bts.dl_channel = get_evdo_channel(user_params, cell_no, sim_card)
bts.evdo_sid = get_evdo_sid(user_params, cell_no, sim_card)
bts.output_level = DEFAULT_1X_OUTPUT_LEVEL
def _init_PDN(anritsu_handle,
sim_card,
pdn,
ipv4,
ipv6,
ims_binding,
vnid_number=DEFAULT_VNID):
""" initializes the PDN parameters
All PDN parameters should be set here
Args:
anritsu_handle: anritusu device object.
pdn: pdn object
ip_address : UE IP address
ims_binding: to bind with IMS VNID(1) or not
Returns:
None
"""
# Setting IP address for internet connection sharing
# Google Fi _init_PDN
if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
pdn.ue_address_ipv4 = ipv4
pdn.ue_address_ipv6 = ipv6
if ims_binding:
pdn.pdn_ims = Switch.ENABLE
pdn.pdn_vnid = vnid_number
pdn.pdn_DG_selection = 'USER'
pdn.pdn_gateway_ipv4addr = Fi_GATEWAY_IPV4_ADDR_IMS_911
pdn.pdn_gateway_ipv6addr = Fi_GATEWAY_IPV6_ADDR_IMS_911
else:
anritsu_handle.gateway_ipv4addr = Fi_GATEWAY_IPV4_ADDR_Data
anritsu_handle.gateway_ipv6addr = Fi_GATEWAY_IPV6_ADDR_Data
pdn.primary_dns_address_ipv4 = Fi_DNS_IPV4_ADDR_Pri
pdn.secondary_dns_address_ipv4 = Fi_DNS_IPV4_ADDR_Sec
pdn.dns_address_ipv6 = Fi_DNS_IPV6_ADDR
pdn.cscf_address_ipv4 = Fi_CSCF_IPV4_ADDR_Data
pdn.cscf_address_ipv6 = Fi_CSCF_IPV6_ADDR_Data
# Pixel Lab _init_PDN_
else:
anritsu_handle.gateway_ipv4addr = GATEWAY_IPV4_ADDR
pdn.ue_address_ipv4 = ipv4
pdn.ue_address_ipv6 = ipv6
if ims_binding:
pdn.pdn_ims = Switch.ENABLE
pdn.pdn_vnid = vnid_number
else:
pdn.primary_dns_address_ipv4 = DNS_IPV4_ADDR
pdn.secondary_dns_address_ipv4 = DNS_IPV4_ADDR
pdn.cscf_address_ipv4 = CSCF_IPV4_ADDR
def _init_IMS(anritsu_handle,
vnid,
sim_card=None,
ipv4_address=CSCF_IPV4_ADDR,
ipv6_address=CSCF_IPV6_ADDR,
ip_type="IPV4V6",
auth=False):
""" initializes the IMS VNID parameters
All IMS parameters should be set here
Args:
anritsu_handle: anritusu device object.
vnid: IMS Services object
Returns:
None
"""
# vnid.sync = Switch.ENABLE # supported in 6.40a release
if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
vnid.cscf_address_ipv4 = ipv4_address
vnid.cscf_address_ipv6 = ipv6_address
vnid.imscscf_iptype = ip_type
vnid.dns = Switch.DISABLE
vnid.ndp_nic = NDP_NIC_NAME
vnid.ndp_prefix = ipv6_address
if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
vnid.cscf_monitoring_ua = Fi_CSCF_Monitoring_UA_URI
vnid.cscf_virtual_ua = Fi_CSCF_Virtual_UA_URI
vnid.cscf_host_name = Fi_CSCF_HOSTNAME
vnid.cscf_ims_authentication = "ENABLE"
if auth:
vnid.cscf_ims_authentication = "ENABLE"
vnid.fi_cscf_userslist_add = Fi_USERLIST_NAME
else:
vnid.cscf_monitoring_ua = CSCF_Monitoring_UA_URI
vnid.psap = Switch.ENABLE
vnid.psap_auto_answer = Switch.ENABLE
else:
vnid.cscf_address_ipv4 = CSCF_IPV4_ADDR
vnid.cscf_address_ipv6 = ipv6_address
vnid.imscscf_iptype = ip_type
vnid.dns = Switch.DISABLE
vnid.ndp_nic = NDP_NIC_NAME
vnid.ndp_prefix = ipv6_address
if sim_card == P0135Ax:
vnid.cscf_monitoring_ua = TMO_CSCF_Monitoring_UA_URI
vnid.cscf_virtual_ua = TMO_CSCF_Virtual_UA_URI
vnid.cscf_host_name = CSCF_HOSTNAME
vnid.cscf_precondition = "ENABLE"
vnid.cscf_ims_authentication = "DISABLE"
if auth:
vnid.cscf_ims_authentication = "ENABLE"
vnid.tmo_cscf_userslist_add = TMO_USERLIST_NAME
elif sim_card == VzW12349:
vnid.cscf_monitoring_ua = CSCF_Monitoring_UA_URI
vnid.cscf_virtual_ua = CSCF_Virtual_UA_URI
vnid.cscf_ims_authentication = "DISABLE"
if auth:
vnid.cscf_ims_authentication = "ENABLE"
vnid.vzw_cscf_userslist_add = VZW_USERLIST_NAME
else:
vnid.cscf_monitoring_ua = CSCF_Monitoring_UA_URI
vnid.psap = Switch.ENABLE
vnid.psap_auto_answer = Switch.ENABLE
def set_system_model_lte_lte(anritsu_handle, user_params, sim_card):
""" Configures Anritsu system for LTE and LTE simulation
Args:
anritsu_handle: anritusu device object.
user_params: pointer to user supplied parameters
Returns:
Lte and Wcdma BTS objects
"""
anritsu_handle.set_simulation_model(BtsTechnology.LTE,
BtsTechnology.LTE)
# setting BTS parameters
lte1_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
lte2_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
_init_lte_bts(lte1_bts, user_params, CELL_1, sim_card)
_init_lte_bts(lte2_bts, user_params, CELL_2, sim_card)
if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
pdn4 = anritsu_handle.get_PDN(PDN_NO_4)
pdn5 = anritsu_handle.get_PDN(PDN_NO_5)
# Initialize PDN IP address for internet connection sharing
_init_PDN(anritsu_handle, sim_card, pdn1, Fi_UE_IPV4_ADDR_Data,
Fi_UE_IPV6_ADDR_Data, False)
_init_PDN(anritsu_handle, sim_card, pdn2, Fi_UE_IPV4_ADDR_Data,
Fi_UE_IPV6_ADDR_Data, False)
_init_PDN(anritsu_handle, sim_card, pdn3, Fi_UE_IPV4_ADDR_Data,
Fi_UE_IPV6_ADDR_Data, False)
_init_PDN(anritsu_handle, sim_card, pdn4, Fi_UE_IPV4_ADDR_IMS,
Fi_UE_IPV6_ADDR_IMS,
True)
_init_PDN(anritsu_handle, sim_card, pdn5, Fi_UE_IPV4_ADDR_911,
Fi_UE_IPV6_ADDR_911,
True)
vnid1 = anritsu_handle.get_IMS(1)
vnid2 = anritsu_handle.get_IMS(2)
# _init_IMS(
# anritsu_handle,
# vnid1,
# sim_card,
# ipv4_address=CSCF_IPV4_ADDR,
# ipv6_address=CSCF_IPV6_ADDR,
# auth=False)
_init_IMS(
anritsu_handle,
vnid1,
sim_card,
ipv4_address=Fi_CSCF_IPV4_ADDR_IMS,
ipv6_address=Fi_CSCF_IPV6_ADDR_IMS,
auth=True)
_init_IMS(
anritsu_handle,
vnid2,
sim_card,
ipv4_address=Fi_CSCF_IPV4_ADDR_911,
ipv6_address=Fi_CSCF_IPV6_ADDR_911,
auth=False)
else:
_init_lte_bts(lte1_bts, user_params, CELL_1, sim_card)
_init_lte_bts(lte2_bts, user_params, CELL_2, sim_card)
pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
# Initialize PDN IP address for internet connection sharing
_init_PDN(anritsu_handle, sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, True)
_init_PDN(anritsu_handle, sim_card, pdn2, UE_IPV4_ADDR_2, UE_IPV6_ADDR_2, False)
_init_PDN(anritsu_handle, sim_card, pdn3, UE_IPV4_ADDR_3, UE_IPV6_ADDR_3, True)
vnid1 = anritsu_handle.get_IMS(DEFAULT_VNID)
if sim_card == P0135Ax:
vnid2 = anritsu_handle.get_IMS(2)
vnid3 = anritsu_handle.get_IMS(3)
_init_IMS(
anritsu_handle,
vnid1,
sim_card,
ipv6_address=CSCF_IPV6_ADDR,
auth=True)
_init_IMS(
anritsu_handle,
vnid2,
sim_card,
ipv6_address=CSCF_IPV6_ADDR_2,
ip_type="IPV6")
_init_IMS(
anritsu_handle,
vnid3,
sim_card,
ipv6_address=CSCF_IPV6_ADDR_3,
ip_type="IPV6")
elif sim_card == VzW12349:
_init_IMS(anritsu_handle, vnid1, sim_card, auth=True)
else:
_init_IMS(anritsu_handle, vnid1, sim_card)
return [lte1_bts, lte2_bts]
def set_system_model_wcdma_wcdma(anritsu_handle, user_params, sim_card):
""" Configures Anritsu system for WCDMA and WCDMA simulation
Args:
anritsu_handle: anritusu device object.
user_params: pointer to user supplied parameters
Returns:
Lte and Wcdma BTS objects
"""
anritsu_handle.set_simulation_model(BtsTechnology.WCDMA,
BtsTechnology.WCDMA)
# setting BTS parameters
wcdma1_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
wcdma2_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
_init_wcdma_bts(wcdma1_bts, user_params, CELL_1, sim_card)
_init_wcdma_bts(wcdma2_bts, user_params, CELL_2, sim_card)
pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
# Initialize PDN IP address for internet connection sharing
if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
_init_PDN(anritsu_handle, sim_card, pdn1, Fi_UE_IPV4_ADDR_Data, Fi_UE_IPV6_ADDR_Data,
False)
else:
_init_PDN(anritsu_handle, sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False)
return [wcdma1_bts, wcdma2_bts]
def set_system_model_lte_wcdma(anritsu_handle, user_params, sim_card):
""" Configures Anritsu system for LTE and WCDMA simulation
Args:
anritsu_handle: anritusu device object.
user_params: pointer to user supplied parameters
Returns:
Lte and Wcdma BTS objects
"""
anritsu_handle.set_simulation_model(BtsTechnology.LTE, BtsTechnology.WCDMA)
# setting BTS parameters
lte_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
wcdma_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
_init_lte_bts(lte_bts, user_params, CELL_1, sim_card)
_init_wcdma_bts(wcdma_bts, user_params, CELL_2, sim_card)
pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
# Initialize PDN IP address for internet connection sharing
if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
pdn4 = anritsu_handle.get_PDN(PDN_NO_4)
pdn5 = anritsu_handle.get_PDN(PDN_NO_5)
# Initialize PDN IP address.
_init_PDN(anritsu_handle, sim_card, pdn1, Fi_UE_IPV4_ADDR_Data,
Fi_UE_IPV6_ADDR_Data, False)
_init_PDN(anritsu_handle, sim_card, pdn2, Fi_UE_IPV4_ADDR_Data,
Fi_UE_IPV6_ADDR_Data, False)
_init_PDN(anritsu_handle, sim_card, pdn3, Fi_UE_IPV4_ADDR_Data,
Fi_UE_IPV6_ADDR_Data, False)
_init_PDN(anritsu_handle, sim_card, pdn4, Fi_UE_IPV4_ADDR_IMS,
Fi_UE_IPV6_ADDR_IMS,
True)
_init_PDN(anritsu_handle, sim_card, pdn5, Fi_UE_IPV4_ADDR_911,
Fi_UE_IPV6_ADDR_911,
True)
vnid1 = anritsu_handle.get_IMS(1)
vnid2 = anritsu_handle.get_IMS(2)
_init_IMS(
anritsu_handle,
vnid1,
sim_card,
ipv4_address=Fi_CSCF_IPV4_ADDR_IMS,
ipv6_address=Fi_CSCF_IPV6_ADDR_IMS,
auth=True)
_init_IMS(
anritsu_handle,
vnid2,
sim_card,
ipv4_address=Fi_CSCF_IPV4_ADDR_911,
ipv6_address=Fi_CSCF_IPV6_ADDR_911,
auth=False)
return [lte_bts, wcdma_bts]
else:
_init_PDN(anritsu_handle, sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, True)
_init_PDN(anritsu_handle, sim_card, pdn2, UE_IPV4_ADDR_2, UE_IPV6_ADDR_2, False)
_init_PDN(anritsu_handle, sim_card, pdn3, UE_IPV4_ADDR_3, UE_IPV6_ADDR_3, True)
vnid1 = anritsu_handle.get_IMS(DEFAULT_VNID)
if sim_card == P0135Ax:
vnid2 = anritsu_handle.get_IMS(2)
vnid3 = anritsu_handle.get_IMS(3)
_init_IMS(
anritsu_handle,
vnid1,
sim_card,
ipv6_address=CSCF_IPV6_ADDR,
auth=True)
_init_IMS(
anritsu_handle,
vnid2,
sim_card,
ipv6_address=CSCF_IPV6_ADDR_2,
ip_type="IPV6")
_init_IMS(
anritsu_handle,
vnid3,
sim_card,
ipv6_address=CSCF_IPV6_ADDR_3,
ip_type="IPV6")
elif sim_card == VzW12349:
_init_IMS(anritsu_handle, vnid1, sim_card, auth=True)
else:
_init_IMS(anritsu_handle, vnid1, sim_card)
return [lte_bts, wcdma_bts]
def set_system_model_lte_gsm(anritsu_handle, user_params, sim_card):
""" Configures Anritsu system for LTE and GSM simulation
Args:
anritsu_handle: anritusu device object.
user_params: pointer to user supplied parameters
Returns:
Lte and Wcdma BTS objects
"""
anritsu_handle.set_simulation_model(BtsTechnology.LTE, BtsTechnology.GSM)
# setting BTS parameters
lte_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
gsm_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
_init_lte_bts(lte_bts, user_params, CELL_1, sim_card)
_init_gsm_bts(gsm_bts, user_params, CELL_2, sim_card)
if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
pdn4 = anritsu_handle.get_PDN(PDN_NO_4)
pdn5 = anritsu_handle.get_PDN(PDN_NO_5)
# Initialize PDN IP address.
_init_PDN(anritsu_handle, sim_card, pdn1, Fi_UE_IPV4_ADDR_Data,
Fi_UE_IPV6_ADDR_Data, False)
_init_PDN(anritsu_handle, sim_card, pdn2, Fi_UE_IPV4_ADDR_Data,
Fi_UE_IPV6_ADDR_Data, False)
_init_PDN(anritsu_handle, sim_card, pdn3, Fi_UE_IPV4_ADDR_Data,
Fi_UE_IPV6_ADDR_Data, False)
_init_PDN(anritsu_handle, sim_card, pdn4, Fi_UE_IPV4_ADDR_IMS,
Fi_UE_IPV6_ADDR_IMS,
True)
_init_PDN(anritsu_handle, sim_card, pdn5, Fi_UE_IPV4_ADDR_911,
Fi_UE_IPV6_ADDR_911,
True)
vnid1 = anritsu_handle.get_IMS(1)
vnid2 = anritsu_handle.get_IMS(2)
_init_IMS(
anritsu_handle,
vnid1,
sim_card,
ipv4_address=Fi_CSCF_IPV4_ADDR_IMS,
ipv6_address=Fi_CSCF_IPV6_ADDR_IMS,
auth=True)
_init_IMS(
anritsu_handle,
vnid2,
sim_card,
ipv4_address=Fi_CSCF_IPV4_ADDR_911,
ipv6_address=Fi_CSCF_IPV6_ADDR_911,
auth=False)
return [lte_bts, gsm_bts]
else:
pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
# Initialize PDN IP address for internet connection sharing
_init_PDN(anritsu_handle, sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, True)
_init_PDN(anritsu_handle, sim_card, pdn2, UE_IPV4_ADDR_2, UE_IPV6_ADDR_2, False)
_init_PDN(anritsu_handle, sim_card, pdn3, UE_IPV4_ADDR_3, UE_IPV6_ADDR_3, True)
vnid1 = anritsu_handle.get_IMS(DEFAULT_VNID)
if sim_card == P0135Ax:
vnid2 = anritsu_handle.get_IMS(2)
vnid3 = anritsu_handle.get_IMS(3)
_init_IMS(
anritsu_handle,
vnid1,
sim_card,
ipv6_address=CSCF_IPV6_ADDR,
auth=True)
_init_IMS(
anritsu_handle,
vnid2,
sim_card,
ipv6_address=CSCF_IPV6_ADDR_2,
ip_type="IPV6")
_init_IMS(
anritsu_handle,
vnid3,
sim_card,
ipv6_address=CSCF_IPV6_ADDR_3,
ip_type="IPV6")
elif sim_card == VzW12349:
_init_IMS(anritsu_handle, vnid1, sim_card, auth=True)
else:
_init_IMS(anritsu_handle, vnid1, sim_card)
return [lte_bts, gsm_bts]
def set_system_model_lte_1x(anritsu_handle, user_params, sim_card):
""" Configures Anritsu system for LTE and 1x simulation
Args:
anritsu_handle: anritusu device object.
user_params: pointer to user supplied parameters
Returns:
Lte and 1x BTS objects
"""
anritsu_handle.set_simulation_model(BtsTechnology.LTE,
BtsTechnology.CDMA1X)
# setting BTS parameters
lte_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
cdma1x_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
_init_lte_bts(lte_bts, user_params, CELL_1, sim_card)
_init_1x_bts(cdma1x_bts, user_params, CELL_2, sim_card)
if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
pdn4 = anritsu_handle.get_PDN(PDN_NO_4)
pdn5 = anritsu_handle.get_PDN(PDN_NO_5)
# Initialize PDN IP address.
_init_PDN(anritsu_handle, sim_card, pdn1, Fi_UE_IPV4_ADDR_Data,
Fi_UE_IPV6_ADDR_Data, False)
_init_PDN(anritsu_handle, sim_card, pdn2, Fi_UE_IPV4_ADDR_Data,
Fi_UE_IPV6_ADDR_Data, False)
_init_PDN(anritsu_handle, sim_card, pdn3, Fi_UE_IPV4_ADDR_Data,
Fi_UE_IPV6_ADDR_Data, False)
_init_PDN(anritsu_handle, sim_card, pdn4, Fi_UE_IPV4_ADDR_IMS,
Fi_UE_IPV6_ADDR_IMS,
True)
_init_PDN(anritsu_handle, sim_card, pdn5, Fi_UE_IPV4_ADDR_911,
Fi_UE_IPV6_ADDR_911,
True)
vnid1 = anritsu_handle.get_IMS(1)
vnid2 = anritsu_handle.get_IMS(2)
_init_IMS(
anritsu_handle,
vnid1,
sim_card,
ipv4_address=Fi_CSCF_IPV4_ADDR_IMS,
ipv6_address=Fi_CSCF_IPV6_ADDR_IMS,
auth=True)
_init_IMS(
anritsu_handle,
vnid2,
sim_card,
ipv4_address=Fi_CSCF_IPV4_ADDR_911,
ipv6_address=Fi_CSCF_IPV6_ADDR_911,
auth=False)
return [lte_bts, cdma1x_bts]
else:
pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
# Initialize PDN IP address for internet connection sharing
_init_PDN(anritsu_handle, sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, True)
_init_PDN(anritsu_handle, sim_card, pdn2, UE_IPV4_ADDR_2, UE_IPV6_ADDR_2, False)
_init_PDN(anritsu_handle, sim_card, pdn3, UE_IPV4_ADDR_3, UE_IPV6_ADDR_3, True)
vnid1 = anritsu_handle.get_IMS(DEFAULT_VNID)
if sim_card == P0135Ax:
vnid2 = anritsu_handle.get_IMS(2)
vnid3 = anritsu_handle.get_IMS(3)
_init_IMS(
anritsu_handle,
vnid1,
sim_card,
ipv6_address=CSCF_IPV6_ADDR,
auth=True)
_init_IMS(
anritsu_handle,
vnid2,
sim_card,
ipv6_address=CSCF_IPV6_ADDR_2,
ip_type="IPV6")
_init_IMS(
anritsu_handle,
vnid3,
sim_card,
ipv6_address=CSCF_IPV6_ADDR_3,
ip_type="IPV6")
elif sim_card == VzW12349:
_init_IMS(anritsu_handle, vnid1, sim_card, auth=True)
else:
_init_IMS(anritsu_handle, vnid1, sim_card)
return [lte_bts, cdma1x_bts]
def set_system_model_lte_evdo(anritsu_handle, user_params, sim_card):
""" Configures Anritsu system for LTE and EVDO simulation
Args:
anritsu_handle: anritusu device object.
user_params: pointer to user supplied parameters
Returns:
Lte and 1x BTS objects
"""
anritsu_handle.set_simulation_model(BtsTechnology.LTE, BtsTechnology.EVDO)
# setting BTS parameters
lte_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
evdo_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
_init_lte_bts(lte_bts, user_params, CELL_1, sim_card)
_init_evdo_bts(evdo_bts, user_params, CELL_2, sim_card)
if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
pdn4 = anritsu_handle.get_PDN(PDN_NO_4)
pdn5 = anritsu_handle.get_PDN(PDN_NO_5)
# Initialize PDN IP address.
_init_PDN(anritsu_handle, sim_card, pdn1, Fi_UE_IPV4_ADDR_Data,
Fi_UE_IPV6_ADDR_Data, False)
_init_PDN(anritsu_handle, sim_card, pdn2, Fi_UE_IPV4_ADDR_Data,
Fi_UE_IPV6_ADDR_Data, False)
_init_PDN(anritsu_handle, sim_card, pdn3, Fi_UE_IPV4_ADDR_Data,
Fi_UE_IPV6_ADDR_Data, False)
_init_PDN(anritsu_handle, sim_card, pdn4, Fi_UE_IPV4_ADDR_IMS,
Fi_UE_IPV6_ADDR_IMS,
True)
_init_PDN(anritsu_handle, sim_card, pdn5, Fi_UE_IPV4_ADDR_911,
Fi_UE_IPV6_ADDR_911,
True)
vnid1 = anritsu_handle.get_IMS(1)
vnid2 = anritsu_handle.get_IMS(2)
_init_IMS(
anritsu_handle,
vnid1,
sim_card,
ipv4_address=Fi_CSCF_IPV4_ADDR_IMS,
ipv6_address=Fi_CSCF_IPV6_ADDR_IMS,
auth=True)
_init_IMS(
anritsu_handle,
vnid2,
sim_card,
ipv4_address=Fi_CSCF_IPV4_ADDR_911,
ipv6_address=Fi_CSCF_IPV6_ADDR_911,
auth=False)
return [lte_bts, evdo_bts]
else:
pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
# Initialize PDN IP address for internet connection sharing
_init_PDN(anritsu_handle, sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, True)
_init_PDN(anritsu_handle, sim_card, pdn2, UE_IPV4_ADDR_2, UE_IPV6_ADDR_2, False)
_init_PDN(anritsu_handle, sim_card, pdn3, UE_IPV4_ADDR_3, UE_IPV6_ADDR_3, True)
vnid1 = anritsu_handle.get_IMS(DEFAULT_VNID)
if sim_card == P0135Ax:
vnid2 = anritsu_handle.get_IMS(2)
vnid3 = anritsu_handle.get_IMS(3)
_init_IMS(
anritsu_handle,
vnid1,
sim_card,
ipv6_address=CSCF_IPV6_ADDR,
auth=True)
_init_IMS(
anritsu_handle,
vnid2,
sim_card,
ipv6_address=CSCF_IPV6_ADDR_2,
ip_type="IPV6")
_init_IMS(
anritsu_handle,
vnid3,
sim_card,
ipv6_address=CSCF_IPV6_ADDR_3,
ip_type="IPV6")
elif sim_card == VzW12349:
_init_IMS(anritsu_handle, vnid1, sim_card, auth=True)
else:
_init_IMS(anritsu_handle, vnid1, sim_card)
return [lte_bts, evdo_bts]
def set_system_model_wcdma_gsm(anritsu_handle, user_params, sim_card):
""" Configures Anritsu system for WCDMA and GSM simulation
Args:
anritsu_handle: anritusu device object.
user_params: pointer to user supplied parameters
Returns:
Wcdma and Gsm BTS objects
"""
anritsu_handle.set_simulation_model(BtsTechnology.WCDMA, BtsTechnology.GSM)
# setting BTS parameters
wcdma_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
gsm_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
_init_wcdma_bts(wcdma_bts, user_params, CELL_1, sim_card)
_init_gsm_bts(gsm_bts, user_params, CELL_2, sim_card)
pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
# Initialize PDN IP address for internet connection sharing
if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
_init_PDN(anritsu_handle, sim_card, pdn1, Fi_UE_IPV4_ADDR_Data,
Fi_UE_IPV6_ADDR_Data, False)
else:
_init_PDN(anritsu_handle, sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False)
return [wcdma_bts, gsm_bts]
def set_system_model_gsm_gsm(anritsu_handle, user_params, sim_card):
""" Configures Anritsu system for GSM and GSM simulation
Args:
anritsu_handle: anritusu device object.
user_params: pointer to user supplied parameters
Returns:
Wcdma and Gsm BTS objects
"""
anritsu_handle.set_simulation_model(BtsTechnology.GSM, BtsTechnology.GSM)
# setting BTS parameters
gsm1_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
gsm2_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
_init_gsm_bts(gsm1_bts, user_params, CELL_1, sim_card)
_init_gsm_bts(gsm2_bts, user_params, CELL_2, sim_card)
pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
# Initialize PDN IP address for internet connection sharing
if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
_init_PDN(anritsu_handle,sim_card, pdn1, Fi_UE_IPV4_ADDR_Data,
Fi_UE_IPV6_ADDR_Data, False)
else:
_init_PDN(anritsu_handle,sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False)
return [gsm1_bts, gsm2_bts]
def set_system_model_lte(anritsu_handle, user_params, sim_card):
""" Configures Anritsu system for LTE simulation
Args:
anritsu_handle: anritusu device object.
user_params: pointer to user supplied parameters
Returns:
Lte BTS object
"""
anritsu_handle.set_simulation_model(BtsTechnology.LTE)
# setting Fi BTS parameters
lte_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
_init_lte_bts(lte_bts, user_params, CELL_1, sim_card)
if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
pdn4 = anritsu_handle.get_PDN(PDN_NO_4)
pdn5 = anritsu_handle.get_PDN(PDN_NO_5)
# Initialize PDN IP address.
_init_PDN(anritsu_handle,sim_card, pdn1, Fi_UE_IPV4_ADDR_Data,
Fi_UE_IPV6_ADDR_Data, False)
_init_PDN(anritsu_handle,sim_card, pdn2, Fi_UE_IPV4_ADDR_Data,
Fi_UE_IPV6_ADDR_Data, False)
_init_PDN(anritsu_handle,sim_card, pdn3, Fi_UE_IPV4_ADDR_Data,
Fi_UE_IPV6_ADDR_Data, False)
_init_PDN(anritsu_handle, sim_card, pdn4, Fi_UE_IPV4_ADDR_IMS,
Fi_UE_IPV6_ADDR_IMS,
True)
_init_PDN(anritsu_handle, sim_card, pdn5, Fi_UE_IPV4_ADDR_911,
Fi_UE_IPV6_ADDR_911,
True)
vnid1 = anritsu_handle.get_IMS(1)
vnid2 = anritsu_handle.get_IMS(2)
_init_IMS(
anritsu_handle,
vnid1,
sim_card,
ipv4_address=Fi_CSCF_IPV4_ADDR_IMS,
ipv6_address=Fi_CSCF_IPV6_ADDR_IMS,
auth=True)
_init_IMS(
anritsu_handle,
vnid2,
sim_card,
ipv4_address=Fi_CSCF_IPV4_ADDR_911,
ipv6_address=Fi_CSCF_IPV6_ADDR_911,
auth=False)
return [lte_bts]
else:
# setting BTS parameters
pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
# Initialize PDN IP address for internet connection sharing
_init_PDN(anritsu_handle,sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, True)
_init_PDN(anritsu_handle,sim_card, pdn2, UE_IPV4_ADDR_2, UE_IPV6_ADDR_2, False)
_init_PDN(anritsu_handle,sim_card, pdn3, UE_IPV4_ADDR_3, UE_IPV6_ADDR_3, True)
vnid1 = anritsu_handle.get_IMS(DEFAULT_VNID)
if sim_card == P0135Ax:
vnid2 = anritsu_handle.get_IMS(2)
vnid3 = anritsu_handle.get_IMS(3)
_init_IMS(
anritsu_handle,
vnid1,
sim_card,
ipv6_address=CSCF_IPV6_ADDR,
auth=True)
_init_IMS(
anritsu_handle,
vnid2,
sim_card,
ipv6_address=CSCF_IPV6_ADDR_2,
ip_type="IPV6")
_init_IMS(
anritsu_handle,
vnid3,
sim_card,
ipv6_address=CSCF_IPV6_ADDR_3,
ip_type="IPV6")
elif sim_card == VzW12349:
_init_IMS(anritsu_handle, vnid1, sim_card, auth=True)
else:
_init_IMS(anritsu_handle, vnid1, sim_card)
return [lte_bts]
def set_system_model_wcdma(anritsu_handle, user_params, sim_card):
""" Configures Anritsu system for WCDMA simulation
Args:
anritsu_handle: anritusu device object.
user_params: pointer to user supplied parameters
Returns:
Wcdma BTS object
"""
anritsu_handle.set_simulation_model(BtsTechnology.WCDMA)
# setting BTS parameters
wcdma_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
_init_wcdma_bts(wcdma_bts, user_params, CELL_1, sim_card)
pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
# Initialize PDN IP address for internet connection sharing
if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
_init_PDN(anritsu_handle,sim_card, pdn1, Fi_UE_IPV4_ADDR_Data,
Fi_UE_IPV6_ADDR_Data, False)
else:
_init_PDN(anritsu_handle,sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False)
return [wcdma_bts]
def set_system_model_gsm(anritsu_handle, user_params, sim_card):
""" Configures Anritsu system for GSM simulation
Args:
anritsu_handle: anritusu device object.
user_params: pointer to user supplied parameters
Returns:
Gsm BTS object
"""
anritsu_handle.set_simulation_model(BtsTechnology.GSM)
# setting BTS parameters
gsm_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
_init_gsm_bts(gsm_bts, user_params, CELL_1, sim_card)
pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
# Initialize PDN IP address for internet connection sharing
if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
_init_PDN(anritsu_handle,sim_card, pdn1, Fi_UE_IPV4_ADDR_Data,
Fi_UE_IPV6_ADDR_Data, False)
else:
_init_PDN(anritsu_handle,sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False)
return [gsm_bts]
def set_system_model_1x(anritsu_handle, user_params, sim_card):
""" Configures Anritsu system for CDMA 1X simulation
Args:
anritsu_handle: anritusu device object.
user_params: pointer to user supplied parameters
Returns:
Cdma 1x BTS object
"""
PDN_ONE = 1
anritsu_handle.set_simulation_model(BtsTechnology.CDMA1X)
# setting BTS parameters
cdma1x_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
_init_1x_bts(cdma1x_bts, user_params, CELL_1, sim_card)
pdn1 = anritsu_handle.get_PDN(PDN_ONE)
# Initialize PDN IP address for internet connection sharing
if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
_init_PDN(anritsu_handle,sim_card, pdn1, Fi_UE_IPV4_ADDR_Data,
Fi_UE_IPV6_ADDR_Data, False)
else:
_init_PDN(anritsu_handle,sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False)
return [cdma1x_bts]
def set_system_model_1x_evdo(anritsu_handle, user_params, sim_card):
""" Configures Anritsu system for CDMA 1X simulation
Args:
anritsu_handle: anritusu device object.
user_params: pointer to user supplied parameters
Returns:
Cdma 1x BTS object
"""
PDN_ONE = 1
anritsu_handle.set_simulation_model(BtsTechnology.CDMA1X,
BtsTechnology.EVDO)
# setting BTS parameters
cdma1x_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
evdo_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
_init_1x_bts(cdma1x_bts, user_params, CELL_1, sim_card)
_init_evdo_bts(evdo_bts, user_params, CELL_2, sim_card)
pdn1 = anritsu_handle.get_PDN(PDN_ONE)
# Initialize PDN IP address for internet connection sharing
if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
_init_PDN(anritsu_handle,sim_card, pdn1, Fi_UE_IPV4_ADDR_Data,
Fi_UE_IPV6_ADDR_Data, False)
else:
_init_PDN(anritsu_handle,sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False)
return [cdma1x_bts]
def wait_for_bts_state(log, btsnumber, state, timeout=30):
""" Waits for BTS to be in the specified state ("IN" or "OUT")
Args:
btsnumber: BTS number.
state: expected state
Returns:
True for success False for failure
"""
# state value are "IN" and "OUT"
status = False
sleep_interval = 1
wait_time = timeout
if state == "IN":
service_state = BtsServiceState.SERVICE_STATE_IN
elif state == "OUT":
service_state = BtsServiceState.SERVICE_STATE_OUT
else:
log.info("wrong state value")
return status
if btsnumber.service_state is service_state:
log.info("BTS state is already in {}".format(state))
return True
# set to desired service state
btsnumber.service_state = service_state
while wait_time > 0:
if service_state == btsnumber.service_state:
status = True
break
time.sleep(sleep_interval)
wait_time = wait_time - sleep_interval
if not status:
log.info("Timeout: Expected BTS state is not received.")
return status
class _CallSequenceException(Exception):
pass
def call_mo_setup_teardown(
log,
ad,
anritsu_handle,
callee_number,
teardown_side=CALL_TEARDOWN_PHONE,
is_emergency=False,
wait_time_in_call=WAIT_TIME_IN_CALL_LONG,
is_ims_call=False,
ims_virtual_network_id=DEFAULT_IMS_VIRTUAL_NETWORK_ID):
""" Makes a MO call and tear down the call
Args:
ad: Android device object.
anritsu_handle: Anritsu object.
callee_number: Number to be called.
teardown_side: the side to end the call (Phone or remote).
is_emergency: is the call an emergency call.
wait_time_in_call: Time to wait when phone in call.
is_ims_call: is the call expected to be ims call.
ims_virtual_network_id: ims virtual network id.
Returns:
True for success False for failure
"""
log.info("Making Call to " + callee_number)
virtual_phone_handle = anritsu_handle.get_VirtualPhone()
try:
# for an IMS call we either check CSCF or *nothing* (no virtual phone).
if is_ims_call:
# we only need pre-call registration in a non-emergency case
if not is_emergency:
if not wait_for_ims_cscf_status(log, anritsu_handle,
ims_virtual_network_id,
ImsCscfStatus.SIPIDLE.value):
raise _CallSequenceException(
"Phone IMS status is not idle.")
else:
if not wait_for_virtualphone_state(log, virtual_phone_handle,
VirtualPhoneStatus.STATUS_IDLE):
raise _CallSequenceException("Virtual Phone not idle.")
if not initiate_call(log, ad, callee_number, is_emergency):
raise _CallSequenceException("Initiate call failed.")
if is_ims_call:
if not wait_for_ims_cscf_status(log, anritsu_handle,
ims_virtual_network_id,
ImsCscfStatus.CALLING.value):
raise _CallSequenceException(
"Phone IMS status is not calling.")
if not wait_for_ims_cscf_status(log, anritsu_handle,
ims_virtual_network_id,
ImsCscfStatus.CONNECTED.value):
raise _CallSequenceException(
"Phone IMS status is not connected.")
else:
# check Virtual phone answered the call
if not wait_for_virtualphone_state(
log, virtual_phone_handle,
VirtualPhoneStatus.STATUS_VOICECALL_INPROGRESS):
raise _CallSequenceException("Virtual Phone not in call.")
time.sleep(wait_time_in_call)
if not ad.droid.telecomIsInCall():
raise _CallSequenceException("Call ended before delay_in_call.")
if teardown_side is CALL_TEARDOWN_REMOTE:
log.info("Disconnecting the call from Remote")
if is_ims_call:
anritsu_handle.ims_cscf_call_action(ims_virtual_network_id,
ImsCscfCall.END.value)
else:
virtual_phone_handle.set_voice_on_hook()
if not wait_for_droid_not_in_call(log, ad,
MAX_WAIT_TIME_CALL_DROP):
raise _CallSequenceException("DUT call not drop.")
else:
log.info("Disconnecting the call from DUT")
if not hangup_call(log, ad, is_emergency):
raise _CallSequenceException(
"Error in Hanging-Up Call on DUT.")
if is_ims_call:
if not wait_for_ims_cscf_status(log, anritsu_handle,
ims_virtual_network_id,
ImsCscfStatus.SIPIDLE.value):
raise _CallSequenceException("Phone IMS status is not idle.")
else:
if not wait_for_virtualphone_state(log, virtual_phone_handle,
VirtualPhoneStatus.STATUS_IDLE):
raise _CallSequenceException(
"Virtual Phone not idle after hangup.")
return True
except _CallSequenceException as e:
log.error(e)
return False
finally:
try:
if ad.droid.telecomIsInCall():
ad.droid.telecomEndCall()
except Exception as e:
log.error(str(e))
def handover_tc(log,
anritsu_handle,
wait_time=0,
s_bts=BtsNumber.BTS1,
t_bts=BtsNumber.BTS2,
timeout=60):
""" Setup and perform a handover test case in MD8475A
Args:
anritsu_handle: Anritsu object.
s_bts: Serving (originating) BTS
t_bts: Target (destination) BTS
wait_time: time to wait before handover
Returns:
True for success False for failure
"""
log.info("Starting HO test case procedure")
log.info("Serving BTS = {}, Target BTS = {}".format(s_bts, t_bts))
time.sleep(wait_time)
ho_tc = anritsu_handle.get_AnritsuTestCases()
ho_tc.procedure = TestProcedure.PROCEDURE_HO
ho_tc.bts_direction = (s_bts, t_bts)
ho_tc.power_control = TestPowerControl.POWER_CONTROL_DISABLE
ho_tc.measurement_LTE = TestMeasurement.MEASUREMENT_DISABLE
anritsu_handle.start_testcase()
status = anritsu_handle.get_testcase_status()
timer = 0
while status == "0":
time.sleep(1)
status = anritsu_handle.get_testcase_status()
timer += 1
if timer > timeout:
return "Handover Test Case time out in {} sec!".format(timeout)
return status
def make_ims_call(log,
ad,
anritsu_handle,
callee_number,
is_emergency=False,
check_ims_reg=True,
check_ims_calling=True,
mo=True,
ims_virtual_network_id=DEFAULT_IMS_VIRTUAL_NETWORK_ID):
""" Makes a MO call after IMS registred
Args:
ad: Android device object.
anritsu_handle: Anritsu object.
callee_number: Number to be called.
check_ims_reg: check if Anritsu cscf server state is "SIPIDLE".
check_ims_calling: check if Anritsu cscf server state is "CALLING".
mo: Mobile originated call
ims_virtual_network_id: ims virtual network id.
Returns:
True for success False for failure
"""
try:
# confirm ims registration
if check_ims_reg:
if not wait_for_ims_cscf_status(log, anritsu_handle,
ims_virtual_network_id,
ImsCscfStatus.SIPIDLE.value):
raise _CallSequenceException("IMS/CSCF status is not idle.")
if mo: # make MO call
log.info("Making Call to " + callee_number)
if not initiate_call(log, ad, callee_number, is_emergency):
raise _CallSequenceException("Initiate call failed.")
if not wait_for_ims_cscf_status(log, anritsu_handle,
ims_virtual_network_id,
ImsCscfStatus.CALLING.value):
raise _CallSequenceException(
"Phone IMS status is not calling.")
else: # make MT call
log.info("Making IMS Call to UE from MD8475A...")
anritsu_handle.ims_cscf_call_action(ims_virtual_network_id,
ImsCscfCall.MAKE.value)
if not wait_for_ims_cscf_status(log, anritsu_handle,
ims_virtual_network_id,
ImsCscfStatus.RINGING.value):
raise _CallSequenceException(
"Phone IMS status is not ringing.")
# answer the call on the UE
if not wait_and_answer_call(log, ad):
raise _CallSequenceException("UE Answer call Fail")
if not wait_for_ims_cscf_status(log, anritsu_handle,
ims_virtual_network_id,
ImsCscfStatus.CONNECTED.value):
raise _CallSequenceException(
"MD8475A IMS status is not connected.")
return True
except _CallSequenceException as e:
log.error(e)
return False
def tear_down_call(log,
ad,
anritsu_handle,
ims_virtual_network_id=DEFAULT_IMS_VIRTUAL_NETWORK_ID):
""" Check and End a VoLTE call
Args:
ad: Android device object.
anritsu_handle: Anritsu object.
ims_virtual_network_id: ims virtual network id.
Returns:
True for success False for failure
"""
try:
# end the call from phone
log.info("Disconnecting the call from DUT")
if not hangup_call(log, ad):
raise _CallSequenceException("Error in Hanging-Up Call on DUT.")
# confirm if CSCF status is back to idle
if not wait_for_ims_cscf_status(log, anritsu_handle,
ims_virtual_network_id,
ImsCscfStatus.SIPIDLE.value):
raise _CallSequenceException("IMS/CSCF status is not idle.")
return True
except _CallSequenceException as e:
log.error(e)
return False
finally:
try:
if ad.droid.telecomIsInCall():
ad.droid.telecomEndCall()
except Exception as e:
log.error(str(e))
# This procedure is for VoLTE mobility test cases
def ims_call_ho(log,
ad,
anritsu_handle,
callee_number,
is_emergency=False,
check_ims_reg=True,
check_ims_calling=True,
mo=True,
wait_time_in_volte=WAIT_TIME_IN_CALL_FOR_IMS,
ims_virtual_network_id=DEFAULT_IMS_VIRTUAL_NETWORK_ID):
""" Makes a MO call after IMS registred, then handover
Args:
ad: Android device object.
anritsu_handle: Anritsu object.
callee_number: Number to be called.
check_ims_reg: check if Anritsu cscf server state is "SIPIDLE".
check_ims_calling: check if Anritsu cscf server state is "CALLING".
mo: Mobile originated call
wait_time_in_volte: Time for phone in VoLTE call, not used for SRLTE
ims_virtual_network_id: ims virtual network id.
Returns:
True for success False for failure
"""
try:
# confirm ims registration
if check_ims_reg:
if not wait_for_ims_cscf_status(log, anritsu_handle,
ims_virtual_network_id,
ImsCscfStatus.SIPIDLE.value):
raise _CallSequenceException("IMS/CSCF status is not idle.")
if mo: # make MO call
log.info("Making Call to " + callee_number)
if not initiate_call(log, ad, callee_number, is_emergency):
raise _CallSequenceException("Initiate call failed.")
if not wait_for_ims_cscf_status(log, anritsu_handle,
ims_virtual_network_id,
ImsCscfStatus.CALLING.value):
raise _CallSequenceException(
"Phone IMS status is not calling.")
else: # make MT call
log.info("Making IMS Call to UE from MD8475A...")
anritsu_handle.ims_cscf_call_action(ims_virtual_network_id,
ImsCscfCall.MAKE.value)
if not wait_for_ims_cscf_status(log, anritsu_handle,
ims_virtual_network_id,
ImsCscfStatus.RINGING.value):
raise _CallSequenceException(
"Phone IMS status is not ringing.")
# answer the call on the UE
if not wait_and_answer_call(log, ad):
raise _CallSequenceException("UE Answer call Fail")
if not wait_for_ims_cscf_status(log, anritsu_handle,
ims_virtual_network_id,
ImsCscfStatus.CONNECTED.value):
raise _CallSequenceException("Phone IMS status is not connected.")
log.info(
"Wait for {} seconds before handover".format(wait_time_in_volte))
time.sleep(wait_time_in_volte)
# Once VoLTE call is connected, then Handover
log.info("Starting handover procedure...")
result = handover_tc(anritsu_handle, BtsNumber.BTS1, BtsNumber.BTS2)
log.info("Handover procedure ends with result code {}".format(result))
log.info(
"Wait for {} seconds after handover".format(wait_time_in_volte))
time.sleep(wait_time_in_volte)
# check if the phone stay in call
if not ad.droid.telecomIsInCall():
raise _CallSequenceException("Call ended before delay_in_call.")
# end the call from phone
log.info("Disconnecting the call from DUT")
if not hangup_call(log, ad, is_emergency):
raise _CallSequenceException("Error in Hanging-Up Call on DUT.")
# confirm if CSCF status is back to idle
if not wait_for_ims_cscf_status(log, anritsu_handle,
ims_virtual_network_id,
ImsCscfStatus.SIPIDLE.value):
raise _CallSequenceException("IMS/CSCF status is not idle.")
return True
except _CallSequenceException as e:
log.error(e)
return False
finally:
try:
if ad.droid.telecomIsInCall():
ad.droid.telecomEndCall()
except Exception as e:
log.error(str(e))
# This procedure is for SRLTE CSFB and SRVCC test cases
def ims_call_cs_teardown(
log,
ad,
anritsu_handle,
callee_number,
teardown_side=CALL_TEARDOWN_PHONE,
is_emergency=False,
check_ims_reg=True,
check_ims_calling=True,
srvcc=None,
mo=True,
wait_time_in_volte=WAIT_TIME_IN_CALL_FOR_IMS,
wait_time_in_cs=WAIT_TIME_IN_CALL,
wait_time_in_alert=WAIT_TIME_IN_ALERT,
ims_virtual_network_id=DEFAULT_IMS_VIRTUAL_NETWORK_ID):
""" Makes a MO call after IMS registred, transit to CS, tear down the call
Args:
ad: Android device object.
anritsu_handle: Anritsu object.
callee_number: Number to be called.
teardown_side: the side to end the call (Phone or remote).
is_emergency: to make emergency call on the phone.
check_ims_reg: check if Anritsu cscf server state is "SIPIDLE".
check_ims_calling: check if Anritsu cscf server state is "CALLING".
srvcc: is the test case a SRVCC call.
mo: Mobile originated call
wait_time_in_volte: Time for phone in VoLTE call, not used for SRLTE
wait_time_in_cs: Time for phone in CS call.
ims_virtual_network_id: ims virtual network id.
Returns:
True for success False for failure
"""
virtual_phone_handle = anritsu_handle.get_VirtualPhone()
try:
# confirm ims registration
if check_ims_reg:
if not wait_for_ims_cscf_status(log, anritsu_handle,
ims_virtual_network_id,
ImsCscfStatus.SIPIDLE.value):
raise _CallSequenceException("IMS/CSCF status is not idle.")
# confirm virtual phone in idle
if not wait_for_virtualphone_state(log, virtual_phone_handle,
VirtualPhoneStatus.STATUS_IDLE):
raise _CallSequenceException("Virtual Phone not idle.")
if mo: # make MO call
log.info("Making Call to " + callee_number)
if not initiate_call(log, ad, callee_number, is_emergency):
raise _CallSequenceException("Initiate call failed.")
else: # make MT call
log.info("Making IMS Call to UE from MD8475A...")
anritsu_handle.ims_cscf_call_action(ims_virtual_network_id,
ImsCscfCall.MAKE.value)
# if check ims calling is required
if check_ims_calling:
if mo:
if not wait_for_ims_cscf_status(log, anritsu_handle,
ims_virtual_network_id,
ImsCscfStatus.CALLING.value):
raise _CallSequenceException(
"Phone IMS status is not calling.")
else:
if not wait_for_ims_cscf_status(log, anritsu_handle,
ims_virtual_network_id,
ImsCscfStatus.RINGING.value):
raise _CallSequenceException(
"Phone IMS status is not ringing.")
# if SRVCC, check if VoLTE call is connected, then Handover
if srvcc != None:
if srvcc == "InCall":
if not wait_for_ims_cscf_status(
log, anritsu_handle, ims_virtual_network_id,
ImsCscfStatus.CONNECTED.value):
raise _CallSequenceException(
"Phone IMS status is not connected.")
# stay in call for "wait_time_in_volte" seconds
time.sleep(wait_time_in_volte)
elif srvcc == "Alert":
# ring for WAIT_TIME_IN_ALERT seconds
time.sleep(WAIT_TIME_IN_ALERT)
# SRVCC by handover test case procedure
srvcc_tc = anritsu_handle.get_AnritsuTestCases()
srvcc_tc.procedure = TestProcedure.PROCEDURE_HO
srvcc_tc.bts_direction = (BtsNumber.BTS1, BtsNumber.BTS2)
srvcc_tc.power_control = TestPowerControl.POWER_CONTROL_DISABLE
srvcc_tc.measurement_LTE = TestMeasurement.MEASUREMENT_DISABLE
anritsu_handle.start_testcase()
time.sleep(5)
if not mo:
# answer the call on the UE
if not wait_and_answer_call(log, ad):
raise _CallSequenceException("UE Answer call Fail")
# check if Virtual phone in the call
if not wait_for_virtualphone_state(
log, virtual_phone_handle,
VirtualPhoneStatus.STATUS_VOICECALL_INPROGRESS):
raise _CallSequenceException("Virtual Phone not in call.")
# stay in call for "wait_time_in_cs" seconds
time.sleep(wait_time_in_cs)
# check if the phone stay in call
if not ad.droid.telecomIsInCall():
raise _CallSequenceException("Call ended before delay_in_call.")
# end the call
if teardown_side is CALL_TEARDOWN_REMOTE:
log.info("Disconnecting the call from Remote")
virtual_phone_handle.set_voice_on_hook()
if not wait_for_droid_not_in_call(log, ad,
MAX_WAIT_TIME_CALL_DROP):
raise _CallSequenceException("DUT call not drop.")
else:
log.info("Disconnecting the call from DUT")
if not hangup_call(log, ad, is_emergency):
raise _CallSequenceException(
"Error in Hanging-Up Call on DUT.")
# confirm if virtual phone status is back to idle
if not wait_for_virtualphone_state(log, virtual_phone_handle,
VirtualPhoneStatus.STATUS_IDLE):
raise _CallSequenceException(
"Virtual Phone not idle after hangup.")
return True
except _CallSequenceException as e:
log.error(e)
return False
finally:
try:
if ad.droid.telecomIsInCall():
ad.droid.telecomEndCall()
except Exception as e:
log.error(str(e))
def call_mt_setup_teardown(log,
ad,
virtual_phone_handle,
caller_number=None,
teardown_side=CALL_TEARDOWN_PHONE,
rat=""):
""" Makes a call from Anritsu Virtual phone to device and tear down the call
Args:
ad: Android device object.
virtual_phone_handle: Anritsu virtual phone handle
caller_number = Caller number
teardown_side = specifiy the side to end the call (Phone or remote)
Returns:
True for success False for failure
"""
log.info("Receive MT Call - Making a call to the phone from remote")
try:
if not wait_for_virtualphone_state(log, virtual_phone_handle,
VirtualPhoneStatus.STATUS_IDLE):
raise Exception("Virtual Phone is not in a state to start call")
if caller_number is not None:
if rat == RAT_1XRTT:
virtual_phone_handle.id_c2k = caller_number
else:
virtual_phone_handle.id = caller_number
virtual_phone_handle.set_voice_off_hook()
if not wait_and_answer_call(log, ad, caller_number):
raise Exception("Answer call Fail")
time.sleep(WAIT_TIME_IN_CALL)
if not ad.droid.telecomIsInCall():
raise Exception("Call ended before delay_in_call.")
except Exception:
return False
if ad.droid.telecomIsInCall():
if teardown_side is CALL_TEARDOWN_REMOTE:
log.info("Disconnecting the call from Remote")
virtual_phone_handle.set_voice_on_hook()
else:
log.info("Disconnecting the call from Phone")
ad.droid.telecomEndCall()
wait_for_virtualphone_state(log, virtual_phone_handle,
VirtualPhoneStatus.STATUS_IDLE)
ensure_phone_idle(log, ad)
return True
def wait_for_sms_deliver_success(log, ad, time_to_wait=60):
sms_deliver_event = EventSmsDeliverSuccess
sleep_interval = 2
status = False
event = None
try:
event = ad.ed.pop_event(sms_deliver_event, time_to_wait)
status = True
except Empty:
log.info("Timeout: Expected event is not received.")
return status
def wait_for_sms_sent_success(log, ad, time_to_wait=60):
sms_sent_event = EventSmsSentSuccess
sleep_interval = 2
status = False
event = None
try:
event = ad.ed.pop_event(sms_sent_event, time_to_wait)
log.info(event)
status = True
except Empty:
log.info("Timeout: Expected event is not received.")
return status
def wait_for_incoming_sms(log, ad, time_to_wait=60):
sms_received_event = EventSmsReceived
sleep_interval = 2
status = False
event = None
try:
event = ad.ed.pop_event(sms_received_event, time_to_wait)
log.info(event)
status = True
except Empty:
log.info("Timeout: Expected event is not received.")
return status, event
def verify_anritsu_received_sms(log, vp_handle, receiver_number, message, rat):
if rat == RAT_1XRTT:
receive_sms = vp_handle.receiveSms_c2k()
else:
receive_sms = vp_handle.receiveSms()
if receive_sms == "NONE":
return False
split = receive_sms.split('&')
text = ""
if rat == RAT_1XRTT:
# TODO: b/26296388 There is some problem when retrieving message with é
# from Anritsu.
return True
for i in range(len(split)):
if split[i].startswith('Text='):
text = split[i][5:]
text = AnritsuUtils.gsm_decode(text)
break
# TODO: b/26296388 Verify Phone number
if text != message:
log.error("Wrong message received")
return False
return True
def sms_mo_send(log, ad, vp_handle, receiver_number, message, rat=""):
try:
if not wait_for_virtualphone_state(log, vp_handle,
VirtualPhoneStatus.STATUS_IDLE):
raise Exception("Virtual Phone is not in a state to receive SMS")
log.info("Sending SMS to " + receiver_number)
ad.droid.smsSendTextMessage(receiver_number, message, False)
log.info("Waiting for SMS sent event")
test_status = wait_for_sms_sent_success(log, ad)
if not test_status:
raise Exception("Failed to send SMS")
if not verify_anritsu_received_sms(log, vp_handle, receiver_number,
message, rat):
raise Exception("Anritsu didn't receive message")
except Exception as e:
log.error("Exception :" + str(e))
return False
return True
def sms_mt_receive_verify(log, ad, vp_handle, sender_number, message, rat=""):
ad.droid.smsStartTrackingIncomingMessage()
try:
if not wait_for_virtualphone_state(log, vp_handle,
VirtualPhoneStatus.STATUS_IDLE):
raise Exception("Virtual Phone is not in a state to receive SMS")
log.info("Waiting for Incoming SMS from " + sender_number)
if rat == RAT_1XRTT:
vp_handle.sendSms_c2k(sender_number, message)
else:
vp_handle.sendSms(sender_number, message)
test_status, event = wait_for_incoming_sms(log, ad)
if not test_status:
raise Exception("Failed to receive SMS")
log.info("Incoming SMS: Sender " + event['data']['Sender'])
log.info("Incoming SMS: Message " + event['data']['Text'])
if event['data']['Sender'] != sender_number:
raise Exception("Wrong sender Number")
if event['data']['Text'] != message:
raise Exception("Wrong message")
except Exception as e:
log.error("exception: " + str(e))
return False
finally:
ad.droid.smsStopTrackingIncomingMessage()
return True
def wait_for_ims_cscf_status(log,
anritsu_handle,
virtual_network_id,
status,
timeout=MAX_WAIT_TIME_IMS_CSCF_STATE):
""" Wait for IMS CSCF to be in expected state.
Args:
log: log object
anritsu_handle: anritsu object
virtual_network_id: virtual network id to be monitored
status: expected status
timeout: wait time
"""
sleep_interval = 1
wait_time = timeout
while wait_time > 0:
if status == anritsu_handle.get_ims_cscf_status(virtual_network_id):
return True
time.sleep(sleep_interval)
wait_time = wait_time - sleep_interval
return False
def wait_for_virtualphone_state(log,
vp_handle,
state,
timeout=MAX_WAIT_TIME_VIRTUAL_PHONE_STATE):
""" Waits for Anritsu Virtual phone to be in expected state
Args:
ad: Android device object.
vp_handle: Anritus virtual phone handle
state = expected state
Returns:
True for success False for failure
"""
status = False
sleep_interval = 1
wait_time = timeout
while wait_time > 0:
if vp_handle.status == state:
log.info(vp_handle.status)
status = True
break
time.sleep(sleep_interval)
wait_time = wait_time - sleep_interval
if not status:
log.info("Timeout: Expected state is not received.")
return status
# There is a difference between CMAS/ETWS message formation in LTE/WCDMA and CDMA 1X
# LTE and CDMA : 3GPP
# CDMA 1X: 3GPP2
# hence different functions
def cmas_receive_verify_message_lte_wcdma(
log, ad, anritsu_handle, serial_number, message_id, warning_message):
""" Makes Anritsu to send a CMAS message and phone and verifies phone
receives the message on LTE/WCDMA
Args:
ad: Android device object.
anritsu_handle: Anritus device object
serial_number = serial number of CMAS message
message_id = CMAS message ID
warning_message = CMAS warning message
Returns:
True for success False for failure
"""
status = False
event = None
ad.droid.smsStartTrackingGsmEmergencyCBMessage()
anritsu_handle.send_cmas_lte_wcdma(
hex(serial_number), message_id, warning_message)
try:
log.info("Waiting for CMAS Message")
event = ad.ed.pop_event(EventCmasReceived, 60)
status = True
log.info(event)
if warning_message != event['data']['message']:
log.info("Wrong warning messgae received")
status = False
if message_id != hex(event['data']['serviceCategory']):
log.info("Wrong warning messgae received")
status = False
except Empty:
log.info("Timeout: Expected event is not received.")
ad.droid.smsStopTrackingGsmEmergencyCBMessage()
return status
def cmas_receive_verify_message_cdma1x(
log,
ad,
anritsu_handle,
message_id,
service_category,
alert_text,
response_type=CMAS_C2K_RESPONSETYPE_SHELTER,
severity=CMAS_C2K_SEVERITY_EXTREME,
urgency=CMAS_C2K_URGENCY_IMMEDIATE,
certainty=CMAS_C2K_CERTIANTY_OBSERVED):
""" Makes Anritsu to send a CMAS message and phone and verifies phone
receives the message on CDMA 1X
Args:
ad: Android device object.
anritsu_handle: Anritus device object
serial_number = serial number of CMAS message
message_id = CMAS message ID
warning_message = CMAS warning message
Returns:
True for success False for failure
"""
status = False
event = None
ad.droid.smsStartTrackingCdmaEmergencyCBMessage()
anritsu_handle.send_cmas_etws_cdma1x(message_id, service_category,
alert_text, response_type, severity,
urgency, certainty)
try:
log.info("Waiting for CMAS Message")
event = ad.ed.pop_event(EventCmasReceived, 60)
status = True
log.info(event)
if alert_text != event['data']['message']:
log.info("Wrong alert messgae received")
status = False
if event['data']['cmasResponseType'].lower() != response_type.lower():
log.info("Wrong response type received")
status = False
if event['data']['cmasUrgency'].lower() != urgency.lower():
log.info("Wrong cmasUrgency received")
status = False
if event['data']['cmasSeverity'].lower() != severity.lower():
log.info("Wrong cmasSeverity received")
status = False
except Empty:
log.info("Timeout: Expected event is not received.")
ad.droid.smsStopTrackingCdmaEmergencyCBMessage()
return status
def etws_receive_verify_message_lte_wcdma(
log, ad, anritsu_handle, serial_number, message_id, warning_message):
""" Makes Anritsu to send a ETWS message and phone and verifies phone
receives the message on LTE/WCDMA
Args:
ad: Android device object.
anritsu_handle: Anritus device object
serial_number = serial number of ETWS message
message_id = ETWS message ID
warning_message = ETWS warning message
Returns:
True for success False for failure
"""
status = False
event = None
if message_id == ETWS_WARNING_EARTHQUAKE:
warning_type = "Earthquake"
elif message_id == ETWS_WARNING_EARTHQUAKETSUNAMI:
warning_type = "EarthquakeandTsunami"
elif message_id == ETWS_WARNING_TSUNAMI:
warning_type = "Tsunami"
elif message_id == ETWS_WARNING_TEST_MESSAGE:
warning_type = "test"
elif message_id == ETWS_WARNING_OTHER_EMERGENCY:
warning_type = "other"
ad.droid.smsStartTrackingGsmEmergencyCBMessage()
anritsu_handle.send_etws_lte_wcdma(
hex(serial_number), message_id, warning_type, warning_message, "ON",
"ON")
try:
log.info("Waiting for ETWS Message")
event = ad.ed.pop_event(EventEtwsReceived, 60)
status = True
log.info(event)
# TODO: b/26296388 Event data verification
except Empty:
log.info("Timeout: Expected event is not received.")
ad.droid.smsStopTrackingGsmEmergencyCBMessage()
return status
def etws_receive_verify_message_cdma1x(log, ad, anritsu_handle, serial_number,
message_id, warning_message):
""" Makes Anritsu to send a ETWS message and phone and verifies phone
receives the message on CDMA1X
Args:
ad: Android device object.
anritsu_handle: Anritus device object
serial_number = serial number of ETWS message
message_id = ETWS message ID
warning_message = ETWS warning message
Returns:
True for success False for failure
"""
status = False
event = None
# TODO: b/26296388 need to add logic to check etws.
return status
def read_ue_identity(log, ad, anritsu_handle, identity_type):
""" Get the UE identity IMSI, IMEI, IMEISV
Args:
ad: Android device object.
anritsu_handle: Anritus device object
identity_type: Identity type(IMSI/IMEI/IMEISV)
Returns:
Requested Identity value
"""
return anritsu_handle.get_ue_identity(identity_type)
def get_transmission_mode(user_params, cell_no):
""" Returns the TRANSMODE to be used from the user specified parameters
or default value
Args:
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
TM to be used
"""
key = "cell{}_transmission_mode".format(cell_no)
transmission_mode = user_params.get(key, DEFAULT_T_MODE)
return transmission_mode
def get_dl_antenna(user_params, cell_no):
""" Returns the DL ANTENNA to be used from the user specified parameters
or default value
Args:
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
number of DL ANTENNAS to be used
"""
key = "cell{}_dl_antenna".format(cell_no)
dl_antenna = user_params.get(key, DEFAULT_DL_ANTENNA)
return dl_antenna
def get_lte_band(user_params, cell_no, sim_card):
""" Returns the LTE BAND to be used from the user specified parameters
or default value
Args:
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
LTE BAND to be used
"""
key = "cell{}_lte_band".format(cell_no)
if sim_card == FiTMO:
band = Fi_LTE_TMO_BAND[cell_no - 1]
elif sim_card == FiSPR:
band = Fi_LTE_SPR_BAND[cell_no - 1]
elif sim_card == FiUSCC:
band = Fi_LTE_USCC_BAND[cell_no - 1]
else:
band = DEFAULT_LTE_BAND[cell_no - 1]
return user_params.get(key, band)
def get_wcdma_band(user_params, cell_no):
""" Returns the WCDMA BAND to be used from the user specified parameters
or default value
Args:
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
WCDMA BAND to be used
"""
key = "cell{}_wcdma_band".format(cell_no)
wcdma_band = user_params.get(key, DEFAULT_WCDMA_BAND)
return wcdma_band
def get_gsm_band(user_params, cell_no, sim_card):
""" Returns the GSM BAND to be used from the user specified parameters
or default value
Args:
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
GSM BAND to be used
"""
key = "cell{}_gsm_band".format(cell_no)
if sim_card == FiTMO:
gsm_band = Fi_GSM_TMO_BAND
else:
gsm_band = user_params.get(key, DEFAULT_GSM_BAND)
return gsm_band
def get_1x_band(user_params, cell_no, sim_card):
""" Returns the 1X BAND to be used from the user specified parameters
or default value
Args:
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
1X BAND to be used
"""
key = "cell{}_1x_band".format(cell_no)
if sim_card == FiSPR:
band = Fi_SPR1X_BAND
elif sim_card == FiUSCC:
band = Fi_USCC1X_BAND
elif sim_card == VzW12349:
band = VzW_CDMA1x_BAND
else:
band = DEFAULT_CDMA1X_BAND
return user_params.get(key, band)
def get_evdo_band(user_params, cell_no, sim_card):
""" Returns the EVDO BAND to be used from the user specified parameters
or default value
Args:
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
EVDO BAND to be used
"""
key = "cell{}_evdo_band".format(cell_no)
if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
band = Fi_EVDO_BAND
elif sim_card == VzW12349:
band = VzW_EVDO_BAND
else:
band = DEFAULT_EVDO_BAND
return user_params.get(key, band)
def get_wcdma_rac(user_params, cell_no):
""" Returns the WCDMA RAC to be used from the user specified parameters
or default value
Args:
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
WCDMA RAC to be used
"""
key = "cell{}_wcdma_rac".format(cell_no)
try:
wcdma_rac = user_params[key]
except KeyError:
wcdma_rac = DEFAULT_RAC
return wcdma_rac
def get_gsm_rac(user_params, cell_no):
""" Returns the GSM RAC to be used from the user specified parameters
or default value
Args:
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
GSM RAC to be used
"""
key = "cell{}_gsm_rac".format(cell_no)
try:
gsm_rac = user_params[key]
except KeyError:
gsm_rac = DEFAULT_RAC
return gsm_rac
def get_wcdma_lac(user_params, cell_no):
""" Returns the WCDMA LAC to be used from the user specified parameters
or default value
Args:
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
WCDMA LAC to be used
"""
key = "cell{}_wcdma_lac".format(cell_no)
try:
wcdma_lac = user_params[key]
except KeyError:
wcdma_lac = DEFAULT_LAC
return wcdma_lac
def get_gsm_lac(user_params, cell_no):
""" Returns the GSM LAC to be used from the user specified parameters
or default value
Args:
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
GSM LAC to be used
"""
key = "cell{}_gsm_lac".format(cell_no)
try:
gsm_lac = user_params[key]
except KeyError:
gsm_lac = DEFAULT_LAC
return gsm_lac
def get_lte_mcc(user_params, cell_no, sim_card):
""" Returns the LTE MCC to be used from the user specified parameters
or default value
Args:
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
LTE MCC to be used
"""
key = "cell{}_lte_mcc".format(cell_no)
if sim_card == FiTMO:
mcc = Fi_TMO_MCC
elif sim_card == FiSPR:
mcc = Fi_SPR_MCC
elif sim_card == FiUSCC:
mcc = Fi_USCC_MCC
elif sim_card == VzW12349:
mcc = VzW_MCC
else:
mcc = DEFAULT_MCC
return user_params.get(key, mcc)
def get_lte_mnc(user_params, cell_no, sim_card):
""" Returns the LTE MNC to be used from the user specified parameters
or default value
Args:
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
LTE MNC to be used
"""
key = "cell{}_lte_mnc".format(cell_no)
if sim_card == FiTMO:
mnc = Fi_TMO_MNC
elif sim_card == FiSPR:
mnc = Fi_SPR_MNC
elif sim_card == FiUSCC:
mnc = Fi_USCC_MNC
elif sim_card == VzW12349:
mnc = VzW_MNC
else:
mnc = DEFAULT_MNC
return user_params.get(key, mnc)
def get_wcdma_mcc(user_params, cell_no, sim_card):
""" Returns the WCDMA MCC to be used from the user specified parameters
or default value
Args:
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
WCDMA MCC to be used
"""
key = "cell{}_wcdma_mcc".format(cell_no)
mcc = VzW_MCC if sim_card == VzW12349 else DEFAULT_MCC
return user_params.get(key, mcc)
def get_wcdma_mnc(user_params, cell_no, sim_card):
""" Returns the WCDMA MNC to be used from the user specified parameters
or default value
Args:
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
WCDMA MNC to be used
"""
key = "cell{}_wcdma_mnc".format(cell_no)
mnc = VzW_MNC if sim_card == VzW12349 else DEFAULT_MNC
return user_params.get(key, mnc)
def get_gsm_mcc(user_params, cell_no, sim_card):
""" Returns the GSM MCC to be used from the user specified parameters
or default value
Args:
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
GSM MCC to be used
"""
key = "cell{}_gsm_mcc".format(cell_no)
mcc = VzW_MCC if sim_card == VzW12349 else DEFAULT_MCC
return user_params.get(key, mcc)
def get_gsm_mnc(user_params, cell_no, sim_card):
""" Returns the GSM MNC to be used from the user specified parameters
or default value
Args:
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
GSM MNC to be used
"""
key = "cell{}_gsm_mnc".format(cell_no)
mnc = VzW_MNC if sim_card == VzW12349 else DEFAULT_MNC
return user_params.get(key, mnc)
def get_1x_mcc(user_params, cell_no, sim_card):
""" Returns the 1X MCC to be used from the user specified parameters
or default value
Args:
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
1X MCC to be used
"""
key = "cell{}_1x_mcc".format(cell_no)
if sim_card == FiSPR:
mcc = Fi_SPR1X_MCC
elif sim_card == FiUSCC:
mcc = Fi_USCC1X_MCC
elif sim_card == VzW12349:
mcc = VzW_MCC
else:
mcc = DEFAULT_MCC
return user_params.get(key, mcc)
def get_1x_channel(user_params, cell_no, sim_card):
""" Returns the 1X Channel to be used from the user specified parameters
or default value
Args:
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
1X Channel to be used
"""
key = "cell{}_1x_channel".format(cell_no)
if sim_card == FiSPR:
ch = Fi_SPR1X_CH
elif sim_card == FiUSCC:
ch = Fi_USCC1X_CH
elif sim_card == VzW12349:
ch = VzW_CDMA1x_CH
else:
ch = DEFAULT_CDMA1X_CH
return user_params.get(key, ch)
def get_1x_sid(user_params, cell_no, sim_card):
""" Returns the 1X SID to be used from the user specified parameters
or default value
Args:
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
1X SID to be used
"""
key = "cell{}_1x_sid".format(cell_no)
if sim_card == FiSPR:
sid = Fi_SPR1X_SID
elif sim_card == FiUSCC:
sid = Fi_USCC1X_SID
elif sim_card == VzW12349:
sid = VzW_CDMA1X_SID
else:
sid = DEFAULT_CDMA1X_SID
return user_params.get(key, sid)
def get_1x_nid(user_params, cell_no, sim_card):
""" Returns the 1X NID to be used from the user specified parameters
or default value
Args:
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
1X NID to be used
"""
key = "cell{}_1x_nid".format(cell_no)
if sim_card == FiSPR:
nid = Fi_SPR1X_NID
elif sim_card == FiUSCC:
nid = Fi_USCC1X_NID
elif sim_card == VzW12349:
nid = VzW_CDMA1X_NID
else:
nid = DEFAULT_CDMA1X_NID
return user_params.get(key, nid)
def get_evdo_channel(user_params, cell_no, sim_card):
""" Returns the EVDO Channel to be used from the user specified parameters
or default value
Args:
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
EVDO Channel to be used
"""
key = "cell{}_evdo_channel".format(cell_no)
if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
ch = Fi_EVDO_CH
elif sim_card == VzW12349:
ch = VzW_EVDO_CH
else:
ch = DEFAULT_EVDO_CH
return user_params.get(key, ch)
def get_evdo_sid(user_params, cell_no, sim_card):
""" Returns the EVDO SID to be used from the user specified parameters
or default value
Args:
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
EVDO SID to be used
"""
key = "cell{}_evdo_sid".format(cell_no)
if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
sid = Fi_EVDO_SECTOR_ID
elif sim_card == VzW12349:
sid = VzW_EVDO_SECTOR_ID
else:
sid = DEFAULT_EVDO_SECTOR_ID
return user_params.get(key, sid)
def get_csfb_type(user_params):
""" Returns the CSFB Type to be used from the user specified parameters
or default value
Args:
user_params: pointer to user supplied parameters
cell_no: specify the cell number this BTS is configured
Anritsu supports two cells. so cell_1 or cell_2
Returns:
CSFB Type to be used
"""
try:
csfb_type = user_params["csfb_type"]
except KeyError:
csfb_type = CsfbType.CSFB_TYPE_REDIRECTION
return csfb_type
def set_post_sim_params(anritsu_handle, user_params, sim_card):
if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
anritsu_handle.send_command("PDNCHECKAPN 1,h2g2")
anritsu_handle.send_command("PDNCHECKAPN 2,n.nv.ispsn")
anritsu_handle.send_command("PDNCHECKAPN 3,fast.t-mobile.com")
anritsu_handle.send_command("PDNCHECKAPN 4,ims")
anritsu_handle.send_command("PDNCHECKAPN 5,*")
anritsu_handle.send_command("PDNIMS 1,DISABLE")
anritsu_handle.send_command("PDNIMS 2,DISABLE")
anritsu_handle.send_command("PDNIMS 3,DISABLE")
anritsu_handle.send_command("PDNIMS 4,ENABLE")
anritsu_handle.send_command("PDNVNID 4,1")
anritsu_handle.send_command("PDNIMS 5,ENABLE")
anritsu_handle.send_command("PDNVNID 5,2")
if sim_card == P0135Ax:
anritsu_handle.send_command("PDNCHECKAPN 1,ims")
anritsu_handle.send_command("PDNCHECKAPN 2,fast.t-mobile.com")
anritsu_handle.send_command("PDNIMS 1,ENABLE")
anritsu_handle.send_command("PDNVNID 1,1")
anritsu_handle.send_command("PDNIMS 2,ENABLE")
anritsu_handle.send_command("PDNIMS 3,ENABLE")
anritsu_handle.send_command("PDNVNID 3,1")
if sim_card == VzW12349:
anritsu_handle.send_command("PDNCHECKAPN 1,IMS")
anritsu_handle.send_command("PDNCHECKAPN 2,VZWINTERNET")
anritsu_handle.send_command("PDNIMS 1,ENABLE")
anritsu_handle.send_command("PDNVNID 1,1")
anritsu_handle.send_command("PDNIMS 3,ENABLE")
anritsu_handle.send_command("PDNVNID 3,1")