Physical buttons are electromechanical devices that make or break a signal upon pressing, then return to the initial (re-pushable) state upon release. There is incredible variety in the constructions that fit this definition. Our discussion here focuses on commonplace push-buttons of keyboards and button panels. Mechanical keyswitches, rubber domes, and metal domes are the most typical structures. Numerous other design parameters exist, such as physical properties of the keycap (width, slant, and key depth), the materials used (e.g., plastics), and system-level feedback (modalities and latencies) . The response upon pressing can be characterized via the the force–displacement function or force curve . Actuation (press-down) and release curves often differ. The FD curve is known to affect not only sensation but also joint kinematics , muscle activity , and the user’s aiming performance . Linear buttons have the feel of pressing a spring; there is no tactile landmark or “bump” during press-down. A tactile-type button has a so-called snap ratio, which determines the strength of its tactile bump. Rubber-dome buttons utilize a snap ratio greater than 40%. Some tactile buttons emit an audible “click” sound near the snap point. Travel distance is the total distance before the keycap hits the bottom, and the distance at which the button is activated is called its activation point . While these features can be modeled with FD curves, we stress again that FD neglects velocity and vibration .

Capturing and modeling physical buttons

There are two main approaches in haptics research applicable to the modeling of buttons. The first is an analytical one aimed at formulating equations that capture the mechanics of haptic interaction, which in the case of buttons would involve the forces, vibrations, etc. during a press. Since these interactions are complex, analytical models almost inevitably need to make simplifying assumptions. For example, the spring–mass-damper system in buttons could be described as a lumped mass . Analytical models applicable to buttons include modeling of spring–mass-damper systems  and friction . While prior applications to buttons and knobs do exist , the ones presented thus far are too low-parametric to capture the rich design space of push-buttons.

The second approach is a reality-based, or data-driven, one that starts with physical measurements and constructs models based on data. In the case of buttons, one starts by physically probing a button to measure the interaction forces between the button and the probe as displacement and even higher-order variables. Displacement has been approached in such a manner outside the button domain. One could cite as example applications the automotive gearshift , non-rigid materials  , and human tissue . Displacement-only models are relatively simple. For buttons, this approach is insufficient. There have been studies examining higher-order variables, such as velocity  and acceleration . This, however, complicates everything from measurement to simulation. Nonetheless, we followed the reality-based approach. We captured the forces involved, displacement values, vibration, and pressing velocities, and we found a way to collapse the data to a more understandable, lower-parametric model.

Haptics rendering

Our work is aligned with haptics research pursuing the creation of rich and realistic sensations . While this area of research is too broad to review here, some relevant findings are worth mentioning. Firstly, research has looked at advanced factors affecting haptic perception, such as friction, temperature, or texture . However, the focus has been on exploration or manipulation of objects, which is quite different from a keypress, which occurs in around 100 ms. The rapid compression and mechanical vibration of tissue in the fingertip are core elements of a button press. Secondly, general-purpose haptic simulators have been produced that could be used for buttons. The Phantom device  is a 6-DOF pen-type general force-rendering device capable of emulating the softness of deformable objects. However, a low operating rate (60 Hz), excessive degrees of freedom (six instead of one), and lack of vibrotactile simulation limit its use for buttons. Softness displays  too might aid in simulating the stiffness of a button, but these are restricted to so-called simple stiffness, which is inadequate for buttons. Finally, pseudo-force-feedback has been explored. By changing the contact area of the finger  or using electro-tactile displays, one can create a softness-like sensation . However, this is not central to commodity push-buttons’ design.

Button simulators

Prior work on button simulation has been limited to static (speed-agnostic) FD simulators, which have the limitations described above. Doerrer and Werthschuetzky  enabled users to edit FD curves in software, and Liao et al. have presented an FD simulator. The Phantom haptic interface also can render a virtual button. Yet, as other simulators do, these too need an exaggerated FD curve to render the “snap” feeling of a tactile button. These papers omitted velocity and vibration dynamics from their model. Moreover, to our knowledge, the perceived realism achievable by FD simulators has not been empirically validated thus far.

Conclusion

We have shown that the FDVV approach proposed as an extension to the dominant FD model increases the scope and perceived realism of button simulations. While this extension was motivated by prior literature, several engineering problems were solved to capture and simulate FDVV models. The added complexity notwithstanding, the core model is understandable and offers practitioners a workable starting point. We have demonstrated the benefit of model–simulator separation via three applications: human-in-the-loop button optimization, interactive button design, and examples of innovative buttons that would be tricky to realize without this approach.

