DifferentialPilot

java.lang.Object
- lejos.robotics.navigation.DifferentialPilot

All Implemented Interfaces:

ArcMoveController, ArcRotateMoveController, LineFollowingMoveController, MoveController, MoveProvider, RotateMoveController

Direct Known Subclasses:

CompassPilot
```
public class DifferentialPilot
extends java.lang.Object
implements LineFollowingMoveController
```
The DifferentialPilot class is a software abstraction of the Pilot mechanism of a NXT robot. It contains methods to control robot movements: travel forward or backward in a straight line or a circular path or rotate to a new direction.
This class will only work with two independently controlled motors to steer differentially, so it can rotate within its own footprint (i.e. turn on one spot). It registers as a RegulatedMotorListener with each of its motors. An object of this class assumes that it has exclusive control of its motors. If any other object makes calls to its motors, the results are unpredictable.
This class can be used with robots that have reversed motor design: the robot moves in the direction opposite to the the direction of motor rotation. .
It automatically updates a OdometryPoseProvider which has called the addMoveListener method on this object.
Some methods optionally return immediately so the thread that called it can do things while the robot is moving, such as monitor sensors and call stop().
Handling stalls: If a stall is detected, isStalled() returns true, isMoving() returns false, moveStopped() is called, and, if a blocking method is executing, that method exits. The units of measure for travel distance, speed and acceleration are the units used in specifying the wheel diameter and track width in the constructor.
In all the methods that cause the robot to change its heading (the angle relative to the X axis in which the robot is facing) the angle parameter specifies the change in heading. A positive angle causes a turn to the left (anti-clockwise) to increase the heading, and a negative angle causes a turn to the right (clockwise).
Example of use of come common methods:
```
 DifferentialPilot pilot = new DifferentialPilot(2.1f, 4.4f, Motor.A, Motor.C, true);  // parameters in inches
 pilot.setRobotSpeed(30);  // cm per second
 pilot.travel(50);         // cm
 pilot.rotate(-90);        // degree clockwise
 pilot.travel(-50,true);  //  move backward for 50 cm
 while(pilot.isMoving())Thread.yield();
 pilot.rotate(-90);
 pilot.rotateTo(270);
 pilot.steer(-50,180,true); // turn 180 degrees to the right
 waitComplete();            // returns when previous method is complete
 pilot.steer(100);          // turns with left wheel stationary
 Delay.msDelay(1000;
 pilot.stop();
 
```
Note: A DifferentialPilot robot can simulate a SteeringPilot robot by calling DifferentialPilot.setMinRadius() and setting the value to something greater than zero (perhaps 15 cm).

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

private class DifferentialPilot.Monitor

Nested Classes
Modifier and Type	Class and Description
`private class`	`DifferentialPilot.Monitor`

Field Summary

Fields
Modifier and Type	Field and Description
`private int`	`_acceleration` used by travel and rotate methods, and stop()
`private double`	`_angle` Angle about to turn - used by movementStopped
`private double`	`_distance` Distance about to travel - used by movementStarted
`private RegulatedMotor`	`_inside` The motor at the inside of the turn.
`protected RegulatedMotor`	`_left` Left motor..
`protected float`	`_leftDegPerDistance` Left motor degrees per unit of travel.
`private byte`	`_leftDirection` direction of rotation of left motor +1 or -1
`private int`	`_leftTC`
`private float`	`_leftTurnRatio` Left motor revolutions for 360 degree rotation of robot (motors running in opposite directions).
`private float`	`_leftWheelDiameter` Diameter of left wheel.
`private java.util.ArrayList<MoveListener>`	`_listeners`
`private DifferentialPilot.Monitor`	`_monitor` The monitor thread
`private boolean`	`_moveActive` set by rotatsionStopped() used by Monitor thread to call movementStopped()
`protected RegulatedMotor`	`_outside` The motor at the outside of the turn.
`private byte`	`_parity` Motor rotation forward makes robot move forward if parity == 1.
`private int`	`_quickAcceleration`
`protected RegulatedMotor`	`_right` Right motor.
`protected float`	`_rightDegPerDistance` Right motor degrees per unit of travel.
`private byte`	`_rightDirection` direction of rotation of right motor +1 or -1
`private int`	`_rightTC`
`private float`	`_rightTurnRatio` Right motor revolutions for 360 degree rotation of robot (motors running in opposite directions).
`private float`	`_rightWheelDiameter` Diameter of right wheel.
`private float`	`_robotRotateSpeed` Speed of robot for turning in degree per seconds.
`private float`	`_robotTravelSpeed` Speed of robot for moving in wheel diameter units per seconds.
`private float`	`_steerRatio` ratio of inside/outside motor speeds set by steer(turnRate) used by other steer methods;
`private float`	`_trackWidth` Distance between wheels.
`private float`	`_turnRadius`
`protected Move.MoveType`	`_type`

Fields inherited from interface lejos.robotics.navigation.MoveController
WHEEL_SIZE_EV3, WHEEL_SIZE_NXT1, WHEEL_SIZE_NXT2, WHEEL_SIZE_RCX

Constructor Summary

