def set_up(self):
"""
Charge the board to match the start capacity.
"""
# Call the UseCaseBase Setup function
EmUsecaseBase.set_up(self)
# check battery state is in expected value
if self.__expected_batt_state not in [
"CHARGING", "DISCHARGING", "NOT CHARGING", "FULL"
]:
tmp_txt = "unknown EXPECTED_BATT_STATE value : %s" % \
str(self.__expected_batt_state)
self._logger.error(tmp_txt)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER,
tmp_txt)
if self.__multimedia_type in ["AUDIO", "VIDEO"]:
self.__multimedia_type = self.__multimedia_type.capitalize()
self.__multimedia_api = self._device.get_uecmd(
self.__multimedia_type)
elif self.__multimedia_type != "NONE":
tmp_txt = "unknown multimedia type: %s" % \
str(self.__multimedia_api)
self._logger.error(tmp_txt)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER,
tmp_txt)
# init capacity
self.update_battery_info()
self._em_targets = self._target_file.parse_energy_management_targets(
"LAB_EM_BATT_MAINTENANCE_CHARGING",
self._tc_parameters.get_params_as_dict(),
self._device.get_phone_model())
# load targets in order to measure iteration
self._em_meas_verdict.load_target(self._em_targets)
# update battery temperature expected depending of TCT
if self.tc_module is not None:
if self._em_targets[
"THERMAL_MSIC_REGISTER_MAINTENANCE.BATTERY.TEMP"] is not None:
EMUtil.update_conf(
self._em_targets[
"THERMAL_MSIC_REGISTER_MAINTENANCE.BATTERY.TEMP"],
["lo_lim", "hi_lim"], self._tct, "*")
# Charge battery
self.em_core_module.monitor_charging(
self.em_core_module.batt_max_capacity,
self.em_core_module.charge_time, self.__em_meas_tab)
return Global.SUCCESS, "No errors"
def set_up(self):
"""
Initialize the test
"""
# Call the UseCaseBase Setup function
EmUsecaseBase.set_up(self)
# set usb charging on
self.em_api.set_usb_charging("on")
# init capacity
msic = self.update_battery_info()
# get capability targets
self._em_targets = self._target_file.parse_energy_management_targets(
"LAB_EM_BATT_OFF_ON_NO_VC",
self._tc_parameters.get_params_as_dict(),
self._device.get_phone_model())
# load targets in order to measure iteration
self._em_meas_verdict.load_target(self._em_targets)
# init verdict value
if self._em_targets[
"MSIC_REGISTER_PLUG.BATTERY.CHARGE_NOW"] is not None:
EMUtil.update_conf(
self._em_targets["MSIC_REGISTER_PLUG.BATTERY.CHARGE_NOW"],
"hi_lim", msic["BATTERY"]["CHARGE_FULL_DESIGN"][0], "=")
if self.tc_module is not None:
if self._em_targets[
"THERMAL_MSIC_REGISTER_PLUG.BATTERY.TEMP"] is not None:
EMUtil.update_conf(
self.
_em_targets["THERMAL_MSIC_REGISTER_PLUG.BATTERY.TEMP"],
["lo_lim", "hi_lim"], self._tct, "*")
# Charge battery
self.em_core_module.monitor_charging(
self.em_core_module.batt_max_capacity,
self.em_core_module.charge_time, self.__em_meas_tab)
return Global.SUCCESS, "No errors"
def set_up(self):
"""
Initialize the test
"""
# Call the UseCaseBase Setup function
EmUsecaseBase.set_up(self)
# set usb charging on
self.em_api.set_usb_charging("on")
# Configure CMU
# Connect to cellular network simulator
self._ns.init()
# check that channel is allow for this band
self._conversion_toolbox.convert_wcdma_channelscript_to_array(
self._cell_band,
self._ul_uarfcn)
# Perform Full Preset
self._ns.perform_full_preset()
# Set cell band using CELL_BAND parameter
self._ns_3g.set_band("BAND" + self._cell_band)
# Set cell off
self._ns_3g.set_cell_off()
# Set Traffic Channel Arfcn using TCH_ARFCN parameter
self._ns_3g.set_uplink_arfcn(self._ul_uarfcn)
# Set mobile power using MOBILE_POWER parameter
self._ns_3g.set_ms_power(self._mobile_power)
# Set cell power using CELL_POWER parameter
self._ns_3g.set_cell_power(self._cell_power)
# init capacity
msic = self.update_battery_info()
# get capability targets
self._em_targets = self._target_file.parse_energy_management_targets(
"LAB_EM_BATT_OFF_ON_VC_3G", self._tc_parameters.get_params_as_dict(),
self._device.get_phone_model())
# load targets in order to measure iteration
self._em_meas_verdict.load_target(self._em_targets)
# init verdict value
if self._em_targets["MSIC_REGISTER_PLUG.BATTERY.CHARGE_NOW"] is not None:
EMUtil.update_conf(
self._em_targets["MSIC_REGISTER_PLUG.BATTERY.CHARGE_NOW"],
"hi_lim", msic["BATTERY"]["CHARGE_FULL_DESIGN"][0], "=")
# init verdict value
if self.tc_module is not None:
if self._em_targets["THERMAL_MSIC_REGISTER_PLUG.BATTERY.TEMP"] is None:
EMUtil.update_conf(
self._em_targets["THERMAL_MSIC_REGISTER_PLUG.BATTERY.TEMP"],
["lo_lim", "hi_lim"], self._tct, "*")
# Charge battery
self.em_core_module.monitor_charging(self.em_core_module.batt_max_capacity, self.em_core_module.charge_time,
self.__em_meas_tab)
# set CMU cell phone ON
self._ns_3g.set_cell_on()
# register phone
RegUtil.check_dut_registration_before_timeout(self._ns_3g,
self.networking_api,
self._logger,
None,
self._registration_timeout)
# Check registration status on DUT
self.modem_api.check_cdk_registration_bfor_timeout(
self._registration_timeout)
return Global.SUCCESS, "No errors"
def run_test_body(self):
EmUsecaseBase.run_test_body(self)
# configure the board to discharge quicker
self._logger.info("Start to discharge battery until %s%%" %
self.em_core_module.batt_min_capacity)
# stop charging through usb
self.em_api.set_usb_charging("off")
# launch uecmd to help the discharge
self.phonesystem_api.set_screen_timeout(3600)
# deactivate set auto brightness
self.phonesystem_api.set_brightness_mode("manual")
# set display brightness to max value
self.phonesystem_api.set_display_brightness(100)
self.phonesystem_api.set_phone_lock(0)
# reinitialize consecutive error
measurement_fail = 0
self.phone_as_reboot = False
# discharge loop
self._logger.info("Start to discharge battery until %s%%" %
self.em_core_module.batt_min_capacity)
while self.batt_capacity > self.em_core_module.batt_min_capacity:
# update total test value
self._total_test += 1
self._logger.info("TEST iteration_%s" % str(self._total_test))
batt_charge_Low = "FAILED_TO_COMPUTE"
batt_charge_High = "FAILED_TO_COMPUTE"
try:
# get msic registers value after booting
msic_reg = self.update_battery_info()
msic_batt = msic_reg["BATTERY"]
batt_charge_Low = msic_batt["CHARGE_NOW"][0] - \
5 * msic_batt["CURRENT_NOW"][0]
batt_charge_High = msic_batt["CHARGE_NOW"][0] + \
5 * msic_batt["CURRENT_NOW"][0]
if self._em_targets[
"MSIC_REGISTER_UNPLUG.BATTERY.CHARGE_NOW"] is not None:
EMUtil.update_conf(
self.
_em_targets["MSIC_REGISTER_UNPLUG.BATTERY.CHARGE_NOW"],
["lo_lim"], batt_charge_Low, "=")
EMUtil.update_conf(
self.
_em_targets["MSIC_REGISTER_UNPLUG.BATTERY.CHARGE_NOW"],
["hi_lim"], batt_charge_High, "=")
thermal_conf = self.em_api.get_thermal_sensor_info()
# store result on xml
self.__em_meas_tab.add_dict_measurement(msic_reg)
self.__em_meas_tab.add_dict_measurement(thermal_conf)
# check thermal capabilities only if thermal chamber is used
if self.tc_module is not None:
# Store various information
self.__em_meas_tab.add_measurement(
[self.tc_module.feed_meas_report()])
self._meas_list.add_dict("THERMAL_MSIC_REGISTER_PLUG",
msic_reg)
self._meas_list.add_dict("THERMAL_CONF_PLUG", thermal_conf)
# get the call state
call_state = "BAND" + self._cell_band
# Check cs call state
call_state += "_CS_CALL_" + str(self.voicecall_api.get_state())
# Store various information
self.__em_meas_tab.add_measurement([
("REGISTRATION",
self.modem_api.get_network_registration_status()),
("VOICE_CALL", call_state)
])
except AcsBaseException as e:
# try to reconnect to the board if uecmd failed
self._logger.error(
"fail to get measurement for OFF ON cycle SDP PLUG TEST: %s"
% str(e))
measurement_fail += 0.5
finally:
# Store various information
self.__em_meas_tab.add_measurement([
self.get_time_tuple(),
("COMMENTS", "OFF ON cycle SDP PLUG TEST")
])
# switch to next meas
self.__em_meas_tab.switch_to_next_meas()
#------------------------------------------------------------------------------------------
try:
# start charging through usb
self.em_api.set_usb_charging("on")
# schedule commands
if self._device.get_state() == "alive":
pid = self.em_api.get_msic_registers("scheduled", 15)
thermal_pid = self.em_api.get_thermal_sensor_info(
"scheduled", 15)
# Charge board
self.em_core_module.charge_battery(20)
# read msic result
msic_reg = self.em_api.get_msic_registers("read", pid)
# stop charging through usb
self.em_api.set_usb_charging("off")
msic_batt = msic_reg["BATTERY"]
self.batt_capacity = msic_batt["CAPACITY"][0]
self.batt_voltage = msic_batt["VOLTAGE"][0]
# get thermal information
thermal_conf = self.em_api.get_thermal_sensor_info(
"read", thermal_pid)
# create XML files
self.__em_meas_tab.add_dict_measurement(msic_reg)
self.__em_meas_tab.add_dict_measurement(thermal_conf)
# compute verdict
self._meas_list.add_dict("MSIC_REGISTER_UNPLUG", msic_reg)
# get the call state
call_state = "BAND" + self._cell_band
# Check cs call state
call_state += "_CS_CALL_" + str(self.voicecall_api.get_state())
self.__em_meas_tab.add_measurement([
("REGISTRATION",
self.modem_api.get_network_registration_status()),
("VOICE_CALL", call_state)
])
# clean scheduled task
self.phonesystem_api.clean_daemon_files()
measurement_fail = 0
except AcsBaseException as e:
# try to reconnect to the board if uecmd failed
self._logger.error(
"fail to get measurement for OFF ON cycle SDP UNPLUG TEST:"
+ str(e))
measurement_fail += 0.5
# stop the usecase if measurement fail several times.
if measurement_fail >= self._consecutive_meas_error:
tmp_txt = "Measurement failed after %s times, stop usecase" % \
self._consecutive_meas_error
self._logger.error(tmp_txt)
if self.batt_voltage > self.vbatt_mos_shutdown or self.batt_voltage == -1:
raise DeviceException(
DeviceException.PROHIBITIVE_MEASURE, tmp_txt)
else:
self._logger.info(
"battery must be empty, stop usecase")
break
# check the board connection
self.em_core_module.check_board_connection()
finally:
self.__em_meas_tab.add_measurement([
self.get_time_tuple(),
("COMMENTS", "OFF ON cycle CABLE UNPLUG TEST"),
("REBOOT", self.phone_as_reboot)
])
# generate em verdict
self._em_meas_verdict.compare_list(self._meas_list,
self._em_targets)
self._em_meas_verdict.judge(ignore_blocked_tc=True)
self._meas_list.clean()
# switch to next meas
self.__em_meas_tab.switch_to_next_meas()
# restart uecmds to help the discharge if phone as reboot
if self.has_board_reboot():
self.phonesystem_api.set_phone_lock(0)
# stop charging through usb
self.em_api.set_usb_charging("off")
# establish a call
self.voicecall_api.dial("OOOO12121121")
self.phone_as_reboot = False
self._logger.info("waiting board discharge during %s seconds" %
self.em_core_module.discharge_time)
time.sleep(self.em_core_module.discharge_time)
return (self._em_meas_verdict.get_global_result(),
self._em_meas_verdict.save_data_report_file())
def set_up(self):
"""
Initialize the test
"""
# Call the UseCaseBase Setup function
EmUsecaseBase.set_up(self)
# set usb charging on
self.em_api.set_usb_charging("on")
# Configure CMU
# Connect to cellular network simulator
self._ns.init()
# Perform Full Preset
self._ns.perform_full_preset()
# Set cell band using CELL_BAND parameter
self._ns_2g.set_band(self._cell_band)
# Set cell off
self._ns_2g.set_cell_off()
# Set cell service using CELL_SERVICE parameter
self._ns_2g.set_cell_service(self._cell_service)
# Set Traffic Channel Arfcn using TCH_ARFCN parameter
self._ns_2g.set_tch_arfcn(self._tch_arfcn)
# Set cell power using CELL_POWER parameter
self._ns_2g.set_cell_power(self._cell_power)
# set data uplink channel
self._data_2g.set_data_channel(self._uplink_channel)
# configure cellular network burst slots
self._slots_conf = self.em_core_module.configure_slot()
# Set main timeslot to 3 and set slot configs
self._data_2g.set_custom_multislot_config(3,
self._slots_conf["DL_STATE"],
self._slots_conf["DL_VALUE"],
self._slots_conf["UL_STATE"],
self._slots_conf["UL_VALUE"])
# init capacity
msic = self.update_battery_info()
# get capability targets
self._em_targets = self._target_file.parse_energy_management_targets(
"LAB_EM_BATT_OFF_ON_VC_2G",
self._tc_parameters.get_params_as_dict(),
self._device.get_phone_model())
# load targets in order to measure iteration
self._em_meas_verdict.load_target(self._em_targets)
# init verdict value
if self._em_targets[
"MSIC_REGISTER_PLUG.BATTERY.CHARGE_NOW"] is not None:
EMUtil.update_conf(
self._em_targets["MSIC_REGISTER_PLUG.BATTERY.CHARGE_NOW"],
"hi_lim", msic["BATTERY"]["CHARGE_FULL_DESIGN"][0], "=")
# init verdict value
if self.tc_module is not None:
if self._em_targets[
"THERMAL_MSIC_REGISTER_PLUG.BATTERY.TEMP"] is not None:
EMUtil.update_conf(
self.
_em_targets["THERMAL_MSIC_REGISTER_PLUG.BATTERY.TEMP"],
["lo_lim", "hi_lim"], self._tct, "*")
# Charge battery
self.em_core_module.monitor_charging(
self.em_core_module.batt_max_capacity,
self.em_core_module.charge_time, self.__em_meas_tab)
# set CMU cell phone ON
self._data_2g.set_data_cell_on()
# register phone
self._data_2g.data_register_dut(None, self._registration_timeout)
# Check registration status on DUT
self.modem_api.check_cdk_registration_bfor_timeout(
self._registration_timeout)
return Global.SUCCESS, "No errors"
def set_up(self):
"""
Initialize the test
"""
# Call the UseCaseBase Setup function
EmUsecaseBase.set_up(self)
# set usb charging on
self.em_api.set_usb_charging("on")
# Check LOAD option
if self._load not in ["LIGHT", "MEDIUM", "HEAVY"]:
tmp_txt = "unknown LOAD option value :" + str(self._load)
self._logger.error(tmp_txt)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER,
tmp_txt)
if self._load in ["HEAVY", "MEDIUM"]:
# Configure CMU
# Connect to cellular network simulator
self._ns.init()
# Perform Full Preset
self._ns.perform_full_preset()
# Set cell band using CELL_BAND parameter
self._ns_2g.set_band(self._cell_band)
# Set cell off
self._ns_2g.set_cell_off()
# Set cell service using CELL_SERVICE parameter
self._ns_2g.set_cell_service(self._cell_service)
# Set Traffic Channel Arfcn using TCH_ARFCN parameter
self._ns_2g.set_tch_arfcn(self._tch_arfcn)
# Set cell power using CELL_POWER parameter
self._ns_2g.set_cell_power(self._cell_power)
# set data uplink channel
self._data_2g.set_data_channel(self._uplink_channel)
# configure cellular network burst slots
self._slots_conf = self.em_core_module.configure_slot()
# Set main timeslot to 3 and set slot configs
self._data_2g.set_custom_multislot_config(
3, self._slots_conf["DL_STATE"], self._slots_conf["DL_VALUE"],
self._slots_conf["UL_STATE"], self._slots_conf["UL_VALUE"])
if self._load in ["HEAVY"]:
# Check initialization and raise exception if something went wrong
if not self._is_router_name_found:
msg = "No Wifi router has been specified by the user"
raise AcsConfigException(
AcsConfigException.INVALID_BENCH_CONFIG, msg)
if not self._is_router_found:
msg = "router name" + self._wifi_router_name + "is missing"
raise AcsConfigException(
AcsConfigException.INVALID_BENCH_CONFIG, msg)
if self._ssid == "":
msg = str(self._ssid) + ": wifi ssid is missing"
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER,
msg)
if self._standard is None:
# unknown wifi security
if self._standard_read == "":
msg = "wifi standard is missing"
else:
msg = self._standard_read \
+ ":Unknown wifi standard is missing"
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER,
msg)
if self._security is None:
# unknown wifi security
if self._security_read == "":
msg = "missing wifi security"
else:
msg = self._security_read + ": unknown wifi security"
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER,
msg)
if (self._security in ("WEP", "WPA", "WPA2")
and self._passphrase in ("", None)):
msg = "Passphrase %s is missing in bench configuration file"
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER,
msg)
# check keys on dict to avoid reading empty files
msic = self.update_battery_info()
self._em_targets = self._target_file.parse_energy_management_targets(
"LAB_EM_BATT_VBATT_LOAD", self._tc_parameters.get_params_as_dict(),
self._device.get_phone_model())
# load targets in order to measure iteration
self._em_meas_verdict.load_target(self._em_targets)
# update charger full design value
if self._em_targets[
"MSIC_REGISTER_STRESS.BATTERY.CHARGE_NOW"] is not None:
EMUtil.update_conf(
self._em_targets["MSIC_REGISTER_STRESS.BATTERY.CHARGE_NOW"],
"hi_lim", msic["BATTERY"]["CHARGE_FULL_DESIGN"][0], "=")
if self.tc_module is not None:
# update battery temperature expected depending of TCT
if self._em_targets[
"THERMAL_MSIC_REGISTER_STRESS.BATTERY.TEMP"] is not None:
EMUtil.update_conf(
self.
_em_targets["THERMAL_MSIC_REGISTER_STRESS.BATTERY.TEMP"],
["lo_lim", "hi_lim"], self._tct, "*")
if self._em_targets[
"THERMAL_MSIC_REGISTER_NO_STRESS.BATTERY.TEMP"] is not None:
EMUtil.update_conf(
self._em_targets[
"THERMAL_MSIC_REGISTER_NO_STRESS.BATTERY.TEMP"],
["lo_lim", "hi_lim"], self._tct, "*")
# Charge battery
self.em_core_module.monitor_charging(
self.em_core_module.batt_max_capacity,
self.em_core_module.charge_time, self.__em_meas_tab)
if self._load in ["HEAVY", "MEDIUM"]:
# set CMU cell phone ON
self._data_2g.set_data_cell_on()
# launch uecmd to help the discharge
self.phonesystem_api.set_screen_timeout(3600)
# deactivate set auto brightness
self.phonesystem_api.set_brightness_mode("manual")
# set display brightness to max value
self.phonesystem_api.set_display_brightness(100)
if self._load in ["HEAVY"]:
# setup wifi connection
self.__setup_wifi()
# connect wifi
self.networking_api.\
wifi_connect(self._ssid)
if self._load in ["HEAVY", "MEDIUM"]:
# register phone
self._data_2g.data_register_dut(None, self._registration_timeout)
# reset consecutive error
self.measurement_fail = 0
return Global.SUCCESS, "No errors"