Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Manufacturing Technology >> Processo de manufatura

Robô Arduino Ant Hexapod


Neste tutorial vou mostrar como construí um hexápode Arduino. Como o nome sugere, o hexápode tem 6 pernas, mas além disso, também possui cauda ou abdômen, cabeça, antenas, mandíbulas e até olhos funcionais. Tudo isso faz com que o hexápode pareça uma formiga, portanto, também podemos chamá-lo de Arduino Ant Robot.

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

Visão geral


Para controlar o robô, criei um aplicativo Android personalizado. O aplicativo possui 4 botões através dos quais podemos comandar o robô para avançar ou retroceder, bem como virar à esquerda ou à direita. Juntamente com essas funções principais, o robô também pode mover a cabeça e a cauda, ​​além de morder, agarrar e soltar coisas e até atacar.

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

Se recuarmos, o robô irá dispensar o ataque, mas caso aproximemos nossa mão, ele irá nos atacar e nos morder. Então, quão legal é isso? Fique por aqui e você descobrirá exatamente como eu o construo e como tudo funciona.

Arduino Hexapod – Modelo 3D Ant Robot


Como de costume, comecei projetando o hexápode usando um software de modelagem 3D. O hexápode tem 6 pernas e cada uma delas consiste em 3 articulações ou 3 servos. Isso significa que precisamos de um total de 18 servos e no meu caso usei os servos MG996R.

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

Aqui também temos os olhos da formiga que são projetados para encaixar um sensor ultrassônico HC-SR04. Todas as peças são montadas entre duas placas e além disso fiz uma interessante cobertura curva 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 em seu navegador no Thangs.

Arquivos STL:

Impressão 3D das peças


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

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

Montando o Arduino Hexapod


Assim que tivermos todas as peças impressas, podemos prosseguir com a montagem do hexápode. Comecei montando as pernas. Para prender os servos às peças impressas, usei parafusos e porcas M3, além de arruelas de pressão. O comprimento dos parafusos precisa ser de pelo menos 12 mm e no meu caso usei parafusos de 16 mm de comprimento.

Precisamos de cerca de 200 parafusos para toda a montagem. Para conectar os links entre si, usamos os chifres redondos que acompanham o pacote servo como acessórios. No entanto, precisamos fazer furos de 3 mm em cada um deles para que os parafusos possam passar, ou podemos usar chifres redondos de metal que possuem rosca M3 e podem ser comprados separadamente.

Ao prender os links aos servos, precisamos ter certeza de que sempre os conectamos na mesma posição e que eles tenham toda a amplitude de movimento.

Devemos notar aqui que os servos possuem um pequeno suporte triangular na parte superior que precisa ser removido. Eu usei uma faca simples para fazer isso, então dessa forma os servos podem ser colocados em flash 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 de base.

Veja como deve ser a montagem da perna. Na verdade, é muito fácil montá-lo, mas agora precisamos de mais cinco deles.

Assim que tivermos todas as pernas prontas, podemos prosseguir com a instalação no corpo do robô ou nas duas placas. Primeiro, precisamos prender 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 de fazermos isso precisamos ajustar a posição dos servos para que fiquem exatamente no meio.

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

Depois de prender as pernas, esse projeto já começou a ganhar forma e se parece com um hexápode.

Há mais um chifre redondo na parte de trás e isso é para o servo de cauda que também precisa ser fixado nesse ponto.

Em seguida, precisamos colocar o hexápode de cabeça para baixo e assim poderemos inserir a placa inferior através dos parafusos M4 das pernas. Então prendi as pernas usando algumas arruelas simples e porcas autotravantes. Devemos ter cuidado com o quanto apertamos esses parafusos, porque na verdade são as articulações do pivô e as pernas também devem ser capazes de girar enquanto estiverem seguras o suficiente.

Em seguida, precisamos instalar o primeiro servo para a cabeça e isso é para o movimento de rolagem. Este servo deve ser colocado perpendicularmente às placas de base, então para isso fiz duas pequenas placas que são primeiro presas ao servo. Então podemos inserir o servo entre as duas placas e podemos prendê-lo facilmente com os parafusos e porcas M3.

