Robô seguidor de linha com Falcon

Vimos a apresentação desse robô no artigo kit iniciante para robótica Da Robocore a plataforma robótica Falcon com a controladora Julieta. Nosso projeto número 0 será o robô seguidor de linha, que  é muito utilizado na iniciação em robótica por diversos motivos; é simples de se fazer, permite implementar variações, é possível aprender usar PID para melhorar o desempenho do robô, pode-se evitar colisões com a adição de um sensor ultrassônico (que já vem no kit) e graças ao conjunto de redução, dá pra colocar um peso extra e implementar mais recursos. Esses recursos extras que vou adicionar pretendo deixar lá pro terceiro ou quarto artigo, primeiro vou partir do básico e gradativamente mostrar o quão rica é a plataforma, que nos permitirá fazer coisas cada vez mais interessantes.

Onde comprar o kit?

Vamos lá. Podemos fazer robôs seguidores de linha com qualquer coisa. Fiz um triciclo seguidor de linha "mais ou menos" bom, mas deu pra provar o conceito. Mas se você pretende realmente fazer projetos robóticos que possam agregar algum valor, talvez a primeira coisa importante para impor respeito ao projeto seja utilizar uma placa controladora robótica. E vai usar essa placa em cima de quê? Nada melhor que um resistente conjunto robótico tolerante a limpeza com álcool e impactos.

A plataforma robótica Falcon tem furação para adicionar diversas placas diferentes, inclusive Raspberry. Mas o kit robótico da Robocore já vem com a placa robótica Julieta, que garantirá a diversão sem a necessidade de se preocupar com características que para iniciantes pode ser complicada; alimentar o motor através de um driver e jamais direto pela microcontroladora; garantir que não haja retorno do motor no desligamento; garantir que algum esforço no motor não venha a queimar a controladora; garantir alimentação adequada para os motores, evitando assim frustração na hora de colocar o robô pra funcionar.

Sem a necessidade de preocupações adicionais, a plataforma robótica Falcon nos permitirá focar no que é mais importante, que é o funcionamento do robô, no qual futuramente adicionaremos recursos extras para controlá-lo de forma manual, instantânea, por comando, adicionando câmera e outros recursos. Por essa razão, minha sugestão é: Invista um pouco agora e colha nos resultados.

O produto é nacional, produzido pela Robocore e de extrema qualidade. Você pode adquirir seu kit através desse link para o Kit iniciante para robótica. Não pode comprar o kit completo agora? Sem problemas, no site da Robocore você encontrará as partes independentes e poderá montar seu robô aos poucos.

Montagem

Não vou escrever sobre a montagem do robô porque além de vir o manual de montagem, ainda vem na caixa o link para um manual online que dispõe até de vídeo. Só para perceber o quão simples isso poderia ser, montei junto com minha filha de 6 anos, que não teve dificuldade para compreender os passos. Acho que posso dizer seguramente que o nível de dificuldade para a montagem está em 1 na escala de 10.

Biblioteca

É pegar e usar. Tendo o código inicial, poderemos focar nos aperfeiçoamentos que desejarmos. Se for um projeto escolar, uma competição de seguidores de linha ou apenas um brinquedo tecnológico para uso pessoal, as preocupações iniciais relacionadas ao hardware e seu funcionamento estarão supridas - perceba que esse é o primeiro artigo que escrevo sobre algo realmente simples, para que os novatos consigam iniciar sem medo e para que os demais possam focar em novas implementações.

Pegue a biblioteca nesse link e na IDE do Arduino vá em Sketch-> Incluir Biblioteca-> Adicionar biblioteca .ZIP, selecionando o arquivo recém baixado.

Hello World

É uma boa ideia gravar um blink do LED 13 antes de qualquer coisa. Isso já garantirá que a alimentação e a comunicação estão ok. Se quiser, já pode começar com um blink diferente:

#include <Arduino.h>

struct led_buitin{
  int stat :1;
} blink;

void setup() {
  Serial.begin(9600);
  pinMode(13, OUTPUT);
}

void loop() {
  blink.stat += 1;
  digitalWrite(13,blink.stat);
  delay(500);
}

Por enquanto pode manter a chave de ligamento dos motores em OFF, isso aqui é só pra testar a "vida" da placa Julieta.

Testando os motores

Hora de testar os motores do nosso robô seguidor de linha. Coloque as pilhas no robô, coloque a chave do motor em ON. Suspenda o robô para ele não fuja com seu notebook. Brincadeiras à parte, aqui temos um código para fazer o avanço. No meu caso, conectei ao contrário, então preciso mudar os fios, mas nada que inverter os comandos não resolva, mas garanta que ambos estejam girando na mesma direção.

#include <Arduino.h>
#include "FalconRobot.h"

FalconRobotMotors motors(5, 7, 6, 8);

void setup() {
  Serial.begin(9600);
  motors.drive(100, FORWARD);
  delay(1000);
  motors.stop();
}

void loop() {
  delay(500);
}

Testando os sensores infravermelho

Só para constar, todo o processo com muito mais detalhes pode ser visto no tutorial indicado no link que acompanha o kit. Estou fazendo um overview da implementação para irmos logo ao resultado.

