Construa um Robô Hexapod Formiga Arduino – Guia Passo a Passo

Neste tutorial, mostrarei como construí um hexapod Arduino. Como o nome sugere, o hexapod tem 6 pernas, mas além disso, também tem uma cauda ou abdômen, uma cabeça, antenas, mandíbulas e até olhos funcionais. Tudo isso faz o hexapod parecer uma formiga, por isso também podemos chamá-lo de Robô Formiga Arduino.

Você pode assistir ao vídeo a seguir ou ler o tutorial escrito abaixo.

Visão Geral

Para controlar o robô, fiz um aplicativo Android personalizado. O app tem 4 botões pelos quais podemos comandar o robô a mover para frente ou para trás, bem como virar à esquerda ou direita. Junto com estas funções principais, o robô também pode mover a cabeça e a cauda, morder, agarrar e soltar coisas e até atacar.

Como mencionei anteriormente, o robô tem olhos funcionais, ou projetei especificamente a cabeça para acomodar um sensor ultrassônico. Então, se tentarmos tocar a cabeça do robô ou aproximar a mão do sensor, o robô inicialmente se preparará para um ataque.

Se nos afastarmos, o robô cancela o ataque, mas caso aproximemos a mão dele, ele atacará e morderá. Que legal é isso? Fique por aqui e descobrirá exatamente como o construí e como tudo funciona.

Modelo 3D do Hexapod Arduino – Robô Formiga

Como de costume, comecei projetando o hexapod usando um software de modelagem 3D. O hexapod tem 6 pernas e cada uma consiste em 3 juntas ou 3 servos. Isso significa que precisamos de um total de 18 servos e, no meu caso, usei servos MG996R.

Na parte traseira, temos a cauda acionada por outro servo MG996R. A cabeça deste robô formiga tem dois graus de liberdade, ou pode rolar e inclinar, e novamente é acionada por mais dois servos. Então, precisamos de um total de 21 servos para este projeto, tipo MG996R, e adicionalmente um menor servo micro SG90 para as mandíbulas.

Aqui também temos os olhos da formiga, projetados para acomodar um sensor ultrassônico HC-SR04. Todas as peças são montadas entre duas placas e, adicionalmente, fiz uma tampa curva interessante para a placa superior para esconder toda a fiação, o Arduino e a bateria entre as duas placas.

Você pode encontrar e baixar este modelo 3D, bem como explorá-lo no seu navegador no Thangs.

Arquivos STL:

Impressão 3D das Peças

Acho que você já sabe o que vem a seguir: impressão 3D das peças do robô. Usei a impressora 3D Creality CR-10 para todas as impressões e ela fez um ótimo trabalho. A peça mais difícil de imprimir foi a cabeça, porque queria que fosse uma única impressão.

Para isso, tive que usar um Ângulo de Sobreposição de Suporte de 60 graus, bem como alguns bloqueadores de suporte. De qualquer forma, a Creality CR-10 fez um ótimo trabalho e a cabeça saiu perfeita.

Montagem do Hexapod Arduino

Uma vez que temos todas as peças impressas, podemos prosseguir com a montagem do hexapod. Comecei montando as pernas. Para fixar os servos às peças impressas, usei parafusos e porcas M3, bem como arruelas de pressão. O comprimento dos parafusos precisa ser de pelo menos 12mm e, no meu caso, usei parafusos de 16mm.

Precisamos de cerca de 200 parafusos para a montagem completa. Para conectar as ligações entre si, usamos os chifres redondos que vêm junto com o pacote do servo como acessórios. No entanto, precisamos furar furos de 3mm em cada um deles para que os parafusos passem, ou podemos usar chifres redondos de metal que têm rosca M3 e podem ser comprados separadamente.

Ao fixar as ligações aos servos, precisamos garantir que sempre as conectemos na mesma posição e que tenham a amplitude total de movimento.

Devemos notar aqui que os servos têm um pequeno suporte triangular no lado superior que precisa ser removido. Usei uma faca utilitária simples para fazer isso, de modo que os servos possam ficar alinhados com as peças impressas. Antes de inserir o terceiro servo no lugar, primeiro precisamos inserir um parafuso M4 que será usado para conectar a perna com a placa base.

Aqui está como a montagem da perna deve ficar. Na verdade, é muito fácil montá-la, mas agora precisamos de mais cinco iguais.

