Robô Arduino Mecanum Wheels

Neste tutorial vamos aprender a construir um robô Arduino Mecanum Wheels que é capaz de se mover em qualquer direção. Esta mobilidade única do robô é alcançada usando um tipo especial de rodas, chamadas de Rodas Mecanum.

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

Visão geral

Na verdade, eu projetei e imprimi em 3D essas rodas porque elas podem ser um pouco caras para comprar. Eles funcionam muito bem e devo dizer que dirigir esta plataforma de robô é muito divertido. Podemos controlar o robô sem fio usando os módulos de rádio transceptor NRF24L01, ou no meu caso, estou usando meu DIY RC Transmitter que fiz em um dos meus vídeos anteriores.

Também tornei possível ser controlado usando um smartphone via comunicação Bluetooth. Eu fiz um aplicativo Android personalizado através do qual podemos controlar o robô de rodas Mecanum para se mover em qualquer direção. Além disso, usando o controle deslizante no aplicativo, podemos controlar a velocidade do movimento.

O cérebro desta plataforma de robô é uma placa Arduino Mega que controla cada roda individualmente. Cada roda está conectada a um motor de passo NEMA 17 e, sabendo que os motores de passo podem ser controlados com precisão, adicionei mais um recurso interessante no aplicativo através do qual podemos programar o robô para se mover automaticamente. Usando o botão Salvar, podemos salvar cada posição ou etapa e, em seguida, o robô pode executar automaticamente e repetir essas etapas. Com o mesmo botão, podemos pausar a operação automática, bem como redefinir ou excluir todas as etapas para que possamos armazenar novas.

Modelo 3D do Robô Mecanum Wheels

Para começar, projetei este robô Mecanum Wheels usando um software de modelagem 3D. A plataforma base deste robô é uma caixa simples que farei com placas de MDF de 8mm.

Os quatro motores de passo estão presos a esta plataforma e as rodas Mecanum estão presas aos eixos do motor.

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

Baixe o modelo 3D de montagem de Thangs.

Arquivos STL para impressão 3D:

Como funcionam as rodas Mecanum

Uma roda Mecanum é uma roda com rolos presos à sua circunferência. Esses rolos são posicionados na diagonal ou em um ângulo de 45 graus em relação ao eixo de rotação da roda. Isso faz com que a roda exerça força na direção diagonal ao se mover para frente ou para trás.

Então, girando as rodas em um determinado padrão, utilizamos essas forças diagonais e, assim, o robô pode se mover em qualquer direção.

Também devemos observar aqui que precisamos de dois tipos de rodas Mecanum, muitas vezes chamadas de rodas Mecanum para canhotos e destros. A diferença entre eles é a orientação dos roletes e devem ser instalados no robô em locais específicos. O eixo de rotação do rolo superior de cada roda deve apontar para o centro do robô.

Aqui está uma rápida demonstração de como o robô se move dependendo da direção de rotação das rodas.

Se todas as quatro rodas se moverem para frente, o movimento resultante do robô será para frente e vice-versa, se todas as rodas se moverem para trás, o robô se moverá para trás. Para mover para a direita, as rodas direitas precisam girar dentro do robô, enquanto as rodas esquerdas precisam girar fora do robô. A força resultante devido aos roletes posicionados na diagonal fará com que o robô se mova para a direita. O mesmo, mas o oposto acontece quando se move para a esquerda. Com estas rodas também podemos obter movimento na direção diagonal girando apenas duas rodas.

Fazendo o Robô Mecanum Wheels

No entanto, agora deixe-me mostrar como eu construí esta plataforma de robô. Como mencionei, para fazer a base da plataforma estou usando placas de MDF de 8 mm. Usando uma serra de mesa, primeiro cortei todas as peças de acordo com as dimensões do modelo 3D.

Em seguida, usando uma furadeira de 3 mm e uma broca Forstner de 25 mm, fiz as aberturas nos painéis laterais para fixação dos motores de passo. Depois de ter as peças prontas, continuei a montá-las. Eu usei uma cola de madeira e alguns parafusos para prendê-los. O mais importante aqui é ter as aberturas para os motores feitas com precisão para que todas as rodas tenham contato uniforme com a superfície posteriormente.