Primeiro passo é saber se os sensores estão conectados corretamente. Ligue a câmera do seu smartphone e aponte para eles, deve aparecer uma luz meio roxa de ambos os sensores. Estando lá, basta seguir para a programação agora.

Agora vamos ler os sensores para ver como está a resolução. Suba esse sketch e abra o monitor serial. Deixei os motores desligados na chave e tirei uma das pilhas para alimentar a placa apenas pela USB, então conectei ao notebook e subi o código a seguir.

#include "FalconRobot.h"
// initialize a sensor object on A2 and A3
FalconRobotLineSensor lineSensor1 = FalconRobotLineSensor(A2);
FalconRobotLineSensor lineSensor2 = FalconRobotLineSensor(A3);

void setup() {
  Serial.begin(9600); // Setup the Serial to a speed of 9600bps
  Serial.println("Welcome to experiment 5!");
}

void loop() {
  // Print the sensors values
  Serial.print("Line Sensor Readings: ");
  Serial.print(lineSensor1.read());
  Serial.print("\t"); // tab character
  Serial.print(lineSensor2.read());
  Serial.println(); // new line
  delay(100);
}

Ao abrir o monitor serial, deverá aparecer a leitura dos sensores, como abaixo:

Quanto mais baixo o valor, mais próximo do branco. Minha mesa é preta, por isso os valores estão inicialmente altos. Inverta os padrões (se estiver sobre branco, coloque sobre preto e vice-versa). Quanto maior o contraste, melhor o resultado.

Código para o projeto 1 - Robô seguidor de linha

E por que não começar com o código de exemplo da Robocore? Será que o código de exemplo está pronto para uma primeira experiência? É o que veremos.

Abra o sketch de exemplo Arquivo->Exemplos->RoboCore Falcon Robot Library->Exp4_2_LineFollowing e carregue-o. Mantenha o botão dos motores em OFF para subir esse sketch. Ou copie e cole o código a seguir:

#include <FalconRobot.h>
// initialize a sensor object on A2 and A3
FalconRobotLineSensor left(A2);
FalconRobotLineSensor right(A3);

int leftValue;  // variable to store the left sensor value
int rightValue;  // variable to store the right sensor value

// constants that are used in the code. LINETHRESHOLD is the level to detect
// if the sensor is on the line or not. If the sensor value is greater than this
// the sensor is above a DARK line.
//
// SPEED sets the nominal speed

#define LINETHRESHOLD 700
#define SPEED 50  // Set to any number from 0 - 100.

FalconRobotMotors motors(5, 7, 6, 8);
int leftSpeed;   // variable used to store the leftMotor speed
int rightSpeed;  // variable used to store the rightMotor speed


void setup() {
  Serial.begin(9600);
  Serial.println("Welcome to experiment 5.2 - Line Following");
  delay(2000);
  Serial.println("Line Sensor Readings: ");
  delay(500);
}

void loop() {

  // Read the sensors
  leftValue = left.read();
  rightValue = right.read();

  // Print the sensors values
  Serial.print(leftValue);
  Serial.print("\t");  // tab character
  Serial.print(rightValue);
  Serial.println();   // new line

  // if the both sensors are on the line, drive forward left and right at the same speed
  if((leftValue > LINETHRESHOLD) && (rightValue > LINETHRESHOLD)) {
    leftSpeed = SPEED;
    rightSpeed = SPEED;
  }

  // if the line only is under the right sensor, adjust relative speeds to turn to the right
  else if(rightValue > LINETHRESHOLD) {
    leftSpeed = SPEED + 40;
    rightSpeed = SPEED - 40;
  }

  // if the line only is under the left sensor, adjust relative speeds to turn to the left
  else if(leftValue > LINETHRESHOLD) {
    leftSpeed = SPEED - 40;
    rightSpeed = SPEED + 40;
  }

  // run motors given the control speeds above
  motors.leftDrive(leftSpeed, FORWARD);
  motors.rightDrive(rightSpeed, FORWARD);

  delay(0);  // add a delay to decrease sensitivity.
}

Quase nada de código, hum?

Como vimos há pouco, podemos pegar o valor lido dos nossos sensores infravermelho pela serial e com isso podemos definir o valor ideal para nosso limite, especificado em THRESHOLD. Podemos iniciar com o código padrão e verificar se o contraste do chão é satisfatório. No meu teste tiver um problema com o desnível da emenda do piso frio. Pois é, não tenho aqui um piso que não seja frio, então ajustei a velocidade (para mais) e a recuperação de direção para menos. Deu bastante certo para o primeiro teste, mas ainda está acontecendo os desvios no desnível, por isso vou tentar resolver com PID. Se você tem um piso de porcelanato, porcelanato líquido ou madeira, não terá esse problema, mas ocasionalmente haverá perda de direção. Utilizar PID deve resolver, vamos deixar esse recurso já para o próximo artigo relacionado ao robô seguidor de linha, onde mostrarei no vídeo a diferença de comportamento de ambos os códigos!

  Inscreva-se no nosso canal Manual do Maker no YouTube.

Também estamos no Instagram.