Faça você mesmo, robô de auto-equilíbrio usando arduino

Depois de ser inspirado pelos motores RYNO e outras scooters com equilíbrio automático da Segway, sempre quis construir algo meu próprio Arduino Segway Robot. Pensando um pouco, decidi construir um robô de auto-equilíbrio usando o Arduino. Dessa forma, eu seria capaz de compreender o conceito subjacente a todas essas scooters e também aprender como funciona o algoritmo PID.

Assim que comecei a construir, percebi que construir esse bot é um pouco desafiador. Existem tantas opções para selecionar e, portanto, as confusões começam da maneira correta selecionando os motores e permanecem até o ajuste dos valores PID. E há tantas coisas a se considerar como tipo de bateria, posição da bateria, punho da roda, tipo de driver do motor, manutenção do CoG (centro de gravidade) e muito mais.

Mas deixe-me dizer a você, uma vez que você construí-lo, você concordará que não é tão difícil quanto parece ser. Então, vamos enfrentá-lo, neste tutorial irei documentar minha experiência na construção do robô com autobalanceamento. Você pode ser um iniciante absoluto que está apenas começando ou pode ter chegado aqui depois de uma longa frustração de não conseguir fazer seu bot funcionar. Este local pretende ser o seu destino final. Então vamos começar……

Selecionando as peças para o robô de autoequilíbrio

Antes de lhe contar todas as opções para construir o bot, deixe-me listar os itens que usei neste projeto de robô de autoequilíbrio

Arduino UNO
Motores DC com engrenagem (cor amarela) - 2Nos
Módulo Motorista L298N
MPU6050
Um par de rodas
Bateria de íon-lítio de 7,4 V
Fios de conexão
Corpo impresso em 3D

Você pode misturar e escolher qualquer um dos componentes acima com base na disponibilidade para fazer seu próprio kit de robô de autoequilíbrio, apenas certifique-se de que os componentes atendam aos seguintes critérios.

Controlador: O controlador que usei aqui é o Arduino UNO, porque é simplesmente fácil de usar. Você também pode usar um Arduino Nano ou um Arduino mini, mas eu recomendo que você fique com o UNO, pois podemos programá-lo diretamente sem nenhum hardware externo.

Motores: A melhor escolha de motor que você pode usar para um robô com autobalanceamento, sem dúvida será o motor de passo. Mas para manter as coisas simples, usei um motor de engrenagem DC. Sim, não é obrigatório ter um stepper; o robô também funciona bem com esses motores de engrenagem DC de cor amarela comumente disponíveis.

Driver do motor: Se você selecionou os motores de engrenagem DC como o meu, você pode usar o módulo driver L298N como eu, ou mesmo um L293D deve funcionar bem. Saiba mais sobre como controlar o motor DC usando L293D e Arduino.

Rodas: Não subestime esses caras; Foi difícil descobrir que o problema estava nas rodas. Portanto, certifique-se de que suas rodas tenham uma boa aderência ao piso que você está usando. Observe com atenção, sua pegada nunca deve permitir que as rodas deslizem no chão.

Acelerômetro e giroscópio: A melhor escolha de acelerômetro e giroscópio para o seu bot será o MPU6050. Portanto, não tente construir um com um acelerômetro normal como ADXL345 ou algo parecido, ele simplesmente não funcionará. Você saberá o motivo no final deste artigo. Você também pode verificar nosso artigo dedicado sobre como usar o MPU6050 com o Arduino.

Bateria: Precisamos de uma bateria o mais leve possível e a tensão operacional deve ser superior a 5 V para que possamos alimentar nosso Arduino diretamente, sem um módulo de reforço. Portanto, a escolha ideal será uma bateria de polímero de lítio de 7,4V. Aqui, como eu tinha uma bateria de íon-lítio de 7,4 V disponível, usei-a. Mas lembre-se de que um Li-po é mais vantajoso do que Li-ion.

Chassi: Outro lugar onde você não deve se comprometer é com o chassi de seus bots. Você pode usar papelão, madeira, plástico, qualquer coisa com que seja bom. Mas, apenas certifique-se de que o chassi é robusto e não deve balançar quando o bot está tentando se equilibrar. Eu projetei meu próprio chassi no Solidworks inferindo dos outros bots e imprimi-o em 3D. Se você tiver uma impressora, também poderá imprimir o desenho; os arquivos do desenho serão anexados no próximo título.

Impressão 3D e montagem de nosso robô de auto-equilíbrio

Se você decidiu imprimir em 3D o mesmo chassi que estou usando para construir meu bot, os arquivos STL podem ser baixados do thingiverse. Eu também adicionei os arquivos de design junto com ele para que você também possa modificá-lo de acordo com suas preferências pessoais.

