Castel'Lab le Fablab MJC de Château-Renault

Outils pour utilisateurs

Outils du site

Piste : • vittascience
start:arduino:cours:vittascience

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentesRévision précédente
Prochaine révision		Révision précédente
start:arduino:cours:vittascience [2025/12/13 23:56] – adminstart:arduino:cours:vittascience [2025/12/14 14:30] (Version actuelle) – [Televerser dans le robot mBot1 à partir de l'interface Vittascience] admin
Ligne 99: Ligne 99:
 3- cliquer sur "Téléverser" ( connecter sur USB et allumer le mBot1 avant ...) 3- cliquer sur "Téléverser" ( connecter sur USB et allumer le mBot1 avant ...)
  
-4- choisir le port COM du mBot1 et faire connexion ( exemple: **"COM3"** sous Windows 11 ou **"USB Serial (ttyUSB0)"** sous Linux) +4- choisir le port COM du mBot1 et faire connexion ( exemple: **" USB Serial (COM3)"** sous Windows 11 ou **"USB Serial (ttyUSB0)"** sous Linux) 
  
 et c'est tout , dans la console série de vittascience tu dois voir : et c'est tout , dans la console série de vittascience tu dois voir :
Ligne 111: Ligne 111:
          
 ===== Exemples Vittascience Robot mBot1 ===== ===== Exemples Vittascience Robot mBot1 =====
 +
 +[[start:arduino:robots:mbot:vittascience]]
 +
 +{{ :start:arduino:cours:activitesvittascience.zip |}}
  
 == Image fond ecran pour virtualisation mBot1 sur Vittascience == == Image fond ecran pour virtualisation mBot1 sur Vittascience ==
Ligne 429: Ligne 433:
 </code> </code>
  
-=== Sortie d un Labyrinthe avec un mBot === +======= Sortie d un Labyrinthe avec un mBot ======
- +
-[[https://www.mazegenerator.net/| Generateur de labyrinthe ]] +
- +
-**Exemples ** +
- +
-{{ :start:arduino:cours:20_by_20_orthogonal_maze.svg |}} +
- +
-{{ :undefined:10_by_10_orthogonal_maze.svg |}} +
- +
- +
- +
-{{ :start:arduino:cours:l_algorithme_de_pledge_-_interstices_-_interstices.pdf |}} +
- +
-{{ :start:arduino:cours:grain_d_usage_labyrinthe_sams_0.pdf |}} +
- +
-{{ :start:arduino:cours:resolution_de_labyrinthe.pdf |}} +
- +
- +
-== idées d'algorythme pour sortir d un labytrinthe == +
- +
-<code txt algolaby001.txt> +
-Initialisation : +
-       *1 Démarrage du robot MBot. +
-       *2 Activation des capteurs de distance (Yeux). +
-       *3 Configuration des paramètres de vitesse et de détection. +
-   *Détection d'obstacle : +
-       *4 Si la distance est supérieure à 20 cm, le robot accélère. +
-       *5 Si la distance est entre 20 cm et 10 cm, le robot maintient une vitesse constante. +
-       *6 Si la distance est inférieure à 10 cm mais supérieure à 5 cm, le robot ralentit. +
-       *7 Si la distance est inférieure à 5 cm, le robot s'arrête. +
-   *Orientation pour trouver la sortie : +
-       *8 Si le robot est arrêté à cause d'un obstacle à 5 cm, il effectue une séquence d'orientations pour trouver la sortie. +
-       *9 Si après un virage à droite de 90°, il n'y a pas d'obstacle proche, le robot avance. +
-       *10 Sinon, s'il effectue un demi-tour (180°) et ne détecte pas d'obstacle proche, le robot avance. +
-       *11 Sinon, après un virage à gauche de 90°, le robot avance (car il aura effectué un demi-tour). +
-   *Répétition du processus : +
-       *12 Le robot continue à avancer tout en détectant les obstacles et ajustant sa vitesse en conséquence. +
-       *13 En cas d'obstacle à 5 cm, il effectue les étapes d'orientation pour trouver la sortie. +
-   *Fin : +
-       *14 Arrêt du robot lorsque la sortie du labyrinthe est détectée. +
-</code> +
- +
-[[https://interstices.info/lalgorithme-de-pledge/|lalgorithme-de-pledge]] +
- +
-{{ :start:arduino:cours:pledge1n.gif?direct&400 |}}{{ :start:arduino:cours:pledge3n.gif?direct&400 |}} +
- +
-<code txt algolaby00.txt> +
-il ne suffit pas de marcher en ligne droite. Il faut compter les changements de direction. +
- +
-Supposons que, comme dans les exemples précédents, tous les angles soient droits. On n’a alors que deux possibilités,  +
-tourner à droite ou à gauche selon un angle de 90°. On compte les changements de direction en augmentant d’un point  +
-lorsque l’on tourne à gauche et en diminuant d’un point lorsque l’on tourne à droite (y compris la première fois  +
-que l’on tourne à droite quand on atteint un mur). Au début, le décompte est à zéro. Les deux instructions sont  +
-alors les suivantes : +
- +
-    *1 Aller tout droit jusqu’au mur, passer à l’instruction 2 ; +
-    *2 Longer le mur par la droite (ou par la gauche, mais toujours dans le même sens) jusqu’à  +
-ce que le décompte des changements de direction atteigne zéro, passer à l’instruction 1 ; +
- +
-Il faut répéter ces actions jusqu’à ce que l’on revienne à la lumière du jour. +
- +
-</code> +
- +
- +
-===== Algorithmes de sortie d un labyrinthe ===== +
- +
- +
- +
-<markdown> +
- +
-Voici une **présentation claire des principaux algorithmes de résolution de labyrinthe pour un robot**, du plus simple au plus avancé. J’indique à chaque fois **le principe**, **les avantages** et **les limites**, avec un peu de pseudo-code quand c’est utile. +
- +
---- +
- +
-## 1. Algorithme de la **main droite** (ou main gauche) +
- +
-### Principe +
- +
-Le robot garde **toujours la main droite en contact avec un mur**. +
-Tant que le labyrinthe est **simplement connexe**, il finira par trouver la sortie. +
- +
-### Avantages +
- +
-* Très simple à implémenter +
-* Peu de mémoire +
-* Adapté aux robots simples (Arduino, capteurs IR) +
- +
-### Limites +
- +
-* Ne fonctionne pas si le labyrinthe a des îlots (murs isolés) +
-* Pas forcément le chemin le plus court +
- +
-### Pseudo-code +
- +
-```text +
-tant que sortie non trouvée : +
-    si mur à droite absent : +
-        tourner à droite +
-        avancer +
-    sinon si devant libre : +
-        avancer +
-    sinon : +
-        tourner à gauche +
-``` +
- +
---- +
- +
-## 2. Algorithme de **Trémaux** (marquage des chemins) +
- +
-### Principe +
- +
-Le robot **marque les passages déjà visités** : +
- +
-* 1 marque → déjà visité +
-* 2 marques → cul-de-sac +
- +
-Il évite de repasser inutilement au même endroit. +
- +
-### Avantages +
- +
-* Fonctionne dans tous les labyrinthes +
-* Garantit de trouver la sortie +
- +
-### Limites +
- +
-* Besoin de mémoire (ou marquage physique) +
-* Plus complexe que la main droite +
- +
---- +
- +
-## 3. **Parcours en profondeur (DFS – Depth First Search)** +
- +
-### Principe +
- +
-Le robot explore un chemin **jusqu’au bout**, puis revient en arrière quand il est bloqué. +
- +
-### Avantages +
- +
-* Simple conceptuellement +
-* Garantie de trouver la sortie +
- +
-### Limites +
- +
-* Peut être très long +
-* Pas le plus court chemin +
- +
-### Pseudo-code simplifié +
- +
-```text +
-fonction DFS(case): +
-    marquer case visitée +
-    si case = sortie : +
-        fin +
-    pour chaque voisin libre : +
-        si non visité : +
-            DFS(voisin) +
-``` +
- +
---- +
- +
-## 4. **Recherche en largeur (BFS – Breadth First Search)** +
- +
-### Principe +
- +
-Le robot explore **niveau par niveau** toutes les possibilités. +
- +
-### Avantages +
- +
-* Trouve **le plus court chemin** +
-* Très fiable +
- +
-### Limites +
- +
-* Utilise beaucoup de mémoire +
-* Moins adapté aux petits robots +
- +
---- +
- +
-## 5. **Algorithme A*** (A-star) +
- +
-### Principe +
- +
-Algorithme intelligent utilisant : +
- +
-* le coût déjà parcouru +
-* une estimation de la distance jusqu’à la sortie +
- +
-### Avantages +
- +
-* Très rapide +
-* Chemin optimal +
-* Utilisé en robotique avancée +
- +
-### Limites +
- +
-* Nécessite une carte du labyrinthe +
-* Plus complexe à programmer +
- +
---- +
- +
-## 6. Comparatif rapide +
- +
-| Algorithme  | Mémoire     | Chemin optimal | Complexité  | +
-| ----------- | ----------- | -------------- | ----------- | +
-| Main droite | Très faible | ❌              | Très simple | +
-| Trémaux     | Faible      | ❌              | Simple      | +
-| DFS         | Moyenne     | ❌              | Moyenne     | +
-| BFS         | Élevée      | ✅              | Moyenne     | +
-| A*          | Élevée      | ✅              | Complexe    | +
- +
---- +
- +
-## Recommandation selon ton robot +
- +
-* 🤖 **Robot simple (capteurs, pas de carte)** → Main droite ou Trémaux +
-* 🤖 **Robot avec mémoire et carte** → BFS ou A* +
-* 🤖 **Projet scolaire** → DFS ou Trémaux +
- +
---- +
- +
-Voici **l’ajout de la gestion des angles et des virages précis** pour un robot de labyrinthe avec **capteurs IR / ultrasons**, adapté à un **robot à deux roues motrices (différentiel)**. +
- +
---- +
- +
-## ⚙️ Principe de base +
- +
-Pour tourner **proprement à 90°**, le robot ne se contente pas d’un délai (`delay`) : +
-il utilise soit : +
- +
-* ⏱️ **le temps** (solution simple) +
-* 🔄 **les encodeurs de roues** (précis) +
-* 🧭 **un gyroscope (IMU)** (très précis) +
- +
-Je te montre les **3 niveaux**, du plus simple au plus avancé. +
- +
---- +
- +
-## 🧩 Schéma de rotation du robot +
- +
-### Virage à 90° à droite +
- +
-``` +
-Vue de dessus +
- +
-     AVANT +
-       ↑ +
-       │ +
-   ┌───┴───┐ +
-   │ ROBOT │   → rotation +
-   └───┬───┘ +
-       │ +
-       ↓ +
- +
-Roue gauche : AVANCE +
-Roue droite : RECULE (ou arrêt) +
-``` +
- +
---- +
- +
-## 🟢 NIVEAU 1 – Rotation par le TEMPS (simple) +
- +
-### Schéma logique +
- +
-``` +
-Tourner à droite : +
-- Moteur gauche : ON +
-- Moteur droit : OFF +
-- Temps ≈ 400 ms → 90° +
-``` +
- +
-### Pseudo-code +
- +
-```c +
-void tournerDroite90() { +
-    moteurGauche(AVANCE); +
-    moteurDroit(ARRET); +
-    delay(400);   // à calibrer +
-    arret(); +
-} +
-``` +
- +
-### ✅ Avantages +
- +
-* Très simple +
-* Suffisant pour projets scolaires +
- +
-### ❌ Limites +
- +
-* Dépend de la batterie et du sol +
- +
---- +
- +
-## 🟡 NIVEAU 2 – Rotation avec ENCODEURS (précis) +
- +
-### Principe +
- +
-Chaque roue a un encodeur → nombre de ticks = angle. +
- +
-### Schéma +
- +
-``` +
-Angle = (ticks mesurés / ticks par tour) × 360° +
-``` +
- +
-### Pseudo-code +
- +
-```c +
-void tournerDroite90() { +
-    resetEncodeurs(); +
-    moteurGauche(AVANCE); +
-    moteurDroit(RECULE); +
- +
-    while (encodeurGauche < TICKS_90) { +
-        // attendre +
-    } +
-    arret(); +
-} +
-``` +
- +
-### ✅ Avantages +
- +
-* Bonne précision +
-* Indépendant du sol +
- +
---- +
- +
-## 🔵 NIVEAU 3 – Rotation avec GYROSCOPE (IMU) +
- +
-### Principe +
- +
-Le robot mesure directement l’angle de rotation (yaw). +
- +
-### Schéma +
- +
-``` +
-Angle cible = angle actuel ± 90° +
-``` +
- +
-### Pseudo-code +
- +
-```c +
-void tournerDroite90() { +
-    float angleInitial = lireYaw(); +
- +
-    moteurGauche(AVANCE); +
-    moteurDroit(RECULE); +
- +
-    while (lireYaw() < angleInitial + 90) { +
-        // rotation +
-    } +
-    arret(); +
-} +
-``` +
- +
-### ✅ Avantages +
- +
-* Très grande précision +
-* Utilisé en robotique avancée +
- +
---- +
- +
-## 🧭 Correction de trajectoire (ligne droite) +
- +
-### Schéma +
- +
-``` +
-Mur à droite trop proche → corriger à gauche +
-Mur à droite trop loin  → corriger à droite +
-``` +
- +
-### Pseudo-code +
- +
-```c +
-erreur = distanceD - distanceConsigne; +
- +
-vG = vBase - Kp * erreur; +
-vD = vBase + Kp * erreur; +
-``` +
- +
-👉 C’est un **contrôle proportionnel (P)**. +
- +
---- +
- +
-## 🔄 Schéma global mis à jour +
- +
-``` +
-Lire capteurs +
-     ↓ +
-Décision (droite / avant / gauche) +
-     ↓ +
-Si virage : +
-   → rotation 90° précise +
-Sinon : +
-   → avance + correction mur +
-     ↓ +
-Répéter +
-``` +
- +
---- +
- +
-## 🧪 Conseils pratiques +
- +
-* Calibrer les **90°** une seule fois +
-* Utiliser **encodeurs OU gyroscope** si possible +
-* Toujours arrêter les moteurs après rotation +
-* Ajouter un petit délai de stabilisation (50 ms) +
- +
---- +
- +
-## 🎯 Résumé+
  
-| Méthode   | Précision | Complexité | +[[vittascience:labyrinthe|Sortie d un Labyrinthe avec un mBot]]
-| --------- | --------- | ---------- | +
-| Temps     | ⭐⭐        | ⭐          | +
-| Encodeurs | ⭐⭐⭐⭐      | ⭐⭐⭐        | +
-| Gyroscope | ⭐⭐⭐⭐⭐     | ⭐⭐⭐⭐       |+
  
---- 
  
-</markdown> 
  
-  
/home/chanteri/www/fablab37110/data/attic/start/arduino/cours/vittascience.1765666564.txt.gz · Dernière modification : de admin