#include <RobotDrive.h>

Inheritance diagram for RobotDrive:

Public Types
enum	MotorType { kFrontLeftMotor = 0, kFrontRightMotor = 1, kRearLeftMotor = 2, kRearRightMotor = 3 }
Public Member Functions
	RobotDrive (UINT32 leftMotorChannel, UINT32 rightMotorChannel)
	RobotDrive (UINT32 frontLeftMotorChannel, UINT32 rearLeftMotorChannel, UINT32 frontRightMotorChannel, UINT32 rearRightMotorChannel)
	RobotDrive (SpeedController leftMotor, SpeedController rightMotor)
	RobotDrive (SpeedController &leftMotor, SpeedController &rightMotor)
	RobotDrive (SpeedController frontLeftMotor, SpeedController rearLeftMotor, SpeedController frontRightMotor, SpeedController rearRightMotor)
	RobotDrive (SpeedController &frontLeftMotor, SpeedController &rearLeftMotor, SpeedController &frontRightMotor, SpeedController &rearRightMotor)
virtual	~RobotDrive ()
void	Drive (float outputMagnitude, float curve)
void	TankDrive (GenericHID leftStick, GenericHID rightStick)
void	TankDrive (GenericHID &leftStick, GenericHID &rightStick)
void	TankDrive (GenericHID leftStick, UINT32 leftAxis, GenericHID rightStick, UINT32 rightAxis)
void	TankDrive (GenericHID &leftStick, UINT32 leftAxis, GenericHID &rightStick, UINT32 rightAxis)
void	TankDrive (float leftValue, float rightValue)
void	ArcadeDrive (GenericHID *stick, bool squaredInputs=true)
void	ArcadeDrive (GenericHID &stick, bool squaredInputs=true)
void	ArcadeDrive (GenericHID moveStick, UINT32 moveChannel, GenericHID rotateStick, UINT32 rotateChannel, bool squaredInputs=true)
void	ArcadeDrive (GenericHID &moveStick, UINT32 moveChannel, GenericHID &rotateStick, UINT32 rotateChannel, bool squaredInputs=true)
void	ArcadeDrive (float moveValue, float rotateValue, bool squaredInputs=true)
void	MecanumDrive_Cartesian (float x, float y, float rotation, float gyroAngle=0.0)
void	MecanumDrive_Polar (float magnitude, float direction, float rotation)
void	HolonomicDrive (float magnitude, float direction, float rotation)
virtual void	SetLeftRightMotorOutputs (float leftOutput, float rightOutput)
void	SetInvertedMotor (MotorType motor, bool isInverted)
void	SetSensitivity (float sensitivity)
void	SetMaxOutput (double maxOutput)
void	SetExpiration (float timeout)
float	GetExpiration ()
bool	IsAlive ()
void	StopMotor ()
bool	IsSafetyEnabled ()
void	SetSafetyEnabled (bool enabled)
void	GetDescription (char *desc)
Protected Member Functions
void	InitRobotDrive ()
float	Limit (float num)
void	Normalize (double *wheelSpeeds)
void	RotateVector (double &x, double &y, double angle)
Protected Attributes
INT32	m_invertedMotors [kMaxNumberOfMotors]
float	m_sensitivity
double	m_maxOutput
bool	m_deleteSpeedControllers
SpeedController *	m_frontLeftMotor
SpeedController *	m_frontRightMotor
SpeedController *	m_rearLeftMotor
SpeedController *	m_rearRightMotor
MotorSafetyHelper *	m_safetyHelper
Static Protected Attributes
static const INT32	kMaxNumberOfMotors = 4

Detailed Description

Utility class for handling Robot drive based on a definition of the motor configuration. The robot drive class handles basic driving for a robot. Currently, 2 and 4 motor standard drive trains are supported. In the future other drive types like swerve and meccanum might be implemented. Motor channel numbers are passed supplied on creation of the class. Those are used for either the Drive function (intended for hand created drive code, such as autonomous) or with the Tank/Arcade functions intended to be used for Operator Control driving.

Constructor & Destructor Documentation

RobotDrive::RobotDrive	(	UINT32	leftMotorChannel,
		UINT32	rightMotorChannel
	)

Constructor for RobotDrive with 2 motors specified with channel numbers. Set up parameters for a two wheel drive system where the left and right motor pwm channels are specified in the call. This call assumes Jaguars for controlling the motors.

Parameters:

leftMotorChannel	The PWM channel number on the default digital module that drives the left motor.
rightMotorChannel	The PWM channel number on the default digital module that drives the right motor.

RobotDrive::RobotDrive	(	UINT32	frontLeftMotor,
		UINT32	rearLeftMotor,
		UINT32	frontRightMotor,
		UINT32	rearRightMotor
	)

Constructor for RobotDrive with 4 motors specified with channel numbers. Set up parameters for a four wheel drive system where all four motor pwm channels are specified in the call. This call assumes Jaguars for controlling the motors.

