AMiRo-OS

/*

AMiRo-OS is an operating system designed for the Autonomous Mini Robot (AMiRo) platform.

Copyright (C) 2016..2019  Thomas Schöpping et al.

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#include <amiroos.h>

#include <ut_alld_VL53L0X_v1.h>

#if ((AMIROOS_CFG_TESTS_ENABLE == true) && defined(AMIROLLD_CFG_VL53L0X) && (AMIROLLD_CFG_VL53L0X == 1)) || defined(__DOXYGEN__)

/******************************************************************************/

/* LOCAL DEFINITIONS                                                          */

/******************************************************************************/

#define INTERRUPT_EVENT_ID            1

/******************************************************************************/

/* EXPORTED VARIABLES                                                         */

/******************************************************************************/

/******************************************************************************/

/* LOCAL TYPES                                                                */

/******************************************************************************/

/******************************************************************************/

/* LOCAL VARIABLES                                                            */

/******************************************************************************/

/******************************************************************************/

/* LOCAL FUNCTIONS                                                            */

/******************************************************************************/

/******************************************************************************/

/* EXPORTED FUNCTIONS                                                         */

/******************************************************************************/

/**

 * @brief utAlldVL53L0XFunc

 * @param stream

 * @param ut

 * @return

 *

 *

 * debug:

 *  chprintf(stream, "timeout %lu\n", MyDevice.timeout); or chprintf((BaseSequentialStream*)&SD1, "%s: %d\n", __FILE__, __LINE__);

 *  aosThdMSleep(100);

 *

 *

 */

aos_utresult_t utAlldVL53L0XFunc(BaseSequentialStream* stream, aos_unittest_t* ut)

