sitemap link mailform link home

LineRacer

Der PRO-BOT128 soll einerc schwarzen Linie folgen

Download Testblatt für Sensorkalibrierung

Das Demoprogramm "LineRacer" im Odner "C-Compact Bsp" auf der original PRO-BOT-CD funktionierte bei uns nicht auf Anhieb.

Für den Start in die Programmierung sollte nun erst einmal ein eigener, einfacher Algorithmus auf der Basis eines simplen 2-Punkt-Reglers erstellt werden.

Der Regler ist also nicht "prädiktiv". Er kann nicht "vorausdenken". Daher muss der Roboter entweder sehr langsam fahren und/oder verliert auch schnell mal die Linie.

1. Variante: Super-Simpel-Wackelente

Diese Variante besteht eigentlich im Kern nur aus etwa 8 Zeilen Programmcode Wink

Es werden nur zwei Fälle unterschieden:

1. Abweichung von der Linie nach links

2. Alle anderen Fälle - also auf der Linie oder Abweichung von der Linie nach rechts

Der PRO-BOT fährt immer nur kleine Kurven, um der Linie zu folgen. Geradenstücke werden nicht erkannt bzw. ausgenutzt, um z.B. schneller zu fahren.

Download Download des Programms mit original PRO-BOT-Bibliothek


Programmlisting:

/*******************************************************************************
 Projektname:       LineRacer.cprj
 Benötigte Libs´s:  IntFunc_lib.cc
 Routinen:          LineRacer.cc, PRO-BOT128C_Lib.cc
 Autor:             Niko
 Datum:             28. November 2012
 Funktion:          PRO-BOT128 folgt einer schwarzen Linie auf den Boden.

                    Der PRO-BOT128 folgt einer Linie wie eine Wackelente.
                    Die Backward-LEDs zeigen an, wenn die Sensoren die schwarze Linie
                    erkennen.

                    Die Werte BLACK und WHITE wurden durch Tests ermittelt und
                    müssen für jeden einzelnen PRO-BOT erneut ermittelt werden.

                    Der schwarze Strich sollte mindestens 10 mm breit sein,
                    damit der PRO-BOT ihn findet und nicht verliert.

                    Es werden nur 2 Zustände ausgewertet:
                    1. Messwert des linken Sensors > Messwert des rechten Sensors:
                    Dann rechten Motor STOPP, damit eine Rechtsdrehung gemacht wird
                    2. Alle anderen Zustände:
                    Dann linken Motor STOPP, damit eine Linksdrehung gemacht wird

                    Allerdings hat dieser simple Algorithmus seine Grenzen!
 */

#define HIGHSPEED 255
#define MIDDLESPEED 220
#define LOWSPEED 100
#define WAIT1 50

int Line_left_value; // Messwert linker Liniensensor
int Line_right_value; // Messwert rechter Liniensensor


void main(void)
{
    PRO_BOT128_INIT(); //System-Setup - immer an 1. Stelle in der main
    Line_left_value = 0;
    Line_right_value = 0;
    LINE_LED_ON(); // Licht an
    DRIVE_ON();//ENABLE for Motore
    MOTOR_DIR(1,1); //Richtung "Vorwärts"


    //Main programm, endless Loop
    do
     {
     Line_left_value = READ_LINE_LEFT();
     Line_right_value = READ_LINE_RIGHT();

     // 2-Punkt-Regler
      if (Line_left_value > Line_right_value)
        {
        MOTOR_POWER(LOWSPEED, MIDDLESPEED);
        BLR_ON();
        DELAY_MS(WAIT1);
        }
        else
        {
        MOTOR_POWER(MIDDLESPEED, LOWSPEED);
        BLL_OFF();
         DELAY_MS(WAIT1);
        }

     }while (1);

}



 

2. Variante: Wackelente mit etwas Intelligenz

Das Programm wertet nun vier Zustände der Liniensensoren aus:

1. Beide Sensoren über BLACK (schwarze Linie) -> Schnelle Vorwärtsfahrt

2. Linker Sensor über BLACK, rechter Sensor über WHITE -> langsame Linkskurve

3. Linker Sensor über WHITE, rechter Sensor über BLACK -> langsame Rechtskurve

4. Beide Sensoren über WHITE -> Linie verloren - ein Stück rückwärts fahren

 

Die Werte für BLACK und WHITE wurde empirisch ermittelt.
Dazu wurde das Testprogramm "Line-Check" im Ordner "PRO-BOT128 Systemtest" der original PRO-BOT-CD verwendet. Dieser Test muss für jeden PRO-BOT durchgeführt werden, um festzustellen, ob die Werte für BLACK und WHITE akzeptabel sind.


Download Download des Programms mit original PRO-BOT-Bibliothek



