Penggeser Kamera Bermotor yang Dikendalikan Bluetooth Arduino

Tentang proyek ini

Ikhtisar Proyek

Untuk seseorang yang suka merekam beberapa video hobi acak, entah bagaimana mahal untuk membeli penggeser kamera bermotor. Jadi, saya membangun sendiri. Dalam tutorial ini, kita akan melalui setiap langkah untuk membuat slider kamera bermotor yang dikendalikan Bluetooth milik Anda sendiri.

Hari ini kita akan membuat penggeser kamera bermotor yang dapat kita kendalikan secara nirkabel melalui Bluetooth dari aplikasi seluler android yang dibuat khusus. Saya menggunakan alat "Penemu Aplikasi MIT" untuk membuat aplikasi yang memberi kita kemampuan untuk mengontrol banyak hal seperti kecepatan gerakan penggeser, jarak tempuh, laju akselerasi/perlambatan, dan banyak lagi. Aplikasi seluler sangat kuat, di dalam aplikasi Anda dapat mengatur panjang penggeser kamera yang Anda gunakan. yang artinya, Anda bebas membuat penggeser kamera yang sebenarnya dengan panjang berapa pun hingga 10 meter tanpa mengkhawatirkan aplikasi.

Kami menggunakan motor stepper NEMA17 sebagai aktuator sehingga kami dapat mengontrol berapa banyak langkah yang kami perlukan untuk menggerakkan penggeser kamera. Untuk mengendalikan motor stepper menggunakan board Arduino, kita membutuhkan penerjemah yang mengambil perintah dari board Arduino dan menerjemahkannya ke bahasa yang dimengerti oleh motor stepper. Inilah peran driver motor stepper Pololu A4988, yang memberi kita lima resolusi mikrolangkah berbeda (turun ke 1/16 langkah) untuk mencapai akurasi gerakan maksimum dan kelancaran gerakan.

Proyek ini Dirancang dengan mempertimbangkan kemampuan dalam fablab/makerspace/hackerspace.

CAD Dan Pemodelan 3d

Kami menggunakan Fusion360 untuk mendesain penggeser kamera, kami memilih untuk menggunakan komponen mekanis yang sangat terkenal dan mudah ditemukan yang dapat Anda beli dengan mudah dari hampir semua toko online atau offline di mana pun Anda tinggal.

Kami menggunakan perangkat keras Openbuilds untuk membangun struktur mekanis, rel linier V-slot 2040 sebagai panduan bagi kamera untuk bergerak. Dua katrol, satu di poros motor stepper. Dan yang lainnya, pada poros rel linier 8mm di sisi berlawanan dari penggeser dengan timing belt terbuka di antara keduanya untuk mengubah dari gerakan putar motor stepper menjadi gerakan linier.

Poros rel linier 8mm dipasang di antara dua Bantalan Blok Flange Bantalan Self-aligning yang dipasang di pelat atas dan bawah dengan empat sekrup M5.

Kami menggunakan empat roda solid Delrin V-Slot yang mereka kendarai di alur-V dari rel V-Slot untuk membuat pergerakan kamera menjadi sangat halus. Bagian tengah pelat kamera memiliki lubang berdiameter 1/4 inci untuk sekrup tripod standar sehingga Anda dapat memasang kamera dengan mudah.

Terakhir, penutup untuk elektronik, Semua bagian penggeser kamera dipasang bersama dengan sekrup dan mur m3*16mm.

Fabrikasi Digital (Pencetakan 3d)

Semua bodi penggeser kamera Dicetak 3D dengan tinggi lapisan 0,2, pengisi 20% kecuali kaki penggeser Kamera kiri dan kanan, dicetak dengan tinggi lapisan 0,2, pengisi 50%.

Anda dapat mengunduh file STL dari Thingiverse.

Perakitan Kit V-Wheel

Proses perakitannya sangat mudah sob, yuk! Pada langkah pertama, kita perlu merakit keempat Solid V-Wheels. Kit roda-V yang solid dilengkapi dengan roda karet, dua bantalan, dua shim persisi, dan mur pengunci.

Masukkan bantalan dari satu sisi roda karet dan putar roda, lalu masukkan satu shim presisi ke dalam roda karet, terakhir masukkan bantalan kedua dari sisi muka kedua.

Rakitan Mekanik Penggeser Kamera

Pertama, Kita perlu merakit pelat kamera dan keempat V-Wheels yang kokoh. menggunakan spacer aluminium 9mm, shim presisi, dan mur pengunci.

Kami akan mengulangi langkah sebelumnya dengan tiga roda lainnya. di dua roda kanan, kita akan menggunakan spacer 9mm. Dan dua roda kiri lainnya kita akan menggunakan spacer eksentrik dengan spacer 3mm, bukan spacer 9mm.

Sekarang, masukkan pelat dudukan kamera ke dalam profil slot-V. Jika ternyata pelatnya kendor dan bergoyang, Anda bisa mengencangkan mur Eksentrik sampai Anda mendapatkan pelat yang kokoh.

Mari masukkan dua mur tee drop-in di setiap ujung profil slot-V. kita perlu menghubungkan profil slot-V dengan kaki kanan dan kiri penggeser kamera.

Dapatkan kedua kaki penggeser kamera dan dorong ke dalam profil slot-V.

bawa empat sekrup M5X10mm, dan kencangkan kedua kakinya dengan profil slot-V.

Kita perlu memasang motor stepper NEMA 17 pada platnya. kemudian, menggunakan empat sekrup M3X16mm, kami akan memperbaiki motor di tempatnya.

