Principe de trilatération
Comment votre GPS calcule-t-il votre position exacte avec seulement des distances aux satellites ? Grâce à la trilatération, un principe mathématique fascinant !
Objectifs du cours
- Comprendre le principe de la trilatération
- Savoir pourquoi 3 satellites minimum sont nécessaires (en 2D)
- Comprendre pourquoi le GPS nécessite 4 satellites (en 3D + temps)
- Découvrir comment l'intersection des sphères donne la position
- Identifier les sources d'erreur dans le calcul GPS
Erreurs courantes à éviter
- Confondre trilatération et triangulation (angles vs distances)
- Penser que 2 satellites suffisent
- Oublier que le récepteur GPS n'a pas d'horloge atomique
- Ne pas comprendre pourquoi on a besoin du 4ème satellite
**Trilatération vs Triangulation**
⚠️ **Ne pas confondre** :
**Trilatération** (GPS) : • Utilise des **distances** • Mesure : longueur du signal satellite → récepteur • 3 distances → 1 position (en 2D) • 4 distances → 1 position (en 3D avec erreur d'horloge)
**Triangulation** (géodésie classique) : • Utilise des **angles** • Mesure : angles entre points de référence • Technique utilisée en topographie
📐 **La trilatération en 2D (version simple)**
Imaginez que vous êtes perdu, mais vous savez : • Vous êtes à **10 km** de la Tour Eiffel • Vous êtes à **15 km** de Notre-Dame • Vous êtes à **12 km** de la Défense
**Question** : Où êtes-vous exactement ?
🎯 **Avec 1 satellite (1 distance)** :
Si vous savez que vous êtes à **10 km** de la Tour Eiffel : • Vous êtes quelque part sur un **cercle** de rayon 10 km autour de la Tour Eiffel • Infinité de positions possibles • **Pas assez d'informations**
Cercle 1 : tous les points à 10 km de A
🎯 **Avec 2 satellites (2 distances)** :
Vous êtes aussi à **15 km** de Notre-Dame : • Vous êtes sur le cercle 1 (10 km de Tour Eiffel) • ET sur le cercle 2 (15 km de Notre-Dame) • **Intersection** = 2 points possibles • **Encore ambigu !**
🎯 **Avec 3 satellites (3 distances)** :
Vous êtes aussi à **12 km** de la Défense : • Intersection des 3 cercles • **1 seul point** satisfait les 3 distances • **Position déterminée !** ✅
**Principe mathématique** :
En 2D : • 1 distance → cercle • 2 distances → 2 points (intersection de 2 cercles) • 3 distances → 1 point (intersection de 3 cercles)
En 3D : • 1 distance → sphère • 2 distances → cercle (intersection de 2 sphères) • 3 distances → 2 points (intersection de 3 sphères) • 4 distances → 1 point (mais il y a une autre raison...)
📊 **Formule mathématique (2D)**
Si vous connaissez : • Position satellite 1 : (x₁, y₁), distance d₁ • Position satellite 2 : (x₂, y₂), distance d₂ • Position satellite 3 : (x₃, y₃), distance d₃
Votre position (x, y) satisfait : • (x - x₁)² + (y - y₁)² = d₁² • (x - x₂)² + (y - y₂)² = d₂² • (x - x₃)² + (y - y₃)² = d₃²
**3 équations, 2 inconnues** → Système résolvable !
🌍 **En 3D : sphères au lieu de cercles**
Pour le GPS (3 dimensions) : • Chaque satellite définit une **sphère** (pas un cercle) • Votre position est à la distance d du satellite • Tous les points à distance d forment une sphère autour du satellite
**Avec 3 satellites** : • 3 sphères qui s'intersectent • Généralement : **2 points** possibles • Solution : 1 point dans l'espace, 1 point aberrant (dans l'espace ou sous terre) • On peut éliminer le point aberrant
**Mais le GPS utilise 4 satellites, pourquoi ?**
🕐 **Le problème de l'horloge**
**Rappel critique** : • Les satellites ont des horloges atomiques (±1 nanoseconde) • Votre smartphone a une horloge quartz ordinaire (±1 milliseconde) • **1 milliseconde d'erreur = 300 km d'erreur de position !**
**Le 4ème satellite corrige l'erreur d'horloge** :
**4 inconnues** : 1. x (latitude) 2. y (longitude) 3. z (altitude) 4. Δt (erreur de l'horloge du récepteur)
**4 équations** (4 satellites) : • Satellite 1 : distance d₁ • Satellite 2 : distance d₂ • Satellite 3 : distance d₃ • Satellite 4 : distance d₄
**Système d'équations** : • (x - x₁)² + (y - y₁)² + (z - z₁)² = (d₁ + c·Δt)² • (x - x₂)² + (y - y₂)² + (z - z₂)² = (d₂ + c·Δt)² • (x - x₃)² + (y - y₃)² + (z - z₃)² = (d₃ + c·Δt)² • (x - x₄)² + (y - y₄)² + (z - z₄)² = (d₄ + c·Δt)²
Avec c = vitesse de la lumière
**4 équations, 4 inconnues** → Résolvable !
Le récepteur GPS calcule **simultanément** : ✅ Votre position (x, y, z) ✅ L'erreur de son horloge (Δt)
🎯 **Résumé : Pourquoi 4 satellites ?**
**Raison 1** : Position 3D • 3 coordonnées spatiales (latitude, longitude, altitude)
**Raison 2** : Correction horloge • 1 inconnue temporelle (erreur d'horloge)
**Total : 4 inconnues → 4 satellites minimum**
**Avec plus de 4 satellites** (généralement 6-12 visibles) : • Meilleure précision • Redondance (détection d'erreurs) • Calcul de moyennes • Détection de satellites défaillants
# Simulation de trilatération GPS
import math
class Point3D:
def __init__(self, x, y, z):
self.x = x
self.y = y
self.z = z
def distance_vers(self, autre):
"""Calcule la distance euclidienne vers un autre point."""
return math.sqrt(
(self.x - autre.x)**2 +
(self.y - autre.y)**2 +
(self.z - autre.z)**2
)
def __str__(self):
return f"({self.x:.1f}, {self.y:.1f}, {self.z:.1f})"
# Démonstration en 2D (simplifié)
print("=== TRILATÉRATION EN 2D (VERSION SIMPLIFIÉE) ===\n")
# Position des "satellites" (points de référence)
ref1 = Point3D(0, 0, 0) # Tour Eiffel
ref2 = Point3D(20, 0, 0) # Notre-Dame
ref3 = Point3D(10, 15, 0) # La Défense
# Position réelle (inconnue) de l'utilisateur
position_reelle = Point3D(8, 7, 0)
print("Points de référence:")
print(f" Tour Eiffel: {ref1}")
print(f" Notre-Dame: {ref2}")
print(f" La Défense: {ref3}")
print()
# Calculer les distances
d1 = position_reelle.distance_vers(ref1)
d2 = position_reelle.distance_vers(ref2)
d3 = position_reelle.distance_vers(ref3)
print("Mesures de distances:")
print(f" Distance à Tour Eiffel: {d1:.2f} km")
print(f" Distance à Notre-Dame: {d2:.2f} km")
print(f" Distance à La Défense: {d3:.2f} km")
print()
print("Interprétation:")
print(f" • Avec 1 distance ({d1:.1f}km) → cercle de rayon {d1:.1f}km")
print(f" → Infinité de positions possibles")
print()
print(f" • Avec 2 distances ({d1:.1f}km et {d2:.1f}km)")
print(f" → Intersection de 2 cercles → 2 points possibles")
print()
print(f" • Avec 3 distances ({d1:.1f}km, {d2:.1f}km et {d3:.1f}km)")
print(f" → Intersection de 3 cercles → 1 point unique ✅")
print()
print(f"Position déterminée: {position_reelle}")
# Simulation GPS 3D
print("\n\n=== TRILATÉRATION GPS EN 3D ===\n")
# Position des satellites GPS (simplifiée, en km)
sat1 = Point3D(5000, 10000, 20000)
sat2 = Point3D(-8000, 12000, 20200)
sat3 = Point3D(3000, -9000, 20100)
sat4 = Point3D(-5000, -8000, 20300)
# Position de l'utilisateur (au sol, altitude ~0)
utilisateur = Point3D(0, 0, 0.006371) # 6371 km = rayon Terre
print("Configuration:")
print(f" Satellites GPS en orbite à ~20 000 km d'altitude")
print(f" Utilisateur au sol (altitude ≈ 0)")
print()
# Calculer les distances réelles
distances_reelles = [
utilisateur.distance_vers(sat1),
utilisateur.distance_vers(sat2),
utilisateur.distance_vers(sat3),
utilisateur.distance_vers(sat4)
]
print("Distances réelles aux satellites:")
for i, d in enumerate(distances_reelles, 1):
print(f" Satellite {i}: {d:,.1f} km")
# Simuler une erreur d'horloge
erreur_horloge = 0.001 # 1 milliseconde
vitesse_lumiere = 300000 # km/s
erreur_distance = erreur_horloge * vitesse_lumiere
print(f"\nErreur d'horloge du récepteur: {erreur_horloge*1000:.0f} ms")
print(f"Erreur de distance induite: {erreur_distance:.0f} km")
# Distances mesurées (avec erreur)
distances_mesurees = [d + erreur_distance for d in distances_reelles]
print(f"\nDistances mesurées (avec erreur):")
for i, d in enumerate(distances_mesurees, 1):
print(f" Satellite {i}: {d:,.1f} km (erreur: +{erreur_distance:.0f} km)")
print(f"\n📍 Le GPS résout le système:")
print(f" • 4 équations (4 satellites)")
print(f" • 4 inconnues (x, y, z, erreur_horloge)")
print(f" • Calcule simultanément: position + correction d'horloge")
# Nombre de satellites et précision
print("\n\n=== NOMBRE DE SATELLITES ET PRÉCISION ===\n")
scenarios = [
(3, "Impossible", "3 inconnues (x,y,z) mais erreur d'horloge non corrigée"),
(4, "Possible", "Position calculée avec correction d'horloge"),
(5, "Bon", "Redondance → meilleure précision"),
(6, "Très bon", "Détection d'erreurs + précision améliorée"),
(8, "Excellent", "Précision optimale"),
(12, "Maximum", "Tous les satellites visibles utilisés")
]
print(f"{'Satellites':<12} {'Calcul GPS':<15} {'Remarque':<50}")
print("-" * 80)
for nb_sat, qualite, remarque in scenarios:
print(f"{nb_sat:<12} {qualite:<15} {remarque:<50}")
# Visualisation des sphères
print("\n\n=== INTERSECTION DES SPHÈRES ===\n")
print("Principe de la trilatération 3D:\n")
print(" Satellite 1: Vous êtes sur une SPHÈRE de rayon d₁")
print(" Satellite 2: Vous êtes sur une SPHÈRE de rayon d₂")
print(" → Intersection de 2 sphères = CERCLE")
print()
print(" Satellite 3: Vous êtes sur une SPHÈRE de rayon d₃")
print(" → Intersection cercle + sphère = 2 POINTS")
print(" → Un point dans l'espace, un aberrant (éliminé)")
print()
print(" Satellite 4: Correction de l'erreur d'horloge")
print(" → POSITION UNIQUE déterminée ✅")
# Calcul de l'erreur selon le nombre de satellites
print("\n\n=== PRÉCISION SELON LE NOMBRE DE SATELLITES ===\n")
import random
def simuler_precision(nb_satellites):
"""Simule la précision GPS selon le nombre de satellites."""
if nb_satellites < 4:
return float('inf') # Impossible
# Précision de base: ~5m avec 4 satellites
# Amélioration avec plus de satellites
precision_base = 5.0
facteur_amelioration = 1 / math.sqrt(nb_satellites - 3)
return precision_base * facteur_amelioration
nb_sats = [4, 5, 6, 7, 8, 10, 12]
print(f"{'Satellites visibles':<20} {'Précision estimée':<20}")
print("-" * 40)
for nb in nb_sats:
precision = simuler_precision(nb)
print(f"{nb:<20} ±{precision:.2f} m")
print("\n→ Plus de satellites = meilleure précision (redondance)")
# DOP (Dilution of Precision)
print("\n\n=== GÉOMÉTRIE DES SATELLITES (DOP) ===\n")
print("La précision dépend aussi de la GÉOMÉTRIE des satellites:\n")
geometries = [
("Satellites bien espacés", "GDOP = 2", "Excellente", "±3m"),
("Géométrie moyenne", "GDOP = 4", "Bonne", "±6m"),
("Satellites groupés", "GDOP = 8", "Médiocre", "±12m"),
("Très mauvaise géométrie", "GDOP > 10", "Mauvaise", "±20m+")
]
print(f"{'Configuration':<30} {'GDOP':<12} {'Qualité':<15} {'Précision':<15}")
print("-" * 75)
for config, gdop, qualite, precision in geometries:
print(f"{config:<30} {gdop:<12} {qualite:<15} {precision:<15}")
print("\n💡 GDOP = Geometric Dilution of Precision")
print(" Mesure de la qualité de la géométrie des satellites")
print(" Plus c'est bas, mieux c'est !")
print(" Idéal: satellites répartis uniformément dans le ciel")Quiz de validation
1. Quelle est la principale différence entre trilatération et triangulation ?
2. Pourquoi le GPS nécessite-t-il 4 satellites minimum (et pas 3) ?
3. Combien d'inconnues le récepteur GPS doit-il résoudre ?
4. Qu'est-ce que le GDOP ?
5. Quelle est la précision d'un GPS standard (smartphone) ?
