Skip to content
Week 7 · Lesson 2 50 min

Lifts and Linear Slides

Discover how linear slides extend, how string and belts pull them, the difference between continuous and cascade rigging, and how to keep a lift from sagging.

In this lesson you will

  • Explain how multi-stage linear slides extend and retract
  • Compare continuous and cascade rigging in speed, force and complexity
  • Describe why a lift needs continuous effort to hold its position
  • Write an OpMode that holds a lift at preset heights using encoders

Lesson

Many scoring locations are higher or further away than your robot can reach from the floor. A lift moves a game element up (or out) in a straight line. In FTC the most common lift is a set of linear slides: stacked rails that slide along each other, like a telescope or a drawer. Lifts are powerful, but they also add weight high on the robot and need careful rigging, so it is worth understanding how they work before you build one.

How linear slides work

Each section of a slide is called a stage. The first stage is bolted to the robot, and each following stage rides on bearings or rollers inside or beside the one before it. More stages give more reach from the same collapsed height, but every stage adds weight, friction and a little wobble. Teams use purpose-built FTC slide kits or, for prototypes, ordinary drawer slides. Mount slides square and parallel: a slight twist makes them bind.

Pulling with string or belt

A motor turns a spool (for string) or a pulley (for a timing belt). As it turns, the string or belt pulls the stages apart. String is light, cheap and easy to route, but it can stretch, fray or slip off the spool. Belts do not stretch much and stay positioned, but they are bulkier and harder to route through many stages. Something also has to bring the slide back down: gravity, elastic, or a second string wound the opposite way on the same spool. A separate retract string is the most reliable because it pulls the slides down even if they stick.

Continuous vs cascade rigging

Continuous riggingCascade rigging
String pathOne string runs through every stage to the last stageEach stage has its own string anchored to the stage before
Stage movementStages may extend in any orderAll stages extend together, at the same time
Speed of top stageSame as the spool's string speedSpool speed times the number of moving stages
Force at the spoolLowerHigher (multiplied by the number of moving stages)
ComplexityFewer anchors, but a long string to tensionMore strings and pulleys to route

Why does cascade rigging go faster? Each stage moves relative to the one below it at the same rate, so the speeds add up: with three moving stages, the top one travels about three times as fast as the string. But physics does not give you free speed. The motor must supply about three times the force, so cascade lifts often need more gear reduction or a stronger motor. Continuous rigging is slower and gentler on the motor. For a first lift, continuous rigging with a retract string is a solid choice.

Holding position

Gravity is always pulling your lift down. If the motor simply stops, the lift will slowly sag or crash down. Setting the zero power behaviour to BRAKE helps a little, but it does not truly hold a heavy lift. The reliable method is to use the motor's encoder with RUN_TO_POSITION: the motor controller keeps measuring the position and pushes back whenever the lift drifts from its target. This is called motor holding, and it means the motor is working even when the lift looks still.

JAVA
1import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode;
2import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
3import com.qualcomm.robotcore.hardware.DcMotor;
4
5@TeleOp(name = "Lift Hold Demo")
6public class LiftHoldDemo extends LinearOpMode {
7    static final int LIFT_LOW = 0;
8    static final int LIFT_HIGH = 1500; // example: measure on your robot
9
10    @Override
11    public void runOpMode() {
12        DcMotor lift = hardwareMap.get(DcMotor.class, "lift");
13        lift.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE);
14        lift.setMode(DcMotor.RunMode.STOP_AND_RESET_ENCODER);
15        lift.setTargetPosition(LIFT_LOW);
16        lift.setMode(DcMotor.RunMode.RUN_TO_POSITION);
17
18        waitForStart();
19        lift.setPower(0.8);
20
21        while (opModeIsActive()) {
22            if (gamepad2.y) {
23                lift.setTargetPosition(LIFT_HIGH);
24            } else if (gamepad2.a) {
25                lift.setTargetPosition(LIFT_LOW);
26            }
27            telemetry.addData("Target", lift.getTargetPosition());
28            telemetry.addData("Position", lift.getCurrentPosition());
29            telemetry.update();
30        }
31    }
32}
Holding a lift at two preset heights. The HIGH tick count is an example; measure your own.

Gravity compensation

Gravity compensation means helping the motor carry the lift's weight so it does not have to fight gravity alone. For a vertical lift, the weight is roughly the same at every height, so two simple approaches work. You can add a small, constant extra motor power in the 'up' direction in your code, or you can add mechanical help such as constant-force springs or elastic bands that pull upward. Mechanical help reduces motor strain and heat; the code approach is easier to adjust. Either way, tune it so the lift barely drifts when the motor is told to do nothing.

Collect3 sTravel4 sScore2 sReturn4 sCycle time ≈ 13 sHypothetical times
Lift travel time happens in every scoring cycle, so a faster, reliable lift shortens every cycle.
  1. 1
    Mount square
    Check that slide rails are parallel and slide freely by hand before adding string.
  2. 2
    Rig and tension
    Route the extend and retract strings, then tension them so there is no slack at any height.
  3. 3
    Find the limits
    Move the lift by hand, read encoder values with telemetry, and note the top and bottom tick counts.
  4. 4
    Test under load
    Run the lift with a game element on it and confirm it holds position without sagging.

Key terms

Linear slide
A set of stacked rails that slide along each other to extend a mechanism in a straight line.
Stage
One section of a linear slide; each extra stage adds reach.
Continuous rigging
A slide rigging method where one string runs through all stages; slower but needs less force.
Cascade rigging
A slide rigging method where each stage is pulled by its own string so all stages extend together, faster but with more force needed.
Motor holding
Using an encoder and a position mode so the motor actively pushes back to keep a mechanism at its target.
Gravity compensation
Extra motor power or springs that offset a mechanism's weight so it does not sag.

Practical exercise

Measure and hold a lift

  1. 1Using a lift on your robot or a drawer-slide prototype with a motor and spool, check that the slides move freely by hand with the robot switched off.
  2. 2Run a telemetry OpMode that prints the motor's encoder position, and move the lift by hand to record the bottom and top tick counts.
  3. 3Put those values into the Lift Hold Demo code, using a top value slightly below the measured maximum.
  4. 4Test the lift 10 times from low to high with a game element on it. Time each move with a stopwatch.
  5. 5Write down whether it held position at the top and how long the average move took.
Deliverable: A short note with your measured tick counts, the average lift time, and whether the lift held without sagging.

Knowledge check

Answer every question, then check your answers.

  1. Q1With cascade rigging and three moving stages, how fast does the top stage move compared with the string?
  2. Q2Why is a separate retract string often used on slides?
  3. Q3What happens when you use RUN_TO_POSITION to hold a lift?
  4. Q4Which is an example of mechanical gravity compensation for a lift?

Further resources

Mark lesson complete