Robot Flou

La programmation d’un robot pour le déplacement et l’évitement d’obstacles par les méthodes traditionnelles peut devenir très complexe, si on veut traiter tous les cas de figure. Faire évoluer cette programmation si on change de robot ou si on rajoute des capteurs l’est encore plus.

Une technique de programmation relativement simple permet de pallier à ce genre d’inconvénients : La logique floue. Il en existe d’autres comme les réseaux de neurones ou les méthodes stochastiques, mais elles sont lourdes à mettre en œuvre et requièrent plus de connaissances que la logique floue.

La logique floue : un concept simple

L’idée de base des systèmes flous est celle des ensembles flous. Un ensemble flou est un ensemble pour lequel la fonction d’appartenance prend des valeurs dans tout l’intervalle [0,1] et pas seulement les valeurs 0 et 1. La fonction d’appartenance va définir le degré d’appartenance de l’élément considéré à l’ensemble dont on parle.

Exemple : la vitesse d’une voiture

On peut considérer une variable linguistique « vitesse » caractérisée selon trois classes : Faible, Normale, Elevée. Tout le monde s’accorde sur le fait que 180 km/h est une vitesse élevée et 20 km/h une vitesse faible. Mais comment qualifier 70 km/h ? Certains diront qu’il s’agit d’une vitesse normale et d’autres d’une vitesse élevée.

La théorie des sous-ensembles flous permet d’accorder les deux points de vue, en considérant 70 km/h comme étant à la fois Faible et Normale.

Dans cet exemple, 70 km/h est considéré comme une vitesse Faible avec un degré de 0,25 et comme Normale avec 0,75.

Principes

Les fonctions de transfert en forme de trapèzes qui définissent les degrés d’appartenance sont arbitraires et leurs formes doivent être définies en fonction du problème.

Un système de règles floues permet de décrire sous forme de règles linguistiques une fonction de transfert entre variables d’entrées et variables de sorties d’un système.

Dans le cas d’un système de commande, les entrées proviennent le plus souvent de capteurs et sont donc des valeurs numériques. De même manière, les sorties sont généralement des consignes pour actionneurs.

Le moteur d’inférence flou raisonne sur des règles linguistiques, c’est-à-dire des implications logiques de la forme :

SI condition1 ET/OU condition2 ALORS Action

Fuzzification

Pour raisonner avec les représentations numériques/linguistiques des variables d’entrée et de sortie, le système à base de règles floues opère selon trois étapes successives :

A partir des données numériques issues des capteurs sont calculés pour chaque entrée les degrés d’appartenance aux classes linguistiques utilisées.

• Evaluation des conditions : chaque condition est de la forme : SI variable = ValeurLinguistique. Le niveau de vérité d’une condition correspond au degré d’appartenance de la valeur numérique de la variable à la classe linguistique considérée.

• Agrégation des conditions : plusieurs méthodes sont possibles, une des plus utilisées étant celle proposée par Mandani : le ET logique est traduit par l’opérateur Min et le OU logique par l’opérateur Max

• Calcul de la conclusion : chaque conclusion est une affectation de la forme Variable = ValeurLinguistique.
  La méthode la plus utilisée est de considérer le degré de vérité calculé pour les prémisses comme le degré de validité de l’affectation.

Défuzzification

Il s’agit, pour chaque variable de sortie, de passer des degrés de validité calculés pour chaque conclusion à des grandeurs numériques.

La méthode la plus utilisée est celle du centre de gravité. On calcul le centre de gravité formé par l’union des degrés de validité.

Bon tout ça c’est très bien mais rien ne vaut un bon exemple ;o)

Le ROBOT FLOU

Pour expérimenter mes toutes nouvelles compétences, j’ai réalisé un robot simple sur la base de la carte PolyBot Board à base Atmel AVR ATMEGA32. La plate-forme est issue du robot eRobot qui était vendu en pièces détachées il y a quelque années.

Il est équipé de deux capteurs IR Sharp G2D120 et de deux contacteurs mécaniques ainsi que de deux moteurs réductés à courant continu.

La première chose à faire est de définir en fonction des caractéristiques du capteur la fonction linguistique associée aux valeurs numérique du capteur. Il faudra définir une fonction pour chaque capteur en entrée et pour chaque moteur en sortie.

Entrée 1 : les contacteurs

Pour les contacteurs la fonction est relativement simple :

Vous remarquerez que la fonction n’a pas une forme de trapèze puisqu’il n’y a que deux états : ouvert ou fermé.

Entrée 2 : les télémètres infrarouge

Plus compliqué les télémètres infrarouge (fds => capteur front droit) :

Le capteur Sharp envoi une valeur analogique comprise entre 170 et 0 d’après la doc technique. Le signal envoyé par le capteur est inversement proportionnel à la proximité d’un obstacle. Donc plus l’obstacle est loin plus la valeur du signal est petite.

