Beginner Robotics Kit - 8. Line Follower Robot

The Starter Kit for Robotics comes with a pair of Analog QRE Reflectance Sensors for line detection. These sensors work by emitting a beam of infrared (IR) light towards the surface below the robot and measuring how much light is reflected. On the sensor, you will notice that there are two small rectangles. One is the IR emitter and the other is the detector.

Line sensors work best when they are close to the surface below the robot. The sensor must be about 3mm above the ground. This is a great distance for the IR emitter to illuminate the surface and read the reflected light. But rest assured, if you followed the assembly step-by-step correctly, the sensors will be well positioned.
Note: Human eyes are not sensitive to infrared light, so unless you are a superhero, you will not be able to see the light emitted by the sensors. But if you use a CCD camera, like the one on your smartphone, you will be able to see small points of light coming out of your sensors.

Seeing the Line

In this example, we will simply read and print the values of our Line Sensors. It is interesting that you test the sensors in different scenarios so that you can understand their behavior.
Load this sample code into the Julieta board. To do this, go to: File-> Examples-> RoboCore Falcon Robot Library-> Exp4_1_LineFollowing or copy and paste the sample code below.

/ *******************************************************************************
* Exp4_1_LineFollowing - FalconRobot Experiment 4.1
*
* This code reads the two line following sensors on A2 and A3
* and prints them out to the Serial Monitor. Upload this example to your
* FalconRobot and open up the Serial Monitor by clicking the magnifying glass
* in the upper-right hand corner.
*
* Hardware setup:
* The Line Sensors must be connected to pins A2 and A3 (left and right sensor,
* respectively).
*
* This sketch was written by RoboCore, with lots of help from the Arduino
* community (especially from Sparkfun). This code is completely free for any use.
*
* Visit https://www.robocore.net/tutoriais/kit-iniciante-robotica-introducao
* for Falcon Robot Kit Information
*
* 20 Jul 2017 MarceloFariaz
******************************************************************************* /

#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);
}

After loading the code for your robot, open the Serial Monitor to view the reading of your sensors. You should see a window like this:

If you made the correct connections, in the first column you will have the values read by the left sensor and in the second column the values read by the right sensor.

With the robot connected to your computer, perform the following tests:

Place your robot on your table. What are the values read by the two sensors?
Place it on the sheet with tape. What are the values read on the tape? What about the white surface?
With the robot still on the table, turn off the ambient lights or cover it with a blanket or something. What happens to the values read? What do you think is causing this?
Move the robot slowly to the edge of the table. Observe the readings as the sensors approach the edge of the table. What are the values of the sensors when they are off the table?

You can now use these values to program your robot to do things like stay on the table or follow a line!

Understanding the code

To set up a connection between the robot and your computer, it is necessary to use the Serial Object in Arduino. In setup() , the Serial.begin(9600); command initializes the Arduino Serial and determines the speed at which data is transmitted and received between the robot and the computer. The value of 9600 defines the baud rate, that is, the number of bits per second. This is a good speed for most applications, but other speeds are supported by the Arduino, such as: 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, and 115200.

 Serial.begin(9600);

To send data from the robot to your computer, you can basically use two commands: Serial.print(""); and Serial.println(""); . The first command, Serial.print(""); simply prints the text in quotes ("") or some data (in the form of a number or variable) to the Serial bus - this is shown in the Monitor Serial. The second command, Serial.println(""); is the same, but adds a carriage return and newline character, moving the cursor to the beginning of the next line.

Serial.print ("Line Sensor Readings:");
  
Serial.println(); // new line

Printing Special Characters

There are some special characters that you can print. Below you can see some that are used in C and C ++:

Code	Description
\t	TAB character
\"	Double quotes
\'	Single quotes
\n	CRLF - new line

FalconRobot Library

The FalconRobotLineSensor is an object created to facilitate interaction with the line sensors that come with the Kit. In the robot, the line sensors were connected to Julieta's A2 and A3 pins. For this reason, in the lines below, an object was created to take care of the reading of each sensor.

  // initialize a sensor object on A2 and A3
  FalconRobotLineSensor lineSensor1 = FalconRobotLineSensor(A2);
  FalconRobotLineSensor lineSensor2 = FalconRobotLineSensor(A3);

