sensor::vl6180::LaeVL6180Mux Class Reference

VL6180 Time of Flight Class. More...

#include <laeVL6180.h>

Public Member Functions
	LaeVL6180Mux (laelaps::LaeI2CMux &mux, int nChan, double fBeamDir, double fDeadzone, const std::string &strNameId="VL6180", const std::string &strDesc="Time-of-Flight range sensor")
	Intialization constructor. More...
	LaeVL6180Mux (const LaeVL6180Mux &src)
	Copy constructor. More...
virtual	~LaeVL6180Mux ()
	Destructor.
int	initSensor (bool bForce=false)
	Initialize sensor with recommended settings and defaults. More...
int	writeDefaults ()
	Write defaults to sensor. More...
void	readShadowRegs ()
	Read shadows register values and update derived data.
void	readShadowRegs (byte_t &regRangeOffset, u16_t &regRangeCrossTalk, byte_t &regAlsGain, u16_t &regAlsIntPeriod)
	Read shadows register values, update derived data, and return registers values. More...
int	tune (uint_t uRangeOffset, uint_t uRangeCrossTalk, double fAlsGain, uint_t uAlsIntPeriod)
	Tune sensor configuration. More...
int	readId (struct VL6180xIdentification &id)
	Read sensor identification. More...
double	measureRange (u32_t msecWait=0xffff)
	Measure the sensed target range. More...
double	measureAmbientLight (u32_t msecWait=0xffff)
	Measure the sensed ambient light illuminance. More...
void	getMeasurements (double &fRange, double &fAmbientLight)
	Get last sensed measurements. More...
std::string	getNameId ()
	Get sensor assigned name id. More...
std::string	getDesc ()
	Get sensor short description. More...
double	getBeamDir ()
	Get sensor direction of the center of emitter IR beam. More...
double	getFoV ()
	Get sensor field of view. More...
void	getMinMax (double &fMin, double &fMax)
	Get sensor's minimum and maximum range. More...
std::string	getRadiationType ()
	Get radiation type. More...
int	calibOffset (int &nOffsetPre, double &fAvgPre, int &nOffsetPost, double &fAvgPost)
	Calibrate part-to-part offset. More...
int	calibCrossTalk (int &nCrossTalk)
	Calibrate cross-talk compensation. More...
int	readReg8 (u16_t reg, byte_t &val)
	Read an 8-bit value from a register. More...
int	readReg16 (u16_t reg, u16_t &val)
	Read a 16-bit value from a register. More...
int	writeReg8 (u16_t reg, byte_t val)
	Write an 8-bit value to a register. More...
int	writeReg16 (u16_t reg, u16_t val)
	Write a 16-bit value to a register. More...

Static Public Member Functions
static double	gainEnumToAnalog (vl6180x_als_gain eAlsGain)
	Convert ambient light sensor gain register value enum to analog gain. More...
static vl6180x_als_gain	gainAnalogToEnum (double fAlsGain)
	Convert ambient light sensor analog gain to associated register value enum. More...

Static Public Attributes
static const int	NSenseErrorsThreshold = 10
	Consecutive sensed error count threshold. More...

Protected Member Functions
void	lock ()
	Lock the share resource. More...
void	unlock ()
	Unlock the shared resource. More...
int	outOfResetInit ()
	Initialize sensor out-of-reset. More...
u32_t	waitForSensorReady (u16_t regStatus, u32_t msecWait)
	Wait for sensor to be ready. More...
u32_t	waitForSensorMeasurement (u32_t msecWait, byte_t bitDone)
	Wait for sensor measurement to complete. More...

Protected Attributes
laelaps::LaeI2CMux &	m_mux
	I2C multiplexor.
int	m_nChan
	multiplexed channel number
double	m_fBeamDir
	center of beam direction(radians)
double	m_fDeadzone
	sensor deadzone (m)
std::string	m_strNameId
	name identifier of sensor
std::string	m_strDesc
	short description
int	m_nErrorCnt
	consecutive error count
bool	m_bBlackListed
	sensor is [not] black listed
double	m_fAlsGain
	ambient light sensor analog gain
uint_t	m_uAlsIntPeriod
	ALS integration period (msec)
byte_t	m_regRangeOffset
	range part-to-part offset register
u16_t	m_regRangeCrossTalk
	range cross-talk register
byte_t	m_regAlsGain
	ambient light sensor gain register
u16_t	m_regAlsIntPeriod
	ALS itegration period register.
double	m_fRange
	range (m)
double	m_fAmbientLight
	ambient light (lux)
pthread_mutex_t	m_mutex
	mutex

Detailed Description

VL6180 Time of Flight Class.

The interface between the processor and the sensor is through an I²C mulitplexer.

Definition at line 368 of file laeVL6180.h.

Constructor & Destructor Documentation

sensor::vl6180::LaeVL6180Mux::LaeVL6180Mux	(	laelaps::LaeI2CMux &	mux,
		int	nChan,
		double	fBeamDir,
		double	fDeadzone,
		const std::string &	strNameId = "VL6180",
		const std::string &	strDesc = "Time-of-Flight range sensor"
	)

Intialization constructor.

Parameters

mux	I2C multiplexer switch.
nChan	Mulitplexed channel number.
fBeamDir	Center of IR beam direction (radians).
fDeadzone	Sense deadzone range.
strNameId	Name identifier.
strDesc	Short description (e.g. location).

LaeVL6180Mux::LaeVL6180Mux

(

const LaeVL6180Mux &

src

)

Copy constructor.

Parameters

src	Source object.

Definition at line 209 of file laeVL6180.cxx.

References m_bBlackListed, m_fAlsGain, m_fAmbientLight, m_fRange, m_mutex, m_nErrorCnt, m_regAlsGain, m_regAlsIntPeriod, m_regRangeCrossTalk, m_regRangeOffset, and m_uAlsIntPeriod.

                                                  :
    m_mux(src.m_mux), m_nChan(src.m_nChan),
    m_fBeamDir(src.m_fBeamDir), m_fDeadzone(src.m_fDeadzone),
    m_strNameId(src.m_strNameId)
{
  m_nErrorCnt         = src.m_nErrorCnt;
  m_bBlackListed      = src.m_bBlackListed;
  m_fAlsGain          = src.m_fAlsGain;
  m_uAlsIntPeriod     = src.m_uAlsIntPeriod;
  m_regRangeOffset    = src.m_regRangeOffset;
  m_regRangeCrossTalk = src.m_regRangeCrossTalk;
  m_regAlsGain        = src.m_regAlsGain;
  m_regAlsIntPeriod   = src.m_regAlsIntPeriod;
  m_fRange            = src.m_fRange;
  m_fAmbientLight     = src.m_fAmbientLight;

  pthread_mutex_destroy(&m_mutex);
}

Member Function Documentation

int LaeVL6180Mux::calibCrossTalk

(

int &

nCrossTalk

)

Calibrate cross-talk compensation.

The offset is stored in register SYSRANGE_CROSSTALK_COMPENSATION_RATE (0x001e).

See also

Section 2.12.4 in datasheet for setup and procedures.

Parameters

[out]

nCrossTalk

Cross-talk compensation written to compensation register.

Returns

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

Definition at line 1037 of file laeVL6180.cxx.

References m_regRangeCrossTalk, measureRange(), readReg8(), VL6180X_RANGE_MAX, and writeReg16().

{
  u16_t  regComp    = VL6180X_SYSRANGE_CROSSTALK_COMPENSATION_RATE;
  u16_t  regRate    = VL6180X_RESULT_RANGE_RETURN_RATE;
  double fBlackTgt  = 0.100;  // required black target distance
  int    minGood    = 10;     // minimum number of measurement to be valid
  int    maxIters   = 20;     // should >= min as per data sheet

  byte_t  val;        // register value
  double  fRate;      // range return rate measurement
  double  fSumRate;   // return rate sum
  double  fAvgRate;   // return rate average
  double  fRange;     // range measurement
  double  fSumRange;  // range sum
  double  fAvgRange;  // range average
  int     nMeasured;  // number of sucessful range measurements
  int     i;          // iterator
  int     rc;         // return code

  //
  // Clear compensation register.
  //
  if( (rc = writeReg16(regComp, 0)) == LAE_OK )
  {
    m_regRangeCrossTalk = 0;  // update shadow register
  }
  else
  {
    LOGDIAG3("Failed to write SYSRANGE_CROSSTALK_COMPENSATION_RATE (0x%04x) "
              "register. Cannot proceed with calibration.",
              regComp);
    return rc;
  }

  //
  // Make set of measurements.
  //
  for(i = 0, fSumRange = 0.0, fSumRate = 0.0, nMeasured = 0; i<maxIters; ++i)
  {
    fRange = measureRange();
    rc = readReg8(regRate, val);

    if( (fRange >= 0.0) && (fRange <= VL6180X_RANGE_MAX) && (rc == LAE_OK) )
    {
      fSumRange += fRange;
      fSumRate  += (double)val;
      ++nMeasured;
    }
  }

  //
  // Not of enough good measurements to determine calibration offset.
  //
  if( nMeasured < minGood )
  {
    LOGDIAG3("Made %d/%d rate/range meassurements. "
            "A minimum of %d are required."
             "Cannot proceed with calibration.",
              nMeasured, minGood);
    return -LAE_ECODE_IO;
  }

  fAvgRange = fSumRange / (double)nMeasured;
  fAvgRate  = fSumRate / (double)nMeasured;

  val = (byte_t)(fAvgRate * (1.0 - fAvgRange/fBlackTgt));

  //
  // Write new compensation value.
  //
  if( (rc = writeReg16(regComp, val)) == LAE_OK )
  {
    m_regRangeCrossTalk = val;    // update shadow register
  }
  else
  {
    LOGDIAG3("Failed to write new SYSRANGE_CROSSTALK_COMPENSATION_RATE (0x%04x)"
              " register value. Calibration failed.",
              regComp);

    return rc;
  }

  nCrossTalk = (int)val & 0x0ff;

  return LAE_OK;
}

int LaeVL6180Mux::calibOffset	(	int &	nOffsetPre,
		double &	fAvgPre,
		int &	nOffsetPost,
		double &	fAvgPost
	)

Calibrate part-to-part offset.

The offset is stored in register SYSRANGE_PART_TO_PART_RANGE_OFFSET (0x0024).

See also

Section 2.12.3 in datasheet for setup and procedures.

Parameters

[out]	nOffsetPre	Current offset register value.
[out]	fAvgPre	Average measured range on pre-calibrated sensor.
[out]	nOffsetPost	Post-procedure offset value written to offset register. If equal to nOffsetPre, no calibration was required.
[out]	fAvgPost	Average measured range after new offset written.

Returns

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

Definition at line 878 of file laeVL6180.cxx.

References m_regRangeOffset, measureRange(), readReg8(), VL6180X_RANGE_MAX, and writeReg8().

{
  u16_t  regOffset  = VL6180X_SYSRANGE_PART_TO_PART_RANGE_OFFSET;
  double fWhiteTgt  = 0.050;  // required white target distance
  double fRes       = 0.003;  // range plus/minus resolution is best possible
  int    minGood    = 10;     // minimum number of measurement to be valid
  int    maxIters   = 20;     // should >= min as per data sheet

  s8_t    offset;     // part-to-part offset in 2's compliment
  double  fRange;     // range measurement
  double  fSum;       // sum
  int     nMeasured;  // number of sucessful range measurements
  int     i;          // iterator
  int     rc;         // return code

  //
  // Read current, pre-calibrated offset register value.
  //
  if( (rc = readReg8(regOffset, (byte_t &)offset)) == LAE_OK )
  {
    m_regRangeOffset = (byte_t)offset;  // update shadow register
  }
  else
  {
    LOGDIAG3("Failed to read SYSRANGE_PART_TO_PART_RANGE_OFFSET (0x%04x) "
              "register. Cannot proceed with calibration.",
              regOffset);
    return rc;
  }

  //
  // Make a set of measurements to gather performance statistics.
  //
  for(i = 0, fSum = 0.0, nMeasured = 0; i<maxIters; ++i)
  {
    fRange = measureRange();
    if( (fRange >= 0.0) && (fRange <= VL6180X_RANGE_MAX) )
    {
      fSum += fRange;
      ++nMeasured;
    }
  }

  //
  // Not of enough good measurements to determine performance.
  //
  if( nMeasured < minGood )
  {
    LOGDIAG3("Made %d/%d range meassurements. A minimum of %d are required."
              "Cannot proceed with calibration.",
              nMeasured, minGood);
    return -LAE_ECODE_IO;
  }

  nOffsetPre  = (int)offset;
  fAvgPre     = fSum / (double)nMeasured;

  //
  // No part-to-part offset calibaration required.
  //
  if( (fAvgPre >= fWhiteTgt-fRes) && (fAvgPre <= fWhiteTgt+fRes) )
  {
    nOffsetPost = nOffsetPre;
    fAvgPost    = fAvgPre;
    return LAE_OK;
  }

  //
  // Clear offset register.
  //
  if( (rc = writeReg8(regOffset, 0)) == LAE_OK )
  {
    m_regRangeOffset = 0;  // update shadow register
  }
  else
  {
    LOGDIAG3("Failed to write SYSRANGE_PART_TO_PART_RANGE_OFFSET (0x%04x) "
              "register. Cannot proceed with calibration.",
              regOffset);
    return rc;
  }

  //
  // Make another set of measurements.
  //
  for(i = 0, fSum = 0.0, nMeasured = 0; i<maxIters; ++i)
  {
    fRange = measureRange();
    if( (fRange >= 0.0) && (fRange <= VL6180X_RANGE_MAX) )
    {
      fSum += fRange;
      ++nMeasured;
    }
  }

  //
  // Not of enough good measurements to determine calibration offset.
  //
  if( nMeasured < minGood )
  {
    LOGDIAG3("Made %d/%d range meassurements. A minimum of %d are required."
              "Cannot proceed with calibration.",
              nMeasured, minGood);
    return -LAE_ECODE_IO;
  }

  fAvgPost    = fSum / (double)nMeasured;
  nOffsetPost = (int)((fWhiteTgt - fAvgPost) * 1000.0);

  offset = (s8_t)(nOffsetPost);

  //
  // Write new offset value.
  //
  if( (rc = writeReg8(regOffset, (byte_t)offset)) == LAE_OK )
  {
    m_regRangeOffset = (byte_t)offset;  // update shadow register
  }
  else
  {
    LOGDIAG3("Failed to write new SYSRANGE_PART_TO_PART_RANGE_OFFSET (0x%04x) "
              "register. Calibration failed.",
              regOffset);
    return rc;
  }

  //
  // One final performance evaluation.
  //
  for(i = 0, fSum = 0.0, nMeasured = 0; i<maxIters; ++i)
  {
    fRange = measureRange();
    if( (fRange >= 0.0) && (fRange <= VL6180X_RANGE_MAX) )
    {
      fSum += fRange;
      ++nMeasured;
    }
  }

  //
  // Not of enough good measurements to determine performance.
  //
  if( nMeasured < minGood )
  {
    LOGWARN("Made %d/%d range meassurements. A minimum of %d are required."
              "Post performance evaluation is unknown.",
              nMeasured, minGood);
  }
  else
  {
    fAvgPost = fSum / (double)nMeasured;
  }

  return LAE_OK;
}

vl6180x_als_gain LaeVL6180Mux::gainAnalogToEnum ( double  fAlsGain )

static

Convert ambient light sensor analog gain to associated register value enum.

The mapped enum with the minimum difference between the target analog gain and the actual is chosen.

Parameters

fAlsGain

Ambient light sensor analog gain.

Returns

Gain enum.

Definition at line 1137 of file laeVL6180.cxx.

References AlsGainAnalogTbl, sensor::vl6180::GAIN_1, sensor::vl6180::GAIN_40, and sensor::vl6180::GAIN_NumOf.

Referenced by sensor::vl6180::LaeRangeMuxSubproc::cmdTuneAls(), and tune().

{
  int       i;
  int       eGain;
  double    diff, minDiff;

  fAlsGain = fabs(fAlsGain);

  if( fAlsGain >= AlsGainAnalogTbl[GAIN_40] )
  {
    return GAIN_40;
  }
  else if( fAlsGain <= AlsGainAnalogTbl[GAIN_1] )
  {
    return GAIN_1;
  }

  eGain   = 0;  
  minDiff = fabs(AlsGainAnalogTbl[eGain] - fAlsGain);

  //
  // Find closest enum.
  //
  for(i=1; i<GAIN_NumOf; ++i)
  {
    diff = fabs(AlsGainAnalogTbl[i] - fAlsGain);
    if( diff < minDiff )
    {
      eGain   = i;
      minDiff = diff;
    }
  }

  return (vl6180x_als_gain)eGain;
}

double LaeVL6180Mux::gainEnumToAnalog ( vl6180x_als_gain  eAlsGain )

static

Convert ambient light sensor gain register value enum to analog gain.

Parameters

eAlsGain

Ambient light sensor gain enumeration.

Returns

Analog gain.

Definition at line 1125 of file laeVL6180.cxx.

References AlsGainAnalogTbl, sensor::vl6180::GAIN_1, and sensor::vl6180::GAIN_NumOf.

Referenced by sensor::vl6180::LaeRangeMuxSubproc::cmdGetTunes(), sensor::vl6180::LaeVL6180MuxArray::readSensorTunes(), readShadowRegs(), and tune().

{
  if( (eAlsGain >= 0) && (eAlsGain < GAIN_NumOf) )
  {
    return AlsGainAnalogTbl[eAlsGain];
  }
  else
  {
    return AlsGainAnalogTbl[GAIN_1];
  }
}

double sensor::vl6180::LaeVL6180Mux::getBeamDir ( )

inline

Get sensor direction of the center of emitter IR beam.

Returns

Radians.

Definition at line 545 of file laeVL6180.h.

      {
        return m_fBeamDir;
      }

std::string sensor::vl6180::LaeVL6180Mux::getDesc ( )

inline

Get sensor short description.

Returns

String name.

Definition at line 535 of file laeVL6180.h.

      {
        return m_strDesc;
      }

double sensor::vl6180::LaeVL6180Mux::getFoV ( )

inline

Get sensor field of view.

Returns

Radians.

Definition at line 555 of file laeVL6180.h.

References laelaps::degToRad(), and VL6180X_RANGE_FOV.

      {
        return laelaps::degToRad(VL6180X_RANGE_FOV);
      }

void sensor::vl6180::LaeVL6180Mux::getMeasurements ( double &  fRange, double &  fAmbientLight  )

inline

Get last sensed measurements.

[out] fRange Sensed object range (meters). [out] fAmbienLight Sensed ambient light (lux).

Definition at line 514 of file laeVL6180.h.

      {
        fRange        = m_fRange;
        fAmbientLight = m_fAmbientLight;
      }

void sensor::vl6180::LaeVL6180Mux::getMinMax ( double &  fMin, double &  fMax  )

inline

Get sensor's minimum and maximum range.

Returns

Meters, meters.

Definition at line 565 of file laeVL6180.h.

References VL6180X_RANGE_MAX, and VL6180X_RANGE_MIN.

      {
        fMin = VL6180X_RANGE_MIN;
        fMax = VL6180X_RANGE_MAX;
      }

std::string sensor::vl6180::LaeVL6180Mux::getNameId ( )

inline

Get sensor assigned name id.

Returns

String name.

Definition at line 525 of file laeVL6180.h.

      {
        return m_strNameId;
      }

std::string sensor::vl6180::LaeVL6180Mux::getRadiationType ( )

inline

Get radiation type.

Returns

String.

Definition at line 576 of file laeVL6180.h.

      {
        return "infrared";
      }

int LaeVL6180Mux::initSensor

(

bool

bForce = false

)

Initialize sensor with recommended settings and defaults.

Note

Higly recommended to call this method and sensor power-up and after resets.

Parameters

bForce

Do [not] force re-initialization.

Returns

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

Definition at line 232 of file laeVL6180.cxx.

References m_bBlackListed, m_nChan, m_nErrorCnt, m_strNameId, outOfResetInit(), readReg8(), readShadowRegs(), and writeDefaults().

{
  byte_t  reset;
  bool    bReinit = true;
  int     rc = LAE_OK;

  m_nErrorCnt     = 0;
  m_bBlackListed  = false;

  if( !bForce )
  {
    rc = readReg8(VL6180X_SYSTEM_FRESH_OUT_OF_RESET, reset);

    if( (rc == LAE_OK) && (reset == 0) )
    {
      LOGDIAG3("VL6180 sensor %s(%d): "
        "Not fresh out of reset: No initialization required.",
        m_strNameId.c_str(), m_nChan);
      bReinit = false;
    }
  }

  if( bReinit )
  {
    if( (rc = outOfResetInit()) == LAE_OK )
    {
      rc = writeDefaults();
    }
  }

  readShadowRegs();

  if( rc == LAE_OK )
  {
    LOGDIAG3("VL6180 sensor %s(%d): Initialized.",
      m_strNameId.c_str(), m_nChan);
  }

  else
  {
    m_bBlackListed = true;
    LOGERROR("VL6180 sensor %s(%d): Black listed: Failed to initialize.",
      m_strNameId.c_str(), m_nChan);
  }

  return rc;
}

void sensor::vl6180::LaeVL6180Mux::lock ( )

inlineprotected

Lock the share resource.

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

Context:

Any.

Definition at line 718 of file laeVL6180.h.

Referenced by measureAmbientLight(), measureRange(), readId(), and readShadowRegs().

      {
        pthread_mutex_lock(&m_mutex);
      }

double LaeVL6180Mux::measureAmbientLight

(

u32_t

msecWait = 0xffff

)

Measure the sensed ambient light illuminance.

Single shot mode.

Parameters

msecWait

Maximum time to wait for the measurement to complete (milliseconds). If the wait time is the special value VL6180X_T_AUTO, then the wait time is auto-calculated base on current sensor configuration.

Returns

On success, returns measured illuminance (lux).
On success, the measured illuminance (lux) is returned.
On error, VL6180X_ERR_MEAS(-1.0) is returned.

Definition at line 696 of file laeVL6180.cxx.

References lock(), m_bBlackListed, m_fAlsGain, m_fAmbientLight, m_nChan, m_nErrorCnt, m_strNameId, m_uAlsIntPeriod, NSenseErrorsThreshold, readReg16(), readReg8(), unlock(), VL6180X_ERR_MEAS, VL6180X_T_AUTO, waitForSensorMeasurement(), waitForSensorReady(), and writeReg8().

{
  static byte_t startMeas     = 0x01; // start measurement
  static byte_t measDone      = 0x20; // measurement done bit
  static byte_t statusErrMask = 0xf0; // status error bit mask
  static double alsRes        = 0.32; // .32 lux/count (default without window)

  double  alsLux;       // working lux value
  u16_t   valAlsRaw;    // raw als value
  byte_t  valStatus;    // als sensor status
  u32_t   msec;         // milliseconds
  int     rc = LAE_OK;  // return code

  if( m_bBlackListed )
  {
    return VL6180X_ERR_MEAS;
  }

  lock();

  // auto-determine max wait time
  if( msecWait == VL6180X_T_AUTO )
  {
    msecWait = (u32_t)((double)m_uAlsIntPeriod * 1.2);
  }

  //
  // Wait for sensor to be ready.
  //
  msec = waitForSensorReady(VL6180X_RESULT_ALS_STATUS, msecWait);

  if( msec > msecWait )
  {
    LOGDIAG3("VL6180 sensor %s(%d): Ambient light sensor busy.",
      m_strNameId.c_str(), m_nChan);
    rc = -LAE_ECODE_TIMEDOUT;
  }

  //
  // Start single shot measurement.
  //
  if( rc == LAE_OK )
  {
    rc = writeReg8(VL6180X_SYSALS_START, startMeas);
  }

  //
  // Wait for ambient sensor measurement to complete.
  //
  if( rc == LAE_OK )
  {
    msec += waitForSensorMeasurement(msecWait-msec, measDone);

    if( msec > msecWait )
    {
      LOGDIAG3("VL6180 sensor %s(%d): Ambient light measurement timed out.",
        m_strNameId.c_str(), m_nChan);
      rc = -LAE_ECODE_TIMEDOUT;
    }
  }

  //
  // Read ALS raw value and status.
  //
  if( rc == LAE_OK )
  {
    if( (rc = readReg16(VL6180X_RESULT_ALS_VAL, valAlsRaw)) == LAE_OK )
    {
      rc = readReg8(VL6180X_RESULT_ALS_STATUS, valStatus);
    }
  }
  
  //
  // Validate measurement and convert to SI units.
  //
  if( rc == LAE_OK )
  {
    // relevant bits
    valStatus &= statusErrMask;

    // bits indicate sensor error
    if( valStatus )
    {
      rc = -LAE_ECODE_BAD_VAL;
    }

    // good
    else
    {
      // calculate LUX from formula in AppNotes
      alsLux = alsRes * ((double)valAlsRaw / m_fAlsGain) * 
                          100.0 / (double)(m_uAlsIntPeriod);
    }
  }

  //
  // Save
  //
  if( rc == LAE_OK )
  {
    m_fAmbientLight = alsLux;
    m_nErrorCnt     = 0;
    RtDb.m_range[m_nChan].m_fAmbientLight = m_fAmbientLight;
  }
  else
  {
    alsLux = VL6180X_ERR_MEAS;
    ++m_nErrorCnt;
  }

  if( m_nErrorCnt > NSenseErrorsThreshold )
  {
    m_bBlackListed = true;
  }

  unlock();

  return alsLux;
}

double LaeVL6180Mux::measureRange

(

u32_t

msecWait = 0xffff

)

Measure the sensed target range.

Single shot mode.

Parameters

msecWait

Maximum time to wait for the measurement to complete (milliseconds). If the wait time is the special value VL6180X_T_AUTO, then the wait time is auto-calculated base on current sensor configuration.

Returns

On success, the measured object range (meters) is returned.
If no object is detected within sensor range, VL6180X_RANGE_NO_OBJ(1000000.0) is returned.
On error, VL6180X_ERR_MEAS(-1.0) is returned.

Definition at line 547 of file laeVL6180.cxx.

References lock(), m_bBlackListed, m_fRange, m_nChan, m_nErrorCnt, m_strNameId, NSenseErrorsThreshold, readReg8(), unlock(), VL6180X_ERR_MEAS, VL6180X_RANGE_MAX, VL6180X_RANGE_NO_OBJ, VL6180X_T_AUTO, waitForSensorMeasurement(), waitForSensorReady(), and writeReg8().

Referenced by calibCrossTalk(), and calibOffset().

{
  static byte_t startMeas             = 0x01; // start measurement
  static byte_t measDone              = 0x04; // measurement done bit
  static byte_t statusErrMask         = 0xf0; // status error bit mask
  static byte_t statusErrOverflowRaw  = 0xd0; // raw range overflow
  static byte_t statusErrOverflow     = 0xf0; // range overflow
  static byte_t clearInterrupts       = 0x07; // clear all interrupts

  double  fRange;       // working measured range
  byte_t  valRange;     // raw range value
  byte_t  valStatus;    // range sensor status
  u32_t   msec;         // milliseconds
  int     rc = LAE_OK;  // return code

  if( m_bBlackListed )
  {
    return VL6180X_ERR_MEAS;
  }

  lock();

  // auto-determine max wait time
  if( msecWait == VL6180X_T_AUTO )
  {
    msecWait = 15;
  }

  //
  // Wait for device and sensor to be ready.
  //
  msec = waitForSensorReady(VL6180X_RESULT_RANGE_STATUS, msecWait);

  if( msec > msecWait )
  {
    LOGDIAG3("VL6180 sensor %s(%d): Range sensor busy.",
      m_strNameId.c_str(), m_nChan);
    rc = -LAE_ECODE_TIMEDOUT;
  }

  //
  // Start single shot measurement.
  //
  if( rc == LAE_OK )
  {
    rc = writeReg8(VL6180X_SYSRANGE_START, startMeas);
  }

  //
  // Wait for range sensor measurement to complete.
  //
  if( rc == LAE_OK )
  {
    msec += waitForSensorMeasurement(msecWait-msec, measDone);

    //
    // Note:
    //  Typically, this timeout indicates that there a no objects in range.
    //  If it is logged, the too many errors will be printed. 
    //
    if( msec > msecWait )
    {
      LOGDIAG3("VL6180 sensor %s(%d): Range measurement timed out.",
        m_strNameId.c_str(), m_nChan);
      rc = -LAE_ECODE_TIMEDOUT;
    }
  }

  writeReg8(VL6180X_SYSTEM_INTERRUPT_CLEAR, clearInterrupts);

  //
  // Read range value (mm) and status.
  //
  if( rc == LAE_OK )
  {
    if( (rc = readReg8(VL6180X_RESULT_RANGE_VAL, valRange)) == LAE_OK )
    {
      //rc = readReg8(VL6180X_RESULT_RANGE_STATUS, valStatus);
      //fprintf(stderr, "DBG: range_status=0x%02x\n", val);
    }
  }

  //
  // Validate measurement and convert to SI units.
  //
  if( rc == LAE_OK )
  {
    // relevant bits
    //valStatus &= statusErrMask;

    // Sensor overflow error. Usually indicates no detected object.
    //if( (valStatus == statusErrOverflowRaw) ||
    //    (valStatus == statusErrOverflow) )
    //{
    //  fRange = VL6180X_RANGE_NO_OBJ;
    //}

    // other bits indicate sensor error
    //else if( valStatus )
    //{
    //  rc = -LAE_ECODE_BAD_VAL;
    //}

    // good
    //else
    //{
      // meters
      fRange = (double)valRange / 1000.0;

      // range sensor not trusted after maximum distance
      if( fRange > VL6180X_RANGE_MAX )
      {
        fRange = VL6180X_RANGE_NO_OBJ;
      } 
    //}
  }

  //
  // Save
  //
  if( rc == LAE_OK )
  {
    m_fRange    = fRange;
    m_nErrorCnt = 0;
    RtDb.m_range[m_nChan].m_fRange = m_fRange;
  }
  else if( rc == -LAE_ECODE_TIMEDOUT )
  {
    fRange   = VL6180X_RANGE_NO_OBJ;
    m_fRange = fRange;
    ++m_nErrorCnt;
    RtDb.m_range[m_nChan].m_fRange = m_fRange;
  }
  else
  {
    fRange = VL6180X_ERR_MEAS;
    ++m_nErrorCnt;
  }

  if( m_nErrorCnt > NSenseErrorsThreshold )
  {
    m_bBlackListed = true;
  }

  unlock();

  return fRange;
}

int LaeVL6180Mux::outOfResetInit ( )

protected

Initialize sensor out-of-reset.

Note

Recommend.

Returns

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

Definition at line 280 of file laeVL6180.cxx.

References writeReg8().

Referenced by initSensor().

{ 
  int     rc;

  //
  // Required by datasheet.
  // http://www.st.com/st-web-ui/static/active/en/resource/technical/document/application_note/DM00122600.pdf
  //
  writeReg8(0x0207, 0x01);
  writeReg8(0x0208, 0x01);
  writeReg8(0x0096, 0x00);
  writeReg8(0x0097, 0xfd);
  writeReg8(0x00e3, 0x00);
  writeReg8(0x00e4, 0x04);
  writeReg8(0x00e5, 0x02);
  writeReg8(0x00e6, 0x01);
  writeReg8(0x00e7, 0x03);
  writeReg8(0x00f5, 0x02);
  writeReg8(0x00d9, 0x05);
  writeReg8(0x00db, 0xce);
  writeReg8(0x00dc, 0x03);
  writeReg8(0x00dd, 0xf8);
  writeReg8(0x009f, 0x00);
  writeReg8(0x00a3, 0x3c);
  writeReg8(0x00b7, 0x00);
  writeReg8(0x00bb, 0x3c);
  writeReg8(0x00b2, 0x09);
  writeReg8(0x00ca, 0x09);  
  writeReg8(0x0198, 0x01);
  writeReg8(0x01b0, 0x17);
  writeReg8(0x01ad, 0x00);
  writeReg8(0x00ff, 0x05);
  writeReg8(0x0100, 0x05);
  writeReg8(0x0199, 0x05);
  writeReg8(0x01a6, 0x1b);
  writeReg8(0x01ac, 0x3e);
  writeReg8(0x01a7, 0x1f);
  writeReg8(0x0030, 0x00);

  // 
  // Clear fresh reset bit. Default is 1 after boot/reset. Setting to 0 can
  // be used to detect reset condition.
  //
  rc = writeReg8(VL6180X_SYSTEM_FRESH_OUT_OF_RESET, 0);

  return rc;
}

int LaeVL6180Mux::readId

(

struct VL6180xIdentification &

id

)

Read sensor identification.

Parameters

[out]

id

Identification structure.

Returns

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

Definition at line 529 of file laeVL6180.cxx.

References lock(), readReg16(), readReg8(), and unlock().

{
  lock();

  readReg8(VL6180X_IDENTIFICATION_MODEL_ID, id.idModel);
  readReg8(VL6180X_IDENTIFICATION_MODEL_REV_MAJOR, id.idModelRevMajor);
  readReg8(VL6180X_IDENTIFICATION_MODEL_REV_MINOR, id.idModelRevMinor);
  readReg8(VL6180X_IDENTIFICATION_MODULE_REV_MAJOR, id.idModuleRevMajor);
  readReg8(VL6180X_IDENTIFICATION_MODULE_REV_MINOR, id.idModuleRevMinor);

  readReg16(VL6180X_IDENTIFICATION_DATE, id.idDate);
  readReg16(VL6180X_IDENTIFICATION_TIME, id.idTime);

  unlock();

  return LAE_OK;
}

int LaeVL6180Mux::readReg16	(	u16_t	reg,
		u16_t &	val
	)

Read a 16-bit value from a register.

Parameters

	reg	16-bit register address.
[out]	val	Read value.

Returns

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

Definition at line 1193 of file laeVL6180.cxx.

References m_mux, m_nChan, m_strNameId, laelaps::LaeI2CMux::transact(), and VL6180X_ADDR.

Referenced by measureAmbientLight(), readId(), and readShadowRegs().

{
  byte_t  req[2];
  byte_t  rsp[2];
  int     n = 0;
  int     rc;

  req[n++] = (byte_t)((reg >> 8) & 0xff);
  req[n++] = (byte_t)(reg & 0xff);

  rc = m_mux.transact(m_nChan, VL6180X_ADDR, req, n, rsp, 2, 0);

  if( rc == LAE_OK )
  {
    val = ((u16_t)(rsp[0]) << 8) | (u16_t)rsp[1];
  }
  else
  {
    LOGDIAG3("VL6180 sensor %s(%d): Failed to read register 0x%04x.",
      m_strNameId.c_str(), m_nChan, reg);
  }

  return rc;
}

int LaeVL6180Mux::readReg8	(	u16_t	reg,
		byte_t &	val
	)

Read an 8-bit value from a register.

Parameters

	reg	16-bit register address.
[out]	val	Read value.

Returns

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

Definition at line 1173 of file laeVL6180.cxx.

References m_mux, m_nChan, m_strNameId, laelaps::LaeI2CMux::transact(), and VL6180X_ADDR.

Referenced by calibCrossTalk(), calibOffset(), initSensor(), measureAmbientLight(), measureRange(), readId(), readShadowRegs(), waitForSensorMeasurement(), and waitForSensorReady().

{
  byte_t  req[2];
  int     n = 0;
  int     rc;

  req[n++] = (byte_t)((reg >> 8) & 0xff);
  req[n++] = (byte_t)(reg & 0xff);

  rc = m_mux.transact(m_nChan, VL6180X_ADDR, req, n, &val, 1, 0);

  if( rc != LAE_OK )
  {
    LOGDIAG3("VL6180 sensor %s(%d): Failed to read register 0x%04x.",
      m_strNameId.c_str(), m_nChan, reg);
  }

  return rc;
}

void LaeVL6180Mux::readShadowRegs	(	byte_t &	regRangeOffset,
		u16_t &	regRangeCrossTalk,
		byte_t &	regAlsGain,
		u16_t &	regAlsIntPeriod
	)

Read shadows register values, update derived data, and return registers values.

Parameters

[out]	regRangeOffset	Range part-to-part offset register value
[out]	regRangeCrossTalk	Range cross-talk register value.
[out]	regAlsGain	ALS gain register value.
[out]	regAlsIntPeriod	ALS itegration period register value.

Definition at line 516 of file laeVL6180.cxx.

References m_regAlsGain, m_regAlsIntPeriod, m_regRangeCrossTalk, m_regRangeOffset, and readShadowRegs().

{
  readShadowRegs();

  regRangeOffset    = m_regRangeOffset;
  regRangeCrossTalk = m_regRangeCrossTalk;
  regAlsGain        = m_regAlsGain;
  regAlsIntPeriod   = m_regAlsIntPeriod;
}

int LaeVL6180Mux::tune	(	uint_t	uRangeOffset,
		uint_t	uRangeCrossTalk,
		double	fAlsGain,
		uint_t	uAlsIntPeriod
	)

Tune sensor configuration.

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.
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 379 of file laeVL6180.cxx.

References laelaps::cap(), gainAnalogToEnum(), gainEnumToAnalog(), m_fAlsGain, m_regAlsGain, m_regAlsIntPeriod, m_regRangeCrossTalk, m_regRangeOffset, m_uAlsIntPeriod, VL6180X_AMBIENT_INT_T_MAX, VL6180X_AMBIENT_INT_T_MIN, VL6180X_FACTORY_DFT, VL6180X_RANGE_OFFSET_MAX, VL6180X_RANGE_OFFSET_MIN, VL6180X_RANGE_XTALK_MAX, VL6180X_RANGE_XTALK_MIN, writeReg16(), and writeReg8().

{
  byte_t  regRangeOffset;
  u16_t   regRangeCrossTalk;
  byte_t  regAlsGain;
  u16_t   regAlsIntPeriod;
  int     rc;

  //
  // Convert to new register values.
  //
  if( (int)uRangeOffset == VL6180X_FACTORY_DFT)
  {
    regRangeOffset = m_regRangeOffset;
  }
  else
  {
    regRangeOffset = (byte_t)cap((int)uRangeOffset,
                                  VL6180X_RANGE_OFFSET_MIN,
                                  VL6180X_RANGE_OFFSET_MAX);
  }

  if( (int)uRangeCrossTalk == VL6180X_FACTORY_DFT)
  {
    regRangeCrossTalk = m_regRangeCrossTalk;
  }
  else
  {
    regRangeCrossTalk = (u16_t)cap(uRangeCrossTalk,
                                    (uint_t)VL6180X_RANGE_XTALK_MIN,
                                    (uint_t)VL6180X_RANGE_XTALK_MAX);
  }

  // map analog to register enum, then find exact analog gain value
  regAlsGain = (byte_t)gainAnalogToEnum(fAlsGain);
  fAlsGain   = gainEnumToAnalog((vl6180x_als_gain)regAlsGain);

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

  regAlsIntPeriod = (u16_t)(uAlsIntPeriod - 1);

  //
  // New offset value.
  //
  if( regRangeOffset != m_regRangeOffset )
  {
    rc = writeReg8(VL6180X_SYSRANGE_PART_TO_PART_RANGE_OFFSET, regRangeOffset);
    if( rc == LAE_OK )
    {
      m_regRangeOffset = regRangeOffset;
    }
    else
    {
      LOGDIAG3("Failed to write new range part-to-part "
                "offset register value %u.", regRangeOffset);
    }
  }

  //
  // New cross-talk value.
  //
  if( regRangeCrossTalk != m_regRangeCrossTalk )
  {
    rc = writeReg16(VL6180X_SYSRANGE_CROSSTALK_COMPENSATION_RATE,
                      regRangeCrossTalk);
    if( rc == LAE_OK )
    {
      m_regRangeOffset = regRangeOffset;
    }
    else
    {
      LOGDIAG3("Failed to write new range cross-talk compensation "
                "register value %u.", regRangeCrossTalk);
    }
  }

  //
  // New gain value.
  //
  if( regAlsGain != m_regAlsGain )
  {
    rc = writeReg8(VL6180X_SYSALS_ANALOGUE_GAIN, (byte_t)(0x40|regAlsGain));
    if( rc == LAE_OK )
    {
      m_fAlsGain   = fAlsGain;
      m_regAlsGain = regAlsGain;
    }
    else
    {
      LOGDIAG3("Failed to write new ALS gain register value %u.", regAlsGain);
    }
  }

  //
  // New integration period value.
  //
  if( regAlsIntPeriod != m_regAlsIntPeriod )
  {
    rc = writeReg16(VL6180X_SYSALS_INTEGRATION_PERIOD, regAlsIntPeriod);
    if( rc == LAE_OK )
    {
      m_uAlsIntPeriod   = uAlsIntPeriod;
      m_regAlsIntPeriod = regAlsIntPeriod;
    }
    else
    {
      LOGDIAG3("Failed to write new ALS integration period register value %u.",
          regAlsIntPeriod);
    }
  }

  // always return success for now
  return LAE_OK;
}

void sensor::vl6180::LaeVL6180Mux::unlock ( )

inlineprotected

Unlock the shared resource.

Context:

Any.

Definition at line 729 of file laeVL6180.h.

Referenced by measureAmbientLight(), measureRange(), readId(), and readShadowRegs().

      {
        pthread_mutex_unlock(&m_mutex);
      }

u32_t LaeVL6180Mux::waitForSensorMeasurement ( u32_t  msecWait, byte_t  bitDone  )

protected

Wait for sensor measurement to complete.

Parameters

msecWait	Maximum time to wait for the measurement to complete (milliseconds).
bitDone	Bit to check for measurement completion.

Returns

Returns the number of milliseconds waited. A value > msecWait indicates a timeout.

Definition at line 844 of file laeVL6180.cxx.

References readReg8().

Referenced by measureAmbientLight(), and measureRange().

{
  static byte_t clearInterrupts = 0x07;   // clear all interrupts

  byte_t  val;
  u32_t   msec;

  //
  // Wait for sensor device to become available.
  //
  for(msec = 0; msec <= msecWait; ++msec)
  {
    if( readReg8(VL6180X_RESULT_INTERRUPT_STATUS_GPIO, val) == LAE_OK )
    {
      // sensor not busy
      if( val & bitDone )
      {
      //  writeReg8(VL6180X_SYSTEM_INTERRUPT_CLEAR, clearInterrupts);
        return msec;
      }

      // sleep 1 msec == 1000 usec
      else
      {
        usleep(1000);
      }
    }
  }

  //fprintf(stderr, "DBG: status_gpio=0x%02x\n", val);
 
  return msec;
}

u32_t LaeVL6180Mux::waitForSensorReady ( u16_t  regStatus, u32_t  msecWait  )

protected

Wait for sensor to be ready.

Parameters

regStatus	Status register to check.
msecWait	Maximum time to wait for the measurement to complete (milliseconds).

Returns

Returns the number of milliseconds waited. A value > msecWait indicates a timeout.

Definition at line 816 of file laeVL6180.cxx.

References readReg8().

Referenced by measureAmbientLight(), and measureRange().

{
  static byte_t statusReady = 0x01; // device and sensor is ready bit

  byte_t  val;
  u32_t   msec;

  //
  // Wait for sensor device to become available.
  //
  for(msec = 0; msec <= msecWait; ++msec)
  {
    // sensor not busy
    if( (readReg8(regStatus, val) == LAE_OK) && (val & statusReady) )
    {
      return msec;
    }

    // sleep 1 msec == 1000 usec
    else
    {
      usleep(1000);
    }
  }

  return msec;
}

int LaeVL6180Mux::writeDefaults

(

)

Write defaults to sensor.

The defaults provide reasonable operation within the Laelaps envirionment.

Returns

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

Definition at line 328 of file laeVL6180.cxx.

References m_regAlsGain, m_regAlsIntPeriod, writeReg16(), and writeReg8().

Referenced by initSensor().

{
  // Recommended settings from datasheet
  // http://www.st.com/st-web-ui/static/active/en/resource/technical/document/application_note/DM00122600.pdf

  // Disable interrupts.
  //writeReg8(VL6180X_SYSTEM_INTERRUPT_CONFIG_GPIO, 0);
  // Set GPIO1 high when sample complete
  writeReg8(VL6180X_SYSTEM_INTERRUPT_CONFIG_GPIO, (4 << 3)|(4));

  // Set GPIO1 high when sample complete. N/A since interrupts are disabled.
  writeReg8(VL6180X_SYSTEM_MODE_GPIO1, 0x10);

  // Set the readout averaging sample period.
  // RDK: Possible TUNE parameter.
  writeReg8(VL6180X_READOUT_AVERAGING_SAMPLE_PERIOD, 48);

  // Set the ALS analog gain.
  writeReg8(VL6180X_SYSALS_ANALOGUE_GAIN, (byte_t)(0x40 | m_regAlsGain));

  // Set auto calibration period (Max = 255)/(OFF = 0).
  writeReg8(VL6180X_SYSRANGE_VHV_REPEAT_RATE, 0xFF);

  // Perform a single temperature calibration
  writeReg8(VL6180X_SYSRANGE_VHV_RECALIBRATE, 0x01);

  // Set ALS integration time in msec.
  writeReg16(VL6180X_SYSALS_INTEGRATION_PERIOD, m_regAlsIntPeriod);

  // Optional settings from datasheet
  // http://www.st.com/st-web-ui/static/active/en/resource/technical/document/application_note/DM00122600.pdf
 
  // Set default ranging inter-measurement period to 100ms.
  // RDK: Used in interleaved mode which may be the optimal mode.
  writeReg8(VL6180X_SYSRANGE_INTERMEASUREMENT_PERIOD, 0x09);

  // Set default ALS inter-measurement period to 100ms.
  // RDK: Used in interleaved mode which may be the optimal mode.
  writeReg8(VL6180X_SYSALS_INTERMEASUREMENT_PERIOD, 0x0A);

  // Additional settings defaults from community
  // RDK Investigate
  writeReg8(VL6180X_SYSRANGE_MAX_CONVERGENCE_TIME, 0x32);
  writeReg8(VL6180X_SYSRANGE_RANGE_CHECK_ENABLES, 0x10 | 0x01);
  writeReg16(VL6180X_SYSRANGE_EARLY_CONVERGENCE_ESTIMATE, 0x7B );

  writeReg8(VL6180X_SYSRANGE_RANGE_IGNORE_VALID_HEIGHT, 255);

  writeReg8(VL6180X_FIRMWARE_RESULT_SCALER, 0x01);
}

int LaeVL6180Mux::writeReg16	(	u16_t	reg,
		u16_t	val
	)

Write a 16-bit value to a register.

Parameters

	reg	16-bit register address.
[in]	val	Write value.

Returns

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

Definition at line 1243 of file laeVL6180.cxx.

References m_mux, m_nChan, m_strNameId, VL6180X_ADDR, and laelaps::LaeI2CMux::write().

Referenced by calibCrossTalk(), tune(), and writeDefaults().

{
  byte_t  req[4];
  int     n = 0;
  int     k;
  int     rc;

  req[n++] = (byte_t)((reg >> 8) & 0xff);
  req[n++] = (byte_t)(reg & 0xff);
  req[n++] = (byte_t)((val >> 8) & 0xff);
  req[n++] = (byte_t)(val & 0xff);

  if( (k = m_mux.write(m_nChan, VL6180X_ADDR, req, n)) == n )
  {
    rc = LAE_OK;
  }
  else
  {
    LOGDIAG3("VL6180 sensor %s(%d): Failed to write register 0x%04x.",
      m_strNameId.c_str(), m_nChan, reg);
    rc = -LAE_ECODE_IO;
  }

  return rc;
}

int LaeVL6180Mux::writeReg8	(	u16_t	reg,
		byte_t	val
	)

Write an 8-bit value to a register.

Parameters

	reg	16-bit register address.
[in]	val	Write value.

Returns

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

Definition at line 1218 of file laeVL6180.cxx.

References m_mux, m_nChan, m_strNameId, VL6180X_ADDR, and laelaps::LaeI2CMux::write().

Referenced by calibOffset(), measureAmbientLight(), measureRange(), outOfResetInit(), tune(), and writeDefaults().

{
  byte_t  req[3];
  int     n = 0;
  int     k;
  int     rc;

  req[n++] = (byte_t)((reg >> 8) & 0xff);
  req[n++] = (byte_t)(reg & 0xff);
  req[n++] = val;

  if( (k = m_mux.write(m_nChan, VL6180X_ADDR, req, n)) == n )
  {
    rc = LAE_OK;
  }
  else
  {
    LOGDIAG3("VL6180 sensor %s(%d): Failed to write register 0x%04x.",
      m_strNameId.c_str(), m_nChan, reg);
    rc = -LAE_ECODE_IO;
  }

  return rc;
}

Member Data Documentation

const int sensor::vl6180::LaeVL6180Mux::NSenseErrorsThreshold = 10

static

Consecutive sensed error count threshold.

The sensor will be black listed if errors exceed this threshold.

Definition at line 376 of file laeVL6180.h.

Referenced by measureAmbientLight(), and measureRange().

---

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

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