{

  // Check if the different things are here from the module.c

  aosDbgCheck((ut->data != NULL) &&

                (((ut_vl53l0xdata_t*)(ut->data))->vl53d != NULL) && (((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.i2cd != NULL);

  // local variables

  aos_utresult_t result = {0, 0};

  uint32_t status = APAL_STATUS_OK;

  uint8_t reg_buf[4] = {0,0,0,0};

  uint8_t* reg_8 = (uint8_t*)(reg_buf);

  uint16_t* reg_16 = (uint16_t*)(reg_buf);

  event_listener_t event_listener;

  aos_timestamp_t tcurrent, tend;

  VL53L0X_DeviceModes deviceMode;

  VL53L0X_GpioFunctionality pFunctionality;

  VL53L0X_InterruptPolarity pPolarity;

  uint8_t pMeasurementDataReady=0;

  VL53L0X_RangingMeasurementData_t    RangingMeasurementData;

  VL53L0X_RangingMeasurementData_t   *pRangingMeasurementData    = &RangingMeasurementData;

  uint32_t ThresholdLow;

  uint32_t ThresholdHigh;

  uint8_t buffer[24];

  memset(buffer, 0xAA, sizeof(buffer));

  chprintf(stream, "validate I2C bus...\n");

  // check I2C communication after fresh reset, without API loaded (before VL53L0X_DataInit() is called)

  //validate I2C bus on 0xC0 0xEE

  status = VL53L0X_read_multi((((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.i2cd, (apalI2Caddr_t)(((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.I2cDevAddr , 0xc0, &reg_8[0], 1, (((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.timeout );

  if ((status == APAL_STATUS_OK || status == APAL_STATUS_WARNING) && reg_8[0]==0xEE) {

    aosUtPassed(stream, &result);

  } else {

    aosUtFailedMsg(stream, &result, "0x%08X; 0x%08X\n", status, reg_8[0]);

  }

  //validate I2C bus on 0xC1 0xAA

  status = VL53L0X_read_multi((((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.i2cd, (apalI2Caddr_t)(((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.I2cDevAddr , 0xc1, &reg_8[0], 1, (((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.timeout );

  if ((status == APAL_STATUS_OK || status == APAL_STATUS_WARNING) && reg_8[0]==0xAA) {

    aosUtPassed(stream, &result);

  } else {

    aosUtFailedMsg(stream, &result, "0x%08X; 0x%08X\n", status, reg_8[0]);

  }

  //validate I2C bus on 0xC2 0x10

  status = VL53L0X_read_multi((((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.i2cd, (apalI2Caddr_t)(((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.I2cDevAddr , 0xc2, &reg_8[0], 1, (((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.timeout );

  if ((status == APAL_STATUS_OK || status == APAL_STATUS_WARNING) && reg_8[0]==0x10) {

    aosUtPassed(stream, &result);

  } else {

    aosUtFailedMsg(stream, &result, "0x%08X; 0x%08X\n", status, reg_8[0]);

  }

  //validate I2C bus on  0x51 0x0099

  status = VL53L0X_read_multi((((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.i2cd, (apalI2Caddr_t)(((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.I2cDevAddr , 0x51, &reg_8[0], 2, (((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.timeout );

  if ((status == APAL_STATUS_OK || status == APAL_STATUS_WARNING) && reg_8[0]==0x00 && reg_8[1]==0x99) {

    aosUtPassed(stream, &result);

  } else {

    aosUtFailedMsg(stream, &result, "0x%08X; 0x%08X\n", status, reg_8[0]);

  }

  //validate I2C bus on  0x61 0x0000

  status = VL53L0X_read_multi((((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.i2cd, (apalI2Caddr_t)(((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.I2cDevAddr , 0x61, &reg_8[0], 2, (((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.timeout );

  if ((status == APAL_STATUS_OK || status == APAL_STATUS_WARNING) && reg_8[0]==0x00 && reg_8[1]==0x00) {

    aosUtPassed(stream, &result);

  } else {

    aosUtFailedMsg(stream, &result, "0x%08X; 0x%08X\n", status, reg_8[0]);

  }

  chprintf(stream, "reading register...\n");

  //read register 0x88 register has status 0x24

  status = VL53L0X_read_multi((((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.i2cd, (apalI2Caddr_t)(((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.I2cDevAddr , 0x88, &reg_8[0], 1, (((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.timeout );

  if ((status == APAL_STATUS_OK || status == APAL_STATUS_WARNING) && reg_8[0]==0x24) {

    aosUtPassed(stream, &result);

  } else {

    aosUtFailedMsg(stream, &result, "0x%08X; 0x%08X\n", status, reg_8[0]);

  }

  chprintf(stream, "writing register...\n");

  //VL53L0X_WrByte(Dev, 0x88, 0x00);

  uint8_t tx_buf = 0x00;

  //status = VL53L0X_write_multi((((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.i2cd, (apalI2Caddr_t)(((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.I2cDevAddr, 0x88, (uint8_t*)&tx_buf, 1 ,(((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.timeout );

  status = VL53L0X_write_byte((((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.i2cd, (apalI2Caddr_t)(((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.I2cDevAddr, 0x88, tx_buf,(((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.timeout );

  if ((status == APAL_STATUS_OK || status == APAL_STATUS_WARNING)) {

    aosUtPassed(stream, &result);

  } else {

    aosUtFailedMsg(stream, &result, "0x%08X; 0x%08X\n", status, reg_8[0]);

  }

  //read register 0x88

  status = VL53L0X_read_multi((((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.i2cd, (apalI2Caddr_t)(((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.I2cDevAddr , 0x88, &reg_8[0], 1, (((ut_vl53l0xdata_t*)(ut->data))->vl53d)->vl53l0x_dev.timeout );

  if ((status == APAL_STATUS_OK || status == APAL_STATUS_WARNING) && reg_8[0]==0x00) {

    aosUtPassed(stream, &result);

  } else {

    aosUtFailedMsg(stream, &result, "0x%08X; 0x%08X\n", status, reg_8[0]);

  }

  chprintf(stream, "init sensor data...\n");

  status = vl53l0x_lld_init(((ut_vl53l0xdata_t*)(ut->data))->vl53d);

  if ((status == APAL_STATUS_OK || status == APAL_STATUS_WARNING)) {

    aosUtPassed(stream, &result);

  } else {

    aosUtFailedMsg(stream, &result, "0x%08X\n", status);

  }

  chprintf(stream, "set single mode...\n");

  status = vl53l0x_lld_set_mode(((ut_vl53l0xdata_t*)(ut->data))->vl53d, VL53L0X_DEVICEMODE_SINGLE_RANGING,

                                VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_DISABLED,0,0);

  status |= VL53L0X_GetDeviceMode(&(((ut_vl53l0xdata_t*)(ut->data))->vl53d->vl53l0x_dev), &deviceMode);

  if ((status == APAL_STATUS_OK || status == APAL_STATUS_WARNING) && deviceMode == VL53L0X_DEVICEMODE_SINGLE_RANGING) {

    aosUtPassed(stream, &result);

  } else {

    aosUtFailedMsg(stream, &result, "0x%08X; %u\n", status, deviceMode);

  }

  chprintf(stream, "reading results...\n");

  status = vl53l0x_lld_perform_mesaurement(((ut_vl53l0xdata_t*)(ut->data))->vl53d, &reg_16[0]);

  chprintf(stream, "\t\tdistance : %u\n", reg_16[0]);

  int i = 0;

  for (i = 0; i<4; i++){

      status |= vl53l0x_lld_perform_mesaurement(((ut_vl53l0xdata_t*)(ut->data))->vl53d, &reg_16[0]);

      chprintf(stream, "\t\tdistance : %u\n", reg_16[0]);

  }

  if ((status == APAL_STATUS_OK || status == APAL_STATUS_WARNING)) {

    aosUtPassed(stream, &result);

  } else {

    aosUtFailedMsg(stream, &result, "0x%08X\n", status);

  }

  chprintf(stream, "setting new address...\n");

  status = vl53l0x_lld_set_address(((ut_vl53l0xdata_t*)(ut->data))->vl53d, 0x49);

  if ((status == APAL_STATUS_OK || status == APAL_STATUS_WARNING)) {

    aosUtPassed(stream, &result);

  } else {

    aosUtFailedMsg(stream, &result, "0x%08X\n", status);

  }

  //-----------------------------------------------------------------------

  chprintf(stream, "reading with interrupt ...\n");

  chprintf(stream, "\tgeneral information: eventmask VL53L0X: %lu and eventflag VL53L0X: %lu \n",

           EVENT_MASK(INTERRUPT_EVENT_ID), ((ut_vl53l0xdata_t*)(ut->data))->evtflags);

  chprintf(stream, "set single mode and interrupt to VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY ...\n");

  status = vl53l0x_lld_set_mode(((ut_vl53l0xdata_t*)(ut->data))->vl53d, VL53L0X_DEVICEMODE_SINGLE_RANGING,

                                VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY,0,0);

  /*

  same as

  status |= VL53L0X_SetDeviceMode(&(((ut_vl53l0xdata_t*)(ut->data))->vl53d->vl53l0x_dev), VL53L0X_DEVICEMODE_SINGLE_RANGING);

  status |= VL53L0X_SetGpioConfig(&(((ut_vl53l0xdata_t*)(ut->data))->vl53d->vl53l0x_dev), 0, VL53L0X_DEVICEMODE_SINGLE_RANGING,

                                 VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY, VL53L0X_INTERRUPTPOLARITY_LOW);

*/

  status |= VL53L0X_GetGpioConfig(&(((ut_vl53l0xdata_t*)(ut->data))->vl53d->vl53l0x_dev), 0, &deviceMode, &pFunctionality, &pPolarity);

  if ((status == APAL_STATUS_OK || status == APAL_STATUS_WARNING) && deviceMode == VL53L0X_DEVICEMODE_SINGLE_RANGING &&

          pFunctionality == VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY && pPolarity == VL53L0X_INTERRUPTPOLARITY_LOW) {

    aosUtPassed(stream, &result);

  } else {

    aosUtFailedMsg(stream, &result, "0x%08X; mode:%u; Interrupt:%u; InterruptPolarity: %u\n", status, deviceMode, pFunctionality, pPolarity);

  }

  chprintf(stream, "check for blocking interrupts...\n");

  status = vl53l0x_lld_CheckRangingDataReady(((ut_vl53l0xdata_t*)(ut->data))->vl53d, &pMeasurementDataReady);

  if ((status == APAL_STATUS_OK || status == APAL_STATUS_WARNING) && pMeasurementDataReady == 0) {

    aosUtPassed(stream, &result);

  } else {

    aosUtFailedMsg(stream, &result, "0x%08X, there are blocking interrupts :%u\n", status, pMeasurementDataReady);

    chprintf(stream, "clear blocking interrupts...\n");

    status = vl53l0x_lld_getRangingData(((ut_vl53l0xdata_t*)(ut->data))->vl53d, pRangingMeasurementData);

    if ((status == APAL_STATUS_OK || status == APAL_STATUS_WARNING)) {

      aosUtPassed(stream, &result);

    } else {

      aosUtFailedMsg(stream, &result, "0x%08X;\n", status);

    }

  }

  chprintf(stream, "start maeasurement ... \n");

  //set everything for eventshandler

  chEvtRegister(((ut_vl53l0xdata_t*)(ut->data))->evtsource, &event_listener, INTERRUPT_EVENT_ID);

  aosSysGetUptime(&tend);

  tend += 2 * MICROSECONDS_PER_SECOND;

  status = vl53l0x_lld_start_measurement(((ut_vl53l0xdata_t*)(ut->data))->vl53d);

  if ((status == APAL_STATUS_OK || status == APAL_STATUS_WARNING)) {

    aosUtPassed(stream, &result);

  } else {

    aosUtFailedMsg(stream, &result, "0x%08X;\n", status);

  }

  do {

    // read proximity data, interrupt event information and interrupt status

    const eventmask_t emask = chEvtWaitOneTimeout(EVENT_MASK(INTERRUPT_EVENT_ID), chTimeUS2I(10*MICROSECONDS_PER_MILLISECOND));

    const eventflags_t eflags = chEvtGetAndClearFlags(&event_listener);

    if (emask == EVENT_MASK(INTERRUPT_EVENT_ID) &&

        eflags == ((ut_vl53l0xdata_t*)(ut->data))->evtflags) {

      // true positive (correct case)

      chprintf(stream, "EVENT\n");

      status |= VL53L0X_GetRangingMeasurementData(&(((ut_vl53l0xdata_t*)(ut->data))->vl53d->vl53l0x_dev), pRangingMeasurementData);

      chprintf(stream, "\t\tinterrupt detected: prox = %i\n", RangingMeasurementData.RangeMilliMeter);

      status |= VL53L0X_ClearInterruptMask(&(((ut_vl53l0xdata_t*)(ut->data))->vl53d->vl53l0x_dev),

                                           VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_LEVEL_HIGH);

    }else if (eflags == ((ut_vl53l0xdata_t*)(ut->data))->evtflags){

        chprintf(stream, "mask: %lu\n", emask);

        chprintf(stream, "flag: %lu\n", eflags);

    }else if (emask == EVENT_MASK(INTERRUPT_EVENT_ID)){

        chprintf(stream, "first::mask: %lu and flag: %lu\n", emask, eflags);

        // read from GPIO

        status |= pcal6524_lld_read_group(((ut_vl53l0xdata_t*)ut->data)->gpio, PCAL6524_LLD_CMD_INPUT_P0, buffer,

                                        ((ut_vl53l0xdata_t*)ut->data)->timeout);

        status |= vl53l0x_lld_CheckRangingDataReady(((ut_vl53l0xdata_t*)(ut->data))->vl53d, &pMeasurementDataReady);

        if ((pMeasurementDataReady == 0x01)) {

            chprintf(stream, "\t\tRead input: 0x%04X 0x%04X 0x%04X\t",

                     (((uint16_t)buffer[0]) << 8) | buffer[1],

                     (((uint16_t)buffer[2]) << 8) | buffer[3],

                     (((uint16_t)buffer[4]) << 8) | buffer[5]);

            //get the measurement from VL53L0X

            status |= vl53l0x_lld_getRangingData(((ut_vl53l0xdata_t*)(ut->data))->vl53d, pRangingMeasurementData);

            chprintf(stream, "distance: %i\n", RangingMeasurementData.RangeMilliMeter);

        }

    }

    aosSysGetUptime(&tcurrent);

  } while (tcurrent < tend);

  if ((status == APAL_STATUS_OK || status == APAL_STATUS_WARNING)) {

    aosUtPassed(stream, &result);

  } else {

    aosUtFailedMsg(stream, &result, "0x%08X; 0x%08X\n", status, pRangingMeasurementData);

  }

  chprintf(stream, "stop maeasurement ... \n");

  status = vl53l0x_lld_stop_measurement(((ut_vl53l0xdata_t*)(ut->data))->vl53d);

  chEvtUnregister(((ut_vl53l0xdata_t*)(ut->data))->evtsource, &event_listener);

  if ((status == APAL_STATUS_OK || status == APAL_STATUS_WARNING)) {

    aosUtPassed(stream, &result);

  } else {

    aosUtFailedMsg(stream, &result, "0x%08X;\n", status);

  }

//-----------------------------------------------------

  chprintf(stream, "set continuous mode and interrupt to VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_OUT_OF_WINDOW (80mm/150mm) ...\n");

  // wand a threshold of 80

  // 100 mm < max Threshold von 254 mm

  ThresholdHigh = 150;

  ThresholdLow = 80;

  status = vl53l0x_lld_set_mode(((ut_vl53l0xdata_t*)(ut->data))->vl53d, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,

                                VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_OUT_OF_WINDOW,ThresholdLow,ThresholdHigh);

  status |= VL53L0X_GetGpioConfig(&(((ut_vl53l0xdata_t*)(ut->data))->vl53d->vl53l0x_dev), 0, &deviceMode, &pFunctionality, &pPolarity);

  status |= VL53L0X_GetInterruptThresholds(&(((ut_vl53l0xdata_t*)(ut->data))->vl53d->vl53l0x_dev),

      VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,

      &ThresholdLow, &ThresholdHigh);

  if ((status == APAL_STATUS_OK || status == APAL_STATUS_WARNING) && deviceMode == VL53L0X_DEVICEMODE_CONTINUOUS_RANGING &&

          pFunctionality == VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_OUT_OF_WINDOW && pPolarity == VL53L0X_INTERRUPTPOLARITY_LOW){

          //&& ThresholdLow == 80 * 65536 && ThresholdHigh == 150 * 65536) { not possible, only strange wrong values, e.g. Threshold low:1431655765;Threshold high:0

    aosUtPassed(stream, &result);

  } else {

    aosUtFailedMsg(stream, &result, "0x%08X; mode:%u; Interrupt:%u; InterruptPolarity:%u; Threshold low:%lu"

                                    ";Threshold high:%lu\n", status, deviceMode, pFunctionality, pPolarity, ThresholdLow/65536.0, ThresholdHigh/65536.0);

  }

  chprintf(stream, "check for blocking interrupts...\n");

  status = vl53l0x_lld_CheckRangingDataReady(((ut_vl53l0xdata_t*)(ut->data))->vl53d, &pMeasurementDataReady);

  if ((status == APAL_STATUS_OK || status == APAL_STATUS_WARNING) && pMeasurementDataReady == 0) {

    aosUtPassed(stream, &result);

  } else {

    aosUtFailedMsg(stream, &result, "0x%08X, there are blocking interrupts :%u\n", status, pMeasurementDataReady);

    chprintf(stream, "clear blocking interrupts...\n");

    status = vl53l0x_lld_getRangingData(((ut_vl53l0xdata_t*)(ut->data))->vl53d, pRangingMeasurementData);

    if ((status == APAL_STATUS_OK || status == APAL_STATUS_WARNING)) {

      aosUtPassed(stream, &result);

    } else {

      aosUtFailedMsg(stream, &result, "0x%08X;\n", status);

    }

  }

  chprintf(stream, "start maeasurement ... \n");

  //set everything for eventshandler

  chEvtRegister(((ut_vl53l0xdata_t*)(ut->data))->evtsource, &event_listener, INTERRUPT_EVENT_ID);

  aosSysGetUptime(&tend);

  tend += 10 * MICROSECONDS_PER_SECOND;

  status = vl53l0x_lld_start_measurement(((ut_vl53l0xdata_t*)(ut->data))->vl53d);

  if ((status == APAL_STATUS_OK || status == APAL_STATUS_WARNING)) {

    aosUtPassed(stream, &result);

  } else {

    aosUtFailedMsg(stream, &result, "0x%08X;\n", status);

  }

  do {

    // read proximity data, interrupt event information and interrupt status

    const eventmask_t emask = chEvtWaitOneTimeout(EVENT_MASK(INTERRUPT_EVENT_ID), chTimeUS2I(10*MICROSECONDS_PER_MILLISECOND));

    const eventflags_t eflags = chEvtGetAndClearFlags(&event_listener);

    if (emask == EVENT_MASK(INTERRUPT_EVENT_ID) &&

        eflags == ((ut_vl53l0xdata_t*)(ut->data))->evtflags) {

      // true positive (correct case)

      chprintf(stream, "EVENT\n");

      status |= VL53L0X_GetRangingMeasurementData(&(((ut_vl53l0xdata_t*)(ut->data))->vl53d->vl53l0x_dev), pRangingMeasurementData);

      chprintf(stream, "\t\tinterrupt detected: prox = %i\n", RangingMeasurementData.RangeMilliMeter);

      status |= VL53L0X_ClearInterruptMask(&(((ut_vl53l0xdata_t*)(ut->data))->vl53d->vl53l0x_dev),0);

    }else if (eflags == ((ut_vl53l0xdata_t*)(ut->data))->evtflags){

        chprintf(stream, "mask: %lu\n", emask);

        chprintf(stream, "flag: %lu\n", eflags);

    }else if (emask == EVENT_MASK(INTERRUPT_EVENT_ID)){

        chprintf(stream, "last::mask: %lu and flag: %lu\n", emask, eflags);

        // read from GPIO

        status |= pcal6524_lld_read_group(((ut_vl53l0xdata_t*)ut->data)->gpio, PCAL6524_LLD_CMD_INPUT_P0, buffer,

                                        ((ut_vl53l0xdata_t*)ut->data)->timeout);

        status |= vl53l0x_lld_CheckRangingDataReady(((ut_vl53l0xdata_t*)(ut->data))->vl53d, &pMeasurementDataReady);

        if ((pMeasurementDataReady == 0x01)) {

            chprintf(stream, "\t\tRead input: 0x%04X 0x%04X 0x%04X\t",

                     (((uint16_t)buffer[0]) << 8) | buffer[1],

                     (((uint16_t)buffer[2]) << 8) | buffer[3],

                     (((uint16_t)buffer[4]) << 8) | buffer[5]);

            //get the measurement from VL53L0X

            status |= vl53l0x_lld_getRangingData(((ut_vl53l0xdata_t*)(ut->data))->vl53d, pRangingMeasurementData);

            chprintf(stream, "distance: %i\n", RangingMeasurementData.RangeMilliMeter);

        }

    }

    aosSysGetUptime(&tcurrent);

  } while (tcurrent < tend);

  if ((status == APAL_STATUS_OK || status == APAL_STATUS_WARNING)) {

    aosUtPassed(stream, &result);

  } else {

    aosUtFailedMsg(stream, &result, "0x%08X; 0x%08X\n", status, pRangingMeasurementData);

  }

  chprintf(stream, "stop maeasurement ... \n");

  status = vl53l0x_lld_stop_measurement(((ut_vl53l0xdata_t*)(ut->data))->vl53d);

  chEvtUnregister(((ut_vl53l0xdata_t*)(ut->data))->evtsource, &event_listener);

  if ((status == APAL_STATUS_OK || status == APAL_STATUS_WARNING)) {

    aosUtPassed(stream, &result);

  } else {

    aosUtFailedMsg(stream, &result, "0x%08X;\n", status);

  }

  chprintf(stream, "setting default address...\n");

  status = vl53l0x_lld_set_address(((ut_vl53l0xdata_t*)(ut->data))->vl53d, 0x29);

  aosUtInfoMsg(stream, "driver object memory footprint: %u bytes\n", sizeof(VL53L0XDriver));

  return result;

}

#endif /* (AMIROOS_CFG_TESTS_ENABLE == true) && defined(AMIROLLD_CFG_VL53L0X) && (AMIROLLD_CFG_VL53L0X == 1) */