Labyrinthe du solveur Robot, à l’aide de l’Intelligence artificielle avec Arduino (3 / 10 étapes)

Étape 3: Installation et test des nouveaux capteurs

Le nouveau tableau de maintenant 7 capteurs, est monté sur un chemin que 5 ceux d’origine est utilisés exclusivement pour le contrôle PID (et détection de la « gamme complète », a expliqué plus tard) et la nouvelle gauche 2 à utiliser pour la détection d’intersection gauche et à droite uniquement.

Un examen rapide, il faut se rappeler comment fonctionnent les 5 capteurs « numériques » originales :

Si un capteur est centré par rapport à la ligne noire, seulement ce capteur spécifique produira un maximum. De l’autre côté, l’espace entre les capteurs doit être calculé pour permettre que 2 capteurs peuvent couvrir toute la largeur de la ligne noire en même temps, produit également un signal élevé sur les deux capteurs.

Comment fonctionnent les 2 nouveaux capteurs « analogiques » :

Si un des capteurs est centré par rapport à la ligne noire, la sortie sera une valeur analogique, qui produit normalement une sortie au soufflet Arduino ADC "100" (n’oubliez pas que l’ADC délivre une puissance de 0 à 1023). Avec des surfaces plus légers, la valeur de sortie sera plus élevée (j’ai testé 500 à 600 sur papier blanc, par exemple). Cette valeur doit être testée sur des situations différentes de matériaux légers et surfaces pour définir la constante de seuil exacte à utiliser dans votre cas (voir la photo ici).

En regardant le code Arduino, chacun des capteurs est définis avec un nom spécifique (considère que le capteur de suivre ligne original, plus à gauche doit être affecté d’une étiquette de « 0 ») :

const int lineFollowSensor0 = 12 ; À l’aide d’entrée numérique

const int lineFollowSensor1 = 18 ; À l’aide de Analog Pin A4 comme entrée numérique

const int lineFollowSensor2 = 17 ; À l’aide de A3 broche analogique comme entrée numérique

const int lineFollowSensor3 = 16 ; À l’aide de Analog broche A2 comme entrée numérique

const int lineFollowSensor4 = 19 ; À l’aide de Analog Pin A5 comme entrée numérique

const int farRightSensorPin = 0 ; Broche analogique A0

const int farLeftSensorPin = 1 ; Les broches analogiques A1

Pour mémoriser, possible 5 capteur tableau d’origine lorsqu’il suit une ligne de sortie sont :

• 1 1 1 1 1
• 0 0 0 0 0
• 0 0 0 0 1
• 0 0 0 1 1
• 0 0 0 1 0
• 0 0 1 1 0
• 0 0 1 0 0
• 0 1 1 0 0
• 0 1 0 0 0
• 1 1 0 0 0
• 1 0 0 0 0

Avec l’ajout de 2 nouveaux, leurs sorties possibles sont :

• Capteur de l’extrême gauche : Sortie analogique supérieur ou inférieur à un seuil
• Capteur de l’extrême droite : Sortie analogique supérieur ou inférieur à un seuil

Afin de stockage des valeurs de chaque capteur une variable de tableau est créée pour les capteurs numériques 5 originales :

int LFSensor [5] = {0, 0, 0, 0, 0} ;

Et deux variables entières pour les 2 nouveaux capteurs analogiques :

int farRightSensor = 0 ;
int farLeftSensor = 0 ;

Chaque position du tableau et variables sera constamment mis à jour avec la sortie de chacun des capteurs :

LFSensor [0] = digitalRead(lineFollowSensor0) ;

LFSensor [1] = digitalRead(lineFollowSensor1) ;

LFSensor [2] = digitalRead(lineFollowSensor2) ;

LFSensor [3] = digitalRead(lineFollowSensor3) ;

LFSensor [4] = digitalRead(lineFollowSensor4) ;

farRightSensor = analogRead(farRightSensorPin) ;

farLeftSensor = analogRead(farLeftSensorPin) ;

Avoir 5 sondes, comme vu dans le projet de Robot ligne suiveur, permet la génération d’une variable de « erreur » qui aidera à contrôler la position du robot sur la ligne. En outre, une variable appelée « mode » servira pour définition si le robot suit une ligne, sur une ligne continue, une intersection ou pas du tout.

Cette variable « mode » servira également avec les capteurs "loin LEFT/RIGHT". Pour la représentation, nous allons examiner les capteurs loin gauche et droite ayant 3 états possibles: H (dépasser le seuil), L (inférieur au seuil) et X (sans objet). Pour les sorties numériques, sera l’habitude 0, 1 et nous présentera également le X:

• X 1 1 1 1 1 X == > mode = CONT_LINE ; erreur = 0 ;
• H 0 X X X X L == > mode = RIGHT_TURN ; erreur = 0 ; (Voir l’exemple à l’image ci-dessus)
• L X X X X 0 H == > mode = LEFT_TURN ; erreur = 0 ;
• X 0 0 0 0 0 X == > mode = NO_LINE ; erreur = 0 ;
• H 0 0 0 0 1 H == > mode = FOLLOWING_LINE ; erreur = 4 ;
• H 0 0 0 1 1 H == > mode = FOLLOWING_LINE ; erreur = 3 ;
• H 0 0 0 1 0 H == > mode = FOLLOWING_LINE ; erreur = 2 ;
• H 0 0 1 1 0 H == > mode = FOLLOWING_LINE ; erreur = 1 ;
• H 0 0 1 0 0 H == > mode = FOLLOWING_LINE ; erreur = 0 ;
• H 0 1 1 0 0 H == > mode = FOLLOWING_LINE ; erreur = -1 ;
• H 0 1 0 0 0 H == > mode = FOLLOWING_LINE ; erreur = -2
• H 1 1 0 0 0 H == > mode = FOLLOWING_LINE ; erreur = -3 ;
• H 1 0 0 0 0 H == > mode = FOLLOWING_LINE ; erreur = -4 ;

Donc, mettre en œuvre la logique ci-dessus dans la fonction :

Sub readLFSsensors()

retourne les variables « mode » et « erreur » qui servira à la logique du programme.

Il est important de tester la logique des capteurs avant de suivre le projet. La fonction ci-dessous est incluse dans le code et peut être utilisée pour des fins de test :

Sub testSensorLogic(void)
{

Serial.Print (farLeftSensor) ;

Serial.Print ("< == RIGH gauche == >") ;

Serial.Print (farRightSensor) ;

Serial.Print (« mode: ") ;

Serial.Print (mode) ;

Serial.Print ("erreur:") ;

Serial.println (erreur) ;

}