While the FDVV approach permits greater realism, and opens many new practical possibilities, our results point also to clear opportunities for further improving realism. Firstly, the iterative compensation method can be enhanced, to better capture the dynamic effects of damping on the actuation signals. Our approach was to try to cancel the effect of the transfer function, but future research could consider learning a data-driven model of the black box through machine learning. This should be coupled with a clever controller design. Secondly, structural vibration can be modeled better. We opted to measure the snap-like vibration as a sound wave, but sometimes this was inadequate to reproduce the felt sensation of the tactile bump. To enhance the realism of the snap point, researchers could consider applying better measurement, modeling and controlling methods for handling the vibration. This would eliminate the human-dependent part of the vibration modeling. While these changes would increase realism, perfect button simulation entails simulating the texture and shape of the keycap, the sound emitted, etc. Finally, once a button has been designed and tested, a suitable electromechanical design should be fabricated. This presents an interesting challenge for future work aimed at bridging the gap between buttons in vitro and buttons in vivo.

Open Science

The materials and data in this paper are released on our project page at http://userinterfaces.aalto.fi/button-design . The materials include 3D models, circuit design, component specifications, construction details of the simulator, and the programs for controllers. All the data for button measurements and experiments are released too. The materials also complement Figure 7 and Figure 12 with the graphs of other buttons.

Acknowledgement

This work has been funded by the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (grant agreement No 637991) and by Korea Creative Content Agency (grant agreement No R2019020010). Designing a push-button with desired sensation and performance is challenging because the mechanical construction must have the right response characteristics. Physical simulation of a button’s force–displacement (FD) response has been studied to facilitate prototyping; however, the simulations’ scope and realism have been limited. In this paper, we extend FD modeling to include vibration (V) and velocity-dependence characteristics (V). The resulting FDVV models better capture tactility characteristics of buttons, including snap. They increase the range of simulated buttons and the perceived realism relative to FD models. The paper also demonstrates methods for obtaining these models, editing them, and simulating accordingly. This end-to-end approach enables the analysis, prototyping, and optimization of buttons, and supports exploring designs that would be hard to implement mechanically.

Applications

We show three applications exploiting the approach.

Human-in-the-loop button optimization

Firstly, we demonstrate the optimization of a button for an interactive task. We look at a temporal pointing task with no visual feedback . It resembles games where a response must be elicited at just the right time (for instance, to catch an enemy). Our goal is to optimize the button’s FDV design and also its activation point. The optimization we used was Bayesian optimization (BO), which is favorable for conditions wherein evaluations are noisy and expensive . The objective in BO is to minimize a user’s mean asynchrony , or the mean difference in time between the target and the user’s elicited response. Figure 3 depicts some example FDV models generated by the optimizer. To keep the study below one hour in total length, we limited the BO’s task to three control points and two other button parameters. We mapped this to the force-actuation signals, which the BO then manipulated so that once a new design is sent to the simulator, users can instantly try it out without iterative learning.

Method: We recruited 10 participants (4 females) from a local university, of ages 20–40 (mean 26). The study had two phases, training and validation. In the training phase, they were asked to press the button when the LED strip showed a bullet to have reached the center of the target zone. Two levels of task difficulty (easy = 100 pixels/second; difficult = 150 pixels/second) were used. For each level, 27 trials were collected and used to compute the mean asynchrony score. The whole process took about 60 minutes. Short breaks were given after every 15 minutes of presses.

Our BO implementation was based on Python’s GPyOpt library¹. In each iteration, it changed the parameter values of the button model. We had three control points in the FDV and three other parameters: $`x1, x2, x3`$ (displacements of three control points) and $`y1, y2, y3`$ (actuation signals of those control points). The ranges of these six parameters were $`x1 \in [0,1), x2\in[1,3), x3\in[3,6.2)`$ and $`y1, y2, y3 \in [20,180]`$. The other two additional parameters were activation point, $`p_a`$, and vibration point, $`p_v`$. The ranges of these two parameters were $`p_a, p_v \in [0.5,5.5]`$. An additional microprocessor, an Arduino Uno, was set to drive an LED strip (Adafruit DotStar) that displayed an array of LED lights with the bullet animation. This microprocessor was connected to the button simulator by software serial port. When the button passed the activation point, the microprocessor of the simulator sent a triggering signal to the LED strip, which would then calculate the temporal error of this press. After 20 presses, we calculated the mean asynchrony and sent the information back to the simulator. Then, the optimizer created a new design of button for the next iteration, based on the data collected, and triggered the simulator to reconfigure itself accordingly.

