Fréquence et vitesse du son

duree_10T = 22.7

T = duree_10T / 10 / 1000
f = 1 / T
ecart = abs(f - 440) / 440 * 100

print("T =", T, "s")
print("f =", round(f, 1), "Hz")
print("écart avec 440 Hz :", round(ecart, 2), "%")

Résultats attendus. \(T = 0{,}002\,27\ \text{s}\), \(f = 440{,}5\ \text{Hz}\), écart 0,12 %.

Interprétation. La fréquence mesurée est en accord avec 440 Hz. Une erreur de lecture de 0,1 ms sur 22,7 ms correspond à 0,4 % : l'écart de 0,12 % est inférieur à cette précision.

Erreurs fréquentes. Oublier de diviser par 1 000 (f = 0,44 Hz) ou par 10 (f = 44 Hz).

sources = ["grondement d'éléphant", "contrebasse (mi grave)", "voix d'homme", "diapason",
           "sifflement", "sifflet à chien", "cri de chauve-souris"]
periodes_ms = [71.4, 24.3, 8.33, 2.27, 0.50, 0.040, 0.020]

for i in range(len(sources)):
    f = 1 / (periodes_ms[i] / 1000)
    if f < 20:
        domaine = "infrason"
    elif f <= 20000:
        domaine = "audible"
    else:
        domaine = "ultrason"
    print(sources[i], ":", round(f), "Hz ->", domaine)

Résultats attendus. Éléphant 14 Hz (infrason) ; contrebasse 41 Hz, voix 120 Hz, diapason 441 Hz, sifflement 2 000 Hz (audibles) ; sifflet à chien 25 000 Hz et chauve-souris 50 000 Hz (ultrasons).

Interprétation. Plus la période est courte, plus la fréquence est grande : les ultrasons ont des périodes de quelques dizaines de microsecondes. Les éléphants communiquent en partie par infrasons, inaudibles pour nous ; les chiens entendent des ultrasons jusqu'à environ 40 kHz.

Erreurs fréquentes. Écrire elif f < 20 000 avec un espace (erreur de syntaxe) ; inverser l'ordre des tests.

import matplotlib.pyplot as plt

d = [0.20, 0.40, 0.60, 0.80, 1.00]
dt_ms = [0.59, 1.17, 1.76, 2.33, 2.92]

dt = []
v = []
for i in range(len(d)):
    dt.append(dt_ms[i] / 1000)
    v.append(d[i] / dt[i])

v_moy = sum(v) / len(v)
print("vitesses (m/s) :", [round(x) for x in v])
print("vitesse moyenne :", round(v_moy), "m/s")

d_modele = []
for i in range(len(dt)):
    d_modele.append(v_moy * dt[i])

plt.plot(dt_ms, d, 'o', color='red', label='mesures')
plt.plot(dt_ms, d_modele, '-', color='navy', label='modèle')
plt.title("Distance parcourue par le son en fonction de la durée")
plt.xlabel("Δt (ms)")
plt.ylabel("d (m)")
plt.legend()
plt.grid()
plt.show()

Résultats attendus. Vitesses : 339 ; 342 ; 341 ; 343 ; 342 m/s. Moyenne : 342 m/s. Les points sont pratiquement sur la droite du modèle.

Interprétation. \(d\) est proportionnelle à \(\Delta t\) : le son se propage à vitesse constante, environ 342 m/s, en accord avec 343 m/s à 20 °C (écart de 0,3 %). La première mesure, la plus courte, est la moins précise : 0,01 ms d'erreur sur 0,59 ms représente près de 2 %.

Erreurs fréquentes. Diviser par dt_ms[i] (vitesses 1 000 fois trop petites, 0,34 m/s) ; tracer le modèle avec dt en secondes et les mesures avec dt_ms (les deux séries ne se superposent plus).

import math
import matplotlib.pyplot as plt

def signal(t, f, amplitudes):
    u = 0
    for k in range(len(amplitudes)):
        rang = k + 1
        u = u + amplitudes[k] * math.sin(2 * math.pi * rang * f * t)
    return u

f = 220
diapason = [1]
clarinette = [1, 0, 0.5, 0, 0.3]

t_ms = []
u_pur = []
u_clar = []
for i in range(401):
    t = i * 0.025e-3
    t_ms.append(t * 1000)
    u_pur.append(signal(t, f, diapason))
    u_clar.append(signal(t, f, clarinette))

plt.plot(t_ms, u_pur, '-', color='blue', label='son pur (diapason)')
plt.plot(t_ms, u_clar, '-', color='red', label='son composé (clarinette)')
plt.title("Même note, deux timbres")
plt.xlabel("t (ms)")
plt.ylabel("tension (unité arbitraire)")
plt.legend()
plt.grid()
plt.show()
print("période de la note :", round(1 / f * 1000, 2), "ms")

Résultats attendus. Une sinusoïde bleue et une courbe rouge plus « carrée », avec des bosses. Les deux se répètent toutes les 4,55 ms (un peu plus de 2 périodes sur l'écran de 10 ms).

Interprétation. Les deux sons ont la même période, donc la même fréquence et la même hauteur. Leurs formes diffèrent : ils n'ont pas le même timbre. Le timbre dépend des harmoniques présents et de leurs amplitudes.

Erreurs fréquentes. Oublier rang (toutes les sinusoïdes ont alors la fréquence \(f\) et la courbe reste une sinusoïde) ; oublier u + (seul le dernier harmonique est gardé).

v_son = 340
duree = 12.0

d = v_son * (duree / 1000) / 2       # erreurs 2, 3 et 4
print("Distance du mur :", round(d, 2), "m")   # erreur 1 : virgule

Erreur 1 (bloquante). Dans le print, il manque une virgule entre le texte et round(d, 2) : erreur de syntaxe.

Erreur 2 (bloquante). La variable v n'existe pas : elle s'appelle v_son (NameError).

Erreur 3 (silencieuse). La durée est en millisecondes : le programme affiche 4 080 m, absurde pour un mur de cour.

Erreur 4 (silencieuse). Pendant 12,0 ms, le son fait l'aller-retour : il parcourt deux fois la distance du mur. Sans la division par 2, on trouve 4,08 m : plausible, mais deux fois la mesure au mètre ruban.

Résultat après correction. \(d = 2{,}04\ \text{m}\), en accord avec la mesure au mètre (environ 2 m).