motor::roboclaw::RoboClaw Class Reference

RoboClaw 2 motor controller class. More...

#include <RoboClaw.h>

Public Member Functions
	RoboClaw (RoboClawComm &comm, const byte_t address=AddrDft, const std::string &strNameId="RoboClaw")
	Initialization constructor. More...
virtual	~RoboClaw ()
	Destructor.
virtual bool	probe (byte_t address)
	Probe address of motor controller. More...
RoboClawComm &	getComm ()
	Get RoboClaw's bound communication object. More...
bool	isOpen () const
	Test if connection is open. More...
byte_t	getAddress () const
	Get the controller address associated with this class instance. More...
void	setAddress (byte_t address)
	Set class instance address. More...
std::string	getNameId () const
	Get class instance name identifier. More...
void	setNameId (const std::string &strNameId)
	Set class instance name identifier. More...
virtual byte_t	getMotorDir (int motor) const
	Get the direction of motor rotation. More...
virtual void	setMotorDir (int motor, int motorDir)
	set the direction of motor rotation. More...
void	getMainBattCutoffRange (double &minmin, double &maxmax) const
	Get the RoboClaw's main battery minimum and maximum voltage cutoff settable range. More...
void	getLogicCutoffRange (double &minmin, double &maxmax) const
	Get the RoboClaw's logic minimum and maximum voltage cutoff settable range. More...
virtual int	cmdReadFwVersion (std::string &strFwVer)
	Read the RoboClaw's firmware version. More...
virtual int	cmdReadMainBattVoltage (double &volts)
	Read the RoboClaw's main battery input voltage. More...
virtual int	cmdReadMainBattCutoffs (double &min, double &max)
	Read the RoboClaw's main battery minimum and maximum voltage cutoff settings. More...
virtual int	cmdSetMainBattCutoffs (const double min, const double max)
	Set the RoboClaw's main battery minimum and maximum voltage cutoff settings. More...
virtual int	cmdReadLogicVoltage (double &volts)
	Read the RoboClaw's LB-/LB+ terminals input voltage powered by and optional logic dedicated battery. More...
virtual int	cmdReadLogicCutoffs (double &min, double &max)
	Read the RoboClaw's optional logic dedicated battery minimum and maximum voltage cutoff settings. The battery is connected to the LB-/LB+ terminals. More...
virtual int	cmdSetLogicCutoffs (const double min, const double max)
	Set the RoboClaw's optional logic dedicated battery minimum and maximum voltage cutoff settings. The battery is connected to the LB-/LB+ terminals. More...
virtual int	cmdReadVelocityPidConst (int motor, u32_t &Kp, u32_t &Ki, u32_t &Kd, u32_t &qpps)
	Read motor's velocity PID constants. More...
virtual int	cmdSetVelocityPidConst (int motor, const u32_t Kp, const u32_t Ki, const u32_t Kd, const u32_t qpps)
	Set motor's velocity PID constants. More...
virtual int	cmdReadMotorCurrentDraw (double &amps1, double &amps2)
	Read the motors ampere draw. More...
virtual int	cmdReadMotorMaxCurrentLimit (int motor, double &maxAmps)
	Read a motor's maximum current limit. More...
virtual int	cmdSetMotorMaxCurrentLimit (int motor, const double maxAmps)
	Set a motor's maximum current limit. More...
virtual int	cmdReadBoardTemperature (double &temp)
	Read RoboClaw board's temperature. More...
virtual int	cmdReadStatus (uint_t &status)
	Read RoboClaw board's status bits. More...
virtual int	cmdReadCmdBufLengths (uint_t &len1, uint_t &len2)
	Read RoboClaw board's temperature. More...
virtual int	cmdReadEncoderMode (byte_t &mode1, byte_t &mode2)
	Read encoder mode. More...
virtual int	cmdSetEncoderMode (int motor, byte_t mode)
	Set a motor's encoder mode. More...
virtual int	cmdSetEncoderMode2 (byte_t mode1, byte_t mode2)
	Set both motors' encoder mode. More...
virtual int	cmdResetQEncoders ()
	Reset both motors' encoders. More...
virtual int	cmdReadQEncoder (int motor, s64_t &encoder)
	Read motor's encoder. More...
virtual int	cmdDutyDrive2 (double duty1, double duty2)
	Drive both motors at the given duty cycle. More...
virtual int	cmdReadQSpeed (int motor, s32_t &speed)
	Read motor's speed. More...
virtual int	cmdQDrive (int motor, s32_t speed)
	Drive a motor at the given speed. More...
virtual int	cmdQDrive2 (s32_t speed1, s32_t speed2)
	Drive both motors at the given speeds. More...
virtual int	cmdQDriveWithAccel (int motor, s32_t speed, u32_t accel)
	Drive a motor at the given speed and with the given acceleration. More...
virtual int	cmdQDriveWithAccel (s32_t speed1, u32_t accel1, s32_t speed2, u32_t accel2)
	Drive both motors at the given speeds and with the given accelerations. More...
virtual int	cmdQDriveForDist (int motor, s32_t speed, u32_t dist, bool bQueue=true)
	Drive a motor at the given speed for a given distance. More...
virtual int	cmdQDriveForDist (s32_t speed1, u32_t dist1, s32_t speed2, u32_t dist2, bool bQueue=true)
	Drive both motors at the given speeds for a given distances. More...
virtual int	cmdQDriveWithAccelForDist (int motor, s32_t speed, u32_t accel, u32_t dist, bool bQueue=true)
	Drive a motor at the given speed with the given acceleration for the given distance. More...
virtual int	cmdQDriveWithAccelForDist (s32_t speed1, u32_t accel1, u32_t dist1, s32_t speed2, u32_t accel2, u32_t dist2, bool bQueue=true)
	Drive both motors at the given speeds with the given accelerations for the given distances. More...
virtual int	cmdQDriveWithProfileToPos (int motor, s32_t speed, u32_t accel, u32_t deccel, s32_t pos, bool bQueue=true)
	Drive a motor at the given speed with the given acceleration/ decceleration profile to the given absolute position. More...
virtual int	cmdQDriveWithProfileToPos (s32_t speed1, u32_t accel1, u32_t deccel1, s32_t pos1, s32_t speed2, u32_t accel2, u32_t deccel2, s32_t pos2, bool bQueue=true)
	Drive both motors at the given speeds with the given acceleration/decceleration profile to the given absolute position. More...
virtual int	cmdQStop ()
	Stop both motors. More...
virtual int	cmdSDrive (int motor, int speed)
	Drive a motor at the given speed. More...
virtual int	cmdSDrive2 (int speed1, int speed2)
	Drive both motors at the given speeds. More...
virtual int	cmdStop (int motor)
	Stop a motor. More...
virtual int	cmdStopWithDecel (int motor, u32_t decel)
	Stop a motor with the given maximum decelerations. More...
virtual int	cmdStop ()
	Stop all motors. More...
virtual int	cmdStopWithDecel (u32_t decel)
	Stop both motors with the given maximum decelerations. More...
virtual int	cmdEStop ()
	Emergency stop all motors. More...
virtual int	cmdWriteSettingsToEEPROM ()
	Write all settings to EEPROM. More...

Protected Member Functions
virtual bool	isValidMotor (int motor) const
	Test if motor index is a valid index. More...

Static Protected Member Functions
static int	abs (int a)
	Integer absolute value. More...
static int	cap (int a, int min, int max)
	Cap value within limits [min, max]. More...
