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 __init__(self, tc_name, global_config): """ Constructor """ # Call UseCase base Init function EmUsecaseBase.__init__(self, tc_name, global_config) # Read Band from test case xml file (str) self._cell_band = str(self._tc_parameters.get_param_value("CELL_BAND")) # Read UL_UARFCN from test case xml file self._ul_uarfcn = int(self._tc_parameters.get_param_value("UL_UARFCN")) # Read mobile power from test case xml file (int) self._mobile_power = int(self._tc_parameters.get_param_value("MOBILE_POWER")) # Read CELL_POWER from test case xml file self._cell_power = \ int(self._tc_parameters.get_param_value("CELL_POWER")) # Read REBOOT_MODE from test case xml file self._reboot_mode = str(self._tc_parameters.get_param_value("REBOOT_MODE")) # Init fuel gauging param self.em_core_module.init_fg_param() # Instantiate ConversionToolBox into conv_toolbox object self._conversion_toolbox = get_conversion_toolbox() # Read registrationTimeout from Phone_Catalog.xml self._registration_timeout = \ int(self._dut_config.get("registrationTimeout")) # Create cellular network simulator and retrieve 3g APIs self._ns = self._em.get_cellular_network_simulator("NETWORK_SIMULATOR1") self._ns_3g = self._ns.get_cell_3g() # Initialize EM xml object # measurement file meas_file_name = os.path.join(self._saving_directory, "EM_meas_report.xml") self.__em_meas_tab = EMUtil.XMLMeasurementFile(meas_file_name) # result file ocv_file_name = os.path.join(self._saving_directory, "Energy_Management_result_report.xml") self._em_meas_result = EMUtil.XMLMeasurementFile(ocv_file_name) # enable Global Measurement file name = os.path.join(self._campaign_folder, self._em_cst.GLOBAL_MEAS_FILE) self.__em_meas_tab.enable_global_meas(name, self._name) # init variables self._ocv_list = [] self._network_type = "3G"
def __init__(self, tc_name, global_config): """ Get parameter from xml testcase file """ # Call UseCase base Init function EmUsecaseBase.__init__(self, tc_name, global_config) # init fuel gauging parameters self.em_core_module.init_fg_param() # Read MAINTENANCE_CHARGING_TIMEOUT from test case xml file self.__maintenance_timeout = \ int(self._tc_parameters.get_param_value("MAINTENANCE_CHARGING_TIMEOUT")) # Read EXPECTED_BATTERY_STATE from test case xml file self.__expected_batt_state = \ str(self._tc_parameters.get_param_value( "EXPECTED_BATT_STATE")).upper() # Read DATA_POLLING from test case xml file self.__data_polling = \ int(self._tc_parameters.get_param_value( "DATA_POLLING")) # Read CAPABILITY_TAG from test case xml file self._capability_tag = \ str(self._tc_parameters.get_param_value( "CAPABILITY_TAG")) # Read MULTIMEDIA_TYPE from test case xml file self.__multimedia_type = \ str(self._tc_parameters.get_param_value("MULTIMEDIA_TYPE")).upper() # Get Multimedia Parameters self.__multimedia_file = self._tc_parameters.get_param_value( "MULTIMEDIA_FILE") self.__volume = int(self._tc_parameters.get_param_value("VOLUME")) # Get path to multimedia files self.__multimedia_path = self._device.multimedia_path # Initialize EM xml object # measurement file name = os.path.join(self._saving_directory, "EM_meas_report.xml") self.__em_meas_tab = EMUtil.XMLMeasurementFile(name) # enable Global Measurement file name = os.path.join(self._campaign_folder, self._em_cst.GLOBAL_MEAS_FILE) self.__em_meas_tab.enable_global_meas(name, self._name) # hysteresis file name = os.path.join(self._saving_directory, "EM_hysteresis_report.xml") self.__em_hysteresis_tab = EMUtil.XMLMeasurementFile(name) # init variables self.__multimedia_api = None self._system_api = self._device.get_uecmd("System", True)
def __init__(self, tc_name, global_config): """ Constructor """ # Call UseCase base Init function EmUsecaseBase.__init__(self, tc_name, global_config) # init fuel gauging parameters self.em_core_module.init_fg_param() # Read STAND_DURATION from test case xml file self._stand_mode = \ self._tc_parameters.get_param_value( "STAND_MODE") # Read STANDBY_DURATION from test case xml file self._stand_duration = \ int(self._tc_parameters.get_param_value( "STAND_DURATION")) # Initialize EM xml object # measurement file meas_file_name = os.path.join(self._saving_directory, "EM_meas_report.xml") self.__em_meas_tab = EMUtil.XMLMeasurementFile(meas_file_name) self._em_targets = self._target_file.parse_energy_management_targets( "LAB_EM_BATT_IBATT_STANDBY_MODE", 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) # get network api self._network_api = self._device.get_uecmd("Networking")
def __init__(self, tc_name, global_config): """ Constructor """ # Call UseCase base Init function EmUsecaseBase.__init__(self, tc_name, global_config) # save global config into an attribute in # order to retrieve value in set_up method self.__global_config = global_config # Read OFF_TIMEOUT from test case xml file self._sleep_time = \ int(self._tc_parameters.get_param_value( "OFF_TIMEOUT")) # Initialize EM xml object # measurement file meas_file_name = os.path.join(self._saving_directory, "EM_meas_report.xml") self.__em_meas_tab = EMUtil.XMLMeasurementFile(meas_file_name) # Call ConfigsParser to parse Energy_Management self._em_targets = self._target_file.parse_energy_management_targets( "LAB_EM_BATT_BOOT_COS_MOS", 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 variables self._off_timeout = 300
def __init__(self, tc_name, global_config): """ Get parameter from xml testcase file """ # Call UseCase base Init function EmUsecaseBase.__init__(self, tc_name, global_config) self.em_core_module.init_fg_param() # Read MAINTENANCE_CHARGING_TIMEOUT from test case xml file self.__maintenance_timeout = int( self._tc_parameters.get_param_value( "MAINTENANCE_CHARGING_TIMEOUT")) # Read EXPECTED_BATTERY_STATE from test case xml file self.__expected_batt_state = str( self._tc_parameters.get_param_value( "EXPECTED_BATT_STATE")).upper() # Read DATA_POLLING from test case xml file self.__data_polling = int( self._tc_parameters.get_param_value("DATA_POLLING")) # Read TEMPERATURE from test case xml file self.tc_module = None self.__chamber_tag = "ROOM" self.__temperature = str( self._tc_parameters.get_param_value("TEMPERATURE")) if self.__temperature != "ROOM": # get temperature chamber equipment if not room temperature self.__temperature = int(self.__temperature) self.tc_module = ThermalChamberModule(self.__temperature) # inform module that this is not a default thermal test self.tc_module.set_test_type("SPECIFIC") self.__chamber_tag = self.tc_module.get_chamber_tag() # Read LOAD from test case xml file self.__load = \ str(self._tc_parameters.get_param_value("LOAD")).upper() # Initialize EM xml object # measurement file name = os.path.join(self._saving_directory, "EM_meas_report.xml") self.__em_meas_tab = EMUtil.XMLMeasurementFile(name) # enable Global Measurement file name = os.path.join(self._campaign_folder, self._em_cst.GLOBAL_MEAS_FILE) self.__em_meas_tab.enable_global_meas(name, self._name) # hysteresis file name = os.path.join(self._saving_directory, "EM_hysteresis_report.xml") self.__em_hysteresis_tab = EMUtil.XMLMeasurementFile(name)
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 __init__(self, tc_name, global_config): """ Advanced ON OFF test that also provide action to charge the board """ # Call UseCase base Init function EmUsecaseBase.__init__(self, tc_name, global_config) # init fuel gauging parameters self.em_core_module.init_fg_param() # time to wait to boot self.__boot_timeout = self._tc_parameters.get_param_value( "BOOT_TIMEOUT", self._device.get_boot_timeout(), default_cast_type=int) # time to wait just after the boot action and before wait to successfully boot self.__after_perform_boot_time = self._tc_parameters.get_param_value( "TIME_TO_WAIT_AFTER_JUST_PERFORM_BOOT", 10, default_cast_type=int) # time to wait to shutdown self.__shutdown_timeout = self._tc_parameters.get_param_value( "SHUTDOWN_TIMEOUT", default_cast_type=int) # cable to insert to make board boot self.__cable_type = self._tc_parameters.get_param_value("CABLE_TYPE") self.__keep_cable_during_shutdown = self._tc_parameters.get_param_value( "KEEP_CABLE_DURING_SHUTDOWN", True, default_cast_type=str_to_bool) # cable to insert to make board boot self.__max_iteration = self._tc_parameters.get_param_value( "MAX_ITERATION", default_cast_type=int) # time to wait to shutdown self.__max_fail = self._tc_parameters.get_param_value( "MAX_CONSECUTIVE_FAIL", 0, default_cast_type=int) self.__min_capacity_stop = self._tc_parameters.get_param_value( "MIN_CAPACITY_TO_STOP_TEST", 0, default_cast_type=int) # time to wait to shutdown # Initialize EM xml object # measurement file meas_file_name = os.path.join(self._saving_directory, "EM_meas_report.xml") self.__em_meas_tab = EMUtil.XMLMeasurementFile(meas_file_name) self.__parser_api = self._device.get_uecmd("Aplog", True) self.__fail_boot = 0 self.__pass_boot = 0
def __init__(self, tc_name, global_config): """ Constructor """ # Call Init function EmUsecaseBase.__init__(self, tc_name, global_config) # Read READ_INFO_TIMEOUT from test case xml file self._read_info_timeout = \ int(self._tc_parameters.get_param_value("READ_INFO_TIMEOUT")) # Read CHARGER_TYPE from TC parameters self._charger_type = \ str(self._tc_parameters.get_param_value("CHARGER_TYPE")) # Read all temperatures from TC parameters temperatures = str( self._tc_parameters.get_param_value("TEMPERATURE_CYCLE")) self._em_targets = self._target_file.parse_energy_management_targets( "LAB_EM_BATT_TEMP_MEAS_CYCLE", 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) # get temperature chamber equipment self.tc_module = ThermalChamberModule(self._ambient_temperature) self.tc_module.set_test_type("SPECIFIC") # Initialize EM xml object # measurement file name = os.path.join(self._saving_directory, "EM_meas_report.xml") self.__em_meas_tab = EMUtil.XMLMeasurementFile(name) self._temperature_cycle = [] for temperature in temperatures.split(","): self._temperature_cycle.append(int(temperature))
def __init__(self, tc_name, global_config): """ Constructor """ # Call UseCase base Init function EmUsecaseBase.__init__(self, tc_name, global_config) # Read REBOOT_MODE from test case xml file self._reboot_mode = str( self._tc_parameters.get_param_value("REBOOT_MODE")) # Init fuel gauging param self.em_core_module.init_fg_param() # Initialize EM xml object # measurement file meas_file_name = os.path.join(self._saving_directory, "EM_meas_report.xml") self.__em_meas_tab = EMUtil.XMLMeasurementFile(meas_file_name) # enable Global Measurement file name = os.path.join(self._campaign_folder, self._em_cst.GLOBAL_MEAS_FILE) self.__em_meas_tab.enable_global_meas(name, self._name)
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 __init__(self, tc_name, global_config): """ Constructor """ # Call UseCase base Init function EmUsecaseBase.__init__(self, tc_name, global_config) # save global config into an attribute in # order to retrieve value in set_up method self.__global_config = global_config # Read LOAD from test case xml file self._load = \ str(self._tc_parameters.get_param_value("LOAD")) # Read BATT_MIN_CAPACITY from test case xml file # Init fuel gauging param self.em_core_module.init_fg_param() # Read STRESS_PERIOD from test case xml file self.hard_stress_time = \ int(self._tc_parameters.get_param_value( "STRESS_PERIOD")) # Read NO_STRESS_PERIOD from test case xml file self.soft_stress_time = \ int(self._tc_parameters.get_param_value( "NO_STRESS_PERIOD")) if self._load in ["HEAVY", "MEDIUM"]: # Read Band from test case xml file (str) self._cell_band = str( self._tc_parameters.get_param_value("CELL_BAND")) # Read CELL_SERVICE from test case xml file self._cell_service = \ str(self._tc_parameters.get_param_value("CELL_SERVICE")) # Read TCH_ARFCN from test case xml file self._tch_arfcn = int( self._tc_parameters.get_param_value("TCH_ARFCN")) # Read UPLINK_CHANNEL from test case xml file self._uplink_channel = int( self._tc_parameters.get_param_value("UPLINK_CHANNEL")) # Read CELL_POWER from test case xml file self._cell_power = \ int(self._tc_parameters.get_param_value("CELL_POWER")) # Read registrationTimeout from Phone_Catalog.xml self._registration_timeout = \ int(self._dut_config.get("registrationTimeout")) # Create cellular network simulator and retrieve 2G APIs self._ns = self._em.get_cellular_network_simulator( "NETWORK_SIMULATOR1") self._ns_2g = self._ns.get_cell_2g() self._data_2g = self._ns_2g.get_data() self._test_mode_2g = self._ns_2g.get_test_mode() # Get Multimedia Parameters self._audio_file = self._tc_parameters.get_param_value( "AUDIO_FILE") self._volume = int(self._tc_parameters.get_param_value("VOLUME")) # Get path to multimedia files self._multimedia_path = self._device.multimedia_path # import special api self._audio_api = self._device.get_uecmd("Audio") self._system_api = self._device.get_uecmd("System") if self._load in ["HEAVY"]: # Get FTP server parameters server = self.__global_config.benchConfig.\ get_parameters("WIFI_SERVER") self._ftp_ip_address = server.get_param_value("IP") self._ftp_username = server.get_param_value("username") self._ftp_password = server.get_param_value("password") if server.has_parameter("ftp_path"): self._ftp_path = server.get_param_value("ftp_path") else: self._ftp_path = "" # get file to download info self._dlfilename = os.path.join( self._ftp_path, self._tc_parameters.get_param_value("DL_FILE")) # get wifi parameters self._wifi_router_name = None self._standard = None self._ssid = "" self._standard_read = None self._security = None self._security_read = None self._passphrase = None self._is_router_name_found = True self._is_router_found = False supported_wifi_standard = [ 'a', 'b', 'g', 'n', 'an', 'bg', 'gb', 'bgn', 'ngb', 'n2.4G', 'n5G', 'off' ] bench_config = self.__global_config.benchConfig # Retrieve wifi access point self._wifi_router_name = \ str(self._tc_parameters.get_param_value("WIFI_ACCESS_POINT")) # if wifi router name is not specified, exit if self._wifi_router_name in [None, "", "NONE"]: self._is_router_name_found = False elif (bench_config.has_parameter(self._wifi_router_name) and self.__global_config.benchConfig.get_parameters( self._wifi_router_name) != ""): self._is_router_found = True self._wifirouter = self.__global_config.benchConfig.\ get_parameters(self._wifi_router_name) ssid_read = self._wifirouter.get_param_value("SSID") self._standard_read = self._wifirouter.get_param_value( "standard") self._security_read = self._wifirouter.\ get_param_value("WIFI_SECURITY").upper() if ssid_read != "": self._ssid = ssid_read if self._standard_read in supported_wifi_standard: self._standard = self._standard_read # retrieve wifi router parameters if self._security_read in ("NONE", "OPEN"): self._logger.debug("OPEN" 'Wifi Security type selected,' + 'getting parameters') self._security = self._security_read elif self._security_read in ("WEP", "WPA", "WPA2"): self._security = self._security_read self._logger.debug( str(self._security) + " Wifi Security selected, getting parameters") passphrase = self._wifirouter.get_param_value("passphrase") self._passphrase = passphrase # Initialize EM xml object # measurement file meas_file_name = os.path.join(self._saving_directory, "EM_meas_report.xml") self.__em_meas_tab = EMUtil.XMLMeasurementFile(meas_file_name) # enable Global Measurement file name = os.path.join(self._campaign_folder, self._em_cst.GLOBAL_MEAS_FILE) self.__em_meas_tab.enable_global_meas(name, self._name) # init variables self.__total_test = 0 self._slots_conf = [] self._data_call_mode = "TEST_MODE_B" self.measurement_fail = 0 self._em_targets = None
def __init__(self, tc_name, global_config): """ Constructor """ # Call UseCase base Init function EmUsecaseBase.__init__(self, tc_name, global_config) # Read Band from test case xml file (str) self._cell_band = str(self._tc_parameters.get_param_value("CELL_BAND")) # Read CELL_SERVICE from test case xml file self._cell_service = \ str(self._tc_parameters.get_param_value("CELL_SERVICE")) # Read TCH_ARFCN from test case xml file self._tch_arfcn = int(self._tc_parameters.get_param_value("TCH_ARFCN")) # Read UPLINK_CHANNEL from test case xml file self._uplink_channel = int( self._tc_parameters.get_param_value("UPLINK_CHANNEL")) # Read CELL_POWER from test case xml file self._cell_power = \ int(self._tc_parameters.get_param_value("CELL_POWER")) # Read DATA_CALL from test case xml file self._data_call = str_to_bool( self._tc_parameters.get_param_value("DATA_CALL")) # Read DATA_CALL_MODE from test case xml file self._data_call_mode = str( self._tc_parameters.get_param_value("DATA_CALL_MODE")) # Read REBOOT_MODE from test case xml file self._reboot_mode = str( self._tc_parameters.get_param_value("REBOOT_MODE")) # Init fuel gauging param self.em_core_module.init_fg_param() # Read registrationTimeout from Device_Catalog.xml self._registration_timeout = \ int(self._dut_config.get("registrationTimeout")) # Create cellular network simulator and retrieve 2G APIs self._ns = self._em.get_cellular_network_simulator( "NETWORK_SIMULATOR1") self._ns_2g = self._ns.get_cell_2g() self._data_2g = self._ns_2g.get_data() # Initialize EM xml object # measurement file meas_file_name = os.path.join(self._saving_directory, "EM_meas_report.xml") self.__em_meas_tab = EMUtil.XMLMeasurementFile(meas_file_name) # result file ocv_file_name = os.path.join(self._saving_directory, "Energy_Management_result_report.xml") self._em_meas_result = EMUtil.XMLMeasurementFile(ocv_file_name) # enable Global Measurement file name = os.path.join(self._campaign_folder, self._em_cst.GLOBAL_MEAS_FILE) self.__em_meas_tab.enable_global_meas(name, self._name) # init variables self._ocv_list = [] self._slots_conf = []
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 __init__(self, tc_name, global_config): """ Constructor """ # Call UseCase base Init function UseCaseBase.__init__(self, tc_name, global_config) self._overmind = None # init em stamp self.em_stamp = self._name self._uc_id_logged = False # override IO CARD with a not None type but not implemented type if self._io_card is None: self._io_card = IIOCard() # get em parameter from device catalog here self.phone_info = self._device.get_em_parameters() # feed the overmind self._overmind = OverMind() self._overmind.init(device=self._device, tc_parameters=self._tc_parameters, equipment_manager=self._em, bench_config=global_config.benchConfig, dut_config=self._dut_config) # Get uecmd api self.em_api = self._device.get_uecmd("EnergyManagement") self.phonesystem_api = self._device.get_uecmd("PhoneSystem") self.modem_api = self._device.get_uecmd("Modem") self.voicecall_api = self._device.get_uecmd("VoiceCall") self.networking_api = self._device.get_uecmd("Networking") self.bt_api = self._device.get_uecmd("LocalConnectivity") # init temperature chamber self._tct = self._tc_parameters.get_param_value("TCT", default_cast_type=int) if self._tct is not None: self.tc_module = ThermalChamberModule(self._tct) else: self.tc_module = None # Each raw measurement data & xml files are # stored in a folder bearing the name # of the TC + a time stamp directory_name = self._name + "_" + time.strftime("%Y-%m-%d_%Hh%M.%S") report_tree = global_config.campaignConfig.get("campaignReportTree") self._saving_directory = report_tree.create_subfolder(directory_name) campaign_pass_rate = float( global_config.campaignConfig.get("targetB2bPassRate")) # resume file self._campaign_folder = report_tree.get_report_path() # verdict file self._em_meas_verdict = EMUtil.EMMeasurement(self._saving_directory, campaign_pass_rate) # Call ConfigsParser to parse Energy_Management external_target_path = self._device.get_config("EMExternalTarget") if external_target_path is not None and os.path.exists( external_target_path): # Call ConfigsParser to parse Energy_Management self._logger.info("[EM BASE] External EM target file found : %s" % external_target_path) self._target_file = ConfigsParser(external_target_path, config_folder="") else: # If no external target file , parse default one self._logger.info( "[EM BASE] No external target file found, use default EM target file" ) self._target_file = ConfigsParser("Energy_Management") # Enable ACS secondary reports self._secondary_report = SecondaryTestReport( self._device.get_report_tree().get_report_path()) # init variables # var for robustness self.start_time = time.time() self.__phone_date = "" self._ambient_temperature = 25 self.phone_as_reboot = False self._consecutive_meas_error = 5 # pylint: disable=W0212 # Ignore used of protected member, will be change if a getter is created later self.pwr_btn_boot = self._device._prss_pwr_btn_time_switch_on self.pwr_btn_off = self._device._prss_pw_btn_time_switch_off # INIT PARAMETERS HERE # param related to usecase self._em_cst = EMUtil.EMConstant self._em_targets = None # add usb sleep for avoiding to lost connection during usb recognition self.usb_sleep = self._device._usb_sleep_duration # pylint: disable=w0212 # param related to device self.vbatt_mos_shutdown = self.phone_info["BATTERY"][ "VBATT_MOS_SHUTDOWN"] + 0.1 self.vbatt_mos_boot = self.phone_info["BATTERY"]["VBATT_MOS_BOOT"] + 0.1 # param that are designed to be updated self.batt_capacity = -1 self.batt_voltage = -1 # measurement list where we store measurement inside self._meas_list = EMUtil.MeasurementList() # init core module at the end self.em_core_module = None bench_type = self._tc_parameters.get_param_value( "BENCH_TYPE", self.DEDICATED_BENCH).upper() if bench_type == "POWER_SUPPLY_BENCH": self.em_core_module = UcPowerSupplyModule(self) elif bench_type == "BATTERY_BENCH": self.em_core_module = UcBatteryModule(self) self._logger.info("Loaded EM TEST_SCRIPT configuration for %s" % self.DEDICATED_BENCH) # get the list of TCD to test, it can have several entries # if the parameter is missing or empty ( meaning None) the old verdict system will be used. self.tcd_to_test = self._tc_parameters.get_param_value( EMConstant.TC_PARAMETER_TO_CHECK, "") if type(self.tcd_to_test) is str: self.tcd_to_test = filter(None, self.tcd_to_test.split(";")) self.tcd_to_test = map(str.strip, self.tcd_to_test)
def __init__(self, tc_name, global_config): """ Constructor """ # Call UseCase base Init function EmUsecaseBase.__init__(self, tc_name, global_config) # Read Band from test case xml file (str) self._cell_band = str(self._tc_parameters.get_param_value("CELL_BAND")) # Read CELL_SERVICE from test case xml file self._cell_service = \ str(self._tc_parameters.get_param_value("CELL_SERVICE")) # Read TCH_ARFCN from test case xml file self._tch_arfcn = int(self._tc_parameters.get_param_value("TCH_ARFCN")) # Read UPLINK_CHANNEL from test case xml file self._uplink_channel = int(self._tc_parameters.get_param_value("UPLINK_CHANNEL")) # Read CELL_POWER from test case xml file self._cell_power = \ int(self._tc_parameters.get_param_value("CELL_POWER")) # Read DATA_CALL from test case xml file self._data_call = str_to_bool(self._tc_parameters.get_param_value("DATA_CALL")) # Read DATA_CALL_MODE from test case xml file self._data_call_mode = str(self._tc_parameters.get_param_value("DATA_CALL_MODE")) # Init fuel gauging param self.em_core_module.init_fg_param() # Read registrationTimeout from Phone_Catalog.xml self._registration_timeout = \ int(self._dut_config.get("registrationTimeout")) # Create cellular network simulator and retrieve 2G APIs self._ns = self._em.get_cellular_network_simulator("NETWORK_SIMULATOR1") self._ns_2g = self._ns.get_cell_2g() self._data_2g = self._ns_2g.get_data() self._vc_2g = self._ns_2g.get_voice_call() self._test_mode_2g = self._ns_2g.get_test_mode() # Initialize EM xml object meas_file_name = os.path.join(self._saving_directory, "EM_meas_report.xml") self.__em_meas_tab = EMUtil.XMLMeasurementFile(meas_file_name) # enable Global Measurement file name = os.path.join(self._campaign_folder, self._em_cst.GLOBAL_MEAS_FILE) self.__em_meas_tab.enable_global_meas(name, self._name) # Call ConfigsParser to parse Energy_Management self._em_targets = self._target_file.parse_energy_management_targets( "LAB_EM_BATT_MONITOR_BURST_CTRL", 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 variables self._total_test = 0 self._shutdown_timeout = 60 self._network_type = "2G" self._slots_conf = [] # prepare to launch scheduled test depending of battery capacity # enter test like below (battery_min, battery_max, test id): function_to_call self.scheduled_test = { (65, 81, "1"): self.__ber_test, (12, 19, "2"): self.__ber_test, (1, 5, "3"): self.__ber_test, }
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"