Lengan Robot Arduino Dikontrol Geser Tangan – Pembangun Langkah demi Langkah DIY

Komponen dan Perlengkapan

Arduino UNO – 1 unit
PCB Custom JLCPCB – 1 unit
Servo Motor, MG996R – 6 unit
Paket Baterai 5V – 1 unit
National Control Devices PCA9685 8-Channel 8W 12V FET Driver Proportional Valve Controller with I2C Interface – 1 unit
Modul Bluetooth HC-05 – 2 unit
SparkFun Stepper motor driver board A4988 – 1 unit
Motor Stepper NEMA-17 – 1 unit
Breadboard (umum) – 1 unit
Satuan Pengukuran Inersial (IMU) (6 derajat kebebasan) – 1 unit
Arduino Nano R3 – 1 unit
Sensor Fleks – 1 unit

Alat dan Mesin yang Diperlukan

Printer 3D (umum)

Tentang Proyek

Mengenalkan Lengan Robot DIY yang Dikontrol oleh Geser Manusia.

Film Blockbuster seperti Pacific Rim, Avatar dan film Sci-Fi lainnya telah menunjukkan kemampuan untuk bersinergi dengan Robot – di mana gerakan Anda dapat ditingkatkan dengan bantuan Robotik.

Bagaimana jika kita bisa membangun robot industri yang sama, tetapi pada skala yang lebih kecil?

Proyek ini adalah upaya untuk mencapai hal ini.

Ini adalah Lengan Robot Arduino yang dapat diprogram atau bahkan dikontrol oleh Geser Tangan.

Lengan Robot Arduino Dikontrol Geser Tangan – Pembangun Langkah demi Langkah DIY

Menetral dengan konvensi pakaian Iron Man, setiap iterasi akan dikenal sebagai Mark. Prototipe ini akan dikenal sebagai MARK 1. Kami dapat mengharapkan lebih banyak iterasi untuk memperbaiki lengan robot asli.

Lihat Tutorial Lengkap Lengan Robot DIY (dikontrol oleh Geser Tangan) Di Sini

Ringkasan

Dalam tutorial ini, kita akan membangun Robot sumbu enam yang dikontrol oleh Geser Tangan menggunakan Sarung Tangan Robotik. Dengan meniru gerakan manusia alami seperti jerempatan, atau rotasi pergelangan tangan ke kiri, Anda akan dapat membuka/menutup atau memutar lengan robot ke kiri dan kanan masing-masing. Secara efektif, mengontrol Lengan Robot secara manual.

Temukan Detail Lebih Lanjut pada artikel asli

Fitur MARK 1:

Rotasi 6 Sumbu
Portabel
Kontrol Robot dengan Geser Manusia
Dapat diprogram sebelumnya untuk melakukan fungsi dasar
Dapat dikontrol secara nirkabel dari jarak jauh
Dapat menahan beban berat 600g (Beban Maksimum 1kg)

Daftar Bagian

Lengan Robot sepenuhnya dapat disesuaikan. Anda dapat membeli sendiri atau mencetak 3D sendiri. Jika Anda memilih untuk mencetak 3D, jangan khawatir. Ada daftar berbagai Robot yang menggunakan servo motor, jadi teori apa yang kita bangun masih berlaku.

Untuk proyek ini, prototipe ini (Mark 1) akan dicetak 3D karena memberikan saya lebih banyak ruang untuk membuat bagian khusus.

Lengan Robot: Thingiverse 3D Printed Robotic Arm (kredit: Wonder Tiger):

Bagian 1: Bagian Gripper
Bagian 2: Basis dan Meja Putar
Bagian 3: Inti Lengan Robot

Anda dapat menemukan informasi lebih lanjut tentang pembangun ini, bersama dengan jenis baut dari bagian di atas. Waktu yang dibutuhkan untuk mencetak bisa hingga 40 jam. Namun, ini memotong biaya pembelian Lengan Robot.

Sarung Tangan Robotik: File .STL Sarung Tangan Robotik (kredit: Roman 13)

Sarung Tangan Robotik adalah tambahan estetika untuk proyek, tetapi Anda dapat menggunakan sarung tangan bangunan biasa untuk memprototipe Lengan Robot.

Catatan: untuk tangan yang lebih besar, cetak pada skala 105%

Cara Kerja

Secara keseluruhan, kita mengirim sinyal (melalui Bluetooth) dari Sarung Tangan Robotik ke servo motor. Ketika nilai telah diterima, driver servo akan mengirim sinyal ke servo motor tertentu yang menggerakkan Lengan Robot.

