O que é um robot segue linha?

Um robot segue linha é um veículo que segue uma linha que desenha um determinado trajeto no plano. Existem enumeras variações de robots segue linha, uns para seguir linhas pretas (o mais comum) outras para seguir linhas brancas, uns com mais sensores outros com menos, mas o objetivo é sempre o mesmo, seguir uma linha e o seu percurso no plano.

Qual o principio de funcionamento?

Este tipo de robot é munido de um conjunto de sensores que detecam a posição do robot em relação à linha, sendo usada esta informação para dar instruções aos motores para corrigir a sua trajetória quando esta foge do centro da linha.

O sensor mas o mais comumente usado é o Infra-vermelho.

E os motores?

Já vimos como se consegue detetar o desvio de um robot utilizando o um array de sensores IR e que esta informação servirá para aumentar ou diminuir a velocidade dos motores para efetuar a correção da trajetória.

Um conceito muito importante para entendermos como controlar a velocidade dos motores é o PWM (Pulse Width Modulation) 

Como não conseguimos, como humanos que somos, ligar e desligar, manualmente, o interruptor numa cadência que nos permitisse regular a velocidade do motor, substituímos este papel por um circuito eletrónico que simula este ligar e desligar do interruptor

Os motores são ligados a um circuito a que chamamos de DRIVERS, isto porque as placas com os microcontroladores não têm potência de saída suficiente para aguentar com a corrente de um motor (havemos de abordar este tema numa outra oportunidade), mas na prática, um DRIVER, é um circuito intermédio que fica entre o motor e a placa microcontroladora que gera os impulsos PWM.

Estes drivers podem-se encontrar nas mais variadas formas e feitios, uns para motores mais potentes outro para motores menos potentes, uns para um só motor outros para dois motores, uns num circuito separado, outros embutidos na própria placa inde está o microcontrolador. Enfim, há uma panóplia deles cada um com as suas especificidades, as figuras 9,10,11 e 12 mostram alguns exemplos.

Diagrama lógico.

De uma forma muito simplicista podemos representar a nossa lógica com o fluxograma da figura 13.

Resumindo. Se há um desvio para a esquerda, compensar a esquerda, se há um desvio para a direita, compensar a direita.

Não havendo desvios o robot segue com a mesma potência nas duas rodas

Mãos à obra! Primeira etapa.

Para quem se está a iniciar na programação, aqui o lema é dividir para conquistar. Fazer as coisas por partes menores, testando cada uma das etapas, é meio caminho andado para se conseguir atingir em pleno o objetivo.

Então vamos começar pelo principal componente que nos vai permitir avaliar a nossa posição, o array de sensores IR. Para o efeito vamos utilizar a plataforma DOBOT AI-Starter, um carro robot que já vem equipado com um conjunto de sensores, desde IR, Cor, Luminosidade, Ultrasons, entre outros, figura 14 e 15.

Os pinos do microcontrolador.

Como é óbvio, tanto os sensores de IR como os motores estão ligados a pinos no microcontrolador, ou nos seus drivers correspondentes, nesta plataforma, o DOBOT-AI Starter, que tem por base um ARduino MEGA, os pinos dos motores e dos sensores IR são os seguintes:

IRed Sensors:

• IR1 PIN - 25

• IR2 PIN - 26

• IR3 PIN - 27

• IR4 PIN - 28

• IR5 PIN - 29

• IR6 PIN - 39

Motors:

• Right Motor A PIN - 5

• Right Motor B PIN - 10

• Left Motor A PIN - 8

• Left Motor B PIN - 9

Então a primeira etapa é fazer a leitura dos sensores IR e verificar se está a detetar, corretamente, a linha preta do circuito. Para tal vamos utilizar a linguagem de programação, mais comum para Arduíno, o C++.

Também vamos partir do principio que o leitor tem conhecimentos básicos da plataforma Arduíno,. Se não for este o caso aconselha-se que , visite a sua página oficial arduino.cc para mais informações. Também partimos do presuposto que o leitor tem conhecimentos básicos cd C++.

Código - 1ª parte - Sensores IR:

Primeiro inicializam-se as constantes com os número dos pinos onde estão conetados os sensores IR respetivamente.

//Constantes referentes aos pinos dos sensores IR.

const int IR1 = 25;

const int IR2 = 26;