Parameters:

frontLeftMotor	Front left motor channel number on the default digital module
rearLeftMotor	Rear Left motor channel number on the default digital module
frontRightMotor	Front right motor channel number on the default digital module
rearRightMotor	Rear Right motor channel number on the default digital module

RobotDrive::RobotDrive	(	SpeedController *	leftMotor,
		SpeedController *	rightMotor
	)

Constructor for RobotDrive with 2 motors specified as SpeedController objects. The SpeedController version of the constructor enables programs to use the RobotDrive classes with subclasses of the SpeedController objects, for example, versions with ramping or reshaping of the curve to suit motor bias or deadband elimination.

Parameters:

leftMotor	The left SpeedController object used to drive the robot.
rightMotor	the right SpeedController object used to drive the robot.

RobotDrive::RobotDrive	(	SpeedController *	frontLeftMotor,
		SpeedController *	rearLeftMotor,
		SpeedController *	frontRightMotor,
		SpeedController *	rearRightMotor
	)

Constructor for RobotDrive with 4 motors specified as SpeedController objects. Speed controller input version of RobotDrive (see previous comments).

Parameters:

rearLeftMotor	The back left SpeedController object used to drive the robot.
frontLeftMotor	The front left SpeedController object used to drive the robot
rearRightMotor	The back right SpeedController object used to drive the robot.
frontRightMotor	The front right SpeedController object used to drive the robot.

RobotDrive::~RobotDrive ( ) [virtual]

RobotDrive destructor. Deletes motor objects that were not passed in and created internally only.

Member Function Documentation

void RobotDrive::ArcadeDrive	(	GenericHID *	stick,
		bool	squaredInputs = `true`
	)

Arcade drive implements single stick driving. Given a single Joystick, the class assumes the Y axis for the move value and the X axis for the rotate value. (Should add more information here regarding the way that arcade drive works.)

Parameters:

stick	The joystick to use for Arcade single-stick driving. The Y-axis will be selected for forwards/backwards and the X-axis will be selected for rotation rate.
squaredInputs	If true, the sensitivity will be increased for small values

void RobotDrive::ArcadeDrive	(	GenericHID &	stick,
		bool	squaredInputs = `true`
	)

Arcade drive implements single stick driving. Given a single Joystick, the class assumes the Y axis for the move value and the X axis for the rotate value. (Should add more information here regarding the way that arcade drive works.)

Parameters:

stick	The joystick to use for Arcade single-stick driving. The Y-axis will be selected for forwards/backwards and the X-axis will be selected for rotation rate.
squaredInputs	If true, the sensitivity will be increased for small values

void RobotDrive::ArcadeDrive	(	GenericHID *	moveStick,
		UINT32	moveAxis,
		GenericHID *	rotateStick,
		UINT32	rotateAxis,
		bool	squaredInputs = `true`
	)

Arcade drive implements single stick driving. Given two joystick instances and two axis, compute the values to send to either two or four motors.

Parameters:

moveStick	The Joystick object that represents the forward/backward direction
moveAxis	The axis on the moveStick object to use for fowards/backwards (typically Y_AXIS)
rotateStick	The Joystick object that represents the rotation value
rotateAxis	The axis on the rotation object to use for the rotate right/left (typically X_AXIS)
squaredInputs	Setting this parameter to true increases the sensitivity at lower speeds

void RobotDrive::ArcadeDrive	(	GenericHID &	moveStick,
		UINT32	moveAxis,
		GenericHID &	rotateStick,
		UINT32	rotateAxis,
		bool	squaredInputs = `true`
	)

Arcade drive implements single stick driving. Given two joystick instances and two axis, compute the values to send to either two or four motors.

Parameters:

moveStick	The Joystick object that represents the forward/backward direction
moveAxis	The axis on the moveStick object to use for fowards/backwards (typically Y_AXIS)
rotateStick	The Joystick object that represents the rotation value
rotateAxis	The axis on the rotation object to use for the rotate right/left (typically X_AXIS)
squaredInputs	Setting this parameter to true increases the sensitivity at lower speeds

void RobotDrive::ArcadeDrive	(	float	moveValue,
		float	rotateValue,
		bool	squaredInputs = `true`
	)

Arcade drive implements single stick driving. This function lets you directly provide joystick values from any source.

Parameters:

moveValue	The value to use for fowards/backwards
rotateValue	The value to use for the rotate right/left
squaredInputs	If set, increases the sensitivity at low speeds

void RobotDrive::Drive	(	float	outputMagnitude,
		float	curve
	)

Drive the motors at "speed" and "curve".

The speed and curve are -1.0 to +1.0 values where 0.0 represents stopped and not turning. The algorithm for adding in the direction attempts to provide a constant turn radius for differing speeds.

This function will most likely be used in an autonomous routine.

Parameters:

outputMagnitude	The forward component of the output magnitude to send to the motors.
curve	The rate of turn, constant for different forward speeds.