Claro, você também pode imprimir em 3D esta plataforma base, em vez de fazê-la com MDF, então incluirei um arquivo 3D dela no artigo do site. Por fim, pintei a base e a cobertura com spray na cor branca.

Em seguida estão as rodas Mecanum. Como eu disse anteriormente, essas rodas podem ser um pouco caras para comprar, então é por isso que decidi projetar e imprimir em 3D minhas próprias rodas. As rodas são feitas de duas partes, lado externo e interno, que são fixadas com alguns parafusos e porcas M4. Eles têm 10 roletes cada e um acoplador de eixo projetado especificamente para encaixar em um motor de passo NEMA 17.

Imprimi em 3D todas as peças das rodas Mecanum usando minha impressora 3D Creality CR-10.

Aqui está um link para esta impressora 3D caso você queira conferir.

Então, assim que preparei as peças impressas em 3D, continuei com a fabricação dos eixos para os rolos. Para isso, usei fio de aço de 3 mm de espessura. O comprimento dos eixos precisa ser em torno de 40 mm, então, usando uma ferramenta rotativa, cortei o fio nesse comprimento.

Comecei a montar a roda Mecanum prendendo os dois lados e o acoplador do eixo usando quatro parafusos e porcas M4. O comprimento dos parafusos deve ser de 45 mm.

Para instalar os roletes, primeiro precisamos inserir levemente o eixo através dos orifícios localizados na circunferência do lado interno.

Em seguida, podemos inserir uma pequena arruela M3, inserir o rolo e empurrar o eixo até a ranhura do lado externo da roda. Usei uma única arruela porque não tinha espaço suficiente para inserir uma segunda arruela do outro lado.

Repeti este processo para todos os 10 rolos. É realmente fácil e divertido montar essas rodas. O importante aqui é que os rolos precisam poder se mover livremente.

No final, usei algumas gotas de cola AC em cada um dos orifícios internos para garantir que os eixos não se soltassem.

Ok, assim que as rodas estiverem prontas, podemos seguir em frente com a montagem de todo o robô. Primeiro, precisamos conectar os motores de passo à plataforma base. Para fixá-los no lugar, usei parafusos M3 com um comprimento de 12 mm.

Em seguida, precisamos anexar as rodas aos eixos do motor. O acoplador de eixo que fiz tem uma ranhura para inserir uma porca M3, por onde passa um parafuso M3 e assim podemos prender a roda ao eixo.

Em seguida, para prender a tampa superior à base, prendi hastes rosqueadas em dois cantos da base. Fiz furos na mesma posição na tampa e assim consegui inserir e prender facilmente a tampa na base.

Na parte de trás da base fiz um furo de 20mm para conectar um interruptor mais tarde, assim como um furo de 5mm para prender um LED.

Diagrama de circuito

Agora podemos seguir em frente com a eletrônica. Aqui está o diagrama de circuito completo deste projeto.

Então vamos controlar os quatro motores de passo NEMA 17 usando quatro drivers de passo DRV8825, ou também podemos usar os drivers de passo A4988. Para alimentar os steppers e todo o robô, usaremos uma fonte de alimentação de 12V e, no meu caso, usarei uma bateria 3S Li-Po que fornece cerca de 12V. Para a comunicação via rádio estamos utilizando o módulo NRF24L01, e para a comunicação Bluetooth estamos utilizando o módulo Bluetooth HC-05. Também incluí um divisor de tensão simples que será usado para monitorar a tensão da bateria e uma conexão de LED para indicar quando a tensão da bateria cair abaixo de 11V.

Também incluí um regulador de tensão de 5V dedicado que pode fornecer cerca de 3A de corrente. Isso é opcional, mas estou planejando em um vídeo futuro combinar este projeto com meu projeto Arduino Robot Arm, e para isso eu precisaria de 5V para acionar seus servomotores.

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

Motor de passo – NEMA 17………………
Driver de passo DRV8825…………………
Módulo Transceptor NRF24L01…….…
Módulo Bluetooth HC-05 …………….…
Bateria Li-Po ……………………………….……
Placa Arduino Mega ………………….…