The FalconRobotLineSensor class has several methods, but for this specific project the main one is xxxx.read(); . This method returns a value between 0 and 1023 based on the input voltage of the sensor. Remember that xxxx represents the name of the object (in this case, lineSensor1 or lineSensor2).

  Serial.print (lineSensor1.read());

Troubleshooting

Nothing is being printed on the Serial Monitor!

Check that the baud rate has been set up correctly on your serial monitor. There is a menu in the lower right corner, it must be configured for the 9600 baud rate.

The value of my sensor does not change!

Check that the sensors have been correctly connected to your Juliet board.
Try to exchange one sensor with another.

Now that you understand how infrared reflectance sensors work, it's time to learn how to make your robot follow the line!

A curiosity: did you know that there are several competitions for line-following robots in all parts of the world, including world robotics championship that RoboCore organizes every year? That's right, the basic concepts that you will learn here can be used for those who know how to build a competition robot!

Following the Line

The algorithm for keeping the robot on track is quite simple. Note that the main objective is to always keep the two sensors on the line, as this way the robot will be centered on the path it must take. Therefore, the basic logic that must be implemented is:

If the two sensors are on the line, move forward (left and right engine at the same speed).
If the left sensor is on the line and the right sensor is off the line, turn to the left (left engine a little slower and the right engine a little faster).
If the right sensor is on the line and the left sensor is off the line, turn to the right (right engine a little slower and the left engine a little faster).

Note that there is also a fourth hypothesis where the two sensors are out of line (4), but in this tutorial only the first three situations will be considered, leaving it up to you to choose what to do when the latter occurs.
Upload this sample code to your Falcon Platform. To do this, go to: File-> Examples-> RoboCore Falcon Robot Library-> Exp4_2_LineFollowing or copy and paste the sample code below.

/*******************************************************************************
* Exp4_2_LineFollowing -- Falcon Robot Experiment 4.2
*
* This code reads the two line following sensors on A2 and A3
* and prints them out to the Serial Monitor. Upload this example to your
* Falcon Robot and open up the Serial Monitor by clicking the magnifying glass
* in the upper-right hand corner.
*
* This is a real simple example of a line following algorithm. It has
* a lot of room for improvement, but works fairly well for a curved track.
* It does not handle right angles reliably -- maybe you can come up with a
* better solution?
*
* Hardware setup:
* The Line Sensors must be connected to pins A2 and A3 (left and right sensor,
* respectively). The motors must be connected, and the board must be receiving
* power from the battery pack.
*
* This sketch was written by RoboCore, with lots of help from the Arduino
* community(especially from Sparkfun). This code is completely free for any use.
*
* Visit https://www.robocore.net/tutoriais/kit-iniciante-robotica-introducao
* for Falcon Robot Kit Information
*
* 20 Jul 2017 MarceloFariaz
*******************************************************************************/

#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.
  }

After uploading the code to your robot, place it on the white sheet with tape you made in the last chapter. Try to replicate the hypotheses mentioned above and check if the robot responds according to the logic necessary to follow the line. That is, place the robot with the two sensors on top of the line and see if the two motors rotate in the same direction, making the robot go forward. Do the same for cases where only one sensor is on the line and see if the robot turns in the right direction.

Exercise: Building a runway

The coolest part about building a robot that follows the line is to observe it by taking a route alone. So let's build a small circuit for your robot.

To do this, simply apply the black tape you received with the Kit on a clear surface large enough for your circuit. Remember that it is important that there is a good difference in reflectance between the black tape and the surface where the track is built so that the robot can identify the line.
It is important that the surface is clear, flat and without large undulations or gaps. You can build on a table, on cardboards or even on a floor that does not have major depressions. Also pay attention to the spacing between the lines, because if the lines of the track are too close, the chances of the robot getting lost increase considerably.

Attention: if you build your track on an elevated surface, such as a table, be very attentive whenever you place the robot to follow, as eventually it may leave route and even fall off the table.

The image above shows a good example of a track to build. It is a simple model and your robot will probably have no problems following the route.

Understanding the code

