Sometimes you might need to reset your Thrifty Nova motor controller back to its original settings. The factory reset feature lets you do this with just one line of code!

Basic Usage

motor.factoryReset();

That's it! This command will reset almost all settings back to their factory defaults.

What Gets Reset?

When you perform a factory reset, these settings will return to their default values:

• Motor inversion (returns to false)

• Brake mode (returns to false)

• Maximum output (returns to 100%)

• Ramp rates (returns to 0.1 seconds)

• Current limits (returns to 40 amps)

• PID values (returns to 0)

• Soft limits

• Temperature throttling

What Doesn't Get Reset?

Some settings will stay the same even after a factory reset:

• CAN ID

• Device name

• Serial number

Example Code

Here's a complete example showing how you might use factory reset in your robot code:

javaCopypublic class MySubsystem extends Subsystem {
    private ThriftyNova motor;
    
    public MySubsystem() {
        // Create our motor with CAN ID 7
        motor = new ThriftyNova(7);
        
        // Reset to factory defaults
        motor.factoryReset();
        
        // Now set up the configuration we actually want
        setupMotor();
    }
    
    private void setupMotor() {
        motor.setInverted(true)
             .setBrakeMode(true)
             .setMaxOutput(0.8)  // Limit to 80% power
             .setRampUp(0.5);    // Take 0.5 seconds to reach full power
    }
}

When Should You Use Factory Reset?

Factory reset is useful when:

1. You're setting up a new motor controller

2. You want to start fresh with default settings

3. You're troubleshooting motor issues

4. You're not sure what settings might have been changed before

💡 Tip: It's a good practice to call factoryReset() during your robot's initialization if you want to ensure you're starting with known default values.

⚠️ Important: Remember that after doing a factory reset, you'll need to reconfigure any special settings your robot needs. Don't just reset and forget!

There are many options to configuring on the Thrifty Nova. These can be configured in the constructor using a variety of configuration setters. These setters can be chained together to make for a very clean configuration style. The following is an example of this configuration strategy.

motor = new ThriftyNova(7)   // create with CAN ID 7
  .setInverted(true)         // reverse the motor
  .setBrakeMode(true);       // set brake mode

Configuration Error Handling

After you are done setting your configurations you can check for any errors reported from the motor controllers. The motor controller will provide a list of errors encountered while configuring values. Errors are represented by a status enum. The following examples show how to access these error codes, check for certain error codes, and clear the error list.

In this example we get a list of all errors, then iterate through the errors and printing them out.

List<Error> errors = motor.getErrors();
for (Error err : errors) {
  System.out.println(err.toString());
}

You can also check if a given error is present. Here we are checking if configuring brake mode has failed.

if (motor.hasError(Errors.SET_BRake_MODE)) {
  System.out.println("Setting brake mode has failed!");
}

You can also clear this error list. It will repopulate if more errors are encountered

motor.clearErrors();

There are two types of behaviors that the motor can take when the user specifies that it should idle. These modes are called Brake Mode and Coast Mode.

Coast Mode is the most simple behavior, and the default mode. When the motor wants to idle, power is cut from the phases, letting the kinetic energy of the motor disipate through friction until the system comes to rest.

Brake Mode turns the motor into an electric generator, which converts the kinetic energy from the system into electric energy into the circuit. It accomplishes this by shorting the phases together anytime the motor is requested to be idle.

Examples

motor.setBrakeMode(false); // keep motor in coast mode 
// ...
motor.setBrakeMode(true);  // switch to brake mode

API Details

Set the brake mode status of the motor to be either in brake mode or not in brake mode.

setBrakeMode(boolean brakeMode);

Parameters:

• inverted If the motor should be in brake mode or not.

The user can constrain the maximum forward and reverse percent output of the motor.

Examples

If you wanted some motor to only be able to apply 25% power in both directions, I could use the following.

motor.setMaxOutput(0.25); // sets 25% as limit for both directions

If you want some motor to have no constraint in going forward, but only 30% power in reverse, then you could use the second method overload.

motor.setMaxOutput(1, 0.3);

You could also specify a limit of 50% power going forward, and not let the motor drive in reverse.

motor.setMaxOutput(0.5, 0);

API Details

Set the maximum percent output.

setMaxOutput(double maxOutput);

Parameters

• maxOutput The maximum absolute output in both directions in range 0 to 1.

setMaxOutput(double maxFwd, double maxRev);

Parameters

• maxFwd The maximum forward output in range 0 to 1.

• maxRev The maximum reverse output in range 0 to 1.

Due to differences in motor phase wire colors, the Minion motor must run with a special config settable in Thrifty Config. This will allow teams to run either REV motors or CTRE motors without changing phase wires.

To change this on Thrifty Config:

Thrifty Config has a dropdown allowing users to select between the default REV option (for Neo-type motors) and the CTRE (Minion) mode.

