Slider de Câmera Motorizado com Pan & Tilt – Projeto Controlado por Arduino
Neste tutorial, aprenderemos a fazer um slider de câmera motorizado com cabeça pan e tilt. Este projeto baseado em Arduino é 100% DIY, construído com materiais baratos como MDF e compensado e controlado usando Arduino, três motores de passo, alguns botões e um joystick anexados em um PCB personalizado. Apesar disso, o resultado final é bastante impressionante, com movimentos de câmera super suaves permitindo obter shots cinematográficos profissionais.
Você pode assistir ao vídeo a seguir ou ler o tutorial escrito abaixo.
Visão Geral
Usando o controlador, podemos mover a câmera manualmente ou definir pontos de início e fim e a câmera se moverá automaticamente de uma posição para a outra. Também, usando o braço de suporte, podemos montar o slider até em um tripé menor, em qualquer ângulo desejado e ainda obter movimentos estáveis.

Para começar, projetei o slider usando um software de modelagem 3D.

Você pode encontrar e baixar este modelo 3D e obter todas as dimensões do modelo 3D abaixo, bem como explorá-lo no seu navegador no Thangs.

Download do modelo 3D de montagem do Thangs.
Link da polia GT2 impressa em 3D: Thingiverse
Construindo o Slider de Câmera
Comecei fazendo os trilhos do slider usando tubo de cobre de 22mm. Decidi fazer o slider com 1 metro de comprimento, então cortei duas peças de 1 metro. Tubos de cobre oxidam facilmente, então precisamos poli-los com polidor de metal. No meu caso, não tinha um, então usei pasta de dente para esse propósito.

Não foi a solução perfeita, mas ainda pude notar uma diferença e os tubos ficaram um pouco mais limpos.
Em seguida, passei a fazer a base de madeira onde os dois tubos serão fixados e que também servirá para montar o slider no tripé. Usando uma serra circular, cortei duas peças de compensado de 21mm e as colei juntas para obter uma peça única mais grossa. Então, usando madeira maciça, fiz uma réplica da placa de montagem do meu tripé e a fixei na peça de compensado usando cola de madeira e um parafuso. Agora a base do slider pode ser facilmente montada no tripé.

Vou montar os trilhos do slider na base usando hastes roscadas de 8mm, então fiz dois furos na base e inseri as hastes de 138mm que cortei previamente no tamanho. Em seguida, tive que furar furos de 8mm nos tubos, o que pode ser um pouco complicado.

Para isso, fiz um gabarito simples onde elevei o lápis a uma altura de 11mm (metade do diâmetro do tubo). Então prendi o tubo em uma superfície plana e, usando o gabarito, marquei o tubo dos dois lados. Isso permite obter furos precisamente alinhados dos dois lados. Primeiro marquei os pontos de furação com a ponta de um parafuso afiado e depois furei progressivamente usando brocas de 2, 4, 6 e 8mm.

Depois disso, inseri os trilhos através das hastes roscadas e, usando algumas arruelas e porcas, os fixei na base do slider. De forma semelhante, usando uma peça de compensado e uma haste roscada, fixei as extremidades dos trilhos.

Próximo é a plataforma deslizante. Novamente usei a serra circular para cortar a placa MDF de 8mm no tamanho certo de acordo com o modelo 3D. Também fiz alguns furos de 8mm para as hastes roscadas onde os rolamentos serão fixados. Para montar a plataforma, usei cola de madeira e alguns parafusos. Usando uma parafusadeira, primeiro fiz furos piloto, depois fiz os rebaixos e aparafusei os parafusos de 3mm no lugar.
Uma vez que os painéis foram fixados, continuei com a montagem do sistema de rolamentos. Os rolamentos que estou usando são 608Z com diâmetro externo de 22mm. Duas arruelas e uma porca entre dois rolamentos criam distância suficiente entre eles, permitindo bom contato com os trilhos de 22mm.

Para tornar a plataforma mais segura ao usar o slider em um ângulo, de forma semelhante, inseri mais dois conjuntos de rolamentos no lado inferior da plataforma. No final, a plataforma deslizante funcionou perfeitamente.

Aqui podemos notar que agora, ao mover a plataforma ao longo do slider no meu tripé pequeno (não heavy duty), a cabeça não consegue segurar o peso da plataforma, então tive que fazer um braço de suporte para estabilizar o slider. Usando duas peças de madeira e algumas porcas e parafusos, fiz uma braçadeira simples que pode ser apertada em uma das pernas do tripé.

A braçadeira tem um parafuso no qual o braço de suporte pode ser fixado. Em seguida, tive que fazer um slot no braço de suporte para poder posicionar o slider em diferentes ângulos. Fiz o slot simplesmente furando muitos furos de 6mm próximos uns dos outros e, depois, usando uma lima, fiz linhas retas finas. Este sistema de suporte funcionou perfeitamente.

Continuei esta construção adicionando pernas ao slider, caso você não queira ou precise usar um tripé. Fiz elas de MDF de 8mm. Usando uma serra manual e uma lima, obtive facilmente o formato desejado das pernas. Então, usando um pouco de cola e duas porcas, as fixei nas extremidades do slider.

A próxima etapa é construir o sistema pan e tilt que será fixado no topo da plataforma deslizante. Usando a serra circular, cortei todas as peças necessárias, com as dimensões tiradas do modelo 3D. Usei algumas peças de compensado para fazer o mecanismo de dobradiça da plataforma de nivelamento para a câmera quando o slider está em um ângulo, bem como algumas placas MDF nas quais fiz furos apropriados para o motor e os rolamentos do sistema de pan.

Prossedi com a instalação do motor de passo e da correia dentada para a plataforma deslizante. Em um lado da plataforma, fixei o motor de passo com uma placa MDF e alguns parafusos e porcas. No outro lado do slider, fixei uma polia tensora para agora instalar a correia dentada. Usando dois parafusos e abraçadeiras, fixei facilmente a correia dentada na plataforma deslizante.

Com esta etapa, o mecanismo de deslizamento estava completamente pronto.
Continuei fazendo as partes superiores do sistema pan e tilt. De acordo com o modelo 3D, fiz todos os furos apropriados para o motor de passo e os rolamentos, e colei e aparafusei tudo junto.
Um amigo meu imprimiu em 3D duas polias de 80 dentes para mim. Dessa forma, obtive redução de velocidade 5x em relação à polia de 16 dentes fixada no motor de passo.

Agora precisei fazer uma correia dentada de loop fechado de acordo com minha configuração, então medi quanto comprimento de correia precisava, cortei e simplesmente colei com cola CA e adicionei um pedaço de fita por cima. A cola CA faz um ótimo trabalho com borracha, então a correia de loop fechado funciona sem problemas.
Em seguida, comecei a montagem final do sistema pan e tilt. Primeiro fixei o motor de tilt usando alguns parafusos e adicionei os dois rolamentos no lugar enquanto os fixava nos slots com um pouco de epóxi. Então fixei a plataforma de tilt na plataforma de pan usando alguns parafusos de 8mm e, ao mesmo tempo, fixei a polia de 80 dentes nela junto com a correia dentada.

Aqui notei que a correia estava um pouco frouxa, mas adicionei um pequeno rolamento no lugar onde o parafuso do motor de passo vai para atuar como tensionador da correia. Isso funcionou e agora a correia tinha tensão suficiente para funcionar corretamente.
Em seguida, fixei o motor de pan e adicionei rolamentos no lado superior da plataforma de nivelamento, bem como no lado inferior. Então inseri um parafuso através deles, adicionei um rolamento de impulso, a polia de 80 dentes e a correia dentada, e por cima deles adicionei a cabeça de tilt previamente montada. Finalmente, a fixei usando um parafuso e pronto, com esta etapa a construção do slider está completa.

Diagrama de Circuito
Ok, próxima vem a parte divertida: instalar os componentes eletrônicos. Aqui está o diagrama de circuito deste projeto DIY de slider de câmera.

Os três motores de passo NEMA 17 são controlados via três drivers A4988. Para controlar o movimento do slider, usamos um potenciômetro conectado a uma entrada analógica do Arduino, e para controlar a cabeça pan e tilt usamos um módulo joystick que na verdade consiste em dois potenciômetros, então está conectado a duas entradas analógicas. Há também outro potenciômetro usado para definir a velocidade do movimento automático entre as posições IN e OUT. Estas posições IN e OUT são definidas com a ajuda de um botão. Este botão tem um resistor pull-up e está conectado a um pino digital do Arduino. Há também um botão de reset, um interruptor de energia e um conector de energia, bem como um fim de curso para o slider e dois LEDs para indicar o status IN e OUT. Podemos alimentar este projeto com 9 ou 12V.
Você pode obter os componentes necessários para este projeto nos links abaixo:
- Motor de Passo (NEMA17)
- Driver A4988
- Adaptador 12V 2A
- Joystick
- Conector de Energia
- Placa Arduino
Design do PCB
Em seguida, de acordo com o diagrama de circuito, projetei um PCB personalizado para manter os componentes eletrônicos organizados.

Fiz isso usando o software gratuito de design de circuitos online EasyEDA. O circuito tinha bastantes conexões, então usei tanto a camada superior quanto a inferior e consegui obter um PCB funcional e bonito. Uma vez terminado este passo, gerei o arquivo Gerber necessário para fabricação do PCB. Então pedi o PCB na JLCPCB, que é na verdade o patrocinador deste tutorial.

Aqui podemos simplesmente carregar o arquivo Gerber e, uma vez carregado, podemos revisar nosso PCB no visualizador Gerber. Se tudo estiver certo, podemos prosseguir, selecionar as propriedades que queremos para nosso PCB, e então pedir nosso PCB a um preço razoável. Note que se for seu primeiro pedido na JLCPCB, você pode obter até 10 PCBs por apenas 2 dólares.

Após uma semana, os PCBs chegaram. A qualidade dos PCBs é ótima e devo admitir que é bastante satisfatório ter seu próprio design de PCB fabricado.

Montando a Eletrônica
Ok, então em seguida passei a montar os componentes eletrônicos. Comecei soldando headers de pinos no PCB. Isso permite conectar e desconectar os componentes facilmente quando necessário. Na verdade, usei headers de pinos para tudo, exceto os capacitores e resistores que soldei diretamente no PCB. Portanto, continuei soldando jumpers em todos os componentes eletrônicos.
Dessa forma, posso facilmente montar os componentes no gabinete do controlador e, ao mesmo tempo, conectá-los ao PCB.

Quanto ao gabinete do controlador, decidi fazê-lo de acrílico transparente de 4mm porque queria que a beleza de todos os componentes eletrônicos fosse visível. Usei uma serra circular para cortar os painéis do gabinete no tamanho certo. Então, usando uma furadeira e brocas Forstner, fiz as aberturas no painel frontal para os botões, potenciômetros, interruptor de energia e o joystick. Depois disso, usando epóxi de 5 minutos, montei o gabinete, e quanto à tampa, inseri e colei dois parafusos através dos quais o painel frontal pode ser inserido e fixado usando porcas por cima.

Finalmente, comecei a montar a eletrônica inserindo a placa Arduino e os drivers A4988 no PCB. Então continuei inserindo e fixando os botões e outros componentes no painel frontal.

Uma vez fixados, conectei os componentes aos headers de pinos apropriados no PCB. No painel lateral do gabinete, adicionei o conector de energia, e então inseri o PCB no gabinete. No mesmo painel há também um furo através do qual passei jumpers para conectar os drivers com os motores de passo, bem como o fim de curso que coloquei no final do slider.

