laelaps::LaeKinActionDutyCycle Class Reference

Laelaps kinematics duty cycle action class. More...

#include <laeKin.h>

Inheritance diagram for laelaps::LaeKinActionDutyCycle:

Public Member Functions
	LaeKinActionDutyCycle (LaeKinematics &kin)
	Default initialization constructor. More...
virtual	~LaeKinActionDutyCycle ()
	Destructor.
int	update (const LaeMapDutyCycle &dutycycle)
	Update with new velocities. More...
virtual int	execute ()
	Execution new velocities. More...
virtual int	terminate ()
	Terminate action. More...
Public Member Functions inherited from laelaps::LaeKinAction
	LaeKinAction (LaeKinematics &kin, ActionType eActionType=ActionTypeIdle)
	Default intialization constructor. More...
virtual	~LaeKinAction ()
	Destructor.
virtual int	plan ()
	Plan next execution. More...
virtual bool	isIdle ()
	Test if action is idle. More...
virtual bool	isPlanningRequired ()
	Test if action requires (re)planning. More...
virtual bool	isExecutionRequired () const
	Test if more action requires (more) execution. More...
virtual bool	hasTerminated () const
	Test if action has been terminated. More...
virtual ActionType	getActionType () const
	Get the action type for this class. More...
virtual ActionState	getActionState () const
	Get the action state. More...

Protected Member Functions
void	clear ()
	Clear goal.

Protected Attributes
LaeMapDutyCycle	m_mapGoalDutyCycle
	map of goal duty cycles
Protected Attributes inherited from laelaps::LaeKinAction
LaeKinematics &	m_kin
	bound kinematics driver
ActionType	m_eActionType
	action type enum
ActionState	m_eActionState
	action state.

Additional Inherited Members
Public Types inherited from laelaps::LaeKinAction
enum	ActionType {   ActionTypeIdle,   ActionTypeVelocity,   ActionTypeDutyCycle,   ActionTypeTwist,   ActionTypeNavForDist,   ActionTypeNavToPos }
	Supported kinematic extended actions. More...
enum	ActionState {   ActionStateIdle,   ActionStateUpdate,   ActionStatePlan,   ActionStateExecute,   ActionStateTerminated }
	Action states. More...
Static Public Member Functions inherited from laelaps::LaeKinAction
static LaeKinAction *	newAction (LaeKinematics &kin, const ActionType eActionType)
	Archetype constructor to create action type instance. More...
static LaeKinAction *	replaceAction (LaeKinematics &kin, LaeKinAction *pAction, const ActionType eNewActionType)
	Archetype constructor to replace action type instance. More...

Detailed Description

Laelaps kinematics duty cycle action class.

A velocity action only sets the duty cycles of a (sub)set of the powertrain motors. Powertrains not specified are kept at their current duty cycles.

Definition at line 1042 of file laeKin.h.

Constructor & Destructor Documentation

LaeKinActionDutyCycle::LaeKinActionDutyCycle

(

LaeKinematics &

kin

)

Default initialization constructor.

Parameters

kin	Bound kinemeatics driver.

Definition at line 1872 of file laeKin.cxx.

    : LaeKinAction(kin, ActionTypeDutyCycle)
{
}

Member Function Documentation

int LaeKinActionDutyCycle::execute ( )

virtual

Execution new velocities.

All motors with new velocities are written with new speeds.

Returns

On success, OK(0) is returned.
On error, RC_ERROR(-1) is returned.

Reimplemented from laelaps::LaeKinAction.

Definition at line 1920 of file laeKin.cxx.

References laelaps::LaeKinAction::ActionStateIdle, motor::roboclaw::RoboClaw::cmdDutyDrive2(), laelaps::LaeKinAction::execute(), laelaps::LaeKinematics::getMotorCtlr(), laelaps::LaePowertrain::getName(), laelaps::LaeKinematics::getPowertrain(), laelaps::LaeKinAction::isExecutionRequired(), laelaps::LAE_ECODE_MOT_CTLR, laelaps::LAE_OK, laelaps::LaeNumMotorCtlrs, laelaps::LaeNumMotorsPerCtlr, laelaps::LaeKinAction::m_eActionState, laelaps::LaeKinAction::m_kin, and m_mapGoalDutyCycle.

Referenced by laelaps::LaeKinematics::setGoalDutyCycles().

