Package ev3dev.actuators.lego.motors

Class BaseRegulatedMotor

java.lang.Object

ev3dev.hardware.EV3DevFileSystem

ev3dev.hardware.EV3DevPlatforms

ev3dev.hardware.EV3DevDevice

ev3dev.hardware.EV3DevMotorDevice

ev3dev.actuators.lego.motors.BaseRegulatedMotor

Direct Known Subclasses:

EV3LargeRegulatedMotor, EV3MediumRegulatedMotor, NXTRegulatedMotor

public abstract class BaseRegulatedMotor
extends EV3DevMotorDevice

Abstraction for a Regulated motors motors. The basic control methods are: forward, backward, reverseDirection, stop and flt. To set each motors's velocity, use setSpeed . The maximum velocity of the motors is limited by the battery voltage and load. With no load, the maximum degrees per second is about 100 times the voltage (for the large EV3 motors).
The velocity is regulated by comparing the tacho count with velocity times elapsed time, and adjusting motors power to keep these closely matched. Changes in velocity will be made at the rate specified via the setAcceleration(int acceleration) method. The methods rotate(int angle) and rotateTo(int ange) use the tachometer to control the position at which the motors stops, usually within 1 degree or 2.

Listeners. An object implementing the RegulatedMotorListener interface may register with this class. It will be informed each time the motors starts or stops.
Stall detection If a stall is detected or if for some other reason the speed regulation fails, the motors will stop, and isStalled() returns true.
Motors will hold their position when stopped. If this is not what you require use the flt() method instead of stop().

Field Summary

Fields

Modifier and Type	Field and Description
protected int	acceleration
private java.util.List<RegulatedMotorListener>	listenerList
private static Logger	log
protected int	MAX_SPEED_AT_9V
private boolean	regulationFlag
private int	speed

Fields inherited from class ev3dev.hardware.EV3DevMotorDevice

AUTO_MODE, BRAKE, COAST, COMMAND, DC_MOTOR, DUTY_CYCLE, HOLD, POLARITY, POLARITY_INVERSED, POLARITY_NORMAL, POSITION, POSITION_SP, POWER, RESET, RUN_DIRECT, RUN_FOREVER, RUN_TO_ABS_POS, RUN_TO_REL_POS, SPEED, STATE, STATE_RUNNING, STATE_STALLED, STOP, STOP_COMMAND, TACHO_MOTOR

Fields inherited from class ev3dev.hardware.EV3DevDevice

ADDRESS, DEVICE, LEGO_PORT, LEGO_SENSOR, MODE, PATH_DEVICE

Fields inherited from class ev3dev.hardware.EV3DevFileSystem

EV3DEV_ROOT_PATH, EV3DEV_TESTING_KEY, ROOT_PATH

Constructor Summary

Constructors

Constructor and Description
BaseRegulatedMotor(Port motorPort, float moveP, float moveI, float moveD, float holdP, float holdI, float holdD, int offset, int maxSpeed) Constructor

Method Summary

Modifier and Type	Method and Description
void	addListener(RegulatedMotorListener regulatedMotorListener)
void	backward()
void	brake() Removes power from the motor and creates a passive electrical load.
void	coast()
void	endSynchronization()
void	flt()
void	flt(boolean b) Set the motors into float mode.
void	forward()
float	getMaxSpeed()
float	getPosition() Returns the current position that the motors regulator is trying to maintain.
int	getRotationSpeed() Return the current velocity.
int	getSpeed() Return the current target speed.
int	getTachoCount()
void	hold() Causes the motor to actively try to hold the current position.
boolean	isMoving() This method returns true if the motors is attempting to rotate.
boolean	isStalled() Return true if the motors is currently stalled.
RegulatedMotorListener	removeListener()
void	resetTachoCount() Reset the tachometer associated with this motors.
void	rotate(int angle) Rotate by the requested number of degrees.
void	rotate(int angle, boolean immediateReturn) Rotate by the request number of degrees.
void	rotateTo(int limitAngle) Rotate to the target angle.
void	rotateTo(int limitAngle, boolean immediateReturn)
void	setAcceleration(int acceleration)
void	setSpeed(int speed) Sets desired motors speed , in degrees per second; The maximum reliably sustainable velocity is 100 x battery voltage under moderate load, such as a direct drive robot on the level.
void	startSynchronization()
void	stop() Causes motors to stop, pretty much instantaneously.
void	stop(boolean b)
boolean	suspendRegulation() Removes this motors from the motors regulation system.
void	synchronizeWith(RegulatedMotor[] regulatedMotors)
void	waitComplete()

Methods inherited from class ev3dev.hardware.EV3DevDevice

detect, getIntegerAttribute, getStringAttribute, setIntegerAttribute, setStringAttribute

Methods inherited from class ev3dev.hardware.EV3DevPlatforms

getMotorPort, getPlatform, getSensorPort

Methods inherited from class ev3dev.hardware.EV3DevFileSystem

getROOT_PATH

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

log

private static final Logger log

MAX_SPEED_AT_9V

protected final int MAX_SPEED_AT_9V

speed

private int speed

acceleration

protected int acceleration

regulationFlag

private boolean regulationFlag

listenerList

private final java.util.List<RegulatedMotorListener> listenerList

Constructor Detail

BaseRegulatedMotor

public BaseRegulatedMotor(Port motorPort,
                          float moveP,
                          float moveI,
                          float moveD,
                          float holdP,
                          float holdI,
                          float holdD,
                          int offset,
                          int maxSpeed)

Constructor

Parameters:

motorPort - motor port

moveP - moveP

moveI - moveI

moveD - moveD

holdP - holdP

holdI - holdI

holdD - holdD

offset - offset

maxSpeed - maxSpeed

Method Detail

suspendRegulation

public boolean suspendRegulation()

Removes this motors from the motors regulation system. After this call the motors will be in float mode and will have stopped. Note calling any of the high level move operations (forward, rotate etc.), will automatically enable regulation.

Returns:

true iff regulation has been suspended.

getTachoCount

public int getTachoCount()

Returns:

the current tachometer count.

See Also:

lejos.robotics.RegulatedMotor#getTachoCount()

getPosition

public float getPosition()

Returns the current position that the motors regulator is trying to maintain. Normally this will be the actual position of the motors and will be the same as the value returned by getTachoCount(). However in some circumstances (activeMotors that are in the process of stalling, or activeMotors that have been forced out of position), the two values may differ. Note that if regulation has been suspended calling this method will restart it.

Returns:

the current position calculated by the regulator.

forward

public void forward()

backward

public void backward()

flt

public void flt(boolean b)

Set the motors into float mode. This will stop the motors without braking and the position of the motors will not be maintained.

flt

public void flt()

coast

public void coast()

brake

public void brake()

Removes power from the motor and creates a passive electrical load. This is usually done by shorting the motor terminals together. This load will absorb the energy from the rotation of the motors and cause the motor to stop more quickly than coasting.

hold

public void hold()

Causes the motor to actively try to hold the current position. If an external force tries to turn the motor, the motor will “push back” to maintain its position.

stop

public void stop()

Causes motors to stop, pretty much instantaneously. In other words, the motors doesn't just stop; it will resist any further motion. Cancels any rotate() orders in progress

stop

public void stop(boolean b)

isMoving

public boolean isMoving()

This method returns true if the motors is attempting to rotate. The return value may not correspond to the actual motors movement.
For example, If the motors is stalled, isMoving() will return true.
After flt() is called, this method will return false even though the motors axle may continue to rotate by inertia. If the motors is stalled, isMoving() will return true. . A stall can be detected by calling isStalled();

Returns:

true iff the motors is attempting to rotate.

setSpeed

public void setSpeed(int speed)

Sets desired motors speed , in degrees per second; The maximum reliably sustainable velocity is 100 x battery voltage under moderate load, such as a direct drive robot on the level.

Parameters:

speed - value in degrees/sec

resetTachoCount

public void resetTachoCount()

Reset the tachometer associated with this motors. Note calling this method will cause any current move operation to be halted.

rotate

public void rotate(int angle,
                   boolean immediateReturn)

Rotate by the request number of degrees.

Parameters:

angle - number of degrees to rotate relative to the current position

immediateReturn - if true do not wait for the move to complete Rotate by the requested number of degrees. Wait for the move to complete.

rotate

public void rotate(int angle)

Rotate by the requested number of degrees. Wait for the move to complete.

Parameters:

angle - angle

rotateTo

public void rotateTo(int limitAngle,
                     boolean immediateReturn)

rotateTo

public void rotateTo(int limitAngle)

Rotate to the target angle. Do not return until the move is complete.

Parameters:

limitAngle - Angle to rotate to.

getSpeed

public int getSpeed()

Return the current target speed.

Returns:

the current target speed.

isStalled

public boolean isStalled()

Return true if the motors is currently stalled.

Returns:

true if the motors is stalled, else false

getRotationSpeed

public int getRotationSpeed()

Return the current velocity.

Returns:

current velocity in degrees/s

addListener

public void addListener(RegulatedMotorListener regulatedMotorListener)

removeListener

public RegulatedMotorListener removeListener()

waitComplete

public void waitComplete()

getMaxSpeed

public float getMaxSpeed()

setAcceleration

public void setAcceleration(int acceleration)

synchronizeWith

public void synchronizeWith(RegulatedMotor[] regulatedMotors)

startSynchronization

public void startSynchronization()

endSynchronization

public void endSynchronization()