Projeto de PCB

No entanto, para manter os componentes eletrônicos organizados e livrar-se da confusão de fiação, projetei uma PCB personalizada usando o software de projeto de circuito online gratuito EasyEDA. Este PCB funcionará como um escudo Arduino MEGA porque poderemos conectá-lo diretamente em cima da placa Arduino Mega. Eu usei a camada superior e a camada inferior para executar as conexões. Para os pinos do Arduno que não usei, incluí conexões de cabeçalho de pinos para que estejam disponíveis caso queiramos usá-los para algo no futuro. Também incluí pinos de conexão de 12V, 5V e GND, bem como pinos para selecionar a resolução de passo dos drivers.

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 do PCB.

arquivo Gerber:

Então encomendei o PCB da JLCPCB que também é 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. Desta vez eu escolhi a cor do PCB para ser azul para combinar com a cor da placa Arduino. E é isso, agora podemos simplesmente encomendar 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 os componentes menores primeiro, os resistores e os capacitores. Em seguida, inseri e soldei conectores de pinos machos na placa de circuito impresso que serão usados para conectá-la à placa Arduino.

Em seguida, coloquei todos os pinos fêmeas no lugar e os soldei também. Quanto às conexões dos motores de passo e pinos para selecionar a resolução de passo, usei pinos machos. Desta forma, podemos conectar diretamente os motores ao PCB e usar jumpers para selecionar a resolução de passo. Então soldei os blocos de terminais, o aparador e o regulador de tensão.

E é isso, o PCB agora está pronto e podemos continuar inserindo os drivers e conectando os motores a ele. Primeiro, coloquei os jumpers para selecionar a resolução do stepping. Selecionei a resolução do 16º passo conectando os pinos MS3 dos drivers a 5V.

Em cima deles coloquei os drivers DRV8825, bem como conectei o módulo NRF24L01 e o módulo Bluetooth HC-05. Agora podemos simplesmente conectar o PCB à placa Arduno.

Em seguida, conectei a bateria ao bloco de terminais apropriado e as coloquei na plataforma de base.

Aqui eu inseri o interruptor de alimentação no lugar e o conectei ao outro bloco de terminais. Logo acima do botão liga/desliga também inseri o LED indicador de bateria.

O que resta agora é conectar os motores ao PCB. Devemos observar aqui que ao conectar motores opostos, devemos conectar seus conectores opostos também. Isso é necessário mais tarde ao programar o robô, para que, por exemplo, o comando de avanço, mova os dois motores na mesma direção, embora na verdade estejam invertidos e um faça rotação no sentido horário e o outro no sentido anti-horário.

No final, posso simplesmente inserir a tampa na parte superior, e assim terminamos com este projeto de robô Mecanum Wheels.

Código Arduino do Robô Mecanum Wheels

O que resta para este vídeo é dar uma olhada no código do Arduino. Na verdade, existem dois códigos Arduino separados. Este é para controlar o robô usando os módulos NRF24L01 e outro é para controlar o robô usando um smartphone.

Código Arduino para controlar o robô usando os módulos NRF24L01:

/*
   === Arduino Mecanum Wheels Robot ===
     Radio control with NRF24L01 
  by Dejan, www.HowToMechatronics.com
  Libraries:
  RF24, https://github.com/tmrh20/RF24/
  AccelStepper by Mike McCauley: http://www.airspayce.com/mikem/arduino/AccelStepper/index.html

*/

#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>

#include <AccelStepper.h>

RF24 radio(48, 49);   // nRF24L01 (CE, CSN)

const byte address[6] = "00001";
unsigned long lastReceiveTime = 0;
unsigned long currentTime = 0;

// Define the stepper motors and the pins the will use
AccelStepper LeftBackWheel(1, 42, 43);   // (Type:driver, STEP, DIR) - Stepper1
AccelStepper LeftFrontWheel(1, 40, 41);  // Stepper2
AccelStepper RightBackWheel(1, 44, 45);  // Stepper3
AccelStepper RightFrontWheel(1, 46, 47); // Stepper4

int wheelSpeed = 1500;

