# Lint as: python2, python3 # Copyright (c) 2010 The Chromium OS Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. import logging, time from autotest_lib.client.common_lib import error from autotest_lib.client.cros import service_stopper from autotest_lib.client.cros.power import power_status from autotest_lib.client.cros.power import power_test from autotest_lib.client.cros.power import power_utils class power_BatteryCharge(power_test.power_Test): """class power_BatteryCharge.""" version = 1 def initialize(self, pdash_note=''): """Perform necessary initialization prior to test run.""" if not power_utils.has_battery(): raise error.TestNAError('DUT has no battery. Test Skipped') self.status = power_status.get_status() if not self.status.on_ac(): raise error.TestNAError( 'This test needs to be run with the AC power online') super(power_BatteryCharge, self).initialize(seconds_period=20, pdash_note=pdash_note, force_discharge=False) self._services = service_stopper.ServiceStopper( service_stopper.ServiceStopper.POWER_DRAW_SERVICES + ['ui']) self._services.stop_services() def run_once(self, max_run_time=180, percent_charge_to_add=1, percent_initial_charge_max=None, percent_target_charge=None, use_design_charge_capacity=True): """ max_run_time: maximum time the test will run for percent_charge_to_add: percentage of the charge capacity charge to add. The target charge will be capped at the charge capacity. percent_initial_charge_max: maxium allowed initial charge. use_design_charge_capacity: If set, use charge_full_design rather than charge_full for calculations. charge_full represents wear-state of battery, vs charge_full_design representing ideal design state. """ time_to_sleep = 60 self._backlight = power_utils.Backlight() self._backlight.set_percent(0) self.remaining_time = self.max_run_time = max_run_time self.charge_full_design = self.status.battery.charge_full_design self.charge_full = self.status.battery.charge_full if use_design_charge_capacity: self.charge_capacity = self.charge_full_design else: self.charge_capacity = self.charge_full if self.charge_capacity == 0: raise error.TestError('Failed to determine charge capacity') self.initial_charge = self.status.battery.charge_now percent_initial_charge = self.initial_charge * 100 / \ self.charge_capacity if percent_initial_charge_max and percent_initial_charge > \ percent_initial_charge_max: raise error.TestError('Initial charge (%f) higher than max (%f)' % (percent_initial_charge, percent_initial_charge_max)) current_charge = self.initial_charge if percent_target_charge is None: charge_to_add = self.charge_capacity * \ float(percent_charge_to_add) / 100 target_charge = current_charge + charge_to_add else: target_charge = self.charge_capacity * \ float(percent_target_charge) / 100 # trim target_charge if it exceeds charge capacity if target_charge > self.charge_capacity: target_charge = self.charge_capacity logging.info('max_run_time: %d', self.max_run_time) logging.info('initial_charge: %f', self.initial_charge) logging.info('target_charge: %f', target_charge) self.start_measurements() while self.remaining_time and current_charge < target_charge: if time_to_sleep > self.remaining_time: time_to_sleep = self.remaining_time self.remaining_time -= time_to_sleep time.sleep(time_to_sleep) self.status.refresh() new_charge = self.status.battery.charge_now logging.info('time_to_sleep: %d', time_to_sleep) logging.info('charge_added: %f', (new_charge - current_charge)) current_charge = new_charge logging.info('current_charge: %f', current_charge) if self.status.battery.status == 'Full': logging.info('Battery full, aborting!') break elif self.status.battery.status == 'Discharging': # TestError might be raised if |use_design_charge_capacity| # is True when testing with older battery. if current_charge > self.charge_capacity * 0.97: logging.info('Battery full (Discharge on AC), aborting!') else: raise error.TestError('This test needs to be run with the ' 'battery charging on AC.') self._end_time = time.time() def postprocess_iteration(self): """"Collect and log keyvals.""" keyvals = {} keyvals['ah_charge_full'] = self.charge_full keyvals['ah_charge_full_design'] = self.charge_full_design keyvals['ah_charge_capacity'] = self.charge_capacity keyvals['ah_initial_charge'] = self.initial_charge keyvals['ah_final_charge'] = self.status.battery.charge_now s_time_taken = self.max_run_time - self.remaining_time min_time_taken = s_time_taken / 60. keyvals['s_time_taken'] = s_time_taken keyvals['percent_initial_charge'] = self.initial_charge * 100 / \ keyvals['ah_charge_capacity'] keyvals['percent_final_charge'] = keyvals['ah_final_charge'] * 100 / \ keyvals['ah_charge_capacity'] percent_charge_added = keyvals['percent_final_charge'] - \ keyvals['percent_initial_charge'] # Conditionally write charge current keyval only when the amount of # charge added is > 50% to remove samples when test is run but battery # is already mostly full. Otherwise current will be ~0 and not # meaningful. if percent_charge_added > 50: hrs_charging = keyvals['s_time_taken'] / 3600. keyvals['a_avg50_charge_current'] = \ (keyvals['ah_final_charge'] - self.initial_charge) / \ hrs_charging self.keyvals.update(keyvals) self._keyvallogger.add_item('time_to_charge_min', min_time_taken, 'point', 'perf') self._keyvallogger.add_item('initial_charge_ah', self.initial_charge, 'point', 'perf') self._keyvallogger.add_item('final_charge_ah', self.status.battery.charge_now, 'point', 'perf') self._keyvallogger.add_item('charge_full_ah', self.charge_full, 'point', 'perf') self._keyvallogger.add_item('charge_full_design_ah', self.charge_full_design, 'point', 'perf') self._keyvallogger.set_end(self._end_time) super(power_BatteryCharge, self).postprocess_iteration() def cleanup(self): """Restore stop services and backlight level.""" if hasattr(self, '_services') and self._services: self._services.restore_services() if hasattr(self, '_backlight') and self._backlight: self._backlight.restore()