Aprender

Um robô autoequilibrante em um Arduino

Avançado

Ou veja todas as aulas.

  • 526componentes na bancada
  • 46placas rodando agora
  • 1.00xtempo real, em todas as placas
Arduino Uno: um robô autoequilibranteao vivo0.000 s 0.00x
Clique para abrir no editor
O exemplo Balance bot: um MPU6050 passando por um filtro complementar e um PID em três potenciômetros. Empurre-o com os botões de seta.

Um robô autoequilibrante fica de pé sobre duas rodas, como um pêndulo de cabeça para baixo, e só se mantém em pé porque continua levando as rodas para baixo de si mesmo. É um projeto clássico de Arduino porque junta duas grandes ideias em uma só construção: transformar um sensor ruidoso em um bom ângulo, e um controlador PID que age sobre ele centenas de vezes por segundo.

O circuito acima é um Uno rodando um robô de duas rodas com seu próprio MPU6050 e driver de motor TB6612. Três potenciômetros ajustam os ganhos do PID enquanto ele roda, e um OLED mostra o ângulo e os ganhos. Aperte Rodar: o robô é segurado em pé por um instante, depois solto, e ele se recupera. Então empurre-o com os botões de seta no robô e gire os potenciômetros para ver o que cada ganho faz.

O que você precisa

  • Um Arduino Uno
  • Um chassi de robô de duas rodas com motores DC com redução
  • Um acelerômetro e giroscópio MPU6050
  • Um driver de motores TB6612FNG
  • Três potenciômetros de 10k
  • Um OLED SSD1306, 128x64, I2C (opcional)
  • Um porta-baterias para os motores

Ligação

Componente e pinoVai paraNota
SCL e SDA do robôPinos 12 e 2O MPU6050 do robô em 0x68, em um I2C por software próprio
AIN1, AIN2, PWMAPinos 10, 9 e 6Motor esquerdo
BIN1, BIN2, PWMBPinos 5, 4 e 3Motor direito
STBY5 VO driver funciona sempre que recebe energia
Botões de Kp, Ki e KdA0, A1 e A2Extremidades em 5 V e GND
SCL e SDA do OLEDA5 e A4Ângulo e ganhos

Passo 1: calcular a inclinação

O MPU6050 tem dois sensores, e nenhum dos dois é bom o bastante sozinho. O acelerômetro sabe onde fica o baixo, então atan2(-ax, az) dá a inclinação em relação à gravidade. Mas ele também sente cada empurrão que as rodas dão no corpo, então, enquanto o robô se move, ele fica ruidoso e errado. O giroscópio mede a velocidade de rotação do corpo, de forma suave, mas é preciso somar essa taxa para obter um ângulo, e os pequenos erros também se acumulam, então o ângulo deriva.

O filtro complementar pega o melhor de cada um: angle = 0.98 * (angle + rate * dt) + 0.02 * accelAngle. De instante a instante, o giro move o ângulo, e o acelerômetro o puxa suavemente de volta à verdade, 2% a cada passo. É uma linha de código, e é o que a maioria dos robôs equilibradores usa.

Passo 2: um PID no ângulo

A cada 10 ms o sketch calcula o quanto o corpo se inclina em relação à vertical e move as rodas para corrigir. A saída é a soma de três termos. P (proporcional) é a inclinação vezes Kp: inclina mais, anda mais forte. D (derivativo) é a taxa do giroscópio vezes Kd: ele resiste ao corpo girar rápido, o que impede que ele passe do ponto. I (integral) soma a inclinação ao longo do tempo vezes Ki: ele fornece o empurrão constante que um motor precisa só para manter uma velocidade.

A soma é limitada a -255 a 255, e seu sinal escolhe a direção (AIN1 e AIN2), enquanto sua intensidade vai para analogWrite em PWMA e PWMB. Inclinando para a frente, as rodas andam para a frente para voltar para baixo do corpo.

Os três potenciômetros definem Kp de 0 a 80, Ki de 0 a 600 e Kd de 0 a 2. Com cada potenciômetro no meio (40, 300 e 1) o robô se equilibra: solte após um segundo, ele fica de pé, e cerca de quatro segundos depois de Rodar o monitor serial informa "Equilibrado por 3 s". Empurre-o com a seta e ele diz "Peguei: de novo em pé" um momento depois.

O coração do loop do robô equilibrador, resumido
const float ALPHA = 0.98;
const float FALLEN = 45.0;
const float I_LIMIT = 150.0;

void loop() {
  unsigned long now = micros();
  if (now - lastUs < PERIOD_US) return;   // every 10 ms
  float dt = (now - lastUs) / 1000000.0;
  lastUs = now;

  Mpu6050Reading r;
  if (!imu.read(r)) return;
  float accelAngle = atan2(-(float)r.ax, (float)r.az) * 57.29578;
  float rate = r.gy / 131.0;
  angle = ALPHA * (angle + rate * dt) + (1 - ALPHA) * accelAngle;

  if (fabs(angle) > FALLEN) {
    fallen = true;
    integral = 0;
    brake();
    Serial.println("FALLEN");
  } else {
    integral += angle * dt;
    if (ki > 0.01) {
      float limit = I_LIMIT / ki;
      if (integral > limit) integral = limit;
      if (integral < -limit) integral = -limit;
    }
    float pid = kp * angle + ki * integral + kd * rate;
    output = (int)constrain(pid, -255, 255);
    drive(output);
  }
  readKnob();
}

O que cada ganho faz: experimente

Deixe o Ki no mínimo. Sem o integral, o robô não consegue sustentar o empurrão que um motor precisa em velocidade, então ele vai se arrastando, inclina cada vez mais para acompanhar e cai: o monitor serial diz "CAIU". Esse é o termo I mostrando seu valor.

Deixe o Kd no mínimo e aperte o botão de levantar no robô. Sem a amortização, cada balanço passa do anterior: ele balança cada vez mais forte até cair. Com o Kd de volta, o mesmo empurrão se dissipa em um ou dois balanços.

Kp define o quanto ele luta contra a inclinação. Baixo demais, ele fica preguiçoso e cambaleante; alto demais, ele treme. As pessoas ajustam um robô de verdade nessa ordem: Kp até ele quase ficar de pé e começar a tremer, Kd até o tremor parar, e então Ki até parar de derivar.

Segurado, solto, caído

A real robot is held upright while it powers up. If the PID ran during that time, the integral would fill up with a lean the wheels cannot fix (your hand is holding it), and the stored push would throw it over the moment you let go. So the sketch keeps the motors braked while the gyro says the body is still, and starts balancing when the rate goes over 1 degree a second: the hand has let go.

Passados 45 graus, ele caiu. Os motores freiam, o integral zera e, no robô, ele fica deitado no chão a cerca de 80 graus. Levante-o com o botão e ele fica segurado de novo, pronto para a próxima tentativa.

O modelo é um pêndulo de verdade sobre rodas, calculado a cada milissegundo, com motores que empurram o corpo para trás enquanto fazem as rodas andarem para a frente. O que ele deixa de fora são os solavancos do chão, a folga das caixas de redução baratas e uma bateria que perde tensão, que são as coisas que tornam um robô de verdade mais difícil de ajustar.

Erros comuns

As rodas girando no sentido errado. Se o robô anda na direção contrária à sua inclinação, ele cai na hora. Troque os fios de um motor ou inverta o sinal da saída.

O ângulo com o sinal errado, porque o MPU6050 está montado em outra orientação. Incline-o para a frente com a mão e confira que o ângulo fica positivo antes de rodar os motores.

Confiar só no acelerômetro. Ele interpreta os empurrões das rodas como inclinação. Misture-o com o giroscópio.

STBY do TB6612 deixado sem ligação. Ele tem um pull-down, então o driver fica desligado e os motores nunca giram. Ligue o STBY no circuito acima e o robô cai assim que é solto.

Um loop lento. Imprimir no monitor serial a cada loop, ou desenhar o OLED inteiro de uma vez, rouba o tempo de que o PID precisa. O sketch imprime quatro vezes por segundo e desenha uma linha do OLED por chamada.

Acúmulo do integral. Sem um limite, o termo I continua crescendo enquanto o robô está segurado ou travado. O sketch o limita e o zera numa queda.

Abra este circuito no editor. Arduino Uno: um robô autoequilibrante, ligado como aparece no topo desta página. Troque um componente ou um valor e rode de novo.

Abrir o circuito

Perguntas

De que sensor um robô autoequilibrante precisa?

Um acelerômetro e um giroscópio juntos, como o MPU6050. O acelerômetro dá o ângulo pela gravidade, o giroscópio a velocidade de rotação, e um filtro complementar ou de Kalman combina os dois.

Como ajusto o PID de um robô equilibrador?

Comece com Ki e Kd em zero. Aumente Kp até ele quase ficar de pé e começar a tremer, aumente Kd até o tremor parar, e então adicione um pouco de Ki para parar de derivar.

Qual driver de motor é melhor para um robô equilibrador?

Um TB6612FNG é uma boa escolha para motores pequenos com redução: é eficiente e comuta rápido. Um L298N funciona, mas desperdiça mais energia como calor.

Por que meu robô equilibrador deriva e cai?

Geralmente é integral de menos, então ele não consegue sustentar o empurrão de que precisa em velocidade, ou um ponto de equilíbrio que não fica exatamente em pé. Adicione um pouco de Ki ou ajuste o ângulo zero.

Monte isto de verdade

Abra o editor, mude um valor e veja o número mudar junto. Nada para instalar, e não precisa de conta.