// Max size of this struct is 32 bytes - NRF24L01 buffer limit
struct Data_Package {
  byte j1PotX;
  byte j1PotY;
  byte j1Button;
  byte j2PotX;
  byte j2PotY;
  byte j2Button;
  byte pot1;
  byte pot2;
  byte tSwitch1;
  byte tSwitch2;
  byte button1;
  byte button2;
  byte button3;
  byte button4;
};
Data_Package data; //Create a variable with the above structure

void setup() {
  // Set initial seed values for the steppers
  LeftFrontWheel.setMaxSpeed(3000);
  LeftBackWheel.setMaxSpeed(3000);
  RightFrontWheel.setMaxSpeed(3000);
  RightBackWheel.setMaxSpeed(3000);

  radio.begin();
  radio.openReadingPipe(0, address);
  radio.setAutoAck(false);
  radio.setDataRate(RF24_250KBPS);
  radio.setPALevel(RF24_PA_LOW);
  radio.startListening(); //  Set the module as receiver

  Serial.begin(115200);
}

void loop() {
  // Check whether we keep receving data, or we have a connection between the two modules
  currentTime = millis();
  if ( currentTime - lastReceiveTime > 1000 ) { // If current time is more then 1 second since we have recived the last data, that means we have lost connection
    resetData(); // If connection is lost, reset the data. It prevents unwanted behavior, for example if a drone jas a throttle up, if we lose connection it can keep flying away if we dont reset the function
  }
  // Check whether there is data to be received
  if (radio.available()) {
    radio.read(&data, sizeof(Data_Package)); // Read the whole data and store it into the 'data' structure
    lastReceiveTime = millis(); // At this moment we have received the data
  }
  // Set speed - left potentiometer
  wheelSpeed = map(data.pot1, 0, 255, 100, 3000);
  
  if (data.j1PotX > 150) {
    moveSidewaysLeft();
  }
  else if (data.j1PotX < 100) {
    moveSidewaysRight();
  }
  else if (data.j1PotY > 160) {
    moveForward();
  }
  else if (data.j1PotY < 100) {
    moveBackward();
  }
  else if (data.j2PotX < 100 & data.j2PotY > 160) {
    moveRightForward();
  }
  else if (data.j2PotX > 160 & data.j2PotY > 160) {
    moveLeftForward();
  }
  else if (data.j2PotX < 100 & data.j2PotY < 100) {
    moveRightBackward();
  }
  else if (data.j2PotX > 160 & data.j2PotY < 100) {
    moveLeftBackward();
  }
  else if (data.j2PotX < 100) {
    rotateRight();
  }
  else if (data.j2PotX > 150) {
    rotateLeft();
  }
  else {
    stopMoving();
  }
  // Execute the steps
  LeftFrontWheel.runSpeed();
  LeftBackWheel.runSpeed();
  RightFrontWheel.runSpeed();
  RightBackWheel.runSpeed();
  
  // Monitor the battery voltage
  int sensorValue = analogRead(A0);
  float voltage = sensorValue * (5.0 / 1023.00) * 3; // Convert the reading values from 5v to suitable 12V i
  // If voltage is below 11V turn on the LED
  if (voltage < 11) {
    digitalWrite(led, HIGH);
  }
  else {
    digitalWrite(led, LOW);
  }
}

void moveForward() {
  LeftFrontWheel.setSpeed(wheelSpeed);
  LeftBackWheel.setSpeed(wheelSpeed);
  RightFrontWheel.setSpeed(wheelSpeed);
  RightBackWheel.setSpeed(wheelSpeed);
}
void moveBackward() {
  LeftFrontWheel.setSpeed(-wheelSpeed);
  LeftBackWheel.setSpeed(-wheelSpeed);
  RightFrontWheel.setSpeed(-wheelSpeed);
  RightBackWheel.setSpeed(-wheelSpeed);
}
void moveSidewaysRight() {
  LeftFrontWheel.setSpeed(wheelSpeed);
  LeftBackWheel.setSpeed(-wheelSpeed);
  RightFrontWheel.setSpeed(-wheelSpeed);
  RightBackWheel.setSpeed(wheelSpeed);
}
void moveSidewaysLeft() {
  LeftFrontWheel.setSpeed(-wheelSpeed);
  LeftBackWheel.setSpeed(wheelSpeed);
  RightFrontWheel.setSpeed(wheelSpeed);
  RightBackWheel.setSpeed(-wheelSpeed);
}
void rotateLeft() {
  LeftFrontWheel.setSpeed(-wheelSpeed);
  LeftBackWheel.setSpeed(-wheelSpeed);
  RightFrontWheel.setSpeed(wheelSpeed);
  RightBackWheel.setSpeed(wheelSpeed);
}
void rotateRight() {
  LeftFrontWheel.setSpeed(wheelSpeed);
  LeftBackWheel.setSpeed(wheelSpeed);
  RightFrontWheel.setSpeed(-wheelSpeed);
  RightBackWheel.setSpeed(-wheelSpeed);
}
void moveRightForward() {
  LeftFrontWheel.setSpeed(wheelSpeed);
  LeftBackWheel.setSpeed(0);
  RightFrontWheel.setSpeed(0);
  RightBackWheel.setSpeed(wheelSpeed);
}
void moveRightBackward() {
  LeftFrontWheel.setSpeed(0);
  LeftBackWheel.setSpeed(-wheelSpeed);
  RightFrontWheel.setSpeed(-wheelSpeed);
  RightBackWheel.setSpeed(0);
}
void moveLeftForward() {
  LeftFrontWheel.setSpeed(0);
  LeftBackWheel.setSpeed(wheelSpeed);
  RightFrontWheel.setSpeed(wheelSpeed);
  RightBackWheel.setSpeed(0);
}
void moveLeftBackward() {
  LeftFrontWheel.setSpeed(-wheelSpeed);
  LeftBackWheel.setSpeed(0);
  RightFrontWheel.setSpeed(0);
  RightBackWheel.setSpeed(-wheelSpeed);
}
void stopMoving() {
  LeftFrontWheel.setSpeed(0);
  LeftBackWheel.setSpeed(0);
  RightFrontWheel.setSpeed(0);
  RightBackWheel.setSpeed(0);
}


void resetData() {
  // Reset the values when there is no radio connection - Set initial default values
  data.j1PotX = 127;
  data.j1PotY = 127;
  data.j2PotX = 127;
  data.j2PotY = 127;
  data.j1Button = 1;
  data.j2Button = 1;
  data.pot1 = 1;
  data.pot2 = 1;
  data.tSwitch1 = 1;
  data.tSwitch2 = 1;
  data.button1 = 1;
  data.button2 = 1;
  data.button3 = 1;
  data.button4 = 1;
}Code language: Arduino (arduino)

Descrição: Então, aqui estamos usando a biblioteca RF24 para comunicação de rádio e a biblioteca AccelStepper para controlar os motores de passo. Primeiro precisamos definir os pinos aos quais todos eles estão conectados, definir algumas variáveis necessárias para o programa abaixo, e na seção de configuração definir a velocidade máxima dos steppers e iniciar a comunicação via rádio.

Na seção de loop, começamos lendo os dados provenientes do transmissor RC. O código do transmissor RC, bem como mais detalhes de como essa comunicação funciona, podem ser encontrados no meu tutorial específico para isso.

Portanto, dependendo dos dados recebidos, por exemplo, se o Joystick esquerdo for movido para frente, seu valor será maior que 160 e, nesse caso, chamará a função personalizada moveForward(). Se olharmos para esta função, podemos ver que tudo o que ela faz é definir a velocidade dos motores para positiva. Para mover para trás, a velocidade é definida como negativa. Então, para se mover em todas as outras direções, basta definir as rotações das rodas adequadamente, conforme explicado no início.

Para executar esses comandos, na seção de loop, precisamos chamar as funções runSpeed() para todos os steppers. Na seção de loop também lemos a entrada analógica do divisor de tensão vindo da bateria, e de acordo com este valor podemos saber quando a tensão da bateria cairá abaixo de 11V para podermos acender o LED indicador.

Código Arduino para controlar o robô usando um smartphone:

/*
   === Arduino Mecanum Wheels Robot ===
     Smartphone control via Bluetooth 
  by Dejan, www.HowToMechatronics.com
  Libraries:
  RF24, https://github.com/tmrh20/RF24/
  AccelStepper by Mike McCauley: http://www.airspayce.com/mikem/arduino/AccelStepper/index.html

*/

#include <SoftwareSerial.h>
#include <AccelStepper.h>

SoftwareSerial Bluetooth(A8, 38); // Arduino(RX, TX) - HC-05 Bluetooth (TX, RX)

// Define the stepper motors and the pins the will use
AccelStepper LeftBackWheel(1, 42, 43);   // (Type:driver, STEP, DIR) - Stepper1
AccelStepper LeftFrontWheel(1, 40, 41);  // Stepper2
AccelStepper RightBackWheel(1, 44, 45);  // Stepper3
AccelStepper RightFrontWheel(1, 46, 47); // Stepper4

#define led 14

int wheelSpeed = 1500;

int dataIn, m;

int lbw[50], lfw[50], rbw[50], rfw[50]; // for storing positions/steps
int index = 0;

void setup() {
  // Set initial seed values for the steppers
  LeftFrontWheel.setMaxSpeed(3000);
  LeftBackWheel.setMaxSpeed(3000);
  RightFrontWheel.setMaxSpeed(3000);
  RightBackWheel.setMaxSpeed(3000);

  Serial.begin(38400);
  Bluetooth.begin(38400); // Default baud rate of the Bluetooth module
  Bluetooth.setTimeout(1);
  delay(20);

  pinMode(led, OUTPUT);

}

void loop() {
  // Check for incoming data

  if (Bluetooth.available() > 0) {
    dataIn = Bluetooth.read();  // Read the data

    if (dataIn == 0) {
      m = 0;
    }
    if (dataIn == 1) {
      m = 1;
    }
    if (dataIn == 2) {
      m = 2;
    }
    if (dataIn == 3) {
      m = 3;
    }
    if (dataIn == 4) {
      m = 4;
    }
    if (dataIn == 5) {
      m = 5;
    }
    if (dataIn == 6) {
      m = 6;
    }
    if (dataIn == 7) {
      m = 7;
    }
    if (dataIn == 8) {
      m = 8;

    }
    if (dataIn == 9) {
      m = 9;
    }
    if (dataIn == 10) {
      m = 10;
    }
    if (dataIn == 11) {
      m = 11;
    }

    if (dataIn == 12) {
      m = 12;
    }
    if (dataIn == 14) {
      m = 14;
    }
    // Set speed
    if (dataIn >= 16) {
      wheelSpeed = dataIn * 10;
      Serial.println(wheelSpeed);
    }
  }
  if (m == 4) {
    moveSidewaysLeft();
  }
  if (m == 5) {
    moveSidewaysRight();
  }
  if (m == 2) {
    moveForward();
  }
  if (m == 7) {
    moveBackward();
  }
  if (m == 3) {
    moveRightForward();
  }
  if (m == 1) {
    moveLeftForward();
  }
  if (m == 8) {
    moveRightBackward();
  }
  if (m == 6) {
    moveLeftBackward();
  }
  if (m == 9) {
    rotateLeft();
  }
  if (m == 10) {
    rotateRight();
  }

  if (m == 0) {
    stopMoving();
  }
  //Serial.println(dataIn);
  // If button "SAVE" is pressed
  if (m == 12) {
    if (index == 0) {
      LeftBackWheel.setCurrentPosition(0);
      LeftFrontWheel.setCurrentPosition(0);
      RightBackWheel.setCurrentPosition(0);
      RightFrontWheel.setCurrentPosition(0);
    }
    lbw[index] = LeftBackWheel.currentPosition();  // save position into the array
    lfw[index] = LeftFrontWheel.currentPosition();
    rbw[index] = RightBackWheel.currentPosition();
    rfw[index] = RightFrontWheel.currentPosition();
    index++;                        // Increase the array index
    m = 0;
  }

  if (m == 14) {
    runSteps();
    if (dataIn != 14) {
      stopMoving();
      memset(lbw, 0, sizeof(lbw)); // Clear the array data to 0
      memset(lfw, 0, sizeof(lfw));
      memset(rbw, 0, sizeof(rbw));
      memset(rfw, 0, sizeof(rfw));
      index = 0;  // Index to 0
    }
  }

  LeftFrontWheel.runSpeed();
  LeftBackWheel.runSpeed();
  RightFrontWheel.runSpeed();
  RightBackWheel.runSpeed();

  // Monitor the battery voltage
  int sensorValue = analogRead(A0);
  float voltage = sensorValue * (5.0 / 1023.00) * 3; // 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(led, HIGH);
  }
  else {
    digitalWrite(led, LOW);
  }

}

