What’s up my friends, welcome back. Today we will build a homemade slider, I’ll show you how I’ve build it starting with the 3D printed parts, all the mechanical parts, the step motor and finally the electronics. It has a control case with a rotary encoder menu and LCD screen for speed and direction control. The slide uses metal bearings and metal tubes and the rest of the parts are designed and 3D printed. It has a length of 1 meter and can slid
by: ELECTRONOOBS on 2026-06-18
1 x Arduino NANO/UNO LINK eBay
1 x A4988 LINK eBay
2 x Push buttons LINK eBay
1 x i2c LCD: LINK eBay
1 x NEMA17 step motor: LINK eBay
1 x 2m timing belt: LINK eBay
1 x GT2 pully: LINK eBay
1 x rotary encoder: LINK eBay
1 x buzzer: LINK eBay
1 x 12V DC transformer: LINK eBay
3D files: LINK here
Screws: LINK eBay
Camera support: LINK eBay
Resistors: LINK eBay
Wires LINK eBay
Female PCB pins LINK eBay
Male PCB pins LINK eBay
Drilled PCB LINK eBay
Wire, soldering iron, solder, etc...
What’s up my friends, welcome back. The first thing to do was to measure the diameter of two metal tubes. Also, of a NEMA 17 step motor, some bearings, the size of a bunch of screws, the camera support, an LCD and all the extra parts. Once I had all the parts dimensions I’ve started editing the plastic parts for this slider. I’ve made the left and right side of the slider and the main plate. Also 4 legs so you could adjust the height and angle of the slider.
I’ve also designed a case where I’ll place the LCD and all the controls but also the Arduino NANO, and a driver IC for the step motor. All the designs have holes for screws so you could tight all the parts in place. Screws for the left and right sides of the slider to fit those in place on the metal tubes, also screws for the step motor and for closing the main control case.
By the way, in the link below you will find the 3D files of this project and also the dimensions.
I’ve used my 3D printers and printed the 3D files using gray and black PLA material with 20% infill and a 0.4 mm nozzle and a layer height of 0.3mm. These are all the parts. Two supports for the left and right side. One has a NEMA 17 step motor support. They both have places for the 3D printed legs with some bumps so you could fix the angle of the leg. Then we have the main plate with spaces for bearings and a hole in the middle for a camera support. Next, we have the 3D printed case made of 2 parts, one is the main case and the other is the front plate of the case with holes for the controls.
We will also need 2 push buttons, one rotary encoder, an i2c LCD module, the Arduino NANO, a 12V DC transformer, the NEMA 17 STEP motor and the A49 88 step motor driver. This module receives 3 signals and will control 4 outputs for the motor coils. Those signals are the enable pin, rotation direction and amount of steps. With these 3 signals we could precisely control the step motor.
I mount the side parts and the two metal tubes. For the slider, I’ve used some bearings that I’ve got out from old rollers. You could use normal 22mm diameter bearings with a screw nut in between like in the photo below so the two bearings would fit on the metal bar with a gap in between. I’ve screwed in place the 4 pairs of bearings on the slider plate and then add two more pairs of rollers on the middle holes so the plate won’t be able to get out.
Now I screw in place the step motor on the left support. To transfer movement you should use timing belt and a pully. But, the one I’ve ordered is not long enough so till I receive a new one, I’ll just use some kind of wire. I’ve printed a special pulley that could get screwed on the shaft of the motor, and another one on the other side with a small bearing inside. Now I tie one end of the wire to the rolling plate, pass the wire over the pully and then over the bearing at the other end and finally tie it on the other side of the rolling plate.
Finally, I add an end stop switch like this one on the motor side support. This switch will be used to home the position of the slider each time that you want. That’s it, the slider body is ready. The wire of the motor and the switch will go inside the control case. Now let’s prepare the case.
Download and follow the schematic of the project from a link below. I screw in place the LCD, the two push buttons and the rotary encoder in the middle. On a drilled PCB and using female pins I solder an Arduino NANO and the step motor driver together with a 10uF capacitor. I also solder 4 pins at the driver output for the step motor connector.
Now, using wires I connect the i2c pins of the LCD to pins A4 and A5 of the Arduino. The rotary encoder has two outputs and we name those data and clock and they will be connected to pins 8 and 9 of the Arduino. The rotary also has a push button inside and it will be connected to digital pin 10. The other two push buttons are connected to pins 11 and 12 and the end stop switch to digital pin 4.
Ok, below you have the full schematic of this project. Pass the wires from the motor and end stop switch inside the case through the back hole. Also the 12V from the transformer and connect that to the Vin of the arduino and to the Vmot of the step motor driver. Remember to add pulldowns to each push button and to the end stop switch.
All buttons have pulldowns to ground so when the button is pushed, it will jump to a high state. Finally, I make the connections from the Arduino to the step motor driver. I connect the enable, the direction and step pins to digital pins 5, 6 and 7 and we are done. I pass the 12V transformer wire through the case hole and connect positive to the Vin pin of the Arduino and ground to ground and also supply 12V to the step motor driver. Now pass the motor and end stop wires inside the case and now let’s take a quick look over the code.
What I want it to do is to be able to use the encoder and enter a menu. Inside the menu, I could home the slider or change the speed. Once the speed is selected, you could select sliding to the right or to the left using the buttons.
Now, on the left side we have an end stop so the code could easily know when to stop. But on the right side we don’t have one. So, the code will have to count the maximum amount of step. We calculate how many steps we need for one cm, then it is very easy to know how many steps we need for 1 full meter. So once the slider is homed, the position step counter in the code will be set to 0.
/*
* Camera slider code for Arduino. Author: ELECTRONOOBS
* Tutorial: http://www.electronoobs.com/eng_arduino_tut27.php
* Video: https://www.youtube.com/watch?v=YGbPnAZzEQk
*
* Connect the pins as her: http://www.electronoobs.com/eng_arduino_tut27_sch1.php
*/
//LCD config
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,20,4); //sometimes the LCD adress is not 0x3f. Change to 0x27 if it dosn't work.
//Variables
bool Last_State;
bool clk_State;
bool dt_State;
int counter_menu = 0;
float counter_speed = 3.5;
int last_counter_menu = 0;
int menu_enter = 0;
bool rotary_push_state = false;
bool last_counter_speed = false;
float Speed = 20;
int just_entered=0;
int homing = 0;
int Position_steps = 0;
bool Slide_left=false;
bool Slide_right=false;
int print_once = 0;
//I/O
#define rotary_button 10
#define left_button 11
#define right_button 12
#define Enable 5
#define Direction 6
#define Step 7
#define end_stop 4
//below read how to calculate the delay for the square wave
float perimeter = 2.5; //in cm
float steps_per_cm = 200/perimeter;
float step_delay = 10/steps_per_cm;
void setup() {
pinMode (rotary_button,INPUT); //Define the pin as input
pinMode (left_button,INPUT); //Define the pin as input
pinMode (right_button,INPUT); //Define the pin as input
pinMode (end_stop,INPUT); //Define the pin as input
pinMode (Enable,OUTPUT); //Define the pin as OUTPUT
pinMode (Direction,OUTPUT); //Define the pin as OUTPUT
pinMode (Step,OUTPUT); //Define the pin as OUTPUT
lcd.init(); //Init the LCD
lcd.backlight(); //Activate backlight
PCICR |= (1 << PCIE0); //enable PCMSK0 scan
PCMSK0 |= (1 << PCINT0); //Set pin D8 trigger an interrupt on state change.
PCMSK0 |= (1 << PCINT1); //Set pin D9 trigger an interrupt on state change.
PCMSK0 |= (1 << PCINT2); //Set pin D10 trigger an interrupt on state change.
PCMSK0 |= (1 << PCINT3); //Set pin D11 trigger an interrupt on state change.
PCMSK0 |= (1 << PCINT4); //Set pin D12 trigger an interrupt on state change.
Last_State = (PINB & B00000001); //pin 8 state (clock pin)?
lcd.clear();
lcd.setCursor(0,0);
lcd.print(" WELCOME! ");
delay(1000);
lcd.setCursor(0,0);
lcd.print(" ELECTRONOOBS ");
lcd.setCursor(0,1);
lcd.print(" Camera SLIDER ");
delay(2000);
lcd.clear();
lcd.setCursor(0,0);
lcd.print(" Homing ");
while (!digitalRead(end_stop))
{
digitalWrite(Enable, LOW); //Negative enabled
digitalWrite(Direction, LOW); //Low for Left
digitalWrite(Step,HIGH);
delay(1);
digitalWrite(Step,LOW);
delay(1);
}
lcd.clear();
lcd.setCursor(0,0);
lcd.print(" READY! ");
delay(1000);
}
void loop() {
/*
* The speed is seconds per meter, so how many seconds the slider needs to make one meter
* We know that in my case, each rotation needs 200 steps
* Also, my pully has a perimeter of 2cm so each 200 steps I make 2cm, so for 1m I need 10.000 steps.
* That's why below I multiplay the speed in seconds by 10.000 and then divide it by the amount of steps
* we need for only one cm and the delay is expresed in microseconds. Also see above the perimeter of the pully
*/
step_delay = (10000 * Speed)/steps_per_cm;
if(Slide_left)
{
if(print_once)
{
lcd.clear();
lcd.setCursor(0,0);
lcd.print(" Sliding LEFT ");
print_once = 0;
}
if(digitalRead(end_stop))
{
digitalWrite(Enable, HIGH); //Disabled
Slide_left = false;
Position_steps = 0;
}
digitalWrite(Enable, LOW); //Negative enabled
digitalWrite(Direction, LOW); //LOW for Left
digitalWrite(Step,HIGH);
delayMicroseconds(step_delay);
digitalWrite(Step,LOW);
delayMicroseconds(step_delay);
}
if(Slide_right)
{
if(print_once)
{
lcd.clear();
lcd.setCursor(0,0);
lcd.print(" Sliding RIGHT ");
print_once = 0;
}
if(Position_steps > 7500)
{
digitalWrite(Enable, HIGH); //Disabled
Slide_right = false;
}
digitalWrite(Enable, LOW); //Negative enabled
digitalWrite(Direction, HIGH); //GIGH for Right
digitalWrite(Step,HIGH);
delayMicroseconds(step_delay);
digitalWrite(Step,LOW);
delayMicroseconds(step_delay);
Position_steps = Position_steps + 2;
}
if(menu_enter == 0 && !Slide_right && !Slide_left)
{
lcd.clear();
lcd.setCursor(0,0);
lcd.print(" Sliding speed ");
lcd.setCursor(0,1);
lcd.print(Speed);
lcd.setCursor(13,1);
lcd.print("s/m");
delay(200);
}
if(menu_enter == 1)
{
if(counter_menu != last_counter_menu)
{
if(counter_menu < 4)
{
lcd.clear();
lcd.setCursor(0,0);
lcd.print("> Speed");
lcd.setCursor(0,1);
lcd.print(" Home");
delay(10);
}
if(counter_menu > 4)
{
lcd.clear();
lcd.setCursor(0,0);
lcd.print(" Speed");
lcd.setCursor(0,1);
lcd.print("> Home");
delay(10);
}
last_counter_menu = counter_menu;
}
}
if(menu_enter == 2)
{
if(counter_speed != last_counter_speed)
{
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Speed: ");
lcd.setCursor(6,0);
lcd.print(Speed);
delay(50);
last_counter_speed = counter_speed;
}
}
//This is part 3 of the menu. The homing menu
if(menu_enter == 3)
{
if(homing)
{
lcd.clear();
lcd.setCursor(0,0);
lcd.print(" HOMING ");
lcd.setCursor(0,1);
lcd.print("----------------");
delay(200);
//Create a while. If the end stop is not pressed, we keep rotating...
while (!digitalRead(end_stop))
{
digitalWrite(Enable, LOW); //Negative enabled
digitalWrite(Direction, LOW); //Low for Left
digitalWrite(Step,HIGH);
delayMicroseconds(700);
digitalWrite(Step,LOW);
delayMicroseconds(700);
}
Position_steps = 0; //Once we are home, we reset the position to 0
digitalWrite(Enable, HIGH); //Disable the step mootr driver
homing=0; //Set the homing variable to 0 or deactivated
menu_enter=0; //The menu position is again the first one
lcd.clear();
lcd.setCursor(0,0);
lcd.print(" Ready! "); //Print ready for 1 seconds
delay(1000);
}//end homing
}//end menu 3
//We apply ranges for counters
if(counter_menu > 8)
{
counter_menu=9;
}
if(counter_menu < 0)
{
counter_menu=0;
}
if(counter_speed > 9999)
{
counter_speed=9999;
}
if(counter_speed < 0)
{
counter_speed=0;
}
if(Speed > 9999)
{
Speed=9999;
}
if(Speed < 0)
{
Speed=0;
}
}//end void
/*Interruption vector triggered by:
-Data and Clock from encoder
-Push buttons
-Encoder push button
*/
ISR(PCINT0_vect){
delay(4);
if((PINB & B00001000) && Slide_left) //Pin 11 was pushed? Left button?
{
Slide_left=false;
delay(200);
}
if((PINB & B00010000) && Slide_right) //Pin 12 was pushed? Right button?
{
Slide_right=false;
delay(200);
}
if((PINB & B00001000) && !Slide_left) //Pin 11 was pushed? Left button?
{
Slide_left=true;
Slide_right=false;
print_once = 1;
delay(200);
}
if((PINB & B00010000) && !Slide_right) //Pin 12 was pushed? Right button?
{
Slide_right=true;
Slide_left=false;
print_once = 1;
delay(200);
}
if((PINB & B00000100) && !rotary_push_state) //Pin 10 was pushed?
{
Slide_left = false;
Slide_right = false;
if(menu_enter == 2)
{
menu_enter = 0; //first menu;
just_entered=1;
delay(500);
}
if(menu_enter == 3)
{
menu_enter = 0; //first menu;
just_entered=1;
homing = 0;
delay(500);
}
if(menu_enter == 1)
{
if(counter_menu < 4)
{
menu_enter = 2; //menu is speed select
delay(500);
}
if(counter_menu > 4)
{
menu_enter = 3; //menu is homing
homing = 1;
delay(500);
}
}
if(menu_enter == 0 && !just_entered)
{
menu_enter = 1; //first menu;
delay(500);
}
just_entered=0;
rotary_push_state = true;
counter_menu ++;
counter_speed = counter_speed + 0.5;
}
if(!(PINB & B00000100) && rotary_push_state) //Pin 10 was released?
{
rotary_push_state = false;
}
if(menu_enter == 2)
{
clk_State = (PINB & B00000001); //pin 8 state, clock pin?
dt_State = (PINB & B00000010);
if (clk_State != Last_State){
// If the data state is different to the clock state, that means the encoder is rotating clockwise
if (dt_State != clk_State) {
counter_speed = counter_speed + 0.5;
}
else {
counter_speed = counter_speed - 0.5;
}
}
Last_State = clk_State; // Updates the previous state of the data with the current state
Speed = counter_speed;
}
if(menu_enter == 1)
{
clk_State = (PINB & B00000001); //pin 8 state, clock pin?
dt_State = (PINB & B00000010);
if (clk_State != Last_State){
// If the data state is different to the clock state, that means the encoder is rotating clockwise
if (dt_State != clk_State) {
counter_menu ++;
}
else {
counter_menu --;
}
}
Last_State = clk_State; // Updates the previous state of the data with the current state
}
}s you can see in the part above, when the amount of steps is over 10.000 we stop the driver. If not, we create a square vawe with a width of the "step_delay" value. After the square wave, we increase the step amount by 2 since each pass from high to low and low to high of the square wave will be a step.
The code is quite easy but probably a bit long. Remember, you will need the i2c liquid crystal library if you use this kind of LCD screen so make sure you download it from below and install it on to your Arduino IDE.
See my other rotary encoded menu video below to learn more about this project because since I’ve already done that, I won’t explain it step by step.
But any way, now, in the code, each time the data or clock pins of the encoder or any of the other buttons will change their state, we create an interruption (read all the comments in the full code). By rotating the encoder, we increase or decrease the menu position or the speed amount. Please, read all the comments in the code in order to understand more.
Now, in infinite loop, if one of the left or right buttons is pressed will activate the enable pin for the step motor driver, select the direction with low for left and high for right, and create a square wave on the steps pin. The delay between the high and low state of the square wave will give us the frequency and that will control the rotation speed of the motor. Read in the code how to calculate your delay time depending on the pulley size. Download the code from a link below, compile, make sure you have the connections as in the schematic and upload the code. And there you go. This is how this works. When I start the slider, the first thing it dose is homing itself and by that reset the position. Then I press the rotary encoder and select the speed menu. In this case the speed is expressed in seconds. This will be the time it takes the slider to make a full meter. I set is to 4 seconds.
I press the rotary encoder again and exit the speed menu and we are ready to slide. I press the R button and the slider starts moving to the right till it reaches the maximum amount of steps. Remember that timing belt is much better if you want precision so once I’ll receive the 3 meters belt, I’ll use that. The slider stops if it reaches maximum sliding steps, or if any of the buttons is pressed.
There you go my friends. The slider is quite strong made with metal tubes. It can easily carry my DSLR Canon camera and with this cheap camera adaptor, you could set any angle. If you would like to support me, check my Patreon page and by that be able to see when I post my videos one day before.
Comments
Leave a comment
Please login in order to comment.