# Patent

## Title
Latency measurement

## Abstract

Panning latency measurement techniques are described. In one or more implementations, a test apparatus includes one or more motors configured to move one or more contacts at least proximal to one or more sensors of a device to be detectable as a movement. The test apparatus also includes one or more modules implemented at least partially in hardware to measure latency of the device to recognize the movement of the one or more contacts.

## Background
BACKGROUND
Display and input techniques utilized by computing devices are ever evolving. For example, initial computing devices were provided with monitors. A user interacted with the computing device by viewing simple text on the monochrome monitor and entering text via a keyboard that could then be viewed on the monitor. Other techniques were then subsequently developed, such as graphical user interfaces and cursor control devices.
Display and input techniques have continued to evolve, such as to sense touch using a touchscreen display of a computing device to recognize gestures. A user, for instance, may interact with a graphical user interface by inputting a gesture using the user's hand that is detected by the touchscreen display or other touch-sensitive device. However, traditional techniques that were utilized to test touchscreen displays and other touch-sensitive devices were often inaccurate and therefore were typically inadequate to test the touchscreen displays as suitable for intended use of the device.
SUMMARY
Panning latency measurement techniques are described. In one or more implementations, a test apparatus includes one or more motors configured to move a contact at least proximal to one or more sensors of a device to be detectable as a movement. The test apparatus also includes one or more modules implemented at least partially in hardware to measure latency of the device to recognize the movement of the contact.
In one or more implementations, data is received by a test apparatus that describes panning movement detected using touch functionality of a device. Latency is measured, by the test apparatus, of the device to recognize the panning movement to initiate one or more operations of the device.
In one or more implementations, a test apparatus includes a contact configured to be disposed proximal to a display device having touchscreen functionality (e.g., sensors configured to detect proximity, including pen sensors), a motor configured to move the contact in a circular path to be detectable by the touchscreen functionality of the device as a panning movement, and one or more modules implemented at least partially in hardware to measure latency of the device to recognize the panning movement of the contact using constant angular velocity. The test apparatus may also be configured to include an interruption module having a photo interrupter circuit configured to detect the contact, which is used at least in part to measure the latency. In another example, the test apparatus may also be configured to include a laser and photo diode which may be used to measure the latency by calibrating velocity of a contact.
This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used as an aid in determining the scope of the claimed subject matter.



BRIEF DESCRIPTION OF THE DRAWINGS
The detailed description is described with reference to the accompanying figures. In the figures, the left-most digit(s) of a reference number identifies the figure in which the reference number first appears. The use of the same reference numbers in different instances in the description and the figures may indicate similar or identical items. Entities represented in the figures may be indicative of one or more entities and thus reference may be made interchangeably to single or plural forms of the entities in the discussion.
FIG. 1 is an illustration of an environment in an example implementation that includes a test apparatus that is suitable to test a device.
FIG. 2 depicts an example implementation of a system configured to test panning latency.
FIG. 3 depicts an example system in which a test apparatus of FIG. 1 is configured to perform panning latency measure using an interruption.
FIG. 4 depicts an example system in which a test apparatus of FIG. 1 is configured to perform panning latency measure using a laser.
FIG. 5 is a flow diagram depicting a procedure in an example implementation in which latency is measured.
FIG. 6 illustrates an example system including various components of an example device that can be implemented as any type of computing device as described with reference to FIGS. 1-4 to implement embodiments of the techniques described herein.



