Aprender

Um robô seguidor de linha com Arduino, do sensor ao volante

Intermediário

Ou veja todas as aulas.

  • 526componentes na bancada
  • 46placas rodando agora
  • 1.00xtempo real, em todas as placas
Arduino Uno: um carrinho seguidor de linhaao vivo0.000 s 0.00x
Clique para abrir no editor
A 5-channel line sensor on A0 to A4 and two motors on a TB6612FNG, on a simulated ATmega328P. Drag the tape across under the sensor.

O seguidor de linha é o primeiro robô que a maioria dos kits de carrinho robô monta. Uma fileira de sensores na frente olha para o chão, o Arduino calcula onde está uma faixa de fita preta e desacelera uma roda enquanto acelera a outra para manter a fita no centro. É uma pequena aula completa sobre sentir, decidir e dirigir.

O circuito acima é um Uno com um sensor de linha de cinco canais em A0 a A4, um driver de motores TB6612FNG, dois motores com caixa de redução e um conjunto de duas células 18650. O carrinho não se move na tela, então o chão se move no lugar dele: arraste o controle deslizante no sensor para deslizar a fita para a esquerda ou para a direita e veja as duas rodas mudarem de velocidade. Clique na amostra de cor para colocar uma barra preta através da pista, e o carrinho para na chegada.

O que você precisa

  • Um Arduino Uno
  • A 5-channel line tracking sensor board (five TCRT5000 sensors)
  • Um driver de motores TB6612FNG
  • Dois motores de 6 V com caixa de redução em um chassi de duas rodas
  • Um porta-pilhas para os motores (aqui duas células 18650, 8,4 V quando cheio)
  • Fios jumper e fita isolante preta em um chão claro

Ligação

Componente e pinoVai paraNota
Sensores S1 (esquerda) a S5 (direita)A4, A3, A2, A1, A0Alto sobre a linha preta
VCC e GND do sensor5 V (IOREF) e GND
PWMA, AIN1 e AIN2 do TB6612Pinos 5, 2 e 4O motor esquerdo
PWMB, BIN1 e BIN2 do TB6612Pinos 6, 7, 8O motor direito
STBY do TB6612Pino 9Low coloca o driver em repouso
VCC do TB66125 VO fornecimento de lógica
VM do TB6612Bateria +A alimentação dos motores
Todos os terrasGNDBateria, driver e Uno interligados

Lendo a linha com cinco sensores

Cada sensor é um LED infravermelho e um sensor de luz apontando para baixo. O chão branco reflete a luz e a fita preta a absorve, e um comparador na placa transforma isso em um sinal digital simples: alto sobre a linha preta, baixo sobre o branco. Por isso o sketch lê os cinco canais com digitalRead(), mesmo eles estando ligados aos pinos analógicos.

Os sensores ficam a 15 mm um do outro. O sketch dá uma posição a cada um, de -30 mm para o S1 à esquerda a +30 mm para o S5 à direita, e faz a média das posições dos sensores que veem a fita. Com a fita sob o sensor do meio, a linha está em 0 mm. Entre S3 e S4, os dois a veem, e a média é 7 mm. Isso dá uma posição mais fina que o espaçamento entre sensores.

Direção: P e D

A posição é o erro: o quão longe a linha está do meio. As duas rodas começam em uma velocidade base de 120 em 255. O sketch soma uma curva à roda esquerda e subtrai da direita. A curva é KP vezes o erro mais KD vezes quanto o erro mudou desde a última vez. KP puxa o carrinho de volta para a linha; KD amortece a oscilação para ele não ficar ziguezagueando.

Com a linha sob o sensor do meio, o monitor serial mostra "line 0 mm left 120 right 120". Deslize a fita para 15 mm à direita e ele estabiliza em "line 15 mm left 165 right 75": a roda esquerda mais rápida, então o carrinho vira à direita, de volta sobre a linha. Coloque-a sob o S1 e ele mostra "line -30 mm left 30 right 180".

