Dalam tutorial ini kami akan mempelajari cara membuat pengendali RC Arduino buatan sendiri. Saya sering membutuhkan kontrol nirkabel untuk proyek-proyek yang saya buat, oleh karena itu saya membangun pengendali radio multifungsi ini yang dapat digunakan untuk hampir segala sesuatu.
Anda dapat menonton video di bawah ini atau membaca tutorial tulisan yang tersedia.
Ringkasan
Sekarang saya dapat mengontrol secara nirkabel setiap proyek Arduino dengan beberapa penyesuaian kecil di sisi penerima. Pengendali ini juga dapat digunakan sebagai pengendali RC komersial untuk mengontrol mainan RC, mobil, drone, dan sebagainya. Untuk tujuan itu, Anda hanya membutuhkan penerima Arduino sederhana yang kemudian menghasilkan sinyal yang sesuai untuk mengontrol perangkat RC komersial tersebut.
Saya akan menjelaskan bagaimana semuanya bekerja dalam video ini melalui beberapa contoh pengendalian mobil robot Arduino, mengontrol Arduino Ant Robot dari video saya sebelumnya, dan mengontrol motor DC brushless menggunakan ESC dan beberapa motor servo.
Komunikasi radio pengendali ini didasarkan pada modul transceiver NRF24L01 yang, jika digunakan dengan antena penguat, dapat memiliki jangkauan stabil hingga 700 meter di ruang terbuka. Pengendali ini memiliki 14 saluran, 6 di antaranya adalah input analog dan 8 input digital.
Pengendali ini memiliki dua joystick, dua potensiometer, dua saklar tombol, enam tombol, dan tambahan unit pengukur internal yang terdiri dari akselemeter dan giroskop yang juga dapat digunakan untuk mengontrol hal-hal hanya dengan memindahkan atau memiringkan pengendali.
Diagram Rangkaian Pengendali RC Arduino
Untuk memulai, mari kita lihat diagram rangkaian. Otak dari pengendali RC ini adalah Arduino Pro Mini yang diberi daya menggunakan 2 baterai LiPo yang menghasilkan sekitar 7,4 volt. Kami dapat menghubungkannya langsung ke pin RAW Pro Mini yang memiliki regulator tegangan yang menurunkan tegangan menjadi 5V. Perhatikan bahwa ada dua versi Arduino Pro Mini, seperti yang saya miliki yang beroperasi pada 5V dan yang lainnya beroperasi pada 3,3V.
Di sisi lain, modul NRF24L01 membutuhkan 3,3V secara ketat dan disarankan berasal dari sumber terpisah. Oleh karena itu, kami perlu menggunakan regulator tegangan 3,3V yang terhubung ke baterai dan mengonversi 7,4V menjadi 3,3V. Kami juga perlu menggunakan kapasitor decoupling tepat di samping modul untuk menjaga tegangan tetap stabil, sehingga komunikasi radio juga akan lebih stabil. Modul NRF24L01 berkomunikasi dengan Arduino menggunakan protokol SPI, sedangkan modul akselemeter dan giro MPU6050 menggunakan protokol I2C.
Anda dapat mendapatkan komponen yang dibutuhkan untuk tutorial Arduino ini dari tautan di bawah ini:
NRF24L01 Transceiver Module………..
NRF24L01 + PA + LNA …………………….
Potensiometer ………………………………..
Motor Servo ……………………………………
Saklar Tombol …………………………….…..
Joystick ………………………………………….. – Joystick ini dilengkapi papan breakout, jadi Anda harus mencabut lepas joystick darinya
Joystick tanpa papan breakout ………… Ebay
Arduino Pro Mini…………………………….. – Anda membutuhkan versi PCB V2 atau V3 untuk papan ini
Arduino Pro Mini seperti yang saya gunakan….. – PCB V1
HT7333 3.3v voltage regulator ……………. Dari toko elektronik lokal – PCB V1 & PCB V2
Saya akhirnya menggunakan semua pin analog dan digital Arduino Pro Mini. Jadi jika saya mencoba menghubungkan semuanya menggunakan kabel jumper, itu akan menjadi cukup berantakan. Oleh karena itu, saya merancang PCB khusus menggunakan perangkat lunak desain rangkaian online gratis EasyEDA.
Di sini saya mempertimbangkan ergonomi pengendali dan merancangnya agar dapat dipegang dengan mudah oleh dua tangan, sementara semua kontrol berada dalam jari jari. Saya membuat tepi melengkung dan menambahkan beberapa lubang 3mm sehingga saya dapat memasang PCB pada sesuatu di kemudian hari. Saya menempatkan pin untuk pemrograman Arduino Pro Mini di sisi atas pengendali sehingga dapat diakses dengan mudah jika kita ingin memrogram ulang Arduino. Kami juga dapat melihat di sini bahwa saya menggunakan pin RX dan TX Arduino untuk tombol joystick. Namun, kedua garis ini harus dicabut dari segala sesuatu saat kita mengunggah sketsa ke Arduino. Oleh karena itu, mereka diinterupsi dengan dua pin yang kemudian dapat dihubungkan dengan mudah menggunakan klem jumper sederhana.
Harap diperhatikan: Pastikan Anda memiliki versi Arduino Pro Mini yang sesuai dengan PCB atau modifikasi desain PCB sesuai dengan versi tersebut. Berikut adalah foto perbandingan antara tiga versi yang berbeda, tergantung pada Arduino dan regulator tegangan Anda.
Berikut adalah tautan ke berkas proyek desain PCB ini. Berkas ini membuka tiga versi yang berbeda dalam tab terpisah, jadi Anda dapat memilih yang Anda butuhkan.
Setelah selesai merancang, saya menghasilkan berkas Gerber yang diperlukan untuk pembuatan PCB.
Berkas Gerber:
Kemudian saya memesan PCB dari JLCPCB yang juga merupakan sponsor video ini.
Di sini kami cukup seret dan lepas berkas Gerber dan setelah diunggah, kami dapat meninjau PCB kami dalam penampil Gerber. Jika semuanya baik, kami dapat melanjutkan dan memilih properti yang kami inginkan untuk PCB kami. Kali ini saya memilih warna PCB menjadi hitam. Dan itulah saja, sekarang kami cukup memesan PCB kami dengan harga terjangkau. Perhatikan jika ini adalah pesanan pertama Anda dari JLCPCB, Anda dapat mendapatkan hingga 10 PCB hanya dengan $2.
Dan inilah hasilnya. Saya sangat suka bagaimana PCB ini terbentuk dengan warna hitam ini. Kualitas PCB sangat bagus, dan semuanya sama persis dengan desain.
Mengrakit PCB
Oke sekarang kita dapat melanjutkan dengan merakit PCB. Saya memulai dengan mencabut lepas pin header Arduino Pro Mini. Cara yang mudah dan baik untuk melakukannya adalah dengan menempatkannya pada papan roti sehingga mereka akan tetap kokoh saat mencabut lepas.
Pro Mini juga memiliki pin di sisi, tetapi perhatikan bahwa lokasi pin ini dapat bervariasi tergantung pada produsen.
Untuk model khusus yang saya miliki, saya membutuhkan 5 pin untuk setiap sisi, sambil membiarkan satu pin GND kosong karena saya menggunakan area di bawahnya pada PCB untuk menjalani beberapa lintasan. Saya mencabut lepas Arduino Pro Mini langsung ke PCB dan memotong panjang berlebihan header. Tepat di sampingnya adalah modul akselemeter dan giroskop MPU6050.
Kemudian saya mencabut lepas regulator tegangan 3,3V dengan kapasitor di sampingnya, dan kapasitor lain di dekat modul NRF24L01. Modul ini memiliki tiga versi yang berbeda dan kami dapat menggunakan salah satunya di sini.
Saya melanjutkan dengan pin untuk pemrograman Arduino, pin RX dan TX, pin suplai daya, dan saklar daya.
Selanjutnya untuk mencabut lepas potensiometer ke PCB, saya harus memperpanjang pin mereka menggunakan beberapa pin header.
Kami dapat melihat di sini bahwa saya sebelumnya memotong panjang knop sehingga saya dapat memasang beberapa tutup pada mereka dengan baik. Namun, kita akan mencabut lepas potensiometer ke PCB nanti.
Kemudian saya memasukkan dan mencabut lepas dua saklar tombol dan dua joystick ke tempatnya.
Terakhir yang tersisa adalah mencabut lepas empat tombol tekan. Namun mereka tidak memiliki ketinggian yang tepat, jadi lagi saya menggunakan pin header untuk memperpanjang pin mereka sedikit.
Dan itulah saja, PCB kami sekarang siap jadi kita dapat melanjutkan dengan membuat tutup untuknya. Karena saya suka bagaimana tampilan PCB dan saya ingin terlihat, saya memutuskan untuk menggunakan akrilik transparan untuk tutupnya.
Di sini saya memiliki akrilik transparan tebal 4 mm yang saat ini memiliki lapisan pelindung dan terlihat biru. Ide untuk tutupnya adalah membuat dua piring dengan bentuk PCB dan mengamankan salah satunya di sisi atas dan yang lainnya di sisi bawah PCB.
Jadi saya menandai bentuk PCB dan menggunakan gergaji logam tangan saya memotong akrilik menurutnya.
Kemudian menggunakan garpu sederhana, saya menyesuaikan bentuk akrilik. Dua piring tersebut berhasil bagus dan cocok sempurna dengan PCB.
Selanjutnya saya menandai lokasi tempat saya perlu membuat pembuka untuk komponen untuk melewati. Menggunakan bor 3mm saya pertama membuat 4 lubang untuk mengamankan piring ke PCB. Untuk lubang ini saya juga membuat penurun sehingga baut dapat ditempel rata dengan piring.
Untuk pembuka untuk saklar tombol dan potensiometer saya menggunakan bor 6mm, dan untuk pembuka joystick saya menggunakan bor Forstner 25mm. Lagi, menggunakan garpu, saya menyesuaikan semua pembuka.
Sebelum merakit tutup, hanya catatan kecil bahwa saya sebenarnya mencabut lepas pin header suplai daya terbalik sehingga dapat dijangkau dari sisi belakang tempat baterai akan berada.
Oke sekarang kita dapat memulai merakit tutup. Saya memulai dengan mencabut lepas lapisan pelindung dari akrilik yang saya akui cukup memuaskan karena akrilik sekarang sangat bersih. Jadi pertama-tama saya mengamankan dua potensiometer pada piring atas, memasukkan baut pemasangan 3mm dan menempatkan cincin jarak 11mm ke tempatnya.
Kemudian saya dengan cermat menggabungkan dan mengamankan piring atas dan PCB menggunakan beberapa baut. Pada titik ini saya akhirnya mencabut lepas potensiometer ke PCB karena sebelumnya saya tidak tahu dengan tepat ketinggian mereka akan ditempatkan.
Selanjutnya di piring belakang saya memasang baterai menggunakan 2 baut. Saya menyelesaikan pemasangan tutup dengan mengamankan piring belakang ke sisi belakang PCB menggunakan empat baut pemasangan.
Terakhir, kita dapat memasang kabel baterai ke pin suplai daya, memasukkan dan mengamankan knop pada potensiometer, memasukkan knop joystick dan memasang antena ke modul NRF24l01. Dan itulah saja, akhirnya kami selesai dengan pengendali RC Arduino buatan sendiri.
Yang tersisa sekarang adalah memprogram Arduino. Untuk memprogram papan Pro Mini kita memerlukan antarmuka USB ke serial UART yang dapat dihubungkan ke header pemrograman yang terletak di sisi atas pengendali kami.
Kemudian di menu alat Arduino IDE kita perlu memilih papan Arduino Pro atau Pro Mini, memilih versi prosesor yang tepat, memilih port dan memilih metode pemrograman ke “USBasp”.
Dan sekarang kami dapat mengunggah kode ke Arduino.
Kode Pengendali RC Berbasis Arduino DIY
Mari kita jelaskan bagaimana kode pengendali bekerja. Jadi pertama-tama kita perlu menyertakan perpustakaan SPI dan RF24 untuk komunikasi nirkabel, dan perpustakaan I2C untuk modul akselemeter. Kemudian kita perlu mendefinisikan input digital, beberapa variabel yang diperlukan untuk program di bawah ini, mendefinisikan objek radio dan alamat komunikasi.
Kemudian kita perlu mendefinisikan struktur tempat kita akan menyimpan 14 nilai input pengendali. Ukuran maksimum struktur ini dapat berukuran 32 byte karena itu adalah batas buffer NRF24L01 atau jumlah data yang dapat dikirim modul sekaligus.
/ 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
Di bagian setup kita perlu menginisialisasi modul MPU6050 dan kita juga dapat menghitung kesalahan IMU yang merupakan nilai yang nantinya digunakan saat menghitung sudut yang benar dari modul.
void initialize_MPU6050() { Wire.begin(); // Initialize comunication Wire.beginTransmission(MPU); // Start communication with MPU6050 // MPU=0x68 Wire.write(0x6B); // Talk to the register 6B Wire.write(0x00); // Make reset - place a 0 into the 6B register Wire.endTransmission(true); //end the transmission // Configure Accelerometer Wire.beginTransmission(MPU); Wire.write(0x1C); //Talk to the ACCEL_CONFIG register Wire.write(0x10); //Set the register bits as 00010000 (+/- 8g full scale range) Wire.endTransmission(true); // Configure Gyro Wire.beginTransmission(MPU); Wire.write(0x1B); // Talk to the GYRO_CONFIG register (1B hex) Wire.write(0x10); // Set the register bits as 00010000 (1000dps full scale) Wire.endTransmission(true); }
Anda dapat menemukan lebih banyak detail bagaimana akselemeter dan giro MEMS bekerja di sini. Tutorial khusus untuk MPU6050 akan segera hadir.
Kemudian kita perlu menginisialisasi komunikasi radio, mengaktifkan resistor pull-up internal Arduino untuk semua input digital dan menetapkan nilai default awal untuk semua variabel.
// Define the radio communication radio.begin(); radio.openWritingPipe(address); radio.setAutoAck(false); radio.setDataRate(RF24_250KBPS); radio.setPALevel(RF24_PA_LOW); // Activate the Arduino internal pull-up resistors pinMode(jB1, INPUT_PULLUP); pinMode(jB2, INPUT_PULLUP); pinMode(t1, INPUT_PULLUP); pinMode(t2, INPUT_PULLUP); pinMode(b1, INPUT_PULLUP); pinMode(b2, INPUT_PULLUP); pinMode(b3, INPUT_PULLUP); pinMode(b4, INPUT_PULLUP);
Di bagian loop mulai dengan membaca semua input analog, memetakan nilainya dari 0 hingga 1023 menjadi nilai byte dari 0 hingga 255 karena kita telah mendefinisikan variabel dalam struktur kami sebagai byte. Setiap input disimpan dalam variabel data tertentu dari struktur.
// Read all analog inputs and map them to one Byte value data.j1PotX = map(analogRead(A1), 0, 1023, 0, 255); // Convert the analog read value from 0 to 1023 into a BYTE value from 0 to 255 data.j1PotY = map(analogRead(A0), 0, 1023, 0, 255); data.j2PotX = map(analogRead(A2), 0, 1023, 0, 255); data.j2PotY = map(analogRead(A3), 0, 1023, 0, 255); data.pot1 = map(analogRead(A7), 0, 1023, 0, 255); data.pot2 = map(analogRead(A6), 0, 1023, 0, 255);
Kita hanya perlu mencatat bahwa karena kita menggunakan resistor pull-up, pembacaan pin digital adalah 0 saat tombol ditekan.
Jadi menggunakan fungsi radio.write() kita cukup mengirim nilai dari semua 14 saluran ke penerima.
// Send the whole data from the structure to the receiver radio.write(&data, sizeof(Data_Package));
Jika saklar tombol 1 dihidupkan, maka kita menggunakan data akselemeter dan giro alih-alih untuk kontrol.
if (digitalRead(t1) == 0) { read_IMU(); // Use MPU6050 instead of Joystick 1 for controling left, right, forward and backward movements }
Jadi alih-alih nilai X dan Y joystick 1 kita menggunakan nilai sudut yang kita peroleh dari IMU, yang sebelumnya kita konversi dari nilai -90 hingga +90 derajat menjadi nilai byte dari 0 hingga 255 dengan cara yang tepat.
// Map the angle values from -90deg to +90 deg into values from 0 to 255, like the values we are getting from the Joystick data.j1PotX = map(angleX, -90, +90, 255, 0); data.j1PotY = map(angleY, -90, +90, 0, 255);
Itulah cara kerja kode pengendali, hal terpenting adalah menentukan komunikasi radio dan mengirim data ke penerima.
Berikut adalah kode Arduino lengkap untuk pengendali RC Arduino buatan sendiri ini:
/* DIY Arduino based RC Transmitter by Dejan Nedelkovski, www.HowToMechatronics.com Library: TMRh20/RF24, https://github.com/tmrh20/RF24/ */ #include <SPI.h> #include <nRF24L01.h> #include <RF24.h> #include <Wire.h> // Define the digital inputs #define jB1 1 // Joystick button 1 #define jB2 0 // Joystick button 2 #define t1 7 // Toggle switch 1 #define t2 4 // Toggle switch 1 #define b1 8 // Button 1 #define b2 9 // Button 2 #define b3 2 // Button 3 #define b4 3 // Button 4 const int MPU = 0x68; // MPU6050 I2C address float AccX, AccY, AccZ; float GyroX, GyroY, GyroZ; float accAngleX, accAngleY, gyroAngleX, gyroAngleY; float angleX, angleY; float AccErrorX, AccErrorY, GyroErrorX, GyroErrorY; float elapsedTime, currentTime, previousTime; int c = 0; RF24 radio(5, 6); // nRF24L01 (CE, CSN) const byte address[6] = "00001"; // Address // 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() { Serial.begin(9600); // Initialize interface to the MPU6050 initialize_MPU6050(); // Call this function if you need to get the IMU error values for your module //calculate_IMU_error(); // Define the radio communication radio.begin(); radio.openWritingPipe(address); radio.setAutoAck(false); radio.setDataRate(RF24_250KBPS); radio.setPALevel(RF24_PA_LOW); // Activate the Arduino internal pull-up resistors pinMode(jB1, INPUT_PULLUP); pinMode(jB2, INPUT_PULLUP); pinMode(t1, INPUT_PULLUP); pinMode(t2, INPUT_PULLUP); pinMode(b1, INPUT_PULLUP); pinMode(b2, INPUT_PULLUP); pinMode(b3, INPUT_PULLUP); pinMode(b4, INPUT_PULLUP); // Set initial default values data.j1PotX = 127; // Values from 0 to 255. When Joystick is in resting position, the value is in the middle, or 127. We actually map the pot value from 0 to 1023 to 0 to 255 because that's one BYTE value 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; } void loop() { // Read all analog inputs and map them to one Byte value data.j1PotX = map(analogRead(A1), 0, 1023, 0, 255); // Convert the analog read value from 0 to 1023 into a BYTE value from 0 to 255 data.j1PotY = map(analogRead(A0), 0, 1023, 0, 255); data.j2PotX = map(analogRead(A2), 0, 1023, 0, 255); data.j2PotY = map(analogRead(A3), 0, 1023, 0, 255); data.pot1 = map(analogRead(A7), 0, 1023, 0, 255); data.pot2 = map(analogRead(A6), 0, 1023, 0, 255); // Read all digital inputs data.j1Button = digitalRead(jB1); data.j2Button = digitalRead(jB2); data.tSwitch2 = digitalRead(t2); data.button1 = digitalRead(b1); data.button2 = digitalRead(b2); data.button3 = digitalRead(b3); data.button4 = digitalRead(b4); // If toggle switch 1 is switched on if (digitalRead(t1) == 0) { read_IMU(); // Use MPU6050 instead of Joystick 1 for controling left, right, forward and backward movements } // Send the whole data from the structure to the receiver radio.write(&data, sizeof(Data_Package)); } void initialize_MPU6050() { Wire.begin(); // Initialize comunication Wire.beginTransmission(MPU); // Start communication with MPU6050 // MPU=0x68 Wire.write(0x6B); // Talk to the register 6B Wire.write(0x00); // Make reset - place a 0 into the 6B register Wire.endTransmission(true); //end the transmission // Configure Accelerometer Wire.beginTransmission(MPU); Wire.write(0x1C); //Talk to the ACCEL_CONFIG register Wire.write(0x10); //Set the register bits as 00010000 (+/- 8g full scale range) Wire.endTransmission(true); // Configure Gyro Wire.beginTransmission(MPU); Wire.write(0x1B); // Talk to the GYRO_CONFIG register (1B hex) Wire.write(0x10); // Set the register bits as 00010000 (1000dps full scale) Wire.endTransmission(true); } void calculate_IMU_error() { // We can call this funtion in the setup section to calculate the accelerometer and gury data error. From here we will get the error values used in the above equations printed on the Serial Monitor. // Note that we should place the IMU flat in order to get the proper values, so that we then can the correct values // Read accelerometer values 200 times while (c < 200) { Wire.beginTransmission(MPU); Wire.write(0x3B); Wire.endTransmission(false); Wire.requestFrom(MPU, 6, true); AccX = (Wire.read() << 8 | Wire.read()) / 4096.0 ; AccY = (Wire.read() << 8 | Wire.read()) / 4096.0 ; AccZ = (Wire.read() << 8 | Wire.read()) / 4096.0 ; // Sum all readings AccErrorX = AccErrorX + ((atan((AccY) / sqrt(pow((AccX), 2) + pow((AccZ), 2))) * 180 / PI)); AccErrorY = AccErrorY + ((atan(-1 * (AccX) / sqrt(pow((AccY), 2) + pow((AccZ), 2))) * 180 / PI)); c++; } //Divide the sum by 200 to get the error value AccErrorX = AccErrorX / 200; AccErrorY = AccErrorY / 200; c = 0; // Read gyro values 200 times while (c < 200) { Wire.beginTransmission(MPU); Wire.write(0x43); Wire.endTransmission(false); Wire.requestFrom(MPU, 4, true); GyroX = Wire.read() << 8 | Wire.read(); GyroY = Wire.read() << 8 | Wire.read(); // Sum all readings GyroErrorX = GyroErrorX + (GyroX / 32.8); GyroErrorY = GyroErrorY + (GyroY / 32.8); c++; } //Divide the sum by 200 to get the error value GyroErrorX = GyroErrorX / 200; GyroErrorY = GyroErrorY / 200; // Print the error values on the Serial Monitor Serial.print("AccErrorX: "); Serial.println(AccErrorX); Serial.print("AccErrorY: "); Serial.println(AccErrorY); Serial.print("GyroErrorX: "); Serial.println(GyroErrorX); Serial.print("GyroErrorY: "); Serial.println(GyroErrorY); } void read_IMU() { // === Read acceleromter data === // Wire.beginTransmission(MPU); Wire.write(0x3B); // Start with register 0x3B (ACCEL_XOUT_H) Wire.endTransmission(false); Wire.requestFrom(MPU, 6, true); // Read 6 registers total, each axis value is stored in 2 registers //For a range of +-8g, we need to divide the raw values by 4096, according to the datasheet AccX = (Wire.read() << 8 | Wire.read()) / 4096.0; // X-axis value AccY = (Wire.read() << 8 | Wire.read()) / 4096.0; // Y-axis value AccZ = (Wire.read() << 8 | Wire.read()) / 4096.0; // Z-axis value // Calculating angle values using accAngleX = (atan(AccY / sqrt(pow(AccX, 2) + pow(AccZ, 2))) * 180 / PI) + 1.15; // AccErrorX ~(-1.15) See the calculate_IMU_error()custom function for more details accAngleY = (atan(-1 * AccX / sqrt(pow(AccY, 2) + pow(AccZ, 2))) * 180 / PI) - 0.52; // AccErrorX ~(0.5) // === Read gyro data === // previousTime = currentTime; // Previous time is stored before the actual time read currentTime = millis(); // Current time actual time read elapsedTime = (currentTime - previousTime) / 1000; // Divide by 1000 to get seconds Wire.beginTransmission(MPU); Wire.write(0x43); // Gyro data first register address 0x43 Wire.endTransmission(false); Wire.requestFrom(MPU, 4, true); // Read 4 registers total, each axis value is stored in 2 registers GyroX = (Wire.read() << 8 | Wire.read()) / 32.8; // For a 1000dps range we have to divide first the raw value by 32.8, according to the datasheet GyroY = (Wire.read() << 8 | Wire.read()) / 32.8; GyroX = GyroX + 1.85; //// GyroErrorX ~(-1.85) GyroY = GyroY - 0.15; // GyroErrorY ~(0.15) // Currently the raw values are in degrees per seconds, deg/s, so we need to multiply by sendonds (s) to get the angle in degrees gyroAngleX = GyroX * elapsedTime; gyroAngleY = GyroY * elapsedTime; // Complementary filter - combine acceleromter and gyro angle values angleX = 0.98 * (angleX + gyroAngleX) + 0.02 * accAngleX; angleY = 0.98 * (angleY + gyroAngleY) + 0.02 * accAngleY; // Map the angle values from -90deg to +90 deg into values from 0 to 255, like the values we are getting from the Joystick data.j1PotX = map(angleX, -90, +90, 255, 0); data.j1PotY = map(angleY, -90, +90, 0, 255); }
Kode Penerima
Sekarang mari kita lihat bagaimana kita dapat menerima data ini. Berikut adalah skematis penerima Arduino dan NRF24L01 sederhana. Tentu saja Anda dapat menggunakan papan Arduino lainnya.
Dan berikut adalah kode penerima sederhana tempat kita akan menerima data dan cukup mencetaknya di serial monitor sehingga kita tahu bahwa komunikasi berjalan dengan baik. Lagi kita perlu menyertakan perpustakaan RF24 dan mendefinisikan objek dan struktur dengan cara yang sama seperti kode pengendali. Di bagian setup saat mendefinisikan komunikasi radio kita perlu menggunakan pengaturan yang sama seperti pengendali dan menetapkan modul sebagai penerima menggunakan fungsi radio.startListening().
/* DIY Arduino based RC Transmitter Project == Receiver Code == by Dejan Nedelkovski, www.HowToMechatronics.com Library: TMRh20/RF24, https://github.com/tmrh20/RF24/ */ #include <SPI.h> #include <nRF24L01.h> #include <RF24.h> RF24 radio(10, 9); // nRF24L01 (CE, CSN) const byte address[6] = "00001"; unsigned long lastReceiveTime = 0; unsigned long currentTime = 0; // 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() { Serial.begin(9600); 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 resetData(); } void loop() { // 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 } // 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 has a throttle up and we lose connection, it can keep flying unless we reset the values } // Print the data in the Serial Monitor Serial.print("j1PotX: "); Serial.print(data.j1PotX); Serial.print("; j1PotY: "); Serial.print(data.j1PotY); Serial.print("; button1: "); Serial.print(data.button1); Serial.print("; j2PotX: "); Serial.println(data.j2PotX); } 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; }
Di dalam loop utama menggunakan fungsi available() kita memeriksa apakah ada data yang masuk. Jika benar, kita cukup membaca data dan menyimpannya ke dalam variabel struktur. Sekarang kita dapat mencetak data di serial monitor untuk memeriksa apakah transmisi berjalan dengan baik. Juga menggunakan fungsi millis() dan pernyataan if kita memeriksa apakah kita terus menerima data, atau jika kita tidak menerima data selama lebih dari 1 detik, maka kita mengatur ulang variabel ke nilai default mereka. Kita gunakan ini untuk mencegah perilaku yang tidak diinginkan, misalnya jika drone memiliki throttle naik dan kita kehilangan koneksi, itu dapat terus terbang kecuali kita mengatur ulang nilainya.
Itulah saja. Sekarang kita dapat menerapkan metode penerimaan data ini untuk setiap proyek Arduino. Misalnya di sini adalah kode untuk mengontrol mobil robot Arduino dari salah satu video saya sebelumnya.
Sebagai pembaruan untuk proyek ini, saya membuat Penerima RC berbasis Arduino khusus. Lagi, ini didasarkan pada papan Arduino Pro mini dan memiliki beberapa koneksi servo dan ESC yang siap pakai, ditempatkan pada PCB yang kompak.
Kontrol Nirkabel Mobil Robot Arduino menggunakan Pengendali RC
Kode Arduino:
Di sini kita perlu mendefinisikan perpustakaan, struktur, dan komunikasi radio seperti yang dijelaskan sebelumnya. Kemudian di dalam loop utama kita hanya perlu membaca data yang masuk dan menggunakannya untuk apa pun yang kita inginkan. Dalam hal ini saya menggunakan nilai joystick 1 untuk mengemudi mobil.
Kontrol Robot Semut / Hexapod Arduino menggunakan Pengendali RC Arduino
Kode Arduino:
Dengan cara yang sama persis saya membuat Robot Semut Arduino dari video saya sebelumnya agar dapat dikendalikan secara nirkabel menggunakan Pengendali RC Arduino ini. Kita hanya perlu membaca data, dan menurutnya menjalankan fungsi yang sesuai, seperti bergerak ke depan, kiri, kanan, gigit, serang, dan sebagainya.
Kontrol ESC dan Servo menggunakan Pengendali RC
Terakhir, mari kita lihat bagaimana pengendali ini dapat digunakan untuk mengontrol perangkat RC komersial.
Biasanya untuk perangkat ini kita perlu mengontrol servo atau motor brushless mereka. Setelah menerima data dari pengendali, untuk mengontrol servo kita cukup menggunakan perpustakaan Servo Arduino dan menggunakan nilai dari 0 hingga 180 derajat. Untuk mengontrol motor brushless menggunakan ESC, kita dapat lagi menggunakan perpustakaan servo untuk menghasilkan sinyal PWM 50Hz yang digunakan untuk mengontrol ESC. Dengan mengubah siklus kerja dari 1000 hingga 2000 mikrodetik kita mengontrol RPM motor dari nol hingga maksimum. Namun, lebih lanjut tentang mengontrol motor brushless menggunakan ESC dalam tutorial saya selanjutnya.
Perhatikan bahwa sebenarnya kita tidak dapat menggabungkan sistem penerima RC standar dengan sistem NRF24L01 2.4GHz ini. Alih-alih, kita perlu memodifikasi atau membuat penerima kami sendiri yang terdiri dari Arduino dan Modul NRF24L01. Dari sana kita dapat kemudian menghasilkan sinyal PWM atau PPM yang sesuai untuk mengontrol perangkat RC.
/* DIY Arduino based RC Transmitter Project == Receiver Code - ESC and Servo Control == by Dejan Nedelkovski, www.HowToMechatronics.com Library: TMRh20/RF24, https://github.com/tmrh20/RF24/ */ #include <SPI.h> #include <nRF24L01.h> #include <RF24.h> #include <Servo.h> RF24 radio(10, 9); // nRF24L01 (CE, CSN) const byte address[6] = "00001"; unsigned long lastReceiveTime = 0; unsigned long currentTime = 0; Servo esc; // create servo object to control the ESC Servo servo1; Servo servo2; int escValue, servo1Value, servo2Value; // 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() { Serial.begin(9600); 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 resetData(); esc.attach(9); servo1.attach(3); servo2.attach(4); } 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 } // Controlling servos servo1Value = map(data.j2PotX, 0, 255, 0, 180); servo2Value = map(data.j2PotY, 0, 255, 0, 180); servo1.write(servo1Value); servo2.write(servo2Value); // Controlling brushless motor with ESC escValue = map(data.pot1, 0, 255, 1000, 2000); // Map the receiving value form 0 to 255 to 0 1000 to 2000, values used for controlling ESCs esc.writeMicroseconds(escValue); // Send the PWM control singal to the ESC } 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; }
Itulah saja. Saya harap Anda menikmati video ini dan mempelajari hal baru. Jangan ragu untuk bertanya di bagian komentar di bawah ini dan lihat Koleksi Proyek Arduino saya.
