# Encoder Navigation - Blocks

In the previous section you learned about how to use Elapsed Time to allow your robot to navigate the world around it autonomously. When starting out many of the robot actions can be accomplished by turning on a motor for a specific amount of time. Eventually, these time-based actions may not be accurate or repeatable enough. Environmental factors, such as the state of battery charge during operation and mechanisms wearing in through use, can all affect time-based actions. Fortunately, there is a way to give feedback to the robot about how it is operating by using sensors; devices that are used to collect information about the robot and the environment around it.

With Elapsed Time, in order to get the robot to move to a specific distance, you had to estimate the amount of time and the percentage of duty cycle needed to get from point a to point b. However, the REV motors come with built in encoders, which provide feedback in the form of ticks ( or counts) per revolution of the motor. The information provided by the encoders can be used to move the motor to a target position, or a target distance.

Moving the motors to a specific position, using the encoders, removes any potential inaccuracies or inconsistencies from using Elapsed Time. The focus of this section is to move the robot to a target position using encoders.

There are two articles in that go through the basics of Encoders. Using Encoders goes through the basics of the different types of motor modes, as well as a few application examples of using these modes in code. In this section we will focus on using `RUN_TO_POSITION`

.

The other article, Encoders, focuses on the general functionality of an encoder.

It is recommended that you review both articles before moving on with this guide.

## Basics of Programming with Encoders

Start by creating a basic op mode called HelloRobot_EncoderAuton.

When creating an op mode a decision needs to be made on whether or not to set it to autonomous mode. For applications under 30 seconds, typically required for competitive game play changing the op mode type to autonomous is recommended. For applications over 30 seconds, setting the code to the autonomous op mode type will limit your autonomous code to 30 seconds of run time. If you plan on exceeding the 30 seconds built into the SDK, keeping the code as a teleoperated op mode type is recommended.

For information on how op modes work please visit the Introduction to Programming section.

For more information on how to change the op mode type check out the Test Bed - Blocks section.

For more information on the directionality of motor check out the Basics of Programming Drivetrains section.

Save and run the op mode two times in a row. Does the robot move as expected the second time?

Try turning the Control Hub off and then back on. How does the robot move?

For more information on the motor mode `STOP_AND_RESET_ENCODERS`

check out the STOP_AND_RESET_ENCODERS section of the Using Encoders guide.

### Converting Encoder Ticks to a Distance

Rather than attempt to measure, or estimate, the distance the robot moves, the encoder ticks can be converted from amount of ticks per revolution of the encoder to how many encoder ticks it takes to move the robot a unit of distance, like a millimeter or inch. Knowing the amount of ticks per a unit of measure allows you to set a specific distance. For instance, if you work through the conversion process and find out that a drivetrain takes 700 ticks to move an inch, this can be used to find the total number of ticks need to move the robot 24 inches.

Reminder that the basis for this guide is the Class Bot V2. The REV DUO Build System is a metric system. Since part of the conversion process references the diameter of the wheels, this section will convert to ticks per mm.

When using encoders built into motors, converting from ticks per revolution to ticks per unit of measure moved requires the following information:

Ticks per revolution of the encoder shaft

Total gear reduction on the motor

Including gearboxes and motion transmission components like gears, sprockets and chain, or belts and pulleys

Circumference of the driven wheels

#### Ticks per Revolution

The amount of ticks per revolution of the encoder shaft is dependent on the motor and encoder. Manufacturers of motors with built-in encoders will have information on the amount of ticks per revolution. For HD Hex Motors the encoder counts 28 ticks per revolution of the motor shaft.

Visit the manufacturers website for your motor or encoders for more information on encoder counts. For HD Hex Motors or Core Hex Motors visit the Motor documentation.

#### Total Gear Reduction

Since ticks per revolution of the encoder shaft is before any gear reduction calculating the total gear reduction is needed. This includes the gearbox and any addition reduction from motion transmission components. To find the total gear reduction use the Compound Gearing formula.

For the Class Bot V2 there are two UltraPlanetary Cartridges, 4:1 and 5:1, and an additional gear reduction from the UltraPlanetary Output to the wheels, 72T:45T ratio.

The UltraPlanetary Cartridges use the nominal gear ratio as a descriptor. The actual gear ratios can be found in the UltraPlanetary Users Manual's Cartridge Details.

Using the compound gearing formula for the Class Bot V2 the total gear reduction is:

Unlike the the spur gears used to transfer motion to the wheels, the UltraPlanetary Gearbox Cartridges are planetary gear systems. To make calculations easier the gear ratios for the Cartridges are already reduced.

#### Circumference of the Wheel

The Class Bot V2 uses the 90mm Traction Wheels. 90mm is the diameter of the wheel. To get the appropriate circumference use the following formula

You can calculate this by hand, but for the purpose of this guide, this can be calculated within the code.

