blob: 8defe4718ef9fbc71a06956ca4eecca459148cc6 [file] [log] [blame]
# Copyright 2017 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.
# TODO(stimim): use DUT API
"""A factory test for ambient light sensor.
Tests that ambient light sensor reacts to both darkening by covering with
finger as well as brightening by shining with flashlight.
Test Procedure
When the test starts, all subtests will be listed on the screen. Operator
needs to press ``SPACE`` to start subtests.
After ``SPACE`` is pressed, the first subtest will become ``ACTIVE`` and
operator should follow the instruction shown on the screen, e.g. "Cover light
sensor with finger". The pytest will keep polling light sensor value, as soon
as the value meets the requirement, the subtest will be marked as ``PASSED``
and next subtest will become ``ACTIVE`` When all subtests are ``PASSED`` the
test will pass and stop.
The pytest requires ALS driver to expose sensor value as a file under sysfs. By
default, the pytest finds the sensor value file with path
Minimum runnable example::
"pytest_name": "light_sensor"
This will read ALS value from ``/sys/bus/iio/devices/*/illuminance0_raw``.
There will be 3 subtests,
1. ``'Light sensor dark'`` (belaw 4)
2. ``'Light sensor exact'`` (between 10 and 15)
3. ``'Light sensor light'`` (above 200)
Unfortunately, in most of the case, this does not work for you, because
* the exposed sysfs file has different name
* scale of the sensor value is different
For example, the arguments for your board might be::
"pytest_name": "light_sensor",
"args": {
"subtest_list": [
"Light sensor dark",
"Light sensor exact",
"Light sensor light"
"subtest_cfg": {
"Light sensor exact": {
"between": [60, 300]
"Light sensor light": {
"above": 500
"Light sensor dark": {
"below": 30
"device_input": "in_illuminance_raw",
"subtest_instruction": {
"Light sensor exact": "i18n! Remove finger from light sensor",
"Light sensor light": "i18n! Shine light sensor with flashlight",
"Light sensor dark": "i18n! Cover light sensor with finger"
Note that you have to specify ``subtest_list``, ``subtests_instruction``,
``subtest_cfg`` at the same time.
from __future__ import print_function
import glob
import logging
import math
import os
import time
import factory_common # pylint: disable=unused-import
from cros.factory.test.i18n import _
from cros.factory.test import test_case
from cros.factory.test import test_ui
from cros.factory.testlog import testlog
from cros.factory.utils.arg_utils import Arg
from cros.factory.utils import process_utils
_DEFAULT_SUBTEST_LIST = ['Light sensor dark',
'Light sensor exact',
'Light sensor light']
_DEFAULT_SUBTEST_CFG = {'Light sensor dark': {'below': 4},
'Light sensor exact': {'between': (10, 15)},
'Light sensor light': {'above': 200}}
'Light sensor dark': _('Cover light sensor with finger'),
'Light sensor exact': _('Remove finger from light sensor'),
'Light sensor light': _('Shine light sensor with flashlight')}
_DEFAULT_DEVICE_PATH = '/sys/bus/iio/devices/*/'
_DEFAULT_DEVICE_INPUT = 'illuminance0_raw'
class iio_generic(object):
"""Object to interface to ambient light sensor over iio.
self._rd : the device file path
self._init_cmd : command to initial device file
self._min : minimum value of device output
self._max : maximum value of device output
self._mindelay : delay between each read action
def __init__(self, device_path, device_input, range_value, init_cmd):
"""Initial light sensor object.
device_path: light sensor device path
device_input: file exports light sensor value
range_value: reference device_path/range_available file to
set one of valid value (1000, 4000, 16000, 64000).
None means no value is set.
init_cmd: initial command to setup light sensor device
if device_path is None:
device_path = _DEFAULT_DEVICE_PATH
if '*' in device_path:
# use glob to find correct path
matches = glob.glob(os.path.join(device_path, device_input))
assert matches, 'Cannot find any light sensor'
assert len(matches) == 1, 'More than one light sensor found'
device_path = os.path.dirname(matches[0])
# initial values
self._rd = os.path.join(device_path, device_input)
self._range_setting = os.path.join(device_path, 'range')
self._init_cmd = init_cmd
self._min = 0
self._max = math.pow(2, 16)
self._mindelay = 0.178
if not os.path.isfile(self._rd):
if range_value is not None:
if range_value not in (1000, 4000, 16000, 64000):
raise ValueError('Range value is invalid: %d' % range_value)
with open(self._range_setting, 'w') as f:
f.write('%d\n' % range_value)
ambient = self.Read('mean', delay=0, samples=10)'ambient light sensor = %d', ambient)
def Config(self):
"""Creates device node if device does not exist."""
if self._init_cmd:
process_utils.Spawn(self._init_cmd, check_call=True)
if not os.path.isfile(self._rd):
raise ValueError('Cannot create %s' % self._rd)
val = self.Read('first', samples=1)
if val <= self._min or val >= self._max:
raise ValueError('Failed initial read')
def Read(self, param, delay=None, samples=1):
"""Reads the light sensor and return value based on param
param: string describing type of value to return. Valid
strings are 'mean' | 'min' | 'max' | 'raw' | 'first'
delay: delay between samples in seconds. 0 means as fast as possible
samples: total samples to read. O means infinite
The value of light sensor
ValueError if param is invalid.
count = 0
buffers = []
if delay is None:
delay = self._mindelay
while True:
with open(self._rd, 'r') as f:
value = int(f.readline().rstrip())
except IOError:
count += 1
if count == samples:
if param == 'mean':
return sum(buffers) / len(buffers)
elif param == 'max':
return max(buffers)
elif param == 'min':
return min(buffers)
elif param == 'raw':
return buffers
elif param == 'first':
return buffers[0]
raise ValueError('Illegal value %s for type' % type)
class LightSensorTest(test_case.TestCase):
"""Tests light sensor."""
ARGS = [
Arg('device_path', str, 'device path', default=None),
Arg('device_input', str, 'device input file',
Arg('timeout_per_subtest', int, 'timeout for each subtest', default=10),
Arg('subtest_list', list, 'subtest list', default=None),
Arg('subtest_cfg', dict, 'subtest configuration', default=None),
Arg('subtest_instruction', dict, 'subtest instruction', default=None),
Arg('check_per_subtest', int, 'check times for each subtest', default=3),
Arg('init_command', list, 'Setup device command', default=None),
# Special parameter for ISL 29018 light sensor
Arg('range_value', int, 'one of value (1000, 4000, 16000, 64000)',
def setUp(self):
self._als = iio_generic(self.args.device_path, self.args.device_input,
self.args.range_value, self.args.init_command)
subtest_args = [
self.args.subtest_list, self.args.subtest_cfg,
if all(subtest_args):
self._subtest_list = self.args.subtest_list
self._subtest_cfg = self.args.subtest_cfg
self._subtest_instruction = self.args.subtest_instruction
elif any(subtest_args):
raise ValueError(
'Missing some of subtest_list, subtest_cfg or subtest_instruction.')
self._subtest_list = _DEFAULT_SUBTEST_LIST
self._subtest_cfg = _DEFAULT_SUBTEST_CFG
self._subtest_instruction = _DEFAULT_SUBTEST_INSTRUCTION
self._timeout_per_subtest = self.args.timeout_per_subtest
self._iter_req_per_subtest = self.args.check_per_subtest
for test_idx, name in enumerate(self._subtest_list):
instruction = self._subtest_instruction[name]
desc = '%s (%s)' % (
name, self.GetConfigDescription(self._subtest_cfg[name]))
html = [
'<div class="task">',
'<div id="title{idx}">'.format(idx=test_idx), instruction, '</div>'
'<div class="desc-row">',
'<div id="desc{idx}" class="desc">'.format(idx=test_idx),
test_ui.Escape(desc), '</div>'
'<div id="result{idx}" class="result">UNTESTED</div>'.format(
'</div>', '</div>'
self.ui.SetHTML(html, id='tasks', append=True)
# Group checker and details for Testlog.
self._group_checker = testlog.GroupParam(
'light', ['name', 'elapsed', 'light'])
testlog.UpdateParam('name', param_type=testlog.PARAM_TYPE.argument)
testlog.UpdateParam('light', description=('Light sensor values over time'))
testlog.UpdateParam('elapsed', value_unit='seconds')
def GetConfigDescription(self, cfg):
if 'above' in cfg:
return 'Input > %d' % cfg['above']
elif 'below' in cfg:
return 'Input < %d' % cfg['below']
elif 'between' in cfg:
return '%d < Input < %d' % tuple(cfg['between'])
raise ValueError('Unknown type in subtest configuration')
def runTest(self):
self._timeout_per_subtest * len(self._subtest_list))
for idx, name in enumerate(self._subtest_list):
self.ui.SetHTML('ACTIVE', id='result%d' % idx)
current_iter_remained = self._iter_req_per_subtest
cumulative_val = 0
start_time = time.time()
while True:
val = self._als.Read('mean', samples=5, delay=0)
self.ui.SetHTML('Input: %d' % val, id='input')
cfg = self._subtest_cfg[name]
passed = False
with self._group_checker:
testlog.LogParam('name', name)
testlog.LogParam('elapsed', time.time() - start_time)
if 'above' in cfg:
passed = testlog.CheckNumericParam('light', val, min=cfg['above'])'%s checking "above" %d > %d',
'PASSED' if passed else 'FAILED',
val, cfg['above'])
elif 'below' in cfg:
passed = testlog.CheckNumericParam('light', val, max=cfg['below'])'%s checking "below" %d < %d',
'PASSED' if passed else 'FAILED',
val, cfg['below'])
elif 'between' in cfg:
lb, ub = cfg['between']
passed = testlog.CheckNumericParam('light', val, min=lb, max=ub)'%s checking "between" %d < %d < %d',
'PASSED' if passed else 'FAILED',
lb, val, ub)
else:'subtest_cfg doesn\'t have "above", "below" or "between"')
if passed:
cumulative_val += val
current_iter_remained -= 1
if not current_iter_remained:
self.ui.SetHTML('PASSED', id='result%d' % idx)
mean_val = cumulative_val / self._iter_req_per_subtest'Passed subtest "%s" with mean value %d.', name,
if current_iter_remained != self._iter_req_per_subtest:'Resetting iter count.')
cumulative_val = 0
current_iter_remained = self._iter_req_per_subtest