Système d'Évitement d'Obstacles par Intelligence Artificielle (Q-Learning) sur Arduino
Composants et Fournitures
| Composant | Quantité | Notes |
|---|---|---|
| Arduino Pro Mini 328 - 5V/16 MHz (SparkFun) | 1 | |
| Capteur Ultrason HC-SR04 | 1 | |
| Double Driver Moteur L298N (SparkFun) | 1 | |
| Moteur DC 60 tr/min | 2 | |
| Roues | 4 | |
| Fils de liaison | 1 | Lot |
| Plaque à souder mini (SparkFun) | 1 | |
| Batterie Li-Ion 7,2 V | 1 | Alimentation moteurs |
| Batterie 9 V + connecteur | 1 | Alimentation logique |
| PCB Personnalisé (PCBWay) | 1 | |
| Interrupteur C&K Série JS | 1 |
Outils Nécessaires
- Fer à souder, fil à souder sans plomb, flux, pompe à dessouder
- Pince à dénuder/couper, pistolet à colle chaude, ruban double face
Applications
- Arduino IDE
À Propos du Projet
Robot Évitement d'Obstacles par Apprentissage par Renforcement (Q-Learning)
Objectif : Apprendre au robot à éviter les obstacles en « N » épisodes et converger vers l'action optimale (ici : tourner à droite).
Algorithme : Q-Learning (apprentissage par renforcement sans modèle, hors-ligne).
Principe du Pilotage Moteurs par L298N
Le L298N est un double pont en H permettant de contrôler indépendamment la vitesse (PWM) et le sens de deux moteurs DC.
Mesure de Distance par HC-SR04
Le capteur émet une impulsion ultrasonore (40 kHz) et mesure le temps de retour de l'écho. Distance = (durée × 0,0343) / 2.
Concepts Clés du Renforcement (RL)
| Terme | Définition dans ce Projet |
|---|---|
| État (State) | Situation du robot. 10 états discrétisés (bien que physiquement 2 : « obstacle loin » / « obstacle près »). |
| Action | 4 actions possibles : 0=AVANT, 1=ARRIÈRE, 2=STOP, 3=GAUCHE. (Droite non implémentée dans le code fourni). |
| État Suivant (Next State) | Résultat de l'action : « SURVÉCU » (retour état initial) ou « CRASHÉ ». |
| Table Q (Q-Table) | Matrice 10×4 initialisée à 0. Stime la valeur « qualité » de chaque (état, action). |
| État Terminal | Inexistant ici : apprentissage continu sans fin d'épisode définie. |
| Matrice de Récompense | Récompenses par (état, action) : AVANT=-10, ARRIÈRE=-2, STOP=-1, GAUCHE=+10 (identique pour les 10 états). |
| Environnement | Monde physique du robot (piste, obstacles). |
Hyperparamètres
- Taux d'apprentissage (α) = 0,1 : pondération nouvelle info vs ancienne.
- Facteur d'actualisation (γ) = 0,5 : importance des récompenses futures.
- Taux d'exploration (ε) = 0,90 : probabilité d'action aléatoire. Décroît ×0,98 par épisode, réinitialisé à 0,9 si < 0,5 (exploration perpétuelle).
Algorithme Q-Learning (Politique ε-Greedy)
- Initialiser Q(s,a) = 0.
- Observer état courant s.
- Choisir action a : avec prob. ε → aléatoire (exploration) ; sinon → argmax Q(s,·) (exploitation).
- Exécuter a, observer récompense r et nouvel état s'.
- Mettre à jour : Q(s,a) ← (1-α)Q(s,a) + α[r + γ·maxa' Q(s',a')].
- s ← s' et recommencer.
// Mise à jour Q (équation de Bellman)
Q_OLD = Q_TABLE[S][A];
Q_MAX = MAX(Q_TABLE, NEXT_S);
Q_NEW = (1 - ALPHA) * Q_OLD + ALPHA * (R + GAMMA * Q_MAX);
Q_TABLE[S][A] = Q_NEW;
Phases du Programme
- Entraînement (100 épisodes) : le robot explore/exploite, met à jour sa Q-table, ε décroît.
- Évaluation : affichage sériel des valeurs Q finales pour vérification.
- Test (infini) : politique purement gloutonne (argmax Q) : le robot évite les obstacles sans exploration.
Code Complet (C/C++ pour Arduino)
Afficher le code source (cliquer pour déplier)
/* Obstacle Avoiding Robot using Q-LEARNING
Auteur : Varun Walimbe
Algorithme : Q-Learning
*/
////////// PARAMÈTRES MATÉRIEL //////////////////
int TRIG_PIN = 7;
int ECHO_PIN = 8;
int duration;
float distance;
int M1 = 13, M2 = 12, M3 = 11, M4 = 10; // L298N IN1..IN4
bool Obstacle = false;
int FLAG;
////////// PARAMÈTRES Q-LEARNING ////////////////
float ALPHA = 0.1; // Learning rate
float GAMMA = 0.5; // Discount factor
float EPSILON = 0.90; // Exploration rate
int REWARD;
int EPISODES = 100;
int STATE = 0;
int ACTION = 0; // 0:AVANT, 1:ARRIÈRE, 2:STOP, 3:GAUCHE
float PROB;
bool ACTION_TAKEN = false;
int NEXT_STATE;
const int STATES = 10;
const int NUMBER_OF_ACTIONS = 4;
// Q-Table 10x4
float Q[STATES][NUMBER_OF_ACTIONS] = {
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0}
};
// Matrice de récompense (identique pour les 10 états)
int REWARDS[STATES][NUMBER_OF_ACTIONS] = {
{-10,-2,-1,10},{-10,-2,-1,10},{-10,-2,-1,10},{-10,-2,-1,10},{-10,-2,-1,10},
{-10,-2,-1,10},{-10,-2,-1,10},{-10,-2,-1,10},{-10,-2,-1,10},{-10,-2,-1,10}
};
float Q_OLD, Q_NEW, Q_MAX;
//////////////// FONCTIONS ROBOT ////////////////
void Forward() { digitalWrite(M1,LOW); digitalWrite(M2,HIGH); digitalWrite(M3,LOW); digitalWrite(M4,HIGH); }
void Backward() { digitalWrite(M1,HIGH); digitalWrite(M2,LOW); digitalWrite(M3,HIGH); digitalWrite(M4,LOW); }
void Left() { digitalWrite(M1,HIGH); digitalWrite(M2,LOW); digitalWrite(M3,LOW); digitalWrite(M4,HIGH); }
void Right() { digitalWrite(M1,LOW); digitalWrite(M2,HIGH); digitalWrite(M3,HIGH); digitalWrite(M4,LOW); }
void Stop() { digitalWrite(M1,LOW); digitalWrite(M2,LOW); digitalWrite(M3,LOW); digitalWrite(M4,LOW); }
bool Obstacle_Avoider() {
digitalWrite(TRIG_PIN, HIGH);
delayMicroseconds(10);
digitalWrite(TRIG_PIN, LOW);
duration = pulseIn(ECHO_PIN, HIGH);
distance = (duration / 2) / 29.1; // cm
Obstacle = (distance < 15);
delay(10);
return Obstacle;
}
/////////// FONCTIONS Q-LEARNING ///////////////
float RANDOM(float eps) { return random(0,100) / 100.0; }
float DECAY(float param) { return param * 0.98; }
int GET_STATE() { return random(0,10); } // État simulé (10 états)
float MAX(float Q_Table[][4], int next_s) {
float maxv = Q_Table[next_s][0];
for (int i=1;i<4;i++) if (Q_Table[next_s][i] > maxv) maxv = Q_Table[next_s][i];
return maxv;
}
int ARGMAX(float Q_Table[][4], int s) {
float maxv = Q_Table[s][0]; int idx = 0;
for (int i=1;i<4;i++) if (Q_Table[s][i] > maxv) { maxv = Q_Table[s][i]; idx = i; }
return idx;
}
void Update(float Q_TABLE[][4], int s, int next_s, int a, int R, float lr, float df) {
Q_OLD = Q_TABLE[s][a];
Q_MAX = MAX(Q_TABLE, next_s);
Q_NEW = (1-lr)*Q_OLD + lr*(R + df*Q_MAX);
Serial.print("Q VALUE: "); Serial.println(Q_NEW);
Q_TABLE[s][a] = Q_NEW;
}
//////////////// BOUCLE PRINCIPALE //////////////
void setup() {
Serial.begin(9600);
pinMode(TRIG_PIN,OUTPUT); pinMode(ECHO_PIN,INPUT);
pinMode(M1,OUTPUT); pinMode(M2,OUTPUT); pinMode(M3,OUTPUT); pinMode(M4,OUTPUT);
randomSeed(analogRead(A0));
Serial.println("ENTRAINEMENT DANS 5 SEC...");
delay(5000);
}
void loop() {
///// ENTRAÎNEMENT /////
for (int ep=0; epSchéma Électrique
Fichier Fritzing : obstacle_avoiding_robot_using_ai_DcoMCWIOFm.fzz
Remarques & Améliorations Possibles
- L'action « DROITE » (récompense +10) est définie dans la matrice mais non codée dans
Right()ni dans l'exécution — à implémenter pour correspondre à l'énoncé. - La discrétisation en 10 états identiques est pédagogique ; un vrai projet utiliserait la distance continue ou des secteurs angulaires.
- L'absence d'état terminal et la réinitialisation d'ε font de cet apprentissage un processus continu (apprentissage tout au long de la vie).
- Pour un déploiement réel : ajouter des capteurs latéraux, gérer l'évitement arrière, et sauvegarder la Q-table en EEPROM.
Contrôler la Luminosité de LEDs par PWM avec un Bouton Poussoir sur Arduino Mega
Construire une Centrale DCC Numérique pour Modélisme Ferroviaire avec Arduino – Application Android Gratuite Incluse
Processus de fabrication
- Arrow Electronics lance l'AI Experience Tour avec Intel, Microsoft, Nvidia
- Robot mobile évitant les obstacles par vision sur Raspberry Pi
- Bosch dévoile une solution de fabrication pilotée par l'IA au salon Hannover Messe
- Intelligence artificielle dans le retail : Bénéfices prouvés, pas un effet de mode
- Kubernetes propulse les startups IA avec des solutions conteneurisées scalables
- Comment l'IA transforme le paysage de l'Internet des objets
- L'intelligence artificielle n'est pas encore prête pour la cybersécurité des systèmes de contrôle industriels
- L'IA prédit l'avantage quantique : un réseau neuronal prédit le comportement du système
- Suivi de la déforestation amazonienne par l'IA