Due to wear and manufacturing tolerances, the diameter of some wheels may be nominally different. For the most accurate results consider measuring your wheel to confirm that the diameter is accurate.

To summarize, for the Class Bot V2 the following information is true:

Ticks per revolution | 28 ticks |

Total gear reduction | 30.21 |

Circumference of the wheel | $90mm * \pi$ |

Each of these pieces of information will be used to find the number of encoder ticks (or counts) per mm that the wheel moves. Rather than worry about calculating this information by hand, these values can be added to the code as constant variables. To do this create three variables:

`COUNTS_PER_MOTOR_REV`

`DRIVE_GEAR_REDUCTION`

`WHEEL_CIRCUMFERENCE_MM`

The common naming convention for constant variables is known as CONSTANT_CASE, where the variable name is in all caps and words are separated by and underscore.

Add the variables to the initialization section of the op mode.

Now that these three variables have been defined, we can use them to calculate two other variables: the amount of encoder counts per rotation of the wheel and the number of counts per mm that the wheel moves.

To calculate counts per wheel revolution multiple`COUNTS_PER_MOTOR_REV`

by `DRIVE_GEAR_REDUCTION`

Use the following formula:

Where,

$a$ =

`COUNTS_PER_MOTOR_REV`

$b$ =

`DRIVE_GEAR_REDUCTION`

$y$ =

`COUNTS_PER_WHEEL_REV`

Once `COUNTS_PER_WHEEL_REV`

is calculated, use it to calculate the counts per mm that the wheel moves. To do this divide the`COUNTS_PER_WHEEL_REV`

by the `WHEEL_CIRCUMFERENCE_MM`

. Use the following formula.

Where,

$a$ =

`COUNTS_PER_MOTOR_REV`

$b$ =

`DRIVE_GEAR_REDUCTION`

$c$ =

`WHEEL_CIRCUMFERENCE_MM`

$y$ =

`COUNTS_PER_WHEEL_REV`

$x$ =

`COUNTS_PER_MM`

`COUNTS_PER_WHEEL_REV`

will be created as a separate variable from`COUNTS_PER_MM`

as it is used in calculating a target velocity.

Create these variables in Blocks and add then to the op mode under the other constant variables.

Once`COUNTS_PER_WHEEL_MM`

is set, this completes the conversion process, and all constant variables are set.

### Moving to a Target Distance

Now that you have created the constant variables needed to calculate the amount of ticks per mm moved, you can use this to set a target distance. For instance, if you would like to have the robot move forward two feet, converting from feet to millimeters and multiplying by the `COUNTS_PER_MM`

will give you the amount of counts (or ticks) needed to reach that distance.

Right now the main distance factor is `COUNTS_PER_MM`

, however you may want to go a distance that is in the imperial system, such as 2 feet (or 24 inches). The target distance in this case will need to be converted to mm. To convert from feet to millimeters use the following formula:

If you convert 2 feet to millimeters, it comes out the be 609.6 millimeters. For the purpose of this guide, lets go ahead an round this to be 610 millimeters. Multiply 610 millimeters by the`COUNTS_PER_MM`

variable to get the number of ticks needed to move the robot 2 feet. Since the intent is to have the robot move in a straight line, set both the `leftTarget`

and `rightTarget`

, to be equal to 610 * `COUNTS_PER_MM`

### Setting Velocity

Velocity is a closed loop control within the SDK that uses the encoder counts to determine the approximate power/speed the motors need to go in order to meet the set velocity. When working with encoder setting a velocity is recommended over setting a power level, as it offers a higher level of control.

To set a velocity, its important to understand the maximum velocity in RPM your motor is capable of. For the Class Bot V2 the motors are capable of a maximum RPM of 300. With a drivetrain, you are likely to get better control by setting velocity lower than the maximum. In this case, lets set the velocity to 175 RPM

Recall that `setVelocity`

is measure in ticks per second.

Since RPM is the amount of revolutions per minute a conversion needs to be made from RPM to ticks per second. To do this divide the RPM by 60, to get the amount of rotations per second. Rotations per second can the be multiplied by `COUNTS_PER_WHEEL_REV`

, to get the amount of ticks per second.

With the velocity set, this is the final thing needed to complete the objective of driving in a straight line. Consider adding telemetry and other hardware components as you begin fleshing out your full autonomous code.

### Turning the Drivetrain Using RUN_TO_POSITION

Since speed an directionality impacts how a robot turns, target position and velocity need to be edited to get the robot to turn. Consider the following code:

The `rightTarget`

has been changed to be a negative target position. Assuming that the encoder starts at zero due to `STOP_AND_RESET_ENCODER`

this causes the robot to turn to the right. Velocity is the same for both motors. If you try running this code, you may notice that the robot pivots along its center of rotation. To get a wider turn changing the velocity so that the right motor is running at a lower velocity than the left motor. Adjust the velocity and target position as needed to get the turn you need.

Last updated