sensor::vl6180::LaeRangeMuxSubproc Class Reference

Multiplexed range sensors class. More...

#include <laeVL6180.h>

Inheritance diagram for sensor::vl6180::LaeRangeMuxSubproc:

Public Types
typedef std::map< std::string, LaeVL6180SensorInfo >	SensorInfoMap
	Sensor information map type.

Public Member Functions
	LaeRangeMuxSubproc (laelaps::LaeI2C &i2cBus, uint_t addr=laelaps::LaeI2CAddrToFMux)
	Initialization constructor. More...
virtual	~LaeRangeMuxSubproc ()
	Destructor.
virtual int	getInterfaceVersion (uint_t &uVerMajor, uint_t &uVerMinor, uint_t &uFwVer)
	Get interface version. More...
virtual void	clearSensedData ()
	Clear sensed data.
virtual int	configure (const laelaps::LaeDesc &desc)
	Configure sensor array from product description. More...
virtual int	configure (const laelaps::LaeTunes &tunes)
	Configure sensor array from tuning parameters. More...
virtual int	reload (const laelaps::LaeTunes &tunes)
	Reload configuration tuning parameters. More...
virtual void	exec ()
	Execute one cycle to take measurements. More...
virtual int	getRange (const std::string &strKey, double &fRange)
	Get a range measurement. More...
virtual int	getRange (std::vector< std::string > &vecNames, std::vector< double > &vecRanges)
	Get all sensor range measurements. More...
virtual int	getAmbientLight (const std::string &strKey, double &fAmbient)
	Get an ambient light illuminance measurement. More...
virtual int	getAmbientLight (std::vector< std::string > &vecNames, std::vector< double > &vecAmbient)
	Get all sensor ambient light illuminance measurements. More...
virtual int	getSensorProps (const std::string &strKey, std::string &strRadiationType, double &fFoV, double &fBeamDir, double &fMin, double &fMax)
	Get range sensor properties. More...
virtual int	readSensorIdentity (const std::string &strKey, VL6180xIdentification &ident)
	Read sensor's identification. More...
virtual int	readSensorTunes (const std::string &strKey, uint_t &uRangeOffset, uint_t &uRangeCrossTalk, double &fAlsGain, uint_t &uAlsIntPeriod)
	Read sensor's current tuning parameters. More...
Public Member Functions inherited from sensor::vl6180::LaeRangeInterface
	LaeRangeInterface (laelaps::LaeI2C &i2cBus)
	Initialization constructor. More...
virtual	~LaeRangeInterface ()
	Destructor.

Static Public Attributes
static const long	TStd = 100
	standard wait write_read (usec)

Protected Member Functions
void	lock ()
	Lock the share resource. More...
void	unlock ()
	Unlock the shared resource. More...
virtual int	cmdGetFwVersion (uint_t &uVerNum)
	Get the firmware version command. More...
int	cmdGetIdent (const std::string &strKey, VL6180xIdentification &ident)
	Read sensor identification command. More...
int	cmdGetTunes (const std::string &strKey, uint_t &uRangeOffset, uint_t &uRangeCrossTalk, double &fAlsGain, uint_t &uAlsIntPeriod)
	Read exported tuning parameters command. More...
int	cmdGetRanges (std::vector< double > &vecRanges)
	Get measured object distances. More...
int	cmdGetAmbientLight (std::vector< double > &vecLux)
	Get measured ambient light illumination. More...
int	cmdTuneToFSensor (const std::string &strKey, uint_t uRangeOffset, uint_t uRangeCrossTalk)
	Tune time-of-flight range sensor command. More...
int	cmdTuneAls (const std::string &strKey, double fAlsGain, uint_t uAlsIntPeriod)
	Tune ambient light sensor command. More...
int	cmdGetRanges ()
	Get range distance measurments command. More...
int	cmdGetAmbientLight ()
	Get ambient light measurments command. More...

Protected Attributes
uint_t	m_addrSubProc
	I2C sub-processor address.
uint_t	m_uFwVer
	firmware version number
SensorInfoMap	m_mapInfo
	map of sensor properties by key
std::vector< double >	m_vecRanges
	measured distances (meters)
std::vector< double >	m_vecLux
	measured ambient light (lux)
pthread_mutex_t	m_mutex
	mutex
Protected Attributes inherited from sensor::vl6180::LaeRangeInterface
laelaps::LaeI2C &	m_i2cBus
	bound I2C bus instance

Detailed Description

Multiplexed range sensors class.

The interface between the processor and the sensors is through an I²C connected sub-processor. Since the sub-processor (mostly) hides the specific sensor hardware, this class is more general.

Used in 2.1+ hardware.

Definition at line 1211 of file laeVL6180.h.

Constructor & Destructor Documentation

