Projekt 10 Einschränkendes Smart Car

1. Beschreibung

In diesem Projekt kombinieren wir das Wissen über einen Linienverfolgungssensor und Motortreiber-Module, um ein einschränkendes Smart Car zu bauen. Im Experiment wollen wir den Linienverfolgungssensor verwenden, um zu erkennen, ob sich eine schwarze Linie um das Smart Car befindet, und dann die Drehung der beiden Motoren entsprechend den Erkennungsergebnissen so steuern, dass das Smart Car in einem im Kreis gezogenen schwarzen Linien eingeschlossen wird.

2. Flussdiagramm

Die spezifische Logik des einschränkenden 4WD Smart Cars ist in der Tabelle dargestellt.

3. Schaltplan

G, V, S1, S2 und S3 des Linienverfolgungssensors sind mit G (GND), V (VCC), D11, D7 und D8 des Sensor-Erweiterungsboards verbunden.

Die Stromversorgung ist mit dem BAT-Anschluss verbunden.

4. Testcode

//*************************************************************************
/*
 keyestudio 4wd BT Car
 lesson 10
 Restricting Smart Car
 http://www.keyestudio.com
*/ 
//Daten vom Smile-Muster, erhalten vom Touch-Tool
unsigned char start01[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
#define SDA_Pin  A4  //Datenpin auf A4 setzen
#define SCL_Pin  A5  //Taktpin auf A5 setzen

int left_ctrl = 2; //Definiere die Richtungssteuerungspins des Motors Gruppe B
int left_pwm = 5;  //Definiere die PWM-Steuerungspins des Motors Gruppe B
int right_ctrl = 4; //Definiere die Richtungssteuerungspins des Motors Gruppe A
int right_pwm = 6;  //Definiere die PWM-Steuerungspins des Motors Gruppe A
int sensor_L = 11;  //Definiere den Pin des linken Linienverfolgungssensors
int sensor_M = 7;   //Definiere den Pin des mittleren Linienverfolgungssensors
int sensor_R = 8;   //Definiere den Pin des rechten Linienverfolgungssensors
int L_val, M_val, R_val; //Definiere diese Variablen

void setup() {
  Serial.begin(9600); //Starte den seriellen Monitor und setze die Baudrate auf 9600
  pinMode(left_ctrl, OUTPUT); //Setze die Richtungssteuerungspins des Motors Gruppe B auf OUTPUT
  pinMode(left_pwm, OUTPUT);  //Setze die PWM-Steuerungspins des Motors Gruppe B auf OUTPUT
  pinMode(right_ctrl, OUTPUT); //Setze die Richtungssteuerungspins des Motors Gruppe A auf OUTPUT
  pinMode(right_pwm, OUTPUT);  //Setze die PWM-Steuerungspins des Motors Gruppe A auf OUTPUT
  pinMode(sensor_L, INPUT);    //Setze die Pins des linken Linienverfolgungssensors auf INPUT
  pinMode(sensor_M, INPUT);    //Setze die Pins des mittleren Linienverfolgungssensors auf INPUT
  pinMode(sensor_R, INPUT);    //Setze die Pins des rechten Linienverfolgungssensors auf INPUT
  //Setze Pin auf Ausgang
  pinMode(SCL_Pin, OUTPUT);
  pinMode(SDA_Pin, OUTPUT);
  matrix_display(start01); //Zeige Startmuster an
}

void loop() 
{
  tracking(); //Führe Hauptprogramm aus
}

void tracking()
{
  L_val = digitalRead(sensor_L); //Lese den Wert des linken Linienverfolgungssensors
  M_val = digitalRead(sensor_M); //Lese den Wert des mittleren Linienverfolgungssensors
  R_val = digitalRead(sensor_R); //Lese den Wert des rechten Linienverfolgungssensors
  if ( L_val == 0 && M_val == 0 && R_val == 0 ) { //Wenn keine schwarzen Linien erkannt werden, fährt das Turtle Car vorwärts
    Car_front();
  }
  else { //Andernfalls, wenn einer der Sensoren eine schwarze Linie erkennt, rückwärts fahren und nach links drehen
    Car_back();
    delay(500);
    Car_left();
    delay(500);
  }
}

void Car_front()
{
  digitalWrite(left_ctrl, HIGH);
  analogWrite(left_pwm, 180);
  digitalWrite(right_ctrl, HIGH);
  analogWrite(right_pwm, 180);
}
void Car_back()
{
  digitalWrite(left_ctrl, LOW);
  analogWrite(left_pwm, 80);
  digitalWrite(right_ctrl, LOW);
  analogWrite(right_pwm, 80);
}
void Car_left()
{
  digitalWrite(left_ctrl, LOW);
  analogWrite(left_pwm, 100);  
  digitalWrite(right_ctrl, HIGH);
  analogWrite(right_pwm, 150);
}

void Car_Stop()
{
  digitalWrite(left_ctrl, LOW);
  analogWrite(left_pwm, 0);
  digitalWrite(right_ctrl, LOW);
  analogWrite(right_pwm, 0);
}


//diese Funktion wird für die Punktmatrixanzeige verwendet
void matrix_display(unsigned char matrix_value[])
{
  IIC_start();  //die Funktion, die die Datenübertragungs-Startbedingung aufruft
  IIC_send(0xc0);  //Adresse auswählen

  for (int i = 0; i < 16; i++) //die Musterdaten sind 16 Bytes lang
  {
    IIC_send(matrix_value[i]); //Übertrage die Daten des Musters
  }
  IIC_end();   //Beende die Musterdatenübertragung
  IIC_start();
  IIC_send(0x8A);  //Anzeige-Steuerung, wähle 4/16 Pulsbreite
  IIC_end();
}
//Bedingungen, unter denen die Datenübertragung beginnt
void IIC_start()
{
  digitalWrite(SDA_Pin, HIGH);
  digitalWrite(SCL_Pin, HIGH);
  delayMicroseconds(3);
  digitalWrite(SDA_Pin, LOW);
  delayMicroseconds(3);
  digitalWrite(SCL_Pin, LOW);
}
//Zeigt das Ende der Datenübertragung an
void IIC_end()
{
  digitalWrite(SCL_Pin, LOW);
  digitalWrite(SDA_Pin, LOW);
  delayMicroseconds(3);
  digitalWrite(SCL_Pin, HIGH);
  delayMicroseconds(3);
  digitalWrite(SDA_Pin, HIGH);
  delayMicroseconds(3);
}
//Daten übertragen
void IIC_send(unsigned char send_data)
{
  for (byte mask = 0x01; mask != 0; mask <<= 1) //Jedes Byte hat 8 Bits und wird bitweise beginnend mit dem niedrigsten Bit geprüft
  {
    if (send_data & mask) { //Setzt die High- und Low-Pegel von SDA_Pin abhängig davon, ob jedes Bit des Bytes eine 1 oder 0 ist
      digitalWrite(SDA_Pin, HIGH);
    } else {
      digitalWrite(SDA_Pin, LOW);
    }
    delayMicroseconds(3);
    digitalWrite(SCL_Pin, HIGH); //Ziehe den Clock-Pin SCL_Pin auf High, um die Datenübertragung zu stoppen
    delayMicroseconds(3);
    digitalWrite(SCL_Pin, LOW); //Ziehe den Clock-Pin SCL_Pin auf Low, um das SIGNAL von SDA zu ändern
  }
}
//*************************************************************************

5. Testergebnis

Nach dem erfolgreichen Hochladen des Codes auf das V4.0 Board, verbinden Sie die Verkabelung gemäß dem Schaltplan, schalten Sie die externe Stromversorgung einund stellen Sie dann den DIP-Schalter auf ON. Stellen Sie das Smart Car in den schwarzen Kreis, dann wird es sich ausschließlich im Kreis bewegen.