Subsystems

A Subsystem is one robot mechanism — a drivetrain, an arm, a lift — with a fixed lifecycle. You register subsystems in your ModularOpMode's preload(), and the OpMode drives each one through init, start, loop, and stop for you.

Subsystem is an abstract class with five lifecycle methods. Extend it, implement the methods for your mechanism, and register it — you never call these methods yourself.

@Override
public void init_loop() {
    // Nothing to do during init for this subsystem — but the method is required.
}

Provided subsystem types

CDALib ships several subsystem base classes and ready-made subsystems. Reach for the one that matches your mechanism.

DeviceSubsystem

The constructor is protected DeviceSubsystem(Device device). The wrapped device is held in a protected final Device device field and refreshed automatically each loop. This is the base you'll use most: wrap one motor, servo, or sensor and expose intent-level methods.

CompoundSubsystem

Extend it and add children in your constructor. init(), start(), update(), and stop() are already implemented to loop over every child.

public class Intake extends CompoundSubsystem {
    public Intake(HardwareMap hardwareMap) {
        registerSubsystem(new Roller(hardwareMap));
        registerSubsystem(new Wrist(hardwareMap));
    }

    @Override
    public void init_loop() {
        // required; delegate to children yourself if needed
    }
}

PositionMotorSubsystem

Resolves a motor from the hardware map and drives it toward a target position with a Controller. Each update() feeds the motor's current encoder position and the elapsed time to the controller and applies the resulting power.

PositionMotorSubsystem lift =
        new PositionMotorSubsystem(hardwareMap, "lift", new PIDController(0.01, 0, 0.001));
lift.setDirection(DcMotorSimple.Direction.REVERSE);
registerSubsystem(lift);

// later, from a binding or module:
lift.setPosition(1200);   // drive toward 1200 encoder ticks and hold

ThreadedIMU

The universal IMU is an I2C device, and I2C is not covered by Lynx bulk caching — a normal getRobotYawPitchRollAngles() in the loop costs a full blocking transaction (several milliseconds) every cycle. ThreadedIMU instead spins a daemon reader thread (~200 Hz by default) that continuously polls the IMU into a cached snapshot; the getters return that snapshot in constant time, removing IMU latency from every loop.

IMU imu = hardwareMap.get(IMU.class, "imu");
imu.initialize(new IMU.Parameters(/* your hub orientation */));

ThreadedIMU heading = new ThreadedIMU(imu);
registerSubsystem(heading);   // ModularOpMode starts the reader on start(), stops it on end

// in a module/binding:
double yaw = heading.getYaw(AngleUnit.DEGREES);

NullSubsystem

All five lifecycle methods are empty. Register it where the code expects a subsystem but you want no behavior — a clean default that keeps a slot non-null.

Writing your own subsystem

Extend Subsystem and implement all five lifecycle methods. This lift wraps a MotorDevice — set the power you want in your control methods and let update() flush it once per loop (a bulk-cache-friendly write). Note the required init_loop(), empty here.

package org.firstinspires.ftc.teamcode.subsystems;

import com.cdarobotics.cdalib.subsystems.Subsystem;
import com.cdarobotics.cdalib.devices.actuators.MotorDevice;
import com.qualcomm.robotcore.hardware.DcMotor;
import com.qualcomm.robotcore.hardware.DcMotorSimple;
import com.qualcomm.robotcore.hardware.HardwareMap;

public class Lift extends Subsystem {

    private final MotorDevice motor;
    private double power = 0.0;

    public Lift(HardwareMap hardwareMap) {
        motor = new MotorDevice(hardwareMap, "lift");
    }

    // Control method your modules/bindings call.
    public void setPower(double power) {
        this.power = power;
    }

    @Override
    public void init() {
        motor.setDirection(DcMotorSimple.Direction.REVERSE)
             .setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE);
    }

    @Override
    public void init_loop() {
        // Required by Subsystem. Nothing to do during init here.
    }

    @Override
    public void start() {
        power = 0.0;
    }

    @Override
    public void update() {
        // Cache the commanded power; MotorDevice.update() flushes it (write-cached).
        motor.setPower(power).update();
    }

    @Override
    public void stop() {
        motor.setPower(0.0).update();
    }
}

Register it in your OpMode:

@Override
protected void preload() {
    registerSubsystem(new Lift(hardwareMap));
}