void runSteps() {
  for (int i = index - 1; i >= 0; i--) { // Run through all steps(index)
    LeftFrontWheel.moveTo(lfw[i]);
    LeftFrontWheel.setSpeed(wheelSpeed);
    LeftBackWheel.moveTo(lbw[i]);
    LeftBackWheel.setSpeed(wheelSpeed);
    RightFrontWheel.moveTo(rfw[i]);
    RightFrontWheel.setSpeed(wheelSpeed);
    RightBackWheel.moveTo(rbw[i]);
    RightBackWheel.setSpeed(wheelSpeed);

    while (LeftBackWheel.currentPosition() != lbw[i] & LeftFrontWheel.currentPosition() != lfw[i] & RightFrontWheel.currentPosition() != rfw[i] & RightBackWheel.currentPosition() != rbw[i]) {
      LeftFrontWheel.runSpeedToPosition();
      LeftBackWheel.runSpeedToPosition();
      RightFrontWheel.runSpeedToPosition();
      RightBackWheel.runSpeedToPosition();

      if (Bluetooth.available() > 0) {      // Check for incomding data
        dataIn = Bluetooth.read();
        if ( dataIn == 15) {           // If button "PAUSE" is pressed
          while (dataIn != 14) {         // Wait until "RUN" is pressed again
            if (Bluetooth.available() > 0) {
              dataIn = Bluetooth.read();
              if ( dataIn == 13) {
                stopMoving();
                break;
              }
            }
          }
        }
        if (dataIn >= 16) {
          wheelSpeed = dataIn * 10;
          dataIn = 14;
        }
        if ( dataIn == 13) {
          break;
        }
      }
    }
  }
  // Go back through steps
  for (int i = 1; i <= index - 1; i++) { // Run through all steps(index)

    LeftFrontWheel.moveTo(lfw[i]);
    LeftFrontWheel.setSpeed(wheelSpeed);
    LeftBackWheel.moveTo(lbw[i]);
    LeftBackWheel.setSpeed(wheelSpeed);
    RightFrontWheel.moveTo(rfw[i]);
    RightFrontWheel.setSpeed(wheelSpeed);
    RightBackWheel.moveTo(rbw[i]);
    RightBackWheel.setSpeed(wheelSpeed);

    while (LeftBackWheel.currentPosition() != lbw[i]& LeftFrontWheel.currentPosition() != lfw[i] & RightFrontWheel.currentPosition() != rfw[i] & RightBackWheel.currentPosition() != rbw[i]) {

      LeftFrontWheel.runSpeedToPosition();
      LeftBackWheel.runSpeedToPosition();
      RightFrontWheel.runSpeedToPosition();
      RightBackWheel.runSpeedToPosition();
      //Serial.print("  current: ");
      //Serial.println(LeftBackWheel.currentPosition());

      if (Bluetooth.available() > 0) {      // Check for incomding data
        dataIn = Bluetooth.read();
        if ( dataIn == 15) {           // If button "PAUSE" is pressed
          while (dataIn != 14) {         // Wait until "RUN" is pressed again
            if (Bluetooth.available() > 0) {
              dataIn = Bluetooth.read();
              if ( dataIn == 13) {
                stopMoving();
                break;
              }
            }
          }
        }
        if (dataIn >= 16) {
          wheelSpeed = dataIn * 10;
          dataIn = 14;
        }
        if ( dataIn == 13) {
          //Serial.println("DEKI");
          break;
        }
      }
    }
  }
}