static double	fcap (double a, double min, double max)
	Cap FPN value within limits [min, max]. More...

Protected Attributes
RoboClawComm &	m_comm
	bound communication object
byte_t	m_address
	assigned controller address
std::string	m_strNameId
	controller name identifier
int	m_nMotorDir [NumMotors]
	motor rotation direction sense
s64_t	m_nEncPrev [NumMotors]
	encoder prevous values
s64_t	m_nEncoder [NumMotors]
	64-bit encoder shadow values

Detailed Description

RoboClaw 2 motor controller class.

RoboClaw by Ion Motion Control.

Definition at line 808 of file RoboClaw.h.

Constructor & Destructor Documentation

RoboClaw::RoboClaw	(	RoboClawComm &	comm,
		const byte_t	address = AddrDft,
		const std::string &	strNameId = "RoboClaw"
	)

Initialization constructor.

Parameters

comm	Bound controller communication object.
address	Motor controller address.
strNameId	Motor controller name identifier.

Definition at line 567 of file RoboClaw.cxx.

{
  if( m_comm.isOpen() )
  {
    cmdStop();
  }
}

bool RoboClaw::probe(byte_t address)
{

Member Function Documentation

static int motor::roboclaw::RoboClaw::abs ( int  a )

inlinestaticprotected

Integer absolute value.

Parameters

a	Integer value.

Returns

|a|

Definition at line 1683 of file RoboClaw.h.

       {
         return a>=0? a: -a;
       }

static int motor::roboclaw::RoboClaw::cap ( int  a, int  min, int  max  )

inlinestaticprotected

Cap value within limits [min, max].

Parameters

a	Value.
min	Minimum.
max	Maximum.

Returns

a: min ≤ a ≤ max

Definition at line 1697 of file RoboClaw.h.

       {
         return a<min? min: a>max? max: a;
       }

int RoboClaw::cmdDutyDrive2 ( double  duty1, double  duty2  )

virtual

Drive both motors at the given duty cycle.

Motor quadrature encoders are ignored.

Command Numbers: 34

Parameters

duty1	Motor1 normalized duty cycle [-1.0, 1.0]. Sign indicates direction.
duty2	Motor2 normalized duty cycle [-1.0, 1.0]. Sign indicates direction.

Definition at line 1297 of file RoboClaw.cxx.

References ROBOCLAW_TRY_MOTOR.

Referenced by laelaps::LaeKinActionDutyCycle::execute(), and laelaps::LaeKinActionDutyCycle::terminate().

{
  byte_t  cmd[CmdMaxBufLen];
  byte_t  rsp[RspMaxBufLen];
  size_t  n = 0;

int RoboClaw::cmdEStop ( )

virtual

Emergency stop all motors.

Command Numbers: 37

Definition at line 1729 of file RoboClaw.cxx.

References motor::roboclaw::CmdWriteEEPROM.

int RoboClaw::cmdQDrive ( int  motor, s32_t  speed  )

virtual

Drive a motor at the given speed.

Movement is controlled using quadrature encoders.

Command Numbers: 35, 36

Parameters

motor	Motor index Motor1(0) or Motor2(1).
speed	Motor speed in quad pulses per second. Sign indicates direction.

Definition at line 1356 of file RoboClaw.cxx.

References motor::roboclaw::CmdDriveQ.

                                    : cmd = ", motor, speed);

  return m_comm.execCmdWithAckRsp(cmd, n, MsgWithCrc);
}

// Command 37
int RoboClaw::cmdQDrive2(s32_t speed1, s32_t speed2)
{
  byte_t  cmd[CmdMaxBufLen];
  size_t  k, n = 0;

  speed1 *= m_nMotorDir[Motor1];
  speed2 *= m_nMotorDir[Motor2];

  cmd[n++] = m_address;

int RoboClaw::cmdQDrive2 ( s32_t  speed1, s32_t  speed2  )

virtual

Drive both motors at the given speeds.

Movement is controlled using quadrature encoders.

Command Numbers: 37

Parameters

speed1	Motor1 speed in quad pulses per second. Sign indicates direction.
speed2	Motor2 speed in quad pulses per second. Sign indicates direction.

Definition at line 1378 of file RoboClaw.cxx.

References motor::roboclaw::CmdDriveQAccelMot1, motor::roboclaw::CmdDriveQAccelMot2, and ROBOCLAW_TRY_MOTOR.

{
  byte_t  cmd[CmdMaxBufLen];
  size_t  k, n = 0;

  ROBOCLAW_TRY_MOTOR(motor);

  speed *= m_nMotorDir[motor];

int RoboClaw::cmdQDriveForDist ( int  motor, s32_t  speed, u32_t  dist, bool  bQueue = true  )

virtual

Drive a motor at the given speed for a given distance.

Movement is controlled using quadrature encoders.

This is a buffered command. Commands execute immediatly if no commands are already in the motor drive queue or if the queue paramter is false. Otherwise, the command is placed at end of the command buffer execution queue.

Command Numbers: 41, 42

Parameters

motor	Motor index Motor1(0) or Motor2(1).
speed	Motor speed in quad pulses per second. Sign indicates direction.
dist	Distance from current position (quad pulses).
bQueue	Do [not] queue the command. If false, the motor drive queue is flushed and any existing command is preempted by this command.

Definition at line 1449 of file RoboClaw.cxx.

                                     : ParamCmdBufPreempt;

  return m_comm.execCmdWithAckRsp(cmd, n, MsgWithCrc);
}

// Command 43
int RoboClaw::cmdQDriveForDist(s32_t speed1, u32_t dist1,
                               s32_t speed2, u32_t dist2,
                               bool  bQueue)
{
  byte_t  cmd[CmdMaxBufLen];
  size_t  k, n = 0;

  speed1 *= m_nMotorDir[Motor1];
  speed2 *= m_nMotorDir[Motor2];

int RoboClaw::cmdQDriveForDist ( s32_t  speed1, u32_t  dist1, s32_t  speed2, u32_t  dist2, bool  bQueue = true  )

virtual

Drive both motors at the given speeds for a given distances.

Movement is controlled using quadrature encoders.

This is a buffered command. Commands execute immediatly if no commands are already in the motor drive queue or if the queue paramter is false. Otherwise, the command is placed at end of the command buffer execution queue.

Command Numbers: 43

Parameters

speed1	Motor1 speed in quad pulses per second. Sign indicates direction.
dist1	Motor1 distance from current position (quad pulses).
speed2	Motor2 speed in quad pulses per second. Sign indicates direction.
dist2	Motor2 distance from current position (quad pulses).
bQueue	Do [not] queue the command. If false, the motor drive queue is flushed and any existing command is preempted by this command.

Definition at line 1473 of file RoboClaw.cxx.

References motor::roboclaw::CmdBufDriveQDist, and ROBOCLAW_TRY_MOTOR.

                                     : ParamCmdBufPreempt;

  return m_comm.execCmdWithAckRsp(cmd, n, MsgWithCrc);
}

// Command 44, 45
int RoboClaw::cmdQDriveWithAccelForDist(int   motor,
                                        s32_t speed,
                                        u32_t accel,
                                        u32_t dist,
                                        bool  bQueue)
{
  byte_t  cmd[CmdMaxBufLen];
  size_t  k, n = 0;

int RoboClaw::cmdQDriveWithAccel ( int  motor, s32_t  speed, u32_t  accel  )

virtual

Drive a motor at the given speed and with the given acceleration.

Movement is controlled using quadrature encoders.

Command Numbers: 38, 39

Parameters

motor	Motor index Motor1(0) or Motor2(1).
speed	Motor speed in quad pulses per second. Sign indicates direction.
accel	Acceleration (qpps/s).

Definition at line 1399 of file RoboClaw.cxx.

References motor::roboclaw::CmdDriveQAccel2.

Referenced by laelaps::LaeKinActionVelocity::execute(), and laelaps::LaeKinActionTwist::execute().

{
  byte_t  cmd[CmdMaxBufLen];
  size_t  k, n = 0;

  speed1 *= m_nMotorDir[Motor1];
  speed2 *= m_nMotorDir[Motor2];

int RoboClaw::cmdQDriveWithAccel ( s32_t  speed1, u32_t  accel1, s32_t  speed2, u32_t  accel2  )

virtual

Drive both motors at the given speeds and with the given accelerations.

Movement is controlled using quadrature encoders.

Command Numbers: 50

Parameters

speed1	Motor1 speed in quad pulses per second. Sign indicates direction.
accel1	Motor1 acceleration (qpps/s).
speed2	Motor2 speed in quad pulses per second. Sign indicates direction.
accel2	Motor2 acceleration (qpps/s).

Definition at line 1421 of file RoboClaw.cxx.

References motor::roboclaw::CmdBufDriveQDistMot1, motor::roboclaw::CmdBufDriveQDistMot2, and ROBOCLAW_TRY_MOTOR.

{
  byte_t  cmd[CmdMaxBufLen];
  size_t  k, n = 0;

  ROBOCLAW_TRY_MOTOR(motor);

  speed *= m_nMotorDir[motor];

int RoboClaw::cmdQDriveWithAccelForDist ( int  motor, s32_t  speed, u32_t  accel, u32_t  dist, bool  bQueue = true  )

virtual

Drive a motor at the given speed with the given acceleration for the given distance.

Movement is controlled using quadrature encoders.

This is a buffered command. Commands execute immediatly if no commands are already in the motor drive queue or if the queue paramter is false. Otherwise, the command is placed at end of the command buffer execution queue.

Command Numbers: 44, 45

Parameters

motor	Motor index Motor1(0) or Motor2(1).
speed	Speed in quad pulses per second. Sign indicates direction.
accel	Acceleration (qpps/s).
dist	Distance from current position (quad pulses).
bQueue	Do [not] queue the command. If false, the motor drive queue is flushed and any existing command is preempted by this command.

Definition at line 1504 of file RoboClaw.cxx.

References motor::roboclaw::CmdBufDriveQAccelDistMot1, and motor::roboclaw::CmdBufDriveQAccelDistMot2.

                                                       :
                              CmdBufDriveQAccelDistMot2;

  k  = m_comm.pack32((uint_t)accel, cmd+n);
  n += k;

  k  = m_comm.pack32((int)speed, cmd+n);
  n += k;

  k  = m_comm.pack32((uint_t)dist, cmd+n);
  n += k;

  cmd[n++] = bQueue? ParamCmdBufQueue: ParamCmdBufPreempt;

  return m_comm.execCmdWithAckRsp(cmd, n, MsgWithCrc);
}

// Command 51
int RoboClaw::cmdQDriveWithAccelForDist(s32_t speed1,
                                        u32_t accel1,
                                        u32_t dist1,
                                        s32_t speed2,
                                        u32_t accel2,
                                        u32_t dist2,
                                        bool  bQueue)
{
  byte_t  cmd[CmdMaxBufLen];

int RoboClaw::cmdQDriveWithAccelForDist ( s32_t  speed1, u32_t  accel1, u32_t  dist1, s32_t  speed2, u32_t  accel2, u32_t  dist2, bool  bQueue = true  )

virtual

Drive both motors at the given speeds with the given accelerations for the given distances.

Movement is controlled using quadrature encoders.

This is a buffered command. Commands execute immediatly if no commands are already in the motor drive queue or if the queue paramter is false. Otherwise, the command is placed at end of the command buffer execution queue.

Command Numbers: 51

Parameters

speed1	Motor1 peed in quad pulses per second. Sign indicates direction.
accel1	Motor1 acceleration (qpps/s).
dist1	Motor1 distance from current position (quad pulses).
speed2	Motor2 peed in quad pulses per second. Sign indicates direction.
accel2	Motor2 acceleration (qpps/s).
dist2	Motor2 distance from current position (quad pulses).
bQueue	Do [not] queue the command. If false, the motor drive queue is flushed and any existing command is preempted by this command.

Definition at line 1536 of file RoboClaw.cxx.

References ROBOCLAW_TRY_MOTOR.

                                     : ParamCmdBufPreempt;

  return m_comm.execCmdWithAckRsp(cmd, n, MsgWithCrc);
}

// Command 65, 66
int RoboClaw::cmdQDriveWithProfileToPos(int   motor,
                                        s32_t speed,
                                        u32_t accel,
                                        u32_t deccel,
                                        s32_t pos,
                                        bool  bQueue)
{
  byte_t  cmd[CmdMaxBufLen];
  size_t  k, n = 0;

int RoboClaw::cmdQDriveWithProfileToPos ( int  motor, s32_t  speed, u32_t  accel, u32_t  deccel, s32_t  pos, bool  bQueue = true  )

virtual

Drive a motor at the given speed with the given acceleration/ decceleration profile to the given absolute position.

Movement is controlled using quadrature encoders.

This is a buffered command. Commands execute immediatly if no commands are already in the motor drive queue or if the queue paramter is false. Otherwise, the command is placed at end of the command buffer execution queue.

Command Numbers: 65, 66

Parameters

motor	Motor index Motor1(0) or Motor2(1).
speed	Speed in quad pulses per second. Sign indicates direction.
accel	Acceleration (qpps/s).
deccel	Decceleration (qpps/s).
pos	Goal absolute position (quad pulses).
bQueue	Do [not] queue the command. If false, the motor drive queue is flushed and any existing command is preempted by this command.

Definition at line 1577 of file RoboClaw.cxx.

References motor::roboclaw::CmdBufDriveQProfPosMot1, and motor::roboclaw::CmdBufDriveQProfPosMot2.

                                                     :
                              CmdBufDriveQProfPosMot2;

  k  = m_comm.pack32((uint_t)accel, cmd+n);
  n += k;

  k  = m_comm.pack32((int)speed, cmd+n);
  n += k;

  k  = m_comm.pack32((uint_t)deccel, cmd+n);
  n += k;

  k  = m_comm.pack32((int)pos, cmd+n);
  n += k;

  cmd[n++] = bQueue? ParamCmdBufQueue: ParamCmdBufPreempt;

  return m_comm.execCmdWithAckRsp(cmd, n, MsgWithCrc);
}

// Command 67
int RoboClaw::cmdQDriveWithProfileToPos(s32_t speed1,
                                        u32_t accel1,
                                        u32_t deccel1,
                                        s32_t pos1,
                                        s32_t speed2,
                                        u32_t accel2,
                                        u32_t deccel2,
                                        s32_t pos2,
                                        bool  bQueue)

int RoboClaw::cmdQDriveWithProfileToPos ( s32_t  speed1, u32_t  accel1, u32_t  deccel1, s32_t  pos1, s32_t  speed2, u32_t  accel2, u32_t  deccel2, s32_t  pos2, bool  bQueue = true  )

virtual

Drive both motors at the given speeds with the given acceleration/decceleration profile to the given absolute position.

Movement is controlled using quadrature encoders.

This is a buffered command. Commands execute immediatly if no commands are already in the motor drive queue or if the queue paramter is false. Otherwise, the command is placed at end of the command buffer execution queue.

Command Numbers: 67

Parameters

speed1	Motor1 speed in quad pulses per second. Sign indicates direction.
accel1	Motor1 acceleration (qpps/s).
deccel1	Motor1 decceleration (qpps/s).
pos1	Motor1 goal absolute position (quad pulses).
speed2	Motor2 speed in quad pulses per second. Sign indicates direction.
accel2	Motor2 acceleration (qpps/s).
deccel2	Motor2 decceleration (qpps/s).
pos2	Motor2 goal absolute position (quad pulses).
bQueue	Do [not] queue the command. If false, the motor drive queue is flushed and any existing command is preempted by this command.

Definition at line 1613 of file RoboClaw.cxx.

References laelaps::cap(), motor::roboclaw::CmdBufDriveQProfPos, and ROBOCLAW_TRY_MOTOR.

                                     : ParamCmdBufPreempt;

  return m_comm.execCmdWithAckRsp(cmd, n, MsgWithCrc);
}

// Command 0, 1, 4, 5
int RoboClaw::cmdSDrive(int motor, int speed)
{
  byte_t  cmd[CmdMaxBufLen];
  size_t  n = 0;

  ROBOCLAW_TRY_MOTOR(motor);

  speed  = RoboClaw::cap(speed, MotorSpeedMaxBackward, MotorSpeedMaxForward);
  speed *= m_nMotorDir[motor];

virtual int motor::roboclaw::RoboClaw::cmdQStop ( )

inlinevirtual

Stop both motors.

Movement is controlled using quadrature encoders, with 0 being stop.

Command Numbers: 37

Definition at line 1543 of file RoboClaw.h.

      {
        return cmdQDrive2(0, 0);
      }

int RoboClaw::cmdReadBoardTemperature ( double &  temp )

virtual

Read RoboClaw board's temperature.

Command Numbers: 82

Parameters

[out]

temp

Board temperature (C)

Definition at line 1034 of file RoboClaw.cxx.

References motor::roboclaw::CmdReadStatus.

  {
    m_comm.unpack16(rsp, val);
    temp = (double)val * ParamTempScale;
  }

  return rc;
}

// Command 90
int RoboClaw::cmdReadStatus(uint_t &status)
{
  byte_t  cmd[CmdMaxBufLen];
  byte_t  rsp[RspMaxBufLen];
  size_t  n = 0;
  uint_t  val;
  int     rc;

  cmd[n++] = m_address;

int RoboClaw::cmdReadCmdBufLengths ( uint_t &  len1, uint_t &  len2  )

virtual

Read RoboClaw board's temperature.

Command Numbers: 47

Parameters

[out]	len1	Motor1 command buffer length.
[out]	len2	Motor2 command buffer length.

Definition at line 1075 of file RoboClaw.cxx.

References motor::roboclaw::CmdReadEncoderMode.

  {
    len1 = (uint_t)rsp[0];
    len2 = (uint_t)rsp[1];
  }

  return rc;
}

// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Encoder Commands
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

// Command 91
int RoboClaw::cmdReadEncoderMode(byte_t &mode1, byte_t &mode2)
{
  byte_t  cmd[CmdMaxBufLen];
  byte_t  rsp[RspMaxBufLen];
  size_t  n = 0;

int RoboClaw::cmdReadEncoderMode ( byte_t &  mode1, byte_t &  mode2  )

virtual

Read encoder mode.

Command Numbers: 91

Parameters

[out]	mode1	Motor1 encoder mode.
[out]	mode2	Motor2 encoder mode.

Definition at line 1100 of file RoboClaw.cxx.

References motor::roboclaw::CmdSetEncoderModeMot1, motor::roboclaw::CmdSetEncoderModeMot2, and ROBOCLAW_TRY_MOTOR.

  {
    mode1 = rsp[0];
    mode2 = rsp[1];
    //LOGDIAG3("Motor controller 0x%02x: mode1=0x%02x, mode2=0x%02x.",
    //    m_address, mode1, mode2);
  }

  return rc;
}

// Command 92, 93
int RoboClaw::cmdSetEncoderMode(int motor, byte_t mode)
{
  byte_t  cmd[CmdMaxBufLen];
  byte_t  mask = ParamEncModeRCAnalogBit | ParamEncModeQuadAbsBit;
  size_t  n = 0;

  ROBOCLAW_TRY_MOTOR(motor);

  cmd[n++] = m_address;

int RoboClaw::cmdReadFwVersion ( std::string &  strFwVer )

virtual

Read the RoboClaw's firmware version.

Command Numbers: 21

Parameters

[out]

strFwVer

Read version string.

Definition at line 608 of file RoboClaw.cxx.

References motor::roboclaw::CmdReadMainBattVolt.

  {
    return RC_ERROR;
  }

  n = m_comm.recvDataRsp(rsp, ParamVerLen);

  if( n > ParamVerLenMin )
  {
    //
    // Validate CRC 
    //
    uCrcCmd  = m_comm.getLastCmdCrc();
    uCrcRsp  = m_comm.getLastRspCrc();
    uCrcCalc = m_comm.crc16(uCrcCmd, rsp, n-2);

    if( uCrcRsp != uCrcCalc )
    {
      LOGERROR("Motor controller 0x%02x: "
            "Command %u response CRC-16 mismatch: "
            "Expected 0x%04x, received 0x%04x.",
            cmd[FieldPosAddr], cmd[FieldPosCmd],
            uCrcCalc, uCrcRsp);
      return RC_ERROR;
    }

    rsp[n-ParamVerLenMin] = 0;  // take off trailing junk
    strFwVer = (char *)rsp;     // convert to string

    LOGDIAG3("%s.", strFwVer.c_str());

    return OK;
  }
  else
  {
    LOGERROR("Motor controller 0x%02x: "
        "Failed to receive firmware version.",
            m_address);
    return RC_ERROR;
  }
}

// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Main Battery Voltage Commands
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

// Command 24
int RoboClaw::cmdReadMainBattVoltage(double &volts)
{
  byte_t  cmd[CmdMaxBufLen];
  byte_t  rsp[RspMaxBufLen];
  size_t  n = 0;

int RoboClaw::cmdReadLogicCutoffs ( double &  min, double &  max  )

virtual

Read the RoboClaw's optional logic dedicated battery minimum and maximum voltage cutoff settings. The battery is connected to the LB-/LB+ terminals.

Command Numbers: 60

Parameters

[out]	min	Minimum voltage (V).
[out]	max	Maximum voltage (V).

Definition at line 900 of file RoboClaw.cxx.

References laelaps::fcap(), and ROBOCLAW_DBG.

  {
    n   = m_comm.unpack16(rsp, valMin);
    n  += m_comm.unpack16(rsp+n, valMax);

    ROBOCLAW_DBG(cmd[FieldPosAddr], cmd[FieldPosCmd],
        "Logic Cutoffs [%u, %u]\n", valMin, valMax);

    min = (double)valMin * ParamVoltScale;
    max = (double)valMax * ParamVoltScale;
  }

  return rc;
}

// Command 58
int RoboClaw::cmdSetLogicCutoffs(const double min, const double max)
{
  byte_t  cmd[CmdMaxBufLen];
  size_t  k, n = 0;
  double  fMin, fMax;
  uint_t  valMin, valMax;
  int     rc;

  fMin    = min / ParamVoltScale;

int RoboClaw::cmdReadLogicVoltage ( double &  volts )

virtual

Read the RoboClaw's LB-/LB+ terminals input voltage powered by and optional logic dedicated battery.

Command Numbers: 25

Parameters

[out]

volts

Voltage (V).

Definition at line 873 of file RoboClaw.cxx.

  {
    m_comm.unpack16(rsp, val);
    volts = (double)val * ParamVoltScale;
  }

  return rc;
}

void RoboClaw::getLogicCutoffRange(double &minmin, double &maxmax) const
{
  minmin = ParamVoltLogicMin;
  maxmax = ParamVoltMax;
}

// Command 60
int RoboClaw::cmdReadLogicCutoffs(double &min, double &max)
{
  byte_t  cmd[CmdMaxBufLen];

int RoboClaw::cmdReadMainBattCutoffs ( double &  min, double &  max  )

virtual

Read the RoboClaw's main battery minimum and maximum voltage cutoff settings.

Command Numbers: 59

Parameters

[out]	min	Minimum voltage (V).
[out]	max	Maximum voltage (V).

Definition at line 694 of file RoboClaw.cxx.

References laelaps::fcap(), and ROBOCLAW_DBG.

  {
    n   = m_comm.unpack16(rsp, valMin);
    n  += m_comm.unpack16(rsp+n, valMax);

    ROBOCLAW_DBG(cmd[FieldPosAddr], cmd[FieldPosCmd],
        "MainBatt Cutoffs [%u, %u]\n", valMin, valMax);

    min = (double)valMin * ParamVoltScale;
    max = (double)valMax * ParamVoltScale;
  }

  return rc;
}

// Command 57
int RoboClaw::cmdSetMainBattCutoffs(const double min, const double max)
{
  byte_t  cmd[CmdMaxBufLen];
  size_t  k, n = 0;
  double  fMin, fMax;
  uint_t  valMin, valMax;
  int     rc;

  fMin    = min / ParamVoltScale;

int RoboClaw::cmdReadMainBattVoltage ( double &  volts )

virtual

Read the RoboClaw's main battery input voltage.

Command Numbers: 24

Parameters

[out]

volts

Voltage (V).

Definition at line 667 of file RoboClaw.cxx.

  {
    m_comm.unpack16(rsp, val);
    volts = (double)val * ParamVoltScale;
  }

  return rc;
}

void RoboClaw::getMainBattCutoffRange(double &minmin, double &maxmax) const
{
  minmin = ParamVoltMainMin;
  maxmax = ParamVoltMax;
}

// Command 59
int RoboClaw::cmdReadMainBattCutoffs(double &min, double &max)
{
  byte_t  cmd[CmdMaxBufLen];

int RoboClaw::cmdReadMotorCurrentDraw ( double &  amps1, double &  amps2  )

virtual

Read the motors ampere draw.

Command Numbers: 49

Parameters

[out]	amps1	Motor1 current draw (amperes)
[out]	amps2	Motor2 current draw (amperes)

Definition at line 761 of file RoboClaw.cxx.

References motor::roboclaw::CmdReadMaxCurrentMot1, and motor::roboclaw::CmdReadMaxCurrentMot2.

  {
    n = 0;

    k = m_comm.unpack16(rsp, val1);
    n += k;

    k  = m_comm.unpack16(rsp+n, val2);
    n += k;

    amps1 = (double)val1 * ParamAmpScale;
    amps2 = (double)val2 * ParamAmpScale;
  }

  return rc;
}

// Command 135, 136
//
// Note: RoboClaw User Manual v5 error. Each value is 32 bits.
//
int RoboClaw::cmdReadMotorMaxCurrentLimit(int motor, double &maxAmps)
{
  byte_t  cmd[CmdMaxBufLen];
  byte_t  rsp[RspMaxBufLen];
  size_t  k, n = 0;
  uint_t  val1, val2;

int RoboClaw::cmdReadMotorMaxCurrentLimit ( int  motor, double &  maxAmps  )

virtual

Read a motor's maximum current limit.

Command Numbers: 136, 137

Parameters

	motor	Motor index Motor1(0) or Motor2(1).
[out]	maxAmps	Motor maximum current limit (amperes)

Definition at line 793 of file RoboClaw.cxx.

  {
    n = 0;

    k = m_comm.unpack32(rsp, val1);
    n += k;

    k  = m_comm.unpack32(rsp+n, val2);
    n += k;

    maxAmps = (double)val1 * ParamAmpScale;
    minAmps = (double)val2 * ParamAmpScale;
  }

  m_comm.enableDbg(false);

  return rc;
}

// Command 133, 134
//
// Note: RoboClaw User Manual v5 error. Each value is 32 bits.
//
int RoboClaw::cmdSetMotorMaxCurrentLimit(int motor, const double maxAmps)
{
  byte_t  cmd[CmdMaxBufLen];
  byte_t  rsp[RspMaxBufLen];
  size_t  k, n = 0;
  double  fMax;

int RoboClaw::cmdReadQEncoder ( int  motor, s64_t &  encoder  )

virtual

Read motor's encoder.

Command Numbers: 16, 17

Parameters

	motor	Motor index Motor1(0) or Motor2(1).
[out]	encoder	Unsigned encoder value (quad pulses).
[out]	status	Status bits indicating sign, and over/under flow.

Definition at line 1174 of file RoboClaw.cxx.

References motor::roboclaw::CmdDriveDuty, motor::roboclaw::CmdReadEncoderMot1, and motor::roboclaw::CmdReadEncoderMot2.

                                                : CmdReadEncoderMot2;

  if( (rc = m_comm.execCmdWithDataRsp(cmd, n, rsp, 7)) == OK )
  {
    ROBOCLAW_DBG_MSG(cmd[FieldPosAddr], cmd[FieldPosCmd], rsp, 7,
        "cmdReadQEncoder(motor=%d): rsp = ", motor);

    //
    // Get 32-bit unsigned encoder value plus its associated status.
    //
    // Note:  This 2-tuple should be atomically kept insync by the firmware but
    //        this is not always the case. During a sharp velocity change
    //        (e.g. stopping) the velocity pid will rightly try to back drive.
    //        The status byte will indicate the _desired_ direction, not the
    //        actual.
    //
    n = m_comm.unpack32(rsp, enc32);
    status = rsp[n];
      
    enc64 = (s64_t)enc32;

    //
    // Debug left_front encoder to reverse engineer and test encoder algorithm.
    //
    //if( m_address == 0x80 && motor == Motor1 && m_nEncPrev[motor] != enc64 )
    //{
    //  fprintf(stderr, "DBG %lld 0x%02x\n", enc64, status);
    //}

    //
    // Track underflow/overflow for now. Not too sure if any action or special
    // calculations are needed.
    //
    // Note: Condition is cleared after reading.
    //
    if( status & ParamEncStatusUnderFlow )
    {
      LOGDIAG2("Motor controller 0x%02x: Motor %d: Encoder underflow: "
                "Encoder32=%u.",
              m_address, motor, enc32);
    }
    if( status & ParamEncStatusOverFlow )
    {
      LOGDIAG2("Motor controller 0x%02x: Motor %d: Encoder overflow: "
                "Encoder32=%u",
              m_address, motor, enc32);
    }

    //
    // Moving backwards. There are two cases:
    //  Case 1: no wrap:  example: previous 1500, current: 1000
    //  Case 2: wrap:     example: previous 15,   current: 4294967200
    //
    if( status & ParamEncStatusDirBackward )
    {
      if( enc64 <= m_nEncPrev[motor] )  // no wrap
      {
        delta = enc64 - m_nEncPrev[motor];
      }
      else  // wrap
      {
        delta = enc64 - ParamEncQuadMax - m_nEncPrev[motor];
        if( iabs(delta) > MaxEncDelta ) // not really backwards
        {
          delta = enc64 - m_nEncPrev[motor];
        }
      }
    }

    //
    // Moving forwards. There are two cases:
    //  Case 1: no wrap:  example: previous 1000,       current: 1500
    //  Case 2: wrap:     example: previous 4294967200, current: 15
    //
    else
    {
      if( enc64 >= m_nEncPrev[motor] ) // no wrap
      {
        delta = enc64 - m_nEncPrev[motor];
      }
      else  // wrap
      {
        delta = enc64 + ParamEncQuadMax - m_nEncPrev[motor];
        if( iabs(delta) > MaxEncDelta ) // not really forwards
        {
          delta = enc64 - m_nEncPrev[motor];
        }
      }
    }

    //
    // Update accumulated value and save current as new previous.
    //
    m_nEncoder[motor] += (m_nMotorDir[motor] * delta);
    m_nEncPrev[motor] = enc64;
    encoder           = m_nEncoder[motor];
  }

  return rc;
}

// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Duty Cycle Commands
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

// Command 34
int RoboClaw::cmdDutyDrive2(double duty1, double duty2)
{
  byte_t  cmd[CmdMaxBufLen];
  int     speed1, speed2;
  size_t  k, n = 0;

int RoboClaw::cmdReadQSpeed ( int  motor, s32_t &  speed  )

virtual

Read motor's speed.

Command Numbers: 18, 19

Parameters

	motor	Motor index Motor1(0) or Motor2(1).
[out]	speed	Signed speed value (qpps).

Definition at line 1323 of file RoboClaw.cxx.

References motor::roboclaw::CmdDriveQMot1, motor::roboclaw::CmdDriveQMot2, motor::roboclaw::CmdReadSpeedMot1, motor::roboclaw::CmdReadSpeedMot2, ROBOCLAW_DBG_MSG, and ROBOCLAW_TRY_MOTOR.

                                              : CmdReadSpeedMot2;

  if( (rc = m_comm.execCmdWithDataRsp(cmd, n, rsp, 7)) == OK )
  {
    ROBOCLAW_DBG_MSG(cmd[FieldPosAddr], cmd[FieldPosCmd], rsp, 7,
        "cmdReadQSpeed(motor=%d): rsp = ", motor);

    n = m_comm.unpack32(rsp, val);
    status = rsp[n];
    speed = (s32_t)val;

    if( status & ParamEncStatusDirBackward )
    {
      speed = -speed;
    }
  }

  return rc;
}

// Command 35, 36
int RoboClaw::cmdQDrive(int motor, s32_t speed)
{
  byte_t  cmd[CmdMaxBufLen];
  size_t  k, n = 0;

  ROBOCLAW_TRY_MOTOR(motor);

  speed *= m_nMotorDir[motor];

int RoboClaw::cmdReadStatus ( uint_t &  status )

virtual

Read RoboClaw board's status bits.

Command Numbers: 90

Parameters

[out]

status

Board status bits.

Definition at line 1055 of file RoboClaw.cxx.

References motor::roboclaw::CmdReadBufLen.

  {
    m_comm.unpack16(rsp, status);
  }

  return rc;
}

// Command 47
int RoboClaw::cmdReadCmdBufLengths(uint_t &len1, uint_t &len2)
{
  byte_t  cmd[CmdMaxBufLen];
  byte_t  rsp[RspMaxBufLen];
  size_t  n = 0;
  uint_t  val;
  int     rc;

  cmd[n++] = m_address;

int RoboClaw::cmdReadVelocityPidConst ( int  motor, u32_t &  Kp, u32_t &  Ki, u32_t &  Kd, u32_t &  qpps  )

virtual

Read motor's velocity PID constants.

Command Numbers: 55, 56

Parameters

	motor	Motor index Motor1(0) or Motor2(1).
[out]	Kp	Velocity PID proportional constant.
[out]	Ki	Velocity PID intergral constant.
[out]	Kd	Velocity PID derivative constant.
[out]	qpps	Maximum speed of motor.

Definition at line 958 of file RoboClaw.cxx.

References motor::roboclaw::CmdReadVelPidMot1, motor::roboclaw::CmdReadVelPidMot2, and ROBOCLAW_DBG.

                                               : CmdReadVelPidMot2;

  if( (rc = m_comm.execCmdWithDataRsp(cmd, n, rsp, 18)) == OK )
  {
    n = 0;

    k = m_comm.unpack32(rsp,   Kp);
    n += k;

    k = m_comm.unpack32(rsp+n, Ki);
    n += k;

    k = m_comm.unpack32(rsp+n, Kd);
    n += k;

    k = m_comm.unpack32(rsp+n, qpps);
    n += k;

    ROBOCLAW_DBG(cmd[FieldPosAddr], cmd[FieldPosCmd],
        "VelPid: motor=%d, P=0x%08x, I=0x%08x, D=0x%08x, Q=%u\n",
        motor, Kp, Ki, Kd, qpps);
  }

  return rc;
}

// Command 28,29
int RoboClaw::cmdSetVelocityPidConst(int         motor,
                                     const u32_t Kp,
                                     const u32_t Ki,
                                     const u32_t Kd,
                                     const u32_t qpps)
{
  byte_t  cmd[CmdMaxBufLen];
  byte_t  rsp[RspMaxBufLen];
  size_t  k, n = 0;

int RoboClaw::cmdResetQEncoders ( )

virtual

Reset both motors' encoders.

Command Numbers: 20

Definition at line 1152 of file RoboClaw.cxx.

    {
      m_nEncPrev[i] = 0;
      m_nEncoder[i] = 0;
    }
  }

  return rc;
}

// Command 16, 17
int RoboClaw::cmdReadQEncoder(int motor, s64_t &encoder)
{
  static s64_t  MaxEncDelta = 2048; // maximum encoder delta on wrap

  byte_t  cmd[CmdMaxBufLen];
  byte_t  rsp[RspMaxBufLen];
  size_t  n = 0;
  uint_t  enc32;      // 32-bit encoder value (quad pulses).
  byte_t  status;     // status bits indicating sign, and over/under flow

int RoboClaw::cmdSDrive ( int  motor, int  speed  )

virtual

Drive a motor at the given speed.

Speeds are scaled from [-max, max] with 0 being stop.

Command Numbers: 0, 1, 4, 5

Parameters

motor	Motor index Motor1(0) or Motor2(1).
speed	Scaled speed [MotorSpeedMaxBackward(-127),MotorSpeedMaxForward(127)]. Sign indicates direction.

Definition at line 1662 of file RoboClaw.cxx.

References motor::roboclaw::CmdDriveBackwardMot1, motor::roboclaw::CmdDriveBackwardMot2, motor::roboclaw::CmdDriveForwardMot1, motor::roboclaw::CmdDriveForwardMot2, and motor::roboclaw::MsgWithCrc.

  {
    cmd[n++] = m_address;
    cmd[n++] = motor == Motor1? CmdDriveForwardMot1: CmdDriveForwardMot2;
    cmd[n++] = (byte_t)speed;
  }
  else
  {
    cmd[n++] = m_address;
    cmd[n++] = motor == Motor1? CmdDriveBackwardMot1: CmdDriveBackwardMot2;
    cmd[n++] = (byte_t)(-speed);
  }

  return m_comm.execCmdWithAckRsp(cmd, n, MsgWithCrc);
}

// Command 0, 1, 4, 5
int RoboClaw::cmdSDrive2(int speed1, int speed2)
{
  int rc;

  if( (rc = cmdSDrive(Motor1, speed1)) == OK )
  {
    rc = cmdSDrive(Motor2, speed2);
  }
  return rc;

int RoboClaw::cmdSDrive2 ( int  speed1, int  speed2  )

virtual

Drive both motors at the given speeds.

Compatibility command. Speeds are scaled from [-max, max] with < 0, 0, > 0 being backwards, stop, and forwards, respectively.

Command Numbers: 0, 1, 4, 5

Parameters

speed1	Motor1 scaled speed [MotorSpeedMaxBackward(-127),MotorSpeedMaxForward(127)]. Sign indicates direction.
speed2	Motor2 scaled speed [MotorSpeedMaxBackward(-127),MotorSpeedMaxForward(127)]. Sign indicates direction.

Definition at line 1689 of file RoboClaw.cxx.

{
  return cmdQDrive(motor, 0);
}

int RoboClaw::cmdSetEncoderMode ( int  motor, byte_t  mode  )

virtual

Set a motor's encoder mode.

The new values are set in volatile memory only. To save to non-volatile memory, issue a write settings to EEPROM command.

Command Numbers: 92, 93

Parameters

motor	Motor index Motor1(0) or Motor2(1).
mode	Motor encoder mode.

Definition at line 1123 of file RoboClaw.cxx.

{
  int rc;

  if( (rc = cmdSetEncoderMode(Motor1, mode1)) == OK )
  {
    rc = cmdSetEncoderMode(Motor2, mode2);
  }

int RoboClaw::cmdSetEncoderMode2 ( byte_t  mode1, byte_t  mode2  )

virtual

Set both motors' encoder mode.

The new values are set in volatile memory only. To save to non-volatile memory, issue a write settings to EEPROM command.

Command Numbers: 92, 93

Parameters

mode1	Motor1 encoder mode.
mode2	Motor2 encoder mode.

Definition at line 1139 of file RoboClaw.cxx.

References motor::roboclaw::CmdResetEncoderCntrs, and motor::roboclaw::MsgWithCrc.

{
  byte_t  cmd[CmdMaxBufLen];
  size_t  n = 0;
  int     rc;

  cmd[n++] = m_address;
  cmd[n++] = CmdResetEncoderCntrs;

int RoboClaw::cmdSetLogicCutoffs ( const double  min, const double  max  )

virtual

Set the RoboClaw's optional logic dedicated battery minimum and maximum voltage cutoff settings. The battery is connected to the LB-/LB+ terminals.

Note: The minimum value is always set to 0 (6.0V) on power-up. RDK: The documention is conflicted here. 3.0V or 6.0V?

The new values are set in volatile memory only. To save to non-volatile memory, issue a write settings to EEPROM command.

Command Numbers: 58

Parameters

[in]	min	Minimum voltage (V).
[in]	max	Maximum voltage (V).

Definition at line 927 of file RoboClaw.cxx.

References motor::roboclaw::CmdSetLogicCutoffs.

{

int RoboClaw::cmdSetMainBattCutoffs ( const double  min, const double  max  )

virtual

Set the RoboClaw's main battery minimum and maximum voltage cutoff settings.

Note: The minimum value is always set to 0 (6.0V) on power-up.

The new values are set in volatile memory only. To save to non-volatile memory, issue a write settings to EEPROM command.

Command Numbers: 57

Parameters

[in]	min	Minimum voltage (V).
[in]	max	Maximum voltage (V).

Definition at line 721 of file RoboClaw.cxx.

References motor::roboclaw::CmdReadMotorDraw, and motor::roboclaw::CmdSetMainBattCutoffs.

{

int RoboClaw::cmdSetMotorMaxCurrentLimit ( int  motor, const double  maxAmps  )

virtual

Set a motor's maximum current limit.

Command Numbers: 134, 135

Parameters

motor	Motor index Motor1(0) or Motor2(1).
maxAmps	Motor maximum current limit (amperes)

Definition at line 832 of file RoboClaw.cxx.

References motor::roboclaw::CmdReadLogicVolt, motor::roboclaw::CmdSetMaxCurrentMot1, and motor::roboclaw::CmdSetMaxCurrentMot2.

                                                  : CmdSetMaxCurrentMot2;

  //
  // pack values
  //
  k = m_comm.pack32(valMax, cmd+n);
  n += k;

  k = m_comm.pack32(valMin, cmd+n);
  n += k;

  // execute
  return m_comm.execCmdWithAckRsp(cmd, n, MsgWithCrc);
}

// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Logic Battery Voltage Commands
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

// Command 25
int RoboClaw::cmdReadLogicVoltage(double &volts)
{
  byte_t  cmd[CmdMaxBufLen];
  byte_t  rsp[RspMaxBufLen];
  size_t  n = 0;

int RoboClaw::cmdSetVelocityPidConst ( int  motor, const u32_t  Kp, const u32_t  Ki, const u32_t  Kd, const u32_t  qpps  )

virtual

Set motor's velocity PID constants.

The new values are set in volatile memory only. To save to non-volatile memory, issue a write settings to EEPROM command.

Command Numbers: 28, 29

Parameters

	motor	Motor index Motor1(0) or Motor2(1).
[in]	Kp	Velocity PID proportional constant.
[in]	Ki	Velocity PID intergral constant.
[in]	Kd	Velocity PID derivative constant.
[in]	qpps	Maximum speed of motor.

Definition at line 997 of file RoboClaw.cxx.

References motor::roboclaw::CmdReadTemp, motor::roboclaw::CmdSetVelPidMot1, and motor::roboclaw::CmdSetVelPidMot2.

                                              : CmdSetVelPidMot2;

  // order is strangly D,P,I,QPPS
  k  = m_comm.pack32(Kd, cmd+n);
  n += k;

  k  = m_comm.pack32(Kp, cmd+n);
  n += k;

  k  = m_comm.pack32(Ki, cmd+n);
  n += k;

  k  = m_comm.pack32(qpps, cmd+n);
  n += k;

  return m_comm.execCmdWithAckRsp(cmd, n, MsgWithCrc);
}

// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Health and Status Commands
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

// Command 82
int RoboClaw::cmdReadBoardTemperature(double &temp)
{
  byte_t  cmd[CmdMaxBufLen];
  byte_t  rsp[RspMaxBufLen];
  size_t  n = 0;

int RoboClaw::cmdStop ( int  motor )

virtual

Stop a motor.

Compatibility command.

Command Numbers: 35, 36

Parameters

motor

Motor index Motor1(0) or Motor2(1).

Definition at line 1705 of file RoboClaw.cxx.

{
  return cmdQDrive2(0, 0);

int RoboClaw::cmdStop ( )

virtual

Stop all motors.

Compatibility command.

Command Numbers: 37

Definition at line 1717 of file RoboClaw.cxx.

{
  return cmdStop();

int RoboClaw::cmdStopWithDecel ( int  motor, u32_t  decel  )

virtual

Stop a motor with the given maximum decelerations.

Stopping is controlled using velocity PID and quadrature encoders.

Compatibility command.

Command Numbers: 38, 39

Parameters

motor	Motor index Motor1(0) or Motor2(1).
decel	Deceleration (qpps/s).

Definition at line 1711 of file RoboClaw.cxx.

Referenced by laelaps::LaeKinActionVelocity::terminate(), and laelaps::LaeKinActionTwist::terminate().

{
  return cmdQDriveWithAccel(0, decel, 0, decel);

int RoboClaw::cmdStopWithDecel ( u32_t  decel )

virtual

Stop both motors with the given maximum decelerations.

Stopping is controlled using velocity PID and quadrature encoders.

Compatibility command.

Command Numbers: 50

Parameters

decel

Deceleration (qpps/s).

Definition at line 1723 of file RoboClaw.cxx.

int RoboClaw::cmdWriteSettingsToEEPROM ( )

virtual

Write all settings to EEPROM.

Command Numbers: 94

Definition at line 1745 of file RoboClaw.cxx.

  {
    usleep(100000);   // 0.1 second to give controller time to write to nvm
  }

  return rc;
}

static double motor::roboclaw::RoboClaw::fcap ( double  a, double  min, double  max  )

inlinestaticprotected

Cap FPN value within limits [min, max].

Parameters

a	Value.
min	Minimum.
max	Maximum.

Returns

a: min ≤ a ≤ max

Definition at line 1711 of file RoboClaw.h.

       {
         return a<min? min: a>max? max: a;
       }

byte_t motor::roboclaw::RoboClaw::getAddress ( ) const

inline

Get the controller address associated with this class instance.

Returns

Returns address.

Definition at line 872 of file RoboClaw.h.

      {
        return m_address;
      }

RoboClawComm& motor::roboclaw::RoboClaw::getComm ( )

inline

Get RoboClaw's bound communication object.

Returns

Returns object.

Definition at line 852 of file RoboClaw.h.

      {
        return m_comm;
      }

void RoboClaw::getLogicCutoffRange	(	double &	minmin,
		double &	maxmax
	)		const

Get the RoboClaw's logic minimum and maximum voltage cutoff settable range.

Parameters

[out]	minmin	Minimum minimum voltage (V).
[out]	maxmax	Maximum maximum voltage (V).

Definition at line 893 of file RoboClaw.cxx.

References motor::roboclaw::CmdReadLogicCutoffs.

  {

void RoboClaw::getMainBattCutoffRange	(	double &	minmin,
		double &	maxmax
	)		const

Get the RoboClaw's main battery minimum and maximum voltage cutoff settable range.

Parameters

[out]	minmin	Minimum minimum voltage (V).
[out]	maxmax	Maximum maximum voltage (V).

Definition at line 687 of file RoboClaw.cxx.

References motor::roboclaw::CmdReadMainBattCutoffs.

  {

virtual byte_t motor::roboclaw::RoboClaw::getMotorDir ( int  motor ) const

inlinevirtual

Get the direction of motor rotation.

The motor direction is a software construct to apply a normal or reverse the sense of forward/backward rotation.

Parameters

motor

Motor index Motor1(0) or Motor2(1).

Returns

Returns motor direction MotorDirNormal(1) or MotorDirReverse(-1).

Definition at line 921 of file RoboClaw.h.

      {
        if( isValidMotor(motor) )
        {
          return m_nMotorDir[motor];
        }
        else
        {
          return MotorDirNormal;
        }
      }

std::string motor::roboclaw::RoboClaw::getNameId ( ) const

inline

Get class instance name identifier.

Returns

Returns string id.

Definition at line 895 of file RoboClaw.h.

      {
        return m_strNameId;
      }

bool motor::roboclaw::RoboClaw::isOpen ( ) const

inline

Test if connection is open.

Returns

Returns true or false.

Definition at line 862 of file RoboClaw.h.

Referenced by Laelaps.WatchDog.WatchDog::cmdConfigDPin(), Laelaps.WatchDog.WatchDog::cmdEnableAuxPort5V(), Laelaps.WatchDog.WatchDog::cmdEnableAuxPortBatt(), Laelaps.WatchDog.WatchDog::cmdEnableMotorCtlrs(), Laelaps.WatchDog.WatchDog::cmdGetFwVersion(), Laelaps.WatchDog.WatchDog::cmdPetTheDog(), Laelaps.WatchDog.WatchDog::cmdReadAPin(), Laelaps.WatchDog.WatchDog::cmdReadDPin(), Laelaps.WatchDog.WatchDog::cmdReadEnables(), Laelaps.WatchDog.WatchDog::cmdReadVoltages(), Laelaps.WatchDog.WatchDog::cmdResetRgbLed(), Laelaps.WatchDog.WatchDog::cmdSetAlarms(), Laelaps.WatchDog.WatchDog::cmdSetBatterySoC(), Laelaps.WatchDog.WatchDog::cmdSetRgbLed(), and Laelaps.WatchDog.WatchDog::cmdWriteDPin().

      {
        return m_comm.isOpen();
      }

virtual bool motor::roboclaw::RoboClaw::isValidMotor ( int  motor ) const

inlineprotectedvirtual

Test if motor index is a valid index.

Parameters

motor

Motor index Motor1(0) or Motor2(1).

Returns

Returns true or false.

Definition at line 1671 of file RoboClaw.h.

      {
        return (motor >= Motor1) && (motor < NumMotors);
      }

bool RoboClaw::probe ( byte_t  address )

virtual

Probe address of motor controller.

A weakness of the RoboClaw controller firmware is that there is no way to fetch its assigned address. The probe function uses a read-only command to determine, by proxy, whether the address is the controller's address. A false outcome is assumed if no response is received.

Parameters

address

Motor controller address to test.

Returns

Returns true if the motor controller has this address, false otherwise.

Definition at line 588 of file RoboClaw.cxx.

References motor::roboclaw::CmdReadFwVersion.

{
  byte_t  cmd[CmdMaxBufLen];
  byte_t  rsp[RspMaxBufLen];
  uint_t  uCrcCmd;

void motor::roboclaw::RoboClaw::setAddress ( byte_t  address )

inline

Set class instance address.

Note

The address may not match the controller's address. It is up to the higher-level code to determine that.

Parameters

address

Motor controller address.

Definition at line 885 of file RoboClaw.h.

      {
        m_address = address;
      }

virtual void motor::roboclaw::RoboClaw::setMotorDir ( int  motor, int  motorDir  )

inlinevirtual

set the direction of motor rotation.

The motor direction is a software construct to apply a normal or reverse the sense of forward/backward rotation.

Parameters

motor	Motor index Motor1(0) or Motor2(1).
motorDir	Motor direction MotorDirNormal(1) or MotorDirReverse(-1).

Definition at line 943 of file RoboClaw.h.

      {
        if( isValidMotor(motor) )
        {
          m_nMotorDir[motor] = motorDir == MotorDirReverse? MotorDirReverse:
                                                            MotorDirNormal;
        }
      }

void motor::roboclaw::RoboClaw::setNameId ( const std::string &  strNameId )

inline

Set class instance name identifier.

Parameters

strNameId

Motor controller name identifier.

Definition at line 905 of file RoboClaw.h.

      {
        m_strNameId = strNameId;
      }

---

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

• include/Laelaps/RoboClaw.h
• sw/liblaelaps/RoboClaw.cxx