Di kaki kiri, masukkan dua mur di dalam tempat mur atas kaki kiri.

Pasang iklan plat motor NEMA 17 pasang di kaki kiri atas. dan, dengan menggunakan dua sekrup M3X16mm, kami akan memperbaiki pelat di kaki kiri.

Untuk dapat mengubah gerakan rotasi motor stepper menjadi gerakan linier, kita perlu memasang pulley GT2 Bore 5mm pada poros motor. dan menggunakan kunci Allen, kencangkan sekrup set katrol agar tetap di tempatnya.

Mari kita pergi ke kaki kanan penggeser kamera, masukkan empat mur M3 di tempat mur kaki.

Kemudian, letakkan bantalan kaki kanan dua pelat di bagian atas kaki kanan penggeser kamera.

Dengan menggunakan empat sekrup M3X16mm, pasang kedua pelat pada kaki kanan penggeser kamera agar tetap di tempatnya.

Bawa salah satu bantalan blok flensa 8mm dan pasang di pelat kaki kanan atas. menggunakan dua sekrup M5X20mm dan dua mur M5.

Kita perlu mengulangi langkah sebelumnya dengan blok bantalan flensa 8mm kedua untuk memasangnya pada pelat bawah kaki kanan penggeser kamera.

Masukkan poros rel linier 8mm di blok bantalan flensa 8mm dari sisi bawahnya, dorong ke atas. Kemudian, masukkan katrol lubang 8 mm ke dalam poros rel linier dan kencangkan dengan mengencangkan sekrup set katrol.

Pos pemeriksaan, Sekarang kami merakit semua mekanisme penggeser kamera kecuali satu hal. sabuk waktu. Ayo lakukan.

putar timing belt 6mm pada motor NEMA17 bore pulley 5mm. Selain itu, pada kaki kanan bore pulley 8mm. Terakhir, kencangkan sabuk dengan pelat kamera.

Saatnya merakit papan kontrol. masukkan pelindung Arduino Camera Slider Kairo di bagian atas papan Arduino.

Masukkan board Arduino dan pelindung Cairo Camera Slider ke dalam enklosur papan kontrol.

masukkan dua mur M3 ke dalam tempat mur kaki kiri.

pasang penutup papan kontrol ke kaki kiri Cairo Camera Slider dengan sekrup M3X16mm.

tutup bagian atas kotak penutup dengan dua sekrup dan mur M3, dan selesai!

Kontrol Uji Motor Stepper

Setelah merakit semua bagian bersama-sama, Kita perlu mengujinya untuk memastikan bahwa semuanya terpasang di tempatnya dengan benar. Sekarang, kita perlu menghubungkan motor stepper dengan papan Arduino melalui driver motor stepper A4988 dan menulis beberapa kode untuk menjalankannya.

Driver motor stepper A4988

Untuk mengontrol motor stepper menggunakan board Arduino atau mikrokontroler apa pun, Anda memerlukan driver motor stepper yang berfungsi sebagai penerjemah, mengambil perintah dari board Arduino, dan menerjemahkannya ke bahasa yang dimengerti motor.

ada banyak driver motor stepper di luar sana tetapi kami akan menggunakan driver A4988 . Driver ini memungkinkan kita untuk mengontrol satu motor bipolar hingga arus keluaran 2A per koil, sangat mudah untuk berinteraksi dengan papan Arduino Anda hanya perlu dua pin digital untuk sepenuhnya mengontrol langkah dan arah motor Anda, memungkinkan Anda untuk mengontrol output arus maksimum mudah dengan potensiometer onboard, dan memberi Anda resolusi langkah mikro hingga 1/16 langkah mikro.

VMOT, GND: Itu pin koneksi daya untuk motor stepper itu sendiri, bisa 8V-35V. Dalam kasus kami, kami menghubungkan sumber daya 12V 3A pada pin tersebut dengan kapasitor decoupling 100uf untuk melindungi board A4998 dari lonjakan daya apa pun.

2B, 2A: pin output untuk kumparan pertama motor stepper yang dapat menghasilkan hingga 2A.

1A, 1B: pin output untuk kumparan kedua motor stepper yang juga dapat menghasilkan hingga 2A.

VDD, GND: Digunakan untuk menggerakkan sirkuit logika internal, bisa dari 3V hingga 5.5V. Ini benar-benar terisolasi dari pin VMOT.

ID: Singkatan dari "Enable" itu adalah pin input LOW (0V) yang aktif, yang berarti ketika pin ini menarik LOW (0V) chip A4988 diaktifkan. Dan ketika ditarik TINGGI (5V) chip A4988 dinonaktifkan. Secara default, pin ini ditarik LOW (0V). Jadi, chip selalu diaktifkan kecuali Anda menariknya TINGGI (5V).

MS1, MS2, MS3: Melalui pin ini, Anda dapat memilih resolusi microstepping motor Anda (ukuran langkah). A4988 memberi Anda lima resolusi langkah mikro yang berbeda (langkah penuh, setengah langkah, seperempat langkah, Langkah kedelapan, langkah keenam belas) . Dengan menerapkan level logika yang sesuai ke tiga pin ini, kita dapat menyetel motor ke salah satu dari lima resolusi langkah.

Secara default, MS1, MS2, MS3 pin memiliki resistor pull-down internal. Jadi, membiarkan ketiga pin pemilihan langkah mikro ini terputus menghasilkan mode langkah penuh.