Então temos um suporte em forma de U e aqui precisamos anexar dois chifres redondos para conectar os dois servos para a cabeça. Novamente, antes de prender o suporte ao servo roll, precisamos ter certeza de que a posição do servo está no meio para que ele gire 90 graus em ambas as direções.

Em seguida é o suporte do servo de inclinação. Então aqui primeiro precisamos inserir um parafuso M4 e prendê-lo ao suporte em forma de 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. Em seguida, 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 forma de U pode flexionar um pouco de maneira útil.

Por último, 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 prender a cabeça ao mecanismo, precisamos pré-montá-la ou prender as mandíbulas com o pequeno servo SG90 e o sensor ultrassônico. Novamente, está um pouco apertado aqui, mas ainda consegui inserir a primeira mandíbula e prendê-la à cabeça usando um parafuso M4.

Você pode notar que há um pequeno orifício na área dos olhos que é projetado especificamente para que possamos passar por uma chave de fenda para apertar o parafuso.

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

Em seguida, podemos inserir a mandíbula no lugar, emparelhar as duas engrenagens e prendê-la ao eixo do motor usando uma chave de fenda.

Em seguida, podemos colocar o sensor ultrassônico no lugar. Os orifícios dos olhos são feitos exatamente para encaixar no sensor ultrassônico, então eu simplesmente usei algumas gotas de cola CA para prender o sensor na cabeça.

Há mais um detalhe a ser adicionado à cabeça e são as antenas. Para isso usei fio carrapato de 3mm, que cortei com cerca de 13cm de comprimento e dobrei levemente para obter a forma desejada. Novamente eu usei algumas gotas de cola AC para prendê-los na cabeça. Finalmente, podemos prender 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 serem instaladas. Essa é a cauda que pode simplesmente deslizar para o suporte da cauda e a tampa curva que realmente a usaremos no final para encobrir a eletrônica. Então esta é a aparência final do nosso robô formiga e eu realmente gosto de como ficou nesta combinação de cores azul e branco.

Diagrama de circuito do robô Ant do Arduino


Ok, agora podemos seguir em frente com a eletrônica. Aqui está o diagrama de circuito deste projeto que é realmente 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 do smartphone e alguns capacitores e resistores. Claro que 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 os servomotores e como controlar servos usando o Arduino

Para alimentar o robô, usarei uma bateria 3S LiPo que tem uma tensão de cerca de 12V. As baterias LiPo podem lidar com uma quantidade maior de consumo de corrente, por isso são adequadas para este projeto porque, se todos os servos estiverem acionados 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 os 12V para 5V. Mesmo no caso de usarmos bateria 2S LiPo que tem uma tensão em torno de 7,4V ou 8,4V quando totalmente carregada, ainda precisamos usar um conversor buck. O conversor buck que vou usar para este projeto pode suportar até 8 amperes de corrente, mas eu recomendaria usar um de 10 a 15A apenas para ter certeza de que você terá energia suficiente e não superaquecerá. No meu caso, o consumo máximo de corrente que notei do robô ao se mover foi de cerca de 6 amp.

Você pode obter os componentes necessários para este projeto nos links abaixo:
  • Servomotor MG996R……………………….….
  • SG90 Micro Servo Motor ……..…….….…….
  • Módulo Bluetooth HC-05 ………………….… 
  • Arduíno Mega Board ……………………….….
  • Bateria LiPo 3S …………………………………….. 
  • Conversor Buck DC-DC ……………………….

Projetando um PCB para o Arduino Hexapod


Agora, se tentarmos conectar tudo junto, será uma bagunça por causa das muitas conexões de servo. Portanto, projetei um PCB personalizado usando o software de design de circuito online gratuito EasyEDA. Este PCB funcionará na verdade como um Arduno Mega Shield para o Hexapod, pois poderemos conectá-lo diretamente em cima do Arduino Mega Board. Eu organizei as conexões dos servos próximas umas das outras e incluí dois grandes capacitores 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 um controle de rádio. Existem várias conexões de pinos digitais e analógicos, conexões de 5V e terra, duas conexões de LED, além de uma conexão para monitoramento da tensão da bateria. A tensão da bateria de 12V 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. Desta forma, saberemos quando a bateria precisará ser recarregada.

Aqui está um link para os arquivos de projeto deste design de PCB. Assim que terminei o projeto, gerei o arquivo Gerber necessário para a fabricação da PCB.

arquivo Gerber:

Então encomendei o PCB da JLCPCB que na verdade é o patrocinador deste vídeo.

Aqui podemos simplesmente arrastar e soltar o arquivo Gerber e, uma vez carregado, podemos revisar nosso PCB no visualizador Gerber. Se tudo estiver bem, podemos continuar e selecionar as propriedades que queremos para o nosso PCB. Neste caso eu escolhi a cor do PCB para ser azul para combinar com a cor da placa Arduino. E é isso, agora podemos encomendar simplesmente nosso PCB a um preço razoável. Observe que, se for seu primeiro pedido da JLCPCB, você poderá obter até 10 PCBs por apenas US $ 2.

Depois de vários dias, os PCBs chegaram. A qualidade dos PCBs é ótima e tudo é exatamente igual ao design.

Montagem do PCB


Ok, agora podemos seguir em frente e montar o PCB. Comecei soldando conectores de pinos machos na placa de circuito impresso que são usados ​​para conectá-la à placa Arduino. Uma vez que colocamos os cabeçalhos dos pinos na parte inferior, podemos usar algum tipo de placa para segurar os pinos e virar a placa. Agora precisamos soldar todos eles no PCB. Uma vez terminado com isso, podemos prosseguir com as conexões de servo para as quais também precisamos de cabeçalhos de pinos machos.

Neste ponto, podemos inserir os cabeçalhos dos pinos para todas as conexões e usar o mesmo método para inverter o PCB e soldar todos os pinos nele. No final, precisamos soldar os resistores, os capacitores e os blocos de terminais. E é isso, o Arduino Mega Shield para nosso Ant Robot já está pronto. Agora podemos simplesmente inseri-lo na 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 eu adicionei um interruptor de alimentação à entrada e conectei a bateria de 12V ao pino de 12V na placa de circuito impresso que será usado apenas para monitorar a tensão da bateria.

Lembre-se que a entrada principal para a placa de circuito impresso deve ser de 5V.

Então agora podemos inserir os componentes eletrônicos entre as duas placas. Novamente, é um pouco apertado, mas ainda podemos encaixar tudo. Primeiro vai a bateria que eu prendi usando uma 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 volts. Por último, precisamos conectar todos os servos aos pinos do servo. Ao fazer isso, certifique-se de anotar o número do pino em que você conectou cada servo. Depois de conectarmos todos os servos, podemos simplesmente colocar a tampa curva na placa superior e terminamos o projeto.

Código hexápode do Arduino


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

Portanto, para controlar os servos, usaremos a biblioteca básica do Servo e para a comunicação Bluetooth precisamos incluir também a biblioteca SoftwareSerial. Primeiro precisamos definir todos os objetos servo assim 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)

// Create servo object
Servo s24;
Servo s23;
Servo s22;Code language: Arduino (arduino)

Na seção de configuração precisamos inicializar a comunicação Bluetooth, os modos dos pinos 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); // Default baud rate of the Bluetooth module
  Bluetooth.setTimeout(1);
  delay(20);
  pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
  pinMode(echoPin, INPUT); // Sets the echoPin as an Input
  pinMode(ledB, OUTPUT);
  // Head
  s15.attach(36, 600, 2400);
  s14.attach(35, 600, 2400);
  s13.attach(34, 600, 2400); //grip
  // Tail
  s5.attach(26, 600, 2400); // Tail
  // Leg 4
  s10.attach(31, 600, 2400);
  s11.attach(32, 600, 2400);
  s12.attach(33, 600, 2400); //rot
  // Leg 5
  s7.attach(28, 600, 2400);
  s8.attach(29, 600, 2400);
  s9.attach(30, 600, 2400); //rot
  // Leg 6
  s1.attach(22, 600, 2400);
  s2.attach(23, 600, 2400);
  s3.attach(24, 600, 2400); //rot
  // Leg 1
  s18.attach(39, 600, 2400);
  s17.attach(38, 600, 2400);
  s16.attach(37, 600, 2400); //rot
  // Leg 2
  s21.attach(42, 600, 2400);
  s20.attach(41, 600, 2400);
  s19.attach(40, 600, 2400); //rot
  // Leg 3
  s24.attach(45, 600, 2400);
  s23.attach(44, 600, 2400);
  s22.attach(43, 600, 2400); //rotCode language: Arduino (arduino)

Em seguida, usando as funções write(), movemos os servos para sua posição inicial. Aqui é onde podemos calibrar nossos servos. Considere que você não poderá 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í podemos programar o movimento do robô.
// == Move to initial position
  // Head
  s15.write(72);
  s14.write(50);
  s13.write(90); // Grip
  
  s5.write(65); // Tail
  
  // Leg 4
  s10.write(65);
  s11.write(35);
  s12.write(40);
  // Leg 5
  s7.write(80);
  s8.write(50);
  s9.write(25);
  // Leg 6
  s1.write(90);
  s2.write(45);
  s3.write(60);

  // Leg 1
  s18.write(60);
  s17.write(90);
  s16.write(100);
  // Leg 2
  s21.write(50);
  s20.write(85);
  s19.write(75);
  // Leg 3
  s24.write(50);
  s23.write(80);
  s22.write(80);Code language: Arduino (arduino)

Quando se trata de programar um movimento hexápode, existem várias maneiras de fazer isso, como usar uma cinemática direta ou inversa. Esses métodos incluem uma matemática séria onde a posição de cada articulação é calculada com base nas entradas para a posição final desejada do corpo. No entanto, decidi torná-lo um pouco menos complicado porque de qualquer maneira 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 se posicionam na posição exata desejada.

Então, vamos dar uma olhada em como eu fiz o hexápode andar. Eu 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 através do ar, enquanto na fase de apoio a perna se move da posição final de volta para a posição inicial com o efetor da extremidade da perna tocando o solo. Desta forma, o corpo do hexápode avançará.

Então programo manualmente as posições de cada servo para realizar esses movimentos usando o loop principal e alguns contadores.
void moveLeg1() {
  // Swign phase - move leg though air - from initial to final position
  // Rise the leg
  if (i1L1 <= 10) {
    s18.write(60 - i1L1 * 2);
    s17.write(90 - i1L1 * 3);
    i1L1++;
  }
  // Rotate the leg
  if (i2L1 <= 30) {
    s16.write(100 - i2L1);
    i2L1++;

  }
  // Move back to touch the ground
  if (i2L1 > 20 & i3L1 <= 10) {
    s18.write(40 + i3L1 * 2);
    s17.write(60 + i3L1 * 3);
    i3L1++;
  }
  // Stance phase - move leg while touching the ground
  // Rotate back to initial position
  if (i2L1 >= 30) {
    s16.write(70 + i4L1);
    i4L1++;
    l1status = HIGH;
  }
  // Reset the counters for repeating the process
  if (i4L1 >= 30) {
    i1L1 = 0;
    i2L1 = 0;
    i3L1 = 0;
    i4L1 = 0;
    i5L1 = 0;
  }
  // Each iteration or step is executed in the main loop section where there is also a delay time for controlling the speed of movement
}Code language: Arduino (arduino)

Então, primeiro os dois servos externos levantam a perna e o terceiro servo conectado ao corpo começa a girar em uma direção específica. Quando o terceiro servo está 10 passos antes de parar de girar, 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 movida de sua posição inicial para a final. Em seguida, giramos o terceiro servo da posição final para a inicial, e isso completa a fase de apoio. Depois que a perna executa um ciclo, os contadores são redefinidos e a perna repetirá o ciclo várias vezes. Cada iteração ou etapa é executada na seção do loop principal, onde também há um tempo de atraso 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 conseguir movimentos reversos, esquerdo e direito. De maneira semelhante, usando contadores para acompanhar os passos, programei o resto das funções, como mover a cabeça, mover a cauda, ​​​​as mandíbulas e assim por diante.

