Robo de equilibrio (SEGWAY)

Ola galera estou projetando para TCC da faculdade um robo de equilibrio semelhante o funcionamento do segway...

no blog é :

projetosegway

implementei o PID basico, mas só consigo fazer funcionar um motor quando coloco o outro no programa ele não funciona os dois...

estou usando:

-acelerometro MMA7361

-Ponte H L298

-arduino mega

-prototype shild mega

no PID output, com 1 motor (motor1) ele controla dependendo da posição do angulo de inclinação (normal)

Input = analogRead(A0);
myPID.Compute();
analogWrite(11,Output);  // reverso
analogWrite(10,Output);  // frente

Mas com os dois motores(MOTOR 1 E 2) ele não funciona nenhum dos dois qdo varia a inclinação

Input = analogRead(A0);
myPID.Compute();
analogWrite(11,Output);  //reverso motor1
analogWrite(10,Output);  //frente motor 1

analogWrite(9,Output);  //reverso motor2
analogWrite(8,Output);  //frente motor2

oq pode ser...

Exibições: 4558

Anexos

▶ Responder esta

Respostas a este tópico

Permalink Responder até Leandro Bernardino em 25 outubro 2013 at 11:34

sou novo na programação em C, começei prticamente à 4 meses

Permalink Responder até Jonatas Freitas em 25 outubro 2013 at 16:49

Com o robo suspenso (sem encostar as rodas no chão) funciona?

Permalink Responder até Leandro Bernardino em 25 outubro 2013 at 17:23

Olá Jonatas..

com os dois motores no codigo não funciona...

e tem outra, estou mandando o motor 1 acionar o sentido de rotação pelas portas analogica 11 e 10, mas ele esta acionando nas portas 8 e 9...rs, q coisa...

Permalink Responder até Jonatas Freitas em 25 outubro 2013 at 17:55

O funcionamento desse robô era outro...

Nesse caso era o controle com base em um encoder incremental.

mas vê se te inspira em algo:

[...]

   Setpoint = y;  //carrega o setpoint
    Input = position; //Le a posição atual do Encoder
    myPID.Compute(); //calcula o PID

    Serial.print(Output);
    Serial.print(" - ");
    Serial.println(position);

    // acionamento dos polos do motor
    if ( position > y ){
      analogWrite(5,Output);
      digitalWrite (6, LOW);
       }
    else {
      if ( position < y){
        analogWrite(6,Output);
        digitalWrite (5, LOW);
      }
      else{ //trava motor
        digitalWrite (5, HIGH);
        digitalWrite (6, HIGH);
      }
    }
  [...]

Permalink Responder até Daniel (OráculoX) em 25 outubro 2013 at 17:00

 Olá Leandro.

 Ficou bem legal a sua montagem, parabéns.

 Não sei qual o material de controle você está utilizando como base para o seu projeto, mas uma teoria que se aplicaria legal é aquela do "pendulo invertido". Daria para você "dar alguns tapas" no seu robo e ele voltar a estabilizar o equilíbrio. Provavelmente é esta a idéia, além do deslocamento. Dai teria-se que pensar no controle de velocidade, etc...

 Vendo sua dúvida: pelo que percebi o setup seria:

 (1) Motor_1 = pinos 11 e 10.

 (2) Motor_2 = pinos 9 e 8.

 Baseando-se em outro artigo de alguns colegas aqui do fórum.:

 http://labdegaragem.com/profiles/blogs/artigo-controlador-pid-propo...

 

Outro Artigo Legal:

[Link]

 Penso que você terá que criar duas instâncias do controle PID. Ou seja, sua instância "my.PID" terá que ser duas. Uma para cada motor. Tendo algo parecido com:

/********************************************************
* PID Basic Example
* Reading analog input 0 to control analog PWM output 3 / MOTOR_1

* Reading analog input 1 to control analog PWM output 4 / MOTOR_2
********************************************************/

#include <PID_v1.h>

//Define Variables we'll be connecting to
double Setpoint_M1, Input_M1, Output_M1;

double Setpoint_M2, Input_M2, Output_M2;

//Specify the links and initial tuning parameters
PID myPID_M1(&Input_M1, &Output_M1, &Setpoint_M1,2,5,1, DIRECT);

PID myPID_M2(&Input_M2, &Output_M2, &Setpoint_M2,2,5,1, DIRECT);  //<- dependendo do lado do fio, inverta, pois os motores estao em posicoes opostas de rotacao.

void setup()
{
//initialize the variables we're linked to
Input_M1 = analogRead(0);

Input_M2 = analogRead(1);

// Aqui talvez precise de um ajuste de escala


Setpoint_M1 = 100;

Setpoint_M2 = 100;

//turn the PID on
myPID_M1.SetMode(AUTOMATIC);

myPID_M2.SetMode(AUTOMATIC);


}

void loop()
{

// Feedback
Input_M1 = analogRead(0);

Input_M2 = analogRead(1);

//se precisar ajustar a escala de leitura neste ponto, use a funcao "map".


myPID_M1.Compute();

myPID_M2.Compute();

//Output do PWM motor 1
analogWrite(3,Output);

//Output do PWM motor 2

analogWrite(4,Output);


}

Acho que é isso. É uma idéia que poderá utilizar para se basear no uso da biblioteca, e certamente precisa ser otimizada.

Espero ter ajudado.

Daniel C.

Permalink Responder até Daniel (OráculoX) em 25 outubro 2013 at 17:19

 Agora pensando um pouco mais, podem ter algumas coisas a serem analisadas.

 Caso seja possível, poste para nós o seu esquema elétrico com a ponte H e a ligação com os motores. Pode ser que a solução seja mais fácil olhando ele.

 Até mais.