RST, SLP: “Setel Ulang” pin adalah pin input LOW (0V) yang aktif, yang berarti ketika ditarik LOW (0V), semua input langkah diabaikan itu juga me-reset penerjemah itu sendiri sampai Anda menariknya HIGH (5V). “Tidur” pin juga pin RENDAH aktif, menariknya RENDAH, menempatkan pengemudi dalam mode tidur meminimalkan konsumsi daya. Secara default, “Tidur” pin ditarik TINGGI (5V).

STP, DIR: “Langkah” pin bertanggung jawab untuk mengontrol jumlah langkah motor yang berputar, setiap pulsa ke “Langkah” pin sesuai untuk satu langkah mikro ke arah yang dipilih oleh “Arah” pin, semakin cepat pulsa, semakin cepat motor akan berputar. Dengan menerapkan nilai logika TINGGI(5V) pada “Arah” pin itu membuat motor berputar searah jarum jam, dengan menerapkan LOW(0V) itu membuat motor berputar berlawanan arah jarum jam(mungkin berbeda satu sama lain sesuai dengan kabel motor Anda dengan driver).

Motor Langkah NEMA17

Motor stepper adalah motor DC yang dapat berputar secara bertahap, digunakan di banyak aplikasi seperti printer 3D untuk menyelaraskan kepala cetak dan mesin CNC untuk mengontrol pergerakan alat pemotong dan ini karena sangat akurat dan presisi.

Tidak seperti motor DC, motor stepper dikendalikan dengan menerapkan pulsa listrik DC ke kumparan internalnya. Setiap pulsa membuat poros maju satu langkah atau sepersekian langkah yang disebut “Microstepping”. Jadi, Anda dapat mengontrol dengan tepat berapa banyak langkah atau bahkan langkah fraksi yang Anda inginkan untuk menggerakkan poros motor. Keuntungan besar lainnya menggunakan motor stepper adalah dapat bergerak dengan sangat tepat dan akurat pada kecepatan yang sangat lambat bahkan tanpa terhenti.

Jenis motor yang kami gunakan dalam proyek ini adalah motor stepper Bipolar NEMA 17 . Motor stepper bipolar memiliki dua kumparan internal dan biasanya memiliki empat kabel, dua kabel per kumparan. berbeda dengan motor stepper Bipolar yang memiliki lima kabel. "Sudut Langkah" motor adalah 1,8° yang menunjukkan seberapa jauh poros maju di setiap langkah penuh, motor bekerja pada 9V tetapi jika Anda ingin mendapatkan daya maksimum, gunakan sumber daya 12V.

Jadi, dengan menghubungkan motor stepper dengan driver motor stepper A4988, kita dapat mengontrol berapa banyak langkah yang kita butuhkan untuk menggerakkan motor dan ke arah mana. Selain itu, kita dapat mengatur mode “microstep” apakah itu full step, half step, quarter step, ….. Mari kita lihat diagram pengkabelan.

Diagram Pengkabelan

Seperti yang kami nyatakan sebelumnya, kami perlu melakukan pemeriksaan kecil untuk memastikan bahwa semua yang kami rakit sebelumnya tepat di tempatnya dan bergerak dengan benar. Sekarang, kita akan menghubungkan semua perangkat keras, motor stepper NEMA 17 dengan driver motor stepper A4988 ke otak, papan Arduino. Dan menggunakan baterai Lithium-Ion 12V 3A untuk memberi makan motor dengan daya yang dibutuhkan.

Kode Arduino

Instalasi Perpustakaan AccelStepper

Instalasi cukup sederhana, kita perlu membuka Arduino IDE. Dari menu "Sketsa". Pilih Sertakan Perpustakaan -> Kelola Perpustakaan…

Sebuah jendela baru akan muncul, cari "AccelStepper" dan instal perpustakaan yang dibuat oleh "Mike McCauley". Mudah kan!

Setelah menginstal perpustakaan AccelStepper, Anda akan melihatnya di menu contoh.

Saya ingin memastikan bahwa perpustakaan AccelStepper diinstal dengan benar dan koneksi motor stepper saya dengan driver motor A4988 benar dan manajemen daya saya baik-baik saja. Jadi, mari kita tulis beberapa baris kode untuk menjalankan motor stepper kita maju dan mundur.

// Bounce stepper test program
// Make a single stepper bounce from one limit to another
// Copyright (C) 2020 makesomestuff.org

#include 
#define stepPin 2
#define dirPin 3 // Define a stepper and the pins it will use

AccelStepper stepper(AccelStepper::DRIVER, stepPin, dirPin); //create an object. the pin "2" is the step pin, "3" is the direction pin.

void setup()
{
 // Change these to suit your stepper if you want
 stepper.setMaxSpeed(100);
 stepper.setAcceleration(20);
 stepper.moveTo(500);
}

void loop()
{
 // If at the end of travel go to the other end
 if (stepper.distanceToGo() ==0)
 stepper.moveTo(-stepper.currentPosition());
 stepper.run();
} 

The code logic is pretty straightforward, we initialized an object from the AccelStepper library, we defined two constants (stepPin, dirPin) that two digital pins is used by the A4988 stepper motor driver to control the movement of the motor itself.

#include 

#define stepPin 2
#define dirPin 3 // Define a stepper and the pins it will use

AccelStepper stepper(AccelStepper::DRIVER, stepPin, dirPin); //create an object. the pin "2" is the step pin, "3" is the direction pin. 

Inside the void setup function, we set the Max. speed of the stepper motor to 100 steps/sec. Also, we set the acceleration/deceleration rate to 20 steps/sec. lastly, we used the moveTo() function to tell the motor to move 500 steps.

