7.4 Motor�N���X

���[�^�����������A�����N���X������Motor�N���X�� ���`���������D

package josx.platform.rcx;

/**
 * Abstraction for a motor.
 * Three instances of <code>Motor</code>
 * are available: <code>Motor.A</code>,
 * <code>Motor.B</code>
 * and <code>Motor.C</code>.
 * To control each motor use
 * methods <code>forward, backward,
 * reverseDirection, stop</code>
 * and <code>flt</code>.
 * To set each motor's power, use
 * <code>setPower</code>.  
 * <p>
 * Example:<p>
 * <code><pre>
 *   Motor.A.setPower(1);
 *   Motor.C.setPower(7);
 *   Motor.A.forward();
 *   Motor.C.forward();
 *   Thread.sleep (1000);
 *   Motor.A.stop();
 *   Motor.C.stop();
 * </pre></code>
 */
public class Motor
{
  private char  iId;
  private short iMode = 4;
  private short iPower = 3;

  /**
   * Motor A, B, C
   */
  public static final
  Motor A = new Motor ('A');
  public static final
  Motor B = new Motor ('B');
  public static final
  Motor C = new Motor ('C');

  private Motor (char aId) {
    iId = aId;
  }

  /**
   * Get the ID of the motor.
   * One of 'A', 'B' or 'C'.
   */
  public final char getId() {
    return iId;
  }

  /**
   * Sets motor power to
   * a <i>value between 0 and 7</i>.
   * @param A value in the range [0-7].
   */
  public final void setPower (int aPower) {
    iPower = (short) aPower;
    controlMotor (iId, iMode, aPower);
  }

  /**
   * Causes motor to rotate forward.
   */
  public final void forward() {
    iMode = 1;
    controlMotor (iId, 1, iPower);
  }
  
  /**
   * Return true if motor is forward.
   */
  public final boolean isForward() {
    return (iMode == 1);
  }

  /**
   * Causes motor to rotate backwards.
   */
  public final void backward() {
    iMode = 2;
    controlMotor (iId, 2, iPower);
  }

  /**
   * Return true if motor is backward. */
  public final boolean isBackward() {
    return (iMode == 2);
  }

  /**
   * Reverses direction of the motor. It only has
   * effect if the motor is moving.
   */
  public final void reverseDirection() {
    if (iMode == 1 || iMode == 2) {
      iMode = (short) (3 - iMode);
      controlMotor (iId, iMode, iPower);
    }
  }

  /**
   * Returns the current motor power.
   */
  public final int getPower() {
    return iPower;          
  }

  /**
   * @return true iff the motor is
   * currently in motion.
   */
  public final boolean isMoving() {
    return (iMode == 1 || iMode == 2);          
  }
  
  /**
   * @return true iff the motor is
   * currently in float mode.
   */
  public final boolean isFloating() {
    return iMode == 4;          
  }
  
  /**
   * Causes motor to stop, pretty much
   * instantaneously. In other words, the
   * motor doesn't just stop; it will resist
   * any further motion.
   */
  public final void stop() {
    iMode = 3;
    controlMotor (iId, 3, 7);
  }
  
  /**
   * Return true if motor is stopped.
   */
  public final boolean isStopped() {
    return (iMode == 3);
  }

  /**
   * Causes motor to float.
   * The motor will lose all power,
   * but this is not the same as stopping.
   * Use this
   * method if you don't want your robot to trip in
   * abrupt turns.
   */
  public final void flt() {
    iMode = 4;
    controlMotor (iId, 4, iPower);
  }

  /**
   * <i>Low-level API</i> for
   * controlling a motor.
   * This method is not meant to
   * be called directly.
   * If called, other methods
   * such as isRunning() will
   * be unreliable.
   * @deprecated I've decided to
   * remove this method.
   If you really need it,
   check its implementation
   in classes/josx/platform/rcx/Motor.java. 
   * @param
   aMotor The motor id:
   'A', 'B' or 'C'.
   * @param
   aMode 1=forward,
   2=backward,
   3=stop,
   4=float
   * @param
   aPower A value in the range [0-7].
   */
  public static
  void controlMotor (char aMotor,
                     int aMode,
                     int aPower) {
    ROM.call ((short) 0x1a4e,
              (short) (0x2000 + aMotor - 'A'), 
              (short) aMode, (short) aPower);
  }
}