Deslizador de câmera motorizada Arduino controlado por Bluetooth
Componentes e suprimentos
 |
| × | 1 | |||
 |
| × | 1 | |||
| × | 1 | ||||
| × | 4 | ||||
| × | 4 | ||||
| × | 4 | ||||
| × | 4 | ||||
| × | 2 | ||||
| × | 2 | ||||
| × | 2 | ||||
| × | 2 | ||||
| × | 2 | ||||
| × | 4 | ||||
| × | 4 | ||||
| × | 8 | ||||
| × | 2 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 1 |
Ferramentas e máquinas necessárias
 |
|
Aplicativos e serviços online
 |
| |||
| ||||
 |
|
Sobre este projeto
Visão geral do projeto
Para alguém que adora gravar alguns vídeos amadores aleatórios, é caro comprar um controle deslizante de câmera motorizado. Então, eu construí meu próprio. Neste tutorial, passaremos por cada etapa para construir seu próprio controle deslizante de câmera motorizada controlado por Bluetooth.
Hoje vamos construir um controle deslizante de câmera motorizado que podemos controlá-lo sem fio por Bluetooth a partir de um aplicativo móvel Android feito sob medida. Usei a ferramenta “MIT App inventor” para fazer o aplicativo que nos dá a capacidade de controlar muitas coisas como a velocidade de movimento do slider, distância de viagem, taxa de aceleração / desaceleração e muito mais. O aplicativo móvel é muito robusto, dentro do aplicativo você pode definir o comprimento do controle deslizante da câmera que está usando. o que significa que você está livre para construir seu controle deslizante de câmera real com qualquer comprimento de até 10 metros sem se preocupar com o aplicativo.
Usamos um motor de passo NEMA17 como um atuador para que possamos controlar quantas etapas precisamos que o controle deslizante da câmera se mova. Para controlar um motor de passo usando a placa Arduino, precisamos de um tradutor que receba comandos da placa Arduino e os traduza para a linguagem que o motor de passo entende. Aí vem a função de driver de motor de passo A4988 Pololu, que nos dá cinco resoluções microstep diferentes (até 1/16 de passo) para alcançar a máxima precisão e suavidade de movimento.
Este projeto foi desenvolvido com a facilidade de uso em um fablab / maker / hackerspace em mente.
CAD e modelagem 3D
Usamos Fusion360 para projetar o controle deslizante da câmera, optamos por usar um componente mecânico muito conhecido e fácil de encontrar que você pode comprar facilmente em quase qualquer loja online ou offline, não importa onde você more.
Estamos usando hardware Openbuilds para construir a estrutura mecânica, o trilho linear V-slot 2040 como um guia para a câmera se mover. Duas polias, uma no eixo do motor de passo. E o outro, em um eixo de trilho linear de 8 mm no lado oposto do controle deslizante com uma correia dentada aberta entre eles para converter o movimento rotativo do motor de passo em movimento linear.
O eixo de trilho linear de 8 mm é instalado entre dois rolamentos autocompensadores de flange em almofada que são instalados nas placas superior e inferior por meio de quatro parafusos M5.
Estamos usando quatro rodas sólidas Delrin V-Slot, que descem na ranhura em V do trilho do V-Slot para tornar o movimento da câmera extremamente suave. O meio da placa da câmera tem um orifício de 1/4 de polegada de diâmetro para um parafuso de tripé padrão para que você possa montar sua câmera facilmente.
Por último, um gabinete para os componentes eletrônicos. Todas as peças do controle deslizante da câmera são fixadas entre si por parafusos e porcas m3 * 16mm.
Fabricação digital (impressão 3D)
Todo o corpo do controle deslizante da câmera é impresso em 3D com 0,2 camada de altura, 20% de preenchimento, exceto o controle deslizante da câmera na perna esquerda e direita, são impressos com 0,2 camada de altura e 50% de preenchimento.
você pode baixar os arquivos STL de Thingiverse.
Conjunto de kit de roda em V
O processo de montagem é muito fácil cara, vamos! Na primeira etapa, precisamos montar as quatro rodas em V sólidas. O kit de roda em V sólido vem com uma roda de borracha, dois rolamentos, dois calços de percisão e uma contraporca.
Insira o rolamento de um lado da roda de borracha e gire a roda, em seguida, insira um calço de precisão dentro da roda de borracha e, por último, insira o segundo rolamento do lado da segunda face.
Conjunto mecânico do controle deslizante da câmera
Primeiro, precisamos montar a placa da câmera e as quatro rodas em V sólidas. usando o espaçador de alumínio de 9 mm, o calço de precisão e a contraporca.
Vamos repetir a etapa anterior com as outras três rodas. nas duas rodas certas, vamos usar o espaçador de 9 mm. E nas outras duas rodas esquerdas vamos usar o espaçador excêntrico com um espaçador de 3 mm em vez do espaçador de 9 mm.
Agora, insira a placa de suporte da câmera no perfil de ranhura em V. Se você descobrir que a placa está solta e balançando, pode apertar a porca excêntrica até obter uma placa sólida.
Vamos inserir duas porcas em T de encaixe em cada extremidade do perfil da ranhura em V. precisamos conectar o perfil V-slot com as pernas direita e esquerda do controle deslizante da câmera.
Pegue as duas pernas do controle deslizante da câmera e empurre-as no perfil do V-slot.
traga quatro parafusos M5X10mm e fixe as duas pernas com o perfil V-slot.
Precisamos instalar o motor de passo NEMA 17 em sua placa. então, usando quatro parafusos M3X16mm vamos consertar o motor no lugar.
Na perna esquerda, insira duas porcas dentro do local das porcas superiores da perna esquerda.
Traga a placa do motor NEMA 17 e fixe-a na parte superior da perna esquerda. e com dois parafusos M3X16mm vamos fixar a placa na perna esquerda.
Para ser capaz de converter o movimento rotacional do motor de passo em movimento linear, precisamos instalar uma polia GT2 Bore 5mm no eixo do motor. e usando a chave Allen, aperte o parafuso de fixação da polia para mantê-lo no lugar.
Vamos para a perna direita do controle deslizante da câmera, insira quatro porcas M3 no lugar das porcas da perna.
Em seguida, coloque os rolamentos da perna direita duas placas na parte superior da perna direita do controle deslizante da câmera.
Usando quatro parafusos M3X16mm, fixe as duas placas na perna direita do controle deslizante da câmera para mantê-las no lugar.
Traga um dos rolamentos do bloco de flange de 8 mm e instale-o na placa da perna superior direita. usando dois parafusos M5X20mm e duas porcas M5.
Precisamos repetir a etapa anterior com o segundo bloco de rolamento de flange de 8 mm para fixá-lo na placa inferior da perna direita do controle deslizante da câmera.
Insira o eixo de trilho linear de 8 mm no bloco de rolamento de flange de 8 mm do lado inferior e empurre-o para cima. Em seguida, insira a polia com furo de 8 mm no eixo do trilho linear e fixe-a apertando o parafuso de fixação da polia.
Ponto de verificação, agora montamos todo o mecanismo deslizante da câmera, exceto uma coisa. a correia dentada. Vamos fazer isso.
gire a correia dentada de 6 mm na polia com furo de 5 mm do motor NEMA17. Além disso, na perna direita, a polia com furo de 8 mm. Por último, aperte o cinto com a placa da câmera.
É hora de montar a placa de controle. insira o escudo do Arduino do Cairo Camera Slider na parte superior da placa do Arduino.
Insira a placa Arduino e a proteção do Slider da câmera Cairo dentro do gabinete da placa de controle.
insira duas porcas M3 dentro do lugar das porcas da perna esquerda.
instale o gabinete da placa de controle na perna esquerda do Slider da câmera Cairo com parafusos M3X16mm.
feche a face superior da caixa do invólucro com dois parafusos M3 e porcas, e é isso!
Controle de teste de motor de passo
Depois de montar todas as peças, precisamos testá-lo para ter certeza de que tudo está instalado em seu lugar corretamente. Agora, precisamos conectar o motor de passo com a placa Arduino por meio do driver do motor de passo A4988 e escrever algum código para executar essa coisa.
Driver de motor de passo A4988
Para controlar qualquer motor de passo usando a placa Arduino ou qualquer microcontrolador, você precisará de um driver de motor de passo que funciona como um tradutor, recebe comandos da placa Arduino e os traduz para a linguagem que o motor entende.
existem muitos drivers de motor de passo, mas usaremos o driver A4988 . Este driver nos permite controlar um motor bipolar com corrente de saída de até 2A por bobina, é muito simples fazer a interface com a placa Arduino, você só precisa de dois pinos digitais para controlar totalmente o passo e a direção do motor, permite controlar a saída de corrente máxima facilmente com um potenciômetro integrado e oferece uma resolução de micro-passos até 1/16 micro-passos.
VMOT, GND: São os pinos de conexão de energia para o próprio motor de passo, pode ser 8V-35V. Em nosso caso, estamos conectando uma fonte de alimentação 12V 3A nesses pinos com um capacitor de desacoplamento de 100 uF para proteger a placa A4998 de quaisquer picos de energia.
2B, 2A: os pinos de saída para a primeira bobina do motor de passo que pode fornecer até 2A.
1A, 1B: os pinos de saída para a segunda bobina do motor de passo que pode fornecer até 2A também.
VDD, GND: Usado para conduzir o circuito lógico interno, pode ser de 3 V a 5,5 V. É totalmente isolado do pino VMOT.
EN: Significa "Ativar", é um pino de entrada LOW (0V) ativo, o que significa que quando este pino puxado para BAIXO (0V), o chip A4988 é ativado. E quando puxado para ALTO (5V), o chip A4988 é desabilitado. Por padrão, este pino é puxado para BAIXO (0 V). Portanto, o chip está sempre habilitado, a menos que você o puxe para ALTO (5V).
MS1, MS2, MS3: Por meio desses pinos, você pode selecionar a resolução de micropasso do motor (tamanho do passo). O A4988 oferece cinco resoluções diferentes de microstep (passo completo, meio passo, quarto passo, oitavo passo, décimo sexto passo) . By applying appropriate logic levels to these three pins we can set the motors to one of the five step resolutions.
By default, the MS1, MS2, MS3 pins have internal pull-down resistors. So leaving these three microstep selection pins disconnected results in full-step mode.
RST, SLP: The “Reset” pin is an active LOW(0V) input pin, which means when it pulled LOW(0V), all the step inputs are ignored it also resets the translator itself until you pull it HIGH(5V). The “Sleep” pin also an active LOW pin, pulling it LOW, puts the driver in the sleep mode minimizing the power consumption. By default, the “Sleep” pin is pulled HIGH(5V).
STP, DIR: The “Step” pin is responsible for controlling the number of steps that the motor is rotating, each pulse to the “Step” pin corresponds for one microstep in the direction selected by the “Direction” pin, the faster the pulses, the faster the motor will rotate. By applying logic value HIGH(5V) on the “Direction” pin it makes the motor rotate clockwise, by applying LOW(0V) it makes the motor rotate counterclockwise(it may differs from one to another according to your motor wiring with the driver).
NEMA17 Stepper Motor
Stepper motors are DC motors that can rotate in precise increments, they are used in many applications like 3D printers to align the printhead and CNC machines to control the movement of the cutting tool and this is because they are very accurate and precise.
Unlike DC motors, stepper motors are controlled by applying DC electrical pulses to their internal coils. Each pulse makes the shaft advance by one step or a fraction of step which is called “Microstepping”. So, you can control precisely how many steps or even fraction steps you want the motor shaft to move. Another great advantage of using stepper motors is that it can move very precisely and accurately at very slow speeds without even stalling.
The type of motor we are using in this project is the NEMA 17 Bipolar stepper motor . The bipolar stepper motor has two internal coils and it usually has four wires, two wires per coil. unlike the Bipolar stepper motor which has five wires. The “Step Angle” of the motor is 1.8° which indicates how much the shaft advances in each full step, the motor works on 9V but if you want to get the maximum power of it use a 12V power source.
So, by connecting the stepper motor with the A4988 stepper motor driver, we can control how many steps we need the motor to move and in what direction. Also, we can set the “microstep” mode is it full step, half step, quarter step, ….. Let’s take a look at the wiring diagram.
Wiring Diagram
As we stated before, we need to make a small check to make sure that everything we assembled before is right in its place and moving properly. Now, we will wire all the hardware together, the NEMA 17 stepper motor with the A4988 stepper motor driver to the brain, the Arduino board. And using a 12V 3A Lithium-Ion battery to feed the motors with the power it needs.
Arduino Code
AccelStepper Library Installation
The Installation is pretty simple, we need to open Arduino IDE. From the “Sketch” menu. Select Include Library –> Manage Libraries…
A new window should appear, search for “AccelStepper” and install the library made by “Mike McCauley”. Easy right!
After installing the AccelStepper library, you should see it in the examples menu.
I wanna make sure that the AccelStepper library is installed correctly and my stepper motor connection with the A4988 motor driver is right and my power management is fine. So, let’s write some lines of code to run our stepper motor forward and backward.
// 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
Código
- 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);}
Peças personalizadas e gabinetes
Cairo Camera Slider STLs
Arquivo CAD em thingiverse.comEsquemas
Processo de manufatura