MotorPair.H

Go to the documentation of this file.

//
// The contents of this file are subject to the Mozilla Public License
// Version 1.0 (the "License"); you may not use this file except in
// compliance with the License. You may obtain a copy of the License
// at http://www.mozilla.org/MPL/
// 
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
// the License for the specific language governing rights and
// limitations under the License.
//
// This software was developed as part of the legOS project.
//
// Contributor: Pat Welch (legOS@mousebrains.com)

#ifndef _MotorPair_H_
#define _MotorPair_H_

#include <config.h>

#if defined(CONF_DMOTOR)

#include <conio.h>      // for the delay() function
#include <c++/Motor.H>

class MotorPair {
public:

  MotorPair(const Motor::Port lport, const Motor::Port rport)
    : mLeft(lport), mRight(rport) {}

  ~MotorPair() {}

  void speed(const int s) const { mLeft.speed(s); mRight.speed(s); }

  void direction(const MotorDirection dir) const { 
    if (dir == ::fwd) {
      mLeft.direction(::fwd); 
      mRight.direction(::rev); 
    } else if (dir == ::rev) {
      mLeft.direction(::rev); 
      mRight.direction(::fwd); 
    } else {
      mLeft.direction(dir); 
      mRight.direction(dir); 
    }
  }

  void forward() const { direction(::fwd); }

  void reverse() const { direction(::rev); }

  void brake() const { 
    mLeft.direction(::brake); 
    mRight.direction(::brake); 
  }

  void off() const { 
    mLeft.direction(::off); 
    mRight.direction(::off); 
  }

  void left() const { 
    mLeft.direction(::fwd); 
    mRight.direction(::fwd); 
  }

  void pivotLeft() const { 
    mLeft.brake(); 
    mRight.direction(::rev); 
  }

  void right() const { 
    mLeft.direction(::rev); 
    mRight.direction(::rev); 
  }

  void pivotRight() const { 
    mLeft.direction(::fwd); 
    mRight.brake(); 
  }


  void forward(const int s) const { forward(); speed(s); }

  void reverse(const int s) const { reverse(); speed(s); }

  void left(const int s) const { left(); speed(s); }

  void pivotLeft(const int s) const { pivotLeft(); speed(s); }

  void right(const int s) const { right(); speed(s); }

  void pivotRight(const int s) const { pivotRight(); speed(s); }

  void brake(const int ms) const { brake(); delay(ms); }

  enum Limits {
         min = Motor::min,  
                 max = Motor::max   
           };

private:
  const Motor mLeft;    
  const Motor mRight;   
};

#else // CONF_DMOTOR
#warning Enable CONF_DMOTOR to use MotorPair.H
#endif // CONF_DMOTOR
#endif // _MotorPair_H_

---