void setup()
{
 // Change these to suit your stepper if you want
 stepper.setMaxSpeed(100);
 stepper.setAcceleration(20);
 stepper.moveTo(500);
} 

Inside the void loop function, we are checking if the motor reached it’s position or not. If it reached the position, it will bounce back. and if it didn’t reach it’s position yet, it will keep running.

void loop()
{
 // If at the end of travel go to the other end
 if (stepper.distanceToGo() ==0)
 stepper.moveTo(-stepper.currentPosition());
 stepper.run();
} 

Camera Slider Full Wireless Control

We have done great things so far. Let’s continue! The next step after testing everything, is to work on the mobile app that we will use to control the camera slider movement and send the orders to it. Also, we need to work on the Arduino code that will receive the data from the mobile app and according to these data it will take some actions like moving the motor, changing speed, acceleration, and so on…

Building The Mobile App

To build the mobile app, I used the MIT App inventor tool that allows you to create mobile apps that run on any Android smartphone. The tool is pretty simple since you only drag and drop some pre-made code blocks to build the logic of your program, also you use some premade blocks to build the app user interface. You can access the source of the mobile app from the link down below. Feel free to edit and share, it’s open-source. Mobile App Source

The image down below, a brief explanation for each button function and how it works.

That mobile app will communicate with the Cairo camera slider wirelessly over the Bluetooth communication. So, the next step is to connect a Bluetooth module to the last circuit we built before and upload some lines of code to the Arduino board to be able to establish the communication between the mobile app and the Cairo camera slider.

Wiring Diagram

It’s the time to connect all things together, previously we connected the stepper motor, stepper motor driver, Arduino UNO, and the battery together and tested the circuit and it worked fine. Now, and after building the mobile app, we need to connect the HC-05 Bluetooth module to our circuit.

To make it wireless we will use the HC-05 Bluetooth module which has wide use, it can set as slave or master as well (unlike the HC-06 module which can work only as a slave) which means that you can make a Bluetooth connection between two different Arduino boards. the HC-05 Bluetooth module is an SPP (Serial Port Protocol) module, which means that it communicates with the Arduino board via the Serial communication. You only need to connect the Tx and the Rx pins between the HC-05 module and the Arduino UNO board.

• Tx(Arduino) --> Rx(HC-05)
• Rx(Arduino) --> Tx(HC-05)
• 5V(Arduino) --> VCC(HC-05)
• GNND(Arduino) --> GND(HC-05)

Schematic and PCB Fabrication

Man! I don’t like breadboarding a big circuit like this. So, I designed a super pretty Arduino UNO shield PCB board that keeps all my components in place without worrying about the jumper wires or even the connections. All you need to do is to place your component on the Arduino shield PCB, insert the HC-05 Bluetooth module, A4988 stepper motor driver, and the battery in their places. and install the shield on top of the Arduino board. that’s it!

I fabricated my PCB at PCBWay the quality was very good, in a few days the package arrived in Egypt safely. and I paid just 5$ for the fabrication which is amazing. The coolest thing that I was able to check the order fabrication and processing status online on my account panel and track everything happening to my baby board like I was there inside the factory.

you can download the PCB design source files or even ordering the Cairo Camera Slider Arduino Shield PCB from the PCBWay website. PCB Source Files &Ordering

Arduino Code And Bluetooth Communication

/*
 TODO::Update the arduino program to Make the user able to choose the motor driver micro stepping mode. find and equation that helps to automatically adjust the the "steps" variable value.
 TODO::update the mobile app to ask the user on the beginning only about the [homing position(done), microstepping mode].
 TODO::Update the arduino program to make the code only iterates around the "homing position" &"microstepping mode" only once on the void setup() function.

 DATA::left arrow button sends --> 1.
 DATA::right arrow button sends --> 2.
 DATA::stop button sends --> 3.

 DATA::rail length (1cm - 1000cm) --> (201 - 1200).

 DATA::motor acceleration spinner Very High --> 14.
 DATA::motor acceleration spinner High --> 11
 DATA::motor acceleration spinner Medium --> 12
 DATA::motor acceleration spinner Low --> 13
 DATA::motor acceleration spinner Very Low --> 15

 DATA::motor speed slider (1 step/sec. - 4000 step/sec.) --> (5001 - 9000).

 DATA::delay start checkbox is true --> 7.
 DATA::delay start checkbox is false --> 8.

 DATA::left end homing --> 16.
 DATA::right end homing --> 17.

 DATA::Smooth movement Type --> 18.
 DATA::Very Smooth movement Type --> 19.

 1301 --> 2300
*/

#include 
#include 

#define stepPin 2
#define dirPin 3

bool homingPositionFlag =false;
int startupSetupFlag =0;
bool delayedStart =false;

int incomingData =0;
int movementDistance =50;
long steps =0; //50cm rail by default @1/8 microstepping.
int microStepResolution =0; //4 or 16
long railLength =0;
int sliderSpeed =10;

AccelStepper stepper(AccelStepper::DRIVER, stepPin, dirPin); //create an object. the pin "2" is the step pin, "3" is the direction pin.

