| # Copyright 2013 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. |
| |
| """A factory test to test battery charging/discharging current. |
| |
| Description |
| ----------- |
| Test battery charging and discharging current. |
| |
| If `usbpd_info` is set, also prompt operator to insert a power adapter of given |
| voltage to the given USB type C port. |
| |
| The `usbpd_info` is a sequence `(usbpd_port, min_millivolt, max_millivolt)`, |
| represent the USB type C port to insert power adapter: |
| |
| - ``usbpd_port``: (int) usbpd_port number. Specify which port to insert power |
| line. |
| - ``min_millivolt``: (int) The minimum millivolt the power must provide. |
| - ``max_millivolt``: (int) The maximum millivolt the power must provide. |
| |
| Test Procedure |
| -------------- |
| 1. If `max_battery_level` is set, check that initial battery level is lower |
| than the value. |
| 2. If `usbpd_info` is set, prompt the operator to insert a power adapter of |
| given voltage to the given USB type C port, and pass this step when one is |
| detected. |
| 3. If `min_charging_current` is set, force the power into charging mode, and |
| check if the charging current is larger than the value. |
| 4. If `min_discharging_current` is set, force the power into discharging mode, |
| and check if the discharging current is larger than the value. |
| |
| Each step would fail after `timeout_secs` seconds. |
| |
| Dependency |
| ---------- |
| Device API cros.factory.device.power. |
| |
| If `usbpd_info` is set, device API cros.factory.device.usb_c.GetPDPowerStatus |
| is also used. |
| |
| Examples |
| -------- |
| To check battery can charge and discharge, add this in test list:: |
| |
| { |
| "pytest_name": "battery_current", |
| "args": { |
| "min_charging_current": 250, |
| "min_discharging_current": 400 |
| } |
| } |
| |
| To check that a 15V USB type C power adapter is connected to port 0, add this |
| in test list:: |
| |
| { |
| "pytest_name": "battery_current", |
| "args": { |
| "usbpd_info": [0, 14500, 15500], |
| "usbpd_prompt": "i18n! USB TypeC" |
| } |
| } |
| """ |
| |
| import logging |
| |
| import factory_common # pylint: disable=unused-import |
| from cros.factory.device import device_utils |
| from cros.factory.test.i18n import _ |
| from cros.factory.test.i18n import arg_utils as i18n_arg_utils |
| from cros.factory.test import test_case |
| from cros.factory.utils.arg_utils import Arg |
| from cros.factory.utils import sync_utils |
| |
| |
| def _GetPromptText(current, target): |
| return _( |
| 'Waiting for {target_status} current to meet {target_current} mA.' |
| ' (Currently {status} at {current} mA)', |
| target_status=_('charging') if target >= 0 else _('discharging'), |
| target_current=abs(target), |
| status=_('charging') if current >= 0 else _('discharging'), |
| current=abs(current)) |
| |
| |
| class BatteryCurrentTest(test_case.TestCase): |
| """A factory test to test battery charging/discharging current.""" |
| ARGS = [ |
| Arg('min_charging_current', int, |
| 'minimum allowed charging current', default=None), |
| Arg('min_discharging_current', int, |
| 'minimum allowed discharging current', default=None), |
| Arg('timeout_secs', int, |
| 'Test timeout value', default=10), |
| Arg('max_battery_level', int, |
| 'maximum allowed starting battery level', default=None), |
| Arg('usbpd_info', list, |
| 'A sequence [usbpd_port, min_millivolt, max_millivolt] used to ' |
| 'select a particular port from a multi-port DUT.', |
| default=None), |
| Arg('use_max_voltage', bool, |
| 'Use the negotiated max voltage in `ectool usbpdpower` to check ' |
| 'charger voltage, in case that instant voltage is not supported.', |
| default=False), |
| i18n_arg_utils.I18nArg('usbpd_prompt', |
| 'prompt operator which port to insert', |
| default='') |
| ] |
| |
| def setUp(self): |
| self._dut = device_utils.CreateDUTInterface() |
| self._power = self._dut.power |
| if self.args.usbpd_info: |
| self._CheckUSBPDInfoArg(self.args.usbpd_info) |
| self._usbpd_port = self.args.usbpd_info[0] |
| self._usbpd_min_millivolt = self.args.usbpd_info[1] |
| self._usbpd_max_millivolt = self.args.usbpd_info[2] |
| self._usbpd_prompt = self.args.usbpd_prompt |
| |
| def _CheckUSBPDInfoArg(self, info): |
| if len(info) == 5: |
| check_types = (int, basestring, basestring, int, int) |
| elif len(info) == 3: |
| check_types = (int, int, int) |
| else: |
| raise ValueError('ERROR: invalid usbpd_info item: ' + str(info)) |
| |
| for i in xrange(len(info)): |
| if not isinstance(info[i], check_types[i]): |
| logging.error('(%s)usbpd_info[%d] type is not %s', type(info[i]), i, |
| check_types[i]) |
| raise ValueError('ERROR: invalid usbpd_info[%d]: ' % i + str(info)) |
| |
| def _LogCurrent(self, current): |
| if current >= 0: |
| logging.info('Charging current = %d mA', current) |
| else: |
| logging.info('Discharging current = %d mA', -current) |
| |
| def _CheckUSBPD(self): |
| for unused_i in range(10): |
| status = self._dut.usb_c.GetPDPowerStatus() |
| voltage_field = ('max_millivolt' if self.args.use_max_voltage else |
| 'millivolt') |
| if voltage_field not in status[self._usbpd_port]: |
| self.ui.SetState( |
| _('Insert power to {prompt}({voltage}mV)', |
| prompt=self._usbpd_prompt, |
| voltage=0)) |
| logging.info('No millivolt detected in port %d', self._usbpd_port) |
| return False |
| millivolt = status[self._usbpd_port][voltage_field] |
| logging.info('millivolt %d, acceptable range (%d, %d)', millivolt, |
| self._usbpd_min_millivolt, self._usbpd_max_millivolt) |
| self.ui.SetState( |
| _('Insert power to {prompt}({voltage}mV)', |
| prompt=self._usbpd_prompt, |
| voltage=millivolt)) |
| if not (self._usbpd_min_millivolt <= millivolt <= |
| self._usbpd_max_millivolt): |
| return False |
| self.Sleep(0.1) |
| return True |
| |
| def _CheckCharge(self): |
| current = self._power.GetBatteryCurrent() |
| target = self.args.min_charging_current |
| self._LogCurrent(current) |
| self.ui.SetState(_GetPromptText(current, target)) |
| return current >= target |
| |
| def _CheckDischarge(self): |
| current = self._power.GetBatteryCurrent() |
| target = self.args.min_discharging_current |
| self._LogCurrent(current) |
| self.ui.SetState(_GetPromptText(current, -target)) |
| return -current >= target |
| |
| def runTest(self): |
| """Main entrance of charger test.""" |
| self.assertTrue(self._power.CheckBatteryPresent()) |
| if self.args.max_battery_level: |
| self.assertLessEqual(self._power.GetChargePct(), |
| self.args.max_battery_level, |
| 'Starting battery level too high') |
| if self.args.usbpd_info is not None: |
| sync_utils.PollForCondition( |
| poll_method=self._CheckUSBPD, poll_interval_secs=0.5, |
| condition_name='CheckUSBPD', |
| timeout_secs=self.args.timeout_secs) |
| if self.args.min_charging_current: |
| self._power.SetChargeState(self._power.ChargeState.CHARGE) |
| sync_utils.PollForCondition( |
| poll_method=self._CheckCharge, poll_interval_secs=0.5, |
| condition_name='ChargeCurrent', |
| timeout_secs=self.args.timeout_secs) |
| if self.args.min_discharging_current: |
| self._power.SetChargeState(self._power.ChargeState.DISCHARGE) |
| sync_utils.PollForCondition( |
| poll_method=self._CheckDischarge, poll_interval_secs=0.5, |
| condition_name='DischargeCurrent', |
| timeout_secs=self.args.timeout_secs) |
| |
| def tearDown(self): |
| # Must enable charger to charge or we will drain the battery! |
| self._power.SetChargeState(self._power.ChargeState.CHARGE) |
