LusoRobótica - Robótica em Português
Robótica => Projectos de robótica => Tópico iniciado por: henriquecm7 em 17 de Maio de 2013, 01:12
-
Boas pessoal,
Eu estou desenvolvendo um robô que deve seguir uma linha preta, e pensei em fazer o algorítmo PID para um melhor resultado.
Mas estou com uma dúvida, meu seguidor de linha é feito de 2 sensores que ficam externamente à linha, então, na hora que eu tenho que calcular a variavel ERRO do PID, eu estou em dúvida de quais valores colocar como o valor padrão e o valor recebido, já que eu tenho 2 sensores.
-
Boas pessoal,
Eu estou desenvolvendo um robô que deve seguir uma linha preta, e pensei em fazer o algorítmo PID para um melhor resultado.
Mas estou com uma dúvida, meu seguidor de linha é feito de 2 sensores que ficam externamente à linha, então, na hora que eu tenho que calcular a variavel ERRO do PID, eu estou em dúvida de quais valores colocar como o valor padrão e o valor recebido, já que eu tenho 2 sensores.
consegues ver a quantidade de luz reflectida, ou so se é preto ou branco
-
A quantidade de luz.
Preto = 1500
Branco = 120 em média (o valor é pego na calibração)
-
Muito interessado neste tópico. :D
Não sei fazer loops PID.
-
Eu fiz um somente com o P por enquanto, e estou bem satisfeito, mas o código ainda não é bom, por[em funciona.
-
Eu fiz um somente com o P por enquanto, e estou bem satisfeito, mas o código ainda não é bom, por[em funciona.
lembro me de ter andado a procura de como isso funcionava, e cheguei a encontrar um site interessante mt bem explicado como o pdi funciona, tb tinha codigo para arduino, mas a explicação era suficiente para entederes
acho que encontrei o site procurando por "pdi arduino"
edit: http://brettbeauregard.com/blog/2011/04/improving-the-beginners-pid-introduction/ (http://brettbeauregard.com/blog/2011/04/improving-the-beginners-pid-introduction/)
-
Antes de calcular o erro vais ter de calcular a ''distância'' do robot à linha. Diz-me uma coisa, o valor do sensor aumenta de 120 a 1500 conforme o sensor esta afastado da linha e se aproxima desta ate estar totalmente em cima dela? Ou quando o sensor esta meio na linha meio fora o valor e aleatorio?
-
O sensor fora da linha retorna 120, e 100% na linha retorna 1500, e parcialmente vai aumentando de 120 até 1500.
Eu queria saber uma forma mais simples de fazer o PID, por enquanto eu fiz assim:
// pseudo P
/*if(sensorValues[0] > sensorValues[1])
error = calibrateValue - sensorValues[0];
else if(sensorValues[1] > sensorValues[0])
error = calibrateValue - sensorValues[1];*/
if(sensorValues[0] > sensorValues[1])
{
error = calibrateValue - sensorValues[0];
int turn = Kp * error + Kd * (error - last_error);
last_error = error;
m0Speed = map(mSpeed + turn, -622, 762, 50, 100);
m1Speed = map(mSpeed - turn, -622, 762, 50, 100);
}
else
{
error = calibrateValue - sensorValues[1];
int turn = Kp * error + Kd * (error - last_error);
last_error = error;
m0Speed = map(mSpeed - turn, -622, 762, 50, 100);
m1Speed = map(mSpeed + turn, -622, 762, 50, 100);
}
Nesse código estou dependendo do valor de cada sensor, e isso eu quero evitar.
-
Soma/substrai/mete ai uma pequena fórmula que com o robot em cima da linha tens 0, e depois para a esquerda tens um valor negativo, e para a direita tens um valor positivo, assim juntas os dois valores num e torna-se mais simples.
-
Tem aqui um exemplo simples de compreender...
http://www.pololu.com/docs/0J21/7.c (http://www.pololu.com/docs/0J21/7.c)
-
O sensor fora da linha retorna 120, e 100% na linha retorna 1500, e parcialmente vai aumentando de 120 até 1500.
Visto que isto acontece, ia-te dizer para fazeres algo como o senso já referiu. Antes do PID, calculas a distancia do robot à linha. Depois essa distancia é que é usada no PID.
-
Eu pensei nisso, mas achei que seria mais fácil desse jeito que comecei a fazer, mas já que estão dizendo que calculando a posição do robô na linha é mais fácil, então vou fazer.
-
Enfim estou conseguindo fazer o seguidor de linha com PID. Porém ainda não está 100% bom, acho que uns 60%. Ele faz algumas curvas, mas as vezes se perde e passa direto, e não estou conseguindo saber se isso é culpa da Proporcional, do Derivado, ou da Integral.
Estou usando
int mSpeed = 130;
float Kp = 0.105;
float Kd = 0.013;
float Ki = 0.002;
E o código do PID é:
int error = posicao; // -1000 com sensor da esquerda no preto, 0 no meio, 1000 com sensor da direita no preto
I = I + error;
D = error - last_error;
int turn = (Kp * error) + (I * Ki) + (D * Kd);
last_error = error;
if (error < 20)
I = 0;
Estou fazendo algo de errado, ou tenho que mudar algumas das proporcionais? Sabem qual?
-
Isso está a ser executado num intervalo de tempo constante, ou foi atirar para o loop e siga?
-
Num loop mesmo, estou programando no arduino, e não estou colocando delay, para ser algo seguido.
-
Nem tens de colocar delay, olha para o exemplo blinky without delay, não deves andar a executar o PID sem aplicar os novos valores de pwm nos motores, nem precisas de ter o pid a correr a centenas de Khz porque vai-te criar oscilações no sistema, o teu KP parece-me estranhamente pequeno.
-
Então eu tenho que aumentar o kp?
-
O melhor para afinar isso é imprimir os valores dos sensores, do pid, dos pwm gerados para o pc via serial e meter esses dados a gerar gráficos, para teres uma ideia de como ele se comporta e porque é que falha.
-
Sim, vou fazer isso para tentar achar qual é a causa do robô sair da linha em uma curva brusca.