void setup() {
 pinMode(stepPin, OUTPUT);
 pinMode(dirPin, OUTPUT);
 Serial.begin(9600);

 stepper.setMaxSpeed(10.00); //The fastest motor speed that can be reliably supported is about 4000 steps per second at a clock frequency of 16 MHz on Arduino such as Uno
 stepper.setAcceleration(500.00); //1600 (40%) (Medium Acceleration rate)

 while (startupSetupFlag <3) {
 if (Serial.available()> 1) {
 unsigned int dataOne =Serial.read();
 unsigned int dataOne1 =Serial.read();
 unsigned int incomingData =(dataOne1 * 256) + dataOne;

 //**************************************************************Motor Homing Part**************************************************
 if (incomingData ==16) { //left end homing position.
 stepper.setCurrentPosition(steps);
 homingPositionFlag =false;
 startupSetupFlag++;
 } else if (incomingData ==17) { //right end homing position.
 stepper.setCurrentPosition(-(steps));
 homingPositionFlag =true;
 startupSetupFlag++;
 }
 //**************************************************************microstep resolution Part**************************************************
 if (incomingData ==18) {
 microStepResolution =4; //50cm rail length @1/4 microstep resolution.
 startupSetupFlag++;
 } else if (incomingData ==19) {
 microStepResolution =16; //50cm rail length @1/16 microstep resolution.
 startupSetupFlag++;
 }

 if (incomingData>=1301 &&incomingData <=2300) {
 railLength =incomingData - 1300; //from raw data to cm.
 if (microStepResolution ==4) {
 steps =((6100L * railLength) / 50L);
 startupSetupFlag++;
 }
 else if (microStepResolution ==16) {
 steps =((25000L * railLength) / 50L);
 startupSetupFlag++;
 }
 }
 }
 //Serial.println(startupSetupFlag);
 }
 /*
 * *********** *********** **********For Debugging Purposes* *********** *********** **********
 Serial.print("rail length:");
 Serial.print(railLength);
 Serial.print(" number of steps:");
 Serial.print(steps);
 Serial.print(" Homing position:");
 Serial.print(stepper.currentPosition());
 Serial.print(" microstep resolution:");
 Serial.println(microStepResolution);*/
}

void loop() {

 if (Serial.available()> 1) {

 unsigned int dataOne =Serial.read();
 unsigned int dataOne1 =Serial.read();
 unsigned int incomingData =(dataOne1 * 256) + dataOne;
 //Serial.print("raw data:");
 //Serial.println(incomingData);

 //**************************************************************Motor Control Part**************************************************
 if (incomingData ==1 &&stepper.isRunning() ==false &&stepper.currentPosition() !=6050 &&homingPositionFlag ==true) {
 if (delayedStart ==true) { //use millis to delay 15 seconds.
 delay(15000); //wait 15 seconds.
 }
 stepper.setCurrentPosition(0);
 stepper.moveTo(steps); //from end to end (@ 1/4 step).
 homingPositionFlag =false;

 /*Serial.print("rail length:");
 Serial.print(railLength);
 Serial.print(" number of steps:");
 Serial.print(steps);
 Serial.print(" Homing position:");
 Serial.print(stepper.currentPosition());
 Serial.print(" microstep resolution:");
 Serial.println(microStepResolution);*/
 }

 else if (incomingData ==2 &&stepper.isRunning() ==false &&stepper.currentPosition() !=-6050 &&homingPositionFlag ==false) {
 if (delayedStart ==true) { //use millis to delay 15 seconds.
 delay(15000); //wait 15 seconds.
 }
 stepper.setCurrentPosition(0);
 stepper.moveTo(-(steps)); //from end to end (@ 1/4 step).
 homingPositionFlag =true;

 /*Serial.print("rail length:");
 Serial.print(railLength);
 Serial.print(" number of steps:");
 Serial.print(steps);
 Serial.print(" Homing position:");
 Serial.print(stepper.currentPosition());
 Serial.print(" microstep resolution:");
 Serial.println(microStepResolution);*/
 }

 else if (incomingData ==3 &&stepper.isRunning() ==true) {
 homing();
 }

 //**************************************************************Set Max. Speed Part**************************************************
 else if (incomingData>=5001 &&incomingData <=9000) {
 sliderSpeed =incomingData - 5000;
 stepper.setMaxSpeed(sliderSpeed);
 }

 //**************************************************************Set Delayed Start Part**************************************************
 else if (incomingData ==7) { //delayed start (15 seconds) is checked "true"
 delayedStart =true;
 }
 else if (incomingData ==8) { //delayed start (15 seconds) is not checked "false"
 delayedStart =false;
 }

 //**************************************************************Set movement distance Part**************************************************
 else if (incomingData>=201 &&incomingData <=1200) { //convertin from rail length into number of steps. (upto 10 meters)
 movementDistance =incomingData - 200; //from raw data to cm.
 if (microStepResolution ==4) {
 steps =((6100L * movementDistance) / 50L);
 }
 else if (microStepResolution ==16) {
 steps =((25000L * movementDistance) / 50L);
 }
 /*Serial.print("rail length:");
 Serial.print(movementDistance);
 Serial.print(" number of steps:");
 Serial.println(steps);*/
 }

 //**************************************************************Set Acceleration Part**************************************************
 else if (incomingData ==11 &&stepper.isRunning() ==false) { //HIGH
 stepper.setAcceleration(3000);
 }

 else if (incomingData ==12 &&stepper.isRunning() ==false) { //Medium
 stepper.setAcceleration(1000);
 }

 else if (incomingData ==13 &&stepper.isRunning() ==false) { //Low
 stepper.setAcceleration(500);
 }

 else if (incomingData ==14 &&stepper.isRunning() ==false) { //Very High
 stepper.setAcceleration(4000);
 }

 else if (incomingData ==15 &&stepper.isRunning() ==false) { //Very Low
 stepper.setAcceleration(10);
 }
 }
 stepper.run();
}