O laço principal, do carrinho seguidor de linha
void loop() {
  if (finished) return;

  int seen = 0;
  int sum = 0;
  for (int i = 0; i < 5; i++) {
    if (digitalRead(SENSORS[i]) == HIGH) {
      seen++;
      sum += (i - 2) * 15;
    }
  }

  if (seen == 5) {
    brake(leftMotor, rightMotor);
    finished = true;
    Serial.println("finish bar: stopped");
    return;
  }

  int left;
  int right;
  if (seen == 0) {
    // Lost it: turn toward where it was last.
    left = lastError >= 0 ? SEARCH : -SEARCH;
    right = -left;
    leftMotor.drive(left);
    rightMotor.drive(right);
    report("searching, last", lastError, left, right);
    delay(10);
    return;
  }

  int error = sum / seen;
  int turn = KP * error + KD * (error - lastError);
  lastError = error;
  left = clampSpeed(BASE + turn);
  right = clampSpeed(BASE - turn);
  leftMotor.drive(left);
  rightMotor.drive(right);
  report("line", error, left, right);
  delay(10);
}

Perder a linha, e a barra de chegada

Em uma curva fechada a fita pode escapar do sensor mais externo, e aí nenhum sensor vê nada. O sketch lembra o último erro e gira na direção dele: uma roda para frente a 110, a outra para trás a 110, até um sensor encontrar a fita de novo. Arraste a fita para fora da borda esquerda e o monitor serial mostra "searching, last -30 mm left -110 right 110".

Os cinco sensores pretos ao mesmo tempo significam uma barra atravessando a pista. O sketch chama brake() nos dois motores e imprime "finish bar: stopped".

Motores e alimentação

O TB6612FNG é uma ponte H para dois motores. Para cada um, dois pinos definem o sentido e um pino PWM define a velocidade, e STBY precisa estar em alto ou nada se move. A biblioteca SparkFun TB6612 cuida disso: drive(150) gira um motor para frente a 150, drive(-150) gira para trás, e brake() o para.

Duas células 18650 cheias fornecem 8,4 V e esses motores são de 6 V, então o sketch nunca pede mais que 180 de 255, cerca de 5,9 V em média. Neste circuito o Uno funciona pela USB; em um carrinho de verdade o mesmo pack alimentaria o pino VIN do Uno através de uma chave.

O Mokxi modela o driver e os motores, mas não o carrinho se movendo pelo chão, então não há momento que o leve para fora de uma curva nem aderência a perder. É isso que você ajusta em KP, KD e na velocidade base em uma pista de verdade.

Erros comuns

Virando para o lado errado. Com a linha à direita, a roda esquerda precisa girar mais rápido. Se o seu carrinho se afasta da linha, troque o mais e o menos nas duas linhas de velocidade, ou inverta os fios de um motor.

Ler o sensor de cabeça para baixo. Nesta placa, alto significa preto. Algumas placas são o contrário; imprima as cinco leituras primeiro e confira.

Montar os sensores alto demais. Um TCRT5000 precisa ficar a alguns milímetros do chão. Acima de cerca de um centímetro ele não distingue preto de branco.

Esquecer o STBY. Com STBY baixo ou desconectado, o driver dorme e os motores nunca giram.

Falta de ground comum entre a bateria, o driver e o Uno.

Velocidade alta demais. Um carrinho que passa da curva em toda esquina precisa de uma velocidade base menor ou de mais KD antes de precisar de um sensor melhor.

Abra este circuito no editor. Arduino Uno: um carrinho seguidor de linha, ligado como ele roda no topo desta página. Mude um componente ou um valor e rode de novo.

Abrir o circuito

Perguntas

Como funciona um robô seguidor de linha?

Sensores embaixo da frente distinguem a fita preta de um chão claro. O Arduino calcula o quão longe a fita está do meio e desacelera a roda do lado onde a fita está, então o robô volta a ficar sobre ela.

Quantos sensores um seguidor de linha precisa?

Dois conseguem seguir uma linha suave. Cinco, como aqui, dão uma posição em vez de apenas esquerda ou direita, o que permite direção suave e deixa o robô ver uma faixa de chegada atravessando a pista.

O que é PID em um seguidor de linha?

Proporcional, integral e derivativo: três maneiras de transformar o erro em uma correção de direção. Este robô usa P e D. O termo P curva mais forte quanto mais longe está a linha; o termo D amortece a curva quando o erro já está diminuindo.

Posso usar um L298N no lugar de um TB6612FNG?

Sim, a ligação e o código são quase iguais: dois pinos de direção e um pino PWM por motor. O L298N perde cerca de 2 volts em seus transistores, então os motores recebem menos da bateria. O Mokxi tem os dois drivers.

Monte isto de verdade

Abra o editor, mude um valor e veja o número mudar junto. Nada para instalar, e não precisa de conta.