const int IR3 = 27;

const int IR4 = 28;

const int IR5 = 29;

const int IR6 = 39;

Depois declaram-se as variáveis que irão guardar as leituras dos sensores, estas variáveis vão mudando de estado conforme é atualizada a leitura. Chamamos estas variáveis de variáveis de estado.

//Variaveis referentes ao estado dos sensores IR.

int stateIR1, stateIR2, stateIR3, stateIR4, stateIR5, stateIR6;

Implementa-se um função (boa prática) para atualizar as variáveis de estado declaradas anteriormente com a leitura digital da porta respetiva a cada um deles.

//Função que atualiza as variaveis de estado dos sensores

void updateIR() {

 stateIR1 = digitalRead(IR1);

 stateIR2 = digitalRead(IR2);

 stateIR3 = digitalRead(IR3);

 stateIR4 = digitalRead(IR4);

 stateIR5 = digitalRead(IR5);

 stateIR6 = digitalRead(IR6);

}

Com é tipico no Arduíno, na função setup(), inicializamos a porta Série, para podermos monitorizar os sensores e os pinos dos sensores.

void setup() {

 //Inicialização da porta serial.

 Serial.begin(115200);

 //Inicializa os pinos dos sensores IR como entrada.

 pinMode(IR1, INPUT);

 pinMode(IR2, INPUT);

 pinMode(IR3, INPUT);

 pinMode(IR4, INPUT);

 pinMode(IR5, INPUT);

 pinMode(IR6, INPUT);

}

Implementamos uma função para enviar para a Porta Série, a informação das variáveis de estado, para podermos monitorizar se os sensores estão a funcionar como esperado.

void printIR(){

Serial.print(stateIR1);

Serial.print(stateIR2);

        Serial.print(stateIR3);

        Serial.print(stateIR4);

        Serial.print(stateIR5);

        Serial.println(stateIR6);

}

Finalmente, na função loop do Arduino, vamos chamar as funções quee criamos para testar esta parte do código. Primeiro chamamos a função updateIR() para atualizar as variavéis de estado, depois chamamos a função printIR() para enviar para a porta série o valor destas mesmas variáveis.

void loop() {

   updateIR();

   printIR();

}

Já temos detenção e já conseguimos saber a posição relativa do robot em relação à linha. 

Código - 2ª parte - Motores:

Primeiro inicializam-se as constantes com os número dos pinos onde estão conetados aos motores. Cada motor tem 2 pinos. Combinando os sinais que metemos nos pinos conseguimos controlar a velocidade (por PWM) e a direção se invertermos os sinais.

//Constantes referentes aos pinos dos motores.

const int MOTOR_RIGTH_PIN1 = 2;

const int MOTOR_RIGTH_PIN2 = 3;

const int MOTOR_LEFT_PIN1  = 4;

const int MOTOR_LEFT_PIN2  = 5;

Posterirmente, na função setup() do Ardduíno, inicializam-se as portas onde estão ligados os pinos dos drivers dos motores para OUTPUT, pois a função destas portas é mandar para o DRIVER um determinado sinal.

 void setup() {

 //Inicialização da porta serial.

 Serial.begin(115200);

 //Inicializa os pinos dos sensores IR como entrada.

 pinMode(IR1, INPUT);

 pinMode(IR2, INPUT);

 pinMode(IR3, INPUT);

 pinMode(IR4, INPUT);

 pinMode(IR5, INPUT);

 pinMode(IR6, INPUT);

 //Inicializa os pinos dos motores como saída.

 pinMode(MOTOR_RIGTH_PIN1, OUTPUT);

 pinMode(MOTOR_RIGTH_PIN2, OUTPUT);

 pinMode(MOTOR_LEFT_PIN1, OUTPUT);

 pinMode(MOTOR_LEFT_PIN2, OUTPUT);

 }

Implementa-se uma função para fazer com que os motores andem para a frente. Anteriormente falamos em portas HIGH e LOW, mas como vamos usar PWM, o sinal LOW será 0 e o HIGH será entre 1 e 255, sendo que de robot para robot temos de testar valores mínimos e máximos. Este valor vai ser passado na função

//função para fazer o robô andar para frente com PWM

void andarFrente(int velocidade){

 analogWrite(MOTOR_RIGTH_PIN1, velocidade);

 analogWrite(MOTOR_RIGTH_PIN2, 0);

 analogWrite(MOTOR_LEFT_PIN1, velocidade);

 analogWrite(MOTOR_LEFT_PIN2, 0);

}

Na função loop() do Arduíno, chamamos a função andarFrente() passando o valor máximo de 255 e apagamos a chamada à função printIR() pois já não precisamos dela, só foi útil para verificar se os sensores estavam a funcionar como era esperado.

Como esta função comunica a baixa velocidade, via porta Série, mantermos a função iria fazer com o ciclo de repetição do programa fosse mais lento o que iria ter repercussões no efeito do PWM.

void loop() {

   updateIR();

   andarFrente(255);

}

Após descarregar o código para o robot, verificamos que temos rotação em ambas as rodas (ver animação 1).

Código - 3ª parte - Direita / Esquerda:

Agora vamos alterar a implementação da nossa função andarFrente() para que admita uma velocidade para cada roda de forma independente e vamos alterar o nome para movimentaRobot().

Repare que ela agora admite 2 parâmetros, a velocidade da roda direita e a da esquerda. Manipulando estes valores conseguimos fazer o carro mover-se para a direita e para a esquerda, aumentando e/ou diminuido a velocidade de rotação das rodas.

//função para fazer o robot virar para a direita ou esquerda

void movimentaRobot(int velocidade_roda_direita, int velocidade_roda_esquerda){

   analogWrite(MOTOR_RIGTH_PIN1, velocidade_roda_direita);

   analogWrite(MOTOR_RIGTH_PIN2, LOW);

   analogWrite(MOTOR_LEFT_PIN1, velocidade_roda_esquerda);

   analogWrite(MOTOR_LEFT_PIN2, LOW);

}

Código - 4ª parte - Correção de rota:

Agora vamos implementar a função segueLinha() que irá avaliar o estado dos sensores e corrigir a rota compensando na velocidade dos motores. 

//Função para fazer o robot corrigir a trajetória mediante leitura dos sensores

void segueLinha(){

   //Todos os sensores fora da linha o robot pára

   if(stateIR1 == 0 && stateIR2 == 0 && stateIR3 == 0 && stateIR4 == 0 && stateIR5 == 0 && stateIR6 == 0){

       movimentaRobot(0,0);

   }

   //Todos os sensores na linha o robot pára

   else if(stateIR1 == 1 && stateIR2 == 1 && stateIR3 == 1 && stateIR4 == 1 && stateIR5 == 1 && stateIR6 == 1){

       movimentaRobot(0,0);

   }

   //Os sensores centrais na linha o robot avança (velocidade igual nas duas rodas)

   else if(stateIR3 == 1 && stateIR4 == 1){

       movimentaRobot(100,100);

   }

   //Um desvio ligeiro para a esquerda é dada uma ligeira compensação para a direita, acelerando a roda esquerda

   else if(stateIR2 == 1 && stateIR3 == 1 ){

       movimentaRobot(0,100);

   }

   //Um desvio acentuado para a esquerda é dada uma acentuada compensação para a direita, acelerando a roda esquerda mais

   else if(stateIR1 == 1 && stateIR2 == 1){

       movimentaRobot(0,180);

   }

   //Um desvio ligeiro para a direita é dada uma ligeira compensação para a esquerda, acelerando a roda direita

   else if(stateIR4 == 1 && stateIR5 == 1){

       movimentaRobot(100,0);

   }

   //Um desvio acentuado para a direita é dada uma ligeira compensação para a direita, acelerando a roda direita

   else if(stateIR5 == 1 && stateIR6 == 1){

       movimentaRobot(180,0);

   }

}

Agora chamamos a nossa função no função loop() do Arduíno:

void loop() {

   updateIR();

   segueLinha();

}

E o nosso robot está pronto para ser testado!

Os valores passados na função movimentaRobot(), no caso variaram entre 100 e 180, são obtidos por experimentação. Como referido mais acima estes valores dependem de muitos factores, tais como tipo de motores, tipo de engrenagem, peso do robot, tensão de alimentação, entre outros.

O programa foi desenvolvido da forma mais simples possível par o efeito. Para um projeto mais "sério" deverão ser aplicados conceitos avançados de programação, tais como o uso de classes, objetos, enums, etc.