Uma vez que temos todas as pernas prontas, podemos prosseguir com a instalação delas no corpo do robô, ou nas duas placas. Primeiro, precisamos fixar os chifres redondos na plataforma superior usando o mesmo método anterior, com parafusos e porcas M3. Então, podemos simplesmente conectá-los aos eixos dos servos usando os parafusos, mas antes disso, precisamos ajustar a posição dos servos para ficar exatamente no meio.

Isso é necessário para que possamos obter a amplitude total de movimento dos servos e também reduzirá o processo de ajuste ou calibração ao programar o Arduino.

Após fixar as pernas, o projeto já começou a tomar forma e parecer um hexapod.

Há mais um chifre redondo na parte traseira e é para o servo da cauda, que também precisa ser fixado neste ponto.

Em seguida, precisamos colocar o hexapod de cabeça para baixo para podermos inserir a placa inferior através dos parafusos M4 das pernas. Então, fixei as pernas a ela usando algumas arruelas planas e porcas auto-travantes. Devemos ter cuidado com o quanto apertamos esses parafusos, porque estas são na verdade as juntas de pivô e as pernas também devem ser capazes de girar enquanto permanecem seguras o suficiente.

Em seguida, precisamos instalar o primeiro servo para a cabeça, que é para o movimento de rolagem. Este servo deve ser colocado perpendicular às placas base, então, para esse fim, fiz duas pequenas placas que primeiro são fixadas ao servo. Então, podemos inserir o servo entre as duas placas e fixá-lo facilmente com parafusos e porcas M3.

Depois, temos um suporte em forma de U e aqui precisamos fixar dois chifres redondos para conectar os dois servos da cabeça. Novamente, antes de fixar o suporte ao servo de rolagem, precisamos garantir que a posição do servo esteja no meio para que possa girar 90 graus em ambas as direções.

O próximo é o suporte do servo de inclinação. Aqui, primeiro precisamos inserir um parafuso M4 e fixá-lo ao suporte em U. Antes de montar o motor de inclinação, também precisamos inserir quatro parafusos M3 que serão usados posteriormente para fixar a cabeça. Então, podemos inserir o servo de inclinação no suporte e encaixar cuidadosamente o eixo no chifre redondo. É um pouco apertado aqui, mas o suporte em U pode flexionar um pouco ajudando.

Por fim, precisamos fixar o servo com os parafusos M3 e, com isso, o mecanismo da cabeça está completo. Agora ele pode rolar e inclinar.

Antes de fixar a cabeça ao mecanismo, precisamos pré-montá-la, ou fixar as mandíbulas com o pequeno servo SG90 e o sensor ultrassônico. Novamente é um pouco apertado, mas ainda consegui inserir a primeira mandíbula e fixá-la à cabeça usando um parafuso M4.

Você pode notar que há um pequeno furo na área dos olhos, projetado especificamente para podermos passar uma chave de fenda para apertar o parafuso.

Em seguida, vai o micro servo no lugar e é fixado usando dois parafusos. Na segunda mandíbula, primeiro precisamos fixar um pequeno chifre de braço para o servo SG90.

Então, podemos inserir a mandíbula no lugar, encaixar as duas engrenagens e fixá-la ao eixo do motor usando uma chave de fenda.

Em seguida, podemos colocar o sensor ultrassônico no lugar. Os furos dos olhos são feitos exatamente para acomodar o sensor ultrassônico, então simplesmente usei algumas gotas de cola cianoacrilato para fixar o sensor à cabeça.

Há mais um detalhe a ser adicionado à cabeça: as antenas. Para isso, usei fio de 3mm de espessura, que cortei cerca de 13cm de comprimento e dobrei levemente para obter o formato desejado. Novamente, usei algumas gotas de cola cianoacrilato para fixá-las à cabeça. Finalmente, podemos fixar a cabeça ao mecanismo de rolagem e inclinação com os quatro parafusos que inserimos anteriormente.

A cabeça agora está totalmente funcional: pode rolar, inclinar e até morder. Há mais duas peças impressas em 3D para instalar: a cauda, que pode simplesmente deslizar no suporte da cauda, e a tampa curva que usaremos no final para cobrir a eletrônica. Esta é a aparência final do nosso robô formiga e gosto muito de como ficou nesta combinação de cores azul e branco.

Diagrama de Circuito do Robô Formiga Arduino