LaeRangeMuxSubproc::LaeRangeMuxSubproc	(	laelaps::LaeI2C &	i2cBus,
		uint_t	addr = laelaps::LaeI2CAddrToFMux
	)

Initialization constructor.

Note

The constructor should be kept light weight.

Parameters

i2cbus	Bound open I2C bus instance.
addr	ToF multiplexor sub-processor I2C address.

Definition at line 1606 of file laeVL6180.cxx.

References m_mutex, and m_uFwVer.

                                                                  :
    LaeRangeInterface(i2cBus), m_addrSubProc(addr),
    m_vecRanges(ToFSensorMaxNumOf, 0.0),
    m_vecLux(ToFSensorMaxNumOf, 0.0)
{
  m_uFwVer = 0;

  pthread_mutex_init(&m_mutex, NULL);
}

Member Function Documentation

int LaeRangeMuxSubproc::cmdGetAmbientLight ( std::vector< double > &  vecLux )

protected

Get measured ambient light illumination.

Parameters

[out]

vecLux

Vector of illuminations (lux).

Returns

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

Definition at line 2037 of file laeVL6180.cxx.

References cmdGetAmbientLight(), and m_vecLux.

{
  int   rc;

  if( (rc = cmdGetAmbientLight()) == LAE_OK )
  {
    vecLux = m_vecLux;
  }

  return rc;
}

int LaeRangeMuxSubproc::cmdGetAmbientLight ( )

protected

Get ambient light measurments command.

Returns

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

Definition at line 1995 of file laeVL6180.cxx.

References lock(), m_addrSubProc, sensor::vl6180::LaeRangeInterface::m_i2cBus, TStd, unlock(), and laelaps::LaeI2C::write_read().

Referenced by cmdGetAmbientLight(), and exec().

{
  byte_t  cmd[LaeToFMuxI2CMaxCmdLen];
  byte_t  rsp[LaeToFMuxI2CMaxRspLen];
  size_t  lenCmd = 0;
  size_t  lenRsp = LaeToFMuxI2CRspLenGetLux;
  int     sensorIndex;
  int     n;
  u32_t   val;
  double  fLux;
  int     rc;

  lock();

  cmd[lenCmd++] = LaeToFMuxI2CCmdIdGetLux;

  rc = m_i2cBus.write_read(m_addrSubProc, cmd, lenCmd, rsp, lenRsp, TStd);

  if( rc == LAE_OK )
  {
    n = 0;

    for(sensorIndex = 0; sensorIndex < ToFSensorMaxNumOf; ++sensorIndex)
    {
      val = 0;
      for(int i = 0; i < 4; ++i)
      {
        val << 8;
        val |= rsp[n++];
      }

      fLux = (double)val * (double)LaeToFMuxI2CArgLuxScale;

      RtDb.m_range[sensorIndex].m_fAmbientLight = fLux;
    }
  }

  unlock();

  return rc;
}

int LaeRangeMuxSubproc::cmdGetFwVersion ( uint_t &  uVerNum )

protectedvirtual

Get the firmware version command.

Parameters

[out]

uVerNum

Firmware version number.

Returns

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

Definition at line 1856 of file laeVL6180.cxx.

References lock(), m_addrSubProc, sensor::vl6180::LaeRangeInterface::m_i2cBus, m_uFwVer, TStd, unlock(), and laelaps::LaeI2C::write_read().

Referenced by configure(), getInterfaceVersion(), and Laelaps.WatchDog.WatchDog::sync().

{
  byte_t  cmd[LaeToFMuxI2CMaxCmdLen];
  byte_t  rsp[LaeToFMuxI2CMaxRspLen];
  size_t  lenCmd = 0;
  size_t  lenRsp = LaeToFMuxI2CRspLenGetVersion;
  int     rc;

  lock();

  cmd[lenCmd++] = LaeToFMuxI2CCmdIdGetVersion;

  rc = m_i2cBus.write_read(m_addrSubProc, cmd, lenCmd, rsp, lenRsp, TStd);

  if( rc == LAE_OK )
  {
    uVerNum = (uint_t)rsp[0];
    m_uFwVer = uVerNum;
    RtDb.m_product.m_uToFMuxFwVer = m_uFwVer;
  }

  unlock();

  return rc;
}

int LaeRangeMuxSubproc::cmdGetIdent ( const std::string &  strKey, VL6180xIdentification &  ident  )

protected

Read sensor identification command.

Parameters

[out]

id

Identification structure.

Returns

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

Definition at line 1882 of file laeVL6180.cxx.

References lock(), m_addrSubProc, sensor::vl6180::LaeRangeInterface::m_i2cBus, m_mapInfo, TStd, unlock(), and laelaps::LaeI2C::write_read().

Referenced by configure(), and readSensorIdentity().

{
  byte_t  cmd[LaeToFMuxI2CMaxCmdLen];
  byte_t  rsp[LaeToFMuxI2CMaxRspLen];
  size_t  lenCmd = 0;
  size_t  lenRsp = LaeToFMuxI2CRspLenGetIdent;
  byte_t  sensorIndex;
  u16_t   val_hi, val_lo;
  int     n;
  int     rc;

  SensorInfoMap::iterator pos;

  if( (pos = m_mapInfo.find(strKey)) == m_mapInfo.end() )
  {
    LOGERROR("VL6180 sensor %s not found.", strKey.c_str());
    return -LAE_ECODE_BAD_VAL;
  }

  sensorIndex = pos->second.m_nIndex;

  lock();

  cmd[lenCmd++] = LaeToFMuxI2CCmdIdGetIdent;
  cmd[lenCmd++] = sensorIndex;

  rc = m_i2cBus.write_read(m_addrSubProc, cmd, lenCmd, rsp, lenRsp, TStd);

  if( rc == LAE_OK )
  {
    n = 0;
    ident.idModel           = rsp[n++];
    ident.idModelRevMajor   = rsp[n++];
    ident.idModelRevMinor   = rsp[n++];
    ident.idModuleRevMajor  = rsp[n++];
    ident.idModuleRevMinor  = rsp[n++];

    val_hi = ((u16_t)rsp[n++]) << 8;
    val_lo = (u16_t)rsp[n++];
    ident.idDate = val_hi | val_lo;

    val_hi = ((u16_t)rsp[n++]) << 8;
    val_lo = (u16_t)rsp[n++];
    ident.idTime = val_hi | val_lo;
  }

  unlock();

  return rc;
}

int LaeRangeMuxSubproc::cmdGetRanges ( std::vector< double > &  vecRanges )

protected

Get measured object distances.

Parameters

[out]

vecRanges

Vector of distances (mm).

Returns

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

Definition at line 1983 of file laeVL6180.cxx.

References cmdGetRanges(), and m_vecRanges.

{
  int   rc;

  if( (rc = cmdGetRanges()) == LAE_OK )
  {
    vecRanges = m_vecRanges;
  }

  return rc;
}

int LaeRangeMuxSubproc::cmdGetRanges ( )

protected

Get range distance measurments command.

Returns

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

Definition at line 1934 of file laeVL6180.cxx.

References lock(), m_addrSubProc, sensor::vl6180::LaeRangeInterface::m_i2cBus, m_vecRanges, TStd, unlock(), VL6180X_ERR_MEAS, VL6180X_RANGE_MIN, VL6180X_RANGE_NO_OBJ, and laelaps::LaeI2C::write_read().

Referenced by cmdGetRanges(), and exec().

{
  byte_t  cmd[LaeToFMuxI2CMaxCmdLen];
  byte_t  rsp[LaeToFMuxI2CMaxRspLen];
  size_t  lenCmd = 0;
  size_t  lenRsp = LaeToFMuxI2CRspLenGetRanges;
  int     sensorIndex;
  byte_t  val;
  double  fRange;
  int     rc;

  lock();

  cmd[lenCmd++] = LaeToFMuxI2CCmdIdGetRanges;

  rc = m_i2cBus.write_read(m_addrSubProc, cmd, lenCmd, rsp, lenRsp, TStd);

  if( rc == LAE_OK )
  {
    for(sensorIndex = 0; sensorIndex < ToFSensorMaxNumOf; ++sensorIndex)
    {
      val = rsp[sensorIndex];
      if( val <= LaeToFMuxRangeMax )
      {
        fRange = (double)val * 0.001;   // mm to meters
      }
      else if( val == LaeToFMuxRangeNoObj )
      {
        fRange = VL6180X_RANGE_NO_OBJ;
      } 
      else if( val == LaeToFMuxRangeNoDev )
      {
        fRange = VL6180X_RANGE_MIN;
      }
      else
      {
        fRange = VL6180X_ERR_MEAS;
      }

      m_vecRanges[sensorIndex] = fRange;
    }
    RtDb.m_range[sensorIndex].m_fRange = fRange;
  }

  unlock();

  return rc;
}

int LaeRangeMuxSubproc::cmdGetTunes ( const std::string &  strKey, uint_t &  uRangeOffset, uint_t &  uRangeCrossTalk, double &  fAlsGain, uint_t &  uAlsIntPeriod  )

protected

Read exported tuning parameters command.

Parameters

[out]	uRangeOffset	ToF sensor part-to-part offset.
[out]	uRangeCrossTalk	ToF sensor cross-talk compensation.
[out]	fAlsGain	Ambient light sensor analog gain.
[out]	uAlsIntPeriod	Ambient light sensor integration period (msec).

Returns

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

Definition at line 2049 of file laeVL6180.cxx.

References sensor::vl6180::LaeVL6180Mux::gainEnumToAnalog(), lock(), m_addrSubProc, sensor::vl6180::LaeRangeInterface::m_i2cBus, m_mapInfo, m_uFwVer, TStd, unlock(), and laelaps::LaeI2C::write_read().

Referenced by configure(), and readSensorTunes().

{
  byte_t  cmd[LaeToFMuxI2CMaxCmdLen];
  byte_t  rsp[LaeToFMuxI2CMaxRspLen];
  size_t  lenCmd = 0;
  size_t  lenRsp = LaeToFMuxI2CRspLenGetTunes;
  byte_t  sensorIndex;
  byte_t  val;
  uint_t  val_hi, val_lo;
  int     n;
  int     rc;

  SensorInfoMap::iterator pos;

  if( (pos = m_mapInfo.find(strKey)) == m_mapInfo.end() )
  {
    LOGERROR("VL6180 sensor %s not found.", strKey.c_str());
    return -LAE_ECODE_BAD_VAL;
  }

  sensorIndex = pos->second.m_nIndex;

  lock();

  cmd[lenCmd++] = LaeToFMuxI2CCmdIdGetTunes;
  cmd[lenCmd++] = sensorIndex;

  rc = m_i2cBus.write_read(m_addrSubProc, cmd, lenCmd, rsp, lenRsp, TStd);

  if( rc == LAE_OK )
  {
    n = 0;

    uRangeOffset    = rsp[n++];

    if( m_uFwVer >= 2 )
    {
      val_hi          = ((uint_t)rsp[n++]) << 8;
      val_lo          = (uint_t)rsp[n++];
      uRangeCrossTalk = val_hi | val_lo;
    }
    else
    {
      uRangeCrossTalk = rsp[n++];
    }

    val             = rsp[n++];
    fAlsGain        = LaeVL6180Mux::gainEnumToAnalog((vl6180x_als_gain)val);

    val_hi          = ((uint_t)rsp[n++]) << 8;
    val_lo          = (uint_t)rsp[n++];
    uAlsIntPeriod   = val_hi | val_lo;
  }

  unlock();

  return rc;
}

int LaeRangeMuxSubproc::cmdTuneAls ( const std::string &  strKey, double  fAlsGain, uint_t  uAlsIntPeriod  )

protected

Tune ambient light sensor command.

Parameters

fAlsGain	Ambient light sensor analog gain.
uAlsIntPeriod	Ambient light sensor integration period (msec).

Returns

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

Definition at line 2173 of file laeVL6180.cxx.

References laelaps::cap(), sensor::vl6180::LaeVL6180Mux::gainAnalogToEnum(), lock(), m_addrSubProc, sensor::vl6180::LaeRangeInterface::m_i2cBus, m_mapInfo, TStd, unlock(), VL6180X_AMBIENT_INT_T_MAX, VL6180X_AMBIENT_INT_T_MIN, and laelaps::LaeI2C::write_read().

Referenced by configure().

{
  byte_t  cmd[LaeToFMuxI2CMaxCmdLen];
  byte_t  rsp[LaeToFMuxI2CMaxRspLen];
  size_t  lenCmd = 0;
  size_t  lenRsp = LaeToFMuxI2CRspLenTuneAls;
  byte_t  sensorIndex;
  byte_t  regAlsGain;
  byte_t  val_hi, val_lo;
  byte_t  pf;
  int     rc;

  SensorInfoMap::iterator pos;

  if( (pos = m_mapInfo.find(strKey)) == m_mapInfo.end() )
  {
    LOGERROR("VL6180 sensor %s not found.", strKey.c_str());
    return -LAE_ECODE_BAD_VAL;
  }

  sensorIndex = pos->second.m_nIndex;

  lock();

  regAlsGain = (byte_t)LaeVL6180Mux::gainAnalogToEnum(fAlsGain);

  uAlsIntPeriod = cap(uAlsIntPeriod, (uint_t)VL6180X_AMBIENT_INT_T_MIN,
                                     (uint_t)VL6180X_AMBIENT_INT_T_MAX);

  val_hi = (byte_t)((uAlsIntPeriod >> 8) & 0xff);
  val_lo = (byte_t)(uAlsIntPeriod & 0xff);

  cmd[lenCmd++] = LaeToFMuxI2CCmdIdTuneAls;
  cmd[lenCmd++] = sensorIndex;
  cmd[lenCmd++] = regAlsGain;
  cmd[lenCmd++] = val_hi;
  cmd[lenCmd++] = val_lo;

  rc = m_i2cBus.write_read(m_addrSubProc, cmd, lenCmd, rsp, lenRsp, TStd);

  if( rc == LAE_OK )
  {
    pf = rsp[0];  // pass/fail
  }

  unlock();

  return rc;
}

int LaeRangeMuxSubproc::cmdTuneToFSensor ( const std::string &  strKey, uint_t  uRangeOffset, uint_t  uRangeCrossTalk  )

protected

Tune time-of-flight range sensor command.

Parameters

uRangeOffset	ToF sensor part-to-part offset. If VL6180X_FACTORY_DFT then leave as is.
uRangeCrossTalk	ToF sensor cross-talk compensation. If VL6180X_FACTORY_DFT then leave as is.

Returns

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

Definition at line 2112 of file laeVL6180.cxx.

References laelaps::cap(), lock(), m_addrSubProc, sensor::vl6180::LaeRangeInterface::m_i2cBus, m_mapInfo, m_uFwVer, TStd, unlock(), VL6180X_RANGE_OFFSET_MAX, VL6180X_RANGE_OFFSET_MIN, VL6180X_RANGE_XTALK_MAX, VL6180X_RANGE_XTALK_MIN, and laelaps::LaeI2C::write_read().

Referenced by configure().

{
  byte_t  cmd[LaeToFMuxI2CMaxCmdLen];
  byte_t  rsp[LaeToFMuxI2CMaxRspLen];
  size_t  lenCmd = 0;
  size_t  lenRsp = LaeToFMuxI2CRspLenTuneToFSensor;
  byte_t  sensorIndex;
  byte_t  regOffset;
  u16_t   regCrossTalk;
  byte_t  val_hi, val_lo;
  byte_t  pf;
  int     rc;

  SensorInfoMap::iterator pos;

  if( (pos = m_mapInfo.find(strKey)) == m_mapInfo.end() )
  {
    LOGERROR("VL6180 sensor %s not found.", strKey.c_str());
    return -LAE_ECODE_BAD_VAL;
  }

  sensorIndex = pos->second.m_nIndex;

  lock();

  regOffset = (byte_t)(uRangeOffset, (uint_t)VL6180X_RANGE_OFFSET_MIN,
                                     (uint_t)VL6180X_RANGE_OFFSET_MAX);

  regCrossTalk = (u16_t)cap(uRangeCrossTalk, (uint_t)VL6180X_RANGE_XTALK_MIN,
                                             (uint_t)VL6180X_RANGE_XTALK_MAX);

  cmd[lenCmd++] = LaeToFMuxI2CCmdIdTuneToFSensor;
  cmd[lenCmd++] = sensorIndex;
  cmd[lenCmd++] = regOffset;

  if( m_uFwVer >= 2 )
  {
    val_hi = (byte_t)((regCrossTalk >> 8) & 0xff);
    val_lo = (byte_t)(regCrossTalk & 0xff);
    cmd[lenCmd++] = val_hi;
    cmd[lenCmd++] = val_lo;
  }
  else
  {
    cmd[lenCmd++] = regCrossTalk;
  }

  rc = m_i2cBus.write_read(m_addrSubProc, cmd, lenCmd, rsp, lenRsp, TStd);

  if( rc == LAE_OK )
  {
    pf = rsp[0];  // pass/fail
  }

  unlock();

  return rc;
}

int LaeRangeMuxSubproc::configure ( const laelaps::LaeDesc &  desc )

virtual

Configure sensor array from product description.

Parameters

desc	Product description.

Returns

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

Reimplemented from sensor::vl6180::LaeRangeInterface.

Definition at line 1651 of file laeVL6180.cxx.

References cmdGetFwVersion(), cmdGetIdent(), cmdGetTunes(), getSensorProps(), laelaps::LaeDesc::m_mapDescRangeSensor, m_mapInfo, m_uFwVer, and laelaps::radToDeg().

Referenced by reload().

{
  LaeDesc::MapDescRangeSensor::const_iterator iter;
  SensorInfoMap::iterator iter2;

  // subproc version
  uint_t  uFwVer;

  // sensor identity
  VL6180xIdentification   ident;
  bool                    bIdent;

  // sensor tuning values
  uint_t  uRangeOffset;
  uint_t  uRangeCrossTalk;
  double  fAlsGain;
  uint_t  uAlsIntPeriod;
  s8_t    nOffset;
  bool    bTunes;

  // sensor properties
  string  strRadiationType;
  double  fFoV;
  double  fBeamDir;
  double  fMin;
  double  fMax;

  int     rc;

  //
  // Read firmware version, if necessary.
  //
  if( m_uFwVer == 0 )
  {
    if( (rc = cmdGetFwVersion(uFwVer)) != LAE_OK )
    {
      LOGERROR("Failed to read ToFMux firmware version.");
    }
  }
 
  //
  // Product Time of Flight proximity sensors.
  //
  for(iter = desc.m_mapDescRangeSensor.begin();
      iter != desc.m_mapDescRangeSensor.end();
      ++iter)
  {
    // map key - index assoc. (channel number is index for now)
    m_mapInfo[iter->first] = LaeVL6180SensorInfo(iter->second->m_nChan,
                                                 iter->second->m_nChan,
                                                 iter->second->m_fDir,
                                                 iter->second->m_fDeadzone,
                                                 iter->second->m_strDesc);
  }

  //
  // Get identity on each sensor.
  //
  for(iter2 = m_mapInfo.begin(); iter2 != m_mapInfo.end(); ++iter2)
  {
    bIdent = false;
    bTunes = false;

    if( (rc = cmdGetIdent(iter2->first, ident)) == LAE_OK )
    {
      bIdent = true;
    }
    else
    {
      LOGERROR("VL6180 range %s sensor: Failed to read identify.",
          iter2->first.c_str());
    }

    rc = cmdGetTunes(iter2->first, uRangeOffset, uRangeCrossTalk,
                                    fAlsGain, uAlsIntPeriod);

    if( rc == LAE_OK )
    {
      bTunes = true;
    }
    else
    {
      LOGERROR("VL6180 range %s sensor: Failed to read tune parameters.",
          iter2->first.c_str());
    }

    nOffset = (s8_t)(uRangeOffset & 0xff);

    getSensorProps(iter2->first, strRadiationType,
                                 fFoV, fBeamDir, fMin, fMax);

    LOGDIAG2("VL6180 %s(%d) Sensor Info:\n"
              "    Properties\n"
              "  Location:        %s\n"
              "  Beam Direction:  %.1lf degrees\n"
              "  Radiation:       %s\n"
              "  FoV:             %.1lf degrees\n"
              "  Min Distance:    %.3lf meters\n"
              "  MAx Distance:    %.3lf meters\n"
              "    Identity\n"
              "  Model:           0x%02x v%u.%u\n"
              "  Module:          v%u.%u\n"
              "  Date/Time:       %u/%u\n"
              "    Tuning\n"
              "  ToF Offset:      %d(%u)\n"
              "  ToF Cross-Talk:  %u\n"
              "  ALS Gain:        %.2lf\n"
              "  ALS Int. Period: %u msec",
        iter2->first.c_str(), iter2->second.m_nIndex,
        iter2->first.c_str(),
        radToDeg(fBeamDir),
        strRadiationType.c_str(),
        radToDeg(fFoV),
        fMin,
        fMax,
        ident.idModel, ident.idModelRevMajor, ident.idModelRevMinor,
        ident.idModuleRevMajor, ident.idModuleRevMinor,
        ident.idDate, ident.idTime,
        nOffset, uRangeOffset,
        uRangeCrossTalk,
        fAlsGain,
        uAlsIntPeriod);
  }

  LOGDIAG2("Configured Range Sensor Group from robot description.");

  return LAE_OK;
}

int LaeRangeMuxSubproc::configure ( const laelaps::LaeTunes &  tunes )

virtual

Configure sensor array from tuning parameters.

Parameters

tunes

Tuning parameters.

Returns

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

Reimplemented from sensor::vl6180::LaeRangeInterface.

Definition at line 1780 of file laeVL6180.cxx.

References cmdTuneAls(), cmdTuneToFSensor(), laelaps::LaeTunes::getVL6180Params(), m_mapInfo, and VL6180X_FACTORY_DFT.

{
  int     nRangeOffset;
  int     nRangeCrossTalk;
  double  fAlsGain;
  int     nAlsIntPeriod;
  int     rc;

  SensorInfoMap::iterator iter;

  for(iter = m_mapInfo.begin(); iter != m_mapInfo.end(); ++iter)
  {
    tunes.getVL6180Params(iter->first,  nRangeOffset, nRangeCrossTalk,
                                        fAlsGain, nAlsIntPeriod);

    //
    // Time-of-flight sensor tuning.
    //
    if( (nRangeOffset != VL6180X_FACTORY_DFT) &&
        (nRangeCrossTalk != VL6180X_FACTORY_DFT) )
    {
      rc = cmdTuneToFSensor(iter->first,  (uint_t)nRangeOffset,
                                          (uint_t)nRangeCrossTalk);

      if( rc == LAE_OK )
      {
        LOGDIAG3("VL6180 range sensor %s: Time-of-flight sensor tuned.",
            iter->first.c_str());
      }
      else
      {
        LOGERROR("VL6180 range sensor %s: Failed to tune time-of-flight.",
            iter->first.c_str());
        return rc;
      }
    }
    
    //
    // Ambient light sensor tuning.
    //
    rc = cmdTuneAls(iter->first, fAlsGain, (uint_t)nAlsIntPeriod);

    if( rc == LAE_OK )
    {
      LOGDIAG3("VL6180 range sensor %s: Ambient light sensor tuned.",
            iter->first.c_str());
    }
    else
    {
      LOGERROR("VL6180 range sensor %s: Failed to tune ambient light sensor.",
            iter->first.c_str());
      return rc;
    }
  }

  LOGDIAG2("Tuned VL6180 range sensor group.");

  return rc;
}

void LaeRangeMuxSubproc::exec ( )

virtual

Execute one cycle to take measurements.

Context:

LaeThreadRange thread instance.

Reimplemented from sensor::vl6180::LaeRangeInterface.

Definition at line 1847 of file laeVL6180.cxx.

References cmdGetAmbientLight(), and cmdGetRanges().

{
  cmdGetRanges();

#ifdef LAE_USE_ALS
  cmdGetAmbientLight();
#endif // LAE_USE_ALS
}

int LaeRangeMuxSubproc::getAmbientLight ( const std::string &  strKey, double &  fAmbient  )

virtual

Get an ambient light illuminance measurement.

Parameters

	strKey	Sensor's unique name (key).
[out]	fAmbient	Sensed ambient light (lux).

Returns

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

Reimplemented from sensor::vl6180::LaeRangeInterface.

Definition at line 2259 of file laeVL6180.cxx.

References m_mapInfo, and m_vecLux.

{
  SensorInfoMap::iterator pos;

  if( (pos = m_mapInfo.find(strKey)) == m_mapInfo.end() )
  {
    LOGERROR("VL6180 sensor %s not found.", strKey.c_str());
    return -LAE_ECODE_BAD_VAL;
  }

  int sensorIndex = pos->second.m_nIndex;

  fLux = m_vecLux[sensorIndex];

  return LAE_OK;
}

int LaeRangeMuxSubproc::getAmbientLight ( std::vector< std::string > &  vecNames, std::vector< double > &  vecAmbient  )

virtual

Get all sensor ambient light illuminance measurements.

Parameters

[out]	vecNames	Vector of sensor unique names.
[out]	vecAmbient	Vector of associated sensor measured ambients (lux).

Returns

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

Reimplemented from sensor::vl6180::LaeRangeInterface.

Definition at line 2276 of file laeVL6180.cxx.

References m_mapInfo, and m_vecLux.

{
  SensorInfoMap::iterator iter;

  vecNames.clear();
  vecLux.clear();

  for(iter = m_mapInfo.begin(); iter != m_mapInfo.end(); ++iter)
  {
    vecNames.push_back(iter->first);
    vecLux.push_back(m_vecLux[iter->second.m_nIndex]);
  }

}

int LaeRangeMuxSubproc::getInterfaceVersion ( uint_t &  uVerMajor, uint_t &  uVerMinor, uint_t &  uFwVer  )

virtual

Get interface version.

Parameters

[out]	uVerMajor	Interface version major number.
[out]	uVerMinor	Interface version minor number.
[out]	uFwVer	Firmware version.

Returns

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

Reimplemented from sensor::vl6180::LaeRangeInterface.

Definition at line 1621 of file laeVL6180.cxx.

References cmdGetFwVersion(), LAE_VER_MAJOR, LAE_VER_MINOR, and m_uFwVer.

{
  int   rc;

  rc = cmdGetFwVersion(m_uFwVer);

  uVerMajor = LAE_VER_MAJOR(RtDb.m_product.m_uProdHwVer);
  uVerMinor = LAE_VER_MINOR(RtDb.m_product.m_uProdHwVer);
  uFwVer    = m_uFwVer;

  return rc;
}

int LaeRangeMuxSubproc::getRange ( const std::string &  strKey, double &  fRange  )

virtual

Get a range measurement.

Parameters

	strKey	Sensor's unique name (key).
[out]	fRange	Sensed object range (meters).

Returns

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

Reimplemented from sensor::vl6180::LaeRangeInterface.

Definition at line 2225 of file laeVL6180.cxx.

References m_mapInfo, and m_vecRanges.

{
  SensorInfoMap::iterator pos;

  if( (pos = m_mapInfo.find(strKey)) == m_mapInfo.end() )
  {
    LOGERROR("VL6180 sensor %s not found.", strKey.c_str());
    return -LAE_ECODE_BAD_VAL;
  }

  int sensorIndex = pos->second.m_nIndex;

  fRange = m_vecRanges[sensorIndex];

  return LAE_OK;
}

int LaeRangeMuxSubproc::getRange ( std::vector< std::string > &  vecNames, std::vector< double > &  vecRanges  )

virtual

Get all sensor range measurements.

Parameters

[out]	vecNames	Vector of sensor unique names.
[out]	vecRanges	Vector of associated sensor measured ranges (meters).

Returns

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

Reimplemented from sensor::vl6180::LaeRangeInterface.

Definition at line 2242 of file laeVL6180.cxx.

References m_mapInfo, and m_vecRanges.

{
  SensorInfoMap::iterator iter;

  vecNames.clear();
  vecRanges.clear();

  for(iter = m_mapInfo.begin(); iter != m_mapInfo.end(); ++iter)
  {
    vecNames.push_back(iter->first);
    vecRanges.push_back(m_vecRanges[iter->second.m_nIndex]);
  }

  return LAE_OK;
}

int LaeRangeMuxSubproc::getSensorProps ( const std::string &  strKey, std::string &  strRadiationType, double &  fFoV, double &  fBeamDir, double &  fMin, double &  fMax  )

virtual

Get range sensor properties.

Parameters

	strKey	Sensor's unique name id (key).
[out]	strRadiationType	Radiation type.
[out]	fFoV	Field of View (radians).
[out]	fBeamdir	Center of beam direction (radians).
[out]	fMin	Minimum range (meters).
[out]	fMax	Maximum range (meters).

Returns

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

Reimplemented from sensor::vl6180::LaeRangeInterface.

Definition at line 2292 of file laeVL6180.cxx.

References m_mapInfo.

Referenced by configure().

{
  SensorInfoMap::iterator pos;

  if( (pos = m_mapInfo.find(strKey)) == m_mapInfo.end() )
  {
    LOGERROR("VL6180 range sensor %s not found.", strKey.c_str());
    return -LAE_ECODE_BAD_VAL;
  }

  int         nIndex;
  int         nChan;
  double      fDeadzone;
  std::string strDesc;

  pos->second.getProps(nIndex, nChan, strRadiationType, fFoV, fBeamDir,
                        fDeadzone, fMin, fMax, strDesc);

  return LAE_OK;
}

void sensor::vl6180::LaeRangeMuxSubproc::lock ( )

inlineprotected

Lock the share resource.

The lock()/unlock() primitives provide a thread safe mechanism.

Context:

Any.

Definition at line 1408 of file laeVL6180.h.

Referenced by cmdGetAmbientLight(), cmdGetFwVersion(), cmdGetIdent(), cmdGetRanges(), cmdGetTunes(), cmdTuneAls(), and cmdTuneToFSensor().

      {
        pthread_mutex_lock(&m_mutex);
      }

int LaeRangeMuxSubproc::readSensorIdentity ( const std::string &  strKey, VL6180xIdentification &  ident  )

virtual

Read sensor's identification.

Parameters

	strKey	Sensor's unique name id (key).
[out]	ident	Identification structure.

Returns

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

Reimplemented from sensor::vl6180::LaeRangeInterface.

Definition at line 2318 of file laeVL6180.cxx.

References cmdGetIdent().

{
  return cmdGetIdent(strKey, ident);
}

int LaeRangeMuxSubproc::readSensorTunes ( const std::string &  strKey, uint_t &  uRangeOffset, uint_t &  uRangeCrossTalk, double &  fAlsGain, uint_t &  uAlsIntPeriod  )

virtual

Read sensor's current tuning parameters.

Parameters

	strKey	Sensor's unique name id (key).
[out]	uRangeOffset	ToF sensor part-to-part offset.
[out]	uRangeCrossTalk	ToF sensor cross-talk compensation.
[out]	fAlsGain	Ambient light sensor analog gain.
[out]	uAlsIntPeriod	Ambient light sensor integration period (msec).

Returns

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

Reimplemented from sensor::vl6180::LaeRangeInterface.

Definition at line 2325 of file laeVL6180.cxx.

References cmdGetTunes().

{
  return cmdGetTunes(strKey, uRangeOffset, uRangeCrossTalk,
                             fAlsGain,     uAlsIntPeriod);
}

int LaeRangeMuxSubproc::reload ( const laelaps::LaeTunes &  tunes )

virtual

Reload configuration tuning parameters.

Parameters

tunes

Tuning parameters.

Returns

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

Reimplemented from sensor::vl6180::LaeRangeInterface.

Definition at line 1840 of file laeVL6180.cxx.

References configure().

{
  LOGDIAG2("Reloading VL6180 range sensor group tuning parameters...");

  return configure(tunes);
}

void sensor::vl6180::LaeRangeMuxSubproc::unlock ( )

inlineprotected

Unlock the shared resource.

Context:

Any.

Definition at line 1419 of file laeVL6180.h.

Referenced by cmdGetAmbientLight(), cmdGetFwVersion(), cmdGetIdent(), cmdGetRanges(), cmdGetTunes(), cmdTuneAls(), and cmdTuneToFSensor().

      {
        pthread_mutex_unlock(&m_mutex);
      }

---

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

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