Operasi Otomatis Platform Lengan Robot Arduino dan Roda Mecanum
Dalam tutorial ini saya akan menunjukkan kepada Anda bagaimana saya membuat Platform Robot Roda Mecanum saya dari video saya sebelumnya, untuk bekerja bersama dan beroperasi secara otomatis dengan Lengan Robot cetak 3D saya, juga proyek Arduino dari salah satu video saya sebelumnya.
Anda dapat menonton video berikut atau membaca tutorial tertulis di bawah ini.
Ringkasan
Jadi, kita dapat mengontrol robot roda Mecanum dengan aplikasi Android custom-build dengan cara yang sama seperti yang dijelaskan di video sebelumnya. Selain itu, sekarang aplikasi juga memiliki tombol untuk mengontrol lengan robot.
Aplikasi kontrol lengan robot asli sebenarnya memiliki penggeser untuk mengontrol sambungan robot, tetapi itu menyebabkan beberapa masalah dengan stabilitas lengan. Dengan cara ini lengan bekerja jauh lebih baik, oleh karena itu saya akan memberikan versi terbaru dari aplikasi kontrol lengan robot dan kode Arduino ke proyek lengan robot asli juga.
Namun demikian, fitur paling keren dari robot ini adalah kemampuannya untuk menyimpan gerakan dan kemudian secara otomatis mengulanginya.
Dengan menggunakan tombol Simpan, kita dapat dengan mudah menyimpan posisi motor untuk setiap langkah. Kemudian kita hanya perlu mengklik tombol Run dan robot akan secara otomatis mengulangi gerakan yang tersimpan berulang-ulang.
Membuat Robot Arduino
Oke, jadi di sini saya memiliki platform roda Mecanum yang sudah dirakit dan Anda dapat menemukan semua detailnya di video saya sebelumnya.
Juga, di sini saya memiliki bagian lengan robot dan motor servo yang dicetak 3D dan sekarang saya akan menunjukkan cara merakitnya. Inilah model 3D dari proyek ini.
Anda dapat menemukan dan mengunduh model 3D ini, serta menjelajahinya di browser Anda di Thangs.
Unduh model 3D di Thans.
File STL untuk pencetakan 3D:
Servo pertama dari lengan robot akan langsung dipasang di penutup atas platform roda mecanum.
Saya menandai lokasinya, dan menggunakan bor 10mm saya membuat beberapa lubang.
Kemudian dengan menggunakan serak, saya memotong lubang dan kemudian menyempurnakan bukaan untuk servo. Saya mengamankan servo ke pelat atas menggunakan empat baut dan mur M3.
Kemudian pada poros keluaran servo ini, dengan menggunakan klakson bulat yang disertakan sebagai aksesori servo, kita perlu memasang bagian berikutnya atau pinggang lengan robot. Namun, kita dapat melihat bahwa dengan cara ini bagian tersebut tetap sekitar 8mm di atas pelat. Oleh karena itu, saya memasang dua lembar papan MDF 8mm, sehingga bagian pinggang dapat meluncur di atasnya dan sambungan akan lebih stabil.
Klakson bundar diamankan ke bagian pinggang menggunakan sekrup self-tapping yang disertakan sebagai aksesori dengan servo, kemudian tanduk bundar diamankan ke poros servo menggunakan baut yang sesuai yang juga disertakan dengan servo.
Selanjutnya kita memiliki servo bahu. Kami cukup meletakkannya di tempatnya dan mengamankannya ke bagian cetakan 3D menggunakan sekrup self-tapping.
Klakson bundar masuk ke bagian berikutnya, dan kemudian kedua bagian diamankan satu sama lain menggunakan baut pada poros keluaran servo.
Kita harus mencatat bahwa sebelum mengamankan bagian-bagian, kita perlu memastikan bahwa bagian tersebut memiliki rentang gerak penuh. Disini saya juga menambahkan karet gelang pada sendi bahu sehingga memberikan sedikit bantuan pada servo, karena servo ini membawa beban sisa lengan serta muatannya.
Dengan cara yang sama, saya merakit sisa lengan robot.
Selanjutnya, kita perlu merakit mekanisme gripper. Gripper dikendalikan dengan motor servo SG90, di mana, pertama-tama kami memasang tautan roda gigi yang dirancang khusus. Kami memasangkan tautan ini dengan tautan roda gigi lain di sisi lain, yang diamankan menggunakan baut dan mur M4. Sebenarnya, semua tautan lain dihubungkan menggunakan baut dan mur M4.
Model 3D gripper awalnya memiliki lubang 3mm tetapi saya tidak memiliki cukup baut M3, jadi saya memperluas lubang menggunakan bor 4mm dan menggunakan baut M4 sebagai gantinya.
Setelah saya merakit mekanisme gripper, saya mengamankannya ke servo terakhir sehingga lengan robot selesai.
Selanjutnya saya melakukan beberapa manajemen kabel. Saya melewati kabel servo melalui lubang yang dirancang khusus dari lengan robot. Dengan menggunakan bor 10 mm, saya membuat lubang di pelat atas agar kabel bisa lewat.
Dengan menggunakan zip-tie, saya mengamankan semua kabel bersama-sama, dan sekarang yang tersisa adalah menghubungkannya ke papan Arduino.
Diagram Sirkuit Robot Arduino
Berikut diagram sirkuit proyek ini dan bagaimana semuanya perlu dihubungkan.
Anda bisa mendapatkan komponen yang dibutuhkan untuk proyek ini dari tautan di bawah ini:
Motor Stepper – NEMA 17 …………..…
DRV8825 Stepper Driver ……….…….…
Motor Servo MG996R…………………..
Motor Servo Mikro SG90 …………….….
Modul Bluetooth HC-05 …………….…
Baterai Li-Po …………………………….……
Arduino Mega Board ………….……….…
Dalam tutorial sebelumnya saya menjelaskan cara kerja bagian robot roda Mecanum dan juga menunjukkan kepada Anda bagaimana saya membuat PCB khusus untuk itu.
Saya menyertakan pengatur tegangan 5V pada PCB ini sehingga kami dapat membuat proyek ini, atau menghubungkan motor servo karena bekerja pada 5V. Regulator tegangan adalah LM350, yang dapat menangani hingga 3 amp arus. Keenam servo lengan robot dapat menarik arus sekitar 2 amp hingga 3 amp, yang berarti dapat menanganinya tetapi itu akan menyebabkan regulator menjadi sangat panas.
Oleh karena itu, saya memasang unit pendingin, serta kipas DC 12V kecil untuk mengeluarkan udara, karena unit pendingin itu sendiri tidak cukup untuk mendinginkan regulator.
Saya menghubungkan kabel sinyal servos ke pin digital Arduino dari nomor 5 hingga 10, dan untuk menyalakan saya menggunakan header pin 5V pada PCB. Akhirnya, saya mendorong semua kabel ke dalam platform, dan mengamankan pelat atas menggunakan dua mur.
Dan itu saja, sekarang kita sudah selesai dengan proyek ini.
Kode Arduino
Yang tersisa adalah melihat bagaimana kode Arduino dan aplikasi Android bekerja. Karena kodenya sedikit lebih panjang, untuk pemahaman yang lebih baik, saya akan memposting kode sumber program di bagian dengan deskripsi untuk setiap bagian. Dan di akhir artikel ini saya akan memposting source code lengkapnya.
Jadi pertama-tama kita perlu mendefinisikan 6 servo, 4 motor stepper dan komunikasi Bluetooth, serta mendefinisikan beberapa variabel yang dibutuhkan untuk program di bawah ini. Di bagian penyiapan, kami mengatur kecepatan maksimum stepper, menentukan pin yang terhubung dengan servo, memulai komunikasi Bluetooth, dan menyetel lengan robot ke posisi awal.
#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)
Kemudian pada bagian loop kita mulai dengan mengecek apakah ada data yang masuk.
// Check for incoming data
if (Bluetooth.available() > 0) {
dataIn = Bluetooth.read(); // Read the dataCode language: Arduino (arduino)
Data ini berasal dari smartphone atau aplikasi Android, jadi mari kita lihat jenis data yang sebenarnya dikirim. Aplikasi Android dibuat menggunakan aplikasi online MIT App Inventor. Ini terdiri dari tombol sederhana yang memiliki gambar yang sesuai sebagai latar belakang.
Jika kita melihat blok aplikasi, kita dapat melihat bahwa yang dilakukannya hanyalah mengirimkan nomor satu byte saat tombol diklik.
Jadi, tergantung pada tombol yang diklik, kami memberi tahu Arduino apa yang harus dilakukan. Misalnya, jika kita menerima nomor '2', platform roda mecanum akan bergerak maju, menggunakan fungsi kustom moveForward.
if (dataIn == 2) {
m = 2;
}
//
if (m == 2) {
moveForward();
}Code language: Arduino (arduino)
Fungsi kustom ini mengatur keempat motor stepper untuk berputar ke depan.
Untuk bergerak ke arah lain, kita hanya perlu memutar roda ke arah yang sesuai.
Untuk mengendalikan lengan robot, kami menggunakan metode yang sama. Sekali lagi, kami memiliki tombol di aplikasi dan saat menahan tombol, sendi lengan robot bergerak ke arah tertentu.
Seperti yang saya sebutkan sebelumnya, dalam aplikasi kontrol Lengan Robot asli kami menggunakan penggeser untuk mengontrol posisi servos tetapi itu menyebabkan beberapa masalah karena dengan cara itu kami harus mengirim Teks ke Arduino, bukan nomor 1-byte. Masalahnya adalah Arduino terkadang melewatkan Teks yang berasal dari Aplikasi dan membuat kesalahan atau lengan Robot bergetar dan berperilaku tidak normal.
Dengan cara ini kami mengirim satu nomor 1-byte saat tombol tertentu disentuh.
Kode Arduino memasuki loop while dari angka itu, dan tetap di sana sampai kita menyentuh tombolnya, karena pada saat itu kita mengirim angka 0 yang berarti robot tidak boleh melakukan apa-apa.
// 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)
Jadi, tergantung pada tombol yang disentuh, servos bergerak ke arah positif atau negatif. Prinsip kerja yang sama berlaku untuk semua motor servo. Untuk mengubah kecepatan gerakan, kami menggunakan nilai yang berasal dari penggeser yang berkisar dari 100 hingga 250.
// If arm speed slider is changed
if (dataIn > 101 & dataIn < 250) {
speedDelay = dataIn / 10; // Change servo speed (delay time)
}Code language: Arduino (arduino)
Dengan membaginya dengan 10, kita mendapatkan nilai dari 10 hingga 25, yang digunakan sebagai penundaan dalam mikrodetik dalam loop while untuk menggerakkan servo.
Untuk menyimpan gerakan robot, kita cukup menyimpan posisi servo dan stepper saat ini ke dalam array, setiap kali tombol Simpan diklik.
// 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)
Kemudian ketika kita menekan tombol Run kita memanggil fungsi kustom runSteps(). Fungsi kustom ini berjalan melalui semua langkah tersimpan menggunakan beberapa loop for dan 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)
Kita harus mencatat bahwa itu dimulai dari posisi pertama dan berlanjut ke posisi terakhir, dan mengulanginya lagi dan lagi. Oleh karena itu, saat menyimpan langkah, kita sebenarnya perlu memposisikan robot sedemikian rupa sehingga langkah pertama memiliki posisi yang sama dengan langkah terakhir. Saat menjalankan langkah-langkah tersebut, kami juga dapat mengubah kecepatan platform dan lengan robot, serta menjeda dan mengatur ulang semua langkah.
Di sini Anda dapat mengunduh aplikasi ini serta file proyek yang dapat diedit:
Berikut kode Arduino lengkap untuk proyek robot Arduino ini:
/*
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)
Jadi itu cukup banyak untuk tutorial ini. Proyek ini bekerja dengan baik, tetapi harap dicatat bahwa ini jauh dari sempurna. Gerakan otomatis mungkin tidak begitu tepat karena selipnya roda mecanum serta kinerja motor servo yang buruk. Motor servo murah ini juga dapat bergetar atau bergetar bahkan saat tidak bergerak hanya karena tidak memiliki kekuatan yang cukup untuk menahan beban bagian cetakan 3D.
Saya harap Anda menikmati tutorial ini dan belajar sesuatu yang baru. Jangan ragu untuk mengajukan pertanyaan apa pun di bagian komentar di bawah dan periksa Koleksi Proyek Arduino saya.