Ok, agora podemos prosseguir com a eletrônica. Aqui está o diagrama de circuito deste projeto, que é na verdade simples, embora pareça um pouco complexo por causa das muitas conexões de servos.

Além dos 22 servos, precisamos de um módulo Bluetooth HC-05 para comunicação com smartphone e alguns capacitores e resistores. Claro, o cérebro do robô é uma placa Arduino, e neste caso é o Arduino Mega porque é a única placa que pode controlar mais de 12 servos usando a biblioteca Servo.

Tutorial Relacionado: Como Funcionam Motores Servo e Como Controlar Servos usando Arduino

Para alimentar o robô, usarei uma bateria LiPo 3S que tem tensão de cerca de 12V. Baterias LiPo podem lidar com maior quantidade de corrente, então são adequadas para este projeto porque, se todos os servos estiverem engajados ao mesmo tempo em carga total, eles podem consumir cerca de 10 amperes de corrente. No entanto, a tensão de operação dos servos é limitada de 4,8 a 7,2V, o que significa que preciso usar um conversor DC-DC buck para converter 12V em 5V. Mesmo se usarmos bateria LiPo 2S que tem tensão em torno de 7,4V ou 8,4V quando totalmente carregada, ainda precisamos usar um conversor buck. O conversor buck que usarei para este projeto pode lidar com até 8 amperes de corrente, mas recomendaria usar um de 10 a 15A apenas para ter certeza de que terá energia suficiente e não superaquecerá. No meu caso, a corrente máxima que notei do robô ao mover foi cerca de 6 ampères.

Você pode obter os componentes necessários para este projeto nos links abaixo:

• Servomotor MG996R
• Servomotor Micro SG90
• Módulo Bluetooth HC-05
• Placa Arduino Mega
• Bateria LiPo 3S
• Conversor DC-DC Buck

Projetando uma PCB para o Hexapod Arduino

Agora, se tentarmos conectar tudo junto, será uma bagunça por causa das muitas conexões de servos. Por isso, projetei uma PCB personalizada usando o software gratuito de design de circuitos online EasyEDA. Esta PCB atuará na verdade como um Shield Arduino Mega para o Hexapod, porque poderemos conectá-la diretamente sobre a placa Arduino Mega. Organizei as conexões dos servos próximas umas das outras e incluí dois capacitores grandes próximos a eles para manter a tensão mais estável. Também incluí uma conexão para um módulo transceptor NRF24L01 caso queiramos controlar o robô usando rádio. Há várias conexões de pinos digitais e analógicos, conexões de 5V e terra, duas conexões de LED, bem como uma conexão para monitorar a tensão da bateria. A tensão de 12V da bateria passará por um divisor de tensão composto por dois resistores R1 e R2 que reduzirão a tensão abaixo de 5V para que o pino analógico possa lê-la com segurança. Dessa forma, saberemos quando a bateria precisará ser recarregada.

Aqui está o link para os arquivos do projeto deste design de PCB. Uma vez finalizado o design, gerei o arquivo Gerber necessário para a fabricação da PCB.

Arquivo Gerber:

Então, encomendei a PCB na JLCPCB, que são na verdade os patrocinadores deste vídeo.

Aqui podemos simplesmente arrastar e soltar o arquivo Gerber e, uma vez carregado, podemos revisar nossa PCB no visualizador Gerber. Se tudo estiver correto, podemos prosseguir e selecionar as propriedades que desejamos para nossa PCB. Neste caso, escolhi a cor da PCB azul para combinar com a cor da placa Arduino. E pronto, agora podemos simplesmente encomendar nossa PCB a um preço razoável. Note que se for seu primeiro pedido na JLCPCB, você pode obter até 10 PCBs por apenas $2.

Após alguns dias, as PCBs chegaram. A qualidade das PCBs é excelente e tudo é exatamente igual ao design.

Montagem da PCB

Ok, agora podemos prosseguir e montar a PCB. Comecei soldando headers de pinos macho na PCB, que são usados para conectá-la à placa Arduino. Uma vez que colocamos os headers de pinos no lado inferior, podemos usar algum tipo de placa para segurar os pinos e virar a placa. Agora precisamos soldar todos eles na PCB. Uma vez terminado isso, podemos prosseguir com as conexões dos servos, para as quais também precisamos headers de pinos macho.

