| #!/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() |