To change this via the API:

Basic Setup

javaCopy// For a NEO motor (default)
ThriftyNova neoMotor = new ThriftyNova(1);  // CAN ID 1

// For a Minion motor
ThriftyNova minionMotor = new ThriftyNova(2, ThriftyNova.MotorType.MINION);  // CAN ID 2

Example Application

javaCopypublic class RobotContainer {
    private ThriftyNova flywheel = new ThriftyNova(1);       // NEO for high-speed flywheel
    private ThriftyNova climber = new ThriftyNova(2, ThriftyNova.MotorType.MINION);  // Minion for climbing
    
    public RobotContainer() {
        // Configure flywheel for high speed
        flywheel.setMaxOutput(1.0)
                .setCurrentLimit(CurrentType.STATOR, 40);
                
        // Configure climber for high torque
        climber.setCurrentLimit(CurrentType.STATOR, 60)
               .setBrakeMode(true);
    }
}

You can also change motor types after initialization:

motor.setMotorType(ThriftyNova.MotorType.NEO);     // Switch to NEO
motor.setMotorType(ThriftyNova.MotorType.MINION);  // Switch to Minion

⚠️ Important: Always verify your motor type matches your physical hardware before running your robot.

The user can specify the amount of time the motor should take to ramp up to full power and to ramp down to idle. The maximum amount of time is 10 seconds.

Examples

To set the motor to ramp up to 100% from idle over a period of 2s, use the following method.

motor.setRampUp(2);

To set the motor to ramp up to idle from 100% output over a period of 3.75s, use the following method.

motor.setRampDown(3.75);

API Details

Set Ramp Up

Sets the time to ramp up in seconds from 0 to 10. For example, an input of 0.5 will ramp the motor from idle to 100% over the course of 0.5 seconds.

setRampUp(double rampUp)

Parameters:

• rampUp The ramp up time.

Set Ramp Down

Sets the time to ramp down in seconds from 0 to 10. For example, an input of 0.5 will ramp the motor from 100% to idle over the course of 0.5 seconds.

setRampDown(double rampDown)

Parameters:

• rampDown The ramp up time.

Hard limits can be configured by connecting limit switches to the Thrifty Nova. Call the enableHardLimits method to enable limit switch hard limits.

Examples

Enable the hard limits.

motor.enableHardLimits(true); 

Disable the hard limits.

motor.enableHardLimits(false); 

API Details

Enable / disable hard limits.

enableHardLimits(boolean enable)

Parameters:

• enable If hard limits should be enabled.

Hard limits work through physical switches or sensors connected to your motor controller's 10-pin connector. When you hit the switch or trigger the Hall effect sensor at the end of your mechanism's travel, it immediately cuts power to the motor to prevent damage. Think of these as your last line of defense - they're your fail-safe that physically prevents the motor from pushing past its mechanical limits even if your code or soft limits somehow fail. You'll typically wire normally-closed limit switches or Hall effect sensors to these pins, so if a wire gets disconnected, the motor will safely stop instead of potentially running past its limits. These are especially important on mechanisms like elevators or arms where running past the end of travel could cause serious damage.

One configuration that can be easily changed is the direction the motor turns forward. This can be set using the following method, and by providing a boolean for weather or not the motor should be inverted.

Examples

motor.setInverted(false); // default settting
// ...
motor.setInverted(true);  // swap "forward" and "reverse" 

Method Details

Set the inversion status of the motor to be either inverted or not inverted.

setInverted(boolean inverted);

Parameters:

• inverted If the motor be inverted or not.

The Thrifty Nova supports follower mode, allowing one motor controller to mirror the behavior of another. This is useful for mechanisms that need multiple synchronized motors, like a drive train or elevator.

Basic Usage

To make a motor follow another:

// Create two motor controllers
ThriftyNova leader = new ThriftyNova(1);    // CAN ID 1
ThriftyNova follower = new ThriftyNova(2);  // CAN ID 2

// Make motor 2 follow motor 1
follower.follow(1);  // Pass the CAN ID of the leader

Configuration Example

Followers can be configured like any other motor. Here's a typical setup for a drive train:

ThriftyNova leftLeader = new ThriftyNova(1)
    .setBrakeMode(true)
    .setMaxOutput(1.0);

ThriftyNova leftFollower = new ThriftyNova(2)
    .setBrakeMode(true)          // Match leader's brake mode
    .setMaxOutput(1.0)           // Match leader's max output
    .setInverted(false)          // Match leader's inversion
    .follow(leftLeader.getDeviceID());  // Follow left leader

Important Notes

• The follower will mirror whatever control mode the leader is using (percent output, position, velocity)

• Follower updates depend on the fault status frame rate - slower rates mean slower follower updates

• A motor can only follow one leader at a time

• If you call other control methods (like setPercent()) on a follower, it will stop following