Neste ponto, podemos realmente inserir os headers de pinos para todas as conexões e usar o mesmo método para virar a PCB e soldar todos os pinos nela. No final, precisamos soldar os resistores, os capacitores e os blocos de terminais. E pronto, o Shield Arduino Mega para nosso Robô Formiga está pronto. Agora podemos simplesmente inseri-lo sobre a placa Arduino.

Em seguida, precisamos definir a tensão de saída do conversor buck para 5V. Podemos fazer isso ajustando o potenciômetro do conversor buck. Você pode notar aqui que adicionei um interruptor de energia na entrada e conectei a bateria de 12V ao pino de 12V na PCB, que será usado apenas para monitorar a tensão da bateria.

Lembre-se de que a entrada principal na PCB deve ser 5V.

Agora podemos inserir os componentes eletrônicos entre as duas placas. Novamente é um pouco apertado, mas ainda conseguimos encaixar tudo. Primeiro vai a bateria, que fixei usando fita, e em cima dela vai o Arduino junto com a PCB que fizemos. Em seguida, podemos conectar o transceptor NRF24L01 ou apenas o módulo Bluetooth, dependendo do tipo de comunicação que usaremos. Também inseri um LED para indicar quando a bateria precisa recarregar, ou caso a tensão caia abaixo de 11V. Por fim, precisamos conectar todos os servos aos pinos de servo. Ao fazer isso, certifique-se de anotar em qual número de pino você conectou cada servo. Depois de conectar todos os servos, podemos simplesmente colocar a tampa curva na placa superior e estamos realmente prontos com este projeto.

Código do Hexapod Arduino

O que resta fazer neste vídeo é ver como o programa Arduino funciona. Como o código é um pouco longo, para melhor entendimento, postarei o código fonte do programa em seções com descrição para cada seção. E no final deste artigo, postarei o código fonte completo.

Para controlar os servos, usaremos a biblioteca Servo básica e para a comunicação Bluetooth precisamos incluir a biblioteca SoftwareSerial também. Primeiro, precisamos definir todos os objetos servo, bem como algumas variáveis necessárias para o programa abaixo.

#include <Servo.h>
#include <SoftwareSerial.h>
#define trigPin 7
#define echoPin 6
#define ledB 10
SoftwareSerial Bluetooth(12, 9); // Arduino(RX, TX) - HC-05 Bluetooth (TX, RX)
// Cria objetos servo
Servo s24;
Servo s23;
Servo s22;

Na seção setup, precisamos inicializar a comunicação Bluetooth, os modos de pino para o sensor ultrassônico, o LED e também definir os pinos aos quais os servos estão conectados.

void setup() {
  Serial.begin(38400);
  Bluetooth.begin(38400); // Taxa de baud padrão do módulo Bluetooth
  Bluetooth.setTimeout(1);
  delay(20);
  pinMode(trigPin, OUTPUT); // Define trigPin como saída
  pinMode(echoPin, INPUT);  // Define echoPin como entrada
  pinMode(ledB, OUTPUT);    // LED
  // Cabeça
  s15.attach(36, 600, 2400);
  s14.attach(35, 600, 2400);
  s13.attach(34, 600, 2400);
  // Garra
  s5.attach(26, 600, 2400);
  // Cauda
  // Perna 4
  s10.attach(31, 600, 2400);
  s11.attach(32, 600, 2400);
  s12.attach(33, 600, 2400);
  // Perna 5
  s7.attach(28, 600, 2400);
  s8.attach(29, 600, 2400);
  s9.attach(30, 600, 2400);
  // Perna 6
  s1.attach(22, 600, 2400);
  s2.attach(23, 600, 2400);
  s3.attach(24, 600, 2400);
  // Perna 1
  s18.attach(39, 600, 2400);
  s17.attach(38, 600, 2400);
  s16.attach(37, 600, 2400);
  // Perna 2
  s21.attach(42, 600, 2400);
  s20.attach(41, 600, 2400);
  s19.attach(40, 600, 2400);
  // Perna 3
  s24.attach(45, 600, 2400);
  s23.attach(44, 600, 2400);
  s22.attach(43, 600, 2400);
}

Então, usando as funções write(), movemos os servos para sua posição inicial. Aqui é onde podemos calibrar nossos servos. Considere que você não conseguirá definir cada servo na posição exata ao montar o robô, mas aqui podemos fazer ajustes e descobrir nossos valores iniciais e, a partir daí, programar o movimento do robô.

