Auf künstlicher Intelligenz (KI) basierender Linienverfolgungsroboter

Apps und Onlinedienste

Arduino-IDE

Über dieses Projekt

Nach der Entwicklung des Arduino-basierten Pick &Place-Roboters war die Idee, einen künstlichen intelligenten KI-basierten linienfolgenden Roboter zu entwickeln. Die Entwicklung eines einfachen linienfolgenden Roboters war gut für den Anfänger, genau das, was er brauchte, um in meinem jüngsten Projekt eine Art Infrarotsensoren anstelle von Servomotoren hinzuzufügen. "Die Idee war, meine Fähigkeiten bei . zu testen fortgeschrittenesNiveau".

Obwohl es eine schwierige Aufgabe war, hat mir eine Art Online-Recherche sehr geholfen.

Warum wird ein KI-basierter Linienverfolgungsroboter benötigt?

Wenn es um KI geht Es ist die neueste Technologie, die das Potenzial hat, die Weltumgebung zu verändern und so das menschliche Leben zu verbessern. Ein Traum, der wahr werden kann, indem wir unseren Robotern Intelligenz verleihen, um reale Probleme zu verstehen und sie entsprechend zu lösen. Dieser Traum kann nur durch Künstliche Intelligenz deshalb reden alle darüber.

• Es kann in der Montage-/Produktionslinie verwendet werden.
• Abholbusse für Passagiere.

Obwohl mein Roboter-Prototyp ein bisschen Intelligenz haben kann, ist es für mich nur ein Anfang, meine Projekte in Richtung KI zu bewegen Daher werde ich hier versuchen, die Entwicklung von linienfolgenden Robotern mit Künstlicher Intelligenz Schritt für Schritt in einer recht einfachen Sprache zu erklären. Aus Mangel an Ressourcen werde ich keinen Roboter bauen, aber ich kann sehr gut erklären, wie Sie ihn bauen können, indem Sie eine Art Recherche durchführen. Ich werde versuchen, genaue Codes bereitzustellen, die auf Ihrer Arduino-IDE funktionieren, damit Sie können Sie ganz einfach Ihren ersten KI-Roboter entwickeln.

Hier kannst du mich auf Patreon unterstützen :http://bit.ly/31NfQ6A

"Die günstigsten Tarife in den USA finden Sie in der Beschreibung dieses Videos, klicken Sie einfach auf die Video ."

Kommen wir nun zum Projekt „Ein KI-basierter Line-Following-Roboter!“.

VERWENDUNG VON INFRAROT-SENSOREN

Unser Projekt enthält 7 Infrarotsensoren, wie in der Abbildung gezeigt.

• 5 für die PID-Steuerung
• 1 für Linkserkennung
• ein weiterer für die Erkennung der rechten Seite.

5 Rolle der PID-Steuerungssensoren :Diese 5 Sensoren werden verwendet, um einen digitalen Ausgang entweder hoch oder niedrig (1, 0) zu erzeugen.

Der Sensor, der in Bezug auf die schwarze Linie zentriert ist, erzeugt nur diesen Sensor HIGH(1). Das ähnlich mögliche Ergebnis von diesem Sensor könnte sein:-

• 10000
• 11000
• 01000
• 01100
• 00100
• 00110
• 00010
• 00011
• 00001
• 00000
• 11111

Jetzt kommen noch zwei weitere Sensoren für links und rechts mögliche Ergebnisse sind

Sensor ganz links:Analogausgang hoch oder niedrig

Sensor ganz links:Analogausgang hoch oder niedrig

Um den Wert von 5 Sensoren zu speichern, erstellen Sie eine Array-Variable.

in LFSensor[5]={1,1,1,1,1}; 

Um den Wert des linken und rechten Sensors zu speichern, verwenden wir Integer

int farleft_sensor=0; 

Wie wir wissen, haben wir 5 Sensoren, mit denen der linke und der rechte Weg von Robotern in einem Array gespeichert werden können. Also

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); 

MAZE-LINKE-HAND-REGEL:

anschauen Dieses Video, um die Labyrinth-Regel für die linke Hand zu verstehen

Kurz gesagt, die Linke-Hand-Regel kann beschrieben werden als:

• Lege deine linke Hand an die Wand.
• Beginne, vorwärts zu gehen
• Berühre an jeder Kreuzung und im ganzen Labyrinth deine linke Hand die Wand zu deiner Linken.
• Irgendwann erreichst du das Ende des Labyrinths. Du wirst wahrscheinlich nicht den kürzesten und direktesten Weg gehen, aber du wirst ihn erreichen.

Der Schlüssel hier besteht also darin, die Kreuzungen zu identifizieren , den Kurs auf der Grundlage der oben genannten Regeln zu definieren. Konkret können wir in unserer Art von 2D-Labyrinth 8 verschiedene Arten von Kreuzungen finden (siehe das erste Bild oben):

Wenn wir uns das Bild ansehen, können wir erkennen, dass die möglichen Aktionen an Kreuzungen sind:

Bei einem "Kreuz "

• Nach links gehen oder
• Nach rechts gehen, oder
• Gerade geradeaus
• An einem "Kreuz „Gehe nach links oder gehe nach rechts oder gehe geradeaus

Bei einem "T ":

• Nach links gehen oder
• Nach rechts gehen
• Bei einem "T ":Gehe nach links oderGehe nach rechts

Bei einem "Nur rechts ":

• Nach rechts gehen
• Bei einem "Nur rechts ":Gehe nach rechts

Bei einem "Nur links ":

• Nach links gehen
• Bei einem "Nur links ":Gehe nach links

Bei "Gerade oder Links ":

• Nach links gehen oder
• Gerade geradeaus
• Bei "Gerade oder Links ":Gehe nach links oderGehe geradeaus

Bei "Gerade oder Rechts ":

• Nach rechts gehen, oder
• Gerade geradeaus
• Bei "Gerade oder Rechts ":Gehe nach rechts oderGehe geradeaus

In einer "Sackgasse ":

• Zurück ("U-Wende")
• In einer "Sackgasse ":Gehe zurück ("U turn")

Am "Ende des Labyrinths ":

• Stopp
• Am "Ende des Labyrinths ":Stopp

Bei Anwendung der „Linke-Hand-Regel“ werden die Aktionen jedoch auf jeweils eine Option reduziert:

• An einem "Kreuz":Gehe nach links
• An einem "T":Gehe nach links
• Nur rechts:Gehe nach rechts
• Bei "Nur links":Gehe nach links
• An einer "Geraden oder Links":Gehe nach links
• An einer "Geradenaus oder Rechts":Gehen Sie geradeaus
• In einer "Sackgasse":Geh zurück ("U-Turn")
• Am "Ende des Labyrinths":Stopp

Wir sind fast da! "Sei ruhig!"

Wenn der Roboter eine "Sackgasse" oder das "Ende eines Labyrinths" erreicht, ist es leicht, sie zu identifizieren, da es keine mehrdeutigen Situationen gibt (wir haben diese Aktionen bereits beim Line Follower-Roboter implementiert, erinnern Sie sich?). Das Problem ist, wenn der Roboter beispielsweise eine "LINIE" findet, weil eine Linie ein "Kreuz" (1) oder ein "T" (2) sein kann. Auch wenn es eine "LINKE oder RECHTE KURSE" erreicht, kann dies eine einfache Abbiegung (Optionen 3 oder 4) oder Optionen sein, geradeaus zu gehen (5 oder 6). Um genau herauszufinden, welche Art von Kreuzung der Roboter ist, muss ein zusätzlicher Schritt unternommen werden:Der Roboter muss einen "Extra-Inch" fahren und sehen, was als nächstes kommt (siehe das zweite Bild oben als Beispiel).

In Bezug auf den Fluss können die möglichen Aktionen nun wie folgt beschrieben werden:

An einer "TASTEN":

• Zurück ("U-Wende")
• An einer "TASTEN":Gehen Sie zurück ("U-Turn")

An einer "LINIE":

• Lauf einen zusätzlichen Zoll
• Wenn es eine Linie gibt:Es ist ein "Kreuz" ==> Gehe nach LINKS
• Wenn es keine Linie gibt:es ist ein "T" ==> Gehe nach LINKS
• Wenn es eine andere Zeile gibt:es ist das "Ende des Labyrinths" ==> STOP
• An einer "LINIE":Laufen Sie einen zusätzlichen Zoll Wenn es eine Linie gibt:Es ist ein "Kreuz" ==> Gehe nach LINKSWenn es keine Linie gibt:es ist ein "T" ==> Gehe nach LINKSWenn es eine andere Linie gibt:es ist das "Ende des Labyrinths" ==> STOP

An einer "RECHTEN BIEGE":

• Lauf einen zusätzlichen Zoll
• wenn es eine Linie gibt:Es ist eine Gerade oder Rechts ==> Gehe GERADE
• Wenn es keine Linie gibt:es ist nur rechts ==> Gehe zu RECHTS
• An einer "RECHTEN ABbiegung":Fahren Sie einen Zentimeter weiter Wenn es eine Linie gibt:Es ist eine Gerade oder Rechts ==> Gehe GERADEAUSWenn es keine Linie gibt:Es ist eine Nur Rechts ==> Gehe nach RECHTS

Bei einer "LINKEN BIEGE":

• Lauf einen zusätzlichen Zoll
• wenn es eine Linie gibt:Es ist eine Gerade oder LINKS ==> Gehe nach LINKS
• Wenn keine Linie vorhanden ist:Nur LINKS ==> Gehe zu LINKS
• Bei einer "LINKEN BIEGE":Fahren Sie einen Zentimeter weiter wenn es eine Linie gibt:Es ist eine Gerade oder LINKS ==> Gehe nach LINKSWenn es keine Linie gibt:es ist nur eine LINKE ==> Gehe nach LINKS

Beachten Sie, dass Sie im Falle einer "LINKS Abbiegung" den Test überspringen können, da Sie sowieso LINKS nehmen. Ich habe die Erklärung nur aus Gründen der Klarheit allgemeiner gelassen. Beim echten Code überspringe ich diesen Test.

Hier sind einige Probleme, die bei der Erstellung dieses Projekts auftreten können.

Verwandtes Thema

Behebung eines Arduino-Treiberproblems

anschauen dieses Video, um das Problem mit dem Arduino-Treiber zu lösen:

Code

• RoBot_Maze_Solve_2
• Funktionen
• AllgemeineFunktionen.
• sensorFunctions
• RobotDefines.h
• MotorFunktionen

RoBot_Maze_Solve_2C/C++

/*---------------------------------------------------------- ---------7 Sensoren Smart Robot - Maze Solver und Line Follower mit programmierbarem PID-Regler über BT==> Grundbewegung basierend auf Nano Mouse Robot, entwickelt von Michael Backus (http://www.akrobotnerd.com/ )==> Linie folgen basierend auf http://samvrit.tk/tutorials/pid-control-arduino-line-follower-robot/?ckattempt=1==> CREDIT an Patrick McCabe für den Pfad Solving Code, besuchen Sie patrickmccabemakes.com!!Marcelo Jose Rovai - 23. April 2016 - Besuchen Sie:http://mjrobot.org---------------- -------------------------------------------------- -*/#include #include "robotDefines.h"String-Befehl;String-Gerät;// BT-Modul#include SoftwareSerial BT1(10, 11); // El Pin 10 es Rx y El Pin 11 es Tx//---------------------------------- ----------void setup () { Serial.begin (9600); BT1.begin(9600); pinMode (ledPin, AUSGANG); pinMode (buttonPin, INPUT_PULLUP); // Zeilenfolgesensoren PinMode (lineFollowSensor0, INPUT); pinMode (lineFollowSensor1, EINGANG); pinMode (lineFollowSensor2, INPUT); pinMode (lineFollowSensor3, INPUT); pinMode (lineFollowSensor4, EINGANG); // Servos leftServo.attach (5); rightServo.attach(3); BT1.print("Überprüfen Sie die PID-Konstanten, die an den Roboter gesendet werden sollen"); Serial.print ( "Überprüfen Sie die PID-Konstanten, die an den Roboter gesendet werden sollen"); BT1.println('\n'); while (digitalRead(buttonPin) &&!mode) { checkBTcmd(); // überprüfen, ob ein Befehl von der BT-Fernbedienung ManualCmd () empfangen wird; Befehl =""; } checkPIDvalues(); Modus =GESTOPPT; Status =0; // 1. Durchgang} ungültige Schleife () { ledBlink (1); BT1.println("Erster Durchgang starten"); Serial.println ("Start First Pass"); readLFSsensoren(); mazeSolve(); // Erster Durchgang, um das Labyrinth zu lösen ledBlink(2); BT1.println("Erster Durchgang beenden"); Serial.println ("Ende des ersten Durchgangs"); while (digitalRead(buttonPin) &&!mode) { checkBTcmd(); // überprüfen, ob ein Befehl von der BT-Fernbedienung ManualCmd () empfangen wird; Befehl =""; } BT1.println("Start 2nd Pass"); Serial.println ( "Beginnen des 2. Durchgangs"); PfadIndex =0; Status =0; LabyrinthOptimierung(); // das Labyrinth so schnell wie möglich ausführen ledBlink (3); BT1.println("Ende 2. Durchgang"); Serial.println ("Ende 2. Durchgang"); while (digitalRead(buttonPin) &&!mode) { checkBTcmd(); // überprüfen, ob ein Befehl von der BT-Fernbedienung ManualCmd () empfangen wird; Befehl =""; } Modus =GESTOPPT; Status =0; // 1. Durchlauf pathIndex =0; pathLength =0;}

FunktionenC/C++

void mazeSolve(void){ while (!status) { readLFSsensors(); Schalter (Modus) { Fall NO_LINE:motorStop(); goAndTurn (LINKS, 180); recIntersection('B'); brechen; case CONT_LINE:runExtraInch(); readLFSsensoren(); if (mode !=CONT_LINE) {goAndTurn (LINKS, 90); recIntersection('L');} // oder es ist ein "T" oder "Cross"). In beiden Fällen geht nach LINKS sonst mazeEnd(); brechen; case RIGHT_TURN:runExtraInch(); readLFSsensoren(); if (mode ==NO_LINE) {goAndTurn (RIGHT, 90); recIntersection('R');} else recIntersection('S'); brechen; Fall LEFT_TURN:goAndTurn (LEFT, 90); recIntersection('L'); brechen; case FOLLOWING_LINE:followingLine(); brechen; } }} //--------------------------------------------------------- Void recIntersection (Zeichenrichtung) {Pfad [PfadLänge] =Richtung; // Speichere den Schnittpunkt in der Pfadvariablen. Pfadlänge ++; vereinfachenPfad(); // Vereinfachen Sie den gelernten Pfad.}//---------------------------------------------------- ------void mazeEnd (void) { motorStop (); BT1.print("Das Ende ==> Pfad:"); for(int i=0;i "); Serial.println (PfadLänge); Status =1; mode =STOPPED;}//------------------------------------------------------- ---void followingLine (void) {//readLFSsensors(); berechnePID(); motorPIDcontrol(); }//----------------------------------------------------------- -------------------------------------------// Pfadvereinfachung. Die Strategie besteht darin, dass wir jedes Mal, wenn wir auf eine // Sequenz xBx stoßen, diese vereinfachen können, indem wir die Sackgasse ausschneiden. Für // Beispiel LBL -> S, weil ein einzelnes S die Sackgasse umgeht // dargestellt durch LBL.void SimplifyPath(){ // Vereinfache den Pfad nur, wenn die vorletzte Abbiegung ein 'B' war if( pathLength <3 ||path[pathLength-2] !='B') return; int totalWinkel =0; int ich; for(i=1;i<=3;i++) { switch(path[pathLength-i]) { case 'R':totalAngle +=90; brechen; Fall 'L':totalAngle +=270; brechen; Fall 'B':totalAngle +=180; brechen; } } // Holen Sie sich den Winkel als Zahl zwischen 0 und 360 Grad. totalAngle =totalAngle % 360; // Ersetze alle diese Züge durch einen einzigen. switch(totalAngle) { case 0:path[pathLength - 3] ='S'; brechen; Fall 90:Pfad[PfadLänge - 3] ='R'; brechen; Fall 180:Pfad[PfadLänge - 3] ='B'; brechen; Fall 270:path[pathLength – 3] ='L'; brechen; } // Der Pfad ist jetzt zwei Schritte kürzer. Pfadlänge -=2; } //----------------------------------------------------------- -----------------------------------------------------------void labyrinthOptimierung ( Void) { Während (! Status) { readLFSsensors (); Schalter (Modus) { case FOLLOWING_LINE:followingLine(); brechen; case CONT_LINE:if (pathIndex>=pathLength) mazeEnd (); else {mazeTurn (Pfad[PfadIndex]); pathIndex++;} break; case LEFT_TURN:if (pathIndex>=pathLength) mazeEnd (); else {mazeTurn (Pfad[PfadIndex]); pathIndex++;} break; case RIGHT_TURN:if (pathIndex>=pathLength) mazeEnd (); else {mazeTurn (Pfad[PfadIndex]); pathIndex++;} break; } } } //--------------------------------------------------------- --------void mazeTurn (char dir) { switch (dir) { case 'L':// Links abbiegen goAndTurn (LEFT, 90); brechen; case 'R':// Rechts abbiegen goAndTurn (RIGHT, 90); brechen; Fall 'B':// Zurück goAndTurn (RIGHT, 800); brechen; case 'S':// Gehe geradeaus runExtraInch(); brechen; }}

Allgemeine Funktionen.C/C++

void ledBlink (int mal) { for (int i =0; i  0) { Serial.print ( "Befehl von BT erhalten ==> "); Serial.println (Gerät); Befehl =Gerät; Gerät =""; // Setzen Sie die Variable BT1.flush () zurück; } } //---------------------------------------------------------- --------------------------void manualCmd(){ switch (command[0]) { case 'g':mode =FOLLOWING_LINE; brechen; Fall 's':motorStop(); // beide Motoren ausschalten brechen; Fall 'f':motorForward(); brechen; Fall 'r':motorTurn (RECHTS, 30); motorStop(); brechen; Fall 'l':motorTurn(LINKS, 30); motorStop(); brechen; Fall 'b':motorBackward(); brechen; Fall 'p':Kp =Befehl[2]; brechen; Fall 'i':Ki =Befehl[2]; brechen; Fall 'd':Kd =Befehl[2]; brechen; }}//---------------------------------------------------------- --------------------------void sendBTdata (int data) // Daten an BT senden {digitalWrite (ledPin, HIGH); BT1.print ("Daten von Arduino"); BT1.print (Daten); BT1.print("xx"); BT1.println('\n'); digitalWrite (ledPin, LOW);}//---------------------------------------------------- ---------------- ungültig berechnenPID () { P =Fehler; ich =ich + Fehler; D =Fehler-vorheriger Fehler; PID-Wert =(Kp*P) + (Ki*I) + (Kd*D); previousError =error;}//------------------------------------------ -------------- ungültig checkPIDvalues ​​() { BT1.print ( "PID:"); BT1.print (Kp); BT1.print(" - "); BT1.print (Ki); BT1.print(" - "); BT1.println(Kd); Serial.print("PID:"); Serial.print (Kp); Serial.print(" - "); Serial.print (Ki); Serial.print(" - "); Serial.println (Kd); }//----------------------------------------------------------- Void testLineFollowSensors () {int LFS0 =digitalRead (lineFollowSensor0); int LFS1 =digitalRead (lineFollowSensor1); int LFS2 =digitalRead (lineFollowSensor2); int LFS3 =digitalRead (lineFollowSensor3); int LFS4 =digitalRead (lineFollowSensor4); Seriendruck ("LFS:L 0 1 2 3 4 R ==> "); Seriendruck (LFS0); Seriendruck (" "); Seriendruck (LFS1); Seriendruck (" "); Seriendruck (LFS2); Seriendruck (" "); Seriendruck (LFS3); Seriendruck (" "); Seriendruck (LFS4); Serial.print (" ==> "); Seriendruck (" P:"); Seriendruck (P); Serial.print (" I:"); Seriendruck (I); Serial.print (" D:"); Seriendruck (D); Serial.print (" PID:"); Serial.println (PIDvalue);}

sensorFuntionsC/C++

int mode =0;# definiere STOPPED 0# definiere FOLLOWING_LINE 1# definiere NO_LINE 2# definiere CONT_LINE 3# definiere POS_LINE 4# definiere RIGHT_TURN 5# definiere LEFT_TURN 6const int power =250;const int iniMotorPower =250;const int adj =0;float adjTurn =8;int extraInch =200;int adjGoAndTurn =800;const int ledPin =13;const int buttonPin =9;// LFSensor weiter links ist "0"const int lineFollowSensor0 =12; const int lineFollowSensor1 =18; const int lineFollowSensor2 =17; const int lineFollowSensor3 =16;const int lineFollowSensor4 =19;const int farRightSensorPin =0; // Analoger Pin A0const int farLeftSensorPin =1; // Analoger Pin A0const int THRESHOLD =150;int farRightSensor =0;int farLeftSensor =0;int LFSensor[5]={0, 0, 0, 0, 0}; // PID-Reglerfloat Kp=50;float Ki=0;float Kd=0;float error=0, P=0, I=0, D=0, PIDvalue=0;float previousError=0, previousI=0;#define RIGHT 1#define LEFT -1Servo leftServo;Servo rightServo; //------------------------------------------------ -//Spezifische Labyrinth-Phase 2 (Optimierung)-Definitionen und -Variablen unsigned char dir; // Die Pfadvariable speichert den Weg, den der Roboter genommen hat::// 'L' für links// 'R' für rechts// 'S' für geradeaus (geradeaus über eine Kreuzung)// 'B' für zurück (U-turn)char path[100] ="";unsigned char pathLength =0; // die Länge des pathint pathIndex =0;unsigned int status =0; // lösen =0; Ende erreichen =1

void motorStop () { leftServo.writeMicroseconds (1500); rightServo.writeMicroseconds(1500); Verzögerung(200);} //------------------------------------------ --- Void motorForward () {leftServo.writeMicroseconds (1500 - (Power + Adj)); rightServo.writeMicroseconds(1500 + power);}//---------------------------------------- -------void motorBackward () {leftServo.writeMicroseconds (1500 + Leistung); rightServo.writeMicroseconds(1500 - power);}//---------------------------------------- -------void motorFwTime (unsigned int time) { motorForward (); Verzögerungszeit); motorStop();} //------------------------------------------------------ --void motorBwTime (unsigned int time) { motorBackward(); Verzögerungszeit); motorStop();} //------------------------------------------------------ -----void motorTurn (int Richtung, int Grad) { leftServo.writeMicroseconds (1500 - (iniMotorPower + adj) * Richtung); rightServo.writeMicroseconds(1500 - iniMotorPower*direction); Verzögerung (rund(adjTurn*degrees+20)); motorStop();} //------------------------------------------------------ --------void motorPIDcontrol(){ int leftMotorSpeed ​​=1500 - (iniMotorPower+adj) - PIDvalue; int rightMotorSpeed ​​=1500 + iniMotorPower - PID-Wert; // Die Motordrehzahl sollte die maximale PWM-Wertbeschränkung nicht überschreiten (leftMotorSpeed, 1000, 2000); einschränken(rightMotorSpeed, 1000, 2000); leftServo.writeMicroseconds(leftMotorSpeed); rightServo.writeMicroseconds(rightMotorSpeed); //Serial.print (PID-Wert); //Serial.print (" ==> Links, Rechts:"); // Serial.print (leftMotorSpeed); //Seriendruck (" "); //Serial.println (rightMotorSpeed);} //------------------------------------------------- -------------void runExtraInch (void) { motorPIDcontrol (); Verzögerung (zusätzliche Zoll); motorStop();} //------------------------------------------------------ --------void goAndTurn (int-Richtung, int-Grad) { motorPIDcontrol (); Verzögerung (adjGoAndTurn); motorTurn(Richtung, Grad);}

Schaltpläne