Sekarang, jika kita menambahkan beberapa servo dan lebih banyak sensor, kita dapat mengontrol setiap Motor.

Jika kita memikirkan Lengan Robot sebagai serangkaian servo motor yang berkoordinasi satu sama lain untuk melakukan fungsi, kita dapat membuat lengan robot yang dikontrol oleh Sarung Tangan Robotik.

Arduino Sarung Tangan Robotik menggunakan sensor untuk berkomunikasi dengan Arduino Lengan Robot dan mengirim data untuk menggerakkan Servo ke sudut yang diinginkan.

Anda mungkin bertanya, sensor apa yang digunakan oleh Sarung Tangan Robotik?

Untuk MARK 1, kami akan menggunakan Sensor Fleks dan akselerometer (MPU6050)

Sensor Fleks – Berdasarkan derajat lenturan dari bagian plastik ini, resistansi berubah, mempengaruhi arus. Pengukuran ini kemudian digunakan untuk mendeteksi perubahan gerakan tangan.
Akselerometer – Untuk gerakan yang lebih alami, akselerometer dapat mendeteksi perubahan rotasi lengan dan pergelangan tangan.

Kami menggunakan sensor ini untuk mendeteksi perubahan dalam gerakan. Kita kemudian dapat mengirim nilai yang dipetakan dari gerakan ke Lengan Robot untuk mengontrol servo motor melalui Bluetooth. Dan dengan cukup banyak gerakan, lengan robot menjadi hidup!

Pemetaan Lengan Robot

Berikut ini merupakan tabel pemetaan nilai yang dikirim ke Lengan Robot oleh Sarung Tangan. Ini dapat ditemukan pada Artikel asli. Dengan masing-masing memiliki kunci untuk mengkarakterisikan fungsinya. (P – Jari Kelingking, L – Kanan, dll.)

Catatan: Huruf besar "F" (jari) mewakili arah berlawanan dari putaran servo motor

Rangkaian Bagian

Lengan Robot – Rangkaian

Membeli Lengan Robot bisa cukup mahal. Untuk menjaga lengan robot ini dalam anggaran, mencetak 3D Lengan Robot adalah opsi terbaik.

Ini membantu di jangka panjang, karena ada banyak contoh lengan robot yang dicetak 3D yang dapat disesuaikan, misalnya, menambahkan LED, membuat clamping penggiat kamera:

Seperti yang disebutkan sebelumnya, Lengan Robot dimodelkan berdasarkan Lengan Robot di Thingyverse. Saya memilih contoh ini karena merupakan desain yang sangat baik yang menyediakan sumbu enam, terdokumentasi dengan baik, dan memiliki kekuatan/ketahanan. Anda dapat mengakses Lengan Robot Wonder Tiger dari Daftar Bagian.

Anda juga dapat menemukan remix saya untuk Penggiat Kamera Lengan Robot. Kami akan membahas ini lebih lanjut dalam rilis mendatang. Namun, bagian-bagian bisa membutuhkan waktu setidaknya 40 jam untuk mencetak semua bagian.

Anda dapat menemukan banyak alternatif Lengan Robot yang dicetak 3D lainnya juga.

Pengenalan Servo Motor dan Driver

Karena Lengan Robot idealnya adalah serangkaian motor yang berkoordinasi bersama-sama, kita secara teori dapat melekatkan beberapa motor yang semuanya dapat diberi daya oleh Arduino. Dalam proyek ini, kita akan menggunakan PCA9685 Servo Driver untuk memberi daya pada MG966R Servo.

Catatan: Gunakan sumber daya eksternal saat memberi daya pada setiap Motor. Arduino tidak dapat menyediakan cukup daya untuk mengontrol semua motor. Dalam proyek ini, Baterai RC 5V, 2200 mAh digunakan.

Diagram kabel Arduino seharusnya terlihat seperti di bawah ini:

NEMA-17 untuk Putaran Dasar

Karena Lengan Robot mulai gaining sedikit berat, dan servo motor MG966R tidak cukup kuat untuk memutar Lengan Robot di dasar. Untuk memutar Lengan Robot, motor yang lebih kuat daripada servo motor diperlukan

Motor Stepper (NEMA-17) dapat digunakan karena presisi dan torsinya yang tinggi, membantu Lengan Robot berputar dengan lancar untuk kontrol geser.

NEMA-17 dan Driver A4988 digunakan untuk mengontrol arah Motor, Anda dapat melihat dari diagram di bawah ini:

Dan akhirnya, diagram berikut menunjukkan diagram kabel akhir rangkaian lengkap Lengan Robot.

Rangkaian Sirkuit

Diagram kabel di bawah ini menunjukkan rangkaian akhir semua bagian elektronik untuk membuat Lengan Robot, termasuk modul Bluetooth. Kami akan membahas proses pemasangan di bawah ini.

Sensor Fleks Manusia

Untuk tetap setia dengan estetika Lengan Robot, Anda dapat mencetak 3D Exoskeleton Gauntlet untuk digunakan sebagai Sarung Tangan Robot Anda.

Namun, Anda dapat menggunakan Sarung Tangan Bangunan standar untuk memprototipe Sarung Tangan Robot. Desain 'Robot Glove Exoskeleton' ini cocok dengan desain Lengan Robot.

Sarung Tangan Robotik terdiri dari komponen berikut:

Sensor Fleks – Berdasarkan lenturan jari, arus berubah yang dapat kita gunakan untuk mengirim sinyal ke Motor
Akselerometer (MPU6050) – Kita dapat mengontrol Motor dengan memetakan geser manusia dari bidang X, Y, Z
LED – LED akan menyala ketika kontrol geser manusia telah dikirim ke Arduino
Modul Bluetooth (HC-05) – Mengirim data ke Penerima HC-05 Lengan Robot
Arduino Nano – Mikrokontroler akan bertindak sebagai otak Sarung Tangan Robot

Diagram berikut bagus untuk menguji sensor fleks dan Akselerometer.

Penting: Lengan Robot hanya akan seakurat kontrol Sarung Tangan Robot, jadi layak untuk melakukannya dengan benar.

Konfigurasi Bluetooth (Master dan Penerima)

Arduino Lengan Robot berkomunikasi melalui Bluetooth menggunakan modul HC-05. Di bawah ini ditandai informasi penting.

Modul

Konfigurasi

Sarung Tangan Robotik HC-05 Master Lengan Robot HC-05 Slave

Catatan:

Baud Rate diatur pada 4800

Pemrograman Arduino

Anda dapat mengunduh kode berikut di bawah ini:

Catatan: Semua kode uji coba lain dan versi terbaru dapat ditemukan di Arduino Robotic Arm Git Repo

Pemrograman Lengan Robot

Kode Lengan Robot menggunakan pustaka HCPCA9685 (untuk Driver Servo). Dengan cara ini, kita dapat memberi daya pada beberapa servo motor, semuanya dikontrol oleh Arduino. Dalam kode, kita dapat mulai dengan menambahkan pustaka ini dan mendeklarasikan variabel servo.

Variabel berikut digunakan untuk menemukan nilai sebelumnya/pertambahan dan mendapatkan posisi servo saat ini.

* Include the HCPCA9685 library */
#include "HCPCA9685.h"
/* I2C slave address for the device/module. For the HCMODU0097 the default I2C address
is 0x40 */
#define I2CAdd 0x40
/* Create an instance of the library */
HCPCA9685 HCPCA9685(I2CAdd);
//initial parking position of the motor
const int servo_joint_L_parking_pos = 60;
//Degree of robot servo sensitivity - Intervals
int servo_joint_L_pos_increment = 20;
//Keep track of the current value of the motor positions
int servo_joint_L_parking_pos_i = servo_joint_L_parking_pos;
//Minimum and maximum angle of servo motor
int servo_joint_L_min_pos = 10;
int servo_joint_L_max_pos = 180;

Inisialisasi Port Serial pada Baud Rate 4800 untuk memulai komunikasi Bluetooth

Serial.begin(4800); // Initialise default communication rate of the Bluetooth module

Dalam bagian loop(), kita terus memeriksa apakah ada data yang datang dari sarung tangan robot. Jika benar, kita akan menyimpan data masuk dalam variabel 'state'. Dan tergantung pada karakter yang diberikan, kita akan menggunakan ini untuk menggerakkan motor(s).

Bagian berikut ini menguraikan kode:

Kode Lengan Robot dapat dilihat sebagai serangkaian servo motor yang bekerja bersama untuk mensimulasikan gerakan manusia. Kode sama, dengan Servo yang didorong oleh Servo Driver berdasarkan nilai Bluetooth.

//Defining the servo driver. 0x40 Address is the default I2C Address.
#define I2CAdd 0x40
int response_time = 5; //Receiving values from the Robotic Glove interval
// Checks whether data is coming from the serial port