Le premier trapèze correspond à la valeur linguistique FAR (« loin » in english dans le texte). Le trapèze est défini par les quatre paramètres suivant : (0,0,10,20) , qui sont ses coordonnées en X. Pour définir ces trapèzes plusieurs essais ont été nécessaires, ceci à cause du temps de réaction du robot par rapport à la distance de l’obstacle et à sa vitesse.

Sortie : les moteurs

Enfin pour les variables de sorties qui sont les moteurs (mD => moteur droit) :

Ici point de trapèze mais juste les différentes valeurs associées à la puissance et à la direction de rotation des moteurs. Plus on définit de valeurs moins il y aura d’à-coup dans le déplacement du robot.

Les règles

En fonction des entrées on calculera les sorties correspondantes à l’aide des règles suivantes :

1. IF fds is close AND fgs is close THEN md is arrTT and mg is arrTT
2. IF fds is close AND fgs is medium THEN md is avTT and mg is avm
3. IF fds is close AND fgs is far THEN md is avTT and mg is avm
4. IF fds is far AND fgs is close THEN md is avm and mg is avTT
5. IF fds is far AND fgs is far THEN md is avTT and mg is avTT
6. IF fds is medium AND fgs is far THEN md is avTT and mg is avTT
7. IF fds is medium AND fgs is close THEN md is avm and mg is avTT
8. IF fds is medium AND fgs is medium THEN md is av and mg is av
9. IF tod is oui THEN md is arr and mg is arrTT
10. IF tod is oui THEN md is arrTT and mg is arr

Ces règles permettent au robot d’éviter les obstacles. Ce sont les règles de base.

Il est parfaitement possible de rajouter des règles supplémentaire sans altérer le comportement du robot. Si le robot était doté de capteurs lui permettant de calculer sa position, l’ajout des règles suivantes lui permettrait de rejoindre un point de coordonnée préprogrammé :

Goal = racine((x-x1)²+(y-y1)²)

(x,y) position actuelle du robot
(x1,y1) destination du robot

• IF (x-x1)=0 THEN µgoal =90 ELSE
  IF ((x-x1)>0 THEN µgoal = arctan((y1-y)/(x1-x)
  ELSE µgoal = 180 + arctan((y1-y)/(x1-x)

Az-error = µ-µgoal (µ direction actuelle du robot)

Les règles seraient alors :

1. IF goal=neargoal THEN vitesse = stop
2. IF goal !=neargoal THEN vitesse = avTT
3. IF Az-error= zero THEN direction = Centre
4. IF Az-error= TresPositif THEN direction = DroiteTT
5. IF Az-error= Positif THEN direction = Droite
6. IF Az-error= TresNégatif THEN direction = GaucheTT
7. IF Az-error= Négatif THEN direction = Gauche

Les graphiques suivants détaillent les degrés d’appartenance des valeurs des capteurs infrarouge ainsi que des degrés d’appartenance des paramètres moteurs.

En entrée nous avons fds = 17 et fgs = 34 (fds,fgs : capteur IR frontaux)

Ce qui donne : medium(0.7) et far (0.3) pour fds ; close (0.4) et medium (0.6) pour fgs

En respectant la loi du Min/Max nous appliquons les règles 4,7,8. (Agrégation)
Règle 4 : min0.3,0.4=0.3 pour (avm,avtt)
Règle 7 : min0.7,0.4=0.4 pour (avm,avtt)
Règle 8 : min0.7,0.6=0.6 pour (av,av)

Nous pouvons maintenant calculer les degrés de validité pour mD et MG (Conclusion)

Pour mD : (moteur droit)
avm=max0.3,0.4=0.4
av=max0.6=0.6

Pour mG : (moteur gauche)
avTT=max0.3,0.4=0.4
av=max0.6=0.6

Retour aux valeurs réelles : (défuzzification)

mD = 0.4 x avm + 0.6 x av = 0.4 x 25 + 0.6 x 50 = 40
MG = 0.4 x avTT + 0.6 x av = 0.4 x 100 + 0.6 x 50 = 70 (dans le graphique ci-dessous nous avons 69, sans doute une erreur d’arrondi)

Fudge

Les graphiques de cette article ont été réalisé avec le logiciel FUDGE (Fuzzy Logic Development and Generation Environment), qui a ceci de très intéressant : il est gratuit et en plus il génère automatiquement le code C associé.

Avec quelques adaptations ce code peut être utilisé directement pour la programmation d’un ATMEGA32.

FUDGE est très simple d’utilisation mais en contre-partie, il n’offre pas beaucoup de possibilités (tel que le mixage de plusieurs ensembles flous, l’opérateur logique OU dans la définition des règles, l’utilisation de variables intermédiaires et la pondération des règles).

Malgré tout il permet de développer du code intelligent très rapidement avec une compacité excellente (important quand on sait la place mémoire disponible sur un ATmega32).

En exemple voici le code utilisé dans mon robot (test.c). Il faut utiliser l’include C générique fourni par Fudge.

En annexe le fichier ZIP du logiciel FUDGE.