Então, por exemplo, se quisermos mover o robô para frente, precisamos chamar as seis funções personalizadas moveLeg() que se repetirão constantemente no loop principal.
// Move forward
  if (m == 2) {
    moveLeg1();
    moveLeg3();
    moveLeg5();
    if (l1status == HIGH) {
      moveLeg2();
      moveLeg4();
      moveLeg6();
    }
  }Code language: Arduino (arduino)

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

Esses comandos são, na verdade, provenientes do módulo Bluetooth ou do aplicativo Android personalizado do nosso smartphone.
// Check for incoming data
  if (Bluetooth.available() > 0) {
    dataIn = Bluetooth.read();  // Read the dataCode language: Arduino (arduino)

Aplicativo Android Robot Ant Robot


Vamos dar uma olhada no aplicativo agora e ver que tipo de dados ele está realmente enviando para o Arduino. Eu fiz o aplicativo usando o aplicativo online do MIT App Inventor e veja como funciona.

Então os gráficos do aplicativo são na verdade imagens que eu fiz e coloquei como botões. Na parte inferior temos um controle deslizante para controlar a velocidade do robô e na parte superior temos os botões para conexão com o módulo Bluetooth.

Vamos dar uma olhada no programa ou nos blocos por trás do aplicativo.

Assim, por exemplo, se clicarmos no botão Forward, os blocos na instrução “if” serão executados. Isso significa que enviaremos o número 2 para o Arduino e ele executará o conjunto de funções avançar. Ao mesmo tempo, podemos notar que alteramos a imagem do botão para a outra versão destacada da mesma imagem. Se pressionarmos novamente o mesmo botão, agora os blocos da instrução “else” serão executados e isso enviará o número 0 para o Arduino que irá zerar todos os contadores e mover o robô para suas posições iniciais. Também voltamos a imagem inicial desse botão. Então eu 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 aplicativo Android pronto para ser instalado em seu smartphone:

Vamos dar uma olhada em mais duas funções no programa Arduino e são o monitor de tensão da bateria e o sensor ultrassônico.
// Monitor the battery voltage
    int sensorValue = analogRead(A3);
    float voltage = sensorValue * (5.00 / 1023.00) * 2.9; // Convert the reading values from 5v to suitable 12V i
    Serial.println(voltage);
    // If voltage is below 11V turn on the LED
    if (voltage < 11) {
      digitalWrite(ledB, HIGH);
    }
    else {
      digitalWrite(ledB, LOW);
    }Code language: Arduino (arduino)

Portanto, se a voltagem da bateria for inferior a 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.
// Get the distance from the ultrasonic sensor
    if (getDistance() > 40) {
      att = 0;
    }
    if (getDistance() <= 40) {
      att = 1;
      dataIn = 99;
    }Code language: Arduino (arduino)

Caso não haja mais objeto na frente ele dispensará o ataque e se o objeto ainda estiver presente e mais próximo da cabeça o robô atacará.
// If there is an object in front of the sensor prepare for attack
  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();
      }
    }
  }
  // If there is no longer object in front, dismiss the attack
  if (att == 2) {
    dismissAttack();
    if (aStatus == HIGH) {
      dataIn = 0;
      att = 0;
    }
  }
  // If there is closer to the sensor attack
  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();
    }
  }Code language: Arduino (arduino)

Então, isso é praticamente tudo para este vídeo.

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

Observe que, se você decidir construir este projeto, precisa estar preparado para enfrentar alguns desafios. O maior problema para mim foi o baixo desempenho dos servos que usei. Espero que tenham 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 do Arduino.

Processo de manufatura

  1. Robô Raspberry Pi controlado por Bluetooth
  2. Obstáculos para evitar o robô com servo motor
  3. Robô seguidor de linha
  4. Controle de um robô Roomba com Arduino e dispositivo Android
  5. Robô controlado por fala
  6. Robô de piano controlado por Arduino:PiBot
  7. Littlearm 2C:Construir um braço de robô Arduino impresso em 3D
  8. Robô assistente autônomo da casa
  9. Controlar Arduino Robot Arm com aplicativo Android
  10. Robô para navegação interna supercool