if (Serial.available() > 0) {
state = Serial.read(); // Reads the data from the serial port
Serial.print(state); // Prints out the value sent
//Motor functionality code block
}

Berdasarkan nilai 'state' saat ini, ' servo Driver akan mengirim sinyal ke Motor yang sesuai.

Misalnya, jika kita melengkungkan jari kita. Nilai 'f' akan dikirim oleh sarung tangan robot (melalui Bluetooth) di mana Lengan Robot akan membaca data ini dan memicu fungsi untuk memutar servo motor yang sesuai. Proses ini diulang dalam loop tak terbatas.

if (Serial.available() > 0) { // Checks whether data is coming from the serial port
state = Serial.read(); // Reads the data from the serial port
Serial.print(state); // Prints out the value sent
//For the naming of the motors, refer to the article / tutorial
//Move (Base Rotation) Stepper Motor Left
if (state == 'S') {
baseRotateLeft();
delay(response_time);
}
}

Catatan: Kode mengimplementasikan hard stop, untuk menghentikan Motor dari melebihi sudut maksimumnya, yang dapat merusak gear motor.

HCPCA9685.Servo(0, servo_joint_L_parking_pos_i); // Drive the servo motor at channel 0 to the desired angle.
//Move Claw Motor Downwards
if (state == 'f') {
if (servo_joint_3_parking_pos_i < servo_joint_3_max_pos) {
HCPCA9685.Servo(4, servo_joint_3_parking_pos_i);
delay(response_time);
Serial.println(servo_joint_3_parking_pos_i);
servo_joint_3_parking_pos_i = servo_joint_3_parking_pos_i + servo_joint_3_pos_increment;
}
}
void baseRotateLeft() {
digitalWrite(stepPin, LOW); //Spin in a direction based on HIGH, LOW
delayMicroseconds(stepDelay); //Change the speed of the Stepper motor
}

Jika nilai servo motor kurang dari rotasi maksimum, terus berputar. Jika sudah mencapai rotasi maksimum 180 derajat, hentikan.

servo_joint_3_parking_pos_i < servo_joint_3_max_pos

Dimana servo_joint_3_max_pos adalah posisi maksimum Motor.

Catatan: Kode mengimplementasikan hard stop untuk menghentikan Motor dari melebihi sudut maksimumnya, yang dapat merusak gear motor.

Pemrograman Sensor Fleks

Kode Lengan Robot dapat ditemukan di GitHub. Jika Anda bekerja pada proyek ini, kontribusikan versi Anda sendiri ke Git Repo. Ini akan membantu membangun indeks versi dan fungsionalitas yang berbeda dari Lengan Robot.

Kode sudah didokumentasikan (Tersedia juga di Git). Namun, kami akan membahas poin-poin kunci:

Kita akan mendefinisikan lima sensor:

//LED ON PIN 3
int pinkie_Data = A1;
int finger_Data = A2;
int thumb_Data = A3;
//const int MPU_addr = 0x68;
const int MPU2 = 0x69, MPU1 = 0x68;

Catatan: 0x68 dan 0x69 mewakili Alamat I2C dari 2 Akselerometer MPU6050

//How often to send values to the Robotic Arm
int response_time = 1000;

Kode berikut ini menguraikan Arduino membaca nilai sensor:

// read the values from Flex Sensors to Arduino
pinkie = analogRead(pinkie_Data);
finger = analogRead(finger_Data);
thumb = analogRead(thumb_Data);

Baca posisi saat ini Akselerometer:

GetMpuValue1(MPU1);
GetMpuValue2(MPU2);

Mengkalibrasi nilai:

Kode berikut ini mengkalibrasi untuk menemukan batas atas dan bawah Sensor Fleks. Untuk mengkalibrasi ulang sarung tangan fleks, tekan tombol reset pada Arduino.

if (bool_caliberate == false ) {
delay(1000);
thumb_high = (thumb * 1.15);
thumb_low = (thumb * 0.9);
finger_high = (finger * 1.03);
finger_low = (finger * 0.8);
pinkie_high = (pinkie * 1.06);
pinkie_low = (pinkie * 0.8);
bool_caliberate = true;
}

Kita akan terus memeriksa apakah nilai saat ini telah melebihi batas atas atau bawah flex yang ditentukan berdasarkan kalibrasi. Jika sensor fleks melebihi atau di bawah nilai ini, data dikirim ke Lengan Robot untuk menggerakkan servo motor tertentu dalam arah tertentu.

