Un mobile sur lequel les forces se compensent garde-t-il vraiment une vitesse constante ? Et comment varie la vitesse d'une balle soumise à son seul poids ?
Objectifs
- Enregistrer un mouvement (chronophotographie ou vidéo) et en extraire des positions.
- Calculer des vitesses et des variations de vitesse \(\Delta v\).
- Vérifier le principe d'inertie sur un mobile autoporteur.
- Représenter les vecteurs \(\Delta\vec v\) d'une balle en chute libre avec Python.
Compétences travaillées
- Réaliser : enregistrer, pointer, programmer.
- Analyser : relier \(\Delta\vec v\) aux forces.
- Valider : confronter des mesures à un modèle, discuter la précision.
- Communiquer : présenter un graphique légendé.
Le code s'exécute réellement dans ton navigateur. Au premier clic sur ▶ Exécuter, Python se télécharge (≈ 7 Mo, une seule fois, connexion Internet nécessaire). Le bouton Télécharger .py donne un fichier utilisable dans EduPython, Thonny, Basthon ou Capytale.
Raccourcis : Ctrl + Entrée exécute, Tab décale la ligne de 4 espaces.
Débutant en Python : fais les cinq activités dans l'ordre, en t'aidant des indices. À l'aise avec les variables et les boucles (en général à partir du deuxième trimestre) : l'activité 1 est facultative, commence directement à l'activité 2 et vise l'activité 5 sans indice.
Matériel
- une table horizontale à coussin d'air et un mobile autoporteur (ou un palet sur une table lisse) ;
- une balle (tennis ou ping-pong lestée) ;
- un smartphone ou une webcam fixe, et une règle de 1 m pour l'étalonnage ;
- un logiciel de pointage vidéo (Tracker, Avimeca, LoggerPro, ou une application de pointage).
Protocole
Jeux de données pédagogiques Les programmes contiennent des positions construites à partir des modèles (mouvement uniforme, mouvement ralenti par frottement, chute libre avec \(g = 9{,}81\ \text{N}\cdot\text{kg}^{-1}\)), puis arrondies au millimètre comme lors d'un pointage. Remplace-les par tes propres mesures si tu as fait l'expérience.
Le pointage donne des positions dans le référentiel de la caméra : si elle bouge, ce n'est plus le référentiel terrestre et les mouvements sont faussés. Si elle filme de biais, les distances sont déformées par la perspective. La règle sert à l'étalonnage : elle indique au logiciel combien de pixels correspondent à 1 m, pour convertir les positions en mètres.
À partir de trois positions successives \(x_0\), \(x_1\), \(x_2\) du mobile autoporteur, il calcule les vitesses \(v_0 = \dfrac{x_1 - x_0}{\Delta t}\) et \(v_1 = \dfrac{x_2 - x_1}{\Delta t}\), puis la variation \(\Delta v_0 = v_1 - v_0\). Pourquoi ? Si les forces se compensent, le principe d'inertie prévoit \(\Delta v = 0\). Comment lire le résultat ? Une valeur de \(\Delta v\) très petite devant \(v\).
À faire :
- Complète les lignes
v1 = ...etdv = ..., puis exécute. - Calcule l'écart relatif \(\dfrac{|\Delta v|}{v_0}\) en pourcentage et affiche-le.
v1 utilise x2, x1 et dt. dv utilise v1 et v0.v1 = (x2 - x1) / dt ; dv = v1 - v0 ; ecart = abs(dv) / v0 * 100.dt = 0.10
x0 = 0.000
x1 = 0.050
x2 = 0.101
v0 = (x1 - x0) / dt
v1 = (x2 - x1) / dt
dv = v1 - v0
ecart = abs(dv) / v0 * 100
print("v0 =", round(v0, 3), "m/s")
print("v1 =", round(v1, 3), "m/s")
print("Δv =", round(dv, 3), "m/s")
print("écart relatif :", round(ecart, 1), "%")
Résultats attendus. \(v_0 = 0{,}50\ \text{m}\cdot\text{s}^{-1}\), \(v_1 = 0{,}51\ \text{m}\cdot\text{s}^{-1}\), \(\Delta v = 0{,}01\ \text{m}\cdot\text{s}^{-1}\), soit 2 %.
Interprétation. \(\Delta v\) est très petit : il correspond à une erreur de pointage de 1 mm (\(0{,}001/0{,}10 = 0{,}01\ \text{m}\cdot\text{s}^{-1}\)). À la précision des mesures, la vitesse est constante.
Erreurs fréquentes. Calculer x2 / dt (position et non déplacement) ; écrire dv = v0 - v1 (signe inversé).
Pour toutes les positions d'un enregistrement, il calcule la liste des vitesses, puis la liste des variations de vitesse. On compare deux mobiles lancés de la même façon : l'autoporteur sur coussin d'air, et un palet sur une table ordinaire. Pourquoi ? Pour voir l'effet d'une force non compensée (les frottements). Comment lire le résultat ? Des \(\Delta v\) proches de 0 d'un côté, des \(\Delta v\) négatifs et réguliers de l'autre.
À faire : complète la boucle qui remplit la liste dv. Exécute pour l'autoporteur, puis remplace la liste x par celle du palet (en commentaire) et exécute à nouveau. Réponds à Q2.
i est v[i], la suivante v[i + 1]. La boucle s'arrête à len(v) - 1 pour que v[i + 1] existe toujours.dv.append(v[i + 1] - v[i]). Pour le palet, ajoute # devant la première liste x et enlève-le devant la seconde.dt = 0.10
x = [0, 0.050, 0.101, 0.150, 0.200, 0.251, 0.300, 0.350] # autoporteur (m)
# x = [0, 0.056, 0.104, 0.144, 0.176, 0.200, 0.216, 0.224] # palet sur table ordinaire (m)
v = []
for i in range(len(x) - 1):
v.append((x[i + 1] - x[i]) / dt)
dv = []
for i in range(len(v) - 1):
dv.append(v[i + 1] - v[i])
print("vitesses (m/s) :", [round(a, 2) for a in v])
print("Δv (m/s) :", [round(a, 2) for a in dv])
Résultats attendus. Autoporteur : vitesses 0,50 ; 0,51 ; 0,49 ; 0,50 ; 0,51 ; 0,49 ; 0,50 m·s⁻¹ et \(\Delta v\) entre −0,02 et +0,01 m·s⁻¹. Palet : vitesses 0,56 ; 0,48 ; 0,40 ; 0,32 ; 0,24 ; 0,16 ; 0,08 m·s⁻¹ et \(\Delta v = -0{,}08\ \text{m}\cdot\text{s}^{-1}\) à chaque fois.
Interprétation. Pour l'autoporteur, les \(\Delta v\) sont de l'ordre de l'incertitude de pointage et changent de signe au hasard : \(\Delta v \approx 0\), le mouvement est rectiligne uniforme, les forces se compensent. Pour le palet, \(\Delta v\) est négatif (opposé au mouvement) et régulier : une force non compensée, le frottement, s'oppose au mouvement.
Erreurs fréquentes. Boucler jusqu'à len(v) : v[i + 1] n'existe pas au dernier tour (IndexError) ; oublier que la liste des vitesses a un élément de moins que celle des positions.
Autoporteur : \(\Delta v \approx 0\) (au plus 0,02 m·s⁻¹, soit 1 à 2 mm d'erreur de pointage). Mouvement rectiligne uniforme : d'après le principe d'inertie, les forces (poids et action du coussin d'air) se compensent. Palet : \(\Delta v = -0{,}08\ \text{m}\cdot\text{s}^{-1}\) à chaque intervalle, opposé au mouvement : d'après la contraposée, les forces ne se compensent pas ; leur somme est opposée au mouvement : c'est la force de frottement de la table.
Il trace la vitesse en fonction du temps pour les deux mobiles. Pourquoi ? Un graphique montre d'un coup si la vitesse reste constante. Comment le lire ? Une droite horizontale : vitesse constante. Une droite qui descend régulièrement : la vitesse diminue de la même quantité à chaque intervalle.
À faire : complète le calcul de v_palet, trace la seconde série, puis ajoute la légende, le titre et les axes avec unités.
x_auto par x_palet dans le calcul. Pour la courbe, copie la ligne plt.plot en changeant la liste, la couleur et l'étiquette.v_palet.append((x_palet[i + 1] - x_palet[i]) / dt) ; plt.plot(t, v_palet, 's-', color='red', label='palet (frottements)') ; plt.legend(), plt.xlabel("t (s)"), plt.ylabel("v (m/s)").import matplotlib.pyplot as plt
dt = 0.10
x_auto = [0, 0.050, 0.101, 0.150, 0.200, 0.251, 0.300, 0.350]
x_palet = [0, 0.056, 0.104, 0.144, 0.176, 0.200, 0.216, 0.224]
t = []
v_auto = []
v_palet = []
for i in range(len(x_auto) - 1):
t.append(i * dt)
v_auto.append((x_auto[i + 1] - x_auto[i]) / dt)
v_palet.append((x_palet[i + 1] - x_palet[i]) / dt)
plt.plot(t, v_auto, 'o-', color='blue', label='autoporteur')
plt.plot(t, v_palet, 's-', color='red', label='palet (frottements)')
plt.title("Vitesse des deux mobiles")
plt.xlabel("t (s)")
plt.ylabel("v (m/s)")
plt.legend()
plt.grid()
plt.ylim(0, 0.7)
plt.show()
Résultat attendu. Les points bleus forment une droite horizontale vers 0,50 m·s⁻¹. Les points rouges forment une droite qui descend de 0,56 à 0,08 m·s⁻¹.
Interprétation. Sans frottements, la vitesse ne varie pas : principe d'inertie. Avec frottements, elle diminue de la même quantité (0,08 m·s⁻¹) toutes les 0,10 s : la force de frottement reste à peu près la même pendant le glissement. Le palet s'arrêtera un peu après 0,7 s.
Erreurs fréquentes. Oublier plt.legend() ; utiliser x_auto dans le calcul de v_palet (les deux courbes seraient confondues).
À partir des positions \((x_i\ ;\ y_i)\) de la balle, il calcule les coordonnées des vitesses, puis celles des vecteurs variation de vitesse :
et trace chaque \(\Delta\vec v_i\) au point \(M_{i+1}\). Pourquoi ? En chute libre, le cours prévoit des \(\Delta\vec v\) verticaux, vers le bas et tous identiques. Comment lire le résultat ? Des flèches toutes parallèles, vers le bas, de même longueur.
\(\Delta v\) vaut environ 0,5 m·s⁻¹ : pour que les flèches soient visibles, on choisit echelle = 0.2 (1 m·s⁻¹ représenté par 0,2 m sur le graphique).
À faire : complète le calcul de dvy et les deux longueurs de la flèche. Exécute, puis réponds à Q3.
vy. Longueur horizontale de la flèche : dvx * echelle.dvy = vy[i + 1] - vy[i] et plt.arrow(x[i + 1], y[i + 1], dvx * echelle, dvy * echelle, color='green', head_width=0.015).import matplotlib.pyplot as plt
dt = 0.050
x = [0.0, 0.095, 0.191, 0.286, 0.382, 0.477, 0.572, 0.668, 0.763, 0.858, 0.954, 1.049, 1.145]
y = [0.0, 0.14, 0.256, 0.348, 0.414, 0.457, 0.474, 0.468, 0.436, 0.381, 0.3, 0.195, 0.066]
echelle = 0.2
vx = []
vy = []
for i in range(len(x) - 1):
vx.append((x[i + 1] - x[i]) / dt)
vy.append((y[i + 1] - y[i]) / dt)
plt.plot(x, y, 'o', color='navy')
somme = 0
for i in range(len(vx) - 1):
dvx = vx[i + 1] - vx[i]
dvy = vy[i + 1] - vy[i]
somme = somme + dvy
print("Δv", i, ": (", round(dvx, 2), ";", round(dvy, 2), ") m/s")
plt.arrow(x[i + 1], y[i + 1], dvx * echelle, dvy * echelle, color='green', head_width=0.015)
moyenne = somme / (len(vx) - 1)
print("Δvy moyen :", round(moyenne, 3), "m/s")
print("Δvy moyen / dt :", round(moyenne / dt, 2), "m/s²")
plt.title("Vecteurs Δv de la balle (1 m/s ↔ 0,2 m)")
plt.xlabel("x (m)")
plt.ylabel("y (m)")
plt.axis('equal')
plt.grid()
plt.show()
Résultats attendus. \(\Delta v_x\) vaut 0 ou ±0,02 m·s⁻¹ ; \(\Delta v_y\) est compris entre −0,52 et −0,46 m·s⁻¹. Moyenne : \(\Delta v_y \approx -0{,}489\ \text{m}\cdot\text{s}^{-1}\), et \(\Delta v_y/\Delta t \approx -9{,}78\ \text{m}\cdot\text{s}^{-2}\). Les flèches vertes sont toutes verticales, vers le bas, presque de même longueur, à la montée comme à la descente.
Interprétation. La balle n'est soumise qu'à son poids, vertical et constant : les \(\Delta\vec v\) sont verticaux, vers le bas et identiques, comme le prévoit le cours. La valeur \(|\Delta v_y|/\Delta t \approx 9{,}8\) est celle de \(g\) : ce lien sera établi en Première. Les petites variations (0,46 à 0,52) viennent de l'arrondi des positions au millimètre.
Erreurs fréquentes. Faire partir les flèches de \(M_i\) au lieu de \(M_{i+1}\) (ce n'est pas faux en soi, mais il faut garder la même convention partout) ; oublier l'échelle (les flèches de 0,5 m écrasent le graphique) ; oublier plt.axis('equal').
Les \(\Delta\vec v\) sont verticaux, dirigés vers le bas, de valeur ≈ 0,49 m·s⁻¹, en tout point : à la montée, au sommet et à la descente. C'est cohérent : la balle n'est soumise qu'à son poids (action de l'air négligeable), vertical, vers le bas et constant ; \(\Delta\vec v\) a la direction et le sens de la somme des forces. À la montée, \(\Delta\vec v\) est opposé à la composante verticale de la vitesse : la balle ralentit verticalement ; à la descente, il est dans son sens : elle accélère. Horizontalement, \(\Delta v_x \approx 0\) : aucune force horizontale.
Yanis veut calculer la valeur moyenne de \(\Delta v_y / \Delta t\) pour une balle qui tombe verticalement, filmée avec des images espacées de 50 ms. Son programme contient quatre erreurs : deux l'empêchent de fonctionner, deux donnent un résultat faux sans message. Corrige une erreur à la fois, et compare le résultat final à ce qu'on attend pour une chute libre.
i si on utilise vy[i + 1] ? La variable tau existe-t-elle ? Dans quel ordre fait-on la soustraction ? Dans quelle unité doit être dt ?range(len(vy) - 1) ; moyenne / dt au lieu de tau ; vy[i + 1] - vy[i] ; dt = 0.050 (en secondes).dt = 0.050 # erreur 4 : durée en secondes
y = [1.0, 0.988, 0.951, 0.890, 0.804, 0.693, 0.559, 0.399]
vy = []
for i in range(len(y) - 1):
vy.append((y[i + 1] - y[i]) / dt)
somme = 0
for i in range(len(vy) - 1): # erreur 1 : vy[i + 1] doit exister
somme = somme + (vy[i + 1] - vy[i]) # erreur 3 : après − avant
moyenne = somme / (len(vy) - 1)
print("Δvy / dt moyen :", round(moyenne / dt, 2), "m/s²") # erreur 2 : dt et non tau
Erreur 1 (bloquante). Au dernier tour de boucle, vy[i + 1] n'existe pas : IndexError. Il faut s'arrêter à len(vy) - 1.
Erreur 2 (bloquante). tau n'a jamais été créée : NameError. L'intervalle s'appelle dt.
Erreur 3 (silencieuse). vy[i] - vy[i + 1] donne « avant − après » : le signe est inversé, et le programme affiche une valeur positive, comme si \(\Delta\vec v\) était vers le haut.
Erreur 4 (silencieuse). dt = 50 est en millisecondes : les vitesses et le résultat final sont faux. Avec seulement les erreurs 1 et 2 corrigées, le programme affiche environ \(1\times10^{-5}\) (positif) : signe faux et ordre de grandeur absurde.
Résultat après correction. \(\Delta v_y/\Delta t \approx -9{,}87\ \text{m}\cdot\text{s}^{-2}\) : négatif (vers le bas) et de valeur proche de \(g\), comme attendu en chute libre.
On attend une valeur négative (la balle accélère vers le bas, \(\Delta\vec v\) est vers le bas) et d'environ 9,8 en valeur absolue (chute libre). Le programme affiche environ \(1\times10^{-5}\) : le signe est faux (valeur positive, erreur 3) et l'ordre de grandeur est absurde, un million de fois trop petit (erreur 4 : durée en ms au lieu de s, qui intervient deux fois dans le calcul). Confronter un résultat au signe et à l'ordre de grandeur attendus permet de détecter les erreurs silencieuses.
Sur la table à coussin d'air, les forces exercées sur le mobile se compensent : ses \(\Delta v\) sont nuls à la précision du pointage près (quelques mm), son mouvement est rectiligne uniforme, conformément au principe d'inertie. Un palet sur une table ordinaire, soumis à une force de frottement non compensée, ralentit régulièrement : \(\Delta\vec v\) est opposé au mouvement. La balle lancée n'est soumise qu'à son poids : ses \(\Delta\vec v\) sont verticaux, vers le bas, tous identiques (≈ 0,49 m·s⁻¹ toutes les 0,050 s), et sa vitesse horizontale reste constante. Dans tous les cas, \(\Delta\vec v\) a la direction et le sens de la somme des forces.
Grille d'auto-évaluation
A = je sais faire seul · B = avec un peu d'aide · C = partiellement · D = à retravailler.
| Compétence | A | B | C | D |
|---|---|---|---|---|
| Enregistrer et pointer un mouvement | ||||
| Calculer une vitesse et une variation de vitesse | ||||
| Utiliser le principe d'inertie ou sa contraposée | ||||
| Tracer des vecteurs Δv avec Python | ||||
| Relier Δv à la somme des forces (chute libre) | ||||
| Repérer une erreur grâce au signe et à l'ordre de grandeur |
Fiche professeur
Organisation
Durée totale estimée : 110 min. En séance de 1 h 30 : partie expérimentale et activités 1 à 3 ; activités 4 et 5 et conclusion en fin de séance, à la maison ou en séance suivante. Le parcours « à l'aise » (activité 1 facultative) fait gagner environ 10 min.
Préparation
Tester la table à coussin d'air ou prévoir les vidéos de secours (mobile autoporteur, balle lancée) ; vérifier le logiciel de pointage.
Sécurité
Table à coussin d'air : tuyau d'air bien fixé, ne pas lancer le mobile hors de la table.
Points de vigilance
Le principe d'inertie se vérifie sur le mobile autoporteur (vecteurs vitesse identiques) ; ne pas laisser croire qu'une force est nécessaire pour maintenir un mouvement.
Différenciation
Aide : Fournir les positions pointées ; faire tracer deux vecteurs vitesse à la main avant de lancer le programme.
Approfondissement : Comparer la variation de vitesse de la balle à la direction du poids : lien qualitatif force / variation de vitesse.
Évaluation (sur 20)
Variation du vecteur vitesse (activités 3 et 4, 8 pts) ; Q5 (principe d'inertie et sa contraposée, 6 pts) ; activité 5 (4 pts) ; pointage (2 pts).
Les corrections détaillées des activités Python et des questions sont dans les encadrés de chaque partie.
Pour consolider : exercices 5, 9 et 10, puis le quiz du cours.
Exercices corrigés Retour au cours