In this example, two constants were used. The LINETHRESHOLD constant and the SPEED constant. The first, LINETHRESHOLD , defines the boundary between the dark line and the track surface. That is, if the sensor value is below the limit, then the sensor is on the white surface, if it is above the limit, then the sensor is on the line. The second, SPEED , defines the nominal speed of the engines when it must move forward.
Note that in this code the expression #define was used. This word allows the creation of constants without taking up the memory of your Arduino's variables.

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

The part of the code where the logic itself is implemented is in the lines below. You can observe 3 conditionals. Each of them deals with the cases mentioned at the beginning of this chapter. The first if takes care of the occasion where the two sensors are on the line, setting the motor speeds to the rated speed, making the robot go in a straight line.
The second conditional, else if takes care of the case where only the right sensor is on the line and the robot must turn to the right. In that case, the speed of the motor on the right is reduced and the speed of the motor on the left is increased. In the last if of the program, it takes care of the last case, where the robot must turn to the left.

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

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

Here is an explanation of the if and else if routine, both used in the code. We use the routines to express what we want to be done if a condition is met, and what we want to happen if that same condition is not met. This is easier to understand if we put it the way we think. Let's see:

   IF (left sensor value is GREATER than LINETHRESHOLD constant) AND ALSO IF (right sensor value is GREATER than LINETHRESHOLD constant) do:
     Left speed will equal SPEED constant and
     Right-hand speed will equal SPEED constant.
  
   IF NO, IF (right sensor value is GREATER than LINETHRESHOLD constant), do:
     Left speed will equal SPEED constant plus 40 and
     Speed on the right will be equal to the SPEED constant decremented from 40.
  
   IF NO, IF (left sensor value is GREATER than constant LINETHRESHOLD), do:
     Speed on the left will be equal to the SPEED constant decresced from 40 and
     Right hand speed will equal SPEED constant plus 40.

Note that the && symbol means that both conditionals have to be met for an action to be performed.

Going Beyond

Going faster

This code really only works when the robot is moving slowly and sometimes it will go off the line in sharp curves. What can you do to make it work better?
Tip: there is a very popular control technique called PID that is widely used for the most diverse applications where it is necessary to stabilize a system with inputs and outputs, such as a robot following line, for example. To learn more, click here . < br>

Other related experiments

With the concepts learned in this chapter you can develop other cool experiments. For example, would you be able to modify the code in such a way that, when placing the robot inside a square, circle or any other closed geometric shape, it remains within the enclosed space?

Troubleshooting

The robot vibrates a lot when it comes to moving!

By adjusting the nominal speed values, the line limit value and the values that are incremented and decremented when turning, you will be able to make the robot follow the course more smoothly.

The robot does not follow the line

Check the connections of the sensors and motors, as it is possible that some connection is inverted and the circuit does not correspond with the logic implemented in the code.

Comments

To make comments you must be logged in. Login.

You are not registered yet? Register Now!

prof.rodrigoluiz
date

Sent 2021-10-05 08:44:32

Uma sugestão para quem está explorando este tutorial:

O código acima é capaz de corrigir o traçado quando um dos sensores está sobre a linha e outro fora dela. Porém, caso os dois sensores saiam da linha, o robô não sabe de que lado da linha ele está. Eu contornei esse problema seguindo as bordas da linha ao invés de seguir a linha em si. Usando esse método, é possível usar uma variável para identificar cada borda e, caso se perca, o robô consegue corrigir o curso de uma forma mais eficaz já que ele sabe se está a direta ou a esquerda da linha. Ainda assim, ele oscila bastante.

Francois

Sent 2021-10-05 12:18:40
prof.rodrigoluiz

Essa é uma alternativa de controle interessante. Como você deve ter percebido, a fluidez do movimento do robô é uma tarefa um tanto complexa que depende, entre outros, das posições dos sensores e da malha de controle utilizada. Porém, é um ótimo desafio para otimizar o robô seguidor de linha.

prof.rodrigoluiz
date

Sent 2021-10-04 09:50:58

Muitos exemplos de PID que vi dependem ou de um encoder ou de mais sensores IR. Vocês sabem se é possível implementar um controlador PID usando somente os componentes do kit?

Francois

