| # -*- coding: utf-8 -*- |
| # 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. |
| |
| |
| # DESCRIPTION : factory test of ambient light sensor. Test that ALS reacts to |
| # both darkening by covering w/ finger as well as brightening. |
| # Roughly speaking: |
| # indoor ambient lighting: 20-100 |
| # sunlight direct: 30k-60k |
| # flashlight direct: 5k-10k |
| |
| |
| import gobject |
| import gtk |
| import logging |
| import math |
| import os |
| import sys |
| import time |
| |
| from autotest_lib.client.bin import test |
| from autotest_lib.client.common_lib import error |
| from autotest_lib.client.common_lib import utils |
| from autotest_lib.client.cros import factory_setup_modules |
| from cros.factory.test import factory |
| from cros.factory.test import ui as ful |
| |
| _LABEL_STATUS_SIZE = (140, 30) |
| |
| _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}} |
| _DEFAULT_SUBTEST_INSTRUCTION = { |
| '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/iio:device0/' |
| |
| class iio_generic(): |
| ''' |
| Object to interface to ambient light sensor over iio. |
| ''' |
| PARAMS = {'rd': _DEFAULT_DEVICE_PATH + 'illuminance0_input', |
| 'range_setting': _DEFAULT_DEVICE_PATH + 'range', |
| 'init': '', |
| 'min': 0, |
| 'max': math.pow(2, 16), |
| # in seconds |
| 'mindelay': 0.178, |
| } |
| |
| def __init__(self, device_path, range_value): |
| self.buf = [] |
| self.ambient = None |
| |
| if device_path is not None: |
| self.PARAMS['rd'] = device_path + 'illuminance0_input' |
| self.PARAMS['range_setting'] = device_path + 'range' |
| |
| if not os.path.isfile(self.PARAMS['rd']): |
| self.cfg() |
| |
| if range_value is not None: |
| with open(self.PARAMS['range_setting'], 'w') as f: |
| f.write('%d\n' % range_value) |
| |
| self.ambient = self.read('mean', delay=0, samples=10) |
| factory.log('ambient light sensor = %d' % self.ambient) |
| |
| def cfg(self): |
| cmd = self.PARAMS['init'] |
| utils.system(cmd) |
| time.sleep(1) |
| if not os.path.isfile(self.PARAMS['rd']): |
| raise error.TestError(cmd + ' did not create ' + self.PARAMS['rd']) |
| val = self.read('first', samples=1) |
| if val <= self.PARAMS['min'] or val >= self.PARAMS['max']: |
| raise error.TestError('Failed initial read\n') |
| |
| |
| def read(self, type, delay=None, samples=1): |
| ''' |
| Read the light sensor and return value based on type |
| @parameter type - string describing type of value to return. Valid |
| strings are 'mean' | 'min' | 'max' | 'raw' |
| @parameter delay - delay between samples in seconds. 0 means as fast as |
| possible |
| @parameter samples - total samples to read. O means infinite |
| ''' |
| cnt = 0 |
| self.buf = [] |
| if delay is None: |
| delay = self.PARAMS['mindelay'] |
| while True: |
| fd = open(self.PARAMS['rd']) |
| ln = int(fd.readline().rstrip()) |
| fd.close() |
| self.buf.append(ln) |
| cnt += 1 |
| time.sleep(delay) |
| if cnt == samples: |
| break |
| if type is 'mean': |
| return sum(self.buf) / len(self.buf) |
| elif type is 'max': |
| return max(self.buf) |
| elif type is 'min': |
| return min(self.buf) |
| elif type is 'raw': |
| return self.buf |
| elif type is 'first': |
| return self.buf[0] |
| else: |
| error.ValueError('Illegal value %s for type' % type) |
| |
| |
| class factory_LightSensor(test.test): |
| version = 3 |
| |
| def next_subtest(self): |
| self._tested += 1 |
| if self._tested >= len(self._subtest_list): |
| gtk.main_quit() |
| return False |
| self._active_subtest = self._subtest_list[self._tested] |
| self.update_status(self._active_subtest, ful.ACTIVE) |
| self._status_label[self._active_subtest].queue_draw() |
| self._deadline = time.time() + self._timeout_per_subtest |
| self._current_iter_remained = self._iter_req_per_subtest |
| self._cumulative_val = 0 |
| return True |
| |
| def timer_event(self, countdown_label): |
| time_remaining = max(0, self._deadline - time.time()) |
| if time_remaining is 0: |
| self.update_status(self._active_subtest, ful.FAILED) |
| self._status_label[self._active_subtest].queue_draw() |
| factory.log('Timeout on subtest "%s"' % self._active_subtest) |
| if not self.next_subtest(): |
| return True |
| |
| countdown_label.set_text('%d' % time_remaining) |
| countdown_label.queue_draw() |
| return True |
| |
| def key_release_callback(self, widget, event): |
| if event.keyval == ord('Q'): |
| gtk.main_quit() |
| return True |
| if event.keyval == ord(' ') and not self._started: |
| self._started = True |
| self._active_subtest = self._subtest_list[0] |
| self.update_status(self._active_subtest, ful.ACTIVE) |
| self._status_label[self._active_subtest].queue_draw() |
| self._deadline = time.time() + self._timeout_per_subtest |
| gobject.timeout_add(1000, self.timer_event, self._countdown_label) |
| |
| return True |
| |
| def pass_one_iter(self, name): |
| self._current_iter_remained -= 1 |
| if self._current_iter_remained is 0: |
| self.update_status(name, ful.PASSED) |
| self._status_label[name].queue_draw() |
| self._current_iter_remained = self._iter_req_per_subtest |
| mean_val = self._cumulative_val / self._iter_req_per_subtest |
| factory.log('Passed subtest "%s" with mean value %d.' % |
| (name, mean_val)) |
| if not self.next_subtest(): |
| return |
| |
| def sensor_event(self, sensor_value): |
| val = self._als.read('mean', samples=5, delay=0) |
| |
| if self._started: |
| name = self._active_subtest |
| cfg = self._subtest_cfg[name] |
| passed = 0 |
| if 'above' in cfg: |
| if val > cfg['above']: |
| factory.log('Passed checking "above" %d > %d' % |
| (val, cfg['above'])) |
| passed = 1 |
| elif 'below' in cfg: |
| if val < cfg['below']: |
| factory.log('Passed checking "below" %d < %d' % |
| (val, cfg['below'])) |
| passed = 1 |
| elif 'between' in cfg: |
| lb, ub = cfg['between'] |
| if val > lb and val < ub: |
| factory.log('Passed checking "between" %d < %d < %d' % |
| (lb, val, ub)) |
| passed = 1 |
| if passed is 1: |
| self._cumulative_val += val |
| self.pass_one_iter(name) |
| else: |
| if self._current_iter_remained != self._iter_req_per_subtest: |
| factory.log('Resetting iter count.') |
| self._cumulative_val = 0 |
| self._current_iter_remained = self._iter_req_per_subtest |
| |
| sensor_value.set_text('%d' % val) |
| sensor_value.queue_draw() |
| return True |
| |
| def update_status(self, name, status): |
| self._status_map[name] = status |
| self._label_status[name].set_text(status) |
| self._label_status[name].modify_fg(gtk.STATE_NORMAL, |
| ful.LABEL_COLORS[status]) |
| self._label_status[name].queue_draw() |
| |
| def calc_cfg_description(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' % cfg['between'] |
| else: |
| raise error.ValueError('Unknown type in subtest configuration') |
| |
| def make_subtest_label_box(self, name): |
| eb = gtk.EventBox() |
| eb.modify_bg(gtk.STATE_NORMAL, ful.BLACK) |
| label_status = ful.make_label(ful.UNTESTED, size=_LABEL_STATUS_SIZE, |
| alignment=(0, 0.5), |
| fg=ful.LABEL_COLORS[ful.UNTESTED]) |
| self._label_status[name] = label_status |
| label_desc = ful.make_label(self._subtest_instruction[name], |
| alignment=(0.5, 0.5), fg=ful.WHITE) |
| cfg_desc = self.calc_cfg_description(self._subtest_cfg[name]) |
| label_en = ful.make_label("%s (%s)" % (name, cfg_desc), |
| alignment=(1, 0.5)) |
| label_sep = ful.make_label(' : ', alignment=(0.5, 0.5)) |
| hbox = gtk.HBox() |
| hbox.pack_end(label_status, False, False) |
| hbox.pack_end(label_sep, False, False) |
| hbox.pack_end(label_en, False, False) |
| vbox = gtk.VBox() |
| vbox.pack_start(label_desc, False, False) |
| vbox.pack_start(hbox, False, False) |
| eb.add(vbox) |
| return eb |
| |
| def register_callbacks(self, window): |
| window.connect('key-release-event', self.key_release_callback) |
| window.add_events(gtk.gdk.KEY_RELEASE_MASK) |
| |
| def get_subtest(self, subtest_list, subtest_cfg, subtest_instruction): |
| has_specified = (subtest_list is not None or |
| subtest_cfg is not None or |
| subtest_instruction is not None) |
| all_specified = (subtest_list is not None and |
| subtest_cfg is not None and |
| subtest_instruction is not None) |
| if has_specified and not all_specified: |
| raise error.ValueError('Missing parameters of subtests.') |
| if all_specified: |
| self._subtest_list = subtest_list |
| self._subtest_cfg = subtest_cfg |
| self._subtest_instruction = subtest_instruction |
| else: |
| self._subtest_list = _DEFAULT_SUBTEST_LIST |
| self._subtest_cfg = _DEFAULT_SUBTEST_CFG |
| self._subtest_instruction = _DEFAULT_SUBTEST_INSTRUCTION |
| |
| def run_once(self, |
| device_path=None, |
| timeout_per_subtest=10, |
| subtest_list=None, |
| subtest_cfg=None, |
| subtest_instruction=None, |
| range_value=None): |
| |
| factory.log('%s run_once' % self.__class__) |
| |
| self.get_subtest(subtest_list, subtest_cfg, subtest_instruction) |
| |
| self._als = iio_generic(device_path, range_value) |
| |
| self._timeout_per_subtest = timeout_per_subtest |
| |
| self._iter_req_per_subtest = 3 |
| self._current_iter_remained = self._iter_req_per_subtest |
| self._cumulative_val = 0 |
| |
| self._status_map = dict((n, ful.UNTESTED) for n in self._subtest_list) |
| self._label_status = dict() |
| self._tested = 0 |
| |
| self._started = False |
| |
| vbox = gtk.VBox() |
| prompt_label = ful.make_label( |
| 'Use indicated light source to pass each subtest\n' |
| 'Hit "space" to begin...\n', |
| fg=ful.WHITE) |
| vbox.pack_start(prompt_label, False, False) |
| |
| padding_size = 15 |
| |
| self._status_label = {} |
| for name in self._subtest_list: |
| label_box = self.make_subtest_label_box(name) |
| vbox.pack_start(label_box, False, False, padding_size) |
| self._status_label[name] = label_box |
| |
| vbox.pack_start(ful.make_hsep(), False, False, padding_size) |
| |
| hbox = gtk.HBox() |
| sensor_label = ful.make_label('Input: ', fg=ful.WHITE) |
| sensor_value = ful.make_label(' ', fg=ful.WHITE) |
| hbox.pack_start(sensor_label, False, False) |
| hbox.pack_start(sensor_value, False, False) |
| |
| countdown_widget, self._countdown_label = ful.make_countdown_widget() |
| self._countdown_label.set_text('%d' % timeout_per_subtest) |
| hbox.pack_end(countdown_widget, False, False) |
| |
| vbox.pack_start(hbox, False, False) |
| |
| # This function sets the period of getting sensor value in ms. |
| # If the value is too small, gtk may not redraw message box properly. |
| |
| gobject.timeout_add(600, self.sensor_event, sensor_value) |
| |
| self._test_widget = vbox |
| ful.run_test_widget(self.job, vbox, |
| window_registration_callback=self.register_callbacks) |
| |
| failed_set = set(name for name, status in self._status_map.items() |
| if status is not ful.PASSED) |
| if failed_set: |
| raise error.TestFail('some subtests timed out (%s)' % |
| ', '.join(failed_set)) |
| |
| factory.log('%s run_once finished' % self.__class__) |