void homing() {
 if (stepper.currentPosition()> 0) {
 homingPositionFlag =true;
 } else {
 homingPositionFlag =false;
 }
 stepper.moveTo(0);
} 

Code Logic

We’re using the amazing AccelStepper Arduino library that provides an object-oriented interface for 2, 3, 4 pins stepper motors to control it’s movement precisely.

#define stepPin 2
#define dirPin 3

bool homingPositionFlag =false;

int startupSetupFlag =0;
bool delayedStart =false;

int incomingData =0;
int movementDistance =50;

long steps =0; //50cm rail by default @1/8 microstepping.
int microStepResolution =0; //4 or 16

long railLength =0;
int sliderSpeed =10;

AccelStepper stepper(AccelStepper::DRIVER, stepPin, dirPin); //create an object. the pin "2" is the step pin, "3" is the direction pin. 

when you open the mobile app and get connected to the Cairo camera slider it will ask you about the micro-stepping mode that you set the A4988 motor driver to work at. it’s very important to choose the correct micro-stepping mode. The Cairo camera slider only supports the 1/4 and 1/16 micro-step resolution. If you chose a wrong micro-step mode it will affect the distance calculations causing the camera carriage to hit the slider limits. So, be careful!

• 1/4 --> Smooth.
• 1/16 --> Very Smooth.

//**************************************************************microstep resolution Part**************************************************
if (incomingData ==18) {
 microStepResolution =4; //50cm rail length @1/4 microstep resolution.
 startupSetupFlag++;

} else if (incomingData ==19) {
 microStepResolution =16; //50cm rail length @1/16 microstep resolution.
 startupSetupFlag++;
} 

It sets the camera slider homing if it’s left or right side homing. the homing position, once you click on right or left side homing a specific piece of data will get sent from the mobile app to the Arduino board according to the homing position that you have chosen.