Sent 2021-10-04 12:40:04
prof.rodrigoluiz

Muitos projetos usam encoders nos motores e vários sensores infravermelhos para terem mais informações sobre o que está acontecendo com o robô. Porém, você pode implementar um controle PID mais simples usando apenas os dois sensores IR do kit.

prof.rodrigoluiz
date

Sent 2021-10-04 13:34:40
prof.rodrigoluiz

Obrigado, Francois Vou tentar fazer adaptar um exemplo que encontrei. Vamos ver se dá certo.

prof.rodrigoluiz
date

Sent 2021-10-05 08:27:13
prof.rodrigoluiz

Voltei a tentar a implementação com PID. Acho até que o meu código está funcionando. Embora eu não tenha trabalhando muito na calibração das constantes.

No meu código eu programei duas funções PID - cada uma dedicada a reduzir a diferença entre a variável LINETHRESHOLD como definida no tutorial de vocês e a leitura do sensor. As correções são obviamente usadas para aumentar ou diminuir a velocidade das rodas conforme necessário. Minha dúvida: eu realmente preciso ter uma função PID para cada sensor ou é possível controlar tudo com uma função só?

Francois

Sent 2021-10-05 12:14:28
prof.rodrigoluiz

Como o controle PID precisa de um ponto de referência e calcula-se o erro em cima disso, você pode tentar criar um algoritmo que combine os sensores para detectar onde o robô está e atuar os dois motores em função disso. Mas uma forma simples de fazer um controle PID é criando uma malha para cada lado, como você fez.

prof.rodrigoluiz
date

Sent 2021-10-07 09:47:56
prof.rodrigoluiz

Consegui fazer o controlador PID funcionar. Agora preciso aprender a calibrar as constantes que envolvem o cálculo da correção.

Vou deixar um link para a minha postagem no fórum aqui caso alguém queira se aventurar e me ajudar a fazer a calibração.

https://www.robocore.net/modules.php?name=Forums&file=viewtopic&t=7130

Francois

Sent 2021-10-07 12:29:36
prof.rodrigoluiz

Muito legal, o seu post pode ajudar várias outras pessoas com seus projetos de PID.

flaviaresende98
date

Sent 2020-10-25 17:49:53

Nao consigo fazer o robo seguir a linha. Utilizo o código, ele lê os sensores, mas quando coloco pra seguir a linha ele so fica girando em circulos e nao segue o código.

Giovanni5

Sent 2020-10-26 09:53:19
flaviaresende98

Como os sensores são ópticos e devem ser muito afetados pela iluminação ambiente, é possível que você tenha que calibrar o código com os valores obtidos nas leituras simples dos sensores (primeiro código deste projeto). Além disso, vale a pena conferir a montagem eletrônica dos sensores, pois se eles estiverem conectados incorretamente, eles não funcionarão.

carlos.ed.b
date

Sent 2020-09-21 17:41:18

boa tarde
estou fazendo os teste e mesmo o motor com velocidade de 20~30 fica um apito e a roda não gira.
não está encostando na carcaça, dou um leve toque a a roda gira.
uma das rodas está com um barulho extremamente alta em relação a outra, na mesma velocidade.

o kit é novo, e desde que abri ele pra testar está assim.
as pilhas são novas, as que vieram no kit.

obrigado

Giovanni5

Sent 2020-09-22 08:21:51
carlos.ed.b