void RobotDrive::HolonomicDrive	(	float	magnitude,
		float	direction,
		float	rotation
	)

Holonomic Drive method for Mecanum wheeled robots.

This is an alias to MecanumDrive_Polar() for backward compatability

Parameters:

magnitude	The speed that the robot should drive in a given direction. [-1.0..1.0]
direction	The direction the robot should drive. The direction and maginitute are independent of the rotation rate.
rotation	The rate of rotation for the robot that is completely independent of the magnitute or direction. [-1.0..1.0]

void RobotDrive::InitRobotDrive ( ) [protected]

Common function to initialize all the robot drive constructors. Create a motor safety object (the real reason for the common code) and initialize all the motor assignments. The default timeout is set for the robot drive.

float RobotDrive::Limit ( float num ) [protected]

Limit motor values to the -1.0 to +1.0 range.

void RobotDrive::MecanumDrive_Cartesian	(	float	x,
		float	y,
		float	rotation,
		float	gyroAngle = `0.0`
	)

Drive method for Mecanum wheeled robots.

A method for driving with Mecanum wheeled robots. There are 4 wheels on the robot, arranged so that the front and back wheels are toed in 45 degrees. When looking at the wheels from the top, the roller axles should form an X across the robot.

This is designed to be directly driven by joystick axes.

Parameters:

x	The speed that the robot should drive in the X direction. [-1.0..1.0]
y	The speed that the robot should drive in the Y direction. This input is inverted to match the forward == -1.0 that joysticks produce. [-1.0..1.0]
rotation	The rate of rotation for the robot that is completely independent of the translation. [-1.0..1.0]
gyroAngle	The current angle reading from the gyro. Use this to implement field-oriented controls.

void RobotDrive::MecanumDrive_Polar	(	float	magnitude,
		float	direction,
		float	rotation
	)

Drive method for Mecanum wheeled robots.

A method for driving with Mecanum wheeled robots. There are 4 wheels on the robot, arranged so that the front and back wheels are toed in 45 degrees. When looking at the wheels from the top, the roller axles should form an X across the robot.

Parameters:

magnitude	The speed that the robot should drive in a given direction. [-1.0..1.0]
direction	The direction the robot should drive in degrees. The direction and maginitute are independent of the rotation rate.
rotation	The rate of rotation for the robot that is completely independent of the magnitute or direction. [-1.0..1.0]

void RobotDrive::Normalize ( double * wheelSpeeds ) [protected]

Normalize all wheel speeds if the magnitude of any wheel is greater than 1.0.

void RobotDrive::RotateVector	(	double &	x,
		double &	y,
		double	angle
	)		`[protected]`

Rotate a vector in Cartesian space.

void RobotDrive::SetLeftRightMotorOutputs	(	float	leftOutput,
		float	rightOutput
	)		`[virtual]`

Set the speed of the right and left motors. This is used once an appropriate drive setup function is called such as TwoWheelDrive(). The motors are set to "leftOutput" and "rightOutput" and includes flipping the direction of one side for opposing motors.

Parameters:

leftOutput	The speed to send to the left side of the robot.
rightOutput	The speed to send to the right side of the robot.

void RobotDrive::SetMaxOutput ( double maxOutput )

Configure the scaling factor for using RobotDrive with motor controllers in a mode other than PercentVbus.

Parameters:

maxOutput Multiplied with the output percentage computed by the drive functions.

void RobotDrive::SetSensitivity ( float sensitivity )

Set the turning sensitivity.

This only impacts the Drive() entry-point.

Parameters:

sensitivity Effectively sets the turning sensitivity (or turn radius for a given value)

void RobotDrive::TankDrive	(	float	leftValue,
		float	rightValue
	)

Provide tank steering using the stored robot configuration. This function lets you directly provide joystick values from any source.

Parameters:

leftValue	The value of the left stick.
rightValue	The value of the right stick.

void RobotDrive::TankDrive	(	GenericHID *	leftStick,
		GenericHID *	rightStick
	)

Provide tank steering using the stored robot configuration. Drive the robot using two joystick inputs. The Y-axis will be selected from each Joystick object.

Parameters:

leftStick	The joystick to control the left side of the robot.
rightStick	The joystick to control the right side of the robot.

void RobotDrive::TankDrive	(	GenericHID *	leftStick,
		UINT32	leftAxis,
		GenericHID *	rightStick,
		UINT32	rightAxis
	)

Provide tank steering using the stored robot configuration. This function lets you pick the axis to be used on each Joystick object for the left and right sides of the robot.

Parameters:

leftStick	The Joystick object to use for the left side of the robot.
leftAxis	The axis to select on the left side Joystick object.
rightStick	The Joystick object to use for the right side of the robot.
rightAxis	The axis to select on the right side Joystick object.

The documentation for this class was generated from the following files:

RobotDrive.h
RobotDrive.cpp

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation