Rebond d'une balle de tennis de table en Python

Objectif du projet : mesurer le champ de pesanteur terrestre et le coefficient de restitution associé aux chocs, à partir de l'étude de la chute et des rebonds d'une balle sur un sol horizontal.

Ce projet est autonome : tu n'as besoin d'aucun autre document, les données mesurées par l'application Phyphox sont recopiées directement dans le script. Chaque étape contient un script incomplet à compléter, puis à copier-coller dans Thonny (ou dans la console Basthon tout en bas de la page si tu n'as pas Thonny sous la main).

＋

Contexte physique

À savoir

On lâche une balle sans vitesse initiale depuis une hauteur h0 de l'ordre du mètre. Juste avant le premier impact avec le sol, sa vitesse vaut v0 ; juste après l'impact, elle vaut v1, avec toujours v1 < v0 : le choc n'est pas parfaitement élastique, une partie de l'énergie mécanique est perdue à chaque rebond.
Ce caractère inélastique se traduit par le coefficient de restitution e, défini comme le rapport de l'énergie cinétique de la balle juste après le choc sur son énergie cinétique juste avant : e = E_c,après / E_c,avant.
On peut montrer que la hauteur du premier rebond vérifie h1 = e·h0, et plus généralement, que la hauteur du n-ième rebond vaut h_n = eⁿ·h0 : chaque rebond « perd » la même fraction de hauteur que le précédent, une décroissance géométrique.
Entre deux chocs consécutifs, en revanche, la balle est en vol libre : l'énergie mécanique s'y conserve, et son mouvement peut être étudié avec les mêmes outils que dans les fiches précédentes.

＋

Une mesure sans caméra : le smartphone comme micro

Le protocole

Cette expérience ne nécessite aucun système d'acquisition vidéo : il suffit de poser un smartphone au niveau du sol, sous le point de lâcher, et d'enregistrer le son avec l'application Phyphox (ou un simple dictaphone).
Chaque impact de la balle sur le sol produit un bref pic sonore, facilement repérable sur l'enregistrement : la durée entre deux pics successifs donne directement l'intervalle de temps T_n entre deux rebonds.
On peut montrer que ces durées suivent la relation T_n = eⁿ · (2h0/g)^1/2 : leur mesure permet, en principe, de remonter à tous les paramètres de l'expérience (le coefficient e et le champ de pesanteur g).

Un exemple de mesures obtenues avec Phyphox

En lâchant une balle depuis une table (h0 = 33,24 cm), l'application a mesuré directement les grandeurs suivantes :

rebond n°	1	2	3	4	5
T_n (s)	0,470	0,424	0,388	0,357	0,330
h_n (cm)	27,09	22,08	18,47	15,65	13,36
énergie restante	81,5 %	68,2 %	57,8 %	49,3 %	—
e_n	81,5 %	83,6 %	84,7 %	85,4 %	—

Phyphox calcule directement un coefficient de restitution moyen e_moy = 83,8 %. C'est cette valeur que ton propre script Python va chercher à retrouver, à partir des seules durées T_n.

Les données

À savoir

Recopie les 5 durées mesurées par Phyphox, ainsi que le numéro de chaque rebond (de 1 à 5).
Le script ci-dessous est déjà complet : copie-le tel quel dans Thonny (ou dans Basthon) pour commencer.

etape0_donnees.py

import numpy as np
import matplotlib.pyplot as plt

# Durées entre deux rebonds consécutifs, mesurées par Phyphox (s)
duree = np.array([0.47, 0.424, 0.388, 0.357, 0.330])

# Numéro de chaque rebond : 1, 2, 3, 4, 5
num = 1 + np.arange(5)

Passer à l'échelle logarithmique

Consigne

La relation T_n = eⁿ · (2h0/g)^1/2 devient une relation affine si l'on prend le logarithme des deux grandeurs : calcule lnum, le logarithme népérien de num, avec np.log(...), puis ldur, celui de duree.

etape1_echelle_log.py

# TODO : logarithme népérien de num et de duree
lnum = np.___(___)
ldur = np.___(_____)

Résultat attendu

Aucun affichage direct, mais lnum et ldur contiennent chacune 5 valeurs, toutes négatives pour ldur (puisque les durées sont inférieures à 1 seconde, leur logarithme est négatif).

Tracer le nuage de points

Consigne

Trace ldur en fonction de lnum, en croix ou en ronds rouges ("ro").
Ajoute une grille avec plt.grid('true').

etape2_trace.py

# TODO : trace ldur en fonction de lnum
plt.plot(____, ____, "__")
plt.grid('____')
plt.show()

Résultat attendu

Un nuage de 5 points rouges qui s'alignent raisonnablement bien sur une droite de pente négative — le signe que la relation affine attendue est bien vérifiée par ces mesures.

Déterminer le coefficient de restitution

Consigne

Modélise le nuage de points par une droite avec np.polyfit(lnum, ldur, 1), et affiche le résultat.
D'après la théorie, la pente de cette droite vaut ln(e). Pour retrouver e lui-même, il faut donc appliquer la fonction exponentielle (l'inverse du logarithme népérien) à cette pente : e = np.exp(mod[0]).

etape3_coefficient_e.py

# TODO : modélise ldur en fonction de lnum par une droite
mod = np.polyfit(____, ____, _)
print('mod :', mod)

# TODO : le coefficient de restitution est l'exponentielle de la pente
e = np.exp(mod[_])
print('coefficient de restitution e =', e)

Indice

Le logarithme népérien et l'exponentielle sont des fonctions réciproques l'une de l'autre : si pente = ln(e), alors exp(pente) = exp(ln(e)) = e. C'est exactement ce que fait la ligne np.exp(mod[0]).

Résultat attendu

mod affiche une pente proche de -0,22, d'où un coefficient de restitution e ≈ 0,79 — une valeur très proche du e_moy = 83,8 % calculé directement par Phyphox. Deux méthodes de mesure indépendantes (le chronométrage automatique de l'application, et ta propre régression) convergent vers le même résultat.

＋

Pour aller plus loin : et le champ de pesanteur ?

Piste de réflexion

La relation théorique T_n = eⁿ · (2h0/g)^1/2 contient, en plus du coefficient e, la hauteur de chute initiale h0 et le champ de pesanteur g — tous deux « cachés » dans l'ordonnée à l'origine de la droite que tu as tracée à l'étape 3 (mod[1]).
À toi de jouer : en utilisant h0 = 33,24 cm (la valeur mesurée dans l'exemple Phyphox) et la relation ci-dessus, peux-tu exprimer g en fonction de mod[1] et de h0 ? Essaie de retrouver une valeur proche de 9,8 m·s⁻².
Indice de départ : prends le logarithme népérien des deux membres de la relation théorique pour n = 0, et compare avec l'expression de la droite modèle ldur = mod[0]·lnum + mod[1].

Pense-bête — linéariser une loi exponentielle

np.log(x)	logarithme népérien
np.exp(x)	exponentielle (réciproque du log)
ln(e^n) = n·ln(e)	la propriété qui linéarise la loi

e = E_c,après/E_c,avant	coefficient de restitution
h_n = eⁿ·h0	hauteur du n-ième rebond
e < 1	choc inélastique : perte d'énergie

Pas de Thonny sous la main ? Utilise Basthon

Ouvrir dans un nouvel onglet ↗

Basthon est une console Python qui tourne directement dans le navigateur, sans rien installer. Colle ici (avec Ctrl+V ou Cmd+V) le code copié avec les boutons « Copier le code » ci-dessus, puis appuie sur Entrée pour l'exécuter.