{
  int                       nCtlr;      // motor controller id
  int                       nMotor;     // motor index
  LaePowertrain            *pTrain;     // working powertrain
  LaeMapDutyCycle::iterator goal;       // working goal
  double                    fDuty[LaeNumMotorsPerCtlr]; // working duty cycles
  bool                      bDoExec;    // do [not] exec
  RoboClaw                 *pMotorCtlr; // motor controller
  int                       rc;         // return code

  // no execution required
  if( !isExecutionRequired() )
  {
    return LAE_OK;
  }

  LaeKinAction::execute();

  //
  // Iterate through motors and executre new duty cycle commands.
  //
  for(nCtlr = 0; nCtlr < LaeNumMotorCtlrs; ++nCtlr)
  {
    bDoExec = false;

    for(nMotor = 0; nMotor < LaeNumMotorsPerCtlr; ++nMotor)
    {
      if( (pTrain = m_kin.getPowertrain(nCtlr, nMotor)) == NULL )
      {
        continue;
      }

      goal = m_mapGoalDutyCycle.find(pTrain->getName());

      if( goal != m_mapGoalDutyCycle.end() )
      {
        fDuty[nMotor] = goal->second;
        bDoExec = true;
      }
      else
      {
        fDuty[nMotor] = 0.0;
      }
    }

    if( bDoExec )
    {
      pMotorCtlr = m_kin.getMotorCtlr(nCtlr);

      rc = pMotorCtlr->cmdDutyDrive2(fDuty[0], fDuty[1]);

      if( rc != OK )
      {
        rc = -LAE_ECODE_MOT_CTLR;
        break;
      }
    }
  }

  m_eActionState = ActionStateIdle;

  return rc;
}

int LaeKinActionDutyCycle::terminate ( )

virtual

Terminate action.

All motors are stopped.

Returns

On success, OK(0) is returned.
On error, RC_ERROR(-1) is returned.

Reimplemented from laelaps::LaeKinAction.

Definition at line 1985 of file laeKin.cxx.

References clear(), motor::roboclaw::RoboClaw::cmdDutyDrive2(), laelaps::LaeKinematics::getMotorCtlr(), laelaps::LaeKinAction::hasTerminated(), laelaps::LAE_OK, laelaps::LaeNumMotorCtlrs, laelaps::LaeKinAction::m_kin, and laelaps::LaeKinAction::terminate().

{
  LaeMapDutyCycle::iterator  iter;
  int                       nCtlr;
  RoboClaw                  *pMotorCtlr;

  // already terminated
  if( hasTerminated() )
  {
    return LAE_OK;
  }

  //
  // Coast all motors.
  //
  for(nCtlr = 0; nCtlr < LaeNumMotorCtlrs; ++nCtlr)
  {
    pMotorCtlr = m_kin.getMotorCtlr(nCtlr);
    pMotorCtlr->cmdDutyDrive2(0.0, 0.0);
  }

  clear();

  LaeKinAction::terminate();

  return LAE_OK;
}

int LaeKinActionDutyCycle::update

(

const LaeMapDutyCycle &

dutycycle

)

Update with new velocities.

Parameters

velocity

Map of powertrain velocities.

Returns

On success, OK(0) is returned.
On error, RC_ERROR(-1) is returned.

Definition at line 1877 of file laeKin.cxx.

References laelaps::LaeKinAction::ActionStateExecute, laelaps::LaeKinAction::ActionStateIdle, laelaps::LaeKinAction::ActionStateUpdate, laelaps::LAE_OK, laelaps::LaeKinAction::m_eActionState, and m_mapGoalDutyCycle.

Referenced by laelaps::LaeKinematics::setGoalDutyCycles().

{
  LaeMapDutyCycle::const_iterator iter;
  LaeMapDutyCycle::iterator       pos;

  // set state to update
  m_eActionState = ActionStateUpdate;

  //
  // Iterate through key,duty map.
  //
  for(iter = duty.begin(); iter != duty.end(); ++iter)
  {
    pos = m_mapGoalDutyCycle.find(iter->first);

    // duty on a new action powertrain
    if( pos == m_mapGoalDutyCycle.end() )
    {
      m_mapGoalDutyCycle[iter->first] = iter->second;
      m_eActionState = ActionStateExecute;
    }

    // different duty on an existing action powertrain
    else if( pos->second != iter->second )
    {
      pos->second = iter->second;
      m_eActionState = ActionStateExecute;
    }

    // else same duty
    
    LOGDIAG3("Motor %12s duty = %5.3lf.", iter->first.c_str(), iter->second);
  }

  // no planning and execution required
  if( m_eActionState == ActionStateUpdate )
  {
    m_eActionState = ActionStateIdle;
  }

  return LAE_OK;
}

---

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

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