In the testing phase, a week after the training phase, the optimized button was compared to other non-optimized buttons: four 4 mm mechanical ones (Cherry MX Clear, Brown, Black, and Red) and a random button design . Each button appeared twice per difficulty level, in counter-balanced order, and the participant needed to press the button 20 times in every trial. In total, we collected 240 observations of mean asynchrony (10 participants $`\times`$ 2 difficulty levels $`\times`$ 2 rounds $`\times`$ 6 buttons).

/>

 

Results: In Figure 2, we present some instances of optimal button designs. For the difficulty level Easy, the resulting mean asynchronies were 65.8 ms (STD 6.15), 83.6 (STD 7.65), 88.04 (STD 7.82), 81.65 (STD 6.19), 84.28 (STD 6.75), and 100.78 (STD 6.89), for the optimal, clear, brown, black, red, and random button, respectively. For the Hard difficulty level, the resulting mean asynchrony values are 77.3 ms (STD 6.89), 93.43 (STD 7.56), 97.48 (STD 7.69), 96.9 (STD 7.61), 96.65 (STD 6.36), and 108.22 (STD 8.77), for the optimal, clear, brown, black, red, and random button, respectively.

/>

 

/>

 

Interactive button design

We implement an interactive button-editing tool that lets engineers freely create and edit button designs (4). Using the tool (implemented on macOS using Swift), designers can manipulate force levels through 15 draggable control points to create a single-FD curve. Travel range, activation point, and vibration point can be edited textually. Next, the model is converted to high-dimensional force actuation signals (with B-spline fitting and iterative compensation). Finally, these signals are used to simulate the button. Several button designs implemented by the interactive button-editing tools are presented below, under “Innovative button designs.” While the tool allows for editing of one FDV model at a time, our backend (Python) also allows for more advanced editing, such as assigning a specific FD curve segment to be pressed or released, and merging multiple FD curves into an FDVV model.

/>

 

Prototyping Innovative Buttons

Our setup enables prototyping innovative and extraordinary buttons that go beyond commodity designs. We give five examples here. The first two are instances of FDVV models, while the remaining are buttons that can be run on the simulator but can not be expressed as FDVV models.

1. A fast tapping button: While humans can only reach about four presses per second in tapping tasks , we can increase this capacity via a novel button design. The principle is this: once a press is detected, the button drops to the bottom and returns automatically. This can be especially useful for content requiring high-frequency rhythmic tapping, such as music games (see Figure 5 (a)). One of the authors reached 8 presses per second with this button.

2. A non-Newtonian-fluid button: In non-Newtonian fluids, viscosity changes under force: the medium becomes either more liquid or more solid. We can design a button that adjusts its stiffness following pressing velocity; see Figure 5 (b). As a result, the button is softer when being pressed gently, but the resisting force increases during fast pressing. This design can be used to prevent accidental touches.

/>

3. A multi-level button: We can extend the input modality of a button by giving multi-level haptic feedback. For example, a typical 4 mm button can be divided into several depth ranges. Through the provision of distinguishable haptic signals, a user can effectively activate different functions of the button by pressing down to different depths; see Figure 5 (c). This can be useful for easier use of single-button devices (e.g., in tuning the luminance of a lamp).

4. Vibration cues: We can deliver rich temporal information through continuous vibrotactile cues while the press is at the bottom. This interaction can enhance the effectiveness and efficiency of dwell-press applications. For instance, when the shutter button of a camera is pressed and the camera is continuously shooting, vibration ticks can help the user easily count the number of shots via humans’ haptic sense.

5. A dynamically returning button: In certain situations, it might be desirable to avoid fast repetition with a given button. In the example of fighting games or shooting games, many attacks involve a cooldown time – i.e., a minimum duration before the next use of the relevant ability. Our simulator can easily render buttons with just such dynamic returning time, as demanded by the game content.

FDVV Modeling

The raw measurement data must be transformed into a lower-dimensional FDVV model . A series of preprocessing steps are followed to produce a synchronized and filtered dataset from multiple data sources. We then fit a B-spline model, using Bayesian Information Criteria (BIC) .

Preprocessing

The outputs of button capture are (timestamp, force, sound) data from the microprocessor and (timestamp, the 3D position of marker1, the 3D position of marker2) data from the motion tracker and vibration data. Our goals are to (1) filter out noise and outliers and (2) synchronize the two data sources.