// == Move para posição inicial
// Cabeça
s15.write(72);
s14.write(50);
s13.write(90);
// Garra
s5.write(65);
// Cauda
// Perna 4
s10.write(65);
s11.write(35);
s12.write(40);
// Perna 5
s7.write(80);
s8.write(50);
s9.write(25);
// Perna 6
s1.write(90);
s2.write(45);
s3.write(60);
// Perna 1
s18.write(60);
s17.write(90);
s16.write(100);
// Perna 2
s21.write(50);
s20.write(85);
s19.write(75);
// Perna 3
s24.write(50);
s23.write(80);
s22.write(80);

Quando se trata de programar o movimento de um hexapod, existem várias maneiras de fazer isso, como usar cinemática direta ou inversa. Esses métodos incluem matemática séria onde a posição de cada junta é calculada baseada nas entradas para a posição final desejada do corpo. No entanto, decidi torná-lo um pouco menos complicado porque, de qualquer forma, os servos que estou usando não são bons o suficiente para tal tarefa. Isso porque meus servos são a versão barata do servo MG996R. Eles não têm o torque certo e nem sempre posicionam na posição exata desejada.

Vamos ver como fiz o hexapod andar. Fiz uma função personalizada separada para mover cada perna. Um ciclo de perna inclui duas fases, chamadas de balanço e apoio. Na fase de balanço, a perna se move de uma posição inicial para uma posição final pelo ar, enquanto na fase de apoio a perna se move da posição final de volta à inicial com o efetor final da perna tocando o chão. Dessa forma, o corpo do hexapod se moverá para frente.

Programei manualmente as posições de cada servo para atingir esses movimentos usando o loop principal e alguns contadores.

void moveLeg1() {
  // Fase de balanço - move perna pelo ar - de posição inicial para final
  // Levanta a perna
  if (i1L1 <= 10) {
    s18.write(60 - i1L1 * 2);
    s17.write(90 - i1L1 * 3);
    i1L1++;
  }
  // Rotaciona a perna
  if (i2L1 <= 30) {
    s16.write(100 - i2L1);
    i2L1++;
  }
  // Move de volta para tocar o chão
  if (i2L1 > 20 && i3L1 <= 10) {
    s18.write(40 + i3L1 * 2);
    s17.write(60 + i3L1 * 3);
    i3L1++;
  }
  // Fase de apoio - move perna enquanto toca o chão
  // Rotaciona de volta para posição inicial
  if (i2L1 >= 30) {
    s16.write(70 + i4L1);
    i4L1++;
    l1status = HIGH;
  }
  // Reseta contadores para repetir o processo
  if (i4L1 >= 30) {
    i1L1 = 0; i2L1 = 0; i3L1 = 0; i4L1 = 0; i5L1 = 0;
  }
  // Cada iteração ou passo é executado na seção do loop principal onde também há um tempo de delay para controlar a velocidade de movimento
}

Primeiro, os dois servos externos levantam a perna e o terceiro servo conectado ao corpo começa a rotacionar em uma direção particular. Quando o terceiro servo está a 10 passos antes de parar de rotacionar, começamos a mover os dois servos externos para trás na mesma posição para tocar o chão. Isso completa a fase de balanço, ou a perna moveu de sua posição inicial para a final. Então, rotacionamos de volta o terceiro servo da posição final para a inicial, completando a fase de apoio. Após a perna executar um ciclo, os contadores são resetados e a perna repetirá o ciclo repetidamente. Cada iteração ou passo é executado na seção do loop principal onde também há um tempo de delay que controla a velocidade dos servos. Fiz funções como esta para todas as outras pernas, bem como algumas funções adicionais para mover as pernas na direção oposta para obter movimentos de ré, esquerda e direita. De maneira similar, usando contadores para rastrear os passos, programei o resto das funções, como mover a cabeça, mover a cauda, as mandíbulas e assim por diante.

Por exemplo, se quisermos mover o robô para frente, precisamos chamar as seis funções moveLeg() personalizadas que se repetirão constantemente no loop principal.

// Mover para frente
if (m == 2) {
  moveLeg1();
  moveLeg3();
  moveLeg5();
  if (l1status == HIGH) {
    moveLeg2();
    moveLeg4();
    moveLeg6();
  }
}

