| #!/usr/bin/env python2.6 |
| # |
| # Copyright (C) 2011 The Android Open Source Project |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| # |
| |
| # |
| # Plots debug log output from WindowOrientationListener. |
| # See README.txt for details. |
| # |
| |
| import numpy as np |
| import matplotlib.pyplot as plot |
| import subprocess |
| import re |
| import fcntl |
| import os |
| import errno |
| import bisect |
| from datetime import datetime, timedelta |
| |
| # Parameters. |
| timespan = 15 # seconds total span shown |
| scrolljump = 5 # seconds jump when scrolling |
| timeticks = 1 # seconds between each time tick |
| |
| # Non-blocking stream wrapper. |
| class NonBlockingStream: |
| def __init__(self, stream): |
| fcntl.fcntl(stream, fcntl.F_SETFL, os.O_NONBLOCK) |
| self.stream = stream |
| self.buffer = '' |
| self.pos = 0 |
| |
| def readline(self): |
| while True: |
| index = self.buffer.find('\n', self.pos) |
| if index != -1: |
| result = self.buffer[self.pos:index] |
| self.pos = index + 1 |
| return result |
| |
| self.buffer = self.buffer[self.pos:] |
| self.pos = 0 |
| try: |
| chunk = os.read(self.stream.fileno(), 4096) |
| except OSError, e: |
| if e.errno == errno.EAGAIN: |
| return None |
| raise e |
| if len(chunk) == 0: |
| if len(self.buffer) == 0: |
| raise(EOFError) |
| else: |
| result = self.buffer |
| self.buffer = '' |
| self.pos = 0 |
| return result |
| self.buffer += chunk |
| |
| # Plotter |
| class Plotter: |
| def __init__(self, adbout): |
| self.adbout = adbout |
| |
| self.fig = plot.figure(1) |
| self.fig.suptitle('Window Orientation Listener', fontsize=12) |
| self.fig.set_dpi(96) |
| self.fig.set_size_inches(16, 12, forward=True) |
| |
| self.raw_acceleration_x = self._make_timeseries() |
| self.raw_acceleration_y = self._make_timeseries() |
| self.raw_acceleration_z = self._make_timeseries() |
| self.raw_acceleration_magnitude = self._make_timeseries() |
| self.raw_acceleration_axes = self._add_timeseries_axes( |
| 1, 'Raw Acceleration', 'm/s^2', [-20, 20], |
| yticks=range(-15, 16, 5)) |
| self.raw_acceleration_line_x = self._add_timeseries_line( |
| self.raw_acceleration_axes, 'x', 'red') |
| self.raw_acceleration_line_y = self._add_timeseries_line( |
| self.raw_acceleration_axes, 'y', 'green') |
| self.raw_acceleration_line_z = self._add_timeseries_line( |
| self.raw_acceleration_axes, 'z', 'blue') |
| self.raw_acceleration_line_magnitude = self._add_timeseries_line( |
| self.raw_acceleration_axes, 'magnitude', 'orange', linewidth=2) |
| self._add_timeseries_legend(self.raw_acceleration_axes) |
| |
| shared_axis = self.raw_acceleration_axes |
| |
| self.filtered_acceleration_x = self._make_timeseries() |
| self.filtered_acceleration_y = self._make_timeseries() |
| self.filtered_acceleration_z = self._make_timeseries() |
| self.filtered_acceleration_magnitude = self._make_timeseries() |
| self.filtered_acceleration_axes = self._add_timeseries_axes( |
| 2, 'Filtered Acceleration', 'm/s^2', [-20, 20], |
| sharex=shared_axis, |
| yticks=range(-15, 16, 5)) |
| self.filtered_acceleration_line_x = self._add_timeseries_line( |
| self.filtered_acceleration_axes, 'x', 'red') |
| self.filtered_acceleration_line_y = self._add_timeseries_line( |
| self.filtered_acceleration_axes, 'y', 'green') |
| self.filtered_acceleration_line_z = self._add_timeseries_line( |
| self.filtered_acceleration_axes, 'z', 'blue') |
| self.filtered_acceleration_line_magnitude = self._add_timeseries_line( |
| self.filtered_acceleration_axes, 'magnitude', 'orange', linewidth=2) |
| self._add_timeseries_legend(self.filtered_acceleration_axes) |
| |
| self.tilt_angle = self._make_timeseries() |
| self.tilt_angle_axes = self._add_timeseries_axes( |
| 3, 'Tilt Angle', 'degrees', [-105, 105], |
| sharex=shared_axis, |
| yticks=range(-90, 91, 30)) |
| self.tilt_angle_line = self._add_timeseries_line( |
| self.tilt_angle_axes, 'tilt', 'black') |
| self._add_timeseries_legend(self.tilt_angle_axes) |
| |
| self.orientation_angle = self._make_timeseries() |
| self.orientation_angle_axes = self._add_timeseries_axes( |
| 4, 'Orientation Angle', 'degrees', [-25, 375], |
| sharex=shared_axis, |
| yticks=range(0, 361, 45)) |
| self.orientation_angle_line = self._add_timeseries_line( |
| self.orientation_angle_axes, 'orientation', 'black') |
| self._add_timeseries_legend(self.orientation_angle_axes) |
| |
| self.current_rotation = self._make_timeseries() |
| self.proposed_rotation = self._make_timeseries() |
| self.predicted_rotation = self._make_timeseries() |
| self.orientation_axes = self._add_timeseries_axes( |
| 5, 'Current / Proposed Orientation', 'rotation', [-1, 4], |
| sharex=shared_axis, |
| yticks=range(0, 4)) |
| self.current_rotation_line = self._add_timeseries_line( |
| self.orientation_axes, 'current', 'black', linewidth=2) |
| self.predicted_rotation_line = self._add_timeseries_line( |
| self.orientation_axes, 'predicted', 'purple', linewidth=3) |
| self.proposed_rotation_line = self._add_timeseries_line( |
| self.orientation_axes, 'proposed', 'green', linewidth=3) |
| self._add_timeseries_legend(self.orientation_axes) |
| |
| self.time_until_settled = self._make_timeseries() |
| self.time_until_flat_delay_expired = self._make_timeseries() |
| self.time_until_swing_delay_expired = self._make_timeseries() |
| self.time_until_acceleration_delay_expired = self._make_timeseries() |
| self.stability_axes = self._add_timeseries_axes( |
| 6, 'Proposal Stability', 'ms', [-10, 600], |
| sharex=shared_axis, |
| yticks=range(0, 600, 100)) |
| self.time_until_settled_line = self._add_timeseries_line( |
| self.stability_axes, 'time until settled', 'black', linewidth=2) |
| self.time_until_flat_delay_expired_line = self._add_timeseries_line( |
| self.stability_axes, 'time until flat delay expired', 'green') |
| self.time_until_swing_delay_expired_line = self._add_timeseries_line( |
| self.stability_axes, 'time until swing delay expired', 'blue') |
| self.time_until_acceleration_delay_expired_line = self._add_timeseries_line( |
| self.stability_axes, 'time until acceleration delay expired', 'red') |
| self._add_timeseries_legend(self.stability_axes) |
| |
| self.sample_latency = self._make_timeseries() |
| self.sample_latency_axes = self._add_timeseries_axes( |
| 7, 'Accelerometer Sampling Latency', 'ms', [-10, 500], |
| sharex=shared_axis, |
| yticks=range(0, 500, 100)) |
| self.sample_latency_line = self._add_timeseries_line( |
| self.sample_latency_axes, 'latency', 'black') |
| self._add_timeseries_legend(self.sample_latency_axes) |
| |
| self.fig.canvas.mpl_connect('button_press_event', self._on_click) |
| self.paused = False |
| |
| self.timer = self.fig.canvas.new_timer(interval=100) |
| self.timer.add_callback(lambda: self.update()) |
| self.timer.start() |
| |
| self.timebase = None |
| self._reset_parse_state() |
| |
| # Handle a click event to pause or restart the timer. |
| def _on_click(self, ev): |
| if not self.paused: |
| self.paused = True |
| self.timer.stop() |
| else: |
| self.paused = False |
| self.timer.start() |
| |
| # Initialize a time series. |
| def _make_timeseries(self): |
| return [[], []] |
| |
| # Add a subplot to the figure for a time series. |
| def _add_timeseries_axes(self, index, title, ylabel, ylim, yticks, sharex=None): |
| num_graphs = 7 |
| height = 0.9 / num_graphs |
| top = 0.95 - height * index |
| axes = self.fig.add_axes([0.1, top, 0.8, height], |
| xscale='linear', |
| xlim=[0, timespan], |
| ylabel=ylabel, |
| yscale='linear', |
| ylim=ylim, |
| sharex=sharex) |
| axes.text(0.02, 0.02, title, transform=axes.transAxes, fontsize=10, fontweight='bold') |
| axes.set_xlabel('time (s)', fontsize=10, fontweight='bold') |
| axes.set_ylabel(ylabel, fontsize=10, fontweight='bold') |
| axes.set_xticks(range(0, timespan + 1, timeticks)) |
| axes.set_yticks(yticks) |
| axes.grid(True) |
| |
| for label in axes.get_xticklabels(): |
| label.set_fontsize(9) |
| for label in axes.get_yticklabels(): |
| label.set_fontsize(9) |
| |
| return axes |
| |
| # Add a line to the axes for a time series. |
| def _add_timeseries_line(self, axes, label, color, linewidth=1): |
| return axes.plot([], label=label, color=color, linewidth=linewidth)[0] |
| |
| # Add a legend to a time series. |
| def _add_timeseries_legend(self, axes): |
| axes.legend( |
| loc='upper left', |
| bbox_to_anchor=(1.01, 1), |
| borderpad=0.1, |
| borderaxespad=0.1, |
| prop={'size': 10}) |
| |
| # Resets the parse state. |
| def _reset_parse_state(self): |
| self.parse_raw_acceleration_x = None |
| self.parse_raw_acceleration_y = None |
| self.parse_raw_acceleration_z = None |
| self.parse_raw_acceleration_magnitude = None |
| self.parse_filtered_acceleration_x = None |
| self.parse_filtered_acceleration_y = None |
| self.parse_filtered_acceleration_z = None |
| self.parse_filtered_acceleration_magnitude = None |
| self.parse_tilt_angle = None |
| self.parse_orientation_angle = None |
| self.parse_current_rotation = None |
| self.parse_proposed_rotation = None |
| self.parse_predicted_rotation = None |
| self.parse_time_until_settled = None |
| self.parse_time_until_flat_delay_expired = None |
| self.parse_time_until_swing_delay_expired = None |
| self.parse_time_until_acceleration_delay_expired = None |
| self.parse_sample_latency = None |
| |
| # Update samples. |
| def update(self): |
| timeindex = 0 |
| while True: |
| try: |
| line = self.adbout.readline() |
| except EOFError: |
| plot.close() |
| return |
| if line is None: |
| break |
| print line |
| |
| try: |
| timestamp = self._parse_timestamp(line) |
| except ValueError, e: |
| continue |
| if self.timebase is None: |
| self.timebase = timestamp |
| delta = timestamp - self.timebase |
| timeindex = delta.seconds + delta.microseconds * 0.000001 |
| |
| if line.find('Raw acceleration vector:') != -1: |
| self.parse_raw_acceleration_x = self._get_following_number(line, 'x=') |
| self.parse_raw_acceleration_y = self._get_following_number(line, 'y=') |
| self.parse_raw_acceleration_z = self._get_following_number(line, 'z=') |
| self.parse_raw_acceleration_magnitude = self._get_following_number(line, 'magnitude=') |
| |
| if line.find('Filtered acceleration vector:') != -1: |
| self.parse_filtered_acceleration_x = self._get_following_number(line, 'x=') |
| self.parse_filtered_acceleration_y = self._get_following_number(line, 'y=') |
| self.parse_filtered_acceleration_z = self._get_following_number(line, 'z=') |
| self.parse_filtered_acceleration_magnitude = self._get_following_number(line, 'magnitude=') |
| |
| if line.find('tiltAngle=') != -1: |
| self.parse_tilt_angle = self._get_following_number(line, 'tiltAngle=') |
| |
| if line.find('orientationAngle=') != -1: |
| self.parse_orientation_angle = self._get_following_number(line, 'orientationAngle=') |
| |
| if line.find('Result:') != -1: |
| self.parse_current_rotation = self._get_following_number(line, 'currentRotation=') |
| self.parse_proposed_rotation = self._get_following_number(line, 'proposedRotation=') |
| self.parse_predicted_rotation = self._get_following_number(line, 'predictedRotation=') |
| self.parse_sample_latency = self._get_following_number(line, 'timeDeltaMS=') |
| self.parse_time_until_settled = self._get_following_number(line, 'timeUntilSettledMS=') |
| self.parse_time_until_flat_delay_expired = self._get_following_number(line, 'timeUntilFlatDelayExpiredMS=') |
| self.parse_time_until_swing_delay_expired = self._get_following_number(line, 'timeUntilSwingDelayExpiredMS=') |
| self.parse_time_until_acceleration_delay_expired = self._get_following_number(line, 'timeUntilAccelerationDelayExpiredMS=') |
| |
| self._append(self.raw_acceleration_x, timeindex, self.parse_raw_acceleration_x) |
| self._append(self.raw_acceleration_y, timeindex, self.parse_raw_acceleration_y) |
| self._append(self.raw_acceleration_z, timeindex, self.parse_raw_acceleration_z) |
| self._append(self.raw_acceleration_magnitude, timeindex, self.parse_raw_acceleration_magnitude) |
| self._append(self.filtered_acceleration_x, timeindex, self.parse_filtered_acceleration_x) |
| self._append(self.filtered_acceleration_y, timeindex, self.parse_filtered_acceleration_y) |
| self._append(self.filtered_acceleration_z, timeindex, self.parse_filtered_acceleration_z) |
| self._append(self.filtered_acceleration_magnitude, timeindex, self.parse_filtered_acceleration_magnitude) |
| self._append(self.tilt_angle, timeindex, self.parse_tilt_angle) |
| self._append(self.orientation_angle, timeindex, self.parse_orientation_angle) |
| self._append(self.current_rotation, timeindex, self.parse_current_rotation) |
| if self.parse_proposed_rotation >= 0: |
| self._append(self.proposed_rotation, timeindex, self.parse_proposed_rotation) |
| else: |
| self._append(self.proposed_rotation, timeindex, None) |
| if self.parse_predicted_rotation >= 0: |
| self._append(self.predicted_rotation, timeindex, self.parse_predicted_rotation) |
| else: |
| self._append(self.predicted_rotation, timeindex, None) |
| self._append(self.time_until_settled, timeindex, self.parse_time_until_settled) |
| self._append(self.time_until_flat_delay_expired, timeindex, self.parse_time_until_flat_delay_expired) |
| self._append(self.time_until_swing_delay_expired, timeindex, self.parse_time_until_swing_delay_expired) |
| self._append(self.time_until_acceleration_delay_expired, timeindex, self.parse_time_until_acceleration_delay_expired) |
| self._append(self.sample_latency, timeindex, self.parse_sample_latency) |
| self._reset_parse_state() |
| |
| # Scroll the plots. |
| if timeindex > timespan: |
| bottom = int(timeindex) - timespan + scrolljump |
| self.timebase += timedelta(seconds=bottom) |
| self._scroll(self.raw_acceleration_x, bottom) |
| self._scroll(self.raw_acceleration_y, bottom) |
| self._scroll(self.raw_acceleration_z, bottom) |
| self._scroll(self.raw_acceleration_magnitude, bottom) |
| self._scroll(self.filtered_acceleration_x, bottom) |
| self._scroll(self.filtered_acceleration_y, bottom) |
| self._scroll(self.filtered_acceleration_z, bottom) |
| self._scroll(self.filtered_acceleration_magnitude, bottom) |
| self._scroll(self.tilt_angle, bottom) |
| self._scroll(self.orientation_angle, bottom) |
| self._scroll(self.current_rotation, bottom) |
| self._scroll(self.proposed_rotation, bottom) |
| self._scroll(self.predicted_rotation, bottom) |
| self._scroll(self.time_until_settled, bottom) |
| self._scroll(self.time_until_flat_delay_expired, bottom) |
| self._scroll(self.time_until_swing_delay_expired, bottom) |
| self._scroll(self.time_until_acceleration_delay_expired, bottom) |
| self._scroll(self.sample_latency, bottom) |
| |
| # Redraw the plots. |
| self.raw_acceleration_line_x.set_data(self.raw_acceleration_x) |
| self.raw_acceleration_line_y.set_data(self.raw_acceleration_y) |
| self.raw_acceleration_line_z.set_data(self.raw_acceleration_z) |
| self.raw_acceleration_line_magnitude.set_data(self.raw_acceleration_magnitude) |
| self.filtered_acceleration_line_x.set_data(self.filtered_acceleration_x) |
| self.filtered_acceleration_line_y.set_data(self.filtered_acceleration_y) |
| self.filtered_acceleration_line_z.set_data(self.filtered_acceleration_z) |
| self.filtered_acceleration_line_magnitude.set_data(self.filtered_acceleration_magnitude) |
| self.tilt_angle_line.set_data(self.tilt_angle) |
| self.orientation_angle_line.set_data(self.orientation_angle) |
| self.current_rotation_line.set_data(self.current_rotation) |
| self.proposed_rotation_line.set_data(self.proposed_rotation) |
| self.predicted_rotation_line.set_data(self.predicted_rotation) |
| self.time_until_settled_line.set_data(self.time_until_settled) |
| self.time_until_flat_delay_expired_line.set_data(self.time_until_flat_delay_expired) |
| self.time_until_swing_delay_expired_line.set_data(self.time_until_swing_delay_expired) |
| self.time_until_acceleration_delay_expired_line.set_data(self.time_until_acceleration_delay_expired) |
| self.sample_latency_line.set_data(self.sample_latency) |
| |
| self.fig.canvas.draw_idle() |
| |
| # Scroll a time series. |
| def _scroll(self, timeseries, bottom): |
| bottom_index = bisect.bisect_left(timeseries[0], bottom) |
| del timeseries[0][:bottom_index] |
| del timeseries[1][:bottom_index] |
| for i, timeindex in enumerate(timeseries[0]): |
| timeseries[0][i] = timeindex - bottom |
| |
| # Extract a word following the specified prefix. |
| def _get_following_word(self, line, prefix): |
| prefix_index = line.find(prefix) |
| if prefix_index == -1: |
| return None |
| start_index = prefix_index + len(prefix) |
| delim_index = line.find(',', start_index) |
| if delim_index == -1: |
| return line[start_index:] |
| else: |
| return line[start_index:delim_index] |
| |
| # Extract a number following the specified prefix. |
| def _get_following_number(self, line, prefix): |
| word = self._get_following_word(line, prefix) |
| if word is None: |
| return None |
| return float(word) |
| |
| # Extract an array of numbers following the specified prefix. |
| def _get_following_array_of_numbers(self, line, prefix): |
| prefix_index = line.find(prefix + '[') |
| if prefix_index == -1: |
| return None |
| start_index = prefix_index + len(prefix) + 1 |
| delim_index = line.find(']', start_index) |
| if delim_index == -1: |
| return None |
| |
| result = [] |
| while start_index < delim_index: |
| comma_index = line.find(', ', start_index, delim_index) |
| if comma_index == -1: |
| result.append(float(line[start_index:delim_index])) |
| break; |
| result.append(float(line[start_index:comma_index])) |
| start_index = comma_index + 2 |
| return result |
| |
| # Add a value to a time series. |
| def _append(self, timeseries, timeindex, number): |
| timeseries[0].append(timeindex) |
| timeseries[1].append(number) |
| |
| # Parse the logcat timestamp. |
| # Timestamp has the form '01-21 20:42:42.930' |
| def _parse_timestamp(self, line): |
| return datetime.strptime(line[0:18], '%m-%d %H:%M:%S.%f') |
| |
| # Notice |
| print "Window Orientation Listener plotting tool" |
| print "-----------------------------------------\n" |
| print "Please turn on the Window Orientation Listener logging. See README.txt." |
| |
| # Start adb. |
| print "Starting adb logcat.\n" |
| |
| adb = subprocess.Popen(['adb', 'logcat', '-s', '-v', 'time', 'WindowOrientationListener:V'], |
| stdout=subprocess.PIPE) |
| adbout = NonBlockingStream(adb.stdout) |
| |
| # Prepare plotter. |
| plotter = Plotter(adbout) |
| plotter.update() |
| |
| # Main loop. |
| plot.show() |