// finger 1 - Claw Bend/Open
if (finger >= finger_high) {
Serial.print("F");
delay(response_time);
}
if (finger <= finger_low) {
Serial.print("f");
delay(response_time);
}

Pemrograman Lengan Robot

Hasil – Balasan

Lengan Robot cukup akurat untuk menggerakkan objek. Namun, akan memerlukan beberapa pekerjaan untuk menggerakkan objek kompleks, atau bahkan bersaing dengan 'lebih dari setahun' kemampuan kekelinceran manusia ... meski menghabiskan lebih banyak waktu untuk bekerja pada kode, presisi Robot dapat bekerja sesuai tujuan untuk MARK 1i. Meskipun Lengan dapat ditingkatkan dapat ditingkatkan secara signifikan.

Jika Anda ingin meningkatkan kode, kontribusikan ke Arduino Robot Arm Git Repo dan bangun lengan Anda. Mari kita buat ini terbuka untuk orang lain untuk mengembangkannya!

Terakhir, Kami juga dapat mengontrol Robot melalui geser tangan dan memprogram Robot untuk mengotomatisasi tugas dasar.

Langkah Selanjutnya

Dan itu saja untuk MARK 1 para sahabat! Jika Anda menyukai proyek ini, pertimbangkan untuk mendukung halaman Patreon saya.

Kode

Code snippet #1
Code snippet #3
Code snippet #4
Code snippet #5
Code snippet #7
Code snippet #11
Code snippet #12

Code snippet #1Plain text

* Include the HCPCA9685 library */ #include "HCPCA9685.h" /* I2C slave address for the device/module. For the HCMODU0097 the default I2C address is 0x40 */ #define I2CAdd 0x40 /* Create an instance of the library */ HCPCA9685 HCPCA9685(I2CAdd); //initial parking position of the motor const int servo_joint_L_parking_pos = 60; //Degree of robot servo sensitivity - Intervals int servo_joint_L_pos_increment = 20; //Keep track of the current value of the motor positions int servo_joint_L_parking_pos_i = servo_joint_L_parking_pos; //Minimum and maximum angle of servo motor int servo_joint_L_min_pos = 10; int servo_joint_L_max_pos = 180;

Code snippet #3Plain text

//Defining the servo driver. 0x40 Address is the default I2C Address. #define I2CAdd 0x40 int response_time = 5; //Receiving values from the Robotic Glove interval // Checks whether data is coming from the serial port if (Serial.available() > 0) { state = Serial.read(); // Reads the data from the serial port Serial.print(state); // Prints out the value sent //Motor functionality code block }

Code snippet #4Plain text

if (Serial.available() > 0) { // Checks whether data is coming from the serial port state = Serial.read(); // Reads the data from the serial port Serial.print(state); // Prints out the value sent //For the naming of the motors, refer to the article / tutorial //Move (Base Rotation) Stepper Motor Left if (state == 'S') { baseRotateLeft(); delay(response_time); } }

Code snippet #5Plain text

HCPCA9685.Servo(0, servo_joint_L_parking_pos_i); // Drive the servo motor at channel 0 to the desired angle. //Move Claw Motor Downwards if (state == 'f') { if (servo_joint_3_parking_pos_i < servo_joint_3_max_pos) { HCPCA9685.Servo(4, servo_joint_3_parking_pos_i); delay(response_time); Serial.println(servo_joint_3_parking_pos_i); servo_joint_3_parking_pos_i = servo_joint_3_parking_pos_i + servo_joint_3_pos_increment; } } void baseRotateLeft() { digitalWrite(stepPin, LOW); //Spin in a direction based on HIGH, LOW delayMicroseconds(stepDelay); //Change the speed of the Stepper motor }

Code snippet #7Plain text

//LED ON PIN 3 int pinkie_Data = A1; int finger_Data = A2; int thumb_Data = A3; //const int MPU_addr = 0x68; const int MPU2 = 0x69, MPU1 = 0x68;

Code snippet #11Plain text

 if (bool_caliberate == false ) { delay(1000); thumb_high = (thumb * 1.15); thumb_low = (thumb * 0.9); finger_high = (finger * 1.03); finger_low = (finger * 0.8); pinkie_high = (pinkie * 1.06); pinkie_low = (pinkie * 0.8); bool_caliberate = true; }

Code snippet #12Plain text

 // finger 1 - Claw Bend/Open if (finger >= finger_high) { Serial.print("F"); delay(response_time); } if (finger <= finger_low) { Serial.print("f"); delay(response_time); }