Você pode notar que as 3 pernas estão desfasadas, então quando as pernas 1, 3 e 5 estão na fase de balanço, as outras três pernas, 2, 4 e 6, estão na fase de apoio. Caso queiramos mover para a esquerda, chamamos as funções moveLeft() apropriadas.

Esses comandos vêm na verdade do módulo Bluetooth ou do aplicativo Android personalizado do nosso smartphone.

// Verifica dados de entrada
if (Bluetooth.available() > 0) {
  dataIn = Bluetooth.read(); // Lê o dado

Aplicativo Android do Robô Formiga Arduino

Vamos ver o app agora e ver que tipo de dados ele está realmente enviando para o Arduino. Fiz o app usando o aplicativo online MIT App Inventor e aqui está como funciona.

Os gráficos do app são na verdade imagens que fiz e coloquei como botões. Na parte inferior, temos um controle deslizante para controlar a velocidade do robô e no topo temos os botões para conectar com o módulo Bluetooth.

Vamos ver o programa ou os blocos por trás do app.

Por exemplo, se clicarmos no botão Avançar, os blocos na instrução "se" serão executados. Isso significa que enviaremos o número 2 para o Arduino e isso executará o conjunto de funções de mover para frente. Ao mesmo tempo, podemos notar que mudamos a imagem do botão para a outra versão destacada da mesma imagem. Se pressionarmos novamente o mesmo botão, agora os blocos na instrução "senão" serão executados e isso enviará o número 0 para o Arduino, que resetará todos os contadores e moverá o robô para suas posições iniciais. Também definimos de volta a imagem inicial daquele botão. Usei o mesmo princípio para todos os outros botões.

Aqui está um arquivo para download do projeto MIT App Inventor acima, bem como o App Android pronto para ser instalado no seu smartphone:

Vamos dar uma olhada em mais duas funções no programa Arduino: o monitor de tensão da bateria e o sensor ultrassônico.

// Monitora a tensão da bateria
int sensorValue = analogRead(A3);
float voltage = sensorValue * (5.00 / 1023.00) * 2.9; // Converte valores de leitura de 5V para 12V adequados
Serial.println(voltage);
// Se tensão abaixo de 11V, liga o LED
if (voltage < 11) {
  digitalWrite(ledB, HIGH);
} else {
  digitalWrite(ledB, LOW);
}

Se a tensão da bateria for menor que 11 volts, acenderemos o LED e, se o sensor ultrassônico detectar um objeto a menos de 40 cm, o robô se preparará para um ataque.

// Obtém distância do sensor ultrassônico
if (getDistance() > 40) {
  att = 0;
}
if (getDistance() <= 40) {
  att = 1;
  dataIn = 99;
}

Caso não haja mais objeto na frente, ele cancelará o ataque e, se o objeto ainda estiver presente e mais próximo da cabeça, o robô atacará.

// Se há objeto na frente do sensor, prepara para ataque
if (att == 1) {
  prepareAttack();
  if (aStatus == HIGH) {
    while (a == 0) {
      delay(2000);
      a = 1;
    }
    if (getDistance() > 30) {
      att = 2; a = 0; aStatus = LOW; initialPosHead();
    }
    if (getDistance() < 30) {
      att = 3; a = 0; aStatus = LOW; initialPosHead();
    }
  }
}
// Se não há mais objeto na frente, cancela o ataque
if (att == 2) {
  dismissAttack();
  if (aStatus == HIGH) {
    dataIn = 0; att = 0;
  }
}
// Se está mais próximo do sensor, ataca
if (att == 3) {
  attack();
  if (attStatus == HIGH) {
    while (aa == 0) {
      delay(2000);
      aa = 1;
    }
    attStatus = LOW;
  }
  if (aStatus == HIGH) {
    while (a == 0) {
      delay(2000);
      a = 1;
    }
    dataIn = 0; att = 0; initialPosHead();
  }
}

Isso é basicamente tudo para este vídeo.

Aqui você pode baixar o código completo para este projeto Arduino Hexapod:

Note que, se decidir construir este projeto, precisa estar preparado para enfrentar alguns desafios. O maior problema para mim foi o desempenho ruim dos servos que usei. Espero que tenha gostado deste vídeo e aprendido algo novo. Sinta-se à vontade para fazer qualquer pergunta na seção de comentários abaixo e confira minha Coleção de Projetos Arduino.