Kit robot suiveur de ligne à contrôle PID – Arduino UNO, capteurs IR, châssis robuste

Composants et fournitures

Châssis en aluminium anodisé KittenBot	×1
Carte de base KittenBot RosBot	×1
Roulette à bille métallique KittenBot (paire)	×1
Roues en caoutchouc avec moyeu moteur KittenBot (paire)	×1
Capteur suiveur de ligne IR 5 canaux KittenBot	×1
Moteur DC (générique)	×1
Batterie 9V (générique)	×1
Arduino UNO	×1

Applications et services en ligne

• Arduino IDE

À propos du projet

Vue d'ensemble

Une fonctionnalité essentielle pour la plupart des robots rovers autonomes est le suivi de ligne. Ce projet vise à construire un robot suiveur de ligne et à apprendre le contrôleur PID de manière ludique.

Pièces

Le robot fonctionne avec deux moteurs, la carte RosBot et un capteur 5 canaux. Contrairement aux autres kits, vous n'avez pas besoin d'acheter un pilote de moteur H-bridge supplémentaire ni divers composants, car la carte RosBot intègre deux pilotes H-bridge doubles. Il suffit de connecter les moteurs à la carte RosBot qui fournira plus de puissance que l'Arduino Uno seul.

• Châssis du robot : Châssis en aluminium anodisé KittenBot – solide, avec de nombreux trous de fixation (4,8 mm compatibles LEGO Technic), réutilisable pour d'autres projets.
• Cerveau du robot : Carte RosBot – carte principale basée sur Arduino UNO avec 2 pilotes H-bridge doubles intégrés.
• Yeux du robot : Capteur suiveur de ligne IR 5 canaux – détection infrarouge plus précise et stable.

Étape 1 : Assemblage

Ce robot s'assemble facilement en suivant les instructions, environ 15 minutes.

1. Fixez les moteurs sur les côtés du châssis, insérez simplement les roues en caoutchouc.
2. Montez le capteur IR 5 canaux à l'avant du châssis.
3. Fixez la carte RosBot sur le châssis, le robot est prêt pour le câblage.

Étape 2 : Câblage

Connexions pour le capteur IR 5 canaux :

• VCC → 5V
• GND → GND RosBot
• T1-T4 → broches A0-A3
• T5 → broche SDA

Les moteurs DC se connectent simplement aux broches A+A- et B+B-.

Programmation

Le code utilise une machine à états indiquant chaque sortie possible du réseau de capteurs. Le robot se déplace dans une direction selon la sortie du réseau de capteurs.

Nous avons déjà défini les valeurs d'erreur, terme proportionnel, terme intégral et terme dérivé :

float Kp = 25;
float Ki = 0.15;
float Kd = 1200;
float error, errorLast, erroInte;

float calcPid(float input) {
  float errorDiff;
  float output;
  error = error * 0.7 + input * 0.3; // filtre
  errorDiff = error - errorLast;
  erroInte = constrain(erroInte + error, -50, 50);
  output = Kp * error + Ki * erroInte + Kd * errorDiff;
  errorLast = error;
  return output;
}

Ajustez ces valeurs pour trouver le meilleur réglage pour votre robot.

Code

Robot suiveur de ligne (Arduino)

#include <Adafruit_NeoPixel.h>
#define S_NULL 0
#define S_ONTRACE 1
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(4, 4, NEO_GRB + NEO_KHZ800);

void doDcSpeed(int spdL, int spdR) {
  spdR = -spdR;
  if (spdL < 0) { analogWrite(5, 0); analogWrite(6, -spdL); }
  else { analogWrite(5, spdL); analogWrite(6, 0); }
  if (spdR < 0) { analogWrite(9, 0); analogWrite(10, -spdR); }
  else { analogWrite(9, spdR); analogWrite(10, 0); }
}

int bias = 0;
int outlineCnt = 0;

void stateMachine(int a) {
  switch (a) {
    case B00000: outlineCnt++; break;
    case B11111: outlineCnt++; break;
    case B00010: case B00110: outlineCnt = 0; pixels.setPixelColor(2, pixels.Color(0, 50, 0)); bias = 1; break;
    case B00001: case B00011: outlineCnt = 0; pixels.setPixelColor(2, pixels.Color(0, 200, 0)); bias = 2; break;
    case B00100: outlineCnt = 0; pixels.setPixelColor(2, pixels.Color(0, 0, 20)); bias = 0; break;
    case B01000: case B01100: outlineCnt = 0; pixels.setPixelColor(2, pixels.Color(50, 0, 0)); bias = -1; break;
    case B10000: case B11000: outlineCnt = 0; pixels.setPixelColor(2, pixels.Color(200, 0, 0)); bias = -2; break;
    default: Serial.println(a, BIN); outlineCnt++; break;
  }
  pixels.setPixelColor(0, pixels.Color(outlineCnt * 10, 0, 0));
  if (outlineCnt > 10) { doDcSpeed(0, 0); }
  else {
    float ff = 150;
    float ctrl = calcPid(bias);
    doDcSpeed(ff - ctrl, ff + ctrl);
  }
  pixels.show();
}

float Kp = 25; float Ki = 0.15; float Kd = 1200;
float error, errorLast, erroInte;

float calcPid(float input) {
  float errorDiff, output;
  error = error * 0.7 + input * 0.3;
  errorDiff = error - errorLast;
  erroInte = constrain(erroInte + error, -50, 50);
  output = Kp * error + Ki * erroInte + Kd * errorDiff;
  errorLast = error;
  return output;
}

int echoTrace() {
  int ret = 0;
  int a[5];
  for (int i = 0; i < 5; i++) {
    a[i] = constrain((1025 - analogRead(A0 + i)) / 10 - 4, 0, 20);
    if (a[i] > 2) ret += (0x1 << i);
  }
  return ret;
}

void setup() {
  Serial.begin(115200);
  pixels.begin();
}

void loop() {
  delay(5);
  int pos = echoTrace();
  stateMachine(pos);
}

Dépôt GitHub : KittenBot/LinefollowRobot

Schématiques

Schéma de câblage disponible dans les ressources du projet.