vex_motor.h

Go to the documentation of this file.

/*----------------------------------------------------------------------------*/
/*                                                                            */
/*    Copyright (c) Innovation First 2017-2019, All rights reserved.          */
/*                                                                            */
/*    Module:     vex_motor.h                                                 */
/*    Author:     James Pearman                                               */
/*    Created:    2 June 2017                                                 */
/*                                                                            */
/*    Revisions:                                                              */
/*                V1.00     TBD - Initial release                             */
/*                                                                            */
/*----------------------------------------------------------------------------*/
 
#ifndef   VEX_MOTOR_CLASS_H
#define   VEX_MOTOR_CLASS_H
 
/*-----------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#define   VEXIQ_MOTOR_OVERTEMP_FLAG     0x02
#define   VEXIQ_MOTOR_CURLIMIT_FLAG     0x04
#define   VEXIQ_MOTOR_ZEROVEL_FLAG      0x08
#define   VEXIQ_MOTOR_ZEROPOS_FLAG      0x10
 
/*-----------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------*/
namespace vex {
  class motor : public device {
    public:
      motor( int32_t index );  
      ~motor();
    
      bool            installed();
      int32_t         value();
 
      motor( int32_t index, bool reverse );
 
      motor( int32_t index, double gearRatio );
 
      motor( int32_t index, double gearRatio, bool reverse );
 
      void            setReversed( bool value );
 
      void            setVelocity( double velocity, velocityUnits units );
 
      void            setVelocity( double velocity, percentUnits units ){
          setVelocity( velocity, static_cast<velocityUnits>(units) );
      };
      void            setVelocity( double velocity, percentUnits units ) {…}
 
      //Legacy 
      void            setBrake( brakeType mode );
 
      void            setStopping( brakeType mode );
 
      void            resetPosition( void );
 
      void            setPosition( double value, rotationUnits units );
 
      void            setTimeout( int32_t time, timeUnits units );
 
      //Actions
 
      void            spin( directionType dir );
 
      void            spin( directionType dir, double velocity, velocityUnits units );
 
      void            spin( directionType dir, double velocity, percentUnits units ){
          spin( dir, velocity, static_cast<velocityUnits>(units) );
      }
 
      void            spin( directionType dir, double voltage, voltageUnits units );
 
      bool            spinTo( double rotation, rotationUnits units, double velocity, velocityUnits units_v, bool waitForCompletion=true );
 
      bool            spinToPosition( double rotation, rotationUnits units, double velocity, velocityUnits units_v, bool waitForCompletion=true );
 
      bool            spinTo( double rotation, rotationUnits units, bool waitForCompletion=true );
 
      bool            spinToPosition( double rotation, rotationUnits units, bool waitForCompletion=true );
 
      bool            spinFor( double rotation, rotationUnits units, double velocity, velocityUnits units_v, bool waitForCompletion=true );
 
      bool            spinFor( directionType dir, double rotation, rotationUnits units, double velocity, velocityUnits units_v, bool waitForCompletion=true );
 
      bool            spinFor( double rotation, rotationUnits units, bool waitForCompletion=true );
 
      bool            spinFor( directionType dir, double rotation, rotationUnits units, bool waitForCompletion=true );
      
      bool            spinFor( double time, timeUnits units, double velocity, velocityUnits units_v );
 
      bool            spinFor( directionType dir, double time, timeUnits units, double velocity, velocityUnits units_v );
 
      bool            spinFor( double time, timeUnits units );
 
      bool            spinFor( directionType dir, double time, timeUnits units );
 
      bool            isSpinning( void );
 
      bool            isDone( void );
 
      bool            isSpinningMode( void );
 
      void            stop( void );
 
      void            stop( brakeType mode );
 
      void            setMaxTorque( double value, percentUnits units );
 
      void            setMaxTorque( double value, torqueUnits units );
      
      void            setMaxTorque( double value, currentUnits units );
      
      // sensing
 
      directionType   direction( void );
 
      double          position( rotationUnits units );
 
      double          velocity( velocityUnits units );
 
      double          velocity( percentUnits units ) {
          return velocity( static_cast<velocityUnits>(units) );
      };
 
      double          current( currentUnits units = currentUnits::amp );
 
      double          current( percentUnits units );
 
      // these are all V5 compatibility functions and do not return any valid values
      // data from the motor for these is not available on IQ
 
      double          voltage( voltageUnits units = voltageUnits::volt );
 
      double          power( powerUnits units = powerUnits::watt );
 
      double          torque( torqueUnits units = torqueUnits::Nm );
 
      double          efficiency( percentUnits units = percentUnits::pct );
 
      double          temperature( percentUnits units = percentUnits::pct );
      
      double          temperature( temperatureUnits units );
 
      
    protected:
      int32_t         getTimeout();
      double          getVelocity( velocityUnits units );
    
    private:
      int32_t         _timeout;
      int16_t         _velocity;
      int16_t         _last_velocity;
      int32_t         _offset;
      bool            _bReverse;
      brakeType       _brakeMode;
      bool            _spinMode;
      int32_t         _flagDelay;
      int32_t         _initDelay;
      float           _gearRatio;
      
      void            defaultStopping( brakeType mode );
      
      bool            zeroPositionFlag( void );
      uint8_t         modeGet( void );
 
      double          velocityToScaled( int32_t velocity, velocityUnits units );
      int32_t         scaledToVelocity( double value, velocityUnits units );
      double          encoderToScaled( int32_t counts, rotationUnits units );
      int32_t         scaledToEncoder( double position, rotationUnits units );
      double          torqueToCurrent( double torque );
  };
  class motor : public device {…};
};
 
#endif // VEX_MOTOR_CLASS_H