Class MoveDifferential

ev3dev2.motor.MoveDifferential

MoveDifferential is a child of MoveTank that adds the following capabilities:

Declaration

class MoveDifferential(MoveTank)

source link

Documentation

drive in a straight line for a specified distance
rotate in place in a circle (clockwise or counter clockwise) for a specified number of degrees
drive in an arc (clockwise or counter clockwise) of a specified radius for a specified distance

Odometry can be use to enable driving to specific coordinates and rotating to a specific angle.

New arguments:

wheel_class - Typically a child class of :class:`ev3dev2.wheel.Wheel`. This is used to get the circumference of the wheels of the robot. The circumference is needed for several calculations in this class.

System Message: ERROR/3 (<string>, line 14); backlink

Unknown interpreted text role "class".

wheel_distance_mm - The distance between the mid point of the two wheels of the robot. You may need to do some test drives to find the correct value for your robot. It is not as simple as measuring the distance between the midpoints of the two wheels. The weight of the robot, center of gravity, etc come into play.

You can use utils/move_differential.py to call on_arc_left() to do some test drives of circles with a radius of 200mm. Adjust your wheel_distance_mm until your robot can drive in a perfect circle and stop exactly where it started. It does not have to be a circle with a radius of 200mm, you can test with any size circle but you do not want it to be too small or it will be difficult to test small adjustments to wheel_distance_mm.

Example:

from ev3dev2.motor import OUTPUT_A, OUTPUT_B, MoveDifferential, SpeedRPM
from ev3dev2.wheel import EV3Tire

STUD_MM = 8

# test with a robot that:
# - uses the standard wheels known as EV3Tire
# - wheels are 16 studs apart
mdiff = MoveDifferential(OUTPUT_A, OUTPUT_B, EV3Tire, 16 * STUD_MM)

# Rotate 90 degrees clockwise
mdiff.turn_right(SpeedRPM(40), 90)

# Drive forward 500 mm
mdiff.on_for_distance(SpeedRPM(40), 500)

# Drive in arc to the right along an imaginary circle of radius 150 mm.
# Drive for 700 mm around this imaginary circle.
mdiff.on_arc_right(SpeedRPM(80), 150, 700)

# Enable odometry
mdiff.odometry_start()

# Use odometry to drive to specific coordinates
mdiff.on_to_coordinates(SpeedRPM(40), 300, 300)

# Use odometry to go back to where we started
mdiff.on_to_coordinates(SpeedRPM(40), 0, 0)

# Use odometry to rotate in place to 90 degrees
mdiff.turn_to_angle(SpeedRPM(40), 90)

# Disable odometry
mdiff.odometry_stop()

Methods

▶ def __init__(self, left_motor_port, right_motor_port, wheel_class, wheel_distance_mm, ...) override
inherited doc motor_specs is a dictionary such as
def __init__(
self,
left_motor_port,
right_motor_port,
wheel_class,
wheel_distance_mm,
desc=None,
motor_class=LargeMotor,
)
source link
This method overrides ev3dev2.motor.MoveTank.__init__.
{
OUTPUT_A : LargeMotor, OUTPUT_C : LargeMotor,
System Message: WARNING/2 (<string>, line 4)
Definition list ends without a blank line; unexpected unindent.
}
▷ def odometry_coordinates_log(self)
source link
▶ def odometry_start(self, theta_degrees_start=90.0, x_pos_start=0.0, y_pos_start=0.0, ...)
Ported from: http://seattlerobotics.org/encoder/200610/Article3/IMU%20Odometry,%20by%20David%20Anderson.htm
def odometry_start(
self,
theta_degrees_start=90.0,
x_pos_start=0.0,
y_pos_start=0.0,
sleep_time=0.005,
)
source link
A thread is started that will run until the user calls odometry_stop() which will set odometry_thread_run to False
▷ def odometry_stop(self)
Signal the odometry thread to exit
source link
▷ def on_arc_left(self, speed, radius_mm, distance_mm, brake=True, block=True)
Drive counter-clockwise in a circle with 'radius_mm' for 'distance_mm'
source link
▷ def on_arc_right(self, speed, radius_mm, distance_mm, brake=True, block=True)
Drive clockwise in a circle with 'radius_mm' for 'distance_mm'
source link
▷ def on_for_distance(self, speed, distance_mm, brake=True, block=True)
Drive in a straight line for ``distance_mm``
source link
▷ def on_to_coordinates(self, speed, x_target_mm, y_target_mm, brake=True, block=True)
Drive to (``x_target_mm``, ``y_target_mm``) coordinates at ``speed``
source link
▶ def turn_degrees(self, speed, degrees, brake=True, block=True, error_margin=2, use_gyro=False) override
Rotate in place ``degrees``. Both wheels must turn at the same speed for us
source link
This method overrides ev3dev2.motor.MoveTank.turn_degrees.
to rotate in place. If the following conditions are met the GryoSensor will be used to improve the accuracy of our turn: - use_gyro, brake and block are all True - A GyroSensor has been defined via self.gyro = GyroSensor()
▶ def turn_left(self, speed, degrees, brake=True, block=True, error_margin=2, use_gyro=False) override
Rotate counter-clockwise ``degrees`` in place
source link
This method overrides ev3dev2.motor.MoveTank.turn_left.
▶ def turn_right(self, speed, degrees, brake=True, block=True, error_margin=2, use_gyro=False) override
Rotate clockwise ``degrees`` in place
source link
This method overrides ev3dev2.motor.MoveTank.turn_right.
▶ def turn_to_angle(self, speed, angle_target_degrees, brake=True, block=True, error_margin=2, ...)
Rotate in place to ``angle_target_degrees`` at ``speed``
def turn_to_angle(
self,
speed,
angle_target_degrees,
brake=True,
block=True,
error_margin=2,
use_gyro=False,
)
source link

Inherited methods

Methods inherited from ev3dev2.motor.MoveTank:
cs, follow_gyro_angle, follow_line, gyro, on, on_for_degrees, on_for_rotations, on_for_seconds
Methods inherited from ev3dev2.motor.MotorSet:
__str__, is_holding, is_overloaded, is_ramping, is_running, is_stalled, off, reset, run_direct, run_forever, run_timed, run_to_abs_pos, run_to_rel_pos, set_args, set_polarity, stop, wait, wait_until, wait_until_not_moving, wait_while