Using Encoder to Drive a Certain Distance

Hi I am looking for some resources and places to get start to use one encoder to drive a certain distance during autonomous. I found this link It has been slightly helpful with understanding how the encoder works and got me started. Here’s what I have so far. Our team will be getting a second encoder soon, I hope I can still get this working with just the one encoder for now. Thanks!

public class Robot extends IterativeRobot {
	RobotDrive tankDrive = new RobotDrive(0, 1);
	Encoder encoder = new Encoder(0, 1, true, EncodingType.k4X);

	double desiredDistance = 1;

	public void robotInit() {


	public void autonomousInit() {
		 * What I want is for the robot to drive one foot. I am certain that I
		 * am going to have to do some calculations. We are using 8" pneumatic
		 * wheels.

	public void autonomousPeriodic() {
		double encodersReading = encoder.get();
		tankDrive.arcadeDrive(0.25, 0);
		if (encodersReading > desiredDistance) {
			tankDrive.arcadeDrive(0, 0);


Remember to use the encoder reset, and start function when initializing (This was a mistake my team made when first getting into them). It looks as though you have all you need other than that though. Just use if statements to progress through your autonomous when target distances are met. best of luck

Also, be careful about what encoders you use. The standard andymark encoders are very… finicky. Make sure if you use them, you don’t EVER have to disassemble the drive system. (don’t take them off)

Just curious about the set distance per pulse function. Is this function the ratio between how far each pulse will take the robot?

For example if I were to calculate the circumference of the wheel (in inches). Then divide the circumference of the wheel by the number of pulses in a full revolution (which is 1440 I think if I am using x4 encoding). Then set the distance per pulse to the circumference/number of pulses in one revolution would it make one full revolution move the robot one inch?

Sorry if this is not clear enough I can try to clarify if it makes zero sense.

That’s the right process. However, wpilib normalizes pulses, so it won’t change by decoding type. You should use 360 pulses in a full revolution, but it will increment in 1/4 increments in 4x mode. In addition, you’ll want to take into account any gearing between the encoder and the wheel.

	//Encoder Distance Constants
    public static final double wheelDiameter = 6;
    public static final double pulsePerRevolution = 360;
    public static final double encoderGearRatio = 3;
    public static final double gearRatio = 64.0/20.0;
    public static final double Fudgefactor = 1.0;

final double distanceperpulse = Math.PI*wheelDiameter/pulsePerRevolution /
        		encoderGearRatio/gearRatio * Fudgefactor;

Thanks so much this helped clarify things greatly. I just have two questions. First, I am trying to figure out if I should be using the k4x or k1x I am not sure I understand that 1/4 increments part you were speaking about. I was wondering if I needed to use k4x or k1x for this math. Second, I am trying to figure out what the encoderGearRatio double is for. Does it have to do with the shaft the encoder is mounted on. Thanks.

It does not matter which one you use. The scaling is the same. The only thing that changes is you get 4x the resolution when you choose k4x.

Yes. That year we used the VexPro Ball Shifters. There was a 3:1 ratio between the encoder and the shaft.

Okay perfect just one final question :smiley: . Our encoder is mounted onto the shaft from the KOP toughboxes. I don’t think there is any gear ratio for the encoder however there is one for the motors (TB Mini Gearbox for AM14U, 10.71:1 Ratio ) so will I need to include a encoderGearRatio?


Just tested the code and I the number I was getting from the encoder very off. I was trying to travel 36 inches but at the 36 inch mark the encoder is reading about 1.26.

This is the manual to the drive train we are using currently just to get things rolling. If you jump to page 4 it will tell you the gear ratio specifics. We are using the included 4 inch wheels.

I am having a hard time finding the exact model of encoder we are using. It is very similar to this: E4T OEM Miniature Optical Encoder Kit - AndyMark, Inc It’s just an optical encoder that we got in 2014.

Here is snippets of the code everything that I am doing with the encoder is included below.

public class Robot extends IterativeRobot {	
	RobotDrive tankDrive = new RobotDrive(0, 1);
	Encoder encoder = new Encoder(0, 1, true, EncodingType.k4X);

	public static final double WHEEL_DIAMETER = 4;
	public static final double PULSE_PER_REVOLUTION = 360;
	public static final double ENCODER_GEAR_RATIO = 0;
	public static final double GEAR_RATIO = 8.45 / 1;
	public static final double FUDGE_FACTOR = 1.0;

        public void autonomousInit() {	
                final double distancePerPulse = Math.PI * Defines.WHEEL_DIAMETER / Defines.PULSE_PER_REVOLUTION


	public void autonomousPeriodic() {
	        double encoderDistanceReading = encoder.getDistance();
		SmartDashboard.putNumber("encoder reading", encoderDistanceReading);, 0);
		if (encoderDistanceReading > 36) {, 0);

I know this is over a year old but I’m doing the same thing right now and, just in case you didn’t notice, you have a divide-by-zero in this code. Your ENCODER_GEAR_RATIO should be ‘1’ not ‘0’.

I was borrowing your conversion method since we’re using the same drivetrain but with 6" wheels this year and noticed the bug.

Note that when you use setDistancePerPulse you want to use 1 / the number of pulses per count value.
What I mean is, if you want for every revolution, the encoder’s output will be one, if the number of pulses per rotation is 5, you’ll want to set the distancePerPulse to 1/5, so that every pulse will produce 1/5 of the rotation, thus after 5 pulses, you will know you have rotated 1 rotation. If I’m not clear let me know and I’ll explain myself farther.