Turning Shots into Equations: Working Backwards from Desired Landing Point to Racket Speed and Normal

Status: Draft (2026-10-18), Measured. Numbers are simulation values calculated directly in Python 3.9.6 with numpy 2.0.2 on a laptop (Apple M1 Max, macOS 26.5). Raw data and code: Working directory measure/robot-arm-basics/in m07_hit.py, out/m07_hit.json. Racket rebound is a simple model and has not been measured with actual rackets and rubbers (hardware unmeasured). The initial ball state is from the DeepMind dataset (CC-BY 4.0). References were accessed on 2026-10-18. Writing rules: Measured data is the default; unmeasured items are marked as "Unmeasured", and unverified items are marked as "Unverified".

Table of Contents

• 1. Intuition: Thinking Backwards
• 2. Figure: Geometry of Racket Rebound
• 3. Calculations
  • 3.1 Outgoing Velocity: Shooting Method and Newton's Method
  • 3.2 Racket: Closed-Form Solution of the Rebound Model
  • 3.3 Why Friction Can Be Ignored, and When It Cannot
• 4. Measurements
  • 4.1 Returning 200 Actual Shots
  • 4.2 When the Racket Is Slightly Misaligned
• 5. Limitations
• 6. Conclusion
• References

1. Intuition: Thinking Backwards

Consider a basketball shot. For the ball to go through the hoop, the velocity it needs when leaving the hand is determined first, and the wrist and arm move to produce that velocity. Table tennis is the same. However, because the ball is already flying toward you, the racket does not "throw" the ball but rather "bounces" it away.

Therefore, shot determination is a two-step inverse problem.

1. Landing point → Outgoing ball velocity v_out. What must the velocity of the ball be when leaving the racket so that it lands at the target point on the opponent's table within a specified time? This is the problem of inverting the flight model (Part 6).
2. Outgoing velocity → Racket. To convert incoming ball velocity v_in to v_out, what should the racket face normal n and racket velocity v_r be? This is the problem of inverting the collision model.

Out of the time budget in Part 1, these two steps receive a share of several tens of milliseconds. The outputs of this stage (racket position, orientation, velocity, and time) are then passed to the inverse kinematics in Part 4 and trajectory generation in Part 8.

2. Figure: Geometry of Racket Rebound

3. Calculations

3.1 Outgoing Velocity: Shooting Method and Newton's Method

The unknowns are the three components of v_out. Since it must arrive at the target point (x_t, y_t) at the table height (z = ball radius), we need to fix one more variable to have three equations. This article fixes the flight time T . This gives three equations: "position after T seconds = target".

F(v_out) = 공을 v_out 으로 T 초 날린 위치 − (x_t, y_t, r) = 0

Because F is a function computed by integrating the flight model from Part 6, it cannot be solved analytically. Therefore, we use a shooting method of "firing and correcting". The Jacobian is obtained via finite differences by slightly perturbing each component of v_out, and corrections are made using Newton's method. The starting value is the solution for a vacuum parabola.

def solve_vout(p, T, goal):
    v = (goal - p) / T
    v[2] += 0.5 * 9.81 * T                   # 진공 포물선에서 출발
    for it in range(20):
        r = flight_to(p, v, T) - goal        # 6편의 RK4 적분
        if norm(r) < 1e-4:                   # 0.1 mm
            return v
        J = np.column_stack([(flight_to(p, v + h*e_i, T) - flight_to(p, v, T)) / h for e_i in I3])
        v = v - np.linalg.solve(J, r)

Outgoing spin of the ball is set to zero (limitations in Section 3.3).

3.2 Racket: Closed-Form Solution of the Rebound Model

The moment of collision between the ball and the racket is decomposed into two directions relative to the racket face.

법선 방향:   (v_out − v_r)·n = −e_r · (v_in − v_r)·n          반발 계수 e_r
접선 방향:   v_out,t = v_in,t                                   마찰 무시(접선 성분 보존)

If the tangential component is conserved, only the normal component remains in v_out − v_in. Therefore, the racket normal is in the direction of v_out − v_in, and solving the normal direction equation for v_r·n yields the racket velocity.

def racket_for(v_in, v_out, e_r=0.8):
    n = (v_out - v_in) / norm(v_out - v_in)
    vrn = (v_out @ n + e_r * (v_in @ n)) / (1 + e_r)     # 라켓 속도의 법선 성분
    return n, vrn                                         # 접선 성분은 자유(0 으로 둠)

The tangential component of the racket velocity does not affect the ball in this model, so it can be any value. In practice, this freedom can be used to choose a direction that is easy for the arm to produce, or to impart spin in a friction-inclusive model. The calculation time was 4.3 µs.

The racket coefficient of restitution e_r was verified from literature to be in the range of 0.78 to 0.88. Koç et al. (2018) estimated 0.788 from human demonstration data, Nakashima et al. (2010) measured rubber restitution as 0.81, and Google (2023) recorded an empirical 0.78. Sony AI (2026) uses a model adding velocity-dependent terms and neural network residuals to a constant 0.878. This article uses 0.8.