void moveForward() {
  LeftFrontWheel.setSpeed(wheelSpeed);
  LeftBackWheel.setSpeed(wheelSpeed);
  RightFrontWheel.setSpeed(wheelSpeed);
  RightBackWheel.setSpeed(wheelSpeed);
}
void moveBackward() {
  LeftFrontWheel.setSpeed(-wheelSpeed);
  LeftBackWheel.setSpeed(-wheelSpeed);
  RightFrontWheel.setSpeed(-wheelSpeed);
  RightBackWheel.setSpeed(-wheelSpeed);
}
void moveSidewaysRight() {
  LeftFrontWheel.setSpeed(wheelSpeed);
  LeftBackWheel.setSpeed(-wheelSpeed);
  RightFrontWheel.setSpeed(-wheelSpeed);
  RightBackWheel.setSpeed(wheelSpeed);
}
void moveSidewaysLeft() {
  LeftFrontWheel.setSpeed(-wheelSpeed);
  LeftBackWheel.setSpeed(wheelSpeed);
  RightFrontWheel.setSpeed(wheelSpeed);
  RightBackWheel.setSpeed(-wheelSpeed);
}
void rotateLeft() {
  LeftFrontWheel.setSpeed(-wheelSpeed);
  LeftBackWheel.setSpeed(-wheelSpeed);
  RightFrontWheel.setSpeed(wheelSpeed);
  RightBackWheel.setSpeed(wheelSpeed);
}
void rotateRight() {
  LeftFrontWheel.setSpeed(wheelSpeed);
  LeftBackWheel.setSpeed(wheelSpeed);
  RightFrontWheel.setSpeed(-wheelSpeed);
  RightBackWheel.setSpeed(-wheelSpeed);
}
void moveRightForward() {
  LeftFrontWheel.setSpeed(wheelSpeed);
  LeftBackWheel.setSpeed(0);
  RightFrontWheel.setSpeed(0);
  RightBackWheel.setSpeed(wheelSpeed);
}
void moveRightBackward() {
  LeftFrontWheel.setSpeed(0);
  LeftBackWheel.setSpeed(-wheelSpeed);
  RightFrontWheel.setSpeed(-wheelSpeed);
  RightBackWheel.setSpeed(0);
}
void moveLeftForward() {
  LeftFrontWheel.setSpeed(0);
  LeftBackWheel.setSpeed(wheelSpeed);
  RightFrontWheel.setSpeed(wheelSpeed);
  RightBackWheel.setSpeed(0);
}
void moveLeftBackward() {
  LeftFrontWheel.setSpeed(-wheelSpeed);
  LeftBackWheel.setSpeed(0);
  RightFrontWheel.setSpeed(0);
  RightBackWheel.setSpeed(-wheelSpeed);
}
void stopMoving() {
  LeftFrontWheel.setSpeed(0);
  LeftBackWheel.setSpeed(0);
  RightFrontWheel.setSpeed(0);
  RightBackWheel.setSpeed(0);
}Code language: Arduino (arduino)

Descrição: O outro código para controlar o robô usando o aplicativo Android é muito semelhante e funciona da mesma maneira. Aqui, em vez do módulo de rádio, precisamos definir o módulo Bluetooth e inicializar sua comunicação na seção de configuração. Então, novamente, primeiro lemos os dados recebidos do smartphone ou do aplicativo Android e, de acordo com isso, informamos ao robô em qual direção ele deve se mover.

Se dermos uma olhada no aplicativo para Android, podemos ver que ele simplesmente envia números de 0 a 15 através do Bluetooth quando os botões são pressionados.

O aplicativo é feito usando o aplicativo online MIT App Inventor e você pode encontrar mais detalhes sobre ele no meu tutorial específico para ele.

Here you can download this app as well as the editable project file:

For programming the automatic robot movement with this app, when we press the “SAVE” button we simply store the current positions of the stepper motors into arrays. Then when we press the “RUN” button, we call the runSteps() custom function which executes or runs through all stored steps using some for and while loops.

Espero que tenham gostado deste tutorial 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.

Operação automática da plataforma Arduino Robot Arm e Mecanum Wheels Gimbal Arduino DIY | Plataforma auto-estabilizadora