Usando termo-retrátil, organizei os jumpers saindo do gabinete do controlador e, finalmente, o que restava era conectar o controlador com os três motores de passo e o fim de curso.

Quanto à alimentação do slider, usei três baterias Li-ion 3.7V conectadas em série produzindo cerca de 11V. E pronto, o slider está feito e funciona perfeitamente.

Código Arduino do DIY Camera Slider
Agora o que resta neste tutorial é dar uma olhada no código Arduino e explicar como o programa funciona. Como o código é um pouco longo, para melhor entendimento, postarei o código-fonte do programa em seções com descrição para cada seção. E no final deste artigo postarei o código-fonte completo.
O programa é baseado na biblioteca AccelStepper de Mike McCauley. Esta é uma biblioteca incrível que permite controle fácil de múltiplos motores de passo ao mesmo tempo. Então, uma vez que incluímos esta biblioteca e a biblioteca MultiStepper.h que faz parte dela, precisamos definir todos os pinos do Arduino que serão usados, definir as instâncias para os steppers, bem como algumas variáveis necessárias para o programa abaixo.
#include <AccelStepper.h>
#include <MultiStepper.h>
#define JoyX A0 // Pino X do Joystick
#define JoyY A1 // Pino Y do Joystick
#define slider A2 // Potenciômetro do slider
#define inOutPot A3 // Potenciômetro de velocidade IN/OUT
#define JoySwitch 10 // Switch do joystick conectado
#define InOutSet 12 // Botão Set
#define limitSwitch 11
#define inLED 8
#define outLED 9
// Define os motores de passo e os pinos que usarão
AccelStepper stepper1(1, 7, 6); // (Tipo:driver, STEP, DIR)
AccelStepper stepper2(1, 5, 4);
AccelStepper stepper3(1, 3, 2);
MultiStepper StepperControl; // Cria instância do MultiStepper
long gotoposition[3]; // Array para armazenar posição IN ou OUT para cada motor
int JoyXPos = 0;
int JoyYPos = 0;
int sliderPos = 0;
int currentSpeed = 100;
int inOutSpeed = 100;
int XInPoint = 0;
int YInPoint = 0;
int ZInPoint = 0;
int XOutPoint = 0;
int YOutPoint = 0;
int ZOutPoint = 0;
int InandOut = 0;
Na seção setup(), definimos os valores iniciais de velocidade para os steppers, definimos alguns modos de pino, bem como adicionamos os três steppers à instância de controle multi stepper chamada "StepperControl". Usando loops while, movemos o slider para a posição inicial (homing): ele se move até pressionar o fim de curso e depois volta 200 passos para liberar o fim de curso.
void setup() {
// Define valores iniciais de velocidade para os steppers
stepper1.setMaxSpeed(3000);
stepper1.setSpeed(200);
stepper2.setMaxSpeed(3000);
stepper2.setSpeed(200);
stepper3.setMaxSpeed(3000);
stepper3.setSpeed(200);
pinMode(JoySwitch, INPUT_PULLUP);
pinMode(InOutSet, INPUT_PULLUP);
pinMode(limitSwitch, INPUT_PULLUP);
pinMode(inLED, OUTPUT);
pinMode(outLED, OUTPUT);
// Cria instâncias para MultiStepper - Adiciona os 3 steppers à instância StepperControl para controle multi
StepperControl.addStepper(stepper1);
StepperControl.addStepper(stepper2);
StepperControl.addStepper(stepper3);
// Move o slider para a posição inicial - homing
while (digitalRead(limitSwitch) != 0) {
stepper1.setSpeed(3000);
stepper1.runSpeed();
stepper1.setCurrentPosition(0); // Quando fim de curso pressionado, define posição como 0 passos
}
delay(20);
// Move 200 passos para trás do fim de curso
while (stepper1.currentPosition() != -200) {
stepper1.setSpeed(-3000);
stepper1.run();
}
}
Na seção loop(), começamos verificando se o slider atingiu as posições limite, ou seja, o fim de curso ou 80cm no outro lado dele.
// Limitando o movimento - Não faz nada se fim de curso pressionado ou distância percorrida na outra direção maior que 80cm
while (digitalRead(limitSwitch) == 0 || stepper1.currentPosition() < -64800) {}
Com o próximo if, aumentamos as velocidades de Pan e Tilt a cada pressionamento do switch do joystick.
// Se joystick pressionado, aumenta velocidades de Pan e Tilt
if (digitalRead(JoySwitch) == 0) {
currentSpeed = currentSpeed + 50;
delay(200);
}
Então verificamos se pressionamos o botão Set, usado para definir as posições IN e OUT. Com o primeiro pressionamento do botão, armazenamos as posições IN dos motores de passo e também acendemos o LED IN.
switch (InandOut) {
case 0: // Define posição IN
InandOut = 1;
XInPoint = stepper1.currentPosition(); // Define posição IN para stepper 1
YInPoint = stepper2.currentPosition(); // Define posição IN para stepper 2
ZInPoint = stepper3.currentPosition(); // Define posição IN para stepper 3
digitalWrite(inLED, HIGH); // Acende inLED
break;
Da mesma forma, com o segundo pressionamento, armazenamos as posições OUT e acendemos o LED OUT.
case 1: // Define posição OUT
InandOut = 2;
XOutPoint = stepper1.currentPosition(); // Define pontos OUT para ambos steppers
YOutPoint = stepper2.currentPosition();
ZOutPoint = stepper3.currentPosition();
digitalWrite(outLED, HIGH);
break;
Então, com o próximo pressionamento do botão, lemos o valor do potenciômetro de velocidade automática que é usado para definir a velocidade máxima dos motores. Também colocamos as posições IN no array "gotoposition" que é usado na função moveTo() que calcula a velocidade necessária para todos os steppers separadamente. Então, usando a função runSpeedToPosition(), o slider move automaticamente para a posição IN.
case 2: // Move para posição IN / vai para case 3
InandOut = 3;
inOutSpeed = analogRead(inOutPot); // Potenciômetro de velocidade automática
// Coloca a posição IN no Array
gotoposition[0] = XInPoint;
gotoposition[1] = YInPoint;
gotoposition[2] = ZInPoint;
stepper1.setMaxSpeed(inOutSpeed);
stepper2.setMaxSpeed(inOutSpeed);
stepper3.setMaxSpeed(inOutSpeed);
StepperControl.moveTo(gotoposition); // Calcula velocidade necessária para todos motores
StepperControl.runSpeedToPosition(); // Bloqueia até todos steppers estarem na posição
delay(200);
break;
Exatamente da mesma forma, no case 3 ou com outro pressionamento do botão, movemos o slider para a posição OUT.
case 3: // Move para posição OUT / volta para case 2
InandOut = 2;
inOutSpeed = analogRead(inOutPot);
// Coloca a posição OUT no Array
gotoposition[0] = XOutPoint;
gotoposition[1] = YOutPoint;
gotoposition[2] = ZOutPoint;
stepper1.setMaxSpeed(inOutSpeed);
stepper2.setMaxSpeed(inOutSpeed);
stepper3.setMaxSpeed(inOutSpeed);
StepperControl.moveTo(gotoposition);
StepperControl.runSpeedToPosition();
delay(200);
break;
Caso seguremos o botão Set pressionado por mais de meio segundo, o case 4 será executado, que reseta as posições IN e OUT para que possamos definir novas.
Em seguida, está o controle de Pan e Tilt pelo joystick. O valor analógico que obtemos do joystick vai de 0 a 1024, ou quando ele repousa no meio o valor é cerca de 500. Então, se movemos o joystick para a esquerda e o valor analógico é maior que 600, definimos a velocidade do motor particular como positiva; e oposto, se movemos o joystick para a direita, definimos a velocidade do motor como negativa, o que significa que ele girará no sentido oposto.
// Joystick X - Movimento Pan
JoyXPos = analogRead(JoyX);
// Se joystick movido para esquerda, move stepper 2 ou pan para esquerda
if (JoyXPos > 600) {
stepper2.setSpeed(currentSpeed);
}
// Se joystick movido para direita, move stepper 2 ou pan para direita
else if (JoyXPos < 400) {
stepper2.setSpeed(-currentSpeed);
}
// Se joystick fica no meio, sem movimento
else {
stepper2.setSpeed(0);
}
Caso fique no meio, a velocidade é definida como 0. Este método é usado para ambos os eixos do joystick, bem como para o potenciômetro do slider. Na verdade, no caso do potenciômetro, usamos seu valor analógico para também aumentar a velocidade do motor conforme giramos mais o potenciômetro.
// Potenciômetro do slider
sliderPos = analogRead(slider);
// Se potenciômetro girado para esquerda, move slider para esquerda
if (sliderPos > 600) {
sliderPos = map(sliderPos, 600, 1024, 0, 3000);
stepper1.setSpeed(sliderPos); // Aumenta velocidade conforme gira
}
// Se potenciômetro girado para direita, move slider para direita
else if (sliderPos < 400 ) {
sliderPos = map(sliderPos, 400, 0, 0, 3000);
stepper1.setSpeed(-sliderPos); // Aumenta velocidade conforme gira
}
// Se potenciômetro no meio, sem movimento
else {
stepper1.setSpeed(0);
}
Por fim, chamamos as funções runSpeed() para cada um dos três motores de passo e isso executa os comandos acima, ou gira os motores apropriadamente.
// Executa os comandos acima - roda os motores de passo
stepper1.runSpeed();
stepper2.runSpeed();
stepper3.runSpeed();
Código Fonte Completo
/* DIY Camera Slider with Pan and Tilt Head
by Dejan Nedelkovski www.HowToMechatronics.com
Library - AccelStepper by Mike McCauley: https://www.airspayce.com/mikem/arduino/AccelStepper/index.html */
#include <AccelStepper.h>
#include <MultiStepper.h>
#define JoyX A0
#define JoyY A1
#define slider A2
#define inOutPot A3
#define JoySwitch 10
#define InOutSet 12
#define limitSwitch 11
#define inLED 8
#define outLED 9
AccelStepper stepper1(1, 7, 6);
AccelStepper stepper2(1, 5, 4);
AccelStepper stepper3(1, 3, 2);
MultiStepper StepperControl;
long gotoposition[3];
int JoyXPos = 0;
int JoyYPos = 0;
int sliderPos = 0;
int currentSpeed = 100;
int inOutSpeed = 100;
int XInPoint = 0;
int YInPoint = 0;
int ZInPoint = 0;
int XOutPoint = 0;
int YOutPoint = 0;
int ZOutPoint = 0;
int InandOut = 0;
void setup() {
stepper1.setMaxSpeed(3000);
stepper1.setSpeed(200);
stepper2.setMaxSpeed(3000);
stepper2.setSpeed(200);
stepper3.setMaxSpeed(3000);
stepper3.setSpeed(200);
pinMode(JoySwitch, INPUT_PULLUP);
pinMode(InOutSet, INPUT_PULLUP);
pinMode(limitSwitch, INPUT_PULLUP);
pinMode(inLED, OUTPUT);
pinMode(outLED, OUTPUT);
StepperControl.addStepper(stepper1);
StepperControl.addStepper(stepper2);
StepperControl.addStepper(stepper3);
while (digitalRead(limitSwitch) != 0) {
stepper1.setSpeed(3000);
stepper1.runSpeed();
stepper1.setCurrentPosition(0);
}
delay(20);
while (stepper1.currentPosition() != -200) {
stepper1.setSpeed(-3000);
stepper1.run();
}
}
void loop() {
while (digitalRead(limitSwitch) == 0 || stepper1.currentPosition() < -64800) {}
if (digitalRead(JoySwitch) == 0) {
currentSpeed = currentSpeed + 50;
delay(200);
}
if (digitalRead(InOutSet) == 0) {
delay(500);
if (digitalRead(InOutSet) == 0) {
InandOut = 4;
}
switch (InandOut) {
case 0:
InandOut = 1;
XInPoint = stepper1.currentPosition();
YInPoint = stepper2.currentPosition();
ZInPoint = stepper3.currentPosition();
digitalWrite(inLED, HIGH);
break;
case 1:
InandOut = 2;
XOutPoint = stepper1.currentPosition();
YOutPoint = stepper2.currentPosition();
ZOutPoint = stepper3.currentPosition();
digitalWrite(outLED, HIGH);
break;
case 2:
InandOut = 3;
inOutSpeed = analogRead(inOutPot);
gotoposition[0] = XInPoint;
gotoposition[1] = YInPoint;
gotoposition[2] = ZInPoint;
stepper1.setMaxSpeed(inOutSpeed);
stepper2.setMaxSpeed(inOutSpeed);
stepper3.setMaxSpeed(inOutSpeed);
StepperControl.moveTo(gotoposition);
StepperControl.runSpeedToPosition();
delay(200);
break;
case 3:
InandOut = 2;
inOutSpeed = analogRead(inOutPot);
gotoposition[0] = XOutPoint;
gotoposition[1] = YOutPoint;
gotoposition[2] = ZOutPoint;
stepper1.setMaxSpeed(inOutSpeed);
stepper2.setMaxSpeed(inOutSpeed);
stepper3.setMaxSpeed(inOutSpeed);
StepperControl.moveTo(gotoposition);
StepperControl.runSpeedToPosition();
delay(200);
break;
case 4:
InandOut = 0;
digitalWrite(inLED, LOW);
digitalWrite(outLED, LOW);
delay(1000);
break;
}
}
JoyXPos = analogRead(JoyX);
if (JoyXPos > 600) { stepper2.setSpeed(currentSpeed); }
else if (JoyXPos < 400) { stepper2.setSpeed(-currentSpeed); }
else { stepper2.setSpeed(0); }
JoyYPos = analogRead(JoyY);
if (JoyYPos > 600) { stepper3.setSpeed(currentSpeed); }
else if (JoyYPos < 400) { stepper3.setSpeed(-currentSpeed); }
else { stepper3.setSpeed(0); }
sliderPos = analogRead(slider);
if (sliderPos > 600) {
sliderPos = map(sliderPos, 600, 1024, 0, 3000);
stepper1.setSpeed(sliderPos);
}
else if (sliderPos < 400 ) {
sliderPos = map(sliderPos, 400, 0, 0, 3000);
stepper1.setSpeed(-sliderPos);
}
else { stepper1.setSpeed(0); }
stepper1.runSpeed();
stepper2.runSpeed();
stepper3.runSpeed();
}
É isso para este tutorial. Sinta-se à vontade para fazer qualquer pergunta na seção de comentários abaixo e confira minha coleção de Projetos Arduino.
Processo de manufatura
- Slider Motorizado para Câmera com Bluetooth e Arduino para Tomadas Cinematográficas Suaves
- Crie um Sistema Ambilight Impressionante para Monitor com Arduino
- Sistema de Presença RFID Confiável com Arduino e Python
- Construa um Voltímetro Inteligente com Arduino e Smartphone – Projeto DIY Fácil
- Construa um Voltímetro DIY com Arduino e Display Nokia 5110 – Guia Passo a Passo
- Autômatos Celulares em Tempo Real no Arduino com Display OLED 128x64
- Contador de RPM Arduino de Alta Velocidade com Algoritmo Inovador
- Construa um Rádio FM Compacto com Arduino Nano e RDA5807M
- Sistema de Presença em Tempo Real com RFID, Arduino e Google Sheets
- Criar Tons Musicais com Arduino: Um Guia Passo a Passo