Você conseguiu realizar o projeto "6. Primeiros Movimentos" (https://www.robocore.net/tutoriais/kit-iniciante-robotica-primeiros-movimentos) corretamente? É possível que a velocidade desta faixa seja pequena demais para que o motor possa partir, portanto tente aumentar um pouco esse parâmetro (velocidade de 40 - 50, por exemplo), e observe o resultado.

carlos.ed.b
date

Sent 2020-09-22 10:18:07
carlos.ed.b

sim, aumentei e melhorou um pouco, mas está estranho ainda, principalmente a diferença de barulho de uma roda para a outra, ate deixei sem as rodas pra ver, a diferença permanece. 

e aumentando a velocidade, o robô agora sai &#39;de lado&#39;, o que poderia ser?

Giovanni5

Sent 2020-09-22 10:59:48
carlos.ed.b

Encaminhe por gentileza um e-mail para suporte@robocore.net, com o número do seu pedido, e um vídeo demonstrando esse comportamento.

carlos.ed.b
date

Sent 2020-09-22 11:05:59
carlos.ed.b

ta bem
Obrigado

felipesoares92
date

Sent 2019-11-10 19:24:20

Como eu faço caso eu queira inverter de linha pretas para linhas brancas?

Giovanni5

Sent 2019-11-11 08:46:33
felipesoares92

Para alterar o fator de leitura da linha, para se adequar a qualquer cor, é necessário ajustar o comando "#define LINETHRESHOLD 700", para um valor que se adeque a leitura do sensor sobre a linha da pista. Portanto, seria necessário realizar a leitura da linha apenas, e observar o valor lido pelo sensor para alterar corretamente o fator deste código.

Francois

Sent 2019-11-11 15:39:40
felipesoares92

Complementando a resposta do Giovanni, se as cores do seu circuito forem invertidas, provavelmente será necessário também ajustar a lógica. Neste tutorial considera-se que a linha é preta, logo o sensor está sobre a linha quando o Arduino lê um valor acima de <LINETHRESHOLD>. Para uma linha branca, o sensor está sobre a ela quando o valor está abaixo de <LINETHRESHOLD>.

RicardoFerraz
date

Sent 2018-05-30 20:21:31

Boa noite pessoal da Robocore, não róla de vocês fazerem um tutorial para controlar o seguidor de linha usando a técnica PID. estou pesquisando adoidado na net e não estou entendendo nada o que explicam.

Francois

Sent 2018-06-01 10:10:06
RicardoFerraz

Está previsto disponibilizarmos um tutorial sobre o controle PID no microcontrolador, porém não para o kit de robótica, visto que é um assunto mais avançado.

RicardoFerraz
date

Sent 2018-05-27 19:17:34

Uma coisa que descobri caso o falcon comece a girar feito um louco, pode ser que os pinos dos sensores estejam ligados errados. ;)

Francois

Sent 2018-05-28 11:42:28
RicardoFerraz

Agradecemos o retorno, adicionamos o seu comentário na solução de problemas.

cristiane2002
date

Sent 2017-09-11 17:29:04

*254-399
*887975
*273-315
*1017-1018
esse são oa valores

cristiane2002
date

Sent 2017-09-11 17:31:02
cristiane2002

Coloque o seu robô sobre sua mesa. Quais sãos os valores lidos pelos dois sensores?Posicione-o sobre a folha com fita. Quais os valores lidos sobre a fita? E sobre a superfície branca?Com o robô ainda sobre a mesa, apague as luzes do ambiente ou cubra ele com um cobertor ou algo do gênero. O que acontece com os valores lidos? O que você acha que está causando isso?Mova o robô lentamente para a borda da mesa. Observe as leituras enquanto os sensores se aproximam da borda da mesa. Quais são os valores dos sensores quando eles estão fora da mesa?
eles estão nessa ordem.

Francois

Sent 2017-09-11 18:23:14
cristiane2002

Os valores lidos estão dentro da faixa esperada. Na parte de "seguindo a linha", carregue o código deste item, deixe as rodas do robô sem contato com a superfície e mova manualmente os sensores sobre a linha, deixando os dois sobre ela, depois um de cada vez sobre e o outro fora (1, 2 e 3 na imagem). Lembre-se que os sensores devem ficar próximos à superfície para ter uma leitura válida. Nesse teste os dois motores devem girar na mesma velocidade quando os dois estão na linha, e um girar mais devagar do que o outro quando somente um sensor está na linha.

cristiane2002
date

Sent 2017-09-09 18:58:32

está dando errado, meu codigo carrega certinho sem nenhum erro, só que quando coloco na folha com a fita, ele fica descontrolado fazendo circulos e só uma roda funciona a outra para, oq faço?

hallszombie
date

Sent 2017-09-11 07:50:25
cristiane2002

Quando você fez o primeiro exercício do projeto "Exercício: Entendendo o comportamento dos Sensores", quais foram as leituras do sensor nas superfície branca e preta ?