Permalink Responder até Leandro Bernardino em 25 outubro 2013 at 17:43

Olá Daniel,

Isso mesmo estou fazendo um robô auto estabilizável, baseado no pendulo invertido mesmo, estamos trocando este motor por um mais preciso 1:30 / 300RPM.

Vou tentar oq vc passou, eu estava tentando apenas com um PID, talvez esse seje o problema...

te dou o retorno...vlw

Permalink Responder até Leandro Bernardino em 25 outubro 2013 at 17:45

vou postar o codigo aqui, daqui a pouco...

Permalink Responder até Leandro Bernardino em 25 outubro 2013 at 18:36

CODIGO do robo e esquema de ligação do motor:

#include <PID_v1.h>

int maxi = 0,mini = 1023;
int IN1 = 11;
int IN2 = 10;
int IN3 = 9;
int IN4 = 8;
int Velocidade = 0;

int sensorX = 0;

//Define Variables we'll be connecting to
double Setpoint, Input, Output;

//Specify the links and initial tuning parameters
PID myPID(&Input, &Output, &Setpoint,2,5,1, DIRECT);

void setup() {

Serial.begin(9600);

//initialize the variables we're linked to
Input = sensorX;   
Setpoint = 0;   //angulo zero

//turn the PID on
myPID.SetMode(AUTOMATIC);
}

void loop() {
int sensorX= analogRead(A0);


//Para melhorar a precisão execute uma calibragem e altere os valores da funcao abaixo para o eixo X
sensorX = map(sensorX, 493, 155, 90, -90);
Serial.print(" Angulo X = ");
Serial.println(sensorX);

delay(600);

if ( sensorX > 1) //controla o motor frente  //mais q 1 grau para frente
{
Velocidade = sensorX * 3;
analogWrite(IN1,0);
analogWrite(IN2,Velocidade);

analogWrite(IN3,0);
analogWrite(IN4,Velocidade);

}
else if ( sensorX < -1) //controla o motor reverso  //-1 grau para traz
{
Velocidade = sensorX * -3;
analogWrite(IN1,Velocidade);
analogWrite(IN2,0);

analogWrite(IN3,Velocidade);
analogWrite(IN4,0);

}
Input = analogRead(0);
myPID.Compute();

//motor1
analogWrite(11,Output);  

analogWrite(10,Output);

//motor2

analogWrite(9,Output);

analogWrite(8,Output);

}

Anexos
Permalink Responder até Daniel (OráculoX) em 28 outubro 2013 at 17:21

Olá Leandro, não abandonei a ajuda não. rs

Estava montando uma planta simulada, mas o simulador não está ajudando, embora tenha conseguido algum controle com algumas bibliotecas para o Arduino.

Queria saber, o controle será feito apenas com o feedback do acelerômetro? Ou você tem algo para informar a posição do motor ( potênciometro) ou o deslocamento forçado ( corrente do motor) ?

Isso pode dar mais opções para o controle.

Até mais.

Permalink Responder até Leandro Bernardino em 29 outubro 2013 at 11:47

ola Daniel,

obrigado por querer ajudar

tive uma ajuda do jonatas também, o codigo funcionou, mas ainda falta ajuste no PID, pois ee ainda não se equilibra sozinho. vou mandar o codigo q estou usando...

#include <PID_v1.h>

int maxi = 0,mini = 1023;
int IN1 = 11;
int IN2 = 10;
int IN3 = 9;
int IN4 = 8;
//int Velocidade = 0;

int sensorX = 0;

//Define Variables we'll be connecting to
double Setpoint, Input, Output;

//Specify the links and initial tuning parameters
PID myPID(&Input, &Output, &Setpoint,8,20,500, DIRECT);

void setup() {

Serial.begin(9600);

//initialize the variables we're linked to
Input = sensorX;
Setpoint = 0; //angulo zero

//turn the PID on
myPID.SetMode(AUTOMATIC);
}

void loop() {
int sensorX= analogRead(A0);
Input = sensorX;

//Para melhorar a precisão execute uma calibragem e altere os valores da funcao abaixo para o eixo X
sensorX = map(sensorX, 493, 155, 90, -90);
Serial.print(" Angulo X = ");
Serial.println(sensorX);

Input = analogRead(A0);
myPID.Compute();
//delay(40);
if ( sensorX > 1) //controla o motor frente //mais q 1 grau para frente
{
analogWrite(IN1,0);
analogWrite(IN2,Output);

analogWrite(IN3,0);
analogWrite(IN4,Output);

}
else if ( sensorX < -1) //controla o motor reverso //-1 grau para traz
{
analogWrite(IN1,Output);
analogWrite(IN2,0);

analogWrite(IN3,Output);
analogWrite(IN4,0);

}
}

a resposta esta meio lenta ainda e o robo cai ainda...mas parece o caminho esse...

agradeço  por querer me ajudar ainda....tamo ai...

Permalink Responder até Mauro Assis em 29 outubro 2013 at 14:39

Leandro,

Parabéns pelo trabalho. Se estiver interessado em teoria e algumas outras aplicaões sobre PID, no meu blog tem: http://automatobr.blogspot.com.br. Lá vc pode ver como ajustar as constantes do PID, que certamente vão acertar a performance do seu robô.

RSS

Destaques

Registre-se no Lab de Garagem
clicando aqui

Convide um amigo para fazer parte

curso gratis de arduino

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço