laelaps::LaeAlarms Class Reference

Alarm class. More...

#include <laeAlarms.h>

Public Member Functions
	LaeAlarms ()
	Default contructor.
virtual	~LaeAlarms ()
	Destructor.
virtual void	update ()
	Update alarm and warning state. More...

Static Public Member Functions
static bool	isCritical ()
	Test if critcal alarms exist. More...
static bool	isBatteryCritical ()
	Test if battery critcal alarms exist. More...
static bool	isSafeToOperate ()
	Test if robot is safe to operate given the current alarm state. More...
static void	clearAlarms (LaeAlarmInfo &info)
	Clear alarm information state. More...
static void	copyAlarms (const LaeAlarmInfo &src, LaeAlarmInfo &dst)
	Copy alarm state. More...

Protected Member Functions
virtual void	updateSysAlarms (const LaeAlarmInfo &subsys, LaeAlarmInfo &sys)
	Update system alarm state from subsystem alarm state. More...

Detailed Description

Alarm class.

Definition at line 167 of file laeAlarms.h.

Member Function Documentation

void LaeAlarms::clearAlarms ( LaeAlarmInfo &  info )

static

Clear alarm information state.

Parameters

[in,out]

info

Alarm state.

Definition at line 355 of file laeAlarms.cxx.

References laelaps::LaeAlarmInfo::m_bIsCritical, laelaps::LaeAlarmInfo::m_uAlarms, and laelaps::LaeAlarmInfo::m_uWarnings.

{
  info.m_bIsCritical  = false;
  info.m_uAlarms      = LAE_ALARM_NONE;
  info.m_uWarnings    = LAE_WARN_NONE;
}

void LaeAlarms::copyAlarms ( const LaeAlarmInfo &  src, LaeAlarmInfo &  dst  )

static

Copy alarm state.

Parameters

[in]	src	Source alarm state.
[out]	dst	Destination alarm state.

Definition at line 362 of file laeAlarms.cxx.

References laelaps::LaeAlarmInfo::m_bIsCritical, laelaps::LaeAlarmInfo::m_uAlarms, and laelaps::LaeAlarmInfo::m_uWarnings.

{
  dst.m_bIsCritical = src.m_bIsCritical;
  dst.m_uAlarms     = src.m_uAlarms;
  dst.m_uWarnings   = src.m_uWarnings;
}

bool LaeAlarms::isBatteryCritical ( )

static

Test if battery critcal alarms exist.

The determination is made solely on the real-time database current state. No subsystems are queried.

Returns

Returns true or false.

Definition at line 80 of file laeAlarms.cxx.

{
  return RtDb.m_alarms.m_battery.m_bIsCritical;
}

bool LaeAlarms::isCritical ( )

static

Test if critcal alarms exist.

The determination is made solely on the real-time database current state. No subsystems are queried.

Returns

Returns true or false.

Definition at line 75 of file laeAlarms.cxx.

{
  return RtDb.m_alarms.m_system.m_bIsCritical;
}

bool LaeAlarms::isSafeToOperate ( )

static

Test if robot is safe to operate given the current alarm state.

The determination is made solely on the real-time database current state. No subsystems are queried.

Returns

Returns true or false.

Definition at line 85 of file laeAlarms.cxx.

Referenced by laelaps::LaeRobot::canMove().

{
  // no critical alarms
  if( !RtDb.m_alarms.m_system.m_bIsCritical )
  {
    return true;
  }
  // only battery critical
  else if( (RtDb.m_alarms.m_system.m_uAlarms & ~LAE_ALARM_BATT) ==
                                                              LAE_ALARM_NONE )
  {
    return true;
  }
  // bad robot
  else
  {
    return false;
  }
}

void LaeAlarms::update ( )

virtual

Update alarm and warning state.

Status, alarms, and erros from all monitored subsystems are processed to provide a unified alarm framework. The alarm state is written to the Laelaps real-time database.

Definition at line 105 of file laeAlarms.cxx.

References laelaps::LaeAlarmInfo::m_bIsCritical, laelaps::LaeAlarmInfo::m_uAlarms, laelaps::LaeAlarmInfo::m_uWarnings, motor::roboclaw::ParamStatusErrLogicBattHigh, motor::roboclaw::ParamStatusErrLogicBattLow, motor::roboclaw::ParamStatusErrMainBattHigh, motor::roboclaw::ParamStatusErrMot1Fault, motor::roboclaw::ParamStatusErrMot2Fault, motor::roboclaw::ParamStatusErrTemp, motor::roboclaw::ParamStatusWarnMainBattHigh, motor::roboclaw::ParamStatusWarnMainBattLow, motor::roboclaw::ParamStatusWarnMot1OverCur, motor::roboclaw::ParamStatusWarnMot2OverCur, and motor::roboclaw::ParamStatusWarnTemp.

Referenced by laelaps::LaeThreadWd::exec().

{
  LaeAlarmInfo  sys;                // system alarms
  LaeAlarmInfo  subsys;             // subsystem alarms
  LaeAlarmInfo  mot1;               // motor 1 subsystem alarms
  LaeAlarmInfo  mot2;               // motor 2 subsystem alarms
  LaeAlarmInfo  sensors;            // sensors subsytem alarms
  u32_t         uStatus;            // subsystem status
  int           nCtlr;              // motor controller index
  int           nMotor1, nMotor2;   // motors 1 and 2 absolute indices

  // clear local copy of system alarms
  clearAlarms(sys);

  //
  // Determine motor controllers and motors alarm state.
  //
  for(nCtlr=0; nCtlr<LaeNumMotorCtlrs; ++nCtlr)
  {
    clearAlarms(subsys);
    clearAlarms(mot1);
    clearAlarms(mot2);

    uStatus = RtDb.m_motorctlr[nCtlr].m_uStatus;

    if( nCtlr == LaeMotorCtlrIdFront ) // front
    {
      nMotor1 = LaeMotorIdLF;
      nMotor2 = LaeMotorIdRF;
    }
    else  // rear
    {
      nMotor1 = LaeMotorIdLR;
      nMotor2 = LaeMotorIdRR;
    }

    // map controller status to controller alarms
    if( uStatus & ParamStatusErrTemp )
    {
      subsys.m_uAlarms |= LAE_ALARM_TEMP;
    }
    if( uStatus & ParamStatusErrMainBattHigh )
    {
      subsys.m_uAlarms |= LAE_ALARM_MOTCTLR_BATT_V_HIGH;
    }
    if( uStatus & ParamStatusErrLogicBattHigh )
    {
      subsys.m_uAlarms |= LAE_ALARM_MOTCTLR_LOGIC_V_HIGH;
    }
    if( uStatus & ParamStatusErrLogicBattLow )
    {
      subsys.m_uAlarms |= LAE_ALARM_MOTCTLR_LOGIC_V_LOW;
    }

    // map controller status to controller warnings
    if( uStatus & ParamStatusWarnMainBattHigh )
    {
      subsys.m_uWarnings |= LAE_WARN_MOTCTLR_BATT_V_HIGH;
    }
    if( uStatus & ParamStatusWarnMainBattLow )
    {
      subsys.m_uWarnings |= LAE_WARN_MOTCTLR_BATT_V_LOW;
    }
    if( uStatus & ParamStatusWarnTemp )
    {
      subsys.m_uWarnings |= LAE_WARN_TEMP;
    }

    // contoller critcal alarms
    if( subsys.m_uAlarms & LAE_CRIT_MOTCTLR )
    {
      subsys.m_bIsCritical = true;
    }

    // motor alarms
    if( uStatus & ParamStatusErrMot1Fault )
    {
      mot1.m_uAlarms |= LAE_ALARM_MOT_FAULT;
    }
    if( uStatus & ParamStatusErrMot2Fault )
    {
      mot2.m_uAlarms |= LAE_ALARM_MOT_FAULT;
    }

    // motor warnings
    if( uStatus & ParamStatusWarnMot1OverCur )
    {
      mot1.m_uWarnings |= LAE_WARN_MOT_OVER_CUR;
    }
    if( uStatus & ParamStatusWarnMot2OverCur )
    { 
      mot2.m_uWarnings |= LAE_WARN_MOT_OVER_CUR;
    }

    // motor critcal alarms
    if( mot1.m_uAlarms & LAE_CRIT_MOT )
    {
      mot1.m_bIsCritical = true;
    }
    if( mot2.m_uAlarms & LAE_CRIT_MOT )
    {
      mot2.m_bIsCritical = true;
    }

    // copy to database
    copyAlarms(subsys, RtDb.m_alarms.m_motorctlr[nCtlr]);
    copyAlarms(mot1, RtDb.m_alarms.m_motor[nMotor1]);
    copyAlarms(mot2, RtDb.m_alarms.m_motor[nMotor2]);

    // update system alarms from subsystem state
    updateSysAlarms(subsys, sys);
    updateSysAlarms(mot1, sys);
    updateSysAlarms(mot2, sys);
  }

  //
  // Determine battery alarm state 
  //
  clearAlarms(subsys);

  if( RtDb.m_energy.m_fBatterySoC < LAE_CRIT_BATT_SOC )
  {
    subsys.m_uAlarms |= LAE_ALARM_BATT;
    subsys.m_bIsCritical = true;
  }
  if( RtDb.m_energy.m_fBatterySoC < LAE_WARN_BATT_SOC )
  {
    subsys.m_uWarnings |= LAE_WARN_BATT;
  }

  // copy to database
  copyAlarms(subsys, RtDb.m_alarms.m_battery);

  // update system alarms from subsystem state
  updateSysAlarms(subsys, sys);

  //
  // Determine senors alarm state 
  //
  clearAlarms(subsys);

  if( !RtDb.m_enable.m_bImu )
  {
    subsys.m_uAlarms |= LAE_ALARM_IMU;
  }
  if( !RtDb.m_enable.m_bRange )
  {
    subsys.m_uAlarms |= LAE_ALARM_RANGE;
  }
  if( !RtDb.m_enable.m_bFCam )
  {
    subsys.m_uAlarms |= LAE_ALARM_FCAM;
  }

  // copy to database
  copyAlarms(subsys, RtDb.m_alarms.m_sensors);

  // update system alarms from subsystem state
  updateSysAlarms(subsys, sys);

  //
  // Other system alarms.
  //
  if( RtDb.m_robotstatus.m_bIsEStopped )
  {
    sys.m_uAlarms |= LAE_ALARM_ESTOP;
  }

  // copy system alarms to database
  copyAlarms(sys, RtDb.m_alarms.m_system);

  //
  // Final settings
  //
  if( RtDb.m_alarms.m_system.m_uAlarms == LAE_ALARM_NONE )
  {
    RtDb.m_robotstatus.m_bAlarmState = false;
  }
  else
  {
    RtDb.m_robotstatus.m_bAlarmState = true;
  }

  //fprintf(stderr, "DBG: isCrit=%d, alarms=0x%x, warns=0x%x\n", 
  //    RtDb.m_alarms.m_system.m_bIsCritical,
  //    RtDb.m_alarms.m_system.m_uAlarms,
  //    RtDb.m_alarms.m_system.m_uWarnings);
}

void LaeAlarms::updateSysAlarms ( const LaeAlarmInfo &  subsys, LaeAlarmInfo &  sys  )

protectedvirtual

Update system alarm state from subsystem alarm state.

Parameters

[in]	subsys	Subsystem alarm state.
[out]	sys	System alarm state.

Definition at line 294 of file laeAlarms.cxx.

References laelaps::LaeAlarmInfo::m_bIsCritical, laelaps::LaeAlarmInfo::m_uAlarms, and laelaps::LaeAlarmInfo::m_uWarnings.

{
  //
  // Any critically alarms subsystem propagates up to the system level.
  //
  if( subsys.m_bIsCritical )
  {
    sys.m_bIsCritical = true;
  }

  //
  // Subsytems alarms that propagate up to the system level.
  //
  if( subsys.m_uAlarms & LAE_ALARM_TEMP )
  {
    sys.m_uAlarms |= LAE_ALARM_TEMP;
  }
  if( subsys.m_uAlarms & LAE_ALARM_BATT )
  {
    sys.m_uAlarms |= LAE_ALARM_BATT;
  }
  if( subsys.m_uAlarms & LAE_ALARM_IMU )
  {
    sys.m_uAlarms |= LAE_ALARM_IMU;
  }
  if( subsys.m_uAlarms & LAE_ALARM_RANGE )
  {
    sys.m_uAlarms |= LAE_ALARM_RANGE;
  }
  if( subsys.m_uAlarms & LAE_ALARM_FCAM )
  {
    sys.m_uAlarms |= LAE_ALARM_FCAM;
  }

  //
  // Subsystem is [not] alarmed.
  //
  if( subsys.m_uAlarms != LAE_ALARM_NONE )
  {
    sys.m_uAlarms |= LAE_ALARM_SUBSYS;
  }

  //
  // Subsytems warnings that propagate up to the system level.
  //
  if( subsys.m_uWarnings & LAE_WARN_TEMP )
  {
    sys.m_uWarnings |= LAE_WARN_TEMP;
  }

  if( subsys.m_uWarnings & LAE_WARN_BATT )
  {
    sys.m_uWarnings |= LAE_WARN_BATT;
  }

  if( subsys.m_uWarnings != LAE_WARN_NONE )
  {
    sys.m_uWarnings |= LAE_WARN_SUBSYS;
  }
}

---

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

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