DETAILED DESCRIPTION
Overview
Panning continues to become ever more popular as a technique to navigate through a use interface output by a computing device. However, techniques are not available conventionally to accurately measure latency in recognizing movement of a contact and thus the responsiveness of the computing device to perform panning.
Latency measurement techniques are described herein. In one or more implementations, a test apparatus is configured to detect latency of movement (e.g., panning), such as end-to-end latency, hardware latency, and so on of a computing device to perform a pan. This measurement may be performed in a variety of ways. For example, a test apparatus may include a step motor that creates a circular path that may be used to test latency in recognition of movement using constant angular velocity, further discussion of which may be found in relation to FIG. 2. In another example, the test apparatus may utilize leverage interruptions, such as a photo interrupter, to measure latency, an example of which may be found in relation to FIG. 3. In a further example, the test apparatus may leverage a laser and photo diode to measure latency, an example of which may be found in relation to FIG. 4. Although panning latency is described in the following discussion by way of example, it should be apparent that measurement of panning latency may refer to measurement of latency in recognition of movement by a device.
In the following discussion, an example environment is first described that may employ the panning latency measurement techniques described herein. Example procedures are then described which may be performed in the example environment as well as other environments. Consequently, performance of the example procedures is not limited to the example environment and the example environment is not limited to performance of the example procedures.
Example Environment
FIG. 1 depicts an environment 100 in an example implementation that includes a test apparatus 102 that is suitable to test a touchscreen device 104. The touchscreen device 104 may be configured in a variety of ways. For example, the touchscreen device 104 may be configured as part of a mobile communication device such as a mobile phone, a portable game-playing device, a tablet computer, as part of a traditional computing device (e.g., a display device that is part of a laptop or personal computer), and so on.
Additionally, the display device 106 of the touchscreen device 104 may be configured in a variety of ways. For example, the display device 106 of the touchscreen device 104 may include sensors that are configured to detect proximity (e.g., contact) with the display device 106. Sensors 110 are typically used to report actual contact with the display device 106, such as when being touched with a finger of a user's hand 108, although other sensors are also described.
Examples of such sensors 110 include capacitive touch sensors. For instance, in projected capacitance an X-Y grid may be formed across the touchscreen using near optically transparent conductors (e.g., indium tin oxide) to detect contact at different X-Y locations on the display device 106. Other capacitance techniques are also contemplated, such as surface capacitance, mutual capacitance, self-capacitance, and so on. Further, other sensors 110 are also contemplated in other instances, such as infrared, optical imaging, dispersive signal technology, acoustic pulse recognition, resistive sensors (e.g., detect pressure), sensor in a pixel, and so on. Thus, a touch sensor 110 may be configured to detect proximity and not actual physical contact, e.g., “hovering” of a stylus.
Regardless of the type of sensors 110 used, inputs detected by the sensors 110 may then be processed by the touch module 112 to detect characteristics of the inputs, which may be used for a variety of purposes. For example, the touch module 112 may recognize that the input indicates selection of a particular object, may recognize one or more inputs as a gesture usable to initiate an operation of the touchscreen device 104 (e.g., expand a user interface), and so forth. However, this processing may rely upon the accuracy of the inputs and therefore conventional techniques that were utilized to test the display device 106 could result in an inaccurate touchscreen making it to market, which could hinder a user's interaction with the device.
In one or more implementations described herein, an ability of a display device 106 to detect proximity (e.g., by a finger of a user's hand 108) is tested by the test apparatus 102. For example, the test apparatus 102 may include a test module 114 and panning movement device 116. The panning movement device 116 may be utilized to test the touchscreen device 104 in a variety of ways. For instance, the test module 114 may leverage the panning movement device 116 to measure panning latency of the touchscreen device 104, such as an ability of the touch module 112 to detect contact by one or more fingers of the user's hand 108 (or other objects) with the display device 106 and subsequent movement of this contact. This may be performed in a variety of ways, an example of which may be found in relation to FIG. 2.
Example Panning Latency Measurement Using a Moving Contact
FIG. 2 depicts an example implementation of a system 200 configured to test panning latency. Panning latency may be used to evaluate sensors 110 and a touch module 112 of a touchscreen device 104 to detect a panning input, which may involve contact with the touchscreen and subsequent movement of the contact. In the illustrated example system, a contact 202 and subsequent movement along a path 204 is provided by a step motor 206 and step motor driver 208, which may be under the control of the test module 114 of FIG. 1. As previously stated, the contact 202 may be detected by being disposed proximal to sensors of a device under test and therefore may not involve actual contact in some instances. Further, although a single contact 202 is illustrated, these techniques may also be leveraged to support multiple contacts, such as to support multi-touch testing. In the illustrated example, the path 204 is circular although other shapes including linear (e.g., back and forth movement) are also contemplated. Detection of the path by the sensors 110 and subsequent processing by the touch module 112 is used to generate an HID report 210 that is evaluated by the test module 114 to generate a report that describes panning latency.
Panning may be involved in a variety of different scenarios, such as scrolling in browser, use in a tile-based user interface, and so on. In one or more of these scenarios, a “stick to the finger” experience may be desired in which an end user instantaneously receives feedback from a display device 106 in response to moving of a contact 202 on the display device 106. The quality of this experience may be quantified as an end-to-end latency for panning scenarios, which may be defined as follows.
Latency is a measure of time delay experienced in a system. In the case of end-to-end panning latency, a continuous system is encountered such that the entire process of panning is not instantaneous, but instead takes some time, generally on an order of magnitude involving seconds. Hence, latency may be defined to measure this. A contact 202 of a test apparatus 102, that initiates the panning gesture may be accurately modeled with a contact position in time function as follows:

Contact(t):(t)→(x,y)

Therefore, for each moment in time the position of the contact 202 is also determined. However, digitizers and other sensors 110 typically do not provide continuous reporting, but instead report discretely and with some predefined reporting rate (e.g., 100-200 reports per second, 100-200 Hz). If the reporting rate was infinite, the reported position in time function may be represented as follows:

Report(t):(t)→(x,y)

Similar to this, an ideal case may be established for display device 106 feedback which includes the graphics latency (e.g., of an operating system) along with a position of the display feedback in time function:

Display(t):(t)→(x,y)

For the purposes of this abstract modeling, the contact 202 position's path 204 may be assumed to be the same as report position path which is the same as display position path. In practice, however, this may not be the case as further addressed later in the discussion. Furthermore, an assumption may be made that each of the three functions above are bijective, which although not the case it may be achieved through piece-wise modeling. This may involve a process of dividing an entire function in several pieces, each of which is bijective. With those two assumptions, a latency function may be built for each position along the path (e.g., the path is the same for each of the three functions per first assumption above) by measuring time difference between display by the display device and contact function for each position along the path, per the second assumption a single timestamp is provided that corresponds to each position in the path for each of the three functions.
Accordingly, a formal model for this definition of latency may be created. This creation of the formal model may begin with three inverse functions as follows:

    
    
        (1) for time of the given contact position: Contact−1(x,y):(x,y)→(t);
        (2) for time of the given report position; Report−1(x,y):(x,y)→(t); and
        (3) for time of the given display feedback position,

Display−1(x,y):(x,y)→(t)

Given those inverse functions, an end-to-end latency function may be defined for each position on the path as follows, in which:

Latency(x,y):(x,t)→(t)

as

Latency(x,y)=Display−1(x,y)−Contact−1(x,y)

    
    


For example, consider fixed point (x0, y0), and appropriate inverse display function for that particular point:

tD=tD(x0,y0)=Display−1(x0,y0)

and similar for contact inverse function for this particular point as follows:

tC=tC(x0,y0)=Contact−1(x0,y0)

In that case, the end-to-end latency for this particular point may be calculated as follows:

Latency(x0,y0)=tD(x0,y0)−tC(x0,y0)=tD−tC 

This expression describes a difference in time between when the contact occurred at given position (x0, y0) and the time at which the display device provided feedback for this event, which again may be thought of as end-to-end latency.

Returning back to initial three functions, end-to-end latency may be broken down in two parts, (1) hardware latency; and (2) operating system and display latency. Hardware latency involves latency of touch hardware, e.g., from a moment at which the contact 202 occurred until the moment report is received by the operating system. The remainder of the latency involves the operating system and display latency. Accordingly, hardware panning latency may be expressed as follows:

LatencyHW(x,y)=Report−1(x,y)−Contact−1(x,y)

An inverse report function may be defined in a similar fashion as inverse contact and display functions above:

tR=tR(x0,y0)=Report−1(x0,y0)

Hence, the hardware latency for any given point on the path (x0, y0) may be expressed as follows:

LatencyHW(x0,y0)=tR(x0,y0)−tC(x0,y0)=tR−tC 

This equation describes the difference in time between a time at which contact 202 occurred at a given position (x0, y0) and a time at which this contact was reported to the system.

A case of panning latency measurement (e.g., hardware and/or end-to-end) may be described as follows, where:

    
    
        Contact(x,y) function is continuous
        Report(x,y) function is discrete (not continuous); and
        Display(x,y) function is discrete (not continuous), for end-to-end latency measurement.

This may be used to represent a real-world scenario in which reporting and display rates are discrete as occurring at generally fixed time intervals. Consequently, there are no changes in the actual equations used above except in domains where appropriate functions are defined.

    
    


For instance, since Report(x,y) is defined in discrete points, the inverse function exists in the same discrete points and not elsewhere. Hence, the hardware latency definition becomes:

LatencyHW(xi,yi)=Report−1(xi,yi)−Contact−1(xi,yi)

where (xi,yi) represents the position of the i-th reported point. Similarly, the following end-to-end latency definition may be observed:

Latency(xi,yi)=Display−1(xi,yi)−Contact−1(xi,yi)

Thus, one way to measure latency is to obtain position and a timestamp for reported or displayed contact, then obtain a timestamp at a point in time at which the contact is located at that precise position (Contact−1(xi,yi)) and calculate the difference between the two timestamps.
Constant Angular Velocity
In the previous section, a model for panning latency measurement was described. In this section, an example system is described that may be used for panning latency measurement. As described above, panning hardware latency may be measured:

    
    
        from touch report (e.g., touch POINTER message), timestamp (tR) and position of the reported touch may be obtained;
        the timestamp (tC) when contact was at the reported position may be obtained; and
        latency for this measurement may then be defined as tR−tC.

Hence, the panning latency measurement may be reduced to contact position measurement.

    
    


One way to measure the position of contact is to move the contact, e.g., around a predefined circular path 204 at constant angular velocity with one or more control points. The starting point is the path 204 of the contact 202 and since a circular motion is being used in this example the path 204 will also be circular in physical world, although not reported so in the coordinate's pixel world. Therefore, this path 204 may be defined using the following parameters:

    
    
        the center of the circle (x00, y00), e.g., in centimeters relative to a defined point; and
        the radius of the circle R, e.g., in centimeters.

These parameters are sufficient to describe the path 204.

    
    


Another way to describe the path 204 is to use parametric equations as a function of angle α:

Posx(α):(α)→(x)

Posx(α)=x(α)=x00+R cos α−R sin α,

This is correct if alpha is defined to a point on the path. If alpha is relative to x-axis, then R cos(alpha) is used.

Posy(α):(α)→(y)

Posy(α)=y(α)=y00+R sin α cos α

Similar to this, an inverse angle function may be established:



  
    
      
        Angle
        ⁡
        
          (
          
            x
            ,
            y
          
          )
        
      
      :
      
        (
        
          x
          ,
          y
        
        )
      
    
    ->
    
      (
      α
      )
    
  




  
    
      Angle
      ⁡
      
        (
        
          x
          ,
          y
        
        )
      
    
    =
    
      
        α
        ⁡
        
          (
          
            x
            ,
            y
          
          )
        
      
      =
      
        
          tan
          
            -
            1
          
        
        ⁢
        
          
            y
            -
            
              y
              00
            
          
          
            x
            -
            
              x
              00
            
          
        
      
    
  



where mentioned position and angle functions depend on the center and the radius of the circle.

Once the path 204 is defined, two additional parameters may be used to describe the contact position in time:

    
    
        angular velocity of the contact (ω); and
        one position of the contact in time, say as an angle in some distinct time t0 (α(t0)).

With those parameters set, the contact position in time may be defined as:

Angle(t):(t)→(α)

Angle(t)=α(t)=α(t0)+ω(t−t0)

    
    


Panning hardware latency may be defined in terms of functions mentioned above. Values are obtained from the touch report, position of the contact (xi,yi) and timestamp tR as follows:




  
    Latency
    ⁡
    
      (
      
        
          x
          i
        
        ,
        
          y
          i
        
        ,
        
          t
          R
        
      
      )
    
  
  =
  
    
      
        α
        ⁡
        
          (
          
            t
            R
          
          )
        
      
      -
      
        α
        ⁡
        
          (
          
            
              x
              i
            
            ,
            
              y
              i
            
          
          )
        
      
    
    ω
  




In this section, latency is described in terms of touch report parameters xi,yi and tR. Six other parameters (x00, y00, R, ω, t0, α(t0)) of the model may be extracted prior to actual measurement, as further described in the following section
Obtaining the Parameters of the Constant Angular Velocity Model
Parameters of this model may be obtained from touch reports and a measurement of an actual size of a display area of the display device 106, e.g., physical size of the screen in centimeters. Thus, this model may support fully automated measurement. For the purposes of this discussion, reported positions are expressed in centimeters, although the positions may also be expressed in pixels or other units. Conversion from pixel coordinate space to physical coordinate space may be performed as follows:



  
    
      PosX
      cm
    
    =
    
      
        
          PosX
          pixels
        
        
          ScreenWidth
          pixels
        
      
      ⁢
      
        ScreenWidth
        cm
      
    
  




  
    
      PosY
      cm
    
    =
    
      
        
          PosY
          pixels
        
        
          ScreenHeight
          pixels
        
      
      ⁢
      
        ScreenHeight
        cm
      
    
  



There are numerous ways to measure and estimate each of the parameters, examples of which are described below. It should be noted that some parameters in this list may be measured independently of another.
Starting with the center of the circular path 204, one way for estimating x00 and y00 is to sum each of the values for collected reported data as described below:



  
    
      x
      00
    
    =
    
      
        1
        n
      
      ⁢
      
        
          ∑
          
            i
            =
            1
          
          n
        
        ⁢
        
          x
          i
        
      
    
  




  
    
      y
      00
    
    =
    
      
        1
        n
      
      ⁢
      
        
          ∑
          
            i
            =
            1
          
          n
        
        ⁢
        
          y
          i
        
      
    
  



The reporting rate may be assumed in this example to be the same in each part of the display area of the display device 106 and that the entire path 204 is bounded by the display area of the display device 106. In one or more implementations, full circle increments are taken into account, soley. It should be noted that estimates for x00 and y00 may be independent from one another as mentioned before.
Another estimate for x00 and y00 may be made as follows:



  
    
      x
      00
    
    =
    
      
        
          
            min
            
              i
              ≤
              n
            
          
          ⁢
          
            x
            i
          
        
        +
        
          
            max
            
              i
              ≤
              n
            
          
          ⁢
          
            x
            i
          
        
      
      2
    
  




  
    
      y
      00
    
    =
    
      
        
          
            min
            
              i
              ≤
              n
            
          
          ⁢
          
            y
            i
          
        
        +
        
          
            max
            
              i
              ≤
              n
            
          
          ⁢
          
            y
            i
          
        
      
      2
    
  



This estimate also assumes that the entire path is bounded by the display area of the display device 106.

Similarly, an estimate for R may be expressed as follows:




  R
  =
  
    
      
        
          max
          
            i
            ≤
            n
          
        
        ⁢
        
          x
          i
        
      
      -
      
        
          min
          
            i
            ≤
            n
          
        
        ⁢
        
          x
          i
        
      
      +
      
        
          max
          
            i
            ≤
            n
          
        
        ⁢
        
          y
          i
        
      
      -
      
        
          min
          
            i
            ≤
            n
          
        
        ⁢
        
          y
          i
        
      
    
    4
  




In another example, an estimate for R may be made using the following expression:




  R
  =
  
    
      
        
          1
          n
        
        ⁢
        
          
            ∑
            
              i
              =
              1
            
            n
          
          ⁢
          
            
              (
              
                
                  x
                  i
                
                -
                
                  x
                  00
                
              
              )
            
            2
          
        
      
      +
      
        
          (
          
            
              y
              i
            
            -
            
              y
              00
            
          
          )
        
        2
      
    
  




Therefore, average error for this estimate may be defined as follows:





  
    
      e
      AV
    
    ⁡
    
      (
      
        
          x
          00
        
        ,
        
          y
          00
        
        ,
        R
      
      )
    
  
  =
  
    
      1
      n
    
    ⁢
    
      
        ∑
        
          i
          =
          1
        
        n
      
      ⁢
      
        
          
            R
            2
          
          -
          
            
              (
              
                
                  x
                  i
                
                -
                
                  x
                  00
                
              
              )
            
            2
          
          -
          
            
              (
              
                
                  y
                  i
                
                -
                
                  y
                  00
                
              
              )
            
            2
          
        
      
    
  




Similarly, the maximum error may be defined as follows:




  
    
      e
      MAX
    
    ⁡
    
      (
      
        
          x
          00
        
        ,
        
          y
          00
        
        ,
        R
      
      )
    
  
  =
  
    
      max
      
        i
        ≤
        n
      
    
    ⁢
    
      
        
          R
          2
        
        -
        
          
            (
            
              
                x
                i
              
              -
              
                x
                00
              
            
            )
          
          2
        
        -
        
          
            (
            
              
                y
                i
              
              -
              
                y
                00
              
            
            )
          
          2
        
      
    
  




Standard deviation may also be defined rather than the maximum error as defined above. Maximum error applies to each of the three parameters for the model and thus is considered robust.
In practice, the above estimates are sufficient for desired error in measurement, e.g., an error that involves a couple of pixels. In case both have failed, an iterative gradient regression may be performed on each of the three parameters x00 and y00 and R, an example of which is shown by the following function:




  
    f
    ⁡
    
      (
      
        
          x
          00
        
        ,
        
          y
          00
        
        ,
        R
      
      )
    
  
  =
  
    
      ∑
      
        i
        =
        1
      
      n
    
    ⁢
    
      
        (
        
          
            R
            2
          
          -
          
            
              (
              
                
                  x
                  i
                
                -
                
                  x
                  00
                
              
              )
            
            2
          
          -
          
            
              (
              
                
                  y
                  i
                
                -
                
                  y
                  00
                
              
              )
            
            2
          
        
        )
      
      2
    
  




This may be performed until a satisfactory local minimum is found around points obtained with one of the two estimates above. One way to accomplish this is to solve each of the following equations for R, x00 and y00 respectively:




  
    
      
        ∂
        
          ∂
          R
        
      
      ⁡
      
        [
        
          f
          ⁡
          
            (
            
              
                x
                00
              
              ,
              
                y
                00
              
              ,
              R
            
            )
          
        
        ]
      
    
    =
    0
  




  
    
      
        ∂
        
          ∂
          
            x
            00
          
        
      
      ⁡
      
        [
        
          f
          ⁡
          
            (
            
              
                x
                00
              
              ,
              
                y
                00
              
              ,
              R
            
            )
          
        
        ]
      
    
    =
    0
  




  
    
      
        ∂
        
          ∂
          
            y
            00
          
        
      
      ⁡
      
        [
        
          f
          ⁡
          
            (
            
              
                x
                00
              
              ,
              
                y
                00
              
              ,
              R
            
            )
          
        
        ]
      
    
    =
    0
  



The solution for the first equation was already mentioned above and is repeated as follows:




  R
  =
  
    
      
        g
        R
      
      ⁡
      
        (
        
          
            x
            00
          
          ,
          
            y
            00
          
        
        )
      
    
    =
    
      
        
          
            1
            n
          
          ⁢
          
            
              ∑
              
                i
                =
                1
              
              n
            
            ⁢
            
              
                (
                
                  
                    x
                    i
                  
                  -
                  
                    x
                    00
                  
                
                )
              
              2
            
          
        
        +
        
          
            (
            
              
                y
                i
              
              -
              
                y
                00
              
            
            )
          
          2
        
      
    
  




The solution for the remaining two functions is a root of a cubic equation, which may be declared as gx00 and gy00 as follows:

x00=gx00(R,y00)

y00=gy00(R,x00)

Additionally, all three may be used in a standard iterative procedure:

R(k)=gR(x00(k-1,y00(k-1))

x00(k)=gx00(R(k),y00(k-1))

y00(k)=gy00(R(k),x00(k))

where x00(0) and y00(0) are taken from simple estimations above, with k defined as the iteration number.

Other scenarios may also be supported in which an entire path is not on the display area of the display device 106, but rather some parts to the path are outside of the display area. In such scenarios, three or more points on the path may be selected and used to calculate a center of the circumscribed circle for that triangle. An example of this is shown in the following process:

    
    
        pick a point on the path (xi, yi);
        select another point on the path (xj, yj) such that distance from the two points is maximal;
        select third point as (x(i+j)/2, y(i+j)/2);
        calculate the center of the circumscribed circle for these three points;
        repeat these steps one or more additional times, calculate average position of the center;
        calculate R using the equation above;
        calculate maximal error using the equation above;
        if the maximal error is acceptable, the process is complete; and
        if not, proceed to iterative process described above.
    
    


At this point parameters x00, y00 and R as well as maximal error of measurement for these parameters have been calculated. Three parameters remain for calculation: ω, t0, α(t0).
An assumption may be made that t0=0 and therefore time may be measured relative to this moment. The initial angle α(t0) may be calculated from the reported data (xi0, yi0) at given timestamp t0=0 using the following expression:




  
    α
    ⁡
    
      (
      
        
          x
          i
          0
        
        ,
        
          y
          i
          0
        
      
      )
    
  
  =
  
    arctan
    ⁢
    
      
        
          y
          i
          0
        
        -
        
          y
          00
        
      
      
        
          x
          i
          0
        
        -
        
          x
          00
        
      
    
  




This measurement may be repeated a number of times; for instance if the position of the measurement is fixed each time the average may be calculated as:




  
    α
    AV
  
  =
  
    
      1
      k
    
    ⁢
    
      
        ∑
        
          i
          =
          1
        
        k
      
      ⁢
      
        α
        ⁡
        
          (
          
            
              x
              i
              0
            
            ,
            
              y
              i
              0
            
          
          )
        
      
    
  




and the maximum error of this measurement as:





  
    e
    α
  
  =
  
    
      max
      
        i
        ≤
        k
      
    
    ⁢
    
      
      
        
          α
          ⁡
          
            (
            
              
                x
                i
                0
              
              ,
              
                y
                i
                0
              
            
            )
          
        
        -
        
          α
          AV
        
      
      
    
  




Angular velocity w may be measured a variety of ways. For instance, reported contact positions may be utilized by selecting points (e.g., randomly) on the path and by measuring time between two passes.
Accordingly, a process that may be performed for this measurement using reported contact positions as follows:

    
    
        select a point on the path (xi0, yi0) (e.g., randomly) and store timestamp for this point ti0;
        as path is circular, find the closest point (xi1, yi1) to (xi0, yi0) in the next cycle;
        
            find a local minimum of distance function between (xi0, yi0) and (xi, yi), e.g. locate (xi1−1, yi1−1), (xi1, yi1) and (xi1+1, yi1+1) such that d(i1−1, i0)>d(i1, i0) and d(i1+1, i0)>=d(i1, i0)
        
        
        interpolate timestamps ti1−1, ti1, ti1+1, in order to get the best estimate ti1*;
        angular velocity may then be expressed as:
    
    






  
    ω
    1
  
  =
  
    
      2
      ⁢
      π
    
    
      
        t
        
          i
          ⁢
          
            
          
          ⁢
          1
        
        *
      
      -
      
        t
        
          i
          ⁢
          
            
          
          ⁢
          0
        
      
    
  




    
    
        or in general for the k-th cycle:
    
    






  
    ω
    k
  
  =
  
    
      2
      ⁢
      π
    
    
      
        t
        
          i
          ⁢
          
            
          
          ⁢
          k
        
        *
      
      -
      
        t
        
          i
          ⁡
          
            (
            
              k
              -
              1
            
            )
          
        
      
    
  




Average angular velocity and maximum error may then be defined for this measurement.

An alternative is to have a separate device that is configured to report back to the system at the moment contact is achieved at some predefined (but effectively arbitrary) position, examples of which are shown and described in relation to FIGS. 3 and 4. This may reduce the complexity of the problem by using fixed timestamps tk. In this case, each measurement for angular velocity becomes:




  
    ω
    k
  
  =
  
    
      2
      ⁢
      π
    
    
      
        t
        k
      
      -
      
        t
        
          k
          -
          1
        
      
    
  




The average angular velocity is then expressed as:





  
    ω
    AV
  
  =
  
    
      1
      n
    
    ⁢
    
      
        ∑
        
          k
          =
          1
        
        n
      
      ⁢
      
        ω
        k
      
    
  




and maximal error expressed as the following:





  
    e
    ω
  
  =
  
    
      max
      
        k
        ≤
        n
      
    
    ⁢
    
      
      
        
          ω
          k
        
        -
        
          ω
          AV
        
      
      
    
  




Hardware Setup for Panning Latency Measurement with Step Motor
In this example, a solution that leverages constant angular velocity is used. In the illustrated system, a step motor 206 is used to achieve constant angular velocity, e.g., which may provide approximately one millisecond accuracy. The system may include a variety of different parts, such as:

    
    
        Leveling surface, used to appropriately level a device under test, such as the display device 106;
        Step motor holder, used to hold the step motor 206 above the leveling surface;
        Step motor 206;
        Step motor driver 208, e.g., a spate box with a control program driving the step motor 206 via a serial port or other communicative connection;
        Mount for the contact 202 (e.g., touch stick or pen);
        Components to detect the moment when contact is located at control point, examples of which are shown in FIGS. 3 and 4; and
        A software component to drive and automate the procedure, which may be implemented as part of the test module 114.
    
    


Leveling may be performed simply by lowering the contact 202 (e.g., the touch stick) until it reaches the surface of the device under test, e.g., the display device 106. The step motor 206 may then be moved at a low angular velocity to verify the contact along the path 204. This may be tested by starting the step motor 206 at nominal angular velocity (e.g.,  ̃3 rad/s) and verifying that reported touch events are consistent:

    
    
        Stable report rate equal to the maximum reporting rate of the device; and
        Stable contact id, contact id does not change for a couple of cycles on average.

Once the two conditions are met, the display device 106 is considered leveled.

    
    


Panning Latency Measurement with Step Motor
Four distinct phases of the panning latency measurement process may be differentiated:

    
    
        Setup (leveling, ensuring that contact 202 is firm and produces uninterrupted touch reports);
        Calibration (detect positions of the control points based on collected data);
        Acquisition (detect center of the circle, radius, and angular velocity based on collected data); and
        Collection (measure panning latency based on collected data).
    
    


In the first stage, leveling is ensured to be appropriate as described above, e.g. contact is firm and yield solid uninterrupted touch reports for at least a complete circle. In the second stage, calibration, the position of the control points (x11, y11) and (x22, y22) are detected. These are locations of the reported touch/pen contacts used to calculate α(t0). One way to accomplish this is to have step motor 206 move the contact 202 at a low angular velocity, e.g., ω=0.03 rad/s, compared to a default nominal working angular velocity of ω=3 rad/s.
In the third stage, the parameters of the path are detected along with the center of the circle and the radius, as well as angular velocity. This may be performed at working velocities, e.g., ω=3 rad/s. Each of the reported samples are acquired and processed to determine these parameters. Error estimates are calculated based on the acquired data and obtained parameters.
Finally in the fourth stage the reported contacts and reported timestamps are collected. Previously obtained parameters of the model are used to measure panning latency. Panning latency may be computed for each reported point, which may be processed with respect to the model presented below to generate the report 212.
Example Panning Latency Measurement Using Interruptions
FIG. 3 depicts an example system 300 in which the test apparatus 102 is configured to perform panning latency measure using an interruption. As before, the device under test includes a display device 106 having sensors 110 and a touch module 112. The test apparatus 102 includes a contact 202 that is moved along a path by a step motor 206 and controlled by a step motor driver 208. In this example, however, the test apparatus 102 further includes an interruption module 302, which may include a photo interrupter circuit to detect a moment at which a contact 202 for the step motor 206 passes a control point, which may correspond to an angle of rotation for step motor α0 that is to be established.
A photo interrupter circuit of the interruption module 302 may include a light-emitting device (e.g., LED) and photo diode placed such that the LED emits focused light 304 (e.g., outside of the visible spectrum) towards the photo diode. The photo diode is configured to receive this focused light, e.g., which may include a lens is used to focus the beam, a groove to further obscure influence of the ambient light, and so on. Consequently, when an opaque object such as the contact 202 or other device connected to the step motor 206 (e.g., a needle) enters the space between LED and photo diode, the photo interrupter circuit reports a signal 306 to the test module 114. This detection may be used to estimate an angular position of the step motor 206 at the moment of interruption.
The interruption module 302 may add four additional components to the system 200 of FIG. 2. These components may include a needle is attached to the moving part of the step motor that is configured to initiate the photo interrupter circuit. The photo interrupter circuit may be placed on the fixed part of the step motor 206, e.g., the holder, and positioned in a such way that needle interrupts the optical beam between two parts of the photo interrupter, e.g., the light 304. Additionally, the interruption module 302 may be configured to include a microcontroller that is to receive an input from the photo interrupter circuit, record a timestamp of this event, and report this timestamp back to the test module 114. The microcontroller may be programmed to detect both rising and falling edge of the photo interrupter signal, allowing an accurate estimate for error in measurement to be established.
Once an event timestamp is received by the test module 114 (e.g., with less than 1 ms latency), a time of the event may be estimated and further used to reduce the error in measurement below 0.5 ms. This information may be later used to estimate actual physical position of the contact 202 at any given time and thus may be used to measure panning latency.
As before, the measurement process may be divided conceptually into four stages, setup, calibration, acquisition, and collection. Setup may be performed as previously described in relation to FIG. 2. For calibration, relatively low angular velocities may be used initially to detect reported positions of the contact 202 when a signal 306 from the interruption module 302 is received. The interruption module 302 may be configured to report two signals per interruption. Expected time between signals (e.g., rising and falling) may be estimated using the following expression:

Δsignal=Δneedle/Rωlow 

This expression is a good estimation when R>>dneedle. For default values of one millimeter for needle thickness, 0.03 rad/s for low angular velocity and 4.5 cm for radius, an expected amount time between signals is approximately 740 ms.

Reported positions (xi0 and yi0) may be collected around the time a signal 306 is received from the interruption module 302, which may then be interpolated to achieve an estimate to address occurrence of touch reports at different times than a photo interrupter signal. As a result, the position (xAV0,yAV0) of the contact 202 reported by the display device 106 may be obtained when rising edge of the photo interrupter signal is reported. Results of the falling edge measurement may be used to increase reliability and confidence. An error in measurement (defined as maximal error in measurement) may be calculated as follows:



  
    
      e
      x
      0
    
    =
    
      
        max
        
          i
          ≤
          k
        
      
      ⁢
      
        
        
          
            x
            i
            0
          
          -
          
            x
            AV
            0
          
        
        
      
    
  




  
    
      e
      y
      0
    
    =
    
      
        max
        
          i
          ≤
          k
        
      
      ⁢
      
        
        
          
            y
            i
            0
          
          -
          
            y
            AV
            0
          
        
        
      
    
  



Error as described above is usually a result of inaccuracies of the digitizer, however it may still be involved as part of error analysis.

For acquisition, properties of the path and angular velocity may be detected as follows. First, reported positions may be recorded for a plurality of cycles, which may or may not be complete, e.g., part of the circle may occur “off screen.”
Once recording is finished, estimates for the center of the circle (x00,y00) and the radius R may be calculated, e.g., a “best estimate” as described above. For example, the error of this estimate may be expressed as:



  
    
      
        e
        AV
      
      ⁡
      
        (
        
          
            x
            00
          
          ,
          
            y
            00
          
          ,
          R
        
        )
      
    
    =
    
      
        1
        n
      
      ⁢
      
        
          ∑
          
            i
            =
            1
          
          n
        
        ⁢
        
          
            
              R
              2
            
            -
            
              
                (
                
                  
                    x
                    i
                  
                  -
                  
                    x
                    00
                  
                
                )
              
              2
            
            -
            
              
                (
                
                  
                    y
                    i
                  
                  -
                  
                    y
                    00
                  
                
                )
              
              2
            
          
        
      
    
  




  
    
      
        e
        MAX
      
      ⁡
      
        (
        
          
            x
            00
          
          ,
          
            y
            00
          
          ,
          R
        
        )
      
    
    =
    
      
        max
        
          i
          ≤
          n
        
      
      ⁢
      
        
          
            R
            2
          
          -
          
            
              (
              
                
                  x
                  i
                
                -
                
                  x
                  00
                
              
              )
            
            2
          
          -
          
            
              (
              
                
                  y
                  i
                
                -
                
                  y
                  00
                
              
              )
            
            2
          
        
      
    
  



In one or more implementations, average error is targeted to be in the order of one pixel which maximum error not significantly different.

Angular velocity may be estimated using the reported timestamps of the photo interrupter rising signals. For each two consecutive reported rising edges, an angular velocity estimate may be defined as:




  
    ω
    k
  
  =
  
    
      2
      ⁢
      π
    
    
      
        t
        k
      
      -
      
        t
        
          k
          -
          1
        
      
    
  




Once recording is finished, an average for angular velocity may be defined as:





  
    ω
    AV
  
  =
  
    
      1
      n
    
    ⁢
    
      
        ∑
        
          k
          =
          1
        
        n
      
      ⁢
      
        ω
        k
      
    
  




Finally, an error in measurement may be defined as:





  
    e
    ω
  
  =
  
    
      max
      
        k
        ≤
        n
      
    
    ⁢
    
      
      
        
          ω
          k
        
        -
        
          ω
          AV
        
      
      
    
  




After collection, panning latency for each reported touch position may be calculated. With the previous two stages, parameters of the model have been established and hence for each reported point latency may be calculated as:



  
    
      Latency
      ⁡
      
        (
        
          
            x
            i
          
          ,
          y
          ,
          
            t
            R
          
        
        )
      
    
    =
    
      
        
          α
          ⁡
          
            (
            
              t
              R
            
            )
          
        
        -
        
          α
          ⁡
          
            (
            
              
                x
                i
              
              ,
              
                y
                i
              
            
            )
          
        
      
      ω
    
  




  where




  
    
      α
      ⁡
      
        (
        
          t
          R
        
        )
      
    
    =
    
      
        
          α
          ⁡
          
            (
            0
            )
          
        
        +
        
          ω
          ⁢
          
            
          
          ⁢
          
            t
            R
          
        
      
      =
      
        
          arctan
          ⁢
          
            
              
                y
                i
                0
              
              -
              
                y
                00
              
            
            
              
                x
                i
                0
              
              -
              
                x
                00
              
            
          
        
        +
        
          ω
          ⁢
          
            
          
          ⁢
          
            t
            R
          
        
      
    
  




  
    
      α
      ⁡
      
        (
        
          
            x
            i
          
          ,
          
            y
            i
          
        
        )
      
    
    =
    
      arctan
      ⁢
      
        
          
            y
            i
          
          -
          
            y
            00
          
        
        
          
            x
            i
          
          -
          
            x
            00
          
        
      
    
  



As previously mentioned, coordinates are in centimeters and not pixels in these examples although pixels and other units of measurement are also contemplated. It should also be noted that latency is independent on R value.

The error in measurement may be expressed as follows:




  
    δ
    
      Latency
      ⁡
      
        (
        
          
            x
            i
          
          ,
          
            y
            i
          
          ,
          
            t
            R
          
        
        )
      
    
  
  =
  
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              x
              i
              0
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            x
            i
            0
          
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              y
              i
              0
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            y
            i
            0
          
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            ω
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          ω
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              t
              R
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            t
            R
          
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              x
              00
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            x
            00
          
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              y
              00
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            y
            00
          
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              x
              i
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            x
            i
          
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              y
              i
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            y
            i
          
        
        
      
    
  




where upper limits may be directly applied and partial derivatives may be either explicitly calculated or numerically estimated.

A plurality of cycles (e.g., e.g., several dozen) may be performed to store reported positions and timestamps xi,yi,tR. These values may then be used to calculate latency. Once latency is calculated, a distribution function may be built over each of the examples and a mean latency extracted from this distribution. This step can be used as a final check point, as a normal Gaussian distribution is expected as a result of this process.
Error Estimate
In the previous example of FIG. 2, the error estimate for the latency may be expressed as follows:




  
    δ
    
      Latency
      ⁡
      
        (
        
          
            x
            i
          
          ,
          
            y
            i
          
          ,
          
            t
            R
          
        
        )
      
    
  
  =
  
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              x
              i
              0
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            x
            i
            0
          
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              y
              i
              0
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            y
            i
            0
          
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            ω
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          ω
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              t
              R
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            t
            R
          
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              x
              00
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            x
            00
          
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              y
              00
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            y
            00
          
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              x
              i
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            x
            i
          
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              y
              i
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            y
            i
          
        
        
      
    
  




This may be broken down into the following pieces and used to provide upper estimates:



  
    
      
    
    ⁢
    
      
        δ
        ⁢
        
          
        
        ⁢
        
          x
          i
        
      
      =
      
        
          ScreenWidth
          cm
        
        
          2
          *
          
            ScreenWidth
            pixels
          
        
      
    
  




  
    
      
    
    ⁢
    
      
        δ
        ⁢
        
          
        
        ⁢
        
          y
          i
        
      
      =
      
        
          ScreenHeight
          cm
        
        
          2
          *
          
            ScreenHeight
            pixels
          
        
      
    
  




  
    
      
    
    ⁢
    
      
        δ
        ⁢
        
          
        
        ⁢
        
          t
          R
        
      
      =
      
        0.5
        ⁢
        
          
        
        ⁢
        ms
      
    
  




  
    
      
    
    ⁢
    
      
        δ
        ⁢
        
          
        
        ⁢
        
          x
          i
          0
        
      
      =
      
        
          max
          ⁢
          
            {
            
              
                e
                x
                0
              
              ,
              
                δ
                ⁢
                
                  
                
                ⁢
                
                  x
                  i
                
              
            
            }
          
        
        =
        
          max
          ⁢
          
            {
            
              
                
                  max
                  
                    i
                    ≤
                    k
                  
                
                ⁢
                
                  
                  
                    
                      x
                      i
                      0
                    
                    -
                    
                      x
                      AV
                      0
                    
                  
                  
                
              
              ,
              
                
                  ScreenWidth
                  cm
                
                
                  2
                  *
                  
                    ScreenWidth
                    pixels
                  
                
              
            
            }
          
        
      
    
  




  
    
      
    
    ⁢
    
      
        δ
        ⁢
        
          
        
        ⁢
        
          y
          i
          0
        
      
      =
      
        
          max
          ⁢
          
            {
            
              
                e
                y
                0
              
              ,
              
                δ
                ⁢
                
                  
                
                ⁢
                
                  y
                  i
                
              
            
            }
          
        
        =
        
          max
          ⁢
          
            {
            
              
                
                  max
                  
                    i
                    ≤
                    k
                  
                
                ⁢
                
                  
                  
                    
                      y
                      i
                      0
                    
                    -
                    
                      y
                      AV
                      0
                    
                  
                  
                
              
              ,
              
                
                  ScreenHeight
                  cm
                
                
                  2
                  *
                  
                    ScreenHeight
                    pixels
                  
                
              
            
            }
          
        
      
    
  




  
    
      
    
    ⁢
    
      
        δ
        ⁢
        
          
        
        ⁢
        ω
      
      =
      
        
          max
          ⁢
          
            {
            
              
                e
                ω
              
              ,
              
                
                  2
                  *
                  δ
                  ⁢
                  
                    
                  
                  ⁢
                  
                    t
                    R
                  
                
                
                  ω
                  2
                
              
            
            }
          
        
        =
        
          max
          ⁢
          
            {
            
              
                
                  max
                  
                    k
                    ≤
                    n
                  
                
                ⁢
                
                  
                  
                    
                      ω
                      k
                    
                    -
                    
                      ω
                      AV
                    
                  
                  
                
              
              ,
              
                
                  2
                  *
                  δ
                  ⁢
                  
                    
                  
                  ⁢
                  
                    t
                    R
                  
                
                
                  ω
                  2
                
              
            
            }
          
        
      
    
  




  
    
      δ
      ⁢
      
        
      
      ⁢
      
        x
        00
      
    
    =
    
      
        max
        ⁢
        
          {
          
            
              
                e
                MAX
              
              ⁡
              
                (
                
                  
                    x
                    00
                  
                  ,
                  
                    y
                    00
                  
                  ,
                  R
                
                )
              
            
            ,
            
              δ
              ⁢
              
                
              
              ⁢
              
                x
                i
              
            
          
          }
        
      
      =
      
        max
        ⁢
        
          {
          
            
              
                max
                
                  i
                  ≤
                  n
                
              
              ⁢
              
                
                  
                    R
                    2
                  
                  -
                  
                    
                      (
                      
                        
                          x
                          i
                        
                        -
                        
                          x
                          00
                        
                      
                      )
                    
                    2
                  
                  -
                  
                    
                      (
                      
                        
                          y
                          i
                        
                        -
                        
                          y
                          00
                        
                      
                      )
                    
                    2
                  
                
              
            
            ,
            
              
                ScreenWidth
                cm
              
              
                2
                *
                
                  ScreenWidth
                  pixels
                
              
            
          
          }
        
      
    
  




  
    
      δ
      ⁢
      
        
      
      ⁢
      
        y
        00
      
    
    =
    
      
        max
        ⁢
        
          {
          
            
              
                e
                MAX
              
              ⁡
              
                (
                
                  
                    x
                    00
                  
                  ,
                  
                    y
                    00
                  
                  ,
                  R
                
                )
              
            
            ,
            
              δ
              ⁢
              
                
              
              ⁢
              
                y
                i
              
            
          
          }
        
      
      =
      
        max
        ⁢
        
          {
          
            
              
                max
                
                  i
                  ≤
                  n
                
              
              ⁢
              
                
                  
                    R
                    2
                  
                  -
                  
                    
                      (
                      
                        
                          x
                          i
                        
                        -
                        
                          x
                          00
                        
                      
                      )
                    
                    2
                  
                  -
                  
                    
                      (
                      
                        
                          y
                          i
                        
                        -
                        
                          y
                          00
                        
                      
                      )
                    
                    2
                  
                
              
            
            ,
            
              
                ScreenHeight
                cm
              
              
                2
                *
                
                  ScreenHeight
                  pixels
                
              
            
          
          }
        
      
    
  



The upper error estimates as proposed above are either coming as a result of direct error in measurement (the first three: δxi, δyi, and δtR) or are a derived from more complex indirect measurements. This is because the latter three (δω, δx00, and δy00) and more particularly the middle two (δxi0 and δyi0) fall in between two categories as measurements of those made directly. Expectations for δxi0 and δyi0 may be defined in which both parts of the error are roughly the same (ex ̃δxi and ey ̃δyi), which is an indication of confident measurement and acceptable response of the sensors 110. In case ex>>δxi, the sensors 110 (which may be independently verified) or the entire setup (e.g., systematic errors) may be blamed. In case ex<<δxi, this may involve a false indication of the accuracy in measurement.
Example Panning Latency Measurement Using a Laser
FIG. 4 depicts an example system 400 in which the test apparatus 102 is configured to perform panning latency measure using a laser. As before, the device under test includes a display device 106 having sensors 110 and a touch module 112. The test apparatus 102 includes a contact 202 that is moved along a path by a step motor 206 and controlled by a step motor driver 208. In this example, however, the test apparatus 102 further includes a laser 402 (e.g., class IIIA laser) and a photo diode 404 (e.g., inverse polarized photo diode and 1MΩ resistor) to detect a moment at which a contact 202 for the step motor 206 passes a control point. In one or more implementations, a sensing area of the photo diode 404 may be reduced, such as to use an opaque tape having a hole sized to provide desired sensitivity, e.g., hole diameter less than 0.5 mm.
The laser 402 and photo diode 406 may be placed in a variety of ways to detect movement of the contact 202. As illustrated, for instance, the laser 402 may be placed on a surface of the display device 106 under test such that contact 202 interrupts the laser beam 306 when it passes in front of it. In this way, a position and timestamp of the contact 202 may be accurately determined at this control point. This technique may be combined with the step motor 206 approach discussed previously in relation to FIG. 2. In another example, the laser 402 may be placed outside the path 204 such that the contact 202 passes through the laser beam 406 twice when moving along the path 204. A variety of other examples are also contemplated.
In the first solution, a single control point is leveraged, while in the second solution two control points may be leveraged. The control points may be differentiated from each other in the acquisition and collection stage, e.g., which may include “ignoring” the second control point that is further away and “keeping” the first control point that is closest to the photo diode 404. One way to accomplish this is to calculate the distance from the last reported position to both control points, which may be established during calibration. A simple criterion may include ignore the reported control point if last reported position is closer to the second (farther) control position.
This criterion will work for angular velocities and relative low latencies. A threshold angular velocity value for a device that exhibits “poor” panning latency (e.g., panning latency  ̃100 ms), whereas target panning latency may be set around 15 ms. Threshold angular velocity may be defined using the following expression:




  
    ω
    threshold
  
  =
  
    π
    latency
  




For the example above, the threshold angular velocity is approximately 31.42 rad/s, which is ten times more than target nominal angular velocity, hence this approach is sufficient for this example.

Another way to differentiate between the two reported control points can also be devised if laser beam 404 does not go through the center of the path 204. In this case, a timestamp of the reported control point may be used to differentiate between the two. A criterion then becomes ignore the reported control point if time between last two consecutive reported control points is smaller than the time of the previous two consecutive reported control points. With these two criteria, the problem of placement of laser 402 and photo diode 404 has been reduced to a single control point, although other examples are also contemplated.
The test module 114 may receive a signal 408 from the photo diode and record the timestamp of this event. The test module 114 may be configured to detect both rising and falling edge of the photo diode 404 signal 408, allowing an accurate estimate for error in measurement.
The test module 114 may then be configured to estimate a time the event occurred based on the event timestamp (e.g., with less than 1 ms latency) and further reduce the error in measurement to below 0.5 ms. This information may be used to estimate actual physical position of the contact 202 at any given time, which may be used to measure panning latency.
The system 400 may include components as previously described, such as the contact 202, step motor 206, step motor driver 208, a leveling surface, test module 114, and so on. Further, the measurement may also be divided into stages as previously described, such as to setup the laser 402, calibration, measurement, and so on.
In regards to calibration and detection of position of control points based on collected data, low angular velocities may be used to detect reported position of the contact 202 when the signal 408 from the photo diode 404 is received. The photo diode, for instance, may report two signals per interruption. An expected time between signals (rising and falling) may be estimated with:

Δsignal=dstick/pen/Rωlow 

As before, this equation provides a good estimate when R>>contact 202. For default values of 8 mm for contact 202 thickness, 0.03 rad/s for low angular velocity and 4.5 cm for radius of the path 204, an expected time between signals is approximately 5926 ms. This measurement may be repeated, e.g., a dozen times, more than 35 times if absolute maximal error is more than one pixel, and so on.

The reported positions (xi0 and yi0) are recorded around the time the signal 408 is received from the photo diode. The recorded positions may be interpolated to arrive at an estimate, e.g., as touch reports may not occur at the same time as the photo diode 404 signal 408.
As a result, the reported position (by a digitizer of the display device 106) (xAV0,yAV0) of the contact 202 when rising edge of the photo diode 404 signal 408 is obtained. Results of the falling edge measurement may be used to increase reliability and confidence as previously described in relation to FIG. 3.
An error in measurement (defined as maximal error in measurement) may be calculated as follows:



  
    
      e
      x
      0
    
    =
    
      
        max
        
          i
          ≤
          k
        
      
      ⁢
      
        
        
          
            x
            i
            0
          
          -
          
            x
            AV
            0
          
        
        
      
    
  




  
    
      e
      y
      0
    
    =
    
      
        max
        
          i
          ≤
          k
        
      
      ⁢
      
        
        
          
            y
            i
            0
          
          -
          
            y
            AV
            0
          
        
        
      
    
  



Error as described above is expected to be more significant than the actual methodological error in measurement (which comes as a result of latency introduced by the microcontroller) in the current example, however both are considered in the later error analysis described below.

Regarding acquisition and detection of properties of the path and angular velocity, this may be accomplished by recording reported positions for several cycles, e.g., a dozen or more as previously described. As described in relation to FIG. 3, cycles may be incomplete, e.g. a part of the cycle contacts the display device 106 while another part does not. Once recording is finished, the best estimates for the center of the circle (x00,y00) and the radius R may be calculated as also previously described. The error of this estimate is may be expressed as follows:



  
    
      
        e
        AV
      
      ⁡
      
        (
        
          
            x
            00
          
          ,
          
            y
            00
          
          ,
          R
        
        )
      
    
    =
    
      
        1
        n
      
      ⁢
      
        
          ∑
          
            i
            =
            1
          
          n
        
        ⁢
        
          
            
              R
              2
            
            -
            
              
                (
                
                  
                    x
                    i
                  
                  -
                  
                    x
                    00
                  
                
                )
              
              2
            
            -
            
              
                (
                
                  
                    y
                    i
                  
                  -
                  
                    y
                    00
                  
                
                )
              
              2
            
          
        
      
    
  




  
    
      
        e
        MAX
      
      ⁡
      
        (
        
          
            x
            00
          
          ,
          
            y
            00
          
          ,
          R
        
        )
      
    
    =
    
      
        max
        
          i
          ≤
          n
        
      
      ⁢
      
        
          
            R
            2
          
          -
          
            
              (
              
                
                  x
                  i
                
                -
                
                  x
                  00
                
              
              )
            
            2
          
          -
          
            
              (
              
                
                  y
                  i
                
                -
                
                  y
                  00
                
              
              )
            
            2
          
        
      
    
  



In one or more implementations, average error is targeted to be in the order of one pixel and maximum error is not significantly different.

Angular velocity is estimated by using the reported timestamps of the photo diode rising signals. For each two consecutive reported rising edges, an angular velocity estimate may be defined as:




  
    ω
    k
  
  =
  
    
      2
      ⁢
      π
    
    
      
        t
        k
      
      -
      
        t
        
          k
          -
          1
        
      
    
  




Once recording is finished, an average for angular velocity may be defined as:





  
    ω
    AV
  
  =
  
    
      1
      n
    
    ⁢
    
      
        ∑
        
          k
          =
          1
        
        n
      
      ⁢
      
        ω
        k
      
    
  




Thus, an error in measurement may be defined as:





  
    e
    ω
  
  =
  
    
      max
      
        k
        ≤
        n
      
    
    ⁢
    
      
      
        
          ω
          k
        
        -
        
          ω
          AV
        
      
      
    
  




collection, calculate panning latency for each reported touch position
With the previous two stages, parameters of the model have been established and hence for each reported point latency may be calculated as:



  
    
      Latency
      ⁡
      
        (
        
          
            x
            i
          
          ,
          y
          ,
          
            t
            R
          
        
        )
      
    
    =
    
      
        
          α
          ⁡
          
            (
            
              t
              R
            
            )
          
        
        -
        
          α
          ⁡
          
            (
            
              
                x
                i
              
              ,
              
                y
                i
              
            
            )
          
        
      
      ω
    
  




  where




  
    
      α
      ⁡
      
        (
        
          t
          R
        
        )
      
    
    =
    
      
        
          α
          ⁡
          
            (
            0
            )
          
        
        +
        
          ω
          ⁢
          
            
          
          ⁢
          
            t
            R
          
        
      
      =
      
        
          arctan
          ⁢
          
            
              
                y
                i
                0
              
              -
              
                y
                00
              
            
            
              
                x
                i
                0
              
              -
              
                x
                00
              
            
          
        
        +
        
          ω
          ⁢
          
            
          
          ⁢
          
            t
            R
          
        
      
    
  




  
    
      α
      ⁡
      
        (
        
          
            x
            i
          
          ,
          
            y
            i
          
        
        )
      
    
    =
    
      arctan
      ⁢
      
        
          
            y
            i
          
          -
          
            y
            00
          
        
        
          
            x
            i
          
          -
          
            x
            00
          
        
      
    
  



Again, as previously mentioned, the coordinates in this example are expressed in centimeters but other units are also contemplated, such as pixels. As also mentioned, latency is independent of R value.
The error in measurement may be expressed as follows:




  
    δ
    
      Latency
      ⁡
      
        (
        
          
            x
            i
          
          ,
          
            y
            i
          
          ,
          
            t
            R
          
        
        )
      
    
  
  =
  
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              x
              i
              0
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            x
            i
            0
          
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              y
              i
              0
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            y
            i
            0
          
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            ω
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          ω
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              t
              R
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            t
            R
          
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              x
              00
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            x
            00
          
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              y
              00
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            y
            00
          
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              x
              i
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            x
            i
          
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              y
              i
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            y
            i
          
        
        
      
    
  




where upper limits are directly applied and partial derivatives may be either explicitly calculated or numerically estimated.

A plurality of cycles may be recorded, with reported positions and timestamps xi,yi,tR, stored. Those values may then be used to calculate latency. Once the latency is calculated, a distribution function may be built over each and mean latency may be extracted from this distribution. This step can be used as a check point, as a normal Gaussian distribution is expected as a result of this process.
In the previous discussion, the error estimate for the latency is expressed as follows:




  
    δ
    
      Latency
      ⁡
      
        (
        
          
            x
            i
          
          ,
          
            y
            i
          
          ,
          
            t
            R
          
        
        )
      
    
  
  =
  
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              x
              i
              0
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            x
            i
            0
          
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              y
              i
              0
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            y
            i
            0
          
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            ω
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          ω
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              t
              R
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            t
            R
          
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              x
              00
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            x
            00
          
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              y
              00
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            y
            00
          
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              x
              i
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            x
            i
          
        
        
      
    
    +
    
      
        
        
          
            ∂
            Latency
          
          
            ∂
            
              y
              i
            
          
        
        
      
      ⁢
      
        
        
          δ
          ⁢
          
            
          
          ⁢
          
            y
            i
          
        
        
      
    
  




This may be broken down into pieces as before to provide upper estimates:




  
    
      
    
    ⁢
    
      
        δ
        ⁢
        
          
        
        ⁢
        
          x
          i
        
      
      =
      
        
          ScreenWidth
          cm
        
        
          2
          *
          
            ScreenWidth
            pixels
          
        
      
    
  




  
    
      
    
    ⁢
    
      
        δ
        ⁢
        
          
        
        ⁢
        
          y
          i
        
      
      =
      
        
          ScreenHeight
          cm
        
        
          2
          *
          
            ScreenHeight
            pixels
          
        
      
    
  




  
    
      
    
    ⁢
    
      
        δ
        ⁢
        
          
        
        ⁢
        
          t
          R
        
      
      =
      
        0.5
        ⁢
        
          
        
        ⁢
        ms
      
    
  




  
    
      
    
    ⁢
    
      
        δ
        ⁢
        
          
        
        ⁢
        
          x
          i
          0
        
      
      =
      
        
          max
          ⁢
          
            {
            
              
                e
                x
                0
              
              ,
              
                δ
                ⁢
                
                  
                
                ⁢
                
                  x
                  i
                
              
            
            }
          
        
        =
        
          max
          ⁢
          
            {
            
              
                
                  max
                  
                    i
                    ≤
                    k
                  
                
                ⁢
                
                  
                  
                    
                      x
                      i
                      0
                    
                    -
                    
                      x
                      AV
                      0
                    
                  
                  
                
              
              ,
              
                
                  ScreenWidth
                  cm
                
                
                  2
                  *
                  
                    ScreenWidth
                    pixels
                  
                
              
            
            }
          
        
      
    
  




  
    
      
    
    ⁢
    
      
        δ
        ⁢
        
          
        
        ⁢
        
          y
          i
          0
        
      
      =
      
        
          max
          ⁢
          
            {
            
              
                e
                y
                0
              
              ,
              
                δ
                ⁢
                
                  
                
                ⁢
                
                  y
                  i
                
              
            
            }
          
        
        =
        
          max
          ⁢
          
            {
            
              
                
                  max
                  
                    i
                    ≤
                    k
                  
                
                ⁢
                
                  
                  
                    
                      y
                      i
                      0
                    
                    -
                    
                      y
                      AV
                      0
                    
                  
                  
                
              
              ,
              
                
                  ScreenHeight
                  cm
                
                
                  2
                  *
                  
                    ScreenHeight
                    pixels
                  
                
              
            
            }
          
        
      
    
  




  
    
      
    
    ⁢
    
      
        δ
        ⁢
        
          
        
        ⁢
        ω
      
      =
      
        
          max
          ⁢
          
            {
            
              
                e
                ω
              
              ,
              
                
                  2
                  *
                  δ
                  ⁢
                  
                    
                  
                  ⁢
                  
                    t
                    R
                  
                
                
                  ω
                  2
                
              
            
            }
          
        
        =
        
          max
          ⁢
          
            {
            
              
                
                  max
                  
                    k
                    ≤
                    n
                  
                
                ⁢
                
                  
                  
                    
                      ω
                      k
                    
                    -
                    
                      ω
                      AV
                    
                  
                  
                
              
              ,
              
                
                  2
                  *
                  δ
                  ⁢
                  
                    
                  
                  ⁢
                  
                    t
                    R
                  
                
                
                  ω
                  2
                
              
            
            }
          
        
      
    
  




  
    
      δ
      ⁢
      
        
      
      ⁢
      
        x
        00
      
    
    =
    
      
        max
        ⁢
        
          {
          
            
              
                e
                MAX
              
              ⁡
              
                (
                
                  
                    x
                    00
                  
                  ,
                  
                    y
                    00
                  
                  ,
                  R
                
                )
              
            
            ,
            
              δ
              ⁢
              
                
              
              ⁢
              
                x
                i
              
            
          
          }
        
      
      =
      
        max
        ⁢
        
          {
          
            
              
                max
                
                  i
                  ≤
                  n
                
              
              ⁢
              
                
                  
                    R
                    2
                  
                  -
                  
                    
                      (
                      
                        
                          x
                          i
                        
                        -
                        
                          x
                          00
                        
                      
                      )
                    
                    2
                  
                  -
                  
                    
                      (
                      
                        
                          y
                          i
                        
                        -
                        
                          y
                          00
                        
                      
                      )
                    
                    2
                  
                
              
            
            ,
            
              
                ScreenWidth
                cm
              
              
                2
                *
                
                  ScreenWidth
                  pixels
                
              
            
          
          }
        
      
    
  




  
    
      δ
      ⁢
      
        
      
      ⁢
      
        y
        00
      
    
    =
    
      
        max
        ⁢
        
          {
          
            
              
                e
                MAX
              
              ⁡
              
                (
                
                  
                    x
                    00
                  
                  ,
                  
                    y
                    00
                  
                  ,
                  R
                
                )
              
            
            ,
            
              δ
              ⁢
              
                
              
              ⁢
              
                y
                i
              
            
          
          }
        
      
      =
      
        max
        ⁢
        
          {
          
            
              
                max
                
                  i
                  ≤
                  n
                
              
              ⁢
              
                
                  
                    R
                    2
                  
                  -
                  
                    
                      (
                      
                        
                          x
                          i
                        
                        -
                        
                          x
                          00
                        
                      
                      )
                    
                    2
                  
                  -
                  
                    
                      (
                      
                        
                          y
                          i
                        
                        -
                        
                          y
                          00
                        
                      
                      )
                    
                    2
                  
                
              
            
            ,
            
              
                ScreenHeight
                cm
              
              
                2
                *
                
                  ScreenHeight
                  pixels
                
              
            
          
          }
        
      
    
  



The upper error estimates as proposed above are a result of direct error in measurement (e.g., the first three: δxi, δyi, and δtR) or are a derived from indirect measurements (e.g., as the latter three: δω, δω00, and δy00). The middle two (δxi0 and δyi0) fall in between two categories, as these are measured directly but the measurement may be repeated a number of times. Expectations for δxi0 and δyi0 may be made that both parts of the error are generally the same (ex ̃δxi and ey ̃δyi), which is an indication of confident measurement and desirability in the operation of the display device 106, e.g., a touch digitizer of the display device. In case ex>>δxi, this may be caused by the display device 106, which can be independently verified. This may also be caused through systemic errors. In case ex<<δxi, a false indication may be obtained in the accuracy in measurement.
Example Procedures
The following discussion describes panning latency measurement techniques that may be implemented utilizing the previously described systems and devices. Aspects of each of the procedures may be implemented in hardware, firmware, or software, or a combination thereof. The procedures are shown as a set of blocks that specify operations performed by one or more devices and are not necessarily limited to the orders shown for performing the operations by the respective blocks. In portions of the following discussion, reference will be made to the environment 100 of FIG. 1 and the systems 200-400 of FIGS. 2-4, respectively.
FIG. 5 depicts a procedure 500 in an example implementation in which latency is measured of a device in recognizing movement. Data is received by a test apparatus that describes panning movement detected using touch functionality of a device (block 502). A device under test, for instance, may provide an output to the test module 114, such as an HID report 210 that describes recognition by the device 106 of the panning movement.
Latency is measured, by the test apparatus, of the device to recognize the panning movement to initiate one or more operations of the device (block 504). A variety of different types of latency may be measured as previously described, such as hardware latency, end-to-end latency, and so on. A variety of other examples are also contemplated, such as an example in which the contact is provided manually by a user, e.g., by following a display of an object across the display device 106.
Example System and Device
FIG. 6 illustrates an example system generally at 600 that includes an example computing device 602 that is representative of one or more computing systems and/or devices that may implement the various techniques described herein. The computing device 602 may be, for example, a server of a service provider, a device associated with a client (e.g., a client device), an on-chip system, and/or any other suitable computing device or computing system.
The example computing device 602 as illustrated includes a processing system 604, one or more computer-readable media 606, and one or more I/O interface 608 that are communicatively coupled, one to another. Although not shown, the computing device 602 may further include a system bus or other data and command transfer system that couples the various components, one to another. A system bus can include any one or combination of different bus structures, such as a memory bus or memory controller, a peripheral bus, a universal serial bus, and/or a processor or local bus that utilizes any of a variety of bus architectures. A variety of other examples are also contemplated, such as control and data lines.
The processing system 604 is representative of functionality to perform one or more operations using hardware. Accordingly, the processing system 604 is illustrated as including hardware element 610 that may be configured as processors, functional blocks, and so forth. This may include implementation in hardware as an application specific integrated circuit or other logic device formed using one or more semiconductors. The hardware elements 610 are not limited by the materials from which they are formed or the processing mechanisms employed therein. For example, processors may be comprised of semiconductor(s) and/or transistors (e.g., electronic integrated circuits (ICs)). In such a context, processor-executable instructions may be electronically-executable instructions.
The computer-readable storage media 606 is illustrated as including memory/storage 612. The memory/storage 612 represents memory/storage capacity associated with one or more computer-readable media. The memory/storage component 612 may include volatile media (such as random access memory (RAM)) and/or nonvolatile media (such as read only memory (ROM), Flash memory, optical disks, magnetic disks, and so forth). The memory/storage component 612 may include fixed media (e.g., RAM, ROM, a fixed hard drive, and so on) as well as removable media (e.g., Flash memory, a removable hard drive, an optical disc, and so forth). The computer-readable media 606 may be configured in a variety of other ways as further described below.
Input/output interface(s) 608 are representative of functionality to allow a user to enter commands and information to computing device 602, and also allow information to be presented to the user and/or other components or devices using various input/output devices. Examples of input devices include a keyboard, a cursor control device (e.g., a mouse), a microphone, a scanner, touch functionality (e.g., capacitive or other sensors that are configured to detect physical touch), a camera (e.g., which may employ visible or non-visible wavelengths such as infrared frequencies to recognize movement as gestures that do not involve touch), and so forth. Examples of output devices include a display device (e.g., a monitor or projector), speakers, a printer, a network card, tactile-response device, and so forth. Thus, the computing device 602 may be configured in a variety of ways as further described below to support user interaction.
Various techniques may be described herein in the general context of software, hardware elements, or program modules. Generally, such modules include routines, programs, objects, elements, components, data structures, and so forth that perform particular tasks or implement particular abstract data types. The terms “module,” “functionality,” and “component” as used herein generally represent software, firmware, hardware, or a combination thereof. The features of the techniques described herein are platform-independent, meaning that the techniques may be implemented on a variety of commercial computing platforms having a variety of processors.
An implementation of the described modules and techniques may be stored on or transmitted across some form of computer-readable media. The computer-readable media may include a variety of media that may be accessed by the computing device 602. By way of example, and not limitation, computer-readable media may include “computer-readable storage media” and “computer-readable signal media.”
“Computer-readable storage media” may refer to media and/or devices that enable persistent and/or non-transitory storage of information in contrast to mere signal transmission, carrier waves, or signals per se. Thus, computer-readable storage media refers to non-signal bearing media. The computer-readable storage media includes hardware such as volatile and non-volatile, removable and non-removable media and/or storage devices implemented in a method or technology suitable for storage of information such as computer readable instructions, data structures, program modules, logic elements/circuits, or other data. Examples of computer-readable storage media may include, but are not limited to, RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disks (DVD) or other optical storage, hard disks, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or other storage device, tangible media, or article of manufacture suitable to store the desired information and which may be accessed by a computer.
“Computer-readable signal media” may refer to a signal-bearing medium that is configured to transmit instructions to the hardware of the computing device 602, such as via a network. Signal media typically may embody computer readable instructions, data structures, program modules, or other data in a modulated data signal, such as carrier waves, data signals, or other transport mechanism. Signal media also include any information delivery media. The term “modulated data signal” means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media include wired media such as a wired network or direct-wired connection, and wireless media such as acoustic, RF, infrared, and other wireless media.
As previously described, hardware elements 610 and computer-readable media 606 are representative of modules, programmable device logic and/or fixed device logic implemented in a hardware form that may be employed in some embodiments to implement at least some aspects of the techniques described herein, such as to perform one or more instructions. Hardware may include components of an integrated circuit or on-chip system, an application-specific integrated circuit (ASIC), a field-programmable gate array (FPGA), a complex programmable logic device (CPLD), and other implementations in silicon or other hardware. In this context, hardware may operate as a processing device that performs program tasks defined by instructions and/or logic embodied by the hardware as well as a hardware utilized to store instructions for execution, e.g., the computer-readable storage media described previously.
Combinations of the foregoing may also be employed to implement various techniques described herein. Accordingly, software, hardware, or executable modules may be implemented as one or more instructions and/or logic embodied on some form of computer-readable storage media and/or by one or more hardware elements 610. The computing device 602 may be configured to implement particular instructions and/or functions corresponding to the software and/or hardware modules. Accordingly, implementation of a module that is executable by the computing device 602 as software may be achieved at least partially in hardware, e.g., through use of computer-readable storage media and/or hardware elements 610 of the processing system 604. The instructions and/or functions may be executable/operable by one or more articles of manufacture (for example, one or more computing devices 602 and/or processing systems 604) to implement techniques, modules, and examples described herein.
As further illustrated in FIG. 6, the example system 600 enables ubiquitous environments for a seamless user experience when running applications on a personal computer (PC), a television device, and/or a mobile device. Services and applications run substantially similar in all three environments for a common user experience when transitioning from one device to the next while utilizing an application, playing a video game, watching a video, and so on.
In the example system 600, multiple devices are interconnected through a central computing device. The central computing device may be local to the multiple devices or may be located remotely from the multiple devices. In one embodiment, the central computing device may be a cloud of one or more server computers that are connected to the multiple devices through a network, the Internet, or other data communication link.
In one embodiment, this interconnection architecture enables functionality to be delivered across multiple devices to provide a common and seamless experience to a user of the multiple devices. Each of the multiple devices may have different physical requirements and capabilities, and the central computing device uses a platform to enable the delivery of an experience to the device that is both tailored to the device and yet common to all devices. In one embodiment, a class of target devices is created and experiences are tailored to the generic class of devices. A class of devices may be defined by physical features, types of usage, or other common characteristics of the devices.
In various implementations, the computing device 602 may assume a variety of different configurations, such as for computer 614, mobile 616, and television 618 uses. Each of these configurations includes devices that may have generally different constructs and capabilities, and thus the computing device 602 may be configured according to one or more of the different device classes. For instance, the computing device 602 may be implemented as the computer 614 class of a device that includes a personal computer, desktop computer, a multi-screen computer, laptop computer, netbook, and so on.
The computing device 602 may also be implemented as the mobile 616 class of device that includes mobile devices, such as a mobile phone, portable music player, portable gaming device, a tablet computer, a multi-screen computer, and so on. The computing device 602 may also be implemented as the television 618 class of device that includes devices having or connected to generally larger screens in casual viewing environments. These devices include televisions, set-top boxes, gaming consoles, and so on.
The techniques described herein in relation to the test module 114 and even the device under test may be supported by these various configurations of the computing device 602 and are not limited to the specific examples of the techniques described herein. This functionality of the test module 114 may also be implemented all or in part through use of a distributed system, such as over a “cloud” 620 via a platform 622 as described below.
The cloud 620 includes and/or is representative of a platform 622 for resources 624. The platform 622 abstracts underlying functionality of hardware (e.g., servers) and software resources of the cloud 620. The resources 624 may include applications and/or data that can be utilized while computer processing is executed on servers that are remote from the computing device 602. Resources 624 can also include services provided over the Internet and/or through a subscriber network, such as a cellular or Wi-Fi network.
The platform 622 may abstract resources and functions to connect the computing device 602 with other computing devices. The platform 622 may also serve to abstract scaling of resources to provide a corresponding level of scale to encountered demand for the resources 624 that are implemented via the platform 622. Accordingly, in an interconnected device embodiment, implementation of functionality described herein may be distributed throughout the system 600. For example, the functionality may be implemented in part on the computing device 602 as well as via the platform 622 that abstracts the functionality of the cloud 620.
Conclusion
Although the invention has been described in language specific to structural features and/or methodological acts, it is to be understood that the invention defined in the appended claims is not necessarily limited to the specific features or acts described. Rather, the specific features and acts are disclosed as example forms of implementing the claimed invention.

## Claims

1. A test apparatus comprising:
one or more motors configured to move one or more contacts at least proximal to one or more sensors of a device to be detectable as movement; and
one or more modules implemented at least partially in hardware to measure latency of the device to recognize the movement of the one or more contacts.

2. A test apparatus as described in claim 1, wherein the one or more modules are configured to measure the latency as hardware latency of the device in recognizing the movement.

3. A test apparatus as described in claim 1, wherein the one or more modules are configured to measure the latency as end-to-end latency of the device in recognizing the movement.

4. A test apparatus as described in claim 1, wherein the one or more motors are configured as a step motor.

5. A test apparatus as described in claim 4, wherein the step motor is configured to move the one or more contacts to form a circular path, at least a portion of which is detectable by the one or more sensors of the device.

6. A test apparatus as described in claim 1, wherein the one or more modules are configured to measure the latency of the device in recognizing the movement through use of constant angular velocity.

7. A test apparatus as described in claim 1, wherein the one or more sensors of the device are configured to detect the one or more contacts as at least proximal through configuration as a touch sensor, infrared sensor, optical imaging sensor, dispersive signal sensor, sensor in pixel, resistive sensor, or acoustic pulse recognition sensor.

8. A test apparatus as described in claim 1, wherein the one or more modules include an interruption module having a photo interrupter circuit configured to detect position of the one or more contacts, which is used at least in part to measure the latency.

9. A test apparatus as described in claim 8, wherein the interruption module is configured to detect when the one or more contacts passes a control point to determine an angle of rotation for the contact by the one or more motors.

10. A test apparatus as described in claim 1, further comprising a laser and a photo diode that is configured to detect when the one or more contacts passes between the laser and the photo diode, which is used at least in part to measure the latency.

11. A method comprising:
moving one or more contacts, by one or more motors, at least proximal to one or more sensors of a device to be detectable as movement; and
measuring latency of the device to recognize the movement of the one or more contacts by one or more modules implemented at least partially in hardware.

12. A method as described in claim 11, wherein the one or more motors are configured as a step motor.

13. A method as described in claim 12, wherein the step motor is configured to move the one or more contacts to form a circular path, at least a portion of which is detectable by the one or more sensors of the device.

14. A method as described in claim 11, wherein the one or more modules include an interruption module having a photo interrupter circuit configured to detect position of the one or more contacts, which is used at least in part to measure the latency.

15. A method as described in claim 14, wherein the interruption module is configured to detect when the one or more contacts passes a control point to determine an angle of rotation for the contact by the one or more motors.

16. A method as described in claim 11, wherein the one or more modules are configured to measure the latency as hardware latency of the device in recognizing the movement.

17. A method as described in claim 11, wherein the one or more modules are configured to measure the latency as end-to-end latency of the device in recognizing the movement.

18. A method as described in claim 11, wherein the one or more modules are configured to measure the latency of the device in recognizing the movement through use of constant angular velocity.

19. A method as described in claim 11, wherein the one or more sensors of the device are configured to detect the one or more contacts as at least proximal through configuration as a touch sensor, infrared sensor, optical imaging sensor, dispersive signal sensor, sensor in pixel, resistive sensor, or acoustic pulse recognition sensor.

20. A method as described in claim 11, further comprising a laser and a photo diode that is configured to detect when the one or more contacts passes between the laser and the photo diode, which is used at least in part to measure the latency.