Step 1, filtering: We pass force and vibration data through a low-pass filter for antialiasing, before the analog–digital conversion of the microprocessor. The filter consists of a resistor–capacitor circuit (R 333 ohm, C 1 uF) with a cutoff frequency of 500 Hz, using a Nyquist frequency of 1,000 Hz. Gaussian filters ($`\sigma=1.2~mm`$) are then applied to both force and displacement data, separately, for further denoising.

Step 2, synchronization: We then synchronize the data from the microprocessor and motion tracker, using the IR LED light data to find keyframes. Because the microprocessor runs at 1,000 Hz and the motion tracker at 256 Hz, resampling is required before synchronizing of the two sides. We chose to upsample displacement data by matching the of the motion tracker to the timestamp of the microprocessor, via linear interpolation. The displacement data get resampled up to 1,000 Hz frequency, after which we have synchronized the signals. We need resampling also to register force data against displacement (here, sampled every 50 $`\mu`$m).

Step 3, outlier removal, averaging and smoothing: We use the resulting dataset to filter out incomplete button presses (ones where the button did not hit the bottom). Finally, . A Gaussian filter ($`\sigma=0.8~mm`$) is then applied to smooth the averaged curve.

Step 4, synchronizing vibration data: Note that vibration data did not pass through steps 3–4. In most buttons, vibration is associated with the snap. This can be programmatically exploited to synchronize the vibration signal. On the other hand, one can ignore measurements detected in the beginning and the end portion, because these are caused mostly by the finger hitting the keycap or the keycap hitting the bottom. Hence, we consider only the middle part of the press, for which we use threshold-based event detection to find the onset of the vibration. For some buttons, this sound wave can be very subtle and rapid (typically <25 ms), making it hard to detect programmatically. To compensate for this, we can resort to a human observer (see “Iterative Compensation,” below).

B-Spline Fitting

The preprocessed dataset is still too high-dimensional for editing by designers. For example, a typical 4 mm button requires approximately 800 parameters in our procedure. Hence, we use B-splines to achieve a lower-dimensional parametric model. While B-splines offer a suitable model for continuous multimodal data, there is still the question of how many control points are needed. We studied this by fitting B-spline models to our button dataset. To control against overfitting, we used Bayesian Information Criterion (BIC)  for the fitness criteria. To reduce the number of parameters even further for feasibility for human editing, we added a custom penalty term: Complexity Penalty, P. This results in a modified BIC^* function:

\begin{equation}
 \label{eq:1}
 BIC\textsuperscript{*} = \ln(n)kP - 2 \ln(\hat{L})
\end{equation}

Where n stands for the number of observations, k for the number of parameters (control points), and $`\hat{L}`$ for the maximized value of the likelihood function of the model. P is the added Complexity Penalty value, which is set to 2.5. Figure 6 (b, c, d) gives examples of fitting for a pressing segment of a certain velocity for Cherry MX Clear button.

Following this procedure, we found 15 B-spline control points was an ideal tradeoff for the six-button dataset with root mean square error of 0.14 cN; see Figure 6 (a). We also registered travel range, the activation point, and the vibration point in the resulting models, as examples shown in Figure 6 (c, d).

/>

 

/>

 

Introduction

This paper investigates the simulation and interactive of push-buttons. Many push-button designs use a spring-loaded slider: when the slider is pushed to the activation point, a binary input is registered. Upon release, it returns to the initial state. More generally, buttons are transducers that register a discrete event from physical motion . Numerous types exist, using spring-loading but also other mechanisms, such as rubber and metal domes. Interestingly, each button is unique in its tactility or tactile response characteristics . Gamers, programmers, typists, and hobbyist groups alike have a keen interest in tactility, which is associated with sensory experience and performance . However, despite the popularity of buttons, researchers have paid relatively little attention to their design.

Simulators have taken on a major role in most branches of engineering and design, where they are used to study reality, predict consequences of design decisions, and derive and optimize solutions. Dedicated simulators can do the same for button design. We believe that one obstacle has been the lack of an accurate yet practical simulation device. It should be able to realistically reproduce different tactilities so that designers and researchers could explore and test them at little cost.

Accurate simulation of button-pressing is challenging, though. Although a press and release occurs in about 100 ms , a wealth of sensory feedback is generated . Slow and fast mechanoreceptors   deliver information on spatial patterns, change in the contact area at the fingertip, the roughness of the contact support, stretching of the skin, subtle and rapid changes in force, and vibrations during a press. Meanwhile, proprioception provides feedback on displacement, as detected via the joints and muscles of the finger . This information is transmitted through the spine at high rates, up to 1 kHz , and contributes to constructing the felt sensation of a press . Hence, to reproduce a realistic button sensation, the simulator needs to capture those physical characteristics of a press that dominate that sensation.

style="width:99.0%" />

While pre-existing simulators can render tactile and linear buttons , we found that force–displacement (FD) approaches cannot accurately render other than a simple linear button. In addition, the perceived realism of the rendered buttons has not been properly evaluated, and no methods have been offered to help designers and engineers exploit such simulation. We believe this to be due to three engineering challenges: (1) modeling, (2) simulator construction, and (3) model–simulator separation. Firstly, prior work has modeled buttons’ response as the displacement-dependent change in force . However, as we show in this paper, an FD model is adequate only for linear buttons pressed at extremely low speed. It is known that the physical response of a button depends also on velocity and acceleration , and that buttons elicit a vibration response. Vibration affects the perception of button-pressing , and it can be so prominent that it produces an illusion of force change . Secondly, the simulators created thus far have fallen short of the operation rate needed for a button press. General haptic devices such as Phantom  and inForce  operate at 60 Hz, while the skin’s mechanoreceptors fire at about 1,000 Hz and respond to tiny changes in force . Simplistic controller approaches may have further curbed attempts to render anything other than a linear button. To our knowledge, previous work has, at best, applied a linear PID controller to render the response at the force actuator of a simulator, although this is generally recognized as insufficient for nonlinear plants . We should emphasize, thirdly and finally, that the button models must be editable if they are to be of practical use. This calls for model–simulator separation. By avoiding the device-dependency of models, we can support the meaningful editing of buttons – by designers and by software.

To address these challenges, we propose an extended model and an end-to-end simulation pipeline around it. Our approach allows simulating more button types than previously, among them tactile-type buttons and buttons with different click reactions and travel ranges. Furthermore, it permits the analysis and editing of buttons. Our work centers on the Force–Displacement–Vibration–Velocity (FDVV) model, illustrated in Figure 7. It adds vibration response and velocity-dependence on top of the FD model. In our implementation, vibration is sampled thorough a microphone during a switch press, and multiple FD curves are sampled, at several speeds. We solve several engineering challenges connected with ambitions to capture and simulate buttons via FDVV models.

In particular, we present methods developed for (1) capturing the FDVV response of a button, (2) computing a lower-parametric FDVV model from the measurement data obtained, and (3) actuating an FDVV model for a given physical plant. Figure 8 gives an overview of the end-to-end approach. The data (force, displacement, vibration, and velocities) obtained during capture are filtered and modeled via B-splines , collapsing the data into a lower-dimensional and more manipulable model. For rendering it, we present a novel simulator construction for FDVV models. This is capable of detecting displacement to $`\mu`$m precision at a high sampling rate (1 kHz) and can produce a wide range of force (up to 4.4 N) and vibration (50 Hz – 20 kHz) feedback. In contrast to previous, 60 Hz simulators, our simulator can render high-fidelity vibration arising from the rapid force change near the snap and bottom-out points during the press . It also has a mechanical limiter for rendering a button with various travel distances (0–6.2 mm). Thanks to the iterative compensation method, which translates an FDVV model into actuation signals that cancel out the simulator plant’s own transfer function, one can assign button designs from software without hardware tweaks.

In summary, this paper makes three contributions. We present advances in modeling and simulator design that extend the range of supported button types. Secondly, we report the results of a controlled study showing that the FDVV model yields higher perceived realism than FD modeling. Finally, the approach opens new possibilities in design and prototyping We demonstrate applications in interactive button-editing, software-side optimization, and prototyping of innovative button designs the mechanical structure of which would be hard to fabricate.

Button Simulator

Ours is the first physical simulator capable of the high-fidelity rendering of FDVV models. An overview is given in Figure 9. Our first design goal was to provide the high-frequency response and high-resolution rendering of forces and vibrations typical of buttons. The second was to enable full control from the software side.

Sensors and actuators: Figure 9 presents the four main components: (1) a linear force actuator (Moticont HVCM-025-022-003-01), (2) a linear position sensor (LVDT MHR 250, ), (3) a voice coil acting as a vibrotactile motor (Tectonic Teax13C02-8), and (4) a servo motor (Tower Pro Micro Servo, torque: 1.8 kg/cm). The force actuator, the sensor, and the servo motor are controlled by an Adafruit ItsyBitsy M0 board, which serves as the main processor of the prototype. The vibrotactile voice coil is driven by an Arduino Uno board and wave shield (Adafruit Wave Shield for Arduino Kit). These two boards are connected via the I2C protocol. When adjustments to the overall travel range are required, the ItsyBitsy board sends a command to the servo motor to adjust the location of the Travel Range Control, which further alters the lowest reachable displacement of the Travel Range Limiter and produces varying travel. When vibrotactile feedback is required, this board communicates with the Arduino Uno via I2C and asks it to drive the vibrotactile motor (voice coil) to present pre-recorded wave files.

/>

 

Microprocessor design: Before the simulation, the actuation signals (see “Iterative Compensation”) are uploaded to the main microprocessor (Adafruit ItsyBitsy M0) and it automatically sets the button travel range. During a simulation, the linear sensor constantly sends the reading value to the microprocessor. A moving-average filter (window size = 25) is applied here for denoising the reading from the position sensor. After the microprocessor has processed the values sent, it calculates the current displacement of the button and estimates the user’s pressing velocity. Then, it determines the corresponding Pulse-width modulation (PWM) signal and sends it to the linear force actuator. At the displacement where vibration starts, the microprocessor sends a command to the Arduino Uno for emitting the vibration. A high operating frequency is used (1 kHz) for the ItsyBitsy M0 board.

Spatial and temporal accuracy

We measured the spatial accuracy of the simulator via a probing device consisting of a linear actuator and a probe attached to a force gauge . The probing velocity was 0.5 mm/s. We used this device to profile a 4 mm Cherry MX Clear button, checking the intended outputs of the simulator against the measurement results. Over multiple repetitions, we learned that the simulator can reproduce the force responses very accurately, with only 1.44 cN mean error (SD 1.68 cN).

Simulation procedure

Prior to simulation, the actuation signals obtained from iterative compensation (see later) are uploaded to the microprocessor. Near the beginning of the press – i.e., at 0.5–1.0 mm of distance traveled – the microprocessor calculates the pressing velocity for the press. At least three timestamped samples are needed. From those samples, the simulator computes velocity and switches to the corresponding actuation specification. That specification is used to determine the resisting force and the vibration for the sensed level of displacement. To simulate the vibration, we followed an event-based approach wherein vibration recording is initiated at the right displacement  , creating a snap-like sensation.

Iterative Compensation

A key objective in our work is to separate the model from the simulator. Any force actuator has its own transfer function in the play that must be canceled out if an FDVV curve is to be simulated correctly. To our knowledge, no prior work on button simulation has considered this issue, which may explain the lack of empirical evaluations of these simulators. To address the issue, we introduce an iterative compensation method shown in Figure 10:

/>

 

The idea is to raise or lower the force-actuation signal amplitude of each displacement point until the desired resisting force is measured by the sensor against the keycap. Per-displacement and per-speed repetition can be applied until the desired FDVV signal is measured from the sensor. This iterative compensation process can be expressed as

\begin{equation}
u_{k+1}(p) = u_{k}(p) + \Gamma(error_{k}) (y_{d}(p)-y_{k}(p)), \quad p\in[1,n]
\end{equation}

Here, $`u_{k}(p)`$ is the actuation signal of a given displacement point $`p`$ in the current iteration, and $`u_{k+1}(p)`$ is the actuation in the next iteration signal of the same displacement point. $`y_{k}(p)`$ is the force detected from the sensor worn on the fingertip, and $`y_{d}(p)`$ is the desired target force at that given displacement point. $`\Gamma(error)`$ represents the proportion of adjustment of the actuation signal that must be applied, based on the error value in the current iteration ($`error_k`$). The error from the current iteration is defined on a per-curve basis as follows:

\begin{equation}
 error_k = \alpha\cdot\frac{\Sigma_{p=1}^{n}|{{y_d(p) -y_k(p)}|}}{n} + (1-\alpha)\cdot \max_{p\in [1,n]} |{y_d(p) -y_k(p)}|
\end{equation}

In this definition, two terms make up the error. The first is the overall difference between the target FD curve and the measured curve. The second is the displacement error at which the largest error is observed. $`\alpha`$ is the weight applied between thees two, which we set to 0.7 based on experiences.

