I know how to convert degrees of wheels to inches, but I was wondering if there is a similar method for gears to degrees in terms of a protractor.

This is the same thing as this

If Iâ€™m interpreting your question correctly, a degree is a **rotational measurement of a change in angle**. Are you asking how to measure the physical change in angle of a gear translated to an arm? Not sure what exactly youâ€™re asking, but degrees are *degrees* regardless of the application. The same is true for radians.

The basic idea of turning the number of degrees something has turned into a distance is to find the length of the arc of that number of degrees along the circumference of the circle.

The way to do that is to multiply by a ratio that is equivalent to 1. For example, we can use a ratio to say that there are `4*pi inches in 360`

degrees (hypothetical case for a 4 inch wheel/gear). Then we simply multiply by the number of degrees youâ€™re wanting to convert into a distance. If that was 180 degrees, or half a rotation, we multiply `180 degrees * (4*pi inches/ 360 degrees)`

to get an answer of 2*pi inches.

Overall, the basic idea is that we find the length of whatever distance a point on the edge of a wheel/gear will travel when the gear/wheel is rotated a certain number of degrees.

Edit: Only after writing this did I realize that you may have meant how to solve for the angular displacement in gear systems?

Ah, if this is what @warbots_programmer is referring to, then yes. I 100% agree with this statement.

I want to convert the degrees that the motor reads into degrees in terms of arm movement

If thatâ€™s the case, what @Aditya_Narayanan said still applies. But youâ€™d simply use the gear reduction to calculate the angular displacement (disregard the translational calculation that deals with arc length).

So, essentially, say the motor returns a value of `360`

degrees, and you have a `1:7`

reduction. Youâ€™d simply multiply the motor output by the reduction: `360 * (1/7)`

. Calculating the reduction is simply a matter of finding the input gear and dividing it by the output gear. **Compound reductions** are a bit more complicated, but the same concept applies. Youâ€™d just multiply a *chain* of ratios to get the end reduction.

Edit: Gear ratio is calculated by dividing the number of teeth on output gear by the input gear.

Is the reduction the same as the gear ratio?

Yes, these words are used interchangeably often. Gear ratio is more practical because it applies to both increases in speed or torque while reduction implies only an increase in torque. I assumed you were referring to a torque reduction because you asked about an arm on a subsystem.

So since I have a motor on a 12 tooth gear, and there is an 84 tooth gear next to it, does that make the gear ratio 1:7 or 7:1?

7:1 â€“â€“ 84:12 reduces to 7:1. It is `output gear/input gear`

. Sorry, I made a mistake in the previous statement, this is what I meant to say. So for every `7`

rotations of the driven gear (connected to the motor), the output gear will turn `1`

time.

Ok thanks for your help.

Would my code be like that or what do I need to change

For the moveLift and what is above it

Two things, post your code in text format on the forum next time so I can point out specific things. When doing so, press on the â€śpre-formatted textâ€ť icon above the text bar.

`.spinFor(double rotation, rotationUnits units, double velocity, velocityUnits units_v, bool waitForCompletion=true)`

These are the parameters for the function you are using. Specifically, the first paramter is what I think youâ€™re confusing. Why do you want to measure the arc length the arm travels? Youâ€™d have to factor in the length of the arm as well because that is technically the radius. Rather, you should be trying to calculate the *angular displacement* of the arm.

Youâ€™d do that by setting the first parameter in `.spinFor`

to `inches*gearReduction`

. Before you do that, you instantiate a new variable,`gearReduction`

and initialize it to `= 1/7`

.

Now your code should look a little something like:

```
void moveLift(float degrees, int speed){
.spinFor(degrees*gearReduction, ...)
}
```

If you were wanting to use the moveLift function to command your lift based on the vertical distance it travels (ex. from a height of 0 inches to 10 inches), this method is going to give you some error. This is because the vertical change in height is not the same as the length of the arc traced out by the arm. Furthermore, if you were wanting to use this function in an autonomous routine, the fact that there is going to be this error is going to make things hard to write out, as the error is not directly proportional to the vertical distance (you canâ€™t correct for it by multiplying by a constant).