Operação automática da plataforma Arduino Robot Arm e Mecanum Wheels
Neste tutorial, mostrarei como fiz minha plataforma robótica Mecanum Wheels do meu vídeo anterior, para trabalhar em conjunto e operar automaticamente com meu braço robótico impresso em 3D, também um projeto Arduino de um dos meus vídeos anteriores.
Você pode assistir ao vídeo a seguir ou ler o tutorial escrito abaixo.
Visão geral
Assim, podemos controlar o robô de rodas Mecanum com o aplicativo Android personalizado da mesma forma que explicamos no vídeo anterior. Além disso, agora o aplicativo também possui botões para controlar o braço do robô.
O aplicativo de controle do braço do robô original realmente tinha controles deslizantes para controlar as articulações do robô, mas isso estava causando alguns problemas com a estabilidade do braço. Dessa forma, o braço funciona muito melhor, portanto, fornecerei esta versão atualizada do aplicativo de controle do braço do robô e o código do Arduino para o projeto original do braço do robô também.
No entanto, a característica mais legal deste robô é a capacidade de armazenar os movimentos e depois repeti-los automaticamente.
Usando o botão Salvar, podemos simplesmente armazenar as posições dos motores para cada etapa. Em seguida, basta clicar no botão Executar e o robô repetirá automaticamente os movimentos armazenados várias vezes.
Construindo o robô Arduino
Ok, então aqui eu tenho a plataforma de rodas Mecanum já montada e você pode encontrar todos os detalhes sobre ela no meu vídeo anterior.
Além disso, aqui tenho as partes impressas em 3D do braço do robô e dos servomotores e agora mostrarei como montá-los. Aqui está o modelo 3D deste projeto.
Você pode encontrar e baixar este modelo 3D, bem como explorá-lo em seu navegador no Thangs.
Baixe o modelo 3D em Thangs.
Arquivos STL para impressão 3D:
O primeiro servo do braço do robô será montado diretamente na tampa superior da plataforma de rodas mecanum.
Marquei o local e com uma furadeira de 10mm fiz vários furos.
Em seguida, usando uma grosa, cortei os orifícios e ajustei a abertura para o servo. Eu prendi o servo na placa superior usando quatro parafusos e porcas M3.
Então neste eixo de saída deste servo, usando o chifre redondo que vem como acessório com o servo, precisamos prender a próxima parte ou a cintura do braço do robô. No entanto, podemos notar que desta forma a peça fica cerca de 8mm acima da placa. Por isso, anexei duas peças de placas de MDF de 8mm, para que a parte da cintura deslize sobre elas e assim a articulação fique mais estável.
O chifre redondo é preso à parte da cintura usando os parafusos auto-roscantes que vêm como acessórios com o servo e, em seguida, o chifre redondo é preso ao eixo do servo usando os parafusos apropriados que também vêm com o servo.
Em seguida, temos o servo de ombro. Simplesmente o colocamos no lugar e o prendemos à peça impressa em 3D usando parafusos autorroscantes.
O chifre redondo vai para a próxima parte e, em seguida, as duas partes são presas uma à outra usando um parafuso no eixo de saída do servo.
Devemos observar que antes de prender as peças, precisamos nos certificar de que a peça tenha toda a amplitude de movimento. Aqui eu também adicionei uma faixa de borracha na articulação do ombro para ajudar um pouco o servo, porque este servo carrega o peso do resto do braço, bem como a carga útil.
Da mesma forma, montei o resto do braço do robô.
Em seguida, precisamos montar o mecanismo da garra. A garra é controlada com um servo motor SG90, no qual, primeiro, anexamos um link de engrenagem projetado sob medida. Nós emparelhamos este elo com outro elo de engrenagem do outro lado, que é preso usando parafusos e porcas M4. Na verdade, todos os outros links são conectados usando parafusos e porcas M4.
O modelo 3D da pinça originalmente tem furos de 3 mm, mas eu não tinha parafusos M3 suficientes, então expandi os furos usando uma broca de 4 mm e usei os parafusos M4.
Uma vez que montei o mecanismo da garra, prendi-o ao último servo e assim o braço do robô foi concluído.
Em seguida, fiz algum gerenciamento de cabos. Passei os fios do servo pelos orifícios especificamente projetados do braço do robô. Com uma furadeira de 10mm fiz um furo na placa superior para que os fios possam passar.
Usando um zip-tie eu prendi todos os fios juntos, e agora o que resta é conectá-los à placa Arduino.
Diagrama de circuito do robô Arduino
Aqui está o diagrama de circuito deste projeto e como tudo precisa ser conectado.
Você pode obter os componentes necessários para este projeto nos links abaixo:
- Motor de passo – NEMA 17 …………..…
- Driver de passo DRV8825 ……….…….…
- Servomotor MG996R………………….….
- SG90 Micro Servo Motor …………….….
- Módulo Bluetooth HC-05 …………….…
- Bateria Li-Po ……………………………….……
- Placa Arduino Mega ………….……….…
No tutorial anterior, expliquei como funciona a parte do robô de rodas Mecanum e também mostrei como fiz uma PCB personalizada para ela.
Incluí um regulador de tensão de 5V nesta placa para que possamos fazer este projeto, ou conectar os servo motores porque eles trabalham em 5V. O regulador de tensão é o LM350, que pode suportar até 3 amperes de corrente. Todos os seis servos do braço do robô podem consumir cerca de 2 amperes a 3 amperes de corrente, o que significa que ele pode lidar com eles, mas isso fará com que o regulador fique muito quente.
Portanto, anexei um dissipador de calor a ele, bem como um pequeno ventilador de 12V DC para soprar um pouco de ar, pois o dissipador de calor em si não era suficiente para resfriar o regulador.
Liguei os fios de sinal dos servos aos pinos digitais do Arduino do número 5 ao 10, e para alimentar usei o pino de 5V na placa de circuito impresso. Finalmente, empurrei todos os fios para dentro da plataforma e prendi a placa superior usando as duas porcas.
E é isso, agora terminamos com este projeto.
Código do Arduino
O que resta é dar uma olhada em como o código do Arduino e o aplicativo Android funcionam. 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.
Então primeiro precisamos definir os 6 servos, os 4 motores de passo e a comunicação Bluetooth, bem como definir algumas variáveis necessárias para o programa abaixo. Na seção de configuração definimos a velocidade máxima dos steppers, definimos os pinos aos quais os servos estão conectados, iniciamos a comunicação Bluetooth e colocamos o braço do robô na posição inicial.
#include <SoftwareSerial.h>
#include <AccelStepper.h>
#include <Servo.h>
Servo servo01;
Servo servo02;
Servo servo03;
Servo servo04;
Servo servo05;
Servo servo06;
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 lbw[50], lfw[50], rbw[50], rfw[50]; // arrays for storing positions/steps
int servo1Pos, servo2Pos, servo3Pos, servo4Pos, servo5Pos, servo6Pos; // current position
int servo1PPos, servo2PPos, servo3PPos, servo4PPos, servo5PPos, servo6PPos; // previous position
int servo01SP[50], servo02SP[50], servo03SP[50], servo04SP[50], servo05SP[50], servo06SP[50]; // for storing positions/steps
int speedDelay = 20;
int index = 0;
int dataIn;
int m = 0;
void setup() {
// Set initial seed values for the steppers
LeftFrontWheel.setMaxSpeed(3000);
LeftBackWheel.setMaxSpeed(3000);
RightFrontWheel.setMaxSpeed(3000);
RightBackWheel.setMaxSpeed(3000);
pinMode(led, OUTPUT);
servo01.attach(5);
servo02.attach(6);
servo03.attach(7);
servo04.attach(8);
servo05.attach(9);
servo06.attach(10);
Bluetooth.begin(38400); // Default baud rate of the Bluetooth module
Bluetooth.setTimeout(5);
delay(20);
Serial.begin(38400);
// Move robot arm to initial position
servo1PPos = 90;
servo01.write(servo1PPos);
servo2PPos = 100;
servo02.write(servo2PPos);
servo3PPos = 120;
servo03.write(servo3PPos);
servo4PPos = 95;
servo04.write(servo4PPos);
servo5PPos = 60;
servo05.write(servo5PPos);
servo6PPos = 110;
servo06.write(servo6PPos);
}Code language: Arduino (arduino)Então, na seção de loop, começamos verificando se há algum dado de entrada.
// Check for incoming data
if (Bluetooth.available() > 0) {
dataIn = Bluetooth.read(); // Read the dataCode language: Arduino (arduino)Esses dados vêm do smartphone ou do aplicativo Android, então vamos dar uma olhada no tipo de dados que ele está realmente enviando. O aplicativo Android é feito usando o aplicativo online MIT App Inventor. Consiste em botões simples que possuem imagens apropriadas como plano de fundo.
Se dermos uma olhada nos blocos do aplicativo, podemos ver que tudo o que ele faz é enviar números de um byte quando os botões são clicados.
Então, dependendo do botão clicado, dizemos ao Arduino o que fazer. Por exemplo, se recebermos o número '2', a plataforma de rodas mecanum avançará, usando a função personalizada moveForward.
if (dataIn == 2) {
m = 2;
}
//
if (m == 2) {
moveForward();
}Code language: Arduino (arduino)Esta função personalizada configura todos os quatro motores de passo para girar para frente.
void moveForward() {
LeftFrontWheel.setSpeed(wheelSpeed);
LeftBackWheel.setSpeed(wheelSpeed);
RightFrontWheel.setSpeed(wheelSpeed);
RightBackWheel.setSpeed(wheelSpeed);
}Code language: Arduino (arduino)Para mover em qualquer outra direção, basta girar as rodas nas direções apropriadas.
Para controlar o braço do robô, usamos o mesmo método. Novamente, temos botões no aplicativo e, ao segurar os botões, as articulações do braço do robô se movem na direção específica.
Como mencionei anteriormente, no aplicativo de controle Robot Arm original estávamos usando controles deslizantes para controlar as posições dos servos, mas isso estava causando alguns problemas porque dessa forma tínhamos que enviar texto para o Arduino, em vez de um número de 1 byte. O problema é que o Arduino às vezes perde o Texto vindo do App e dá erro ou o braço do Robô treme e se comporta de forma anormal.
Dessa forma, nós simplesmente enviamos um único número de 1 byte quando um botão específico é pressionado.
O código do Arduino entra no loop while desse número e fica lá até tocarmos no botão, pois nesse momento enviamos o número 0 o que significa que o robô não deve fazer nada.
// Move servo 1 in positive direction
while (m == 16) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo01.write(servo1PPos);
servo1PPos++;
delay(speedDelay);
}
// Move servo 1 in negative direction
while (m == 17) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo01.write(servo1PPos);
servo1PPos--;
delay(speedDelay);
}Code language: Arduino (arduino)Assim, dependendo dos botões tocados, os servos se movem na direção positiva ou negativa. O mesmo princípio de funcionamento se aplica a todos os servomotores. Para alterar a velocidade do movimento, usamos os valores provenientes do controle deslizante que variam de 100 a 250.
// If arm speed slider is changed
if (dataIn > 101 & dataIn < 250) {
speedDelay = dataIn / 10; // Change servo speed (delay time)
}Code language: Arduino (arduino)Ao dividi-los por 10 obtemos valores de 10 a 25, que são usados como atraso em microssegundos nos loops whiles para acionamento dos servos.
Para armazenar os movimentos do robô, simplesmente salvamos as posições atuais dos servos e dos steppers em arrays, cada vez que o botão Salvar é clicado.
// If button "SAVE" is pressed
if (m == 12) {
//if it's initial save, set the steppers position to 0
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();
servo01SP[index] = servo1PPos; // save position into the array
servo02SP[index] = servo2PPos;
servo03SP[index] = servo3PPos;
servo04SP[index] = servo4PPos;
servo05SP[index] = servo5PPos;
servo06SP[index] = servo6PPos;
index++; // Increase the array index
m = 0;
}Code language: Arduino (arduino)Então, quando pressionamos o botão Executar, chamamos a função personalizada runSteps(). Essa função personalizada percorre todas as etapas armazenadas usando alguns loops for e while.
if (m == 14) {
runSteps();
// If button "RESET" is pressed
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));
memset(servo01SP, 0, sizeof(servo01SP)); // Clear the array data to 0
memset(servo02SP, 0, sizeof(servo02SP));
memset(servo03SP, 0, sizeof(servo03SP));
memset(servo04SP, 0, sizeof(servo04SP));
memset(servo05SP, 0, sizeof(servo05SP));
memset(servo06SP, 0, sizeof(servo06SP));
index = 0; // Index to 0
}
}Code language: Arduino (arduino)Devemos notar que ele começa da primeira posição e vai até a última posição, e repete isso várias vezes. Portanto, ao salvar as etapas, na verdade precisamos posicionar o robô de forma que a primeira etapa tenha a mesma posição da última etapa. Ao percorrer as etapas, também podemos alterar a velocidade da plataforma e do braço do robô, além de pausar e redefinir todas as etapas.
Aqui você pode baixar este aplicativo, bem como o arquivo de projeto editável:
Aqui está o código Arduino completo para este projeto de robô Arduino:
/*
Arduino Robot Arm and Mecanum Wheels Robot
Smartphone Control via Bluetooth
by Dejan, www.HowToMechatronics.com
*/
#include <SoftwareSerial.h>
#include <AccelStepper.h>
#include <Servo.h>
Servo servo01;
Servo servo02;
Servo servo03;
Servo servo04;
Servo servo05;
Servo servo06;
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 lbw[50], lfw[50], rbw[50], rfw[50]; // arrays for storing positions/steps
int servo1Pos, servo2Pos, servo3Pos, servo4Pos, servo5Pos, servo6Pos; // current position
int servo1PPos, servo2PPos, servo3PPos, servo4PPos, servo5PPos, servo6PPos; // previous position
int servo01SP[50], servo02SP[50], servo03SP[50], servo04SP[50], servo05SP[50], servo06SP[50]; // for storing positions/steps
int speedDelay = 20;
int index = 0;
int dataIn;
int m = 0;
void setup() {
// Set initial seed values for the steppers
LeftFrontWheel.setMaxSpeed(3000);
LeftBackWheel.setMaxSpeed(3000);
RightFrontWheel.setMaxSpeed(3000);
RightBackWheel.setMaxSpeed(3000);
pinMode(led, OUTPUT);
servo01.attach(5);
servo02.attach(6);
servo03.attach(7);
servo04.attach(8);
servo05.attach(9);
servo06.attach(10);
Bluetooth.begin(38400); // Default baud rate of the Bluetooth module
Bluetooth.setTimeout(5);
delay(20);
Serial.begin(38400);
// Move robot arm to initial position
servo1PPos = 90;
servo01.write(servo1PPos);
servo2PPos = 100;
servo02.write(servo2PPos);
servo3PPos = 120;
servo03.write(servo3PPos);
servo4PPos = 95;
servo04.write(servo4PPos);
servo5PPos = 60;
servo05.write(servo5PPos);
servo6PPos = 110;
servo06.write(servo6PPos);
}
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;
}
if (dataIn == 16) {
m = 16;
}
if (dataIn == 17) {
m = 17;
}
if (dataIn == 18) {
m = 18;
}
if (dataIn == 19) {
m = 19;
}
if (dataIn == 20) {
m = 20;
}
if (dataIn == 21) {
m = 21;
}
if (dataIn == 22) {
m = 22;
}
if (dataIn == 23) {
m = 23;
}
if (dataIn == 24) {
m = 24;
}
if (dataIn == 25) {
m = 25;
}
if (dataIn == 26) {
m = 26;
}
if (dataIn == 27) {
m = 27;
}
// Move the Mecanum wheels platform
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();
}
// Mecanum wheels speed
if (dataIn > 30 & dataIn < 100) {
wheelSpeed = dataIn * 20;
}
// Move robot arm
// Move servo 1 in positive direction
while (m == 16) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo01.write(servo1PPos);
servo1PPos++;
delay(speedDelay);
}
// Move servo 1 in negative direction
while (m == 17) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo01.write(servo1PPos);
servo1PPos--;
delay(speedDelay);
}
// Move servo 2
while (m == 19) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo02.write(servo2PPos);
servo2PPos++;
delay(speedDelay);
}
while (m == 18) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo02.write(servo2PPos);
servo2PPos--;
delay(speedDelay);
}
// Move servo 3
while (m == 20) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo03.write(servo3PPos);
servo3PPos++;
delay(speedDelay);
}
while (m == 21) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo03.write(servo3PPos);
servo3PPos--;
delay(speedDelay);
}
// Move servo 4
while (m == 23) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo04.write(servo4PPos);
servo4PPos++;
delay(speedDelay);
}
while (m == 22) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo04.write(servo4PPos);
servo4PPos--;
delay(speedDelay);
}
// Move servo 5
while (m == 25) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo05.write(servo5PPos);
servo5PPos++;
delay(speedDelay);
}
while (m == 24) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo05.write(servo5PPos);
servo5PPos--;
delay(speedDelay);
}
// Move servo 6
while (m == 26) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo06.write(servo6PPos);
servo6PPos++;
delay(speedDelay);
}
while (m == 27) {
if (Bluetooth.available() > 0) {
m = Bluetooth.read();
}
servo06.write(servo6PPos);
servo6PPos--;
delay(speedDelay);
}
// If arm speed slider is changed
if (dataIn > 101 & dataIn < 250) {
speedDelay = dataIn / 10; // Change servo speed (delay time)
}
// If button "SAVE" is pressed
if (m == 12) {
//if it's initial save, set the steppers position to 0
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();
servo01SP[index] = servo1PPos; // save position into the array
servo02SP[index] = servo2PPos;
servo03SP[index] = servo3PPos;
servo04SP[index] = servo4PPos;
servo05SP[index] = servo5PPos;
servo06SP[index] = servo6PPos;
index++; // Increase the array index
m = 0;
}
// If button "RUN" is pressed
if (m == 14) {
runSteps();
// If button "RESET" is pressed
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));
memset(servo01SP, 0, sizeof(servo01SP)); // Clear the array data to 0
memset(servo02SP, 0, sizeof(servo02SP));
memset(servo03SP, 0, sizeof(servo03SP));
memset(servo04SP, 0, sizeof(servo04SP));
memset(servo05SP, 0, sizeof(servo05SP));
memset(servo06SP, 0, sizeof(servo06SP));
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 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);
}
// Automatic mode custom function - run the saved steps
void runSteps() {
while (dataIn != 13) { // Run the steps over and over again until "RESET" button is pressed
for (int i = 0; i <= index - 2; i++) { // Run through all steps(index)
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) {
break;
}
}
}
}
// If speed slider is changed
if (dataIn > 100 & dataIn < 150) {
speedDelay = dataIn / 10; // Change servo speed (delay time)
}
// Mecanum wheels speed
if (dataIn > 30 & dataIn < 100) {
wheelSpeed = dataIn * 10;
dataIn = 14;
}
}
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();
}
// Servo 1
if (servo01SP[i] == servo01SP[i + 1]) {
}
if (servo01SP[i] > servo01SP[i + 1]) {
for ( int j = servo01SP[i]; j >= servo01SP[i + 1]; j--) {
servo01.write(j);
delay(speedDelay);
}
}
if (servo01SP[i] < servo01SP[i + 1]) {
for ( int j = servo01SP[i]; j <= servo01SP[i + 1]; j++) {
servo01.write(j);
delay(speedDelay);
}
}
// Servo 2
if (servo02SP[i] == servo02SP[i + 1]) {
}
if (servo02SP[i] > servo02SP[i + 1]) {
for ( int j = servo02SP[i]; j >= servo02SP[i + 1]; j--) {
servo02.write(j);
delay(speedDelay);
}
}
if (servo02SP[i] < servo02SP[i + 1]) {
for ( int j = servo02SP[i]; j <= servo02SP[i + 1]; j++) {
servo02.write(j);
delay(speedDelay);
}
}
// Servo 3
if (servo03SP[i] == servo03SP[i + 1]) {
}
if (servo03SP[i] > servo03SP[i + 1]) {
for ( int j = servo03SP[i]; j >= servo03SP[i + 1]; j--) {
servo03.write(j);
delay(speedDelay);
}
}
if (servo03SP[i] < servo03SP[i + 1]) {
for ( int j = servo03SP[i]; j <= servo03SP[i + 1]; j++) {
servo03.write(j);
delay(speedDelay);
}
}
// Servo 4
if (servo04SP[i] == servo04SP[i + 1]) {
}
if (servo04SP[i] > servo04SP[i + 1]) {
for ( int j = servo04SP[i]; j >= servo04SP[i + 1]; j--) {
servo04.write(j);
delay(speedDelay);
}
}
if (servo04SP[i] < servo04SP[i + 1]) {
for ( int j = servo04SP[i]; j <= servo04SP[i + 1]; j++) {
servo04.write(j);
delay(speedDelay);
}
}
// Servo 5
if (servo05SP[i] == servo05SP[i + 1]) {
}
if (servo05SP[i] > servo05SP[i + 1]) {
for ( int j = servo05SP[i]; j >= servo05SP[i + 1]; j--) {
servo05.write(j);
delay(speedDelay);
}
}
if (servo05SP[i] < servo05SP[i + 1]) {
for ( int j = servo05SP[i]; j <= servo05SP[i + 1]; j++) {
servo05.write(j);
delay(speedDelay);
}
}
// Servo 6
if (servo06SP[i] == servo06SP[i + 1]) {
}
if (servo06SP[i] > servo06SP[i + 1]) {
for ( int j = servo06SP[i]; j >= servo06SP[i + 1]; j--) {
servo06.write(j);
delay(speedDelay);
}
}
if (servo06SP[i] < servo06SP[i + 1]) {
for ( int j = servo06SP[i]; j <= servo06SP[i + 1]; j++) {
servo06.write(j);
delay(speedDelay);
}
}
}
}
}Code language: Arduino (arduino)Então, isso é praticamente tudo para este tutorial. O projeto funciona bem, mas observe que está longe de ser perfeito. Os movimentos automáticos podem não ser tão precisos por causa do deslizamento das rodas mecanum, bem como pelo mau desempenho dos servo motores. Esses servomotores baratos também podem tremer ou tremer mesmo quando não estão em movimento, apenas porque não têm força suficiente para suportar o peso das peças impressas em 3D.
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.
Processo de manufatura
- Construa seu robô de streaming de vídeo controlado pela Internet com Arduino e Raspberry Pi
- Robô Pi Simples
- Obstáculos para evitar o robô com servo motor
- Controle de um robô Roomba com Arduino e dispositivo Android
- Controle do Servo Motor com Arduino e MPU6050
- Braço robótico simples e inteligente usando Arduino
- Littlearm 2C:Construir um braço de robô Arduino impresso em 3D
- Braço do robô Arduino DIY - Controlado por gestos manuais
- Braço Robótico Programável Local e Remoto
- Robot combina braço robótico colaborativo com plataforma móvel