Procedure: We first upload the reference data (FDVV model) to the simulator. A participant is asked to press the button repetitively in line with the speed indicator presented by a GUI. Figure 11 illustrates the whole process. The force sensor is connected to the same microprocessor that runs the simulator. The sensor (response rate: 1 kHz) captures the force responses during a press by the fingertip. The value sensed is passed through a resistor–capacitor filter with a 498 Hz cutoff rate, to reduce within sensor noise. All the resisting force samples within a 50 $`\mu`$m interval are aggregated and averaged for this displacement point. In our experience, the procedure converges after only 8–12 presses; however, each button needs to be modeled at multiple velocities. With four velocities, there are 240 presses in total (4 velocities $`\times`$ 4 rounds $`\times`$ 15 presses) to compute its actuation signals. A typical example is presented in Figure 11 (b): $`error_k`$ decreases rapidly to below 3 cN within 10 presses.

/>

 

Outputs: After the process is complete, the microprocessor records the actuation signals that resulted in the minimal error. For a given reference force curve, we ran the iterative compensation process four times, obtaining four series of actuation signals. We then averaged these at each displacement and finally applied a Gaussian filter ($`\sigma=1.2~mm`$) to smooth the signals. After all the force-actuation signal curves were obtained (see Figure 12 (a)), we linearly interpolated the signal curves to form denser, more continuous curve sets that responded to more velocity changes (see Figure 12 (b)).

/>

 

Optional human-in-the-loop vibration tuning

As described earlier, sometimes the vibration emitted at the snap point is weak and our sensor does not reliably pick it up accurately. Also, sometimes when vibration is measured as a soundwave, it may fail to reproduce the same sensation when reproduced using the vibration motor. In order to produce the desired snap sensation, the vibration needs to be accentuated. To this end, we devised a human-in-the-loop method for tuning the vibration response at the simulator side.

Procedure:

/>

 

Button Capture

Most previous work has captured buttons by a single-FD curve model. This approach has become conventional also in the way manufacturers present buttons on datasheets. However, button-pressing involves complex phenomena affected by the varying stiffness and damping effects produced by mechanical design. The stiffness effect means that the resisting force changes as a function of the button’s displacement. The damping effect entails the resisting force changing with the button’s velocity. An FD-only model captures neither the damping effect nor the high-frequency structural vibrations of a button press.

We propose an extension to the physical measurement of the tactility characteristics of push-buttons. Our capture method features three novel elements: (1) We measure presses under different velocities. (2) A human finger is used for pressing, as opposed to a rigid, static-velocity probing object as in earlier work. This allows us to better cover the response envelope people encounter in everyday button-pressing, via a procedure that requires no more than a few minutes to complete per button. (3) We record vibrations, which are important for covering more advanced button types. This necessitates a more complex measurement setup than before.

/>

 

Setup: Our measurement setup is shown in Figure 14. Two retroreflective markers are attached to sides of the keycap. A motion-tracking system (OptiTrack Prime 13, 256 FPS) records the displacement of the button during a press. Also, a microphone is attached to the keycap, to detect vibration during button presses. On the user’s index finger is a force sensor (Honeywell, FSAGPDXX001RCAB5), with a conical tip (ABS, 3D printed, ) attached. A microprocessor (Adafruit Metro M0 Express) samples both sensors with its internal 10-bit ADC at 1 kHz frequency, which is the highest sampling rate allowed for the force sensor. Synchronization between the sensor data and the motion data is handled via an optical clapperboard (three 850 nm IR LEDs). The microprocessor is attached to a switch that turns on the LEDs. When the switch is triggered, the microprocessor and the motion tracking system record a reference point for synchronization.

Procedure: A participant is asked to wear the sensors and press the given button, following the instructions on the display. A velocity indicator is presented on this display, which shows animation for various velocities. The velocity indicator also creates a beep sound indicating the moment of contact and that of hitting the bottom. Note that we stated that the animation refers to the rate of pressing and the average velocity, not the moment-by-moment velocity. The participant is asked to press the button at the specified pace. We go through velocities of 50, 100, 150, and 200 mm/s, collecting 15 presses per velocity.

Example buttons: The paper reports on studies of six physical buttons: Cherry MX Clear and Brown (4 mm, tactile), Cherry MX Black and Red (4 mm, linear), HP PR1101U (3.6 mm, tactile), and MacBook Pro 2011 (2.2 mm, tactile). They have distinct haptic profiles (linear/tactile) and travel ranges.

A User Study: Perceived Realism

We assessed the perceived realism of the rendered buttons in a controlled study. We adopted the idea of ABX test as used in psychophysics for comparing two sensory stimulus options for identifying a target  . A participant tries a real reference button (X) and is then asked to press two simulated buttons (A, B) and decide which offers a more realistic rendering of it. The A, B buttons are rendered via the same physical simulator, and the user can try out the three buttons as many times as desired. We compared our FDVV models against speed-agnostic FD models because it represents the prevailing understanding of button tactility represented in academic literature, hobbyist groups, and manufacturer datasheets.