Programmlisting:

/*******************************************************************************
 Projektname:       LineRacer.cprj
 Benötigte Libs´s:  IntFunc_lib.cc
 Routinen:          LineRacer.cc, PRO-BOT128C_Lib.cc
 Autor:             Niko
 Datum:             28. November 2012
 Funktion:          PRO-BOT128 folgt einer schwarzen Linie auf den Boden.

                    Der PRO-BOT128 folgt einer Linie wie eine Wackelente.
                    Die Forward-LEDs zeigen an, wenn die Linie verloren wurde.
                    Die Backward-LEDs zeigen an, wenn die Sensoren die schwarze Linie
                    erkennen.

                    Die Werte BLACK und WHITE wurden durch Tests ermittelt und
                    müssen für jeden einzelnen PRO-BOT erneut ermittelt werden.

                    Der schwarze Strich sollte mindestens 20 mm breit sein,
                    damit der PRO-BOT ihn findet und nicht verliert.
                    Auf geraden Strecken beschleunigt der PRO-BOT auf "HIGHSPEED".

                    Es werden 4 Zustände ausgewertet:
                    Beide Sensoren auf BLACK - Geradeausfahrt mit HIGHSPEED
                    Linker Sensor auf BLACK - Linksskurve
                    Rechter Sensor auf BLACK - Rechtskurve
                    Beide Sensoren auf WHITE - HALT und kurze Strecke rückwärts

                    Das kurze Rückwärtsfahren führt dazu, dass der PRO-BOT meist
                    die Linie wiederfindet. Allerdings hat dieser simple Algo-
                    rithmus seine Grenzen!
 */

#define WHITE 200
#define BLACK 100
#define HIGHSPEED 200
#define MIDDLESPEED 180
#define LOWSPEED 0

int Line_left_value; // Messwert linker Liniensensor
int Line_right_value; // Messwert rechter Liniensensor


void main(void)
{
    PRO_BOT128_INIT(); //System-Setup - immer an 1. Stelle in der main
    Line_left_value = 0;
    Line_right_value = 0;
    LINE_LED_ON(); // Licht an
    DRIVE_ON();//ENABLE for Motore
    MOTOR_DIR(1,1); //Richtung "Vorwärts"


    //Main programm, endless Loop
    do
     {
     Line_left_value = READ_LINE_LEFT();
     Line_right_value = READ_LINE_RIGHT();

     // Beide Liniensensoren erkennen BLACK
      if (  (Line_left_value < BLACK) && (Line_right_value < BLACK))
     {
        DRIVE_ON();
        MOTOR_POWER(HIGHSPEED, HIGHSPEED);
        BLL_ON();
        BLR_ON();
     }
     // Nur der linke Liniensensoren erkennt BLACK
      if (  (Line_left_value < BLACK) && (Line_right_value > WHITE))
     {
        DRIVE_ON();
        MOTOR_POWER(MIDDLESPEED, LOWSPEED);
        BLL_ON();
        BLR_OFF();
     }
     // Nur der rechte Liniensensoren erkennt BLACK
      if (  (Line_left_value > WHITE) && (Line_right_value < BLACK))
     {
        DRIVE_ON();
        MOTOR_POWER(LOWSPEED, MIDDLESPEED);
        BLL_OFF();
        BLR_ON();
     }
     // Beide Liniensensoren erkennen WHITE - Linie verloren!
     if (  (Line_left_value > WHITE) && (Line_right_value > WHITE))
     {
        DRIVE_OFF();
        FLL_ON();
        FLR_ON();
        BLL_OFF();
        BLR_OFF();
        DELAY_MS(500);
        DRIVE_ON();
        MOTOR_DIR(0,0); //Richtung auf "Rückwärts", um Linie wieder zu finden
        MOTOR_POWER (MIDDLESPEED, MIDDLESPEED);
        DELAY_MS(500);
        DRIVE_OFF();
        DELAY_MS(200);
        DRIVE_ON();
        MOTOR_DIR(1,1); //Richtung wieder auf "VORWÄRTS"
     }
     else
     {
        FLL_OFF();
        FLR_OFF();
     }

     /*
     Mit diesem Programmteil kann man die Messwerte auf dem PC ausgeben:
     Msg_WriteInt(Line_left_value);
     Msg_WriteText("-left");
     Msg_WriteChar(13);

     Msg_WriteInt(Line_right_value);
     Msg_WriteText("-right");
     Msg_WriteChar(13);
     */

     }while (1);

}

 


Buchempfehlung:

Buchempfehlung

Externer Link PRO-BOT128 selbst bauen und erfolgreich einsetzen

.

Letzte Änderung:
October 24. 2018 15:31:58
«    top    »