As peças não têm estruturas salientes, então você pode imprimi-las facilmente sem nenhum suporte e um preenchimento de 25% funcionará bem. Os designs são bastante simples e qualquer impressora básica deve ser capaz de lidar com eles com facilidade. Usei o software Cura para fatiar o modelo e imprimi usando meu Tevo Tarantula, as configurações são mostradas abaixo.

Você teria que imprimir a parte do corpo, bem como quatro peças de montagem do motor. A montagem é bastante simples; use porcas e parafusos de 3 mm para prender o motor e as placas no lugar. Após a montagem, deverá ficar parecido com o mostrado na imagem abaixo.

O design real foi planejado com o módulo de unidade L298N no rack inferior do Arduino e bateria em cima dele, conforme mostrado acima. Se você estiver seguindo a mesma ordem, pode parafusar diretamente a placa através dos orifícios fornecidos e usar uma etiqueta de fio para a bateria Li-po. Este arranjo também deve funcionar, exceto para as rodas superlisas que eu tive que mudar mais tarde.

No meu bot, troquei a posição da bateria e da placa Arduino UNO para facilitar a programação e também tive que introduzir uma placa de perf para completar as conexões. Então meu bot não ficou como planejado no estágio inicial. Depois de completar o teste de programação de fiação e tudo mais, meu robô de duas rodas finalmente se parece com isso

Diagrama de circuito

Fazer as conexões para este robô de auto balanceamento baseado em Arduino é muito simples. Este é um robô de auto-equilíbrio usando Arduino e MPU6050, então devemos fazer a interface do MPU6050 com o Arduino e conectar os motores através do módulo Motor driver. Toda a configuração é alimentada pela bateria de íons de lítio de 7,4V. O diagrama de circuito para o mesmo é mostrado abaixo.

O Arduino e o módulo de driver do motor L298N são alimentados diretamente através do pino Vin e do terminal de 12 V respectivamente. O regulador integrado na placa Arduino converterá a entrada de 7,4 V em 5 V e o ATmega IC e o MPU6050 serão alimentados por ele. Os motores DC podem funcionar com tensões de 5 V a 12 V. Mas estaremos conectando o fio positivo de 7,4 V da bateria ao terminal de entrada de 12 V do módulo acionador do motor. Isso fará com que os motores operem com 7,4V. A tabela a seguir listará como o módulo do driver do motor MPU6050 e L298N está conectado ao Arduino.

Pino de componente	Pin Arduino
MPU6050
Vcc	+ 5V
Terra	Gnd
SCL	A5
SDA	A4
INT	D2
L298N
EM 1	D6
EM 2	D9
IN3	D10
IN4	D11

O MPU6050 se comunica com o Arduino por meio da interface I2C, então usamos os pinos SPI A4 e A5 do Arduino. Os motores DC são conectados aos pinos PWM D6, D9 D10 e D11 respectivamente. Precisamos conectá-los aos pinos PWM porque estaremos controlando a velocidade do motor DC variando o ciclo de trabalho dos sinais PWM. Se você não estiver familiarizado com esses dois componentes, é recomendável ler o tutorial da interface MPU6050 e do driver do motor L298N.

Código de robô com auto-equilíbrio

Agora temos que programar nossa placa Arduino UNO para equilibrar o robô. É aqui que toda a magia acontece; o conceito por trás disso é simples. Temos que verificar se o bot está inclinado para a frente ou para trás usando o MPU6050 e então se estiver inclinado para a frente temos que girar as rodas para frente e se estiver inclinado para trás temos que girar as rodas na direção reversa.

Ao mesmo tempo , também temos que controlar a velocidade com que as rodas estão girando, se o bot estiver um pouco desorientado da posição central, as rodas giram lentamente e a velocidade aumenta à medida que se afasta mais da posição central. Para atingir essa lógica, usamos o algoritmo PID, que tem a posição central como ponto de ajuste e o nível de desorientação como saída.

Para saber a posição atual do bot usamos o MPU6050, que é um acelerômetro de 6 eixos e um sensor giroscópio combinados. Para obter um valor confiável de posição do sensor, precisamos usar o valor do acelerômetro e do giroscópio, porque os valores do acelerômetro têm problemas de ruído e os valores do giroscópio tendem a desviar com o tempo. Portanto, temos que combinar os dois e obter o valor de inclinação e rotação de yaw de nosso robô, do qual usaremos apenas o valor de yaw.

Parece um pouco de cabeça cambaleando, certo? Mas não se preocupe, graças à comunidade Arduino, temos bibliotecas prontamente disponíveis que podem realizar o cálculo de PID e também obter o valor de yaw do MPU6050. A biblioteca é desenvolvida por br3ttb e jrowberg, respectivamente. Antes de prosseguir, baixe suas bibliotecas do seguinte link e adicione-as ao diretório lib do Arduino.

github.com/br3ttb/Arduino-PID-Library/blob/master/PID_v1.h

github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050

Agora que temos as bibliotecas adicionadas ao nosso IDE Arduino. Vamos começar a programar para nosso robô de auto-equilíbrio. Como sempre, o código completo para o robô de balanceamento MPU6050 é fornecido no final desta página, aqui estou apenas explicando os trechos mais importantes do código. Como dito anteriormente, o código é construído em cima do código de exemplo MPU6050, vamos apenas otimizar o código para o nosso propósito e adicionar o PID e a técnica de controle para nosso robô de auto-equilíbrio.

Primeiro, incluímos as bibliotecas necessárias para o funcionamento deste programa. Eles incluem a biblioteca I2C embutida, a Biblioteca PID e a Biblioteca MPU6050 que acabamos de baixar.

#include "I2Cdev.h" #include // De #include "MPU6050_6Axis_MotionApps20.h" //https://github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050

Em seguida, declaramos as variáveis necessárias para obter os dados do sensor MPU6050. Lemos o vetor de gravidade e os valores do quatérnio e, em seguida, calculamos o passo de guinada e o valor de rotação do bot. O array float ypr conterá o resultado final.

// controle / status MPU vars bool dmpReady = false; // define verdadeiro se a inicialização DMP foi bem-sucedida uint8_t mpuIntStatus; // mantém o byte de status de interrupção real do MPU uint8_t devStatus; // retorna o status após cada operação do dispositivo (0 = sucesso,! 0 = erro) uint16_t packetSize; // tamanho do pacote DMP esperado (o padrão é 42 bytes) uint16_t fifoCount; // contagem de todos os bytes atualmente em FIFO uint8_t fifoBuffer; // buffer de armazenamento FIFO // orientação / movimento vars Quaternion q; // contêiner de quaternion VectorFloat gravity; // vetor de gravidade float ypr; // yaw / pitch / roll container e vetor de gravidade

Em seguida, vem o segmento muito importante do código, e é aqui que você passará muito tempo ajustando o conjunto certo de valores. Se o seu robô for construído com um centro de gravidade muito bom e os componentes estiverem dispostos simetricamente (o que na maioria dos casos não é), o valor do seu ponto de ajuste será 180. Ou conecte seu bot ao monitor serial Arduino e incline-o até você encontrar uma boa posição de equilíbrio, ler o valor exibido no monitor serial e este é o seu valor de ponto de ajuste. O valor de Kp, Kd e Ki deve ser ajustado de acordo com seu bot. Não há dois bots idênticos que terão os mesmos valores de Kp, Kd e Ki, então não há como escapar disso. Assista ao vídeo no final desta página para ter uma ideia de como ajustar esses valores.

/ ********* Ajuste esses 4 valores para o seu BOT ********* / double setpoint = 176; // define o valor quando o bot está perpendicular ao solo usando o monitor serial. // Leia a documentação do projeto em circuitdigest.com para saber como definir esses valores double Kp = 21; // Defina este primeiro double Kd = 0.8; // Defina este segundo duplo Ki = 140; // Finalmente defina esta / ****** Definição de fim de valores ********* /

Na próxima linha, inicializamos o algoritmo PID passando as variáveis de entrada entrada, saída, ponto de ajuste, Kp, Ki e Kd. Destes, já definimos os valores do ponto de ajuste Kp, Ki e Kd no trecho de código acima. O valor de entrada será o valor atual de guinada que é lido do sensor MPU6050 e o valor de saída será o valor que é calculado pelo algoritmo PID. Então, basicamente, o algoritmo PID nos dará um valor de saída que deve ser usado para corrigir o valor de entrada para estar próximo do ponto de ajuste.

PID pid (& input, & output, & setpoint, Kp, Ki, Kd, DIRECT);

Dentro da função de configuração vazia inicializamos o MPU6050 configurando o DMP (Digital Motion Processor). Isso nos ajudará a combinar os dados do acelerômetro com os dados do giroscópio e fornecer um valor confiável de guinada, inclinação e rotação. Não iremos nos aprofundar muito nisso, pois estará muito além do tópico. De qualquer forma, um segmento de código que você deve consultar na função de configuração são os valores de deslocamento do giroscópio. Cada sensor MPU6050 tem seus próprios valores de deslocamento, você pode usar este esboço do Arduino para calcular o valor de deslocamento do seu sensor e atualizar as seguintes linhas de acordo em seu programa.

// forneça seus próprios deslocamentos de giroscópio aqui, escalonados para sensibilidade mínima mpu.setXGyroOffset (220); mpu.setYGyroOffset (76); mpu.setZGyroOffset (-85); mpu.setZAccelOffset (1688);

Também temos que inicializar os pinos PWM digitais que estamos usando para conectar nossos motores. No nosso caso, é D6, D9, D10 e D11. Portanto, inicializamos esses pinos como pinos de saída e os tornam BAIXOS por padrão.

// Inicializar o motor Outpu pinos pinMode (6, OUTPUT); pinMode (9, OUTPUT); pinMode (10, OUTPUT); pinMode (11, OUTPUT); // Por padrão, desligue ambos os motores analogWrite (6, LOW); analogWrite (9, LOW); analogWrite (10, LOW); analogWrite (11, LOW);

Dentro da função de loop principal verificamos se os dados do MPU6050 estão prontos para serem lidos . Se sim, então o usamos para calcular o valor do PID e então exibir o valor de entrada e saída do PID no monitor serial apenas para verificar como o PID está respondendo. Então, com base no valor da saída, decidimos se o bot precisa se mover para frente ou para trás ou ficar parado.

Uma vez que assumimos que o MPU6050 retornará 180 quando o bot estiver de pé. Obteremos valores de correção positivos quando o bot estiver caindo para a frente e obteremos valores negativos se o bot estiver caindo para trás. Portanto, verificamos essa condição e chamamos as funções apropriadas para mover o bot para frente ou para trás.

while (! mpuInterrupt && fifoCount <packetSize) { // nenhum dado mpu - realizando cálculos PID e saída para motores pid.Compute (); // Imprime o valor de Input e Output no monitor serial para verificar como está funcionando. Serial.print (entrada); Serial.print ("=>"); Serial.println (saída); if (input> 150 && input <200) {// Se o Bot está caindo if (output> 0) // Falling to front Forward (); // Gire as rodas para frente else if (output <0) // Caindo para trás Reverse (); // Girar as rodas para trás } else // Se o bot não cair Stop (); // Mantenha as rodas paradas }

A variável de saída PID também decide quão rápido o motor deve ser girado. Se o robô está prestes a cair, fazemos pequenas correções girando a roda lentamente. Se essas pequenas correções funcionarem e ainda assim se o robô estiver caindo, aumentamos a velocidade do motor. O valor de quão rápido as rodas giram será decidido pelo algoritmo PI. Observe que, para a função Reverse, multiplicamos o valor da saída por -1 para que possamos converter o valor negativo em positivo.

void Forward () // Código para girar a roda para frente { analogWrite (6, saída); analogWrite (9,0); analogWrite (10, saída); analogWrite (11,0); Serial.print ("F"); // Informações de depuração } void Reverse () // Código para girar a roda para trás { analogWrite (6,0); analogWrite (9, saída * -1); analogWrite (10,0); analogWrite (11, saída * -1); Serial.print ("R"); } void Stop () // Código para parar as duas rodas { analogWrite (6,0); analogWrite (9,0); analogWrite (10,0); analogWrite (11,0); Serial.print ("S"); }

Trabalho do Arduino Self Balancing Robot

Assim que estiver pronto com o hardware, você pode fazer o upload do código para a placa Arduino. Certifique-se de que as conexões estejam corretas, pois estamos usando uma bateria de íon-lítio, é necessário muito cuidado. Portanto, verifique se há curtos-circuitos e certifique-se de que os terminais não entrem em contato, mesmo se o seu bot sofrer alguns pequenos impactos. Ligue seu módulo e abra o monitor serial, se o seu Arduino conseguiu se comunicar com o MPU6050 com sucesso e se tudo estiver funcionando conforme o esperado, você deverá ver a tela a seguir.

Aqui vemos os valores de entrada e saída do algoritmo PID no formato entrada => saída . Se o bot estiver perfeitamente balanceado, o valor de saída será 0. O valor de entrada é o valor atual do sensor MPU6050. O alfabeto “F” representa que o bot está se movendo para frente e “R” representa que o bot está ao contrário.

Durante os estágios iniciais do PID eu recomendo deixar seu cabo Arduino conectado ao bot para que você possa monitorar facilmente os valores de entrada e saída e também seja fácil corrigir e carregar seu programa para os valores Kp, Ki e Kd. O vídeo abaixo mostra o funcionamento completo do bot e também mostra como corrigir seus valores de PID.

Espero que isso ajude a construir seu próprio robô de auto-equilíbrio. Se você tiver qualquer problema em fazê-lo funcionar, deixe suas perguntas na seção de comentários abaixo ou use os fóruns para perguntas mais técnicas. Se você quiser mais diversão, também pode usar a mesma lógica para construir um robô de equilíbrio de bola.