Vecteurs et
trigonométrie.

• Calculer la position d’un robot après une suite de déplacements.
• Trouver l’angle vers une cible et la distance qui la sépare.
• Faire tourner un point, un vecteur, une forme.
• Comprendre comment un robot à deux roues estime sa position.

Pas de prérequis en trigonométrie : tout est introduit par le cercle et vérifié par le code.

Le déplacement de p à q se décompose en dx horizontal et dy vertical, perpendiculaires. La distance est l’hypoténuse. d² = dx² + dy². La fonction hypot est plus sûre que sqrt(dx*dx + dy*dy) pour les très grands ou très petits nombres (pas de débordement intermédiaire).

Les deux sont des couples de nombres, mais le sens diffère : un point est une position, un vecteur est un déplacement. Point + vecteur = point. Point − point = vecteur. On ne fait pas point + point. Cette distinction évite beaucoup d’erreurs ; en séance 16 on en fera deux classes différentes. Le vecteur unitaire (norme 1) donne « la direction sans la longueur » : très utile pour dire « avance de k cm vers là ».

Le radian est la « vraie » unité : un tour = 2π. Les fonctions cos, sin attendent des radians ; math.radians et math.degrees convertissent. Les 10⁻¹⁶ dans les résultats (cos 90° ≈ 6e-17 au lieu de 0) sont les erreurs de flottants de la séance 13 : comparez avec isclose.

y d’abord, x ensuite. C’est la convention de tous les langages (C, Java, JavaScript…). atan2 regarde les signes des deux pour choisir le bon quadrant et gère x = 0. La fonction normaliser_angle est indispensable : la différence entre 350° et 10° est 20°, pas 340°. Un robot qui l’oublie fait un tour presque complet pour rien.

Le point (x, y) est à distance r et angle α : x = r cos α, y = r sin α. Après rotation de θ, il est à l’angle α + θ. Les formules d’addition cos(α+θ) = cos α cos θ − sin α sin θ et sin(α+θ) = sin α cos θ + cos α sin θ donnent x' = x cos θ − y sin θ et y' = x sin θ + y cos θ. En prépa, vous écrirez cela sous forme de matrice 2×2 ; le calcul est identique. C’est aussi ce que fait * sur les nombres complexes : (x + iy)·e^(iθ).

u·v = |u|·|v|·cos(angle). Si les vecteurs pointent dans le même sens, cos = 1 et le produit est maximal ; perpendiculaires, il est nul ; opposés, négatif. C’est l’outil pour répondre à « est-ce devant moi ? », « quelle part de cette force agit dans cette direction ? ». Le produit scalaire est au cœur de la physique (travail d’une force), de l’infographie (éclairage) et des réseaux de neurones (similarité). Le max(-1, min(1, c)) évite qu’un 1.0000000002 dû aux flottants ne fasse planter acos.

Estimer sa position en cumulant ses déplacements s’appelle l’odométrie (du grec « mesure du chemin »). C’est ce que fait tout robot mobile avec ses encodeurs de roue. Problème : chaque petite erreur (une roue qui patine, un angle mal mesuré) s’accumule et n’est jamais corrigée. Après 10 mètres, le robot peut se croire à 30 cm de sa vraie position. D’où le besoin de recalage par d’autres capteurs (GPS, caméra, lidar) : la fusion de capteurs, un domaine de recherche entier.

Un robot à deux roues motrices (comme un fauteuil roulant ou la plupart des robots de compétition) n’a que deux commandes : la vitesse de chaque roue. Même vitesse : tout droit. Vitesses différentes : arc de cercle dont le rayon dépend de la différence. Sens opposés : rotation sur place. Les formules ci-dessus (modèle unicycle) seront celles de votre robot en partie E. Remarquez qu’on ne peut pas se déplacer latéralement : c’est une contrainte non holonome, la raison pour laquelle créneau est difficile.

À chaque pas : calculer l’angle voulu, l’erreur par rapport au cap, corriger (avec une limite de rotation), avancer. Cette boucle est un contrôleur proportionnel rudimentaire, l’ancêtre du PID de la séance 29. Essayez avec rot_max=5 : la trajectoire devient une courbe. Ajoutez un obstacle : que faire ? C’est la séance 28.

def point_cardinal(angle):
    noms = ["E", "NE", "N", "NO", "O", "SO", "S", "SE"]
    secteur = round(angle / 45) % 8
    return noms[secteur]

Pour le polygone : angle extérieur = 360/n. Un hexagone : tourner de 60° à chaque sommet. round(angle / 45) choisit le secteur le plus proche ; le % 8 gère les négatifs et les angles > 360.

def position_main(t1, t2):
    a1 = math.radians(t1)
    a2 = math.radians(t1 + t2)
    return (L1 * math.cos(a1) + L2 * math.cos(a2), L1 * math.sin(a1) + L2 * math.sin(a2))

def angles_pour(x, y):
    d2 = x * x + y * y
    c2 = (d2 - L1 * L1 - L2 * L2) / (2 * L1 * L2)
    if not -1 <= c2 <= 1:
        return None                                   # hors de portée
    t2 = math.acos(c2)                                # solution « coude vers le haut »
    t1 = math.atan2(y, x) - math.atan2(L2 * math.sin(t2), L1 + L2 * math.cos(t2))
    return math.degrees(t1), math.degrees(t2)

for _ in range(100):
    t1, t2 = random.uniform(-180, 180), random.uniform(0, 180)
    x, y = position_main(t1, t2)
    sol = angles_pour(x, y)
    x2, y2 = position_main(*sol)
    assert math.isclose(x, x2, abs_tol=1e-9) and math.isclose(y, y2, abs_tol=1e-9)
print("OK")

La cinématique inverse a en général deux solutions (coude en haut / en bas), parfois aucune (trop loin, ou trop près si L₁ ≠ L₂). Pour un bras à 6 axes, c’est un vrai problème de recherche. Le test vérifie la position et non les angles : le second choix de coude donne d’autres angles pour la même position.

def parcours(tours, sigma_d=0.02, sigma_a=1.0, biais_a=0.0):
    x = y = 0.0; cap = 0.0
    for _ in range(tours):
        for _ in range(4):
            for _ in range(10):
                d = 10 * (1 + random.gauss(0, sigma_d))
                x += d * math.cos(math.radians(cap)); y += d * math.sin(math.radians(cap))
            cap += 90 + random.gauss(biais_a, sigma_a)
    return math.hypot(x, y)          # la position idéale est (0, 0)

for tours in (1, 5, 20, 50):
    err = [parcours(tours) for _ in range(300)]
    print(f"{tours:2} tours : erreur moyenne {statistics.mean(err):6.1f} cm, écart-type {statistics.stdev(err):6.1f}")
print("biais +1° :", statistics.mean(parcours(20, biais_a=1.0) for _ in range(300)))

L’erreur croît environ comme √(nombre de pas) pour un bruit centré (marche aléatoire : les erreurs se compensent partiellement) mais linéairement avec un biais (elles s’additionnent). D’où l’importance de calibrer un robot (mesurer et corriger le biais) avant de se soucier du bruit. Ce résultat — √n pour le bruit, n pour le biais — est fondamental en métrologie et en physique statistique ; vous le démontrerez en prépa avec la variance d’une somme de variables indépendantes.