# Attempting lowest speed possible, motors won't move in opposite direction.

### Forums:

Hey there, I recently picked up a YetiBorg and I am attempting to use it as a Camera Dolly. This requires really low speeds in order to get the smooth tracking shots I am hoping to get.

I have it working really well when sending a negative value to the motors. I can send a value as low as -0.06, and it crawls along perfectly, really slowly. For example:

`ZB.SetMotor1(-0.06)`

But if I send a positive value to the motors (attempting to drive the opposite direction), it won't even move unless the value is at least 0.7. So it requires a minimum value like this:

`ZB.SetMotor1(0.7)`

That is a much higher speed (notice the decimal point is shifted by a tenth).

The motors being used here are these:
https://www.piborg.org/motors-mounts-and-wheels-1140/piborg-motor-12v-10...

After quite a bit of testing and reading about similar issues, I discovered that this seems to be expected. The motors must simply have more resistance when going in one direction than the other.

If that's true, since there are 4 motors available for use, I am thinking of flipping the back 2 motors around, so that sending a negative value to them drives the Yeti in the opposite direction from the front motors. This way, I would only ever pass negative values to the motors. The motors which are "backwards" would simply be set to off. Here's a code example:

To go "Forward":

```ZB.SetMotor2(-0.06) # Front right
ZB.SetMotor3(-0.06) # Front left
ZB.SetMotor1(0)      # Rear left   (Flipped motor around)
ZB.SetMotor4(0)      # Rear right (Flipped motor around)
```

To go "Backward":

```ZB.SetMotor2(0)      # Front right
ZB.SetMotor3(0)      # Front left
ZB.SetMotor1(-0.06) # Rear left   (Flipped motor around)
ZB.SetMotor4(-0.06) # Rear right (Flipped motor around)
```

The problem with this approach is that the motors lock up, even when they are off. They don't really "lock", but they always have resistance, and this prevent the Yeti from moving at all.

To solve that, I am thinking of add a one-way bearing to each of the wheels, allowing them to free-wheel when going "backwards", but will still drive when spinning "forwards". These bearings are the cheapest I could find on Amazon, and I believe they require a 6mm shaft:
https://www.amazon.ca/gp/product/B081V7CY6H/ref=ox_sc_act_title_3?smid=A...

Since this motor has a 4mm shaft I believe I would need to step up to a 6mm shaft using something like this as well:

https://www.amazon.ca/gp/product/B07P6XB62M/ref=ox_sc_act_title_2?smid=A...

If anyone has any thoughts on anything I might be missing, that would be great. To re-iterate, my main problem is that I need slow speeds, and the motor won't actually move at a slow speed in the opposite direction.

### I might have a software solution

I am not entirely sure, but from memory it might be possible to get the motors which are the wrong way to free-wheel by giving them a very small value.

I do not remember if it needs to be positive or negative, but for forward it would either be:

```ZB.SetMotor2(-0.06) # Front right
ZB.SetMotor3(-0.06) # Front left
ZB.SetMotor1(-0.004)      # Rear left   (Flipped motor around)
ZB.SetMotor4(-0.004)      # Rear right (Flipped motor around)
```

or

```ZB.SetMotor2(-0.06) # Front right
ZB.SetMotor3(-0.06) # Front left
ZB.SetMotor1(0.004)      # Rear left   (Flipped motor around)
ZB.SetMotor4(0.004)      # Rear right (Flipped motor around)
```

Any lower than 0.004 will not work as it will be treated as zero.