Error Handling

Like other configurations, you can check if setting up follower mode failed:

if (motor.hasError(Error.SET_FOLLOWER_ID)) {
    System.out.println("Failed to set up follower mode!");
}

Soft limits are positions on the motor's encoder that the motor will not pass. This allows you to constrain motion between two points, helpful in many mechanisms where overrotation or overextension are dangerous.

Examples

First you must set the soft limits, the following constrains the motor between -18 and 24 encoder ticks.

motor.setSoftLimits(-18, 24); 

This example constrains the motor between 3 and 9 encoder ticks.

motor.setSoftLimits(3, 9); 

Then one must physically enable the soft limits to take effect.

motor.enableSoftLimits(true); 

You can also turn off soft limts, but still leave the limits configured on the motor controller.

motor.enableSoftLimits(false); 

API Details

Set Soft Limits

Sets the soft limits that the motor will not cross if soft limits are enabled.

setSoftLimits(double revLimit, double fwdLimit)

Parameters:

• revLimit The reverse position the motor will not go past.

• fwdLimit The forward position the motor will not go past.

Enable Soft Limits

Enable / disable soft limits.

enableSoftLimits(boolean enable)

Parameters:

• enable If soft limits should be enabled.

Soft limits tell your motor controller how many revolutions your motor can safely turn before it needs to stop. Unlike hard limit switches that physically cut power at the end of travel, soft limits use the motor's built-in encoder to count rotations. You set these in your controller to match your mechanism's actual range of motion - for example, if your arm can only rotate 3.5 times before it hits its mechanical stop, you'd set your soft limit to something like 3.4 rotations. This prevents your mechanism from binding up or damaging itself by trying to push past its mechanical limits. Since these are programmed into the controller itself using encoder counts, they're always enforced - you can't override them, and they'll work consistently every time.

The Thrifty Nova provides for the user to define a maximum current, where the motor will not draw any more power once a certain current threshold is crossed on either the stator or supply side.

• Stator: Uses the total draw of phase a, b, and c from the motor side.

• Supply: Uses the draw from the supply side

Think about current limits as protective boundaries - kind of like having both a speed limit and a weight limit on a bridge. Your motor controller needs two different types of these limits because of how brushless motors work.

When your motor is running slowly or just starting up, something interesting happens - the windings inside the motor (stator) can actually draw more current than what's coming from your battery. This gets especially important in pushing matches or when your motor is nearly stalled. Imagine your robot is in a head-to-head pushing match - your motors are working super hard but barely moving. In these near-stall conditions, they're pulling tons of current through their windings while hardly drawing anything from the battery. Without both limits in place, you could easily cook your motors without even realizing it. That's why we need both a supply current limit (protecting your battery) and a stator current limit (protecting the motor's insides). This dual protection becomes crucial when you're running at those really low speeds or in tough pushing situations.

For the Neo 550 - since it's one of the smaller motors in the family - you'll want to keep those current limits between 25-30 amps. Yes, your controller might be set to 40 amps by default, but that's too much for these little guys. The full-size Neo motors are different - they can handle brief bursts up to 60 amps, but you'll still want to keep them around 40 amps for normal match use to avoid burning them up.

Examples

To set a limit of 24 amps on stator side.

motor.setMaxCurrent(CurrentType.STATOR, 24);

To set a limit of 60 amps on stator side.

motor.setMaxCurrent(CurrentType.STATOR, 60);

To set a limit of 50 amps on supply side.

motor.setMaxCurrent(CurrentType.SUPPLY, 50);

API Details

Set the max current the motor can draw in amps. Motor speed will be capped to satisfy the max current. Also set what current reading is used for limiting calculations, between:

setMaxCurrent(CurrentType currentType, double maxCurrent)

Parameters:

• currentType The current reading used for limiting calculations.

• maxCurrent The max current.

You can reset the encoder on the Thrifty Nova to be at some specific value. The current position of the encoder will real as the set value, and all the other readings will be adjusted accordingly. The position needs to be passed in encoder units, so it can be wise to use conversions.

Encoder Types

The Thrifty Nova supports three types of encoders, each with different capabilities:

Setting Up Encoders

First, tell the motor which encoder type you're using:

javaCopy// Select which encoder to use for feedback
motor.useEncoderType(EncoderType.INTERNAL);  // Built-in NEO encoder
motor.useEncoderType(EncoderType.QUAD);      // External quadrature encoder
motor.useEncoderType(EncoderType.ABS);       // External absolute encoder

Usage Examples

The following example sets the encoder to be currently at the zero position.

myEncoder.setEncoderPosition(0);

And this example sets the current position to read as 21 encoder units.

myEncoder.setEncoderPosition(21);

API Details for setEncoderPosition

Sets the encoder position.

setEncoderPosition(double position)

Parameters:

• position The position to set the encoder to.