Method

Participants: We recruited 12 participants (6 females) from a local university, of ages 21–41 (mean 29.75). All of them reported typing and other button-pressing experience. They were rewarded with a movie ticket (valued at 14 euros) for the 60-minute study.

Task and apparatus: The study compared six physical buttons listed previously in “Button Capture”. They differ in characteristics, but all are realistic. All the buttons were captured and transformed into (1) a single-FD model and (2) FDVV models. Actuation signals were computed as described in the previous section.

To prevent users’ haptic judgments from being biased by their vision, the simulator was placed inside a black box with a hole, into which the user reached to press. The target buttons and the simulator were at the same height. The participants were asked to wear a headset playing white noise and earmuffs, to isolate hearing during the study. A graphical interface showed which of the two buttons (labeled A and B) was currently active. The information displayed was the name of the target button (one of the six), the simulated button’s label (A or B), and the current trial number. Double-blind administration was employed: neither the experimenter nor the participant knew which button (A vs. B) used FDVV and which used FD.

Procedure and experiment design: The participants were told about the simulator and the purposes of the study. They were asked to explore the real buttons once, with different pressing velocities. We did not repeat this instruction during the study proper, though; we let them decide what was natural for them.

Again, each round featured a reference button and two simulated buttons. The interface identified the reference button and the label of the currently active button (see Figure 15). The participants were told that there are two simulated buttons in each round, denoted as button A and button B. In each round, participants were instructed to press the reference button and to feel it. After that, they were asked to try the alternative simulations, labeled A and B. They could switch among the three buttons as many times as they wished. When ready to make their judgment, they were asked to indicate which button had more realism (A, B, or equal) and to rate the perceived realism of A and B separately, on a seven-point Likert scale. After the study, an interview was conducted. We gave a three-minute break after every 20 minutes of button presses, to minimize fatigue. There were six rounds for each of the six buttons, making 36 trials in total. The trial order of the six button designs was counter-balanced by Latin square. The assignment of the FDVV and FD models to the labels, A and B, was randomized at each trial.

/>

 

Results

/>

 

The results support the FDVV approach. It was associated with higher perceived realism for all the simulated buttons. The participants chose the FDVV model as more realistic 77.31% of the time. An overview is shown in Figure 16. We examined the ratings further by using Wilcoxon Signed Ranks Tests. The analysis showed that there are statistically significant differences for each target button between the FDVV and single-FD models:

1. For the Clear button, the median FDVV model ranks (mdn 5.16, mean 4.9, STD 0.72) were significantly higher than the median single-FD ones (mdn 3.83, mean 3.72, STD 0.92), with $`Z = -3.06`$, $`P = 0.002`$.

2. For the Brown button, the median FDVV model ranks (mdn 4.92, mean 4.64, STD 1.02) were significantly higher than the median single-FD ones (mdn 3.83, mean 3.86, STD 0.87), with $`Z = -2.748`$, $`P = 0.006`$.

3. For the Black button, the median FDVV model ranks (mdn 5.33, mean 5.4, STD 0.53) were significantly higher than the median single-FD ones (mdn 3.83, mean 4.25, STD 0.72), with $`Z = -2.94`$, $`P = 0.003`$.

4. For the Red button, the median FDVV model ranks (mdn 5.33, mean 5.14, STD 0.9) were significantly higher than the median single-FD ones (mdn 4.67, mean 4.58, STD 0.54), with $`Z = -2.158`$, $`P = 0.031`$.

5. For the HP keyboard (spacebar), the median FDVV model ranks (mdn 5.33, mean 5.03, STD 0.58) were significantly higher than the median single-FD ranks (mdn 3.83, mean 4.0, STD 0.85), with $`Z = -2.987`$, $`P = 0.003`$.

6. For the MacBook Pro keyboard (spacebar), the median FDVV model ranks (mdn 5.42, mean 5.57, STD 0.57) were significantly higher than the median single-FD ranks (mdn 4.67, mean 3.67, STD 0.9), with $`Z = -3.06`$, $`P = 0.002`$.

From Figure 16, we see that the smallest difference between the FDVV and FD simulation was for the Red button. This is a linear button, and the FD model offers a reasonable simulation. One participant stated, “The red one has a smooth (linear) feeling, and it’s lighter than the other buttons. I feel two models with a similarly smooth and light feeling, so it’s hard to tell the differences.”