3.3 Why Friction Can Be Ignored, and When It Cannot

Real rubber is tacky and elastic, altering the ball's tangential velocity and imparting spin. Nakashima et al. (2010) modeled the rubber storing tangential kinetic energy as elastic energy and reversing the tangential velocity at the contact point. The model in this article discards that effect and deals only with returns. Aggressive shots played with topspin cannot be planned using this model. Part 10 measures how quickly data can correct the flawed parts of this model.

4. Measurements

4.1 Returning 200 Actual Shots

From the dataset in Part 1, balls coming toward the robot were flown using the Part 6 model up to the striking plane behind the end line (y = −1.6 m), selecting 200 balls passing through that plane at a height of 5 cm or more above the table. The ball speed at the striking plane had a median of 2.8 m/s (5th percentile 2.2, 95th percentile 3.9). The target point was (0.3, 0.9) m on the opponent's side.

• For all four T values, the 5th, 50th, and 95th percentiles of Newton iteration counts were 2, and even the 95th percentile of landing error was below 0.01 mm. This is because the vacuum parabola starting value is already very close.
• Most of the solve time is spent on RK4 integration. In Part 6, the position error of RK4 with a 5 ms step size was on the order of 10⁻⁷ mm, so remeasuring with the step size increased to 5 ms reduced it at T = 0.6 s to 13.7 ms , and the landing error verified with a 1 ms integration was 0.005 cm.
• Shorter flight times (faster returns) require the ball to be sent lower and faster, reducing net clearance. At T = 0.35 s, 5% of the balls pass 3.2 cm above the net. Choosing T is a trade-off between "fast" and "safe", and in practice becomes an optimization problem constrained by net clearance, racket speed limits (Part 5), and joint accelerations (Part 8). This article merely compared four T values on a grid without performing optimization (unmeasured).

4.2 When the Racket Is Slightly Misaligned

Across 100 returns at T = 0.6 s, errors were individually introduced to the calculated racket parameters, and actual landing points were recalculated using the Part 6 model.

• A 1° racket angle error results in 6 cm, and a 0.1 m/s racket speed error results in 10 cm. As noted in Part 3, joint zero-point errors of ±0.1° tilt the racket normal by 0.1–0.2°, meaning zero-point errors alone lose around 1 cm. In Part 9, using only PD control resulted in a joint velocity error of 0.2 rad/s at the moment of impact, which, multiplied by an arm length of 0.5 m, yields a racket speed error of 0.1 m/s. This corresponds to a 10 cm landing point error.
• An error of 0.05 in the coefficient of restitution e_r results in 13 cm. Because this value varies depending on the rubber and the exact impact spot on the racket, this constant must be re-measured for each robot (Part 10).
• Timing is more forgiving than expected. If the racket is delayed by 10 ms, the ball drops slightly further and slows down in the meantime, but that effect resulted in a 2.3 cm landing error. Instead, because the ball flies an additional 2.9 cm (median) during those 10 ms, the impact location on the racket faceshifts accordingly. Since the racket face radius is 7–8 cm, 10 ms is manageable, but failing to compensate for the delays from Part 1 (tens to 100 ms) will cause you to miss the ball.

5. Limitations

• Racket friction and spin transfer were ignored. The incoming ball spin actually alters the rebound direction, but has no effect in this model.
• The racket face was treated as an infinitely large plane. Edge impacts, racket bending, and vibrations were not addressed (unmeasured).
• Contact was treated as instantaneous. During actual contact duration, the racket continues to move and rotate. This is why Part 8 sets the acceleration to zero at the moment of impact.
• Flight time T was predetermined. The method of optimizing T and strike time/position simultaneously (Koç et al. 2018) was not implemented.

6. Conclusion

• Shot determination consists of two inverse problems: a shooting method (2 Newton iterations) to find outgoing velocity from the landing point, and a closed-form expression (4 µs) to find the racket from outgoing velocity.
• In the friction-free rebound model, the racket normal points in the direction of v_out − v_in, and the racket velocity is determined by a single component in that direction.
• The racket speed required for a return is small, ranging from 2 to 4 m/s. What is difficult is not the magnitude of the speed, but its precision. A 1° racket angle, 0.1 m/s speed, and 0.05 coefficient of restitution result in landing point errors of 6, 10, and 13 cm, respectively.

TT Tip. To return the ball, the racket can move much slower than you might think. However, even a 1° misalignment of the racket face causes the ball to miss by nearly a handspan, so accuracy comes before speed!

References

All materials were accessed on 2026-10-18.

• Nakashima et al., Modeling of Rebound Phenomenon of a Rigid Ball with Friction and Elastic Effects, ACC 2010, Institutional Repository.
• Koc, Maeda, Peters, Online optimal trajectory generation for robot table tennis, RAS 105 (2018), author preprint, Table A.3.
• D'Ambrosio et al., arXiv:2309.03315, Appendix D (racket restitution settings and measured values).
• Conti et al. (Sony AI), arXiv:2606.28805, Table IV (racket model).
• Google DeepMind, competitive_robot_table_tennis, CC-BY 4.0.