Comment évoluent la direction et la valeur du vecteur vitesse d'une balle lancée, de son départ jusqu'à sa redescente ?
Objectifs
- Exploiter une chronophotographie : positions, durée \(\Delta t\), distances.
- Calculer des vitesses avec \(v_i = \dfrac{M_iM_{i+1}}{\Delta t}\).
- Représenter des positions successives avec un langage de programmation.
- Représenter des vecteurs vitesse avec un langage de programmation.
- Interpréter les résultats et repérer l'effet des erreurs de mesure.
Compétences travaillées
- Réaliser : mettre en œuvre un protocole, programmer.
- Analyser : choisir la bonne relation, organiser un calcul.
- Valider : juger la cohérence d'un résultat.
- Communiquer : légender un graphique (titre, axes, unités).
Les capacités numériques en gras sont celles du programme officiel de Seconde.
Le code s'exécute réellement, dans ton navigateur (technologie Pyodide). Au premier clic sur ▶ Exécuter, Python se télécharge (≈ 7 Mo, une seule fois, connexion Internet nécessaire). Tes modifications sont gardées dans ce navigateur.
Pour les graphiques, l'éditeur utilise une version allégée de matplotlib.pyplot avec exactement la même syntaxe (plot, arrow, xlabel, show…). Le bouton Télécharger .py donne un fichier qui fonctionne tel quel avec le vrai matplotlib, dans EduPython, Thonny, Basthon ou Capytale.
Raccourcis : Ctrl + Entrée exécute le code, 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
- un smartphone sur un support fixe (ou une webcam) ;
- une balle de tennis ;
- un mètre ruban ou une règle de 1 m (étalon de longueur) ;
- un fond uni et bien éclairé ;
- un logiciel de pointage gratuit : Tracker, Pymecavideo ou Avimeca.
Protocole
x et y).Lancer doucement, loin des fenêtres et des personnes. Si la caméra n'est pas perpendiculaire au plan du lancer, les distances mesurées sont faussées. Le pointage « au clic » introduit une incertitude de quelques millimètres sur chaque position.
Jeu de données pédagogique Si tu ne peux pas filmer, utilise les données des programmes. Elles ont été calculées à partir d'un modèle de lancer (vitesse initiale réaliste, \(g = 9{,}81\ \text{N/kg}\)), puis légèrement « bruitées » (± 3 mm) pour imiter les erreurs de pointage d'une vraie vidéo. Durée entre deux images : \(\Delta t = 0{,}040\ \text{s}\) (25 images par seconde).
Le logiciel ne mesure que des pixels. L'objet de longueur connue donne l'échelle (combien de mètres réels pour un pixel) : sans elle, impossible d'obtenir des distances en mètres, donc des vitesses en m·s⁻¹. Il doit être dans le plan du mouvement, sinon il paraît plus grand ou plus petit (perspective) et l'échelle est fausse.
Un palet glisse sur une table à coussin d'air. Le programme stocke deux positions et la durée entre elles dans des variables, puis calcule la distance parcourue et la vitesse \(v = \dfrac{d}{\Delta t}\). Pourquoi ? C'est exactement le calcul que tu ferais à la main, écrit une fois pour toutes. Comment lire le résultat ? Une valeur en m·s⁻¹ à comparer avec une vitesse connue.
À faire :
- Exécute le programme. Le résultat de la distance te paraît-il étrange ? Corrige l'affichage avec
round(d, 3). - Ajoute une variable
v_kmhqui contient la vitesse en km/h et affiche-la. - Remplace
dt = 0.050pardt = 0.100et exécute à nouveau. Que devient la vitesse ? Est-ce logique ?
v_kmh = … qui utilise la variable v déjà calculée. Une multiplication s'écrit avec *.print("Vitesse :", round(v_kmh, 1), "km/h").x1 = 0.062
x2 = 0.092
dt = 0.050
d = x2 - x1
v = d / dt
v_kmh = v * 3.6 # conversion m/s → km/h
print("Distance parcourue :", round(d, 3), "m")
print("Vitesse :", round(v, 2), "m/s, soit", round(v_kmh, 1), "km/h")
Lignes importantes. d = x2 - x1 : sur une droite, la distance entre deux positions est la différence des abscisses. v_kmh = v * 3.6 réutilise v : inutile de refaire tout le calcul.
Résultats attendus. Distance : 0.03 m ; vitesse : 0.6 m/s, soit 2.2 km/h. Avec dt = 0.100 : 0.3 m/s.
Interprétation. Sans round, Python affiche 0.030000000000000006 : l'ordinateur stocke les décimaux en binaire avec une infime erreur d'arrondi, sans importance physique. Si la même distance est parcourue en deux fois plus de temps, la vitesse est deux fois plus petite : c'est cohérent avec \(v = d/\Delta t\).
Erreurs fréquentes. Écrire 0,062 (virgule) au lieu de 0.062 ; écrire v_kmh = v / 3.6 (on obtient une valeur plus petite qu'en m·s⁻¹ : impossible, 1 m·s⁻¹ = 3,6 km/h).
Les dix positions du palet sont rangées dans une liste x. Une boucle parcourt les positions deux par deux et calcule \(v_i = \dfrac{x_{i+1}-x_i}{\Delta t}\) pour chaque intervalle. Pourquoi ? Faire 9 calculs à la main est long ; le programme les fait tous de la même façon. Comment lire le résultat ? Si toutes les vitesses sont proches, le mouvement est uniforme.
x[0] est la première valeur de la liste, x[1] la deuxième… len(x) donne le nombre de valeurs. Avec 10 positions, il n'y a que 9 intervalles : la boucle doit s'arrêter avant le dernier point, d'où range(len(x) - 1).
À faire : complète les deux lignes marquées ..., exécute, puis réponds à la question Q2.
i est x[i], la suivante est x[i + 1]. Une moyenne est la somme des valeurs divisée par leur nombre : sum(liste) et len(liste).v = (x[i + 1] - x[i]) / dt ; la moyenne utilise la liste vitesses, pas la liste x.dt = 0.050
x = [0.0, 0.03, 0.062, 0.092, 0.124, 0.156, 0.184, 0.215, 0.249, 0.278]
vitesses = []
for i in range(len(x) - 1):
v = (x[i + 1] - x[i]) / dt # distance entre deux images / durée
vitesses.append(v)
print("Entre M", i, "et M", i + 1, ":", round(v, 2), "m/s")
moyenne = sum(vitesses) / len(vitesses)
print("Vitesse moyenne :", round(moyenne, 2), "m/s")
Lignes importantes. range(len(x) - 1) donne i de 0 à 8 : la dernière vitesse utilise x[9], le dernier point. vitesses.append(v) mémorise chaque vitesse pour calculer la moyenne ensuite.
Résultats attendus. 0.6 ; 0.64 ; 0.6 ; 0.64 ; 0.64 ; 0.56 ; 0.62 ; 0.68 ; 0.58 m/s. Moyenne : 0.62 m/s.
Interprétation. Les vitesses varient légèrement autour de 0,62 m·s⁻¹ (entre 0,56 et 0,68) sans augmenter ni diminuer régulièrement : ces petites variations viennent des erreurs de pointage (quelques millimètres). Le mouvement du palet est rectiligne uniforme, aux incertitudes de mesure près.
Erreurs fréquentes. range(len(x)) fait calculer x[10], qui n'existe pas (IndexError) ; diviser par len(x) (10) au lieu de len(vitesses) (9).
Pour aller plus loin. Vérifie que la moyenne vaut aussi \(\dfrac{x_9 - x_0}{9\,\Delta t}\). Pourquoi est-ce logique ?
Oui, il est uniforme : les vitesses restent autour de 0,62 m·s⁻¹, sans tendance à augmenter ou à diminuer. Les petits écarts (± 0,06 m·s⁻¹) viennent de l'incertitude du pointage : une erreur de 1,5 mm sur une position, divisée par \(\Delta t = 0{,}050\ \text{s}\), donne déjà une erreur de 0,03 m·s⁻¹ sur la vitesse.
Il place les positions successives \((x_i\ ;\ y_i)\) de la balle de tennis dans un repère : c'est une chronophotographie reconstruite. Pourquoi ? Le graphique montre d'un coup d'œil la forme de la trajectoire et l'espacement des points. Comment le lire ? Un graphique scientifique doit avoir un titre, des axes nommés avec leurs unités, et la même échelle sur les deux axes pour ne pas déformer la trajectoire.
À faire : le programme trace les points mais le graphique est incomplet. Ajoute :
- un titre ;
- le nom et l'unité de chaque axe ;
- la même échelle sur les deux axes, et une grille ;
- (bonus) le nom de chaque point : M0, M1, M2…
plt.title(...), plt.xlabel(...), plt.ylabel(...), plt.axis('equal') et plt.grid(), avant plt.show().for i in range(len(x)): avec, à l'intérieur, plt.text(x[i], y[i], "M" + str(i)). str(i) transforme le nombre en texte.import matplotlib.pyplot as plt
dt = 0.040
x = [0.0, 0.099, 0.201, 0.3, 0.397, 0.497, 0.597, 0.7, 0.798, 0.901, 1.0, 1.103, 1.202, 1.298, 1.399, 1.498]
y = [0.0, 0.134, 0.254, 0.361, 0.45, 0.523, 0.579, 0.625, 0.648, 0.663, 0.655, 0.632, 0.597, 0.543, 0.48, 0.395]
plt.plot(x, y, 'o', color='navy', label='positions de la balle')
for i in range(len(x)):
plt.text(x[i], y[i], "M" + str(i)) # nom de chaque point
plt.title("Chronophotographie d'un lancer (Δt = 0,040 s)")
plt.xlabel("x (m)")
plt.ylabel("y (m)")
plt.axis('equal') # même échelle sur les deux axes
plt.grid()
plt.legend()
plt.show()
Résultat attendu. 16 points formant une courbe en cloche (parabole) : la balle monte jusqu'à environ 0,66 m de haut vers \(x \approx 0{,}9\ \text{m}\), puis redescend.
Interprétation. La trajectoire est curviligne. Horizontalement, les points sont régulièrement espacés (environ 0,10 m entre deux images) ; verticalement, les écarts diminuent en montant puis augmentent en descendant.
Erreurs fréquentes. Oublier les unités dans les noms d'axes ; écrire plt.plot(x, y) sans 'o' (les points sont reliés et on ne voit plus les positions) ; mettre plt.show() avant plt.xlabel (les réglages arrivent trop tard).
La trajectoire est curviligne (forme de parabole) dans le référentiel terrestre. L'écart horizontal reste à peu près constant (≈ 0,10 m) : selon l'horizontale, le mouvement est uniforme. L'écart vertical diminue pendant la montée (la balle ralentit verticalement), devient presque nul au sommet, puis augmente vers le bas pendant la descente.
En chaque point \(M_i\), il calcule les deux coordonnées du vecteur vitesse :
puis dessine une flèche partant de \(M_i\). Pourquoi ? C'est la construction du cours \(\vec v_i \approx \overrightarrow{M_iM_{i+1}}/\Delta t\), appliquée à tous les points. Comment lire le résultat ? La direction de chaque flèche suit la trajectoire ; sa longueur donne la valeur de la vitesse grâce à l'échelle choisie.
Une vitesse n'est pas une longueur : on choisit echelle = 0.03, ce qui signifie que \(1\ \text{m}\cdot\text{s}^{-1}\) est représenté par une flèche de 0,03 m sur le graphique. Une vitesse de 4 m·s⁻¹ donne une flèche de 0,12 m, un peu plus courte que l'écart entre deux points : les flèches restent distinctes.
À faire : complète les lignes marquées ... pour calculer vy et tracer chaque flèche avec plt.arrow(x_départ, y_départ, longueur_x, longueur_y). Puis réponds à Q4.
vx * echelle, verticalement… à toi.vy = (y[i + 1] - y[i]) / dt et plt.arrow(x[i], y[i], vx * echelle, vy * echelle, color='red', head_width=0.015).import matplotlib.pyplot as plt
dt = 0.040
x = [0.0, 0.099, 0.201, 0.3, 0.397, 0.497, 0.597, 0.7, 0.798, 0.901, 1.0, 1.103, 1.202, 1.298, 1.399, 1.498]
y = [0.0, 0.134, 0.254, 0.361, 0.45, 0.523, 0.579, 0.625, 0.648, 0.663, 0.655, 0.632, 0.597, 0.543, 0.48, 0.395]
echelle = 0.03
plt.plot(x, y, 'o', color='navy')
for i in range(len(x) - 1):
vx = (x[i + 1] - x[i]) / dt
vy = (y[i + 1] - y[i]) / dt
v = (vx**2 + vy**2) ** 0.5
print("M", i, ": v =", round(v, 2), "m/s")
plt.arrow(x[i], y[i], vx * echelle, vy * echelle, color='red', head_width=0.015)
plt.title("Vecteurs vitesse (1 m/s ↔ 0,03 m)")
plt.xlabel("x (m)")
plt.ylabel("y (m)")
plt.axis('equal')
plt.grid()
plt.show()
Lignes importantes. vx et vy sont les coordonnées du vecteur \(\overrightarrow{M_iM_{i+1}}/\Delta t\). Dans plt.arrow, les deux premiers nombres placent l'origine de la flèche en \(M_i\) ; les deux suivants donnent son étendue à l'échelle choisie.
Résultats attendus. \(v\) passe de 4,17 m·s⁻¹ (M0) à environ 2,5 m·s⁻¹ près du sommet (M7 à M9), puis remonte à 3,26 m·s⁻¹ (M14). Les flèches sont tangentes à la trajectoire : inclinées vers le haut au départ, presque horizontales au sommet, inclinées vers le bas à la fin.
Interprétation. La direction du vecteur vitesse change en permanence (trajectoire courbe) et sa valeur diminue puis augmente. Le vecteur vitesse n'est jamais constant : le mouvement n'est pas uniforme. Les petites irrégularités (2,52 puis 2,60 m·s⁻¹) viennent du bruit de pointage.
Erreurs fréquentes. Faire partir la flèche de x[i + 1] au lieu de x[i] ; oublier l'échelle (flèches de 4 m de long qui écrasent le graphique) ; oublier plt.axis('equal') (les flèches ne paraissent plus tangentes).
Variante. Affiche aussi vx : il reste proche de 2,5 m·s⁻¹ du début à la fin. Seule la composante verticale \(v_y\) change : elle passe de positive (montée) à négative (descente).
La vitesse est minimale près du sommet de la trajectoire (≈ 2,5 m·s⁻¹ vers M7 à M9). Le vecteur vitesse y est presque horizontal : au sommet, la balle ne monte plus et ne descend pas encore. C'est cohérent avec le cours : le vecteur vitesse est tangent à la trajectoire, et la tangente au sommet d'une courbe en cloche est horizontale. La vitesse n'est pas nulle au sommet : la balle continue d'avancer horizontalement.
Théo a voulu écrire seul un programme qui affiche la vitesse en chaque point. Il contient trois erreurs : deux empêchent le programme de fonctionner, la troisième donne des résultats faux sans message d'erreur. Exécute, lis les messages, corrige une erreur à la fois, et vérifie la cohérence des résultats.
dt = 0.04 ; range(len(x) - 1) ; diviser par dt au lieu de multiplier.dt = 0.04 # erreur 1 : point décimal
x = [0.0, 0.099, 0.201, 0.3, 0.397, 0.497, 0.597, 0.7, 0.798, 0.901, 1.0, 1.103, 1.202, 1.298, 1.399, 1.498]
y = [0.0, 0.134, 0.254, 0.361, 0.45, 0.523, 0.579, 0.625, 0.648, 0.663, 0.655, 0.632, 0.597, 0.543, 0.48, 0.395]
for i in range(len(x) - 1): # erreur 2 : 15 intervalles pour 16 points
vx = (x[i + 1] - x[i]) / dt # erreur 3 : v = d / Δt
vy = (y[i + 1] - y[i]) / dt
v = (vx**2 + vy**2) ** 0.5
print("M", i, ": v =", round(v, 2), "m/s")
Erreur 1. Avec dt = 0,04, Python lit deux nombres séparés par une virgule, 0 et 04, et refuse d'écrire un entier commençant par 0 : erreur d'écriture dès la ligne 1. En Python, la virgule décimale s'écrit avec un point.
Erreur 2. Avec range(len(x)), la dernière valeur de i est 15 et le programme cherche x[16], qui n'existe pas (IndexError). Avec 16 points, il n'y a que 15 intervalles.
Erreur 3. Multiplier par dt donne des « vitesses » de l'ordre de 0,007 m·s⁻¹ : une balle lancée irait moins vite qu'un escargot ! Aucun message d'erreur ne signale ce problème : seul un regard critique sur l'ordre de grandeur permet de le repérer.
Résultats attendus après correction. Les mêmes valeurs qu'à l'activité 4 : de 4,17 m·s⁻¹ à 3,26 m·s⁻¹ en passant par un minimum d'environ 2,5 m·s⁻¹.
Parce que le programme fonctionne et affiche des nombres : rien ne signale l'erreur. Seule une vérification de cohérence (ordre de grandeur d'une vitesse de lancer : quelques m·s⁻¹) permet de la détecter. Un ordinateur calcule exactement ce qu'on lui demande, même si la physique est fausse.
Dans le référentiel terrestre, le vecteur vitesse de la balle est toujours tangent à la trajectoire et orienté dans le sens du mouvement. Sa direction tourne progressivement : inclinée vers le haut au départ, horizontale au sommet, inclinée vers le bas en fin de trajectoire. Sa valeur diminue pendant la montée (de 4,2 à environ 2,5 m·s⁻¹), est minimale au sommet, puis augmente pendant la descente. La composante horizontale \(v_x\) reste à peu près constante (≈ 2,5 m·s⁻¹) : seule la composante verticale varie. Le vecteur vitesse n'est donc pas constant : le mouvement est curviligne et non uniforme.
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 |
|---|---|---|---|---|
| Calculer une vitesse à partir de deux positions et de \(\Delta t\) | ||||
| Utiliser une liste et une boucle pour traiter des mesures | ||||
| Tracer un graphique légendé (titre, axes, unités) | ||||
| Représenter des vecteurs vitesse avec une échelle | ||||
| Repérer et corriger une erreur dans un programme | ||||
| Juger la cohérence d'un résultat (ordre de grandeur, unité) |
Fiche professeur
Organisation
Durée totale estimée : 100 min, compatible avec une séance de 1 h 30 à 2 h.
Préparation
Tester le logiciel de pointage sur les postes avant la séance ; préparer une vidéo de secours (lancer de balle filmé avec un étalon de 1 m).
Sécurité
Pas de risque particulier ; zone de lancer dégagée.
Points de vigilance
L'étalonnage de longueur dans le logiciel est l'erreur la plus fréquente : vérifier qu'une règle de 1 m mesure bien 1 m après étalonnage. L'origine du repère doit être placée avant le pointage.
Différenciation
Aide : Fournir directement le fichier de positions pointées ; travailler l'activité 3 avec le schéma papier du cours.
Approfondissement : Comparer les vecteurs vitesse au sommet et au départ ; prolonger vers la variation de vitesse (chapitre 7).
Évaluation (sur 20)
Construction des vecteurs vitesse (activité 4, 6 pts) ; description du mouvement (Q5, 6 pts) ; activité 5 (4 pts) ; qualité du pointage (4 pts).
Les corrections détaillées des activités Python et des questions sont dans les encadrés de chaque partie.
Pour consolider : exercices 8 et 9 (mêmes calculs, à la main), puis le quiz du cours.
Exercices corrigés Retour au cours