O objetivo deste projeto é construir um robô seguidor de linha com controle PID. Também usaremos um dispositivo Android para mais facilmente poder configurar os principais parâmetros (ganhos) da malha de controle.
Abaixo um vídeo que mostra o robô a seguindo um circuito básico:
A lista de materiais necessários é muito simples e o robô final é muito barato (cerca de US$ 75,00):
Para os motores, utilizei 2 servos em modo contínuo (SM-S4303R). Eles devem ser “colados”, formando um único e sólido bloco como você pode ver na foto (use a fita 3M Command, cola ou fita dupla face). Esses servos girarão a uma dada velocidade dependendo da largura do pulso que receba em sua entrada de dados. Para este servo específico, a largura do pulso varia de 1.0 ms a 2.0ms (outros tipos de servos podem trabalhar com larguras de pulso diferentes).
Olhando em detalhes:
A primeira coisa que se deve fazer, é enviar um pulso de 1.5ms (1500us) para verificar se os motores ficam realmente”parados”. Caso isto não ocorra, os servosdevem ser ajustados (procure o parafuso amarelo, na lateral do servo). É claro que se o seu servo não possui esse ajuste, tente alterar o valor “1500ms” até obter o ponto final.
Monte o Arduino e os servos como mostrado abaixo:
O código abaixo, para o Arduino deve ser usado para o ajuste:
#include Servo // este código linha deve ser mudado, por favor, olhe o código anexado
Servo leftServo;
Servo rightServo;
void setup ()
{
leftServo.attach (5);
rightServo.attach (3);
leftServo.writeMicroseconds (1500);
rightServo.writeMicroseconds (1500);
}
void loop ()
{
}
1. Com a fita 3M Command, fixar os 2 Servos à uma das peças de madeira quadrado.
2. Fixar o segundo quadrado de madeira ao anterior, utilizando os grampos de papel. Ajuste o comprimento da plataforma para suas necessidades.
3. Fixe o caster utilizando-se o grampo de papel.
4. A alimentação para os motores será fornecida por um dos conjuntos de baterias (5V). Este conjunto de baterias será instalado entre o protoboard e a plataforma do corpo.
5. Conecte a bateria a ser utilizada com os servos: deixe uma linha de alimentação lateral do protoboard exclusivamente para os servos
6. Conecte o Arduino Nano ao protoboard
7. Conecte os terras do Protoboard ao GND do Arduino.
8. Conecte os Servos ao Arduino: LEFT => Pin 5; RIGHT => Pin 3
9. Ligue o LED ao Arduino Pino 13
10. Ligue o botão para Arduino Pin 9
Note que, devido a maneira com que os servos estão montados (em oposição) as faixa de variação de velocidade em função da largura de pulso são diferentes:
Um LED externo é adicionar ao pin13, com finalidade de sinalização e testes (você pode usar o LED interno do Arduino se quiser, mas leve em consideração que será difícil de vê-lo no meio dos cabos).
Além disso, um botão é ligado ao pino 9. Este botão será muito útil para testes e para o comando de início, quando o robô estiver posicionado no início do circuito de linha.
Por exemplo:
while (digitalRead (buttonPin)) {}
motorTurn (LEFT, 500);
motorTurn (RIGHT, 500);
Note que as 2 linhas que irão comandar o robô para virar à esquerda, esperar 500ms e virar à direita, só serão executadas depois que você pressionar o botão (buttonPin = 0). Antes disso, o programa ficará executando um “loop infinito”.
O código Motor_Test.ino, disponível no final deste tutorial, poderá ser usado como uma base para um teste de motores mais completo (para frente, para trás, parada completa, virar à esquerda, virar à direita). Se necessário você deverá ajustar os atrasos (“delays”) para obter um ângulo de virada correto.. Também, dependendo de seus motores, os valores definidos para a largura de pulso devem ser um pouco diferentes para compensar qualquer falta de alinhamento entre os mesmos.
O módulo Bluetooth HC-06 deverá ser instalado no protoboard. A biblioteca SoftSerial do Arduino será utilizada.
Abaixo as conexões de pino HC-06:
O robô funcionará com ou sem o módulo Bluetooth. O código será construído de uma maneira que caso você não ative o BT, os parâmetros utilizados serão os padrões. Na última parte deste tutorial, vou explorar como usar um aplicativo Android para enviar dados para um melhor ajuste dos parâmetros do robô e mover-lo em modo manual. O uso da App Android é um opcional no caso que alguém deseje explorar mais o uso de um Robô seguidor de linha em competições, por exemplo.

1. Fixe os 5 sensores em uma barra de plástico, como mostrado nas fotos
2. É aconselhável para rotular os sensores para fins de teste. O nome sensores vai de de “0” (mais à esquerda) para “4” (mais à direita)
3. Passe os cabos sob o quadro, usando os elásticos para corrigi-los (tome cuidado para não misturar-se com as rodas ou Caster.
4. Conecte os cabos de pinos do Arduino, como abaixo:
5. Fixe o segundo conjunto de baterias 5V e conecte ao pino Vin do Arduino.
Em meu caso, estou usando um módulo com 4 sensores integrados + 1 extra. Todos são compatíveis. Para simplificar, no diagrama abaixo, I inclui 5 sensores individuais conectados juntos. O resultado final é o mesmo em ambas as configurações.
Cada sensor é constituído por um LED e um fotodiodo, ambos infravermelhos. A luz emitida pelo LED atinge a superfície e é reflectida de volta para o fotodiodo. O fotodiodo em seguida, gera uma tensão de saída proporcional à reflectância da superfície.
No caso dos sensores utilizados, um circuito integrado no módulo gera um sinal de saída digital simples (ALTO: escuro; BAIXO: Luz). Um potenciômetro instalado no módulo (ver foto) irá ajustar o nível correto de luz para ser considerada “dark” ou não. Quando a luz reflectida é considerada “escura”, a saída fica ALTA ( “1”) e BAIXA ( “0”) para outra cor mais clara. Eu usei aqui um módulo integrado com 4 sensores e e módulo extra com um sensor único (forma diferente, mas mesma lógica). A combinação é uma matriz de 5 sensores que eu considero apropriado para este tipo de controle, como explicado abaixo.
A matriz de 5 sensores é montada de forma que, se apenas um sensor está centrado em relação à linha preta, ele irá produzir um “1”.
Por outro lado, o espaço entre os sensores devem ser calculados para permitir que 2 sensores possam cobrir a largura total da linha preta simultaneamente,também produzindo assim um “1” em ambos os sensores (ver os quadros aqui).
As possíveis combinações de saída do conjunto de sensores são:
Trabalhar com 5 sensores, permite a geração de uma “variável de erro” que ajudará a controlar a posição do robô sobre a linha, como mostrado abaixo:
Vamos considerar que a condição ideal é quando o robô está centrado, tendo a linha apenas abaixo do “sensor do meio” (Sensor 2). A saída da matriz será: 0 0 1 0 0 e nesta situação, o “erro” será “zero”.
Se o robô começa a derivar para a esquerda (a linha “parece mover-se” para a direita) o erro deverá aumentar e com um sinal positivo. Se o robô começar a mover-se para a direita (a linha” parece mover-se “para a esquerda), da mesma maneira, o erro tem de aumentar, mas agora com um sinal negativo.
A variável de erro, relacionada com o estado do sensor será:
Olhando o código Arduino, cada um dos sensores será definido com um nome específico (considere que o Sensor mais à esquerda deve ser atribuído com uma etiqueta de “0”):
const int lineFollowSensor0 = 12;
const int lineFollowSensor1 = 18;
const int lineFollowSensor2 = 17;
const int lineFollowSensor3 = 16;
const int lineFollowSensor4 = 19;
A fim de armazenar os valores de cada um dos sensores uma variável tipo Array será criada:
int LFSensor [5] = {0, 0, 0, 0, 0};
Cada posição da matriz irá ser constantemente actualizada com a saída de cada um dos sensores:
LFSensor [0] = digitalRead (lineFollowSensor0);
LFSensor [1] = digitalRead (lineFollowSensor1);
LFSensor [2] = digitalRead (lineFollowSensor2);
LFSensor [3] = digitalRead (lineFollowSensor3);
LFSensor [4] = digitalRead (lineFollowSensor4);
Uma vez armazenado o valor de cada um dos sensores, uma lógica deve ser implementada para gerar a variável de erro:
if (( LFSensor [0] == 0) && (LFSensor [1] == 0) && (LFSensor [2] == 0) && (LFSensor [3] == 0) && (LFSensor [4] == 1 )) erro = 4;
else if ((LFSensor [0] == 0) && (LFSensor [1] == 0) && (LFSensor [2] == 0) && (LFSensor [3] == 1) && (LFSensor [4] == 1)) erro = 3;
else if ((LFSensor [0] == 0) && (LFSensor [1] == 0) && (LFSensor [2] == 0) && (LFSensor [3] == 1) && (LFSensor [4] == 0)) erro = 2;
else if ((LFSensor [0] == 0) && (LFSensor [1] == 0) && (LFSensor [2] == 1) && (LFSensor [3] == 1) && (LFSensor [4] == 0)) erro = 1;
else if ((LFSensor [0] == 0) && (LFSensor [1] == 0) && (LFSensor [2] == 1) && (LFSensor [3] == 0) && (LFSensor [4] == 0)) erro = 0;
else if ((LFSensor [0] == 0) && (LFSensor [1] == 1) && (LFSensor [2] == 1) && (LFSensor [3] == 0) && (LFSensor [4] == 0)) erro = - 1;
else if ((LFSensor [0] == 0) && (LFSensor [1] == 1) && (LFSensor [2] == 0) && (LFSensor [3] == 0) && (LFSensor [4] == 0)) erro = -2;
else if ((LFSensor [0] == 1) && (LFSensor [1] == 1) && (LFSensor [2] == 0) && (LFSensor [3] == 0) && (LFSensor [4] == 0)) erro = -3;
else if ((LFSensor [0] == 1) && (LFSensor [1] == 0) && (LFSensor [2] == 0) && (LFSensor [3] == 0) && (LFSensor [4] == 0)) erro = -4;
Perfeito! Neste ponto, o robô está montado e operacional. Você deve aproveitar e executar alguns testes básicos com os motores, ler a saída de sensores e testá-los através de uma linha. O que está faltando ainda, é o verdadeiro “cérebro”, ou seja fazer o Robô executar a tarefa de “andar na linha” por seus próprios meios. Vamos conseguir isso, através da implementação de uma lógica de controle que garantirá ao robô seguir uma linha, seja qual for o desenho.
Suponha que o robô esteja “andando” sobre uma linha e a saída do Array de Sensores é: “0 0 1 0 0”. Neste caso, o erro correspondente é “0” e ambos os motores estarão empurrando o robô para a frente com uma velocidade constante. Um código para essa condição seria:
rightServo.writeMicroseconds (1500 + iniMotorPower);
leftServo.writeMicroseconds (1500 - iniMotorPower);
Por exemplo, com iniMotorSpeed = 250, significa que "LEFT" Servo receberá pulsos de 1250us e o "RIGHT" Servo 1750us, o que fará com que o robô avance com metade de sua velocidade máxima. Lembre-se que a velocidade de avanço do Servo direito irá variar com larguras de pulso que variam de 1500us (parado) a 2000us (velocidade máxima) e o Servo esquerdo de 1500us (parado) a 1000us (velocidade máxima).
Suponha agora que o robô comece a derivar para a esquerda ( a “linha vai para a direita”), fazendo com que o sensor 3 também, fique sobre a linha. Neste caso, a saída do Array de sensores será: “0 0 1 1 0” e o erro = 1. Nesta situação, o que necessitamos é virar o robô para a direita. Para fazer isso, devemos diminuir a velocidade do Servo direito o que significa diminuir a largura do pulso. Além disso, a velocidade do Servo esquerdo deve aumentar, o que significa diminuir a largura do pulso. Para isso, precisamos alterar a função de controle do motor:
rightServo.writeMicroseconds (1500 + iniMotorPower - erro); // Erro positivo: velocidade diminue leftServo.writeMicroseconds (1500 - iniMotorPower - erro); //Erro positivo: velocidade aumenta
A lógica acima é correcta, mas é fácil compreender que a adição ou subtracção de apenas “1” microssegundo na duração dos pulsos não irá gerar a correcção necessária, ao menos em um tempo realista. É intuitivo que o número a se adicionar ou subtrair deve ser maior, por exemplo, 50, 100, etc. Para conseguir isso, o “erro” deve ser multiplicado por uma constante “K”. Uma vez que a influência dessa constante será proporcional ao erro, vamos chamar-la “Constante proporcional: Kp. No meu caso, testei o robô com uma constante Kp=50 e ele funcionou muito bem.
A função final para os motores será:
int Kp = 50;
rightServo.writeMicroseconds (1500 + iniMotorPower - Kp * erro);
leftServo.writeMicroseconds (1500 - iniMotorPower - Kp * erro);
Podemos resumir o que acontecerá com os motores, como mostrado abaixo:
Se a situação é o oposto e o robô vai para a direita, o erro seria “negativo” e a velocidade dos servos deve mudar:
Neste ponto fica claro que quanto mais o robô “escorregue” para um lado, maior será o erro (1, 2, 3 ou 4) e mais rápido ele deve retornar ao centro (valores a serem adicionados a largura do pulso: 50, 100, 150, 200). A velocidade com que o robô irá reagir ao erro será proporcional ao mesmo.
Controle PID (Proporcional, Derivativo e Integral) é um dos sistemas de controle mais comuns que existem. A maioria dos sistemas de controle industriais utilizam algum tipo do controle PID. Há muitas maneiras de ajustar uma malha PID, incluindo a técnica “tentativa e erro”, que é a que usaremos nesse projeto.
Pense no PID como uma mola simples. Uma mola tem um comprimento original (setpoint), que quando perturbada, pela expansão ou contração, tende a recuperar o seu comprimento original no menor tempo possível. Controladores PID são utilizados onde quer que haja a necessidade de controlar uma quantidade física e a torná-la igual a um valor pré-especificado. Por exemplo, controlador de velocidade em carros, robôs, reguladores de temperatura, reguladores de tensão, etc.
Como o PID funciona?
O sistema calcula o “erro” ou “desvio” da
quantidade física em relação ao set point, medindo o valor atual dessa quantidade física usando um sensor. Para voltar ao set point, este “erro” deve ser minimizado, idealmente igual a zero. Além disso, esse processo deve ocorrer o mais rapidamente possível (também idealmente esse tempo deveria ser zero).
Para mais informações, acesse: http://en.wikipedia.org/wiki/PID_controller
Implementando PID
Equação:
PIDvalue = (Kp * P) + (Ki * I) + (Kd * D)
Onde:
Uma abordagem para a obtenção das constantes é deixar Ki de fora e trabalhar com o Controle PD (manter Ki = 0); definir a variável Kd como 0 e sintonizar o termo Kp sozinho pela primeira vez. Kp de 25 é um bom lugar para começar no nosso caso aqui e ir subindo seu valor. Na última etapa foi utilizado um Kp de 50 que funciona muito bem com meu robô. Se o robô reagir muito lentamente, voce deve aumentar o valor. Se o robô parece reagir muito rapidamente tornando-se instável, diminua o valor. Uma vez que o robô responda razoavelmente, sintonize a parte derivativa da malha de controle. Primeiro defina o valor Kp e Kd cada um para a 1/2 do valor Kp. Por exemplo, se a resposta do robô é razoável com um Kp = 50, definir Kp = 25 e Kd = 25 para iniciar. Aumente o ganho de Kd para diminuir o “overshoot ou o diminua se o robô se tornar instável.
Um outro componente do loop a ser considerado é a taxa real de amostra / loop. Acelerar-la ou para retardar-la pode fazer uma diferença significativa no desempenho do robô. Isso é definido pelas declarações de “Delay” que você tem em seu código. Use o método tentativa-erro para obter o melhor resultado.
Com base na abordagem anterior, implementamos a função abaixo:
void calculatePID ()
{
P = error;
I = I + error;
D = error - previousError;
PIDvalue = (Kp * P) + (Ki * I) + (Kd * D);
previousError = error;
}
A constante Kp simples usada na última etapa será substituída agora por PIDvalue, mais completa:
void motorPIDcontrol ()
{
int leftMotorSpeed = 1500 - iniMotorPower - PIDvalue;
int rightMotorSpeed = 1500 + iniMotorPower - PIDvalue;
leftServo.writeMicroseconds (leftMotorSpeed);
rightServo.writeMicroseconds (rightMotorSpeed);
}
Mas note que se você tem Kd e Ki = 0, PIDvalue = Kp * error, exatamente como na etapa anterior onde usamos só o controle Proporcional.
Neste ponto do projeto, o robô já pode seguir sem parar um circuito de linha do tipo “loop constante”.
A função Loop do programa de ciclo seria simplesmente:
void loop ()
{
readLFSsensors (); // Ler sensores, armazenar os valores no Array de sensores e calcular o "erro"
calculatePID ();
motorPIDcontrol ();
}
Mas, para uma operação mais completa e real, é importante acrescentar, pelo menos um par de “comandos básicos de linha”.
Por exemplo, vamos introduzir uma nova variável: "mode", definindo 3 estados para esta variável:
#define STOPPED 0
#define FOLLOWING_LINE 1
#define NO_LINE 2
Se todos os sensores de encontrar uma linha preta, a saída do Array de Sensor seria: 1 1 1 1 1. Nesta condição, podemos definir o modo como “PARADO” e o robô deve realizar um “Full Stop”.
if ((LFSensor [0] == 1) && (LFSensor [1] == 1) && (LFSensor [2] == 1) && (LFSensor [3] == 1) && (LFSensor [4] == 1 )) {mode = STOPPED;}
Outra situação comum com robôs seguidores de linha, é quando o mesmo não encontra “nenhuma linha”, ou a saída do Array de Sensores é: 0 0 0 0 0. Neste caso, podemos programá-lo para girar 180 graus (ou girar em ângulos pequenos até que uma linha é encontrada e a condição normal FOLLOWING_LINE é retomada.
else if ((LFSensor [0] == 0) && (LFSensor [1] == 0) && (LFSensor [2] == 0) && (LFSensor [3] == 0) && (LFSensor [4] == 0)) {mode = NO_LINE;)
A função loop completa seria:
void loop ()
{
readLFSsensors ();
switch (mode)
{
case STOPPED:
motorStop();
break;
case NO_LINE:
motorStop ();
motorTurn (LEFT, 180);
break;
case FOLLOWING_LINE:
calculatePID ();
motorPIDcontrol ();
break;
}
}
O código final incluirá integrar lógica adicional e também algumas variáveis devem ser inicializadas, etc. Durante as explicações , deixei estes detalhes de fora para simplificar a explicação, mas acredito que tudo fique claro dando uma olhada no código final.
No código do Arduino, você poderá encontrar no arquivo “robotDefines.h” as seguintes definições para as constantes “default” serem usadas com o controle PID.
float Kp = 50;
float Ki = 0;
float Kd = 0;
Como explicado anteriormente, a melhor maneira de definir os ganhos corretos (Constantes Kd, Ki e Kd) é usar a metodologia “Tentativa-e-erro”. O lado ruim disso é que você deve re-compilar o programa a cada vez que você defina uma constante nova. Uma maneira de acelerar o processo é usar o App Android para enviar as constantes na fase de setup do programa.
Eu desenvolvi um aplicativo Android exclusivamente para isso:
o MJRoBot Line Follower PID Control
Em resumo o aplicativo possui:
No final deste tutorial, você encontrará o arquivo .aia que pode ser modificado no MIT AppInventor e o arquivo .apk para ser instalado diretamente no seu dispositivo Android.
Durante a fase de setup do programa, introduziremos um “loop” onde você poderá enviar os parâmetros PID para o robô antes de colocá-lo sobre a linha.
No vídeo, você pode ver alguns testes usando o App Android:
Abaixo o código final para o robô:
Este é o primeiro tutorial de um projeto mais complexo, explorando a potencialidade de um robô seguidor de linha. No próximo tutorial, desenvolverei um robô com habilidade para resolver um labirinto, ou seja não só encontrar o caminho de saída, mas também qual seria o caminho mais curto e rápido.
Aproveito também a pedir a vocês, amigos garagistas que façam uma visita a meu post no Instructables.com abaixo e se gostarem, que votem no tutorial, que está concorrendo ao "Contest Robotics" (é só clicar na bandeirinha laranja no canto superior direito da página). Muito Obrigado.
Votar em: Line Follower Robot - PID Control - Android Setup
Espero que esse trabalho possa contribuir para que outras pessoas possam aprender mais sobre eletrônica, robôs, Arduino, etc.
Um abraço e até o próximo post!
Obrigado
Comentar
Marcelo, estou com dificuldades no pid com a shied l293d
Marcelo, já montei todo o robo, mas tenho uma dúvida, os motores vao de 0 a 255 (PWM), onde 0 é parado e 255 rotação máxima, então eu quero iniciar o motor em 150 e faço algo como abaixo:
int initMotorPower = 50;
int leftMotorSpeed = 100 - iniMotorPower - PIDvalue;
int rightMotorSpeed = 100 + iniMotorPower*adj - PIDvalue;
Quando o PID está em 0.00, o LEFT está em 50 e o RIGHT em 150, é nesse ponto que não entendi, pois eles deveriam rodar na mesma rotação.. nao? E quando estou com o array {0,0,0,1,1}, ele está dando valores negativos?
Marcelo, vou usar o driver Motor Ponte H L298N para os motores, ja o array de sensores estou fazendo utilizando o sensor tcrt 5000 e soldando na mão mesmo, vou precisar da sua ajuda na implementação do PID, na sexta feira estará todo o equipamento em mãos e vou iniciar. Grato Atenciosamente.
Marcelo, posso usar motor dc de 5v ao inves do servo e mesmo assim configurar PID?
Pode ser que o Dropbox esteja com problemas. Você também pode baixar os arquivos de meu post no Instructables. Vá até o final do post no link abaixo e poderá baixar os arquivos individualmante.
Line Follower Robot - PID Control - Android Setup
Um abraço
Bem-vindo a
Laboratorio de Garagem (arduino, eletrônica, robotica, hacking)
© 2024 Criado por Marcelo Rodrigues. Ativado por
Você precisa ser um membro de Laboratorio de Garagem (arduino, eletrônica, robotica, hacking) para adicionar comentários!
Entrar em Laboratorio de Garagem (arduino, eletrônica, robotica, hacking)