void setup() {
 pinMode(stepPin, OUTPUT);
 pinMode(dirPin, OUTPUT);
 Serial.begin(9600);

 stepper.setMaxSpeed(10.00); //The fastest motor speed that can be reliably supported is about 4000 steps per second at a clock frequency of 16 MHz on Arduino such as Uno
 stepper.setAcceleration(500.00); //1600 (40%) (Medium Acceleration rate)

 while (startupSetupFlag <3) {
 if (Serial.available()> 1) {
 unsigned int dataOne =Serial.read();
 unsigned int dataOne1 =Serial.read();
 unsigned int incomingData =(dataOne1 * 256) + dataOne;

 //**************************************************************Motor Homing Part**************************************************
 if (incomingData ==16) { //left end homing position.
 stepper.setCurrentPosition(steps);
 homingPositionFlag =false;
 startupSetupFlag++;
 }
 else if (incomingData ==17) { //right end homing position.
 stepper.setCurrentPosition(-(steps));
 homingPositionFlag =true;
 startupSetupFlag++;
 } 

now it sets how many steps should the stepper motor moves without hitting the camera carriage with the camera slider right or left legs. it reads and saves the rail length according to the value that the user enters in the mobile app. So, depending on the micro-step resolution that the user selected before, and the rail length I can calculate the number of steps that the motor should rotate to reach the limits of the slider rail without hitting the right or left legs.

if (incomingData>=1301 &&incomingData <=2300) {
 railLength =incomingData - 1300; //from raw data to cm.
 if (microStepResolution ==4) {
 steps =((6100L * railLength) / 50L);
 startupSetupFlag++;
 }
 else if (microStepResolution ==16) {
 steps =((25000L * railLength) / 50L);
 startupSetupFlag++;
 }
 }
 }
 //Serial.println(startupSetupFlag);
 } 

inside the loop function, it reads the mobile app incoming data and according to these data it takes different actions, like moving the stepper motor clockwise, moving anti-clockwise, stop and return back to the starting point, and changing the traveling speed, so on…

void loop() {

 if (Serial.available()> 1) {

 unsigned int dataOne =Serial.read();
 unsigned int dataOne1 =Serial.read();
 unsigned int incomingData =(dataOne1 * 256) + dataOne;
 //Serial.print("raw data:");
 //Serial.println(incomingData);

 //**************************************************************Motor Control Part**************************************************
 if (incomingData ==1 &&stepper.isRunning() ==false &&stepper.currentPosition() !=6050 &&homingPositionFlag ==true) {
 if (delayedStart ==true) { //use millis to delay 15 seconds.
 delay(15000); //wait 15 seconds.
 }
 stepper.setCurrentPosition(0);
 stepper.moveTo(steps); //from end to end (@ 1/4 step).
 homingPositionFlag =false;

 /*Serial.print("rail length:");
 Serial.print(railLength);
 Serial.print(" number of steps:");
 Serial.print(steps);
 Serial.print(" Homing position:");
 Serial.print(stepper.currentPosition());
 Serial.print(" microstep resolution:");
 Serial.println(microStepResolution);*/
 }

 else if (incomingData ==2 &&stepper.isRunning() ==false &&stepper.currentPosition() !=-6050 &&homingPositionFlag ==false) {
 if (delayedStart ==true) { //use millis to delay 15 seconds.
 delay(15000); //wait 15 seconds.
 }
 stepper.setCurrentPosition(0);
 stepper.moveTo(-(steps)); //from end to end (@ 1/4 step).
 homingPositionFlag =true;

 /*Serial.print("rail length:");
 Serial.print(railLength);
 Serial.print(" number of steps:");
 Serial.print(steps);
 Serial.print(" Homing position:");
 Serial.print(stepper.currentPosition());
 Serial.print(" microstep resolution:");
 Serial.println(microStepResolution);*/
 }

 else if (incomingData ==3 &&stepper.isRunning() ==true) {
 homing();
 }

 //**************************************************************Set Max. Speed Part**************************************************
 else if (incomingData>=5001 &&incomingData <=9000) {
 sliderSpeed =incomingData - 5000;
 stepper.setMaxSpeed(sliderSpeed);
 }

 //**************************************************************Set Delayed Start Part**************************************************
 else if (incomingData ==7) { //delayed start (15 seconds) is checked "true"
 delayedStart =true;
 }
 else if (incomingData ==8) { //delayed start (15 seconds) is not checked "false"
 delayedStart =false;
 }

 //**************************************************************Set movement distance Part**************************************************
 else if (incomingData>=201 &&incomingData <=1200) { //convertin from rail length into number of steps. (upto 10 meters)
 movementDistance =incomingData - 200; //from raw data to cm.
 if (microStepResolution ==4) {
 steps =((6100L * movementDistance) / 50L);
 }
 else if (microStepResolution ==16) {
 steps =((25000L * movementDistance) / 50L);
 }
 /*Serial.print("rail length:");
 Serial.print(movementDistance);
 Serial.print(" number of steps:");
 Serial.println(steps);*/
 }

 //**************************************************************Set Acceleration Part**************************************************
 else if (incomingData ==11 &&stepper.isRunning() ==false) { //HIGH
 stepper.setAcceleration(3000);
 }

 else if (incomingData ==12 &&stepper.isRunning() ==false) { //Medium
 stepper.setAcceleration(1000);
 }

 else if (incomingData ==13 &&stepper.isRunning() ==false) { //Low
 stepper.setAcceleration(500);
 }

 else if (incomingData ==14 &&stepper.isRunning() ==false) { //Very High
 stepper.setAcceleration(4000);
 }

 else if (incomingData ==15 &&stepper.isRunning() ==false) { //Very Low
 stepper.setAcceleration(10);
 }
 }
 stepper.run();
}

void homing() {
 if (stepper.currentPosition()> 0) {
 homingPositionFlag =true;
 } else {
 homingPositionFlag =false;
 }
 stepper.moveTo(0);
} 

Cairo Camera Slider User Guide &troubleshooting

After connecting the 12V power source to the Arduino UNO board that distributes power to the Cairo camera slider Arduino shield as well, turn on the Bluetooth on your mobile, search for new devices, pair with the HC-05 device, and open the mobile app then press on the “Press here to connect with Cairo camera slider” button. It will show up the menu of the paired Bluetooth devices, select the HC-05 Bluetooth device.

After connecting successfully with the Control board, the mobile app will ask you some questions to set up some parameters. First question will ask you about the micro-step resolution of the stepper motor driver if it’s smooth(1/4 micro-step), or very smooth(1/16 micro-step). select the mode According to the micro-stepping resolution mode that you set the A4988 driver at. If you selected a wrong mode The Cairo camera slider will not work correctly.

Then, it will ask you about the aluminum rail length that you are using in your camera slider. Enter the distance in CM. in my case I’m using a 50cm rail length.

Lastly, it will ask you about the camera carriage homing position, It’s very important to place the camera carriage on one of the two rail ends, the right end or the left end. In my case, the camera carriage is on the left end. So, I selected the left end homing.

If you started the Cairo camera slider and the camera carriage is on the middle of the rail or not on one of the two rail ends it will cause the carriage to hit the limits when it moves.

After you finish the set-up process, It will show you the parameters that you have set. And once you click OK, you will be ready to play around with your lovely Cairo camera slider.

Cairo Camera Slider In-Action

Kode

• Cairo Camera Slider Final Code

Cairo Camera Slider Final CodeArduino

/* TODO::Update the arduino program to Make the user able to choose the motor driver micro stepping mode. find and equation that helps to automatically adjust the the "steps" variable value. TODO::update the mobile app to ask the user on the beginning only about the [homing position(done), microstepping mode]. TODO::Update the arduino program to make the code only iterates around the "homing position" &"microstepping mode" only once on the void setup() function. DATA::left arrow button sends --> 1. DATA::right arrow button sends --> 2. DATA::stop button sends --> 3. DATA::rail length (1cm - 1000cm) --> (201 - 1200). DATA::motor acceleration spinner Very High --> 14. DATA::motor acceleration spinner High --> 11 DATA::motor acceleration spinner Medium --> 12 DATA::motor acceleration spinner Low --> 13 DATA::motor acceleration spinner Very Low --> 15 DATA::motor speed slider (1 step/sec. - 4000 step/sec.) --> (5001 - 9000). DATA::delay start checkbox is true --> 7. DATA::delay start checkbox is false --> 8. DATA::left end homing --> 16. DATA::right end homing --> 17. DATA::Smooth movement Type --> 18. DATA::Very Smooth movement Type --> 19. 1301 --> 2300*/#include #include #define stepPin 2#define dirPin 3bool homingPositionFlag =false;int startupSetupFlag =0;bool delayedStart =false;int incomingData =0;int movementDistance =50;long steps =0; //50cm rail by default @1/8 microstepping.int microStepResolution =0; //4 or 16long railLength =0;int sliderSpeed =10;AccelStepper stepper(AccelStepper::DRIVER, stepPin, dirPin); //create an object. the pin "2" is the step pin, "3" is the direction pin.void setup() { pinMode(stepPin, OUTPUT); pinMode(dirPin, OUTPUT); Serial.begin(9600); stepper.setMaxSpeed(10.00); //The fastest motor speed that can be reliably supported is about 4000 steps per second at a clock frequency of 16 MHz on Arduino such as Uno stepper.setAcceleration(500.00); //1600 (40%) (Medium Acceleration rate) while (startupSetupFlag <3) { if (Serial.available()> 1) { unsigned int dataOne =Serial.read(); unsigned int dataOne1 =Serial.read(); unsigned int incomingData =(dataOne1 * 256) + dataOne; //**************************************************************Motor Homing Part************************************************** if (incomingData ==16) { //left end homing position. stepper.setCurrentPosition(steps); homingPositionFlag =false; startupSetupFlag++; } else if (incomingData ==17) { //right end homing position. stepper.setCurrentPosition(-(steps)); homingPositionFlag =true; startupSetupFlag++; } //**************************************************************microstep resolution Part************************************************** if (incomingData ==18) { microStepResolution =4; //50cm rail length @1/4 microstep resolution. startupSetupFlag++; } else if (incomingData ==19) { microStepResolution =16; //50cm rail length @1/16 microstep resolution. startupSetupFlag++; } if (incomingData>=1301 &&incomingData <=2300) { railLength =incomingData - 1300; //from raw data to cm. if (microStepResolution ==4) { steps =((6100L * railLength) / 50L); startupSetupFlag++; } else if (microStepResolution ==16) { steps =((25000L * railLength) / 50L); startupSetupFlag++; } } } //Serial.println(startupSetupFlag); } /* * *********** *********** **********For Debugging Purposes* *********** *********** ********** Serial.print("rail length:"); Serial.print(railLength); Serial.print(" number of steps:"); Serial.print(steps); Serial.print(" Homing position:"); Serial.print(stepper.currentPosition()); Serial.print(" microstep resolution:"); Serial.println(microStepResolution);*/}void loop() { if (Serial.available()> 1) { unsigned int dataOne =Serial.read(); unsigned int dataOne1 =Serial.read(); unsigned int incomingData =(dataOne1 * 256) + dataOne; //Serial.print("raw data:"); //Serial.println(incomingData); //**************************************************************Motor Control Part************************************************** if (incomingData ==1 &&stepper.isRunning() ==false &&stepper.currentPosition() !=6050 &&homingPositionFlag ==true) { if (delayedStart ==true) { //use millis to delay 15 seconds. delay(15000); //wait 15 seconds. } stepper.setCurrentPosition(0); stepper.moveTo(steps); //from end to end (@ 1/4 step). homingPositionFlag =false; /*Serial.print("rail length:"); Serial.print(railLength); Serial.print(" number of steps:"); Serial.print(steps); Serial.print(" Homing position:"); Serial.print(stepper.currentPosition()); Serial.print(" microstep resolution:"); Serial.println(microStepResolution);*/ } else if (incomingData ==2 &&stepper.isRunning() ==false &&stepper.currentPosition() !=-6050 &&homingPositionFlag ==false) { if (delayedStart ==true) { //use millis to delay 15 seconds. delay(15000); //wait 15 seconds. } stepper.setCurrentPosition(0); stepper.moveTo(-(steps)); //from end to end (@ 1/4 step). homingPositionFlag =true; /*Serial.print("rail length:"); Serial.print(railLength); Serial.print(" number of steps:"); Serial.print(steps); Serial.print(" Homing position:"); Serial.print(stepper.currentPosition()); Serial.print(" microstep resolution:"); Serial.println(microStepResolution);*/ } else if (incomingData ==3 &&stepper.isRunning() ==true) { homing(); } //**************************************************************Set Max. Speed Part************************************************** else if (incomingData>=5001 &&incomingData <=9000) { sliderSpeed =incomingData - 5000; stepper.setMaxSpeed(sliderSpeed); } //**************************************************************Set Delayed Start Part************************************************** else if (incomingData ==7) { //delayed start (15 seconds) is checked "true" delayedStart =true; } else if (incomingData ==8) { //delayed start (15 seconds) is not checked "false" delayedStart =false; } //**************************************************************Set movement distance Part************************************************** else if (incomingData>=201 &&incomingData <=1200) { //convertin from rail length into number of steps. (upto 10 meters) movementDistance =incomingData - 200; //from raw data to cm. if (microStepResolution ==4) { steps =((6100L * movementDistance) / 50L); } else if (microStepResolution ==16) { steps =((25000L * movementDistance) / 50L); } /*Serial.print("rail length:"); Serial.print(movementDistance); Serial.print(" number of steps:"); Serial.println(steps);*/ } //**************************************************************Set Acceleration Part************************************************** else if (incomingData ==11 &&stepper.isRunning() ==false) { //HIGH stepper.setAcceleration(3000); } else if (incomingData ==12 &&stepper.isRunning() ==false) { //Medium stepper.setAcceleration(1000); } else if (incomingData ==13 &&stepper.isRunning() ==false) { //Low stepper.setAcceleration(500); } else if (incomingData ==14 &&stepper.isRunning() ==false) { //Very High stepper.setAcceleration(4000); } else if (incomingData ==15 &&stepper.isRunning() ==false) { //Very Low stepper.setAcceleration(10); } } stepper.run();}void homing() { if (stepper.currentPosition()> 0) { homingPositionFlag =true; } else { homingPositionFlag =false; } stepper.moveTo(0);}

Suku cadang dan penutup khusus

Cairo Camera Slider STLs

File CAD di thingiverse.com

Skema

UVC Box Sterilizer UV DIY Peredupan Lampu dengan PWM menggunakan Tombol Tekan