Constructors
Constructor and Description
`DifferentialPilot(double leftWheelDiameter, double rightWheelDiameter, double trackWidth, RegulatedMotor leftMotor, RegulatedMotor rightMotor, boolean reverse)` Allocates a DifferentialPilot object, and sets the physical parameters of the NXT robot.
`DifferentialPilot(double wheelDiameter, double trackWidth, RegulatedMotor leftMotor, RegulatedMotor rightMotor)` Allocates a DifferentialPilot object, and sets the physical parameters of the NXT robot. Assumes Motor.forward() causes the robot to move forward.
`DifferentialPilot(double wheelDiameter, double trackWidth, RegulatedMotor leftMotor, RegulatedMotor rightMotor, boolean reverse)` Allocates a DifferentialPilot object, and sets the physical parameters of the NXT robot.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addMoveListener(MoveListener m)` Adds a MoveListener that will be notified of all movement events.
`void`	`arc(double radius, double angle)` Moves the NXT robot along an arc with a specified radius and angle, after which the robot stops moving.
`void`	`arc(double radius, double angle, boolean immediateReturn)` Moves the NXT robot along an arc with a specified radius and angle, after which the robot stops moving.
`void`	`arcBackward(double radius)` Starts the NXT robot moving backward along an arc with a specified radius.
`void`	`arcForward(double radius)` Starts the NXT robot moving forward along an arc with a specified radius.
`void`	`backward()` Starts the NXT robot moving backward.
`private void`	`bak()` Motors backward.
`void`	`forward()` Starts the NXT robot moving forward.
`private void`	`fwd()` Motors forward.
`float`	`getAngleIncrement()`
`double`	`getAngularAcceleration()` Returns the acceleration at which the robot accelerates at the start of a move and decelerates at the end of a move.
`double`	`getAngularSpeed()` Returns the value of the rotation speed
`private int`	`getLeftCount()` Returns the tachoCount of the left motor
`double`	`getLinearAcceleration()` Returns the acceleration at which the robot accelerates at the start of a move and decelerates at the end of a move.
`double`	`getLinearSpeed()` Returns the speed at which the robot will travel forward and backward (and to some extent arcs, although actual arc speed is slightly less).
`double`	`getMaxAngularSpeed()` returns the maximum value of the rotation speed;
`double`	`getMaxLinearSpeed()` Returns the maximum speed at which this robot is capable of traveling forward and backward.
`float`	`getMaxRotateSpeed()`
`double`	`getMinRadius()` The minimum steering radius this vehicle is capable of when traveling in an arc.
`Move`	`getMovement()` Returns the move made since the move started, but before it has completed.
`float`	`getMovementIncrement()`
`private int`	`getRightCount()` Returns the tachoCount of the right motor
`double`	`getTurnRate()` Get the turn rate for arc and steer commands
`boolean`	`isMoving()` true if the robot is moving
`boolean`	`isStalled()`
`protected void`	`movementActive()` Called to indicate that the motors are now running and should be monitored for movement.
`protected void`	`movementStart()` called at start of a movement to inform the listeners that a movement has started.
`private void`	`movementStop()` called by Arc() ,travel(),rotate(),stop() rotationStopped() calls moveStopped on listener
`void`	`quickStop()` Stops the robot almost immediately.
`private double`	`radius(double turnRate)` Returns the radius of the turn made by steer(turnRate) Used in for planned distance at start of arc and steer moves.
`void`	`reset()` Resets tacho count for both motors.
`void`	`rotate(double angle)` Rotates the NXT robot through a specific angle.
`void`	`rotate(double angle, boolean immediateReturn)` Rotates the NXT robot through a specific angle.
`void`	`rotateLeft()`
`void`	`rotateRight()`
`void`	`setAngularAcceleration(double acceleration)` Sets the acceleration at which the robot will accelerate at the start of a move and decelerate at the end of a move.
`void`	`setAngularSpeed(double rotateSpeed)` sets the rotation speed of the vehicle, degrees per second
`void`	`setLinearAcceleration(double acceleration)` Sets the acceleration at which the robot will accelerate at the start of a move and decelerate at the end of a move.
`void`	`setLinearSpeed(double travelSpeed)` set travel speed in wheel diameter units per second
`void`	`setMinRadius(double radius)` Set the radius of the minimum turning circle.
`private void`	`setMotorAccel(int acceleration)` helper method for setAcceleration and quickStop
`private void`	`setSpeed(int leftSpeed, int rightSpeed)`
`void`	`steer(double turnRate)` Starts the robot moving forward along a curved path.
`void`	`steer(double turnRate, double angle)` Moves the robot along a curved path through a specified turn angle.
`void`	`steer(double turnRate, double angle, boolean immediateReturn)` Moves the robot along a curved path for a specified angle of rotation.
`void`	`steerBackward(double turnRate)` Starts the robot moving backward along a curved path.
`(package private) void`	`steerPrep(double turnRate)` helper method used by steer(float) and steer(float,float,boolean) sets _outsideSpeed, _insideSpeed, _steerRatio set motor acceleration to help continuous steer and arc moves
`void`	`stop()` Stops the NXT robot.
`void`	`travel(double distance)` Moves the NXT robot a specific distance in an (hopefully) straight line. A positive distance causes forward motion, a negative distance moves backward.
`void`	`travel(double distance, boolean immediateReturn)` Moves the NXT robot a specific distance in an (hopefully) straight line. A positive distance causes forward motion, a negative distance moves backward.
`void`	`travelArc(double radius, double distance)` Moves the NXT robot a specified distance along an arc of specified radius, after which the robot stops moving.
`void`	`travelArc(double radius, double distance, boolean immediateReturn)` Moves the NXT robot a specified distance along an arc of specified radius, after which the robot stops moving.
`private double`	`turnRate(double radius)` Calculates the turn rate corresponding to the turn radius; use as the parameter for steer() negative argument means center of turn is on right, so angle of turn is negative
`private void`	`waitComplete()` wait for the current operation on both motors to complete
`private void`	`waitForActiveMove()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - _turnRadius
```
private float _turnRadius
```
  - _left
```
protected final RegulatedMotor _left
```
    Left motor..
  - _right
```
protected final RegulatedMotor _right
```
    Right motor.
  - _inside
```
private RegulatedMotor _inside
```
    The motor at the inside of the turn. set by steer(turnRate) used by other steer methodsl
  - _outside
```
protected RegulatedMotor _outside
```
    The motor at the outside of the turn. set by steer(turnRate) used by other steer methodsl
  - _steerRatio
```
private float _steerRatio
```
    ratio of inside/outside motor speeds set by steer(turnRate) used by other steer methods;
  - _leftDegPerDistance
```
protected final float _leftDegPerDistance
```
    Left motor degrees per unit of travel.
  - _rightDegPerDistance
```
protected final float _rightDegPerDistance
```
    Right motor degrees per unit of travel.
  - _leftTurnRatio
```
private final float _leftTurnRatio
```
    Left motor revolutions for 360 degree rotation of robot (motors running in opposite directions). Calculated from wheel diameter and track width. Used by rotate() and steer() methods.
  - _rightTurnRatio
```
private final float _rightTurnRatio
```
    Right motor revolutions for 360 degree rotation of robot (motors running in opposite directions). Calculated from wheel diameter and track width. Used by rotate() and steer() methods.
  - _robotTravelSpeed
```
private float _robotTravelSpeed
```
    Speed of robot for moving in wheel diameter units per seconds. Set by setSpeed(), setTravelSpeed()
  - _robotRotateSpeed
```
private float _robotRotateSpeed
```
    Speed of robot for turning in degree per seconds.
  - _parity
```
private byte _parity
```
    Motor rotation forward makes robot move forward if parity == 1.
  - _trackWidth
```
private final float _trackWidth
```
    Distance between wheels. Used in steer() and rotate().
  - _leftWheelDiameter
```
private final float _leftWheelDiameter
```
    Diameter of left wheel.
  - _rightWheelDiameter
```
private final float _rightWheelDiameter
```
    Diameter of right wheel.
  - _leftTC
```
private int _leftTC
```
  - _rightTC
```
private int _rightTC
```
  - _listeners
```
private java.util.ArrayList<MoveListener> _listeners
```
  - _type
```
protected Move.MoveType _type
```
  - _distance
```
private double _distance
```
    Distance about to travel - used by movementStarted
  - _angle
```
private double _angle
```
    Angle about to turn - used by movementStopped
  - _acceleration
```
private int _acceleration
```
    used by travel and rotate methods, and stop()
  - _quickAcceleration
```
private int _quickAcceleration
```
  - _leftDirection
```
private byte _leftDirection
```
    direction of rotation of left motor +1 or -1
  - _rightDirection
```
private byte _rightDirection
```
    direction of rotation of right motor +1 or -1
  - _monitor
```
private DifferentialPilot.Monitor _monitor
```
    The monitor thread
  - _moveActive
```
private boolean _moveActive
```
    set by rotatsionStopped() used by Monitor thread to call movementStopped()
- Constructor Detail
  - DifferentialPilot
```
public DifferentialPilot(double wheelDiameter,
                         double trackWidth,
                         RegulatedMotor leftMotor,
                         RegulatedMotor rightMotor)
```
    Allocates a DifferentialPilot object, and sets the physical parameters of the NXT robot.
    Assumes Motor.forward() causes the robot to move forward.
    
    Parameters:
    
    wheelDiameter - Diameter of the tire, in any convenient units (diameter in mm is usually printed on the tire).
    
    trackWidth - Distance between center of right tire and center of left tire, in same units as wheelDiameter.
    
    leftMotor - The left Motor (e.g., Motor.C).
    
    rightMotor - The right Motor (e.g., Motor.A).
  - DifferentialPilot
```
public DifferentialPilot(double wheelDiameter,
                         double trackWidth,
                         RegulatedMotor leftMotor,
                         RegulatedMotor rightMotor,
                         boolean reverse)
```
    Allocates a DifferentialPilot object, and sets the physical parameters of the NXT robot.
    
    Parameters:
    
    wheelDiameter - Diameter of the tire, in any convenient units (diameter in mm is usually printed on the tire).
    
    trackWidth - Distance between center of right tire and center of left tire, in same units as wheelDiameter.
    
    leftMotor - The left Motor (e.g., Motor.C).
    
    rightMotor - The right Motor (e.g., Motor.A).
    
    reverse - If true, the NXT robot moves forward when the motors are running backward.
  - DifferentialPilot
```
public DifferentialPilot(double leftWheelDiameter,
                         double rightWheelDiameter,
                         double trackWidth,
                         RegulatedMotor leftMotor,
                         RegulatedMotor rightMotor,
                         boolean reverse)
```
    Allocates a DifferentialPilot object, and sets the physical parameters of the NXT robot.
    
    Parameters:
    
    leftWheelDiameter - Diameter of the left wheel, in any convenient units (diameter in mm is usually printed on the tire).
    
    rightWheelDiameter - Diameter of the right wheel. You can actually fit intentionally wheels with different size to your robot. If you fitted wheels with the same size, but your robot is not going straight, try swapping the wheels and see if it deviates into the other direction. That would indicate a small difference in wheel size. Adjust wheel size accordingly. The minimum change in wheel size which will actually have an effect is given by minChange = A*wheelDiameter*wheelDiameter/(1-(A*wheelDiameter) where A = PI/(moveSpeed*360). Thus for a moveSpeed of 25 cm/second and a wheelDiameter of 5,5 cm the minChange is about 0,01058 cm. The reason for this is, that different while sizes will result in different motor speed. And that is given as an integer in degree per second.
    
    trackWidth - Distance between center of right tire and center of left tire, in same units as wheelDiameter.
    
    leftMotor - The left Motor (e.g., Motor.C).
    
    rightMotor - The right Motor (e.g., Motor.A).
    
    reverse - If true, the NXT robot moves forward when the motors are running backward.
- Method Detail
  - getLeftCount
```
private int getLeftCount()
```
    Returns the tachoCount of the left motor
    
    Returns:
    
    tachoCount of left motor. Positive value means motor has moved the robot forward.
  - getRightCount
```
private int getRightCount()
```
    Returns the tachoCount of the right motor
    
    Returns:
    
    tachoCount of the right motor. Positive value means motor has moved the robot forward.
  - setSpeed
```
private void setSpeed(int leftSpeed,
                      int rightSpeed)
```
  - setLinearSpeed
```
public void setLinearSpeed(double travelSpeed)
```
    set travel speed in wheel diameter units per second
    
    Specified by:
    
    setLinearSpeed in interface MoveController
    
    Parameters:
    
    travelSpeed - : speed in distance (wheel diameter)units/sec
  - getLinearSpeed
```
public double getLinearSpeed()
```
    Description copied from interface: MoveController
    
    Returns the speed at which the robot will travel forward and backward (and to some extent arcs, although actual arc speed is slightly less). Speed is measured in units/second. e.g. If wheel diameter is cm, then speed is cm/sec.
    
    Specified by:
    
    getLinearSpeed in interface MoveController
    
    Returns:
    
    Speed in chosen units per second (e.g. cm/sec)
  - setLinearAcceleration
```
public void setLinearAcceleration(double acceleration)
```
    Description copied from interface: MoveController
    
    Sets the acceleration at which the robot will accelerate at the start of a move and decelerate at the end of a move. Acceleration is measured in units/second^2. e.g. If wheel diameter is cm, then acceleration is cm/sec^2.
    If acceleration is set during a move it will not be in used for the current move, it will be in effect with the next move.
    
    Specified by:
    
    setLinearAcceleration in interface MoveController
    
    Parameters:
    
    acceleration - in chosen units/second^2
  - getLinearAcceleration
```
public double getLinearAcceleration()
```
    Description copied from interface: MoveController
    
    Returns the acceleration at which the robot accelerates at the start of a move and decelerates at the end of a move.
    
    Specified by:
    
    getLinearAcceleration in interface MoveController
    
    Returns:
    
    acceleration in chosen units/second^2
  - setMotorAccel
```
private void setMotorAccel(int acceleration)
```
    helper method for setAcceleration and quickStop
    
    Parameters:
    
    acceleration -
  - getMaxLinearSpeed
```
public double getMaxLinearSpeed()
```
    Description copied from interface: MoveController
    
    Returns the maximum speed at which this robot is capable of traveling forward and backward. Speed is measured in units/second. e.g. If wheel diameter is cm, then speed is cm/sec.
    
    Specified by:
    
    getMaxLinearSpeed in interface MoveController
    
    Returns:
    
    Speed in chosen units per second (e.g. cm/sec)
  - setAngularSpeed
```
public void setAngularSpeed(double rotateSpeed)
```
    sets the rotation speed of the vehicle, degrees per second
    
    Specified by:
    
    setAngularSpeed in interface RotateMoveController
    
    Parameters:
    
    rotateSpeed -
  - getAngularSpeed
```
public double getAngularSpeed()
```
    Description copied from interface: RotateMoveController
    
    Returns the value of the rotation speed
    
    Specified by:
    
    getAngularSpeed in interface RotateMoveController
    
    Returns:
    
    the rotate speed in degrees per second
  - getMaxRotateSpeed
```
public float getMaxRotateSpeed()
```
  - getMaxAngularSpeed
```
public double getMaxAngularSpeed()
```
    Description copied from interface: RotateMoveController
    
    returns the maximum value of the rotation speed;
    
    Specified by:
    
    getMaxAngularSpeed in interface RotateMoveController
    
    Returns:
    
    max rotation speed
  - forward
```
public void forward()
```
    Starts the NXT robot moving forward.
    
    Specified by:
    
    forward in interface MoveController
  - backward
```
public void backward()
```
    Starts the NXT robot moving backward.
    
    Specified by:
    
    backward in interface MoveController
  - bak
```
private void bak()
```
    Motors backward. This is called by forward() and backward(), depending on parity.
  - fwd
```
private void fwd()
```
    Motors forward. This is called by forward() and backward() depending on parity.
  - rotateLeft
```
public void rotateLeft()
```
    Specified by:
    
    rotateLeft in interface RotateMoveController
  - rotateRight
```
public void rotateRight()
```
    Specified by:
    
    rotateRight in interface RotateMoveController
  - rotate
```
public void rotate(double angle)
```
    Rotates the NXT robot through a specific angle. Returns when angle is reached. Wheels turn in opposite directions producing a zero radius turn.
    Note: Requires correct values for wheel diameter and track width. calls rotate(angle,false)
    
    Specified by:
    
    rotate in interface RotateMoveController
    
    Parameters:
    
    angle - The wanted angle of rotation in degrees. Positive angle rotate left (anti-clockwise), negative right.
  - rotate
```
public void rotate(double angle,
                   boolean immediateReturn)
```
    Rotates the NXT robot through a specific angle. Returns when angle is reached. Wheels turn in opposite directions producing a zero radius turn.
    Note: Requires correct values for wheel diameter and track width. Side effect: inform listeners
    
    Specified by:
    
    rotate in interface RotateMoveController
    
    Parameters:
    
    angle - The wanted angle of rotation in degrees. Positive angle rotate left (anti-clockwise), negative right.
    
    immediateReturn - If true this method returns immediately.
  - stop
```
public void stop()
```
    Stops the NXT robot. side effect: inform listeners of end of movement
    
    Specified by:
    
    stop in interface MoveController
  - quickStop
```
public void quickStop()
```
    Stops the robot almost immediately. Use this method if the normal stop() is too slow;
  - travel
```
public void travel(double distance)
```
    Moves the NXT robot a specific distance in an (hopefully) straight line.
    A positive distance causes forward motion, a negative distance moves backward. If a drift correction has been specified in the constructor it will be applied to the left motor. calls travel(distance, false)
    
    Specified by:
    
    travel in interface MoveController
    
    Parameters:
    
    distance - The distance to move. Unit of measure for distance must be same as wheelDiameter and trackWidth.
  - travel
```
public void travel(double distance,
                   boolean immediateReturn)
```
    Moves the NXT robot a specific distance in an (hopefully) straight line.
    A positive distance causes forward motion, a negative distance moves backward. If a drift correction has been specified in the constructor it will be applied to the left motor.
    
    Specified by:
    
    travel in interface MoveController
    
    Parameters:
    
    distance - The distance to move. Unit of measure for distance must be same as wheelDiameter and trackWidth.
    
    immediateReturn - If true this method returns immediately.
  - arcForward
```
public void arcForward(double radius)
```
    Description copied from interface: ArcMoveController
    
    Starts the NXT robot moving forward along an arc with a specified radius.
    If radius is positive, the robot arcs left, and the center of the turning circle is on the left side of the robot.
    If radius is negative, the robot arcs right, and the center of the turning circle is on the right side of the robot.
    If radius is zero, the robot rotates in place.
    Postcondition: Motor speeds are unpredictable.
    Note: If you have specified a drift correction in the constructor it will not be applied in this method.
    
    Specified by:
    
    arcForward in interface ArcMoveController
    
    Parameters:
    
    radius - of the arc path. If positive, the left side of the robot is on the inside of the turn. If negative, the left side of the robot is on the outside of the turn.
  - arcBackward
```
public void arcBackward(double radius)
```
    Description copied from interface: ArcMoveController
    
    Starts the NXT robot moving backward along an arc with a specified radius.
    If radius is positive, the robot arcs left, and the center of the turning circle is on the left side of the robot.
    If radius is negative, the robot arcs right, and the center of the turning circle is on the right side of the robot.
    If radius is zero, the robot rotates in place.
    Postcondition: Motor speeds are unpredictable.
    Note: If you have specified a drift correction in the constructor it will not be applied in this method.
    
    Specified by:
    
    arcBackward in interface ArcMoveController
    
    Parameters:
    
    radius - of the arc path. If positive, the left side of the robot is on the inside of the turn. If negative, the left side of the robot is on the outside of the turn.
  - arc
```
public void arc(double radius,
                double angle)
```
    Description copied from interface: ArcMoveController
    
    Moves the NXT robot along an arc with a specified radius and angle, after which the robot stops moving. This method does not return until the robot has completed moving angle degrees along the arc.
    If radius is positive, the robot arcs left, and the center of the turning circle is on the left side of the robot.
    If radius is negative, the robot arcs right, and the center of the turning circle is on the right side of the robot.
    If radius is zero, is zero, the robot rotates in place.
    Robot will stop when the degrees it has moved along the arc equals angle.
    If angle is positive, the robot will turn to the left (anti-clockwise).
    If angle is negative, the robot will turn to the right (clockwise). If angle is zero, the robot will not move and the method returns immediately.
    Postcondition: Motor speeds are unpredictable.
    Note: If you have specified a drift correction in the constructor it will not be applied in this method.
    
    Specified by:
    
    arc in interface ArcMoveController
    
    Parameters:
    
    radius - of the arc path. If positive, the left side of the robot is on the inside of the turn. If negative, the left side of the robot is on the outside of the turn.
    
    angle - The sign of the angle determines the direction of the robot turns: Positive is anti-clockwise, negative is clockwise.
    
    See Also:
    
    ArcMoveController.travelArc(double, double)
  - arc
```
public void arc(double radius,
                double angle,
                boolean immediateReturn)
```
    Description copied from interface: ArcMoveController
    
    Moves the NXT robot along an arc with a specified radius and angle, after which the robot stops moving. This method has the ability to return immediately by using the immediateReturn parameter.
    If radius is positive, the robot arcs left, and the center of the turning circle is on the left side of the robot.
    If radius is negative, the robot arcs right, and the center of the turning circle is on the right side of the robot.
    If radius is zero, is zero, the robot rotates in place.
    The robot will stop when the degrees it has moved along the arc equals angle.
    If angle is positive, the robot will turn to the left (anti-clockwise).
    If angle is negative, the robot will turn to the right (clockwise). If angle is zero, the robot will not move and the method returns immediately.
    Postcondition: Motor speeds are unpredictable.
    Note: If you have specified a drift correction in the constructor it will not be applied in this method.
    
    Specified by:
    
    arc in interface ArcMoveController
    
    Parameters:
    
    radius - of the arc path. If positive, the left side of the robot is on the inside of the turn. If negative, the left side of the robot is on the outside of the turn.
    
    angle - The sign of the angle determines the direction of the robot turns: Positive is anti-clockwise, negative is clockwise.
    
    immediateReturn - If immediateReturn is true then the method returns immediately.
    
    See Also:
    
    ArcMoveController.travelArc(double, double, boolean)
  - travelArc
```
public void travelArc(double radius,
                      double distance)
```
    Description copied from interface: ArcMoveController
    
    Moves the NXT robot a specified distance along an arc of specified radius, after which the robot stops moving. This method does not return until the robot has completed moving distance along the arc. The units (inches, cm) for distance must be the same as the units used for radius.
    If radius is positive, the robot arcs left, and the center of the turning circle is on the left side of the robot.
    If radius is negative, the robot arcs right, and the center of the turning circle is on the right side of the robot.
    If radius is zero, the robot rotates in place
    The robot will stop when it has moved along the arc distance units.
    If distance is positive, the robot will move travel forwards.
    If distance is negative, the robot will move travel backwards.
    If distance is zero, the robot will not move and the method returns immediately.
    Postcondition: Motor speeds are unpredictable.
    
    Specified by:
    
    travelArc in interface ArcMoveController
    
    Parameters:
    
    radius - of the arc path. If positive, the left side of the robot is on the inside of the turn. If negative, the left side of the robot is on the outside of the turn.
    
    distance - to travel, in same units as radius. The sign of the distance determines the direction of robot motion. Positive drives the robot forward, negative drives it backward.
    
    See Also:
    
    ArcMoveController.arc(double, double)
  - travelArc
```
public void travelArc(double radius,
                      double distance,
                      boolean immediateReturn)
```
    Description copied from interface: ArcMoveController
    
    Moves the NXT robot a specified distance along an arc of specified radius, after which the robot stops moving. This method has the ability to return immediately by using the immediateReturn parameter. The units (inches, cm) for distance should be the same as the units used for radius.
    If radius is positive, the robot arcs left, and the center of the turning circle is on the left side of the robot.
    If radius is negative, the robot arcs right, and the center of the turning circle is on the right side of the robot.
    If radius is zero, the robot rotates in place.
    The robot will stop when it has moved along the arc distance units.
    If distance is positive, the robot will move travel forwards.
    If distance is negative, the robot will move travel backwards.
    If distance is zero, the robot will not move and the method returns immediately.
    Postcondition: Motor speeds are unpredictable.
    
    Specified by:
    
    travelArc in interface ArcMoveController
    
    Parameters:
    
    radius - of the arc path. If positive, the left side of the robot is on the inside of the turn. If negative, the left side of the robot is on the outside of the turn.
    
    distance - to travel, in same units as radius. The sign of the distance determines the direction of robot motion. Positive drives the robot forward, negative drives it backward.
    
    immediateReturn - If immediateReturn is true then the method returns immediately.
    
    See Also:
    
    ArcMoveController.arc(double, double, boolean)
  - turnRate
```
private double turnRate(double radius)
```
    Calculates the turn rate corresponding to the turn radius;
    use as the parameter for steer() negative argument means center of turn is on right, so angle of turn is negative
    
    Parameters:
    
    radius -
    
    Returns:
    
    turnRate to be used in steer()
  - radius
```
private double radius(double turnRate)
```
    Returns the radius of the turn made by steer(turnRate) Used in for planned distance at start of arc and steer moves.
    
    Parameters:
    
    turnRate -
    
    Returns:
    
    radius of the turn.
  - steer
```
public void steer(double turnRate)
```
    Starts the robot moving forward along a curved path. This method is similar to the arcForward(double radius ) method except it uses the turnRate parameter do determine the curvature of the path and therefore has the ability to drive straight. This makes it useful for line following applications.
    The turnRate specifies the sharpness of the turn. Use values between -200 and +200.
    A positive value means that center of the turn is on the left. If the robot is traveling toward the top of the page the arc looks like this: ).
    A negative value means that center of the turn is on the right so the arc looks this: (.
    . In this class, this parameter determines the ratio of inner wheel speed to outer wheel speed as a percent.
    Formula: ratio = 100 - abs(turnRate).
    When the ratio is negative, the outer and inner wheels rotate in opposite directions. Examples of how the formula works:
    - steer(0) -> inner and outer wheels turn at the same speed, travel straight
    - steer(25) -> the inner wheel turns at 75% of the speed of the outer wheel, turn left
    - steer(100) -> the inner wheel stops and the outer wheel is at 100 percent, turn left
    - steer(200) -> the inner wheel turns at the same speed as the outer wheel - a zero radius turn.
    Note: If you have specified a drift correction in the constructor it will not be applied in this method.
    Specified by:
    
    steer in interface LineFollowingMoveController
    
    Parameters:
    
    turnRate - If positive, the left side of the robot is on the inside of the turn. If negative, the left side is on the outside.
  - steerBackward
```
public void steerBackward(double turnRate)
```
    Starts the robot moving backward along a curved path. This method is essentially the same as steer(double) except that the robot moves backward instead of forward.
    
    Specified by:
    
    steerBackward in interface LineFollowingMoveController
    
    Parameters:
    
    turnRate -
  - steer
```
public void steer(double turnRate,
                  double angle)
```
    Moves the robot along a curved path through a specified turn angle. This method is similar to the arc(double radius , double angle) method except it uses a ratio of motor speeds to determine the curvature of the path and therefore has the ability to drive straight. This makes it useful for line following applications. This method does not return until the robot has completed moving angle degrees along the arc.
    The turnRate specifies the sharpness of the turn. Use values between -200 and +200.
    For details about how this parameter works.See steer(double turnRate)
    The robot will stop when its heading has changed by the amount of the angle parameter.
    If angle is positive, the robot will move in the direction that increases its heading (it turns left).
    If angle is negative, the robot will move in the directin that decreases its heading (turns right).
    If angle is zero, the robot will not move and the method returns immediately.
    The sign of the turn rate and the sign of the angle together determine if the robot will move forward or backward. Assuming the robot is heading toward the top of the page. Then a positive turn rate means the arc looks like this: ) . If the angle is positive, the robot moves forward to increase its heading angle. If negative, it moves backward to decrease the heading.
    But if the turn rate is negative, the arc looks like this: ( .So a positive angle (increase in heading) means the robot moves backwards, while a negative angle means the robot moves forward to decrease its heading.
    Note: If you have specified a drift correction in the constructor it will not be applied in this method.
    
    Parameters:
    
    turnRate - If positive, the left side of the robot is on the inside of the turn. If negative, the left side is on the outside.
    
    angle - The angle through which the robot will rotate. If negative, the robot will move in the directin that decreases its heading.
  - steer
```
public void steer(double turnRate,
                  double angle,
                  boolean immediateReturn)
```
    Moves the robot along a curved path for a specified angle of rotation. This method is similar to the arc(double radius, double angle, boolean immediateReturn) method except it uses the turnRate() parameter to determine the curvature of the path and therefore has the ability to drive straight. This makes it useful for line following applications. This method has the ability to return immediately by using the immediateReturn parameter set to true.
    The turnRate specifies the sharpness of the turn. Use values between -200 and +200.
    For details about how this parameter works, see steer(double turnRate)
    The robot will stop when its heading has changed by the amount of the angle parameter.
    If angle is positive, the robot will move in the direction that increases its heading (it turns left).
    If angle is negative, the robot will move in the direction that decreases its heading (turns right).
    If angle is zero, the robot will not move and the method returns immediately.
    For more details about this parameter, see steer(double turnRate, double angle)
    Note: If you have specified a drift correction in the constructor it will not be applied in this method.
    
    Parameters:
    
    turnRate - If positive, the left side of the robot is on the inside of the turn. If negative, the left side is on the outside.
    
    angle - The angle through which the robot will rotate. If negative, robot traces the turning circle backwards.
    
    immediateReturn - If immediateReturn is true then the method returns immediately.
  - steerPrep
```
void steerPrep(double turnRate)
```
    helper method used by steer(float) and steer(float,float,boolean) sets _outsideSpeed, _insideSpeed, _steerRatio set motor acceleration to help continuous steer and arc moves
    
    Parameters:
    
    turnRate - .
  - movementStart
```
protected void movementStart()
```
    called at start of a movement to inform the listeners that a movement has started. Must be called before the motors start to move to capture the correct positional information
  - movementActive
```
protected void movementActive()
```
    Called to indicate that the motors are now running and should be monitored for movement. Must be called after the motors are started.
  - movementStop
```
private void movementStop()
```
    called by Arc() ,travel(),rotate(),stop() rotationStopped() calls moveStopped on listener
  - isMoving
```
public boolean isMoving()
```
    Description copied from interface: MoveController
    
    true if the robot is moving
    
    Specified by:
    
    isMoving in interface MoveController
    
    Returns:
    
    true if the NXT robot is moving.
  - waitComplete
```
private void waitComplete()
```
    wait for the current operation on both motors to complete
  - waitForActiveMove
```
private void waitForActiveMove()
```
  - isStalled
```
public boolean isStalled()
```
  - reset
```
public void reset()
```
    Resets tacho count for both motors.
  - setMinRadius
```
public void setMinRadius(double radius)
```
    Set the radius of the minimum turning circle. Note: A DifferentialPilot robot can simulate a SteeringPilot robot by calling DifferentialPilot.setMinRadius() and setting the value to something greater than zero (example: 15 cm).
    
    Specified by:
    
    setMinRadius in interface ArcMoveController
    
    Parameters:
    
    radius - in degrees
  - getMinRadius
```
public double getMinRadius()
```
    Description copied from interface: ArcMoveController
    
    The minimum steering radius this vehicle is capable of when traveling in an arc. Theoretically this should be identical for both forward and reverse travel. In practice?
    
    Specified by:
    
    getMinRadius in interface ArcMoveController
    
    Returns:
    
    the radius in degrees
  - getMovementIncrement
```
public float getMovementIncrement()
```
    Returns:
    
    The move distance since it last started moving
  - getAngleIncrement
```
public float getAngleIncrement()
```
    Returns:
    
    The angle rotated since rotation began.
  - addMoveListener
```
public void addMoveListener(MoveListener m)
```
    Description copied from interface: MoveProvider
    
    Adds a MoveListener that will be notified of all movement events.
    
    Specified by:
    
    addMoveListener in interface MoveProvider
    
    Parameters:
    
    m - the move listener
  - getMovement
```
public Move getMovement()
```
    Description copied from interface: MoveProvider
    
    Returns the move made since the move started, but before it has completed. This method is used by GUI maps to display the movement of a robot in real time. The robot must be capable of determining the move while it is in motion.
    
    Specified by:
    
    getMovement in interface MoveProvider
    
    Returns:
    
    The move made since the move started.
  - getTurnRate
```
public double getTurnRate()
```
    Get the turn rate for arc and steer commands
    
    Returns:
    
    the turn rate
  - setAngularAcceleration
```
public void setAngularAcceleration(double acceleration)
```
    Description copied from interface: RotateMoveController
    
    Sets the acceleration at which the robot will accelerate at the start of a move and decelerate at the end of a move. Acceleration is measured in units/second^2. e.g. If wheel diameter is cm, then acceleration is cm/sec^2.
    If acceleration is set during a move it will not be in used for the current move, it will be in effect with the next move.
    
    Specified by:
    
    setAngularAcceleration in interface RotateMoveController
    
    Parameters:
    
    acceleration - in chosen units/second^2
  - getAngularAcceleration
```
public double getAngularAcceleration()
```
    Description copied from interface: RotateMoveController
    
    Returns the acceleration at which the robot accelerates at the start of a move and decelerates at the end of a move.
    
    Specified by:
    
    getAngularAcceleration in interface RotateMoveController
    
    Returns:
    
    acceleration in chosen units/second^2

Class DifferentialPilot

Nested Class Summary

Field Summary

Fields inherited from interface lejos.robotics.navigation.MoveController

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

_turnRadius

_left

_right

_inside

_outside

_steerRatio

_leftDegPerDistance

_rightDegPerDistance

_leftTurnRatio

_rightTurnRatio

_robotTravelSpeed

_robotRotateSpeed

_parity

_trackWidth

_leftWheelDiameter

_rightWheelDiameter

_leftTC

_rightTC

_listeners

_type

_distance

_angle

_acceleration

_quickAcceleration

_leftDirection

_rightDirection

_monitor

_moveActive

Constructor Detail

DifferentialPilot

DifferentialPilot

DifferentialPilot

Method Detail

getLeftCount

getRightCount

setSpeed

setLinearSpeed

getLinearSpeed

setLinearAcceleration

getLinearAcceleration

setMotorAccel

getMaxLinearSpeed

setAngularSpeed

getAngularSpeed

getMaxRotateSpeed

getMaxAngularSpeed

forward

backward

bak

fwd

rotateLeft

rotateRight

rotate

rotate

stop

quickStop

travel

travel

arcForward

arcBackward

arc

arc

travelArc

travelArc

turnRate

radius

steer

steerBackward

steer

steer

steerPrep

movementStart