From 55b315f6b070b7a1f62d21adf982a16e740ece2f Mon Sep 17 00:00:00 2001 From: Gunar Schorcht Date: Sun, 12 Dec 2021 13:49:01 +0100 Subject: [PATCH 01/18] drivers/vl53l1x: add driver for ST VL53L1X sensor --- drivers/Makefile.dep | 4 + drivers/include/vl53l1x.h | 597 + drivers/vl53l1x/Makefile | 1 + drivers/vl53l1x/Makefile.dep | 15 + drivers/vl53l1x/Makefile.include | 7 + drivers/vl53l1x/include/vl53l1x_params.h | 153 + .../vl53l1x/include/vl53l1x_register_map.h | 11881 ++++++++++++++++ drivers/vl53l1x/include/vl53l1x_regs.h | 52 + drivers/vl53l1x/vl53l1x.c | 1316 ++ 9 files changed, 14026 insertions(+) create mode 100644 drivers/include/vl53l1x.h create mode 100644 drivers/vl53l1x/Makefile create mode 100644 drivers/vl53l1x/Makefile.dep create mode 100644 drivers/vl53l1x/Makefile.include create mode 100644 drivers/vl53l1x/include/vl53l1x_params.h create mode 100644 drivers/vl53l1x/include/vl53l1x_register_map.h create mode 100644 drivers/vl53l1x/include/vl53l1x_regs.h create mode 100644 drivers/vl53l1x/vl53l1x.c diff --git a/drivers/Makefile.dep b/drivers/Makefile.dep index 57ada70bd3e9..4cc59c810187 100644 --- a/drivers/Makefile.dep +++ b/drivers/Makefile.dep @@ -237,6 +237,10 @@ ifneq (,$(filter vcnl40%0,$(USEMODULE))) USEMODULE += vcnl40x0 endif +ifneq (,$(filter vl53l1x_%,$(USEMODULE))) + USEMODULE += vl53l1x +endif + ifneq (,$(filter vl6180x_%,$(USEMODULE))) USEMODULE += vl6180x endif diff --git a/drivers/include/vl53l1x.h b/drivers/include/vl53l1x.h new file mode 100644 index 000000000000..226573b9a752 --- /dev/null +++ b/drivers/include/vl53l1x.h @@ -0,0 +1,597 @@ +/* + * Copyright (C) 2021 Gunar Schorcht + * + * This file is subject to the terms and conditions of the GNU Lesser + * General Public License v2.1. See the file LICENSE in the top level + * directory for more details. + */ + +/** + * @defgroup drivers_vl53l1x VL53L1X Time-of-Flight (ToF) ranging sensor + * @ingroup drivers_sensors + * @ingroup drivers_saul + * @brief Device driver for the ST VL53L1X Time-of-Flight (ToF) ranging sensor + * + * \section drivers_vl53l1x VL53L1X Time-of-Flight (ToF) ranging sensor + * + * ## Driver Variants + * + * Using the according module, the driver can be used in different variants + * which differ in functionality and size: + * + * Module Name | Driver | Short Description + * :-------------------|:----------------------|:---------------------------- + * \ref vl53l1x_std | Standard driver | Common functionality and medium size + * \ref vl53l1x_st_api | ST VL53L1X API driver | Complete functionality and large size + * \ref vl53l1x_basic | Basic driver | Minimum functionality and small size + * + * All driver variants provide @ref drivers_saul capabilities for distance. + * + * ## ST VL53L1X API driver (vl53l1x_st_api) {#vl53l1x_st_api} + * + * This variant of the driver uses ST STSW-IMG007 VL53L1X Full API as package. + * In this case, the driver is simply a wrapper for the API which provides a + * driver interface that is compatible with other driver variants. + * + * Using vl53l1x_st_api variant provides the application with the functionality + * of other driver variants. Additionally, it provides access to the complete + * functionality of the sensor by using API functions directly. This is for + * example necessary to + * + * - to configure and use threshold interrupts, or + * - to calibrate the sensor. + * + * Even though the sensor is calibrated by ST during the final module test and + * these calibration data are loaded from NVM, the sensor should be calibrated + * on customers production line when soldered on customer board or adding a + * cover glass. + * + * Please refer the [VL53L1X API user manual] + * (https://www.st.com/resource/en/user_manual/dm00474730.pdf) for detailed + * information on how to use the API to calibrate the sensor. + * + * @note Since the ST STSW-IMG007 VL53L1X API package is quite complex and + * very large, this driver variant should only be used when memory + * requirements are not an issue. + * + * ## Standard driver (vl53l1x_std) {#vl53l1x_std} + * + * This driver variant is a compromise of size and functionality. It provides + * the application with most functionality of the sensor. The driver can be + * used when memory requirements are important and most of the functionality + * should be used. + * + * Since the sensor loads its calibration data from NVM during boot, this + * driver variant gives results with same accuracy as with module + * \ref vl53l1x_st_api once the calibration of the sensor is done on customers + * production line with module \ref vl53l1x_st_api. + * + * ## Basic driver (vl53l1x_basic) {#vl53l1x_basic} + * + * This is the smallest driver variant that only provides some basic functions + * such as + * + * - the distance measurements and + * - the data-ready interrupt + * + * at acceptable accuracy. This driver should be used when memory requirements + * are an issue. + * + * ## Driver Comparison Sheet + * + * Function / Property | vl53l1x_basic | vl53l1x | vl53l1x_st_api + * :--------------------------------------|:------:|:----:|:--------------: + * Distance results in mm | X | X | X + * Signal rate results in MCPS | | X | X + * Measurement status information | | X | X + * SAUL capability | X | X | X + * Distance mode configuration | | X | X + * Timing budget configuration | | X | X + * Inter-measurement period configuration | | X | X + * Region of Interest (ROI) configuration | | X | X + * Data-ready interrupts | X | X | X + * Threshold interrupts | | | X + * Calibration functions | | | X [1] + * Limit check configuration | | | X [1] + * Accuracy | medium | high | high + * Size on reference platform in kByte | 1.3 | 4.2 | 27.9 + * + * [1] These functions are available by using the ST VL53L1X API directly. + * + * @{ + * + * @author Gunar Schorcht + * @file + */ + +#ifndef VL53L1X_H +#define VL53L1X_H + +#ifdef __cplusplus +extern "C" +{ +#endif + +#include +#include + +#include "kernel_defines.h" +#include "periph/gpio.h" +#include "periph/i2c.h" + +#if IS_USED(MODULE_VL53L1X_ST_API) + +#include "vl53l1_api.h" + +/* to be able to use also VL53L1_ instead of VL53L1X_ for consistency */ +#define VL53L1X_ VL53L1_ +#define vl53l1x_ vl53l1_ +/* platform specific error codes are starting at VL53L1X_ERROR_BASE */ +#define VL53L1X_ERROR_BASE VL53L1_ERROR_PLATFORM_SPECIFIC_START + +#else /* IS_USED(MODULE_VL53L1X_ST_API) */ + +#define VL53L1X_ERROR_BASE (0) /**< base value of driver error codes */ + +#define VL53L1X_RANGESTATUS_RANGE_VALID 0 /**< range is valid */ +#define VL53L1X_RANGESTATUS_SIGMA_FAIL 1 /**< sigma failure */ +#define VL53L1X_RANGESTATUS_SIGNAL_FAIL 2 /**< signal failure */ +#define VL53L1X_RANGESTATUS_RANGE_VALID_MIN_RANGE_CLIPPED 3 /**< target is below minimum + detection threshold */ +#define VL53L1X_RANGESTATUS_OUTOFBOUNDS_FAIL 4 /**< phase out of valid limits, + different to a wrap exit. */ +#define VL53L1X_RANGESTATUS_HARDWARE_FAIL 5 /**< hardware failure */ +#define VL53L1X_RANGESTATUS_RANGE_VALID_NO_WRAP_CHECK_FAIL 6 /**< range is valid but the wrap + around check has not been + done */ +#define VL53L1X_RANGESTATUS_WRAP_TARGET_FAIL 7 /**< wrapped target, no matching + phase in other VCSEL period + timing */ +#define VL53L1X_RANGESTATUS_XTALK_SIGNAL_FAIL 9 /**< specific to lite ranging */ +#define VL53L1X_RANGESTATUS_SYNCRONISATION_INT 10 /**< first interrupt when starting + ranging in back to back mode */ +#define VL53L1X_RANGESTATUS_MIN_RANGE_FAIL 13 /**< user ROI input is not valid */ +#define VL53L1X_RANGESTATUS_NONE 255 /**< No Update. */ + +#define VL53L1_DISTANCEMODE_SHORT 1 /**< distances up to 1.3 m */ +#define VL53L1_DISTANCEMODE_MEDIUM 2 /**< distances up to 2 m */ +#define VL53L1_DISTANCEMODE_LONG 3 /**< distances up to 4 m */ + +#endif /* IS_USED(MODULE_VL53L1X_ST_API) */ + +/** + * @name Definition of error codes + * @{ + */ +#define VL53L1X_OK (0) /**< success */ +#define VL53L1X_ERROR_I2C (VL53L1X_ERROR_BASE - 1) /**< I2C communication error */ +#define VL53L1X_ERROR_WRONG_ID (VL53L1X_ERROR_BASE - 2) /**< wrong id read */ +#define VL53L1X_ERROR_NO_DATA (VL53L1X_ERROR_BASE - 3) /**< no data available */ +#define VL53L1X_ERROR_RAW_DATA (VL53L1X_ERROR_BASE - 4) /**< read raw data failed */ +#define VL53L1X_ERROR_NO_PIN (VL53L1X_ERROR_BASE - 5) /**< pin not defined */ +#define VL53L1X_ERROR_TIMEOUT (VL53L1X_ERROR_BASE - 6) /**< timeout happened */ +#define VL53L1X_ERROR_INV_ARG (VL53L1X_ERROR_BASE - 7) /**< invalid argument */ +#define VL53L1X_ERROR_INV_PARAM (VL53L1X_ERROR_BASE - 8) /**< invalid params */ +/** @} */ + +#if !IS_USED(MODULE_VL53L1X_BASIC) || DOXYGEN +/** + * @brief VL53L1X distance modes + * + * The values are reused from the ST VL53L1X API for compatibility. + * + * @note Distance mode CANNOT be configured when module \ref vl53l1x_basic + * is enabled. + */ +typedef enum { + VL53L1X_DIST_SHORT = VL53L1_DISTANCEMODE_SHORT, /**< up to 1.3 m */ + VL53L1X_DIST_MEDIUM = VL53L1_DISTANCEMODE_MEDIUM, /**< up to 2 m */ + VL53L1X_DIST_LONG = VL53L1_DISTANCEMODE_LONG, /**< up to 4 m */ +} vl53l1x_dist_mode_t; +#endif /* !IS_USED(MODULE_VL53L1X_BASIC) */ + +#if IS_USED(MODULE_VL53L1X_ST_API) || DOXYGEN +/** + * @brief Threshold modes used for threshold interrupts + * + * For distances and signal rates, upper and lower thresholds can be defined, + * with the upper and lower thresholds defining a threshold window. These + * thresholds can be used to trigger threshold interrupts. + * + * #vl53l1x_thresh_mode_t is used by interrupt configuration to define the + * conditions under which an threshold interrupt will be triggered. + * + * @note Threshold interrupts are ONLY available when module + * \ref vl53l1x_st_api is enabled. Otherwise only data-ready + * interrupts can be used. + */ +typedef enum { + VL53L1X_THRESH_HIGH = 0, /**< only when the value exceeds the upper + threshold */ + VL53L1X_THRESH_LOW = 1, /**< only when the value falls below the lower + threshold */ + VL53L1X_THRESH_OUT = 2, /**< when the value exceeds the upper threshold or + falls below the lower threshold (the value + leaves the threshold window) */ + VL53L1X_THRESH_IN = 3, /**< when value exceeds the lower threshold or + falls below the higher threshold (the value + enters the threshold window) */ +} vl53l1x_thresh_mode_t; + +/** + * @brief Interrupt mode + * + * It defines when an interrupt is triggered. Interrupts can be triggered + * either on new data in each measurement cycly or when the threshold condition + * defined by the vl53l1x_thresh_mode_t is fulfilled. + * + * @note The interrupt mode can be configured ONLY if \ref vl53l1x_st_api + * is enabled. Otherwise only data-ready interrupts can be used. + */ +typedef enum { + VL53L1X_INT_DATA_READY = 0, /**< on new data in each measurement cycle */ + VL53L1X_INT_DIST = 1, /**< on distance threshold condition */ + VL53L1X_INT_RATE = 2, /**< on signal rate threshold condition */ + VL53L1X_INT_DIST_OR_RATE = 3, /**< on distance or signal rate threshold condition */ + VL53L1X_INT_DIST_AND_RATE = 4, /**< on distance and signal rate threshold condition */ +} vl53l1x_int_mode_t; +#endif /* IS_USED(MODULE_VL53L1X_ST_API) || DOXYGEN */ + +/** + * @brief Interrupt configuration + * + * @note Interrupts can be configured only if \ref vl53l1x_st_api + * is enabled. Otherwise only data-ready interrupts can be used. + */ +typedef struct { +#if IS_USED(MODULE_VL53L1X_ST_API) || DOXYGEN + vl53l1x_int_mode_t mode; /**< defines when interrupts are triggered */ + + vl53l1x_thresh_mode_t dist_mode; /**< threshold mode for distance */ + uint16_t dist_high; /**< upper threshold for distance in mm */ + uint16_t dist_low; /**< lower threshold for distance in mm */ + + vl53l1x_thresh_mode_t rate_mode; /**< threshold mode for signal rates */ + uint32_t rate_high; /**< upper threshold for signal rate + as fixed point 16.16 */ + uint32_t rate_low; /**< lower threshold for signal rate + as fixed point 16.16 */ +#endif /* IS_USED(MODULE_VL53L1X_ST_API) || DOXYGEN */ +} vl53l1x_int_config_t; + +/** + * @brief VL53L1X device initialization parameters + */ +typedef struct { + + unsigned i2c_dev; /**< I2C device, default I2C_DEV(0) */ + bool vddio_2v8; /**< if true, I/O voltage is 2.8 V, otherwise 1.8 V */ + + gpio_t pin_int; /**< Interrupt pin open drain, active low: + #GPIO_UNDEF if not used */ +#if !IS_USED(MODULE_VL53L1X_BASIC) + gpio_t pin_shutdown;/**< Shutdown pin low active: + #GPIO_UNDEF if not used */ + uint32_t budget; /**< Timing budget given to the sensor to perform range + measurements in us [20000 ... 1000000], + default: 50 ms */ + uint32_t period; /**< Inter-measurement period in ms, has to be + vl53l1x_params_t::t_budget + 4ms, + default: 100 ms */ + vl53l1x_dist_mode_t mode; /**< Distance mode, default: VL53L1X_DIST_LONG */ +#endif /* !IS_USED(MODULE_VL53L1X_BASIC) */ + +} vl53l1x_params_t; + +/** + * @brief VL53L1X sensor device data structure type + */ +typedef struct { +#if IS_USED(MODULE_VL53L1X_ST_API) + VL53L1_Dev_t dev; /**< ST VL53L1 API device structure, must be the first + member for compatibility with ST VL53L1 API. The + driver device structure is just an extension. */ +#elif !IS_USED(MODULE_VL53L1X_BASIC) + bool calibrated; /**< Device is already calibrated */ + uint16_t fast_osc_frequency; /**< Fast OSC Frequency in fixed point 4.12 format */ + uint16_t osc_calibrate_val; /**< OSC calibration value */ +#endif + + vl53l1x_params_t params; /**< Device initialization parameters */ + bool int_init; /**< Interrupt pin is already initialized */ + +} vl53l1x_t; + +/** + * @brief VL53L1X ranging data + * + * Please refer the [VL53L1X API user manual] + * (https://www.st.com/resource/en/user_manual/dm00474730.pdf) + * section 2.6 for detailed information about the meaning of ranging data + * values. + */ +typedef struct { + uint16_t distance; /**< distance in millimeter */ + uint8_t status; /**< status for the current measurement */ + uint32_t signal_rate; /**< signal rate in MCPS as fixed point 16.16 */ + uint32_t ambient_rate; /**< ambient rate in MCPS as fixed point 16.16 */ +} vl53l1x_data_t; + +#if !IS_USED(MODULE_VL53L1X_BASIC) +/** + * @brief VL53L1X region of interest (ROI) + * + * Defines the region of interest (ROI) within the 16 x 16 SPAD (single photon + * avalanche diode) array. The ROI is a square or rectangle defined by two + * corners: top left and bottom right. + */ +typedef struct{ + uint8_t x_tl; /**< ROI top left x coordinate [0...15] (default 0) */ + uint8_t y_tl; /**< ROI top left y coordinate [0...15] (default 15) */ + uint8_t x_br; /**< ROI bottom right x coordinate [0...15] (default 15) */ + uint8_t y_br; /**< ROI bottom right x coordinate [0...15] (default 0) */ +} vl53l1x_roi_t; +#endif /* !IS_USED(MODULE_VL53L1X_BASIC) */ + +/** + * @brief Initialize the VL53L1X sensor device + * + * @param[in] dev device descriptor of VL53L1X sensor to be initialized + * @param[in] params configuration parameters, see #vl53l1x_params_t + * + * @retval VL53L1X_OK on success + * @retval VL53L1X_ERROR_* a negative error code on error + */ +int vl53l1x_init(vl53l1x_t *dev, const vl53l1x_params_t *params); + +/** + * @brief Data-ready status function + * + * The function can be used for polling to know when new ranging data are ready. + * + * @param[in] dev device descriptor of VL53L1X sensor + * + * @retval VL53L1X_OK new ranging data are ready + * @retval VL53L1X_ERROR_NO_DATA no new ranging data available + * @retval VL53L1X_ERROR_* negative error code + */ +int vl53l1x_data_ready(vl53l1x_t *dev); + +/** + * @brief Read one ranging data sample in mm + * + * This function returns only the ranging data in millimeters. + * + * @note Since reading any data resets the interrupt as well as the + * data-ready flag, either function #vl53l1x_read_mm, function + * #vl53l1x_read_data, or function #vl53l1x_read_details can be + * used in one measurement cycle. + * + * @param[in] dev device descriptor of VL53L1X sensor + * @param[out] mm ranging data in mm + * + * @retval VL53L1X_OK on success + * @retval VL53L1X_ERROR_* negative error code + */ +int vl53l1x_read_mm(vl53l1x_t *dev, int16_t *mm); + +#if !IS_USED(MODULE_VL53L1X_BASIC) +/** + * @brief Read one ranging data sample with status and signal information + * + * This function returns the ranging data distance together with additional + * information about the measurement like the status and the signals. + * + * Please refer the [VL53L1X API user manual] + * (https://www.st.com/resource/en/user_manual/dm00474730.pdf) + * section 2.6 for detailed information about the meaning of ranging data + * values. + * + * @note + * - Since reading any data resets the interrupt as well as the data-ready + * flag, either function #vl53l1x_read_mm, function #vl53l1x_read_data, or + * function #vl53l1x_read_details can be used in one measurement cycle. + * - This function is NOT available when module \ref vl53l1x_basic is used. + * + * @param[in] dev device descriptor of VL53L1X sensor + * @param[out] data ranging data + * + * @retval VL53L1X_OK on success + * @retval VL53L1X_ERROR_* negative error code + */ +int vl53l1x_read_data(vl53l1x_t *dev, vl53l1x_data_t *data); + +#endif /* !IS_USED(MODULE_VL53L1X_BASIC) */ + +#if IS_USED(MODULE_VL53L1X_ST_API) || DOXYGEN +/** + * @brief Read one ranging data sample with detailed information + * + * This function can only be used with module \ref vl53l1x_st_api and the + * ST STSW-IMG007 VL53L1X API to get detailed information about the measurement. + * + * Please refer the [VL53L1X API user manual] + * (https://www.st.com/resource/en/user_manual/dm00474730.pdf) + * section 2.6 for detailed information about the meaning of detailed + * ranging data. + * + * @note + * - Since reading any data resets the interrupt as well as the data-ready + * flag, either function #vl53l1x_read_mm, function #vl53l1x_read_data, or + * function #vl53l1x_read_details can be used in one measurement cycle. + * - This function is ONLY available when module \ref vl53l1x_basic is used. + * + * @param[in] dev device descriptor of VL53L1X sensor + * @param[out] details ranging data + * + * @retval VL53L1X_OK on success + * @retval VL53L1X_ERROR_* negative error code + */ +int vl53l1x_read_details(vl53l1x_t *dev, + VL53L1_RangingMeasurementData_t *details); + +#endif /* IS_USED(MODULE_VL53L1X_ST_API) || DOXYGEN */ + +#if !IS_USED(MODULE_VL53L1X_BASIC) +/** + * @brief Power down the sensor + * + * This function requires that a GPIO connected to sensor's /XSHUT pin is + * defined by parameter vl53l1x_params_t::pin_shutdown. + * + * @note This function is NOT available when module \ref vl53l1x_basic + * is used. + * + * @param[in] dev device descriptor of VL53L1X sensor + * + * @retval VL53L1X_OK on success + * @retval VL53L1X_ERROR_* negative error code + */ +int vl53l1x_power_down(const vl53l1x_t *dev); + +/** + * @brief Power down the sensor + * + * This function requires that a GPIO connected to sensor's /XSHUT pin is + * defined by parameter vl53l1x_params_t::pin_shutdown. + * + * @note This function is NOT available when module \ref vl53l1x_basic + * is used. + * + * @param[in] dev device descriptor of VL53L1X sensor + * + * @retval VL53L1X_OK on success + * @retval VL53L1X_ERROR_* negative error code + */ +int vl53l1x_power_up(vl53l1x_t *dev); + +/** + * @brief Change the timing budget in microseconds + * + * This function can be used to change the timing budget that was defined + * by configuration parameter vl53l1x_params_t::budget during sensor + * initialization. + * + * @note This function is NOT available when module \ref vl53l1x_basic + * is used. + * + * @param[in] dev device descriptor of VL53L1X sensor + * @param[in] budget_us new timing budget in us + * + * @retval VL53L1X_OK on success + * @retval VL53L1X_ERROR_* negative error code + */ +int vl53l1x_set_timing_budget(vl53l1x_t *dev, uint32_t budget_us); + +/** + * @brief Change the inter-measurement period im ms + * + * This function can be used to change the the inter-measurement period that was + * defined by configuration parameter vl53l1x_params_t::period during sensor + * initialization. + * + * @pre The inter-measurement period MUST be longer than the timing budget + * + 4 ms. Otherwise the function fails. Therefore, if the time + * budget is also changed, it should be done first. + * + * @note This function is NOT available when module \ref vl53l1x_basic + * is used. + * + * @param[in] dev device descriptor of VL53L1X sensor + * @param[in] period_ms new measurement period in ms + * + * @retval VL53L1X_OK on success + * @retval VL53L1X_ERROR_* negative error code + */ +int vl53l1x_set_measurement_period(vl53l1x_t *dev, uint32_t period_ms); + +/** + * @brief Change the distance mode + * + * This function can be used to change the the distance mode that was + * defined by configuration parameter vl53l1x_params_t::mode during sensor + * initialization. + * + * @note This function is NOT available when module \ref vl53l1x_basic + * is used. + * + * @param[in] dev device descriptor of VL53L1X sensor + * @param[in] mode new distance mode, see #vl53l1x_dist_mode_t + * + * @retval VL53L1X_OK on success + * @retval VL53L1X_ERROR_* negative error code + */ +int vl53l1x_set_distance_mode(vl53l1x_t *dev, vl53l1x_dist_mode_t mode); + +/** + * @brief Set the region of interest (ROI) + * + * Using this function, the region of interest (ROI) within the 16 x 16 SPAD + * (single photon avalanche diode) array can be defined. + * + * @note This function is NOT available when module \ref vl53l1x_basic + * is used. + * + * @param[in] dev device descriptor of VL53L1X sensor + * @param[in] roi new region of interest, see #vl53l1x_roi_t + * + * @retval VL53L1X_OK on success + * @retval VL53L1X_ERROR_* negative error code + */ +int vl53l1x_set_roi(vl53l1x_t *dev, vl53l1x_roi_t *roi); + +/** + * @brief Get the region of interest (ROI) + * + * @note This function is NOT available when module \ref vl53l1x_basic + * is used. + * + * @param[in] dev device descriptor of VL53L1X sensor + * @param[out] roi region of interest, see #vl53l1x_roi_t + * + * @retval VL53L1X_OK on success + * @retval VL53L1X_ERROR_* negative error code + */ +int vl53l1x_get_roi(vl53l1x_t *dev, vl53l1x_roi_t *roi); + +#endif /* IS_USED(MODULE_VL53L1X_BASIC) */ + +/** + * @brief Configure interrupts + * + * The function + * + * - configures the interrupts of the sensor + * - initializes the GPIO defined by vl53l1x_params_t::pin_int, and + * - attaches the ISR specified by the @p isr parameter to the interrupt. + * + * @warning Since the ISR is executed in the interrupt context, it must not be + * blocking or time consuming. In addition, it must not access the + * sensor directly via I2C. It should only indicate to a waiting + * thread that an interrupt has occurred, which is then handled + * in the thread context. + * If it is tried to access the sensor in interrupt context, an + * assertion blows up (if assertions are enabled). + * + * @note The interrupt configuration for threshold interrupts is ONLY + * used when module \ref vl53l1x_st_api is enabled. Otherwise, only + * data-ready interrupts are used independent on the configuration given + * by parameter \p cfg. In later case, parameter \p cfg can be NULL. + * + * @param[in] dev device descriptor of VL53L1X sensor + * @param[in] cfg interrupt configuration, see #vl53l1x_int_config_t + * @param[in] isr ISR called for all types of interrupts + * @param[in] isr_arg ISR argument, can be NULL + * + * @retval VL53L1X_OK on success + * @retval VL53L1X_ERROR_* negative error code on error + */ +int vl53l1x_int_config(vl53l1x_t *dev, vl53l1x_int_config_t* cfg, + void (*isr)(void *), + void *isr_arg); +#ifdef __cplusplus +} +#endif + +#endif /* VL53L1X_H */ +/** @} */ diff --git a/drivers/vl53l1x/Makefile b/drivers/vl53l1x/Makefile new file mode 100644 index 000000000000..48422e909a47 --- /dev/null +++ b/drivers/vl53l1x/Makefile @@ -0,0 +1 @@ +include $(RIOTBASE)/Makefile.base diff --git a/drivers/vl53l1x/Makefile.dep b/drivers/vl53l1x/Makefile.dep new file mode 100644 index 000000000000..82b6e7dc0a26 --- /dev/null +++ b/drivers/vl53l1x/Makefile.dep @@ -0,0 +1,15 @@ +ifneq (,$(filter vl53l1x_st_api,$(USEMODULE))) + USEMODULE += driver_vl53l1x_st_api_platform + USEPKG += driver_vl53l1x_st_api +endif + +ifeq (,$(filter vl53l1x_%,$(USEMODULE))) + USEMODULE += vl53l1x_std +endif + +ifneq (,$(filter vl53l1x,$(USEMODULE))) + FEATURES_REQUIRED += periph_gpio_irq + FEATURES_REQUIRED += periph_gpio + FEATURES_REQUIRED += periph_i2c + USEMODULE += ztimer_msec +endif diff --git a/drivers/vl53l1x/Makefile.include b/drivers/vl53l1x/Makefile.include new file mode 100644 index 000000000000..4ff527a2d74a --- /dev/null +++ b/drivers/vl53l1x/Makefile.include @@ -0,0 +1,7 @@ +# include variants of VL53L1X drivers as pseudo modules +PSEUDOMODULES += vl53l1x_basic +PSEUDOMODULES += vl53l1x_st_api +PSEUDOMODULES += vl53l1x_std + +USEMODULE_INCLUDES_vl53l1x := $(LAST_MAKEFILEDIR)/include +USEMODULE_INCLUDES += $(USEMODULE_INCLUDES_vl53l1x) diff --git a/drivers/vl53l1x/include/vl53l1x_params.h b/drivers/vl53l1x/include/vl53l1x_params.h new file mode 100644 index 000000000000..a8c36f777c71 --- /dev/null +++ b/drivers/vl53l1x/include/vl53l1x_params.h @@ -0,0 +1,153 @@ +/* + * Copyright (C) 2021 Gunar Schorcht + * + * This file is subject to the terms and conditions of the GNU Lesser + * General Public License v2.1. See the file LICENSE in the top level + * directory for more details. + */ + +/** + * @ingroup drivers_vl53l1x + * @brief Default configuration for ST VL53L1X Time-of-Flight (ToF) ranging sensor + * @author Gunar Schorcht + * @file + * @{ + */ + +#ifndef VL53L1X_PARAMS_H +#define VL53L1X_PARAMS_H + +#include "board.h" +#include "saul_reg.h" +#include "vl53l1x.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @name Default hardware configuration parameters + * @{ + */ + +/** + * @brief Default device is I2C_DEV(0) + */ +#ifndef VL53L1X_PARAM_DEV +#define VL53L1X_PARAM_DEV I2C_DEV(0) +#endif + +/** + * @brief Default I2C VDDIO voltage: 2.8 V + */ +#ifndef VL53L1X_PARAM_VDDIO_2V8 +#define VL53L1X_PARAM_VDDIO_2V8 (true) +#endif + +/** + * @brief Default interrupt pin: not used + */ +#ifndef VL53L1X_PARAM_PIN_INT +#define VL53L1X_PARAM_PIN_INT (GPIO_UNDEF) +#endif + +/** + * @brief Default shutdown pin: not used + */ +#ifndef VL53L1X_PARAM_PIN_SHUTDOWN +#define VL53L1X_PARAM_PIN_SHUTDOWN (GPIO_UNDEF) +#endif +/** @} */ + +/** + * @name Default sensor configuration parameters + * @{ + */ + +#if !DOXYGEN + +/* Mapping of Kconfig defines to the respective driver enumeration values */ +#ifdef CONFIG_VL53L1X_DIST_SHORT +#define CONFIG_VL53L1X_PARAM_DISTANCE_MODE (VL53L1X_DIST_SHORT) +#elif CONFIG_VL53L1X_DIST_MEDIUM +#define CONFIG_VL53L1X_PARAM_DISTANCE_MODE (VL53L1X_DIST_MEDIUM) +#elif CONFIG_VL53L1X_DIST_LONG +#define CONFIG_VL53L1X_PARAM_DISTANCE_MODE (VL53L1X_DIST_LONG) +#endif + +#endif /* !DOXYGEN */ + +/** + * @brief Default inter-measurement period [ms]: 100 ms + */ +#ifndef CONFIG_VL53L1X_PARAM_PERIOD +#define CONFIG_VL53L1X_PARAM_PERIOD (100) +#endif + +/** + * @brief Default Timing budget [us]: 50 ms + */ +#ifndef CONFIG_VL53L1X_PARAM_TIMING_BUDGET +#define CONFIG_VL53L1X_PARAM_TIMING_BUDGET (50000) +#endif + +/** + * @brief Default distance mode: long + */ +#ifndef CONFIG_VL53L1X_PARAM_DISTANCE_MODE +#define CONFIG_VL53L1X_PARAM_DISTANCE_MODE (VL53L1X_DIST_LONG) +#endif +/**@}*/ + +/** + * @brief Default VL53L1X configuration parameter set + */ +#ifndef VL53L1X_PARAMS +#if !IS_USED(MODULE_VL53L1X_BASIC) +#define VL53L1X_PARAMS { \ + .i2c_dev = VL53L1X_PARAM_DEV, \ + .vddio_2v8 = VL53L1X_PARAM_VDDIO_2V8, \ + .pin_int = VL53L1X_PARAM_PIN_INT, \ + .pin_shutdown = VL53L1X_PARAM_PIN_SHUTDOWN, \ + .budget = CONFIG_VL53L1X_PARAM_TIMING_BUDGET, \ + .period = CONFIG_VL53L1X_PARAM_PERIOD, \ + .mode = CONFIG_VL53L1X_PARAM_DISTANCE_MODE, \ + } +#else /* !IS_USED(MODULE_VL53L1X_BASIC) */ +#define VL53L1X_PARAMS { \ + .i2c_dev = VL53L1X_PARAM_DEV, \ + .vddio_2v8 = VL53L1X_PARAM_VDDIO_2V8, \ + .pin_int = VL53L1X_PARAM_PIN_INT, \ + } +#endif /* !IS_USED(MODULE_VL53L1X_BASIC) */ +#endif /* VL53L1X_PARAMS */ + +/** + * @brief Default SAUL device information + */ +#ifndef VL53L1X_SAUL_INFO +#define VL53L1X_SAUL_INFO { .name = "vl53l1x" } +#endif + +/** + * @brief Allocate some memory to store the default configuration + */ +static const vl53l1x_params_t vl53l1x_params[] = +{ + VL53L1X_PARAMS +}; + +/** + * @brief Additional meta information to keep in the SAUL registry + */ +static const saul_reg_info_t vl53l1x_saul_info[] = +{ + VL53L1X_SAUL_INFO +}; + +#ifdef __cplusplus +} +#endif + +#endif /* VL53L1X_PARAMS_H */ +/** @} */ diff --git a/drivers/vl53l1x/include/vl53l1x_register_map.h b/drivers/vl53l1x/include/vl53l1x_register_map.h new file mode 100644 index 000000000000..08a8a2352f73 --- /dev/null +++ b/drivers/vl53l1x/include/vl53l1x_register_map.h @@ -0,0 +1,11881 @@ +/* + * Copyright (c) 2017, STMicroelectronics - All Rights Reserved + * + ******************************************************************************** + * + * License terms: BSD 3-clause "New" or "Revised" License. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * + ******************************************************************************** + * + */ + +/** + * @file vl53l1x_register_map.h + * @brief VL53L1X Register Map definitions + */ + +#ifndef VL53L1X_REGISTER_MAP_H +#define VL53L1X_REGISTER_MAP_H + +#ifndef DOXYGEN + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @defgroup VL53L1X_register_DefineRegisters_group Define Registers + * @brief List of all the defined registers + * @{ + */ + +#define VL53L1X_SOFT_RESET 0x0000 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_I2C_SLAVE__DEVICE_ADDRESS 0x0001 +/*!< + type: uint8_t \n + default: EWOK_I2C_DEV_ADDR_DEFAULT \n + info: \n + - msb = 6 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_nvm_managed', 'system_config'] + + fields: \n + - [6:0] = i2c_slave_device_address +*/ +#define VL53L1X_ANA_CONFIG__VHV_REF_SEL_VDDPIX 0x0002 +/*!< + type: uint8_t \n + default: 0x02 \n + info: \n + - msb = 3 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_nvm_managed', 'analog_config'] + + fields: \n + - [3:0] = ref_sel_vddpix +*/ +#define VL53L1X_ANA_CONFIG__VHV_REF_SEL_VQUENCH 0x0003 +/*!< + type: uint8_t \n + default: 0x10 \n + info: \n + - msb = 6 + - lsb = 3 + - i2c_size = 1 + + groups: \n + ['static_nvm_managed', 'analog_config'] + + fields: \n + - [6:3] = ref_sel_vquench +*/ +#define VL53L1X_ANA_CONFIG__REG_AVDD1V2_SEL 0x0004 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 1 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_nvm_managed', 'analog_config'] + + fields: \n + - [1:0] = reg_avdd1v2_sel +*/ +#define VL53L1X_ANA_CONFIG__FAST_OSC__TRIM 0x0005 +/*!< + type: uint8_t \n + default: 0x48 \n + info: \n + - msb = 6 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_nvm_managed', 'analog_config'] + + fields: \n + - [6:0] = fast_osc_trim +*/ +#define VL53L1X_OSC_MEASURED__FAST_OSC__FREQUENCY 0x0006 +/*!< + type: uint16_t \n + default: OSC_FREQUENCY \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['static_nvm_managed', 'analog_config'] + + fields: \n + - [15:0] = osc_frequency (fixed point 4.12) +*/ +#define VL53L1X_OSC_MEASURED__FAST_OSC__FREQUENCY_HI 0x0006 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_OSC_MEASURED__FAST_OSC__FREQUENCY_LO 0x0007 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_VHV_CONFIG__TIMEOUT_MACROP_LOOP_BOUND 0x0008 +/*!< + type: uint8_t \n + default: 0x81 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_nvm_managed', 'vhv_config'] + + fields: \n + - [1:0] = vhv_timeout__macrop + - [7:2] = vhv_loop_bound +*/ +#define VL53L1X_VHV_CONFIG__COUNT_THRESH 0x0009 +/*!< + type: uint8_t \n + default: 0x80 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_nvm_managed', 'vhv_config'] + + fields: \n + - [7:0] = vhv_count_thresh +*/ +#define VL53L1X_VHV_CONFIG__OFFSET 0x000A +/*!< + type: uint8_t \n + default: 0x07 \n + info: \n + - msb = 5 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_nvm_managed', 'vhv_config'] + + fields: \n + - [5:0] = vhv_step_val +*/ +#define VL53L1X_VHV_CONFIG__INIT 0x000B +/*!< + type: uint8_t \n + default: 0x20 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_nvm_managed', 'vhv_config'] + + fields: \n + - [7] = vhv0_init_enable + - [5:0] = vhv0_init_value +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_REF_0 0x000D +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['customer_nvm_managed', 'ref_spad_en'] + + fields: \n + - [7:0] = spad_enables_ref_0 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_REF_1 0x000E +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['customer_nvm_managed', 'ref_spad_en'] + + fields: \n + - [7:0] = spad_enables_ref_1 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_REF_2 0x000F +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['customer_nvm_managed', 'ref_spad_en'] + + fields: \n + - [7:0] = spad_enables_ref_2 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_REF_3 0x0010 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['customer_nvm_managed', 'ref_spad_en'] + + fields: \n + - [7:0] = spad_enables_ref_3 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_REF_4 0x0011 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['customer_nvm_managed', 'ref_spad_en'] + + fields: \n + - [7:0] = spad_enables_ref_4 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_REF_5 0x0012 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 3 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['customer_nvm_managed', 'ref_spad_en'] + + fields: \n + - [3:0] = spad_enables_ref_5 +*/ +#define VL53L1X_GLOBAL_CONFIG__REF_EN_START_SELECT 0x0013 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['customer_nvm_managed', 'ref_spad_start'] + + fields: \n + - [7:0] = ref_en_start_select +*/ +#define VL53L1X_REF_SPAD_MAN__NUM_REQUESTED_REF_SPADS 0x0014 +/*!< + type: uint8_t \n + default: 0x2C \n + info: \n + - msb = 5 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['customer_nvm_managed', 'ref_spad_config'] + + fields: \n + - [5:0] = ref_spad_man__num_requested_ref_spad +*/ +#define VL53L1X_REF_SPAD_MAN__REF_LOCATION 0x0015 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 1 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['customer_nvm_managed', 'ref_spad_config'] + + fields: \n + - [1:0] = ref_spad_man__ref_location +*/ +#define VL53L1X_ALGO__CROSSTALK_COMPENSATION_PLANE_OFFSET_KCPS 0x0016 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['customer_nvm_managed', 'algo_config'] + + fields: \n + - [15:0] = crosstalk_compensation_plane_offset_kcps (fixed point 7.9) +*/ +#define VL53L1X_ALGO__CROSSTALK_COMPENSATION_PLANE_OFFSET_KCPS_HI 0x0016 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_ALGO__CROSSTALK_COMPENSATION_PLANE_OFFSET_KCPS_LO 0x0017 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_ALGO__CROSSTALK_COMPENSATION_X_PLANE_GRADIENT_KCPS 0x0018 +/*!< + type: int16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['customer_nvm_managed', 'algo_config'] + + fields: \n + - [15:0] = crosstalk_compensation_x_plane_gradient_kcps (fixed point 5.11) +*/ +#define VL53L1X_ALGO__CROSSTALK_COMPENSATION_X_PLANE_GRADIENT_KCPS_HI 0x0018 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_ALGO__CROSSTALK_COMPENSATION_X_PLANE_GRADIENT_KCPS_LO 0x0019 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_ALGO__CROSSTALK_COMPENSATION_Y_PLANE_GRADIENT_KCPS 0x001A +/*!< + type: int16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['customer_nvm_managed', 'algo_config'] + + fields: \n + - [15:0] = crosstalk_compensation_y_plane_gradient_kcps (fixed point 5.11) +*/ +#define VL53L1X_ALGO__CROSSTALK_COMPENSATION_Y_PLANE_GRADIENT_KCPS_HI 0x001A +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_ALGO__CROSSTALK_COMPENSATION_Y_PLANE_GRADIENT_KCPS_LO 0x001B +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_REF_SPAD_CHAR__TOTAL_RATE_TARGET_MCPS 0x001C +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['customer_nvm_managed', 'ref_spad_char'] + + fields: \n + - [15:0] = ref_spad_char__total_rate_target_mcps (fixed point 9.7) +*/ +#define VL53L1X_REF_SPAD_CHAR__TOTAL_RATE_TARGET_MCPS_HI 0x001C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_REF_SPAD_CHAR__TOTAL_RATE_TARGET_MCPS_LO 0x001D +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_ALGO__PART_TO_PART_RANGE_OFFSET_MM 0x001E +/*!< + type: int16_t \n + default: 0x0000 \n + info: \n + - msb = 12 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['customer_nvm_managed', 'algo_config'] + + fields: \n + - [12:0] = part_to_part_offset_mm (fixed point 11.2) +*/ +#define VL53L1X_ALGO__PART_TO_PART_RANGE_OFFSET_MM_HI 0x001E +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_ALGO__PART_TO_PART_RANGE_OFFSET_MM_LO 0x001F +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MM_CONFIG__INNER_OFFSET_MM 0x0020 +/*!< + type: int16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['customer_nvm_managed', 'mm_config'] + + fields: \n + - [15:0] = mm_config__inner_offset_mm +*/ +#define VL53L1X_MM_CONFIG__INNER_OFFSET_MM_HI 0x0020 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MM_CONFIG__INNER_OFFSET_MM_LO 0x0021 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MM_CONFIG__OUTER_OFFSET_MM 0x0022 +/*!< + type: int16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['customer_nvm_managed', 'mm_config'] + + fields: \n + - [15:0] = mm_config__outer_offset_mm +*/ +#define VL53L1X_MM_CONFIG__OUTER_OFFSET_MM_HI 0x0022 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MM_CONFIG__OUTER_OFFSET_MM_LO 0x0023 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_DSS_CONFIG__TARGET_TOTAL_RATE_MCPS 0x0024 +/*!< + type: uint16_t \n + default: 0x0380 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['static_config', 'dss_config'] + + fields: \n + - [15:0] = dss_config__target_total_rate_mcps (fixed point 9.7) +*/ +#define VL53L1X_DSS_CONFIG__TARGET_TOTAL_RATE_MCPS_HI 0x0024 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_DSS_CONFIG__TARGET_TOTAL_RATE_MCPS_LO 0x0025 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_DEBUG__CTRL 0x0026 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'debug_config'] + + fields: \n + - [0] = enable_result_logging +*/ +#define VL53L1X_TEST_MODE__CTRL 0x0027 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 3 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'test_mode_config'] + + fields: \n + - [3:0] = test_mode__cmd +*/ +#define VL53L1X_CLK_GATING__CTRL 0x0028 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 3 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'clk_config'] + + fields: \n + - [0] = clk_gate_en__mcu_bank + - [1] = clk_gate_en__mcu_patch_ctrl + - [2] = clk_gate_en__mcu_timers + - [3] = clk_gate_en__mcu_mult_div +*/ +#define VL53L1X_NVM_BIST__CTRL 0x0029 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 4 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'nvm_bist_config'] + + fields: \n + - [2:0] = nvm_bist__cmd + - [4] = nvm_bist__ctrl +*/ +#define VL53L1X_NVM_BIST__NUM_NVM_WORDS 0x002A +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 6 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'nvm_bist_config'] + + fields: \n + - [6:0] = nvm_bist__num_nvm_words +*/ +#define VL53L1X_NVM_BIST__START_ADDRESS 0x002B +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 6 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'nvm_bist_config'] + + fields: \n + - [6:0] = nvm_bist__start_address +*/ +#define VL53L1X_HOST_IF__STATUS 0x002C +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'system_status'] + + fields: \n + - [0] = host_interface +*/ +#define VL53L1X_PAD_I2C_HV__CONFIG 0x002D +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'gpio_config'] + + fields: \n + - [0] = pad_scl_sda__vmodeint_hv + - [1] = i2c_pad__test_hv + - [2] = pad_scl__fpen_hv + - [4:3] = pad_scl__progdel_hv + - [5] = pad_sda__fpen_hv + - [7:6] = pad_sda__progdel_hv +*/ +#define VL53L1X_PAD_I2C_HV__EXTSUP_CONFIG 0x002E +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'gpio_config'] + + fields: \n + - [0] = pad_scl_sda__extsup_hv +*/ +#define VL53L1X_GPIO_HV_PAD__CTRL 0x002F +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 1 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'gpio_config'] + + fields: \n + - [0] = gpio__extsup_hv + - [1] = gpio__vmodeint_hv +*/ +#define VL53L1X_GPIO_HV_MUX__CTRL 0x0030 +/*!< + type: uint8_t \n + default: 0x11 \n + info: \n + - msb = 4 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'gpio_config'] + + fields: \n + - [3:0] = gpio__mux_select_hv + - [4] = gpio__mux_active_high_hv +*/ +#define VL53L1X_GPIO__TIO_HV_STATUS 0x0031 +/*!< + type: uint8_t \n + default: 0x02 \n + info: \n + - msb = 1 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'gpio_config'] + + fields: \n + - [0] = gpio__tio_hv + - [1] = fresh_out_of_reset +*/ +#define VL53L1X_GPIO__FIO_HV_STATUS 0x0032 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 1 + - lsb = 1 + - i2c_size = 1 + + groups: \n + ['static_config', 'gpio_config'] + + fields: \n + - [1] = gpio__fio_hv +*/ +#define VL53L1X_ANA_CONFIG__SPAD_SEL_PSWIDTH 0x0033 +/*!< + type: uint8_t \n + default: 0x02 \n + info: \n + - msb = 2 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'analog_config'] + + fields: \n + - [2:0] = spad_sel_pswidth +*/ +#define VL53L1X_ANA_CONFIG__VCSEL_PULSE_WIDTH_OFFSET 0x0034 +/*!< + type: uint8_t \n + default: 0x08 \n + info: \n + - msb = 4 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'analog_config'] + + fields: \n + - [4:0] = vcsel_pulse_width_offset (fixed point 1.4) +*/ +#define VL53L1X_ANA_CONFIG__FAST_OSC__CONFIG_CTRL 0x0035 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'analog_config'] + + fields: \n + - [0] = osc_config__latch_bypass +*/ +#define VL53L1X_SIGMA_ESTIMATOR__EFFECTIVE_PULSE_WIDTH_NS 0x0036 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'algo_config'] + + fields: \n + - [7:0] = sigma_estimator__eff_pulse_width +*/ +#define VL53L1X_SIGMA_ESTIMATOR__EFFECTIVE_AMBIENT_WIDTH_NS 0x0037 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'algo_config'] + + fields: \n + - [7:0] = sigma_estimator__eff_ambient_width +*/ +#define VL53L1X_SIGMA_ESTIMATOR__SIGMA_REF_MM 0x0038 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'algo_config'] + + fields: \n + - [7:0] = sigma_estimator__sigma_ref +*/ +#define VL53L1X_ALGO__CROSSTALK_COMPENSATION_VALID_HEIGHT_MM 0x0039 +/*!< + type: uint8_t \n + default: 0x14 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'algo_config'] + + fields: \n + - [7:0] = crosstalk_compensation_valid_height_mm +*/ +#define VL53L1X_SPARE_HOST_CONFIG__STATIC_CONFIG_SPARE_0 0x003A +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'algo_config'] + + fields: \n + - [7:0] = static_config_spare_0 +*/ +#define VL53L1X_SPARE_HOST_CONFIG__STATIC_CONFIG_SPARE_1 0x003B +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'algo_config'] + + fields: \n + - [7:0] = static_config_spare_1 +*/ +#define VL53L1X_ALGO__RANGE_IGNORE_THRESHOLD_MCPS 0x003C +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['static_config', 'algo_config'] + + fields: \n + - [15:0] = range_ignore_thresh_mcps (fixed point 3.13) +*/ +#define VL53L1X_ALGO__RANGE_IGNORE_THRESHOLD_MCPS_HI 0x003C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_ALGO__RANGE_IGNORE_THRESHOLD_MCPS_LO 0x003D +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_ALGO__RANGE_IGNORE_VALID_HEIGHT_MM 0x003E +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'algo_config'] + + fields: \n + - [7:0] = range_ignore_height_mm +*/ +#define VL53L1X_ALGO__RANGE_MIN_CLIP 0x003F +/*!< + type: uint8_t \n + default: 0x8D \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'algo_config'] + + fields: \n + - [0] = algo__range_min_clip_enable + - [7:1] = algo__range_min_clip_value_mm +*/ +#define VL53L1X_ALGO__CONSISTENCY_CHECK__TOLERANCE 0x0040 +/*!< + type: uint8_t \n + default: 0x08 \n + info: \n + - msb = 3 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'algo_config'] + + fields: \n + - [3:0] = consistency_check_tolerance (fixed point 1.3) +*/ +#define VL53L1X_SPARE_HOST_CONFIG__STATIC_CONFIG_SPARE_2 0x0041 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'algo_config'] + + fields: \n + - [7:0] = static_config_spare_2 +*/ +#define VL53L1X_SD_CONFIG__RESET_STAGES_MSB 0x0042 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 3 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'sigmadelta_config'] + + fields: \n + - [3:0] = loop_init__clear_stage +*/ +#define VL53L1X_SD_CONFIG__RESET_STAGES_LSB 0x0043 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['static_config', 'sigmadelta_config'] + + fields: \n + - [7:4] = accum_reset__clear_stage + - [3:0] = count_reset__clear_stage +*/ +#define VL53L1X_GPH_CONFIG__STREAM_COUNT_UPDATE_VALUE 0x0044 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['general_config', 'roi_config'] + + fields: \n + - [7:0] = stream_count_update_value +*/ +#define VL53L1X_GLOBAL_CONFIG__STREAM_DIVIDER 0x0045 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['general_config', 'roi_config'] + + fields: \n + - [7:0] = stream_count_internal_div +*/ +#define VL53L1X_SYSTEM__INTERRUPT_CONFIG_GPIO 0x0046 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['general_config', 'gph_config'] + + fields: \n + - [1:0] = int_mode_distance + - [3:2] = int_mode_rate + - [4] = int_spare + - [5] = int_new_measure_ready + - [6] = int_no_target_en + - [7] = int_combined_mode +*/ +#define VL53L1X_CAL_CONFIG__VCSEL_START 0x0047 +/*!< + type: uint8_t \n + default: 0x0B \n + info: \n + - msb = 6 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['general_config', 'cal_config'] + + fields: \n + - [6:0] = cal_config__vcsel_start +*/ +#define VL53L1X_CAL_CONFIG__REPEAT_RATE 0x0048 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 11 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['general_config', 'cal_config'] + + fields: \n + - [11:0] = cal_config__repeat_rate +*/ +#define VL53L1X_CAL_CONFIG__REPEAT_RATE_HI 0x0048 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_CAL_CONFIG__REPEAT_RATE_LO 0x0049 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_GLOBAL_CONFIG__VCSEL_WIDTH 0x004A +/*!< + type: uint8_t \n + default: 0x02 \n + info: \n + - msb = 6 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['general_config', 'global_config'] + + fields: \n + - [6:0] = global_config__vcsel_width +*/ +#define VL53L1X_PHASECAL_CONFIG__TIMEOUT_MACROP 0x004B +/*!< + type: uint8_t \n + default: 0x04 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['general_config', 'phasecal_config'] + + fields: \n + - [7:0] = phasecal_config__timeout_macrop +*/ +#define VL53L1X_PHASECAL_CONFIG__TARGET 0x004C +/*!< + type: uint8_t \n + default: 0x21 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['general_config', 'phasecal_config'] + + fields: \n + - [7:0] = algo_phasecal_lim +*/ +#define VL53L1X_PHASECAL_CONFIG__OVERRIDE 0x004D +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['general_config', 'phasecal_config'] + + fields: \n + - [0] = phasecal_config__override +*/ +#define VL53L1X_DSS_CONFIG__ROI_MODE_CONTROL 0x004F +/*!< + type: uint8_t \n + default: 0x01 \n + info: \n + - msb = 2 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['general_config', 'dss_config'] + + fields: \n + - [1:0] = dss_config__input_mode + - [2] = calculate_roi_enable +*/ +#define VL53L1X_SYSTEM__THRESH_RATE_HIGH 0x0050 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['general_config', 'gph_config'] + + fields: \n + - [15:0] = thresh_rate_high (fixed point 9.7) +*/ +#define VL53L1X_SYSTEM__THRESH_RATE_HIGH_HI 0x0050 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SYSTEM__THRESH_RATE_HIGH_LO 0x0051 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SYSTEM__THRESH_RATE_LOW 0x0052 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['general_config', 'gph_config'] + + fields: \n + - [15:0] = thresh_rate_low (fixed point 9.7) +*/ +#define VL53L1X_SYSTEM__THRESH_RATE_LOW_HI 0x0052 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SYSTEM__THRESH_RATE_LOW_LO 0x0053 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_DSS_CONFIG__MANUAL_EFFECTIVE_SPADS_SELECT 0x0054 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['general_config', 'dss_config'] + + fields: \n + - [15:0] = dss_config__manual_effective_spads_select +*/ +#define VL53L1X_DSS_CONFIG__MANUAL_EFFECTIVE_SPADS_SELECT_HI 0x0054 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_DSS_CONFIG__MANUAL_EFFECTIVE_SPADS_SELECT_LO 0x0055 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_DSS_CONFIG__MANUAL_BLOCK_SELECT 0x0056 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['general_config', 'dss_config'] + + fields: \n + - [7:0] = dss_config__manual_block_select +*/ +#define VL53L1X_DSS_CONFIG__APERTURE_ATTENUATION 0x0057 +/*!< + type: uint8_t \n + default: 0x33 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['general_config', 'dss_config'] + + fields: \n + - [7:0] = dss_config__aperture_attenuation +*/ +#define VL53L1X_DSS_CONFIG__MAX_SPADS_LIMIT 0x0058 +/*!< + type: uint8_t \n + default: 0xFF \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['general_config', 'dss_config'] + + fields: \n + - [7:0] = dss_config__max_spads_limit +*/ +#define VL53L1X_DSS_CONFIG__MIN_SPADS_LIMIT 0x0059 +/*!< + type: uint8_t \n + default: 0x01 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['general_config', 'dss_config'] + + fields: \n + - [7:0] = dss_config__min_spads_limit +*/ +#define VL53L1X_MM_CONFIG__TIMEOUT_MACROP_A_HI 0x005A +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 3 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['timing_config', 'mm_config'] + + fields: \n + - [3:0] = mm_config__config_timeout_macrop_a_hi +*/ +#define VL53L1X_MM_CONFIG__TIMEOUT_MACROP_A_LO 0x005B +/*!< + type: uint8_t \n + default: 0x06 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['timing_config', 'mm_config'] + + fields: \n + - [7:0] = mm_config__config_timeout_macrop_a_lo +*/ +#define VL53L1X_MM_CONFIG__TIMEOUT_MACROP_B_HI 0x005C +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 3 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['timing_config', 'mm_config'] + + fields: \n + - [3:0] = mm_config__config_timeout_macrop_b_hi +*/ +#define VL53L1X_MM_CONFIG__TIMEOUT_MACROP_B_LO 0x005D +/*!< + type: uint8_t \n + default: 0x06 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['timing_config', 'mm_config'] + + fields: \n + - [7:0] = mm_config__config_timeout_macrop_b_lo +*/ +#define VL53L1X_RANGE_CONFIG__TIMEOUT_MACROP_A_HI 0x005E +/*!< + type: uint8_t \n + default: 0x01 \n + info: \n + - msb = 3 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['timing_config', 'range_config'] + + fields: \n + - [3:0] = range_timeout_overall_periods_macrop_a_hi +*/ +#define VL53L1X_RANGE_CONFIG__TIMEOUT_MACROP_A_LO 0x005F +/*!< + type: uint8_t \n + default: 0x92 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['timing_config', 'range_config'] + + fields: \n + - [7:0] = range_timeout_overall_periods_macrop_a_lo +*/ +#define VL53L1X_RANGE_CONFIG__VCSEL_PERIOD_A 0x0060 +/*!< + type: uint8_t \n + default: 0x0B \n + info: \n + - msb = 5 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['timing_config', 'range_config'] + + fields: \n + - [5:0] = range_config__vcsel_period_a +*/ +#define VL53L1X_RANGE_CONFIG__TIMEOUT_MACROP_B_HI 0x0061 +/*!< + type: uint8_t \n + default: 0x01 \n + info: \n + - msb = 3 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['timing_config', 'range_config'] + + fields: \n + - [3:0] = range_timeout_overall_periods_macrop_b_hi +*/ +#define VL53L1X_RANGE_CONFIG__TIMEOUT_MACROP_B_LO 0x0062 +/*!< + type: uint8_t \n + default: 0x92 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['timing_config', 'range_config'] + + fields: \n + - [7:0] = range_timeout_overall_periods_macrop_b_lo +*/ +#define VL53L1X_RANGE_CONFIG__VCSEL_PERIOD_B 0x0063 +/*!< + type: uint8_t \n + default: 0x09 \n + info: \n + - msb = 5 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['timing_config', 'range_config'] + + fields: \n + - [5:0] = range_config__vcsel_period_b +*/ +#define VL53L1X_RANGE_CONFIG__SIGMA_THRESH 0x0064 +/*!< + type: uint16_t \n + default: 0x0080 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['timing_config', 'range_config'] + + fields: \n + - [15:0] = range_config__sigma_thresh (fixed point 14.2) +*/ +#define VL53L1X_RANGE_CONFIG__SIGMA_THRESH_HI 0x0064 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGE_CONFIG__SIGMA_THRESH_LO 0x0065 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGE_CONFIG__MIN_COUNT_RATE_RTN_LIMIT_MCPS 0x0066 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['timing_config', 'range_config'] + + fields: \n + - [15:0] = range_config__min_count_rate_rtn_limit_mcps (fixed point 9.7) +*/ +#define VL53L1X_RANGE_CONFIG__MIN_COUNT_RATE_RTN_LIMIT_MCPS_HI 0x0066 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGE_CONFIG__MIN_COUNT_RATE_RTN_LIMIT_MCPS_LO 0x0067 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGE_CONFIG__VALID_PHASE_LOW 0x0068 +/*!< + type: uint8_t \n + default: 0x08 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['timing_config', 'range_config'] + + fields: \n + - [7:0] = range_config__valid_phase_low (fixed point 5.3) +*/ +#define VL53L1X_RANGE_CONFIG__VALID_PHASE_HIGH 0x0069 +/*!< + type: uint8_t \n + default: 0x80 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['timing_config', 'range_config'] + + fields: \n + - [7:0] = range_config__valid_phase_high (fixed point 5.3) +*/ +#define VL53L1X_SYSTEM__INTERMEASUREMENT_PERIOD 0x006C +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['timing_config', 'system_config'] + + fields: \n + - [31:0] = intermeasurement_period +*/ +#define VL53L1X_SYSTEM__INTERMEASUREMENT_PERIOD_3 0x006C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SYSTEM__INTERMEASUREMENT_PERIOD_2 0x006D +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SYSTEM__INTERMEASUREMENT_PERIOD_1 0x006E +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SYSTEM__INTERMEASUREMENT_PERIOD_0 0x006F +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SYSTEM__FRACTIONAL_ENABLE 0x0070 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['timing_config', 'system_config'] + + fields: \n + - [0] = range_fractional_enable +*/ +#define VL53L1X_SYSTEM__GROUPED_PARAMETER_HOLD_0 0x0071 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 1 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['dynamic_config', 'gph_config'] + + fields: \n + - [0] = grouped_parameter_hold + - [1] = grouped_parameter_hold_id +*/ +#define VL53L1X_SYSTEM__THRESH_HIGH 0x0072 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['dynamic_config', 'gph_config'] + + fields: \n + - [15:0] = thresh_high +*/ +#define VL53L1X_SYSTEM__THRESH_HIGH_HI 0x0072 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SYSTEM__THRESH_HIGH_LO 0x0073 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SYSTEM__THRESH_LOW 0x0074 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['dynamic_config', 'gph_config'] + + fields: \n + - [15:0] = thresh_low +*/ +#define VL53L1X_SYSTEM__THRESH_LOW_HI 0x0074 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SYSTEM__THRESH_LOW_LO 0x0075 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SYSTEM__ENABLE_XTALK_PER_QUADRANT 0x0076 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['dynamic_config', 'gph_config'] + + fields: \n + - [0] = system__enable_xtalk_per_quadrant +*/ +#define VL53L1X_SYSTEM__SEED_CONFIG 0x0077 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 2 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['dynamic_config', 'gph_config'] + + fields: \n + - [1:0] = system__seed_config + - [2] = system__fw_pause_ctrl +*/ +#define VL53L1X_SD_CONFIG__WOI_SD0 0x0078 +/*!< + type: uint8_t \n + default: 0x04 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['dynamic_config', 'gph_config'] + + fields: \n + - [7:0] = sd_config__woi_sd0 +*/ +#define VL53L1X_SD_CONFIG__WOI_SD1 0x0079 +/*!< + type: uint8_t \n + default: 0x04 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['dynamic_config', 'gph_config'] + + fields: \n + - [7:0] = sd_config__woi_sd1 +*/ +#define VL53L1X_SD_CONFIG__INITIAL_PHASE_SD0 0x007A +/*!< + type: uint8_t \n + default: 0x03 \n + info: \n + - msb = 6 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['dynamic_config', 'gph_config'] + + fields: \n + - [6:0] = sd_config__initial_phase_sd0 +*/ +#define VL53L1X_SD_CONFIG__INITIAL_PHASE_SD1 0x007B +/*!< + type: uint8_t \n + default: 0x03 \n + info: \n + - msb = 6 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['dynamic_config', 'gph_config'] + + fields: \n + - [6:0] = sd_config__initial_phase_sd1 +*/ +#define VL53L1X_SYSTEM__GROUPED_PARAMETER_HOLD_1 0x007C +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 1 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['dynamic_config', 'gph_config'] + + fields: \n + - [0] = grouped_parameter_hold + - [1] = grouped_parameter_hold_id +*/ +#define VL53L1X_SD_CONFIG__FIRST_ORDER_SELECT 0x007D +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 1 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['dynamic_config', 'gph_config'] + + fields: \n + - [0] = sd_config__first_order_select_rtn + - [1] = sd_config__first_order_select_ref +*/ +#define VL53L1X_SD_CONFIG__QUANTIFIER 0x007E +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 3 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['dynamic_config', 'gph_config'] + + fields: \n + - [3:0] = sd_config__quantifier +*/ +#define VL53L1X_ROI_CONFIG__USER_ROI_CENTRE_SPAD 0x007F +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['dynamic_config', 'gph_config'] + + fields: \n + - [7:0] = user_roi_center_spad +*/ +#define VL53L1X_ROI_CONFIG__USER_ROI_REQUESTED_GLOBAL_XY_SIZE 0x0080 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['dynamic_config', 'gph_config'] + + fields: \n + - [7:0] = roi_config__user_roi_requested_global_xy_size +*/ +#define VL53L1X_SYSTEM__SEQUENCE_CONFIG 0x0081 +/*!< + type: uint8_t \n + default: 0xFF \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['dynamic_config', 'gph_config'] + + fields: \n + - [0] = sequence_vhv_en + - [1] = sequence_phasecal_en + - [2] = sequence_reference_phase_en + - [3] = sequence_dss1_en + - [4] = sequence_dss2_en + - [5] = sequence_mm1_en + - [6] = sequence_mm2_en + - [7] = sequence_range_en +*/ +#define VL53L1X_SYSTEM__GROUPED_PARAMETER_HOLD 0x0082 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 1 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['dynamic_config', 'gph_config'] + + fields: \n + - [0] = grouped_parameter_hold + - [1] = grouped_parameter_hold_id +*/ +#define VL53L1X_POWER_MANAGEMENT__GO1_POWER_FORCE 0x0083 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['system_control', 'pwrman_ctrl'] + + fields: \n + - [0] = go1_dig_powerforce +*/ +#define VL53L1X_SYSTEM__STREAM_COUNT_CTRL 0x0084 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['system_control', 'stream_ctrl'] + + fields: \n + - [0] = retain_stream_count +*/ +#define VL53L1X_FIRMWARE__ENABLE 0x0085 +/*!< + type: uint8_t \n + default: 0x01 \n + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['system_control', 'firmware_ctrl'] + + fields: \n + - [0] = firmware_enable +*/ +#define VL53L1X_SYSTEM__INTERRUPT_CLEAR 0x0086 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 1 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['system_control', 'system_int_clr'] + + fields: \n + - [0] = sys_interrupt_clear_range + - [1] = sys_interrupt_clear_error +*/ +#define VL53L1X_SYSTEM__MODE_START 0x0087 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['system_control', 'system_start'] + + fields: \n + - [1:0] = scheduler_mode + - [3:2] = readout_mode + - [4] = mode_range__single_shot + - [5] = mode_range__back_to_back + - [6] = mode_range__timed + - [7] = mode_range__abort +*/ +#define VL53L1X_RESULT__INTERRUPT_STATUS 0x0088 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 5 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['system_results', 'results'] + + fields: \n + - [2:0] = int_status + - [4:3] = int_error_status + - [5] = gph_id_gpio_status +*/ +#define VL53L1X_RESULT__RANGE_STATUS 0x0089 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['system_results', 'results'] + + fields: \n + - [4:0] = range_status + - [5] = max_threshold_hit + - [6] = min_threshold_hit + - [7] = gph_id_range_status +*/ +#define VL53L1X_RESULT__REPORT_STATUS 0x008A +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 3 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['system_results', 'results'] + + fields: \n + - [3:0] = report_status +*/ +#define VL53L1X_RESULT__STREAM_COUNT 0x008B +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['system_results', 'results'] + + fields: \n + - [7:0] = result__stream_count +*/ +#define VL53L1X_RESULT__DSS_ACTUAL_EFFECTIVE_SPADS_SD0 0x008C +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['system_results', 'results'] + + fields: \n + - [15:0] = result__dss_actual_effective_spads_sd0 (fixed point 8.8) +*/ +#define VL53L1X_RESULT__DSS_ACTUAL_EFFECTIVE_SPADS_SD0_HI 0x008C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__DSS_ACTUAL_EFFECTIVE_SPADS_SD0_LO 0x008D +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__PEAK_SIGNAL_COUNT_RATE_MCPS_SD0 0x008E +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['system_results', 'results'] + + fields: \n + - [15:0] = result__peak_signal_count_rate_mcps_sd0 (fixed point 9.7) +*/ +#define VL53L1X_RESULT__PEAK_SIGNAL_COUNT_RATE_MCPS_SD0_HI 0x008E +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__PEAK_SIGNAL_COUNT_RATE_MCPS_SD0_LO 0x008F +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__AMBIENT_COUNT_RATE_MCPS_SD0 0x0090 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['system_results', 'results'] + + fields: \n + - [15:0] = result__ambient_count_rate_mcps_sd0 (fixed point 9.7) +*/ +#define VL53L1X_RESULT__AMBIENT_COUNT_RATE_MCPS_SD0_HI 0x0090 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__AMBIENT_COUNT_RATE_MCPS_SD0_LO 0x0091 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__SIGMA_SD0 0x0092 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['system_results', 'results'] + + fields: \n + - [15:0] = result__sigma_sd0 (fixed point 14.2) +*/ +#define VL53L1X_RESULT__SIGMA_SD0_HI 0x0092 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__SIGMA_SD0_LO 0x0093 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__PHASE_SD0 0x0094 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['system_results', 'results'] + + fields: \n + - [15:0] = result__phase_sd0 (fixed point 5.11) +*/ +#define VL53L1X_RESULT__PHASE_SD0_HI 0x0094 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__PHASE_SD0_LO 0x0095 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__FINAL_CROSSTALK_CORRECTED_RANGE_MM_SD0 0x0096 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['system_results', 'results'] + + fields: \n + - [15:0] = result__final_crosstalk_corrected_range_mm_sd0 +*/ +#define VL53L1X_RESULT__FINAL_CROSSTALK_CORRECTED_RANGE_MM_SD0_HI 0x0096 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__FINAL_CROSSTALK_CORRECTED_RANGE_MM_SD0_LO 0x0097 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__PEAK_SIGNAL_COUNT_RATE_CROSSTALK_CORRECTED_MCPS_SD0 0x0098 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['system_results', 'results'] + + fields: \n + - [15:0] = result__peak_signal_count_rate_crosstalk_corrected_mcps_sd0 (fixed point 9.7) +*/ +#define VL53L1X_RESULT__PEAK_SIGNAL_COUNT_RATE_CROSSTALK_CORRECTED_MCPS_SD0_HI 0x0098 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__PEAK_SIGNAL_COUNT_RATE_CROSSTALK_CORRECTED_MCPS_SD0_LO 0x0099 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__MM_INNER_ACTUAL_EFFECTIVE_SPADS_SD0 0x009A +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['system_results', 'results'] + + fields: \n + - [15:0] = result__mm_inner_actual_effective_spads_sd0 (fixed point 8.8) +*/ +#define VL53L1X_RESULT__MM_INNER_ACTUAL_EFFECTIVE_SPADS_SD0_HI 0x009A +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__MM_INNER_ACTUAL_EFFECTIVE_SPADS_SD0_LO 0x009B +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__MM_OUTER_ACTUAL_EFFECTIVE_SPADS_SD0 0x009C +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['system_results', 'results'] + + fields: \n + - [15:0] = result__mm_outer_actual_effective_spads_sd0 (fixed point 8.8) +*/ +#define VL53L1X_RESULT__MM_OUTER_ACTUAL_EFFECTIVE_SPADS_SD0_HI 0x009C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__MM_OUTER_ACTUAL_EFFECTIVE_SPADS_SD0_LO 0x009D +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__AVG_SIGNAL_COUNT_RATE_MCPS_SD0 0x009E +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['system_results', 'results'] + + fields: \n + - [15:0] = result__avg_signal_count_rate_mcps_sd0 (fixed point 9.7) +*/ +#define VL53L1X_RESULT__AVG_SIGNAL_COUNT_RATE_MCPS_SD0_HI 0x009E +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__AVG_SIGNAL_COUNT_RATE_MCPS_SD0_LO 0x009F +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__DSS_ACTUAL_EFFECTIVE_SPADS_SD1 0x00A0 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['system_results', 'results'] + + fields: \n + - [15:0] = result__dss_actual_effective_spads_sd1 (fixed point 8.8) +*/ +#define VL53L1X_RESULT__DSS_ACTUAL_EFFECTIVE_SPADS_SD1_HI 0x00A0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__DSS_ACTUAL_EFFECTIVE_SPADS_SD1_LO 0x00A1 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__PEAK_SIGNAL_COUNT_RATE_MCPS_SD1 0x00A2 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['system_results', 'results'] + + fields: \n + - [15:0] = result__peak_signal_count_rate_mcps_sd1 (fixed point 9.7) +*/ +#define VL53L1X_RESULT__PEAK_SIGNAL_COUNT_RATE_MCPS_SD1_HI 0x00A2 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__PEAK_SIGNAL_COUNT_RATE_MCPS_SD1_LO 0x00A3 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__AMBIENT_COUNT_RATE_MCPS_SD1 0x00A4 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['system_results', 'results'] + + fields: \n + - [15:0] = result__ambient_count_rate_mcps_sd1 (fixed point 9.7) +*/ +#define VL53L1X_RESULT__AMBIENT_COUNT_RATE_MCPS_SD1_HI 0x00A4 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__AMBIENT_COUNT_RATE_MCPS_SD1_LO 0x00A5 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__SIGMA_SD1 0x00A6 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['system_results', 'results'] + + fields: \n + - [15:0] = result__sigma_sd1 (fixed point 14.2) +*/ +#define VL53L1X_RESULT__SIGMA_SD1_HI 0x00A6 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__SIGMA_SD1_LO 0x00A7 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__PHASE_SD1 0x00A8 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['system_results', 'results'] + + fields: \n + - [15:0] = result__phase_sd1 (fixed point 5.11) +*/ +#define VL53L1X_RESULT__PHASE_SD1_HI 0x00A8 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__PHASE_SD1_LO 0x00A9 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__FINAL_CROSSTALK_CORRECTED_RANGE_MM_SD1 0x00AA +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['system_results', 'results'] + + fields: \n + - [15:0] = result__final_crosstalk_corrected_range_mm_sd1 +*/ +#define VL53L1X_RESULT__FINAL_CROSSTALK_CORRECTED_RANGE_MM_SD1_HI 0x00AA +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__FINAL_CROSSTALK_CORRECTED_RANGE_MM_SD1_LO 0x00AB +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__SPARE_0_SD1 0x00AC +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['system_results', 'results'] + + fields: \n + - [15:0] = result__spare_0_sd1 +*/ +#define VL53L1X_RESULT__SPARE_0_SD1_HI 0x00AC +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__SPARE_0_SD1_LO 0x00AD +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__SPARE_1_SD1 0x00AE +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['system_results', 'results'] + + fields: \n + - [15:0] = result__spare_1_sd1 +*/ +#define VL53L1X_RESULT__SPARE_1_SD1_HI 0x00AE +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__SPARE_1_SD1_LO 0x00AF +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__SPARE_2_SD1 0x00B0 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['system_results', 'results'] + + fields: \n + - [15:0] = result__spare_2_sd1 +*/ +#define VL53L1X_RESULT__SPARE_2_SD1_HI 0x00B0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__SPARE_2_SD1_LO 0x00B1 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__SPARE_3_SD1 0x00B2 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['system_results', 'results'] + + fields: \n + - [7:0] = result__spare_3_sd1 +*/ +#define VL53L1X_RESULT__THRESH_INFO 0x00B3 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['system_results', 'results'] + + fields: \n + - [3:0] = result__distance_int_info + - [7:4] = result__rate_int_info +*/ +#define VL53L1X_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD0 0x00B4 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['core_results', 'ranging_core_results'] + + fields: \n + - [31:0] = result_core__ambient_window_events_sd0 +*/ +#define VL53L1X_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD0_3 0x00B4 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD0_2 0x00B5 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD0_1 0x00B6 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD0_0 0x00B7 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__RANGING_TOTAL_EVENTS_SD0 0x00B8 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['core_results', 'ranging_core_results'] + + fields: \n + - [31:0] = result_core__ranging_total_events_sd0 +*/ +#define VL53L1X_RESULT_CORE__RANGING_TOTAL_EVENTS_SD0_3 0x00B8 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__RANGING_TOTAL_EVENTS_SD0_2 0x00B9 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__RANGING_TOTAL_EVENTS_SD0_1 0x00BA +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__RANGING_TOTAL_EVENTS_SD0_0 0x00BB +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD0 0x00BC +/*!< + type: int32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['core_results', 'ranging_core_results'] + + fields: \n + - [31:0] = result_core__signal_total_events_sd0 +*/ +#define VL53L1X_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD0_3 0x00BC +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD0_2 0x00BD +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD0_1 0x00BE +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD0_0 0x00BF +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD0 0x00C0 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['core_results', 'ranging_core_results'] + + fields: \n + - [31:0] = result_core__total_periods_elapsed_sd0 +*/ +#define VL53L1X_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD0_3 0x00C0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD0_2 0x00C1 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD0_1 0x00C2 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD0_0 0x00C3 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD1 0x00C4 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['core_results', 'ranging_core_results'] + + fields: \n + - [31:0] = result_core__ambient_window_events_sd1 +*/ +#define VL53L1X_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD1_3 0x00C4 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD1_2 0x00C5 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD1_1 0x00C6 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD1_0 0x00C7 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__RANGING_TOTAL_EVENTS_SD1 0x00C8 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['core_results', 'ranging_core_results'] + + fields: \n + - [31:0] = result_core__ranging_total_events_sd1 +*/ +#define VL53L1X_RESULT_CORE__RANGING_TOTAL_EVENTS_SD1_3 0x00C8 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__RANGING_TOTAL_EVENTS_SD1_2 0x00C9 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__RANGING_TOTAL_EVENTS_SD1_1 0x00CA +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__RANGING_TOTAL_EVENTS_SD1_0 0x00CB +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD1 0x00CC +/*!< + type: int32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['core_results', 'ranging_core_results'] + + fields: \n + - [31:0] = result_core__signal_total_events_sd1 +*/ +#define VL53L1X_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD1_3 0x00CC +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD1_2 0x00CD +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD1_1 0x00CE +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD1_0 0x00CF +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD1 0x00D0 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['core_results', 'ranging_core_results'] + + fields: \n + - [31:0] = result_core__total_periods_elapsed_sd1 +*/ +#define VL53L1X_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD1_3 0x00D0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD1_2 0x00D1 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD1_1 0x00D2 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD1_0 0x00D3 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT_CORE__SPARE_0 0x00D4 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['core_results', 'ranging_core_results'] + + fields: \n + - [7:0] = result_core__spare_0 +*/ +#define VL53L1X_PHASECAL_RESULT__REFERENCE_PHASE 0x00D6 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['debug_results', 'phasecal_results'] + + fields: \n + - [15:0] = result_phasecal__reference_phase (fixed point 5.11) +*/ +#define VL53L1X_PHASECAL_RESULT__REFERENCE_PHASE_HI 0x00D6 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PHASECAL_RESULT__REFERENCE_PHASE_LO 0x00D7 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PHASECAL_RESULT__VCSEL_START 0x00D8 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 6 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'phasecal_results'] + + fields: \n + - [6:0] = result_phasecal__vcsel_start +*/ +#define VL53L1X_REF_SPAD_CHAR_RESULT__NUM_ACTUAL_REF_SPADS 0x00D9 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 5 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'ref_spad_status'] + + fields: \n + - [5:0] = ref_spad_char_result__num_actual_ref_spads +*/ +#define VL53L1X_REF_SPAD_CHAR_RESULT__REF_LOCATION 0x00DA +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 1 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'ref_spad_status'] + + fields: \n + - [1:0] = ref_spad_char_result__ref_location +*/ +#define VL53L1X_VHV_RESULT__COLDBOOT_STATUS 0x00DB +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'vhv_results'] + + fields: \n + - [0] = vhv_result__coldboot_status +*/ +#define VL53L1X_VHV_RESULT__SEARCH_RESULT 0x00DC +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 5 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'vhv_results'] + + fields: \n + - [5:0] = cp_sel_result +*/ +#define VL53L1X_VHV_RESULT__LATEST_SETTING 0x00DD +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 5 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'vhv_results'] + + fields: \n + - [5:0] = cp_sel_latest_setting +*/ +#define VL53L1X_RESULT__OSC_CALIBRATE_VAL 0x00DE +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 9 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['debug_results', 'misc_results'] + + fields: \n + - [9:0] = osc_calibrate_val +*/ +#define VL53L1X_RESULT__OSC_CALIBRATE_VAL_HI 0x00DE +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RESULT__OSC_CALIBRATE_VAL_LO 0x00DF +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_ANA_CONFIG__POWERDOWN_GO1 0x00E0 +/*!< + type: uint8_t \n + default: 0x02 \n + info: \n + - msb = 1 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'analog_config'] + + fields: \n + - [0] = go2_ref_bg_disable_avdd + - [1] = go2_regdvdd1v2_enable_avdd +*/ +#define VL53L1X_ANA_CONFIG__REF_BG_CTRL 0x00E1 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 1 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'analog_config'] + + fields: \n + - [0] = go2_ref_overdrvbg_avdd + - [1] = go2_ref_forcebgison_avdd +*/ +#define VL53L1X_ANA_CONFIG__REGDVDD1V2_CTRL 0x00E2 +/*!< + type: uint8_t \n + default: 0x01 \n + info: \n + - msb = 3 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'analog_config'] + + fields: \n + - [0] = go2_regdvdd1v2_sel_pulldown_avdd + - [1] = go2_regdvdd1v2_sel_boost_avdd + - [3:2] = go2_regdvdd1v2_selv_avdd +*/ +#define VL53L1X_ANA_CONFIG__OSC_SLOW_CTRL 0x00E3 +/*!< + type: uint8_t \n + default: 0x02 \n + info: \n + - msb = 2 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'analog_config'] + + fields: \n + - [0] = osc_slow_en + - [1] = osc_slow_op_en + - [2] = osc_slow_freq_sel +*/ +#define VL53L1X_TEST_MODE__STATUS 0x00E4 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'test_mode_status'] + + fields: \n + - [0] = test_mode_status +*/ +#define VL53L1X_FIRMWARE__SYSTEM_STATUS 0x00E5 +/*!< + type: uint8_t \n + default: 0x02 \n + info: \n + - msb = 1 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'firmware_status'] + + fields: \n + - [0] = firmware_bootup + - [1] = firmware_first_range +*/ +#define VL53L1X_FIRMWARE__MODE_STATUS 0x00E6 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'firmware_status'] + + fields: \n + - [7:0] = firmware_mode_status +*/ +#define VL53L1X_FIRMWARE__SECONDARY_MODE_STATUS 0x00E7 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'firmware_status'] + + fields: \n + - [7:0] = fw_secondary_mode_status +*/ +#define VL53L1X_FIRMWARE__CAL_REPEAT_RATE_COUNTER 0x00E8 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 11 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['debug_results', 'firmware_status'] + + fields: \n + - [11:0] = firmware_cal_repeat_rate +*/ +#define VL53L1X_FIRMWARE__CAL_REPEAT_RATE_COUNTER_HI 0x00E8 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_FIRMWARE__CAL_REPEAT_RATE_COUNTER_LO 0x00E9 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_FIRMWARE__HISTOGRAM_BIN 0x00EA +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_GPH__SYSTEM__THRESH_HIGH 0x00EC +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['debug_results', 'gph_actual'] + + fields: \n + - [15:0] = shadow_thresh_high +*/ +#define VL53L1X_GPH__SYSTEM__THRESH_HIGH_HI 0x00EC +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_GPH__SYSTEM__THRESH_HIGH_LO 0x00ED +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_GPH__SYSTEM__THRESH_LOW 0x00EE +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['debug_results', 'gph_actual'] + + fields: \n + - [15:0] = shadow_thresh_low +*/ +#define VL53L1X_GPH__SYSTEM__THRESH_LOW_HI 0x00EE +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_GPH__SYSTEM__THRESH_LOW_LO 0x00EF +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_GPH__SYSTEM__ENABLE_XTALK_PER_QUADRANT 0x00F0 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'gph_actual'] + + fields: \n + - [0] = shadow__enable_xtalk_per_quadrant +*/ +#define VL53L1X_GPH__SPARE_0 0x00F1 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 2 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'gph_actual'] + + fields: \n + - [0] = fw_safe_to_disable + - [1] = shadow__spare_0 + - [2] = shadow__spare_1 +*/ +#define VL53L1X_GPH__SD_CONFIG__WOI_SD0 0x00F2 +/*!< + type: uint8_t \n + default: 0x04 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'gph_actual'] + + fields: \n + - [7:0] = shadow_sd_config__woi_sd0 +*/ +#define VL53L1X_GPH__SD_CONFIG__WOI_SD1 0x00F3 +/*!< + type: uint8_t \n + default: 0x04 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'gph_actual'] + + fields: \n + - [7:0] = shadow_sd_config__woi_sd1 +*/ +#define VL53L1X_GPH__SD_CONFIG__INITIAL_PHASE_SD0 0x00F4 +/*!< + type: uint8_t \n + default: 0x03 \n + info: \n + - msb = 6 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'gph_actual'] + + fields: \n + - [6:0] = shadow_sd_config__initial_phase_sd0 +*/ +#define VL53L1X_GPH__SD_CONFIG__INITIAL_PHASE_SD1 0x00F5 +/*!< + type: uint8_t \n + default: 0x03 \n + info: \n + - msb = 6 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'gph_actual'] + + fields: \n + - [6:0] = shadow_sd_config__initial_phase_sd1 +*/ +#define VL53L1X_GPH__SD_CONFIG__FIRST_ORDER_SELECT 0x00F6 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 1 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'gph_actual'] + + fields: \n + - [0] = shadow_sd_config__first_order_select_rtn + - [1] = shadow_sd_config__first_order_select_ref +*/ +#define VL53L1X_GPH__SD_CONFIG__QUANTIFIER 0x00F7 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 3 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'gph_actual'] + + fields: \n + - [3:0] = shadow_sd_config__quantifier +*/ +#define VL53L1X_GPH__ROI_CONFIG__USER_ROI_CENTRE_SPAD 0x00F8 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'gph_actual'] + + fields: \n + - [7:0] = shadow_user_roi_center_spad_q0 +*/ +#define VL53L1X_GPH__ROI_CONFIG__USER_ROI_REQUESTED_GLOBAL_XY_SIZE 0x00F9 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'gph_actual'] + + fields: \n + - [7:0] = shadow_user_roi_requested_global_xy_size +*/ +#define VL53L1X_GPH__SYSTEM__SEQUENCE_CONFIG 0x00FA +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'gph_actual'] + + fields: \n + - [0] = shadow_sequence_vhv_en + - [1] = shadow_sequence_phasecal_en + - [2] = shadow_sequence_reference_phase_en + - [3] = shadow_sequence_dss1_en + - [4] = shadow_sequence_dss2_en + - [5] = shadow_sequence_mm1_en + - [6] = shadow_sequence_mm2_en + - [7] = shadow_sequence_range_en +*/ +#define VL53L1X_GPH__GPH_ID 0x00FB +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'gph_actual'] + + fields: \n + - [0] = shadow_gph_id +*/ +#define VL53L1X_SYSTEM__INTERRUPT_SET 0x00FC +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 1 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'system_int_set'] + + fields: \n + - [0] = sys_interrupt_set_range + - [1] = sys_interrupt_set_error +*/ +#define VL53L1X_INTERRUPT_MANAGER__ENABLES 0x00FD +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 4 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'interrupt_manager'] + + fields: \n + - [0] = interrupt_enable__single_shot + - [1] = interrupt_enable__back_to_back + - [2] = interrupt_enable__timed + - [3] = interrupt_enable__abort + - [4] = interrupt_enable__test +*/ +#define VL53L1X_INTERRUPT_MANAGER__CLEAR 0x00FE +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 4 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'interrupt_manager'] + + fields: \n + - [0] = interrupt_clear__single_shot + - [1] = interrupt_clear__back_to_back + - [2] = interrupt_clear__timed + - [3] = interrupt_clear__abort + - [4] = interrupt_clear__test +*/ +#define VL53L1X_INTERRUPT_MANAGER__STATUS 0x00FF +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 4 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'interrupt_manager'] + + fields: \n + - [0] = interrupt_status__single_shot + - [1] = interrupt_status__back_to_back + - [2] = interrupt_status__timed + - [3] = interrupt_status__abort + - [4] = interrupt_status__test +*/ +#define VL53L1X_MCU_TO_HOST_BANK__WR_ACCESS_EN 0x0100 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'host_bank_ctrl'] + + fields: \n + - [0] = mcu_to_host_bank_wr_en +*/ +#define VL53L1X_POWER_MANAGEMENT__GO1_RESET_STATUS 0x0101 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'power_man_status'] + + fields: \n + - [0] = go1_status +*/ +#define VL53L1X_PAD_STARTUP_MODE__VALUE_RO 0x0102 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 1 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'pad_config'] + + fields: \n + - [0] = pad_atest1_val_ro + - [1] = pad_atest2_val_ro +*/ +#define VL53L1X_PAD_STARTUP_MODE__VALUE_CTRL 0x0103 +/*!< + type: uint8_t \n + default: 0x30 \n + info: \n + - msb = 5 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'pad_config'] + + fields: \n + - [0] = pad_atest1_val + - [1] = pad_atest2_val + - [4] = pad_atest1_dig_enable + - [5] = pad_atest2_dig_enable +*/ +#define VL53L1X_PLL_PERIOD_US 0x0104 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 17 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['debug_results', 'pll_config'] + + fields: \n + - [17:0] = pll_period_us (fixed point 0.24) +*/ +#define VL53L1X_PLL_PERIOD_US_3 0x0104 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PLL_PERIOD_US_2 0x0105 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PLL_PERIOD_US_1 0x0106 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PLL_PERIOD_US_0 0x0107 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_INTERRUPT_SCHEDULER__DATA_OUT 0x0108 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['debug_results', 'debug_timer'] + + fields: \n + - [31:0] = interrupt_scheduler_data_out +*/ +#define VL53L1X_INTERRUPT_SCHEDULER__DATA_OUT_3 0x0108 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_INTERRUPT_SCHEDULER__DATA_OUT_2 0x0109 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_INTERRUPT_SCHEDULER__DATA_OUT_1 0x010A +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_INTERRUPT_SCHEDULER__DATA_OUT_0 0x010B +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_NVM_BIST__COMPLETE 0x010C +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'nvm_bist_status'] + + fields: \n + - [0] = nvm_bist__complete +*/ +#define VL53L1X_NVM_BIST__STATUS 0x010D +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['debug_results', 'nvm_bist_status'] + + fields: \n + - [0] = nvm_bist__status +*/ +#define VL53L1X_IDENTIFICATION__MODEL_ID 0x010F +/*!< + type: uint8_t \n + default: 0xEA \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'identification'] + + fields: \n + - [7:0] = model_id +*/ +#define VL53L1X_IDENTIFICATION__MODULE_TYPE 0x0110 +/*!< + type: uint8_t \n + default: 0xAA \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'identification'] + + fields: \n + - [7:0] = module_type +*/ +#define VL53L1X_IDENTIFICATION__REVISION_ID 0x0111 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'identification'] + + fields: \n + - [3:0] = nvm_revision_id + - [7:4] = mask_revision_id +*/ +#define VL53L1X_IDENTIFICATION__MODULE_ID 0x0112 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['nvm_copy_data', 'identification'] + + fields: \n + - [15:0] = module_id +*/ +#define VL53L1X_IDENTIFICATION__MODULE_ID_HI 0x0112 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_IDENTIFICATION__MODULE_ID_LO 0x0113 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_ANA_CONFIG__FAST_OSC__TRIM_MAX 0x0114 +/*!< + type: uint8_t \n + default: OSC_TRIM_DEFAULT \n + info: \n + - msb = 6 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'analog_config'] + + fields: \n + - [6:0] = osc_trim_max +*/ +#define VL53L1X_ANA_CONFIG__FAST_OSC__FREQ_SET 0x0115 +/*!< + type: uint8_t \n + default: OSC_FREQ_SET_DEFAULT \n + info: \n + - msb = 2 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'analog_config'] + + fields: \n + - [2:0] = osc_freq_set +*/ +#define VL53L1X_ANA_CONFIG__VCSEL_TRIM 0x0116 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 2 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'analog_config'] + + fields: \n + - [2:0] = vcsel_trim +*/ +#define VL53L1X_ANA_CONFIG__VCSEL_SELION 0x0117 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 5 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'analog_config'] + + fields: \n + - [5:0] = vcsel_selion +*/ +#define VL53L1X_ANA_CONFIG__VCSEL_SELION_MAX 0x0118 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 5 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'analog_config'] + + fields: \n + - [5:0] = vcsel_selion_max +*/ +#define VL53L1X_PROTECTED_LASER_SAFETY__LOCK_BIT 0x0119 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'laser_safety'] + + fields: \n + - [0] = laser_safety__lock_bit +*/ +#define VL53L1X_LASER_SAFETY__KEY 0x011A +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 6 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'laser_safety'] + + fields: \n + - [6:0] = laser_safety__key +*/ +#define VL53L1X_LASER_SAFETY__KEY_RO 0x011B +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'laser_safety'] + + fields: \n + - [0] = laser_safety__key_ro +*/ +#define VL53L1X_LASER_SAFETY__CLIP 0x011C +/*!< + type: uint8_t \n + default: 0x02 \n + info: \n + - msb = 5 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'laser_safety'] + + fields: \n + - [5:0] = vcsel_pulse_width_clip +*/ +#define VL53L1X_LASER_SAFETY__MULT 0x011D +/*!< + type: uint8_t \n + default: 0x32 \n + info: \n + - msb = 5 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'laser_safety'] + + fields: \n + - [5:0] = vcsel_pulse_width_mult +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_0 0x011E +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_0 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_1 0x011F +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_1 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_2 0x0120 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_2 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_3 0x0121 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_3 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_4 0x0122 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_4 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_5 0x0123 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_5 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_6 0x0124 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_6 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_7 0x0125 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_7 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_8 0x0126 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_8 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_9 0x0127 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_9 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_10 0x0128 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_10 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_11 0x0129 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_11 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_12 0x012A +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_12 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_13 0x012B +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_13 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_14 0x012C +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_14 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_15 0x012D +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_15 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_16 0x012E +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_16 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_17 0x012F +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_17 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_18 0x0130 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_18 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_19 0x0131 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_19 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_20 0x0132 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_20 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_21 0x0133 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_21 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_22 0x0134 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_22 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_23 0x0135 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_23 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_24 0x0136 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_24 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_25 0x0137 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_25 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_26 0x0138 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_26 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_27 0x0139 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_27 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_28 0x013A +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_28 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_29 0x013B +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_29 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_30 0x013C +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_30 +*/ +#define VL53L1X_GLOBAL_CONFIG__SPAD_ENABLES_RTN_31 0x013D +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'ret_spad_config'] + + fields: \n + - [7:0] = spad_enables_rtn_31 +*/ +#define VL53L1X_ROI_CONFIG__MODE_ROI_CENTRE_SPAD 0x013E +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'roi_config'] + + fields: \n + - [7:0] = mode_roi_center_spad +*/ +#define VL53L1X_ROI_CONFIG__MODE_ROI_XY_SIZE 0x013F +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['nvm_copy_data', 'roi_config'] + + fields: \n + - [7:0] = mode_roi_xy_size +*/ +#define VL53L1X_GO2_HOST_BANK_ACCESS__OVERRIDE 0x0300 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_MULTIPLIER__MULTIPLICAND 0x0400 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_MULTIPLIER__MULTIPLICAND_3 0x0400 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_MULTIPLIER__MULTIPLICAND_2 0x0401 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_MULTIPLIER__MULTIPLICAND_1 0x0402 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_MULTIPLIER__MULTIPLICAND_0 0x0403 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_MULTIPLIER__MULTIPLIER 0x0404 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_MULTIPLIER__MULTIPLIER_3 0x0404 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_MULTIPLIER__MULTIPLIER_2 0x0405 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_MULTIPLIER__MULTIPLIER_1 0x0406 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_MULTIPLIER__MULTIPLIER_0 0x0407 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_MULTIPLIER__PRODUCT_HI 0x0408 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_MULTIPLIER__PRODUCT_HI_3 0x0408 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_MULTIPLIER__PRODUCT_HI_2 0x0409 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_MULTIPLIER__PRODUCT_HI_1 0x040A +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_MULTIPLIER__PRODUCT_HI_0 0x040B +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_MULTIPLIER__PRODUCT_LO 0x040C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_MULTIPLIER__PRODUCT_LO_3 0x040C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_MULTIPLIER__PRODUCT_LO_2 0x040D +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_MULTIPLIER__PRODUCT_LO_1 0x040E +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_MULTIPLIER__PRODUCT_LO_0 0x040F +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_MULTIPLIER__START 0x0410 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_MULTIPLIER__STATUS 0x0411 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_DIVIDER__START 0x0412 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_DIVIDER__STATUS 0x0413 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_DIVIDER__DIVIDEND 0x0414 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_DIVIDER__DIVIDEND_3 0x0414 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_DIVIDER__DIVIDEND_2 0x0415 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_DIVIDER__DIVIDEND_1 0x0416 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_DIVIDER__DIVIDEND_0 0x0417 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_DIVIDER__DIVISOR 0x0418 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_DIVIDER__DIVISOR_3 0x0418 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_DIVIDER__DIVISOR_2 0x0419 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_DIVIDER__DIVISOR_1 0x041A +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_DIVIDER__DIVISOR_0 0x041B +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_DIVIDER__QUOTIENT 0x041C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_DIVIDER__QUOTIENT_3 0x041C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_DIVIDER__QUOTIENT_2 0x041D +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_DIVIDER__QUOTIENT_1 0x041E +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_UTIL_DIVIDER__QUOTIENT_0 0x041F +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TIMER0__VALUE_IN 0x0420 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TIMER0__VALUE_IN_3 0x0420 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TIMER0__VALUE_IN_2 0x0421 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TIMER0__VALUE_IN_1 0x0422 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TIMER0__VALUE_IN_0 0x0423 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TIMER1__VALUE_IN 0x0424 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TIMER1__VALUE_IN_3 0x0424 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TIMER1__VALUE_IN_2 0x0425 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TIMER1__VALUE_IN_1 0x0426 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TIMER1__VALUE_IN_0 0x0427 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TIMER0__CTRL 0x0428 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TIMER1__CTRL 0x0429 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_GENERAL_PURPOSE__GP_0 0x042C +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + [''] + + fields: \n + - [7:0] = mcu_gp_0 +*/ +#define VL53L1X_MCU_GENERAL_PURPOSE__GP_1 0x042D +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + [''] + + fields: \n + - [7:0] = mcu_gp_1 +*/ +#define VL53L1X_MCU_GENERAL_PURPOSE__GP_2 0x042E +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + [''] + + fields: \n + - [7:0] = mcu_gp_2 +*/ +#define VL53L1X_MCU_GENERAL_PURPOSE__GP_3 0x042F +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + [''] + + fields: \n + - [7:0] = mcu_gp_3 +*/ +#define VL53L1X_MCU_RANGE_CALC__CONFIG 0x0430 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + [''] + + fields: \n + - [0] = fw_calc__sigma_delta_sel + - [2] = fw_calc__phase_output_en + - [3] = fw_calc__peak_signal_rate_en + - [4] = fw_calc__ambient_rate_en + - [5] = fw_calc__total_rate_per_spad_en + - [6] = fw_calc__snr_avg_signal_rate_en + - [7] = fw_calc__sigma_en +*/ +#define VL53L1X_MCU_RANGE_CALC__OFFSET_CORRECTED_RANGE 0x0432 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + [''] + + fields: \n + - [15:0] = offset_corrected_range +*/ +#define VL53L1X_MCU_RANGE_CALC__OFFSET_CORRECTED_RANGE_HI 0x0432 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__OFFSET_CORRECTED_RANGE_LO 0x0433 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__SPARE_4 0x0434 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 16 + - lsb = 0 + - i2c_size = 4 + + groups: \n + [''] + + fields: \n + - [16:0] = mcu_calc__spare_4 +*/ +#define VL53L1X_MCU_RANGE_CALC__SPARE_4_3 0x0434 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__SPARE_4_2 0x0435 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__SPARE_4_1 0x0436 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__SPARE_4_0 0x0437 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__AMBIENT_DURATION_PRE_CALC 0x0438 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 13 + - lsb = 0 + - i2c_size = 2 + + groups: \n + [''] + + fields: \n + - [13:0] = ambient_duration_prec_calc +*/ +#define VL53L1X_MCU_RANGE_CALC__AMBIENT_DURATION_PRE_CALC_HI 0x0438 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__AMBIENT_DURATION_PRE_CALC_LO 0x0439 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__ALGO_VCSEL_PERIOD 0x043C +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + [''] + + fields: \n + - [7:0] = algo_vcsel_period +*/ +#define VL53L1X_MCU_RANGE_CALC__SPARE_5 0x043D +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + [''] + + fields: \n + - [7:0] = mcu_calc__spare_5 +*/ +#define VL53L1X_MCU_RANGE_CALC__ALGO_TOTAL_PERIODS 0x043E +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + [''] + + fields: \n + - [15:0] = algo_total_periods +*/ +#define VL53L1X_MCU_RANGE_CALC__ALGO_TOTAL_PERIODS_HI 0x043E +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__ALGO_TOTAL_PERIODS_LO 0x043F +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__ALGO_ACCUM_PHASE 0x0440 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + [''] + + fields: \n + - [31:0] = algo_accum_phase +*/ +#define VL53L1X_MCU_RANGE_CALC__ALGO_ACCUM_PHASE_3 0x0440 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__ALGO_ACCUM_PHASE_2 0x0441 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__ALGO_ACCUM_PHASE_1 0x0442 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__ALGO_ACCUM_PHASE_0 0x0443 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__ALGO_SIGNAL_EVENTS 0x0444 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + [''] + + fields: \n + - [31:0] = algo_signal_events +*/ +#define VL53L1X_MCU_RANGE_CALC__ALGO_SIGNAL_EVENTS_3 0x0444 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__ALGO_SIGNAL_EVENTS_2 0x0445 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__ALGO_SIGNAL_EVENTS_1 0x0446 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__ALGO_SIGNAL_EVENTS_0 0x0447 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__ALGO_AMBIENT_EVENTS 0x0448 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + [''] + + fields: \n + - [31:0] = algo_ambient_events +*/ +#define VL53L1X_MCU_RANGE_CALC__ALGO_AMBIENT_EVENTS_3 0x0448 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__ALGO_AMBIENT_EVENTS_2 0x0449 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__ALGO_AMBIENT_EVENTS_1 0x044A +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__ALGO_AMBIENT_EVENTS_0 0x044B +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__SPARE_6 0x044C +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + [''] + + fields: \n + - [15:0] = mcu_calc__spare_6 +*/ +#define VL53L1X_MCU_RANGE_CALC__SPARE_6_HI 0x044C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__SPARE_6_LO 0x044D +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__ALGO_ADJUST_VCSEL_PERIOD 0x044E +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + [''] + + fields: \n + - [15:0] = algo_adjust_vcsel_period +*/ +#define VL53L1X_MCU_RANGE_CALC__ALGO_ADJUST_VCSEL_PERIOD_HI 0x044E +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__ALGO_ADJUST_VCSEL_PERIOD_LO 0x044F +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__NUM_SPADS 0x0450 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + [''] + + fields: \n + - [15:0] = num_spads +*/ +#define VL53L1X_MCU_RANGE_CALC__NUM_SPADS_HI 0x0450 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__NUM_SPADS_LO 0x0451 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__PHASE_OUTPUT 0x0452 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + [''] + + fields: \n + - [15:0] = phase_output +*/ +#define VL53L1X_MCU_RANGE_CALC__PHASE_OUTPUT_HI 0x0452 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__PHASE_OUTPUT_LO 0x0453 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__RATE_PER_SPAD_MCPS 0x0454 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 19 + - lsb = 0 + - i2c_size = 4 + + groups: \n + [''] + + fields: \n + - [19:0] = rate_per_spad_mcps +*/ +#define VL53L1X_MCU_RANGE_CALC__RATE_PER_SPAD_MCPS_3 0x0454 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__RATE_PER_SPAD_MCPS_2 0x0455 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__RATE_PER_SPAD_MCPS_1 0x0456 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__RATE_PER_SPAD_MCPS_0 0x0457 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__SPARE_7 0x0458 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + [''] + + fields: \n + - [7:0] = mcu_calc__spare_7 +*/ +#define VL53L1X_MCU_RANGE_CALC__SPARE_8 0x0459 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + [''] + + fields: \n + - [7:0] = mcu_calc__spare_8 +*/ +#define VL53L1X_MCU_RANGE_CALC__PEAK_SIGNAL_RATE_MCPS 0x045A +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + [''] + + fields: \n + - [15:0] = peak_signal_rate +*/ +#define VL53L1X_MCU_RANGE_CALC__PEAK_SIGNAL_RATE_MCPS_HI 0x045A +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__PEAK_SIGNAL_RATE_MCPS_LO 0x045B +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__AVG_SIGNAL_RATE_MCPS 0x045C +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + [''] + + fields: \n + - [15:0] = avg_signal_rate +*/ +#define VL53L1X_MCU_RANGE_CALC__AVG_SIGNAL_RATE_MCPS_HI 0x045C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__AVG_SIGNAL_RATE_MCPS_LO 0x045D +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__AMBIENT_RATE_MCPS 0x045E +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + [''] + + fields: \n + - [15:0] = ambient_rate +*/ +#define VL53L1X_MCU_RANGE_CALC__AMBIENT_RATE_MCPS_HI 0x045E +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__AMBIENT_RATE_MCPS_LO 0x045F +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__XTALK 0x0460 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + [''] + + fields: \n + - [15:0] = crosstalk (fixed point 9.7) +*/ +#define VL53L1X_MCU_RANGE_CALC__XTALK_HI 0x0460 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__XTALK_LO 0x0461 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__CALC_STATUS 0x0462 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + [''] + + fields: \n + - [7:0] = calc_status +*/ +#define VL53L1X_MCU_RANGE_CALC__DEBUG 0x0463 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 + + groups: \n + [''] + + fields: \n + - [0] = calc_debug__divide_by_zero +*/ +#define VL53L1X_MCU_RANGE_CALC__PEAK_SIGNAL_RATE_XTALK_CORR_MCPS 0x0464 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + [''] + + fields: \n + - [15:0] = peak_signal_rate_xtalk_corr +*/ +#define VL53L1X_MCU_RANGE_CALC__PEAK_SIGNAL_RATE_XTALK_CORR_MCPS_HI 0x0464 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__PEAK_SIGNAL_RATE_XTALK_CORR_MCPS_LO 0x0465 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MCU_RANGE_CALC__SPARE_0 0x0468 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + [''] + + fields: \n + - [7:0] = mcu_calc__spare_0 +*/ +#define VL53L1X_MCU_RANGE_CALC__SPARE_1 0x0469 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + [''] + + fields: \n + - [7:0] = mcu_calc__spare_1 +*/ +#define VL53L1X_MCU_RANGE_CALC__SPARE_2 0x046A +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + [''] + + fields: \n + - [7:0] = mcu_calc__spare_2 +*/ +#define VL53L1X_MCU_RANGE_CALC__SPARE_3 0x046B +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + [''] + + fields: \n + - [7:0] = mcu_calc__spare_3 +*/ +#define VL53L1X_PATCH__CTRL 0x0470 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__JMP_ENABLES 0x0472 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__JMP_ENABLES_HI 0x0472 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__JMP_ENABLES_LO 0x0473 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__DATA_ENABLES 0x0474 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__DATA_ENABLES_HI 0x0474 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__DATA_ENABLES_LO 0x0475 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_0 0x0476 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_0_HI 0x0476 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_0_LO 0x0477 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_1 0x0478 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_1_HI 0x0478 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_1_LO 0x0479 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_2 0x047A +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_2_HI 0x047A +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_2_LO 0x047B +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_3 0x047C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_3_HI 0x047C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_3_LO 0x047D +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_4 0x047E +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_4_HI 0x047E +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_4_LO 0x047F +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_5 0x0480 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_5_HI 0x0480 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_5_LO 0x0481 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_6 0x0482 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_6_HI 0x0482 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_6_LO 0x0483 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_7 0x0484 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_7_HI 0x0484 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_7_LO 0x0485 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_8 0x0486 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_8_HI 0x0486 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_8_LO 0x0487 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_9 0x0488 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_9_HI 0x0488 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_9_LO 0x0489 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_10 0x048A +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_10_HI 0x048A +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_10_LO 0x048B +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_11 0x048C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_11_HI 0x048C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_11_LO 0x048D +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_12 0x048E +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_12_HI 0x048E +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_12_LO 0x048F +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_13 0x0490 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_13_HI 0x0490 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_13_LO 0x0491 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_14 0x0492 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_14_HI 0x0492 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_14_LO 0x0493 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_15 0x0494 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_15_HI 0x0494 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__OFFSET_15_LO 0x0495 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_0 0x0496 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_0_HI 0x0496 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_0_LO 0x0497 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_1 0x0498 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_1_HI 0x0498 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_1_LO 0x0499 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_2 0x049A +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_2_HI 0x049A +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_2_LO 0x049B +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_3 0x049C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_3_HI 0x049C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_3_LO 0x049D +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_4 0x049E +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_4_HI 0x049E +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_4_LO 0x049F +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_5 0x04A0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_5_HI 0x04A0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_5_LO 0x04A1 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_6 0x04A2 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_6_HI 0x04A2 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_6_LO 0x04A3 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_7 0x04A4 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_7_HI 0x04A4 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_7_LO 0x04A5 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_8 0x04A6 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_8_HI 0x04A6 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_8_LO 0x04A7 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_9 0x04A8 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_9_HI 0x04A8 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_9_LO 0x04A9 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_10 0x04AA +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_10_HI 0x04AA +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_10_LO 0x04AB +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_11 0x04AC +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_11_HI 0x04AC +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_11_LO 0x04AD +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_12 0x04AE +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_12_HI 0x04AE +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_12_LO 0x04AF +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_13 0x04B0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_13_HI 0x04B0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_13_LO 0x04B1 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_14 0x04B2 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_14_HI 0x04B2 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_14_LO 0x04B3 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_15 0x04B4 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_15_HI 0x04B4 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PATCH__ADDRESS_15_LO 0x04B5 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SPI_ASYNC_MUX__CTRL 0x04C0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_CLK__CONFIG 0x04C4 +/*!< + type: uint8_t \n + default: 0x01 \n + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 + + groups: \n + [''] + + fields: \n + - [0] = clk_mcu_en +*/ +#define VL53L1X_GPIO_LV_MUX__CTRL 0x04CC +/*!< + type: uint8_t \n + default: 0x08 \n + info: \n + - msb = 4 + - lsb = 0 + - i2c_size = 1 + + groups: \n + [''] + + fields: \n + - [3:0] = gpio__mux_select_lv + - [4] = gpio__mux_active_high_lv +*/ +#define VL53L1X_GPIO_LV_PAD__CTRL 0x04CD +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 + + groups: \n + [''] + + fields: \n + - [0] = gpio__extsup_lv +*/ +#define VL53L1X_PAD_I2C_LV__CONFIG 0x04D0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PAD_STARTUP_MODE__VALUE_RO_GO1 0x04D4 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 + + groups: \n + [''] + + fields: \n + - [0] = pad_spi_csn_val_ro +*/ +#define VL53L1X_HOST_IF__STATUS_GO1 0x04D5 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 + + groups: \n + [''] + + fields: \n + - [0] = host_interface_lv +*/ +#define VL53L1X_MCU_CLK_GATING__CTRL 0x04D8 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 3 + - lsb = 0 + - i2c_size = 1 + + groups: \n + [''] + + fields: \n + - [0] = clk_gate_en__go1_mcu_bank + - [1] = clk_gate_en__go1_mcu_patch_ctrl + - [2] = clk_gate_en__go1_mcu_timers + - [3] = clk_gate_en__go1_mcu_mult_div +*/ +#define VL53L1X_TEST__BIST_ROM_CTRL 0x04E0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TEST__BIST_ROM_RESULT 0x04E1 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TEST__BIST_ROM_MCU_SIG 0x04E2 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TEST__BIST_ROM_MCU_SIG_HI 0x04E2 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TEST__BIST_ROM_MCU_SIG_LO 0x04E3 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TEST__BIST_RAM_CTRL 0x04E4 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TEST__BIST_RAM_RESULT 0x04E5 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TEST__TMC 0x04E8 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TEST__PLL_BIST_MIN_THRESHOLD 0x04F0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TEST__PLL_BIST_MIN_THRESHOLD_HI 0x04F0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TEST__PLL_BIST_MIN_THRESHOLD_LO 0x04F1 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TEST__PLL_BIST_MAX_THRESHOLD 0x04F2 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TEST__PLL_BIST_MAX_THRESHOLD_HI 0x04F2 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TEST__PLL_BIST_MAX_THRESHOLD_LO 0x04F3 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TEST__PLL_BIST_COUNT_OUT 0x04F4 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TEST__PLL_BIST_COUNT_OUT_HI 0x04F4 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TEST__PLL_BIST_COUNT_OUT_LO 0x04F5 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TEST__PLL_BIST_GONOGO 0x04F6 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_TEST__PLL_BIST_CTRL 0x04F7 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__DEVICE_ID 0x0680 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__REVISION_ID 0x0681 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__CLK_CTRL1 0x0683 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__CLK_CTRL2 0x0684 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__WOI_1 0x0685 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__WOI_REF_1 0x0686 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__START_RANGING 0x0687 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__LOW_LIMIT_1 0x0690 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__HIGH_LIMIT_1 0x0691 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__LOW_LIMIT_REF_1 0x0692 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__HIGH_LIMIT_REF_1 0x0693 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__QUANTIFIER_1_MSB 0x0694 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__QUANTIFIER_1_LSB 0x0695 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__QUANTIFIER_REF_1_MSB 0x0696 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__QUANTIFIER_REF_1_LSB 0x0697 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__AMBIENT_OFFSET_1_MSB 0x0698 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__AMBIENT_OFFSET_1_LSB 0x0699 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__AMBIENT_OFFSET_REF_1_MSB 0x069A +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__AMBIENT_OFFSET_REF_1_LSB 0x069B +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__FILTER_STRENGTH_1 0x069C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__FILTER_STRENGTH_REF_1 0x069D +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__SIGNAL_EVENT_LIMIT_1_MSB 0x069E +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__SIGNAL_EVENT_LIMIT_1_LSB 0x069F +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__SIGNAL_EVENT_LIMIT_REF_1_MSB 0x06A0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__SIGNAL_EVENT_LIMIT_REF_1_LSB 0x06A1 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__TIMEOUT_OVERALL_PERIODS_MSB 0x06A4 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__TIMEOUT_OVERALL_PERIODS_LSB 0x06A5 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__INVERT_HW 0x06A6 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__FORCE_HW 0x06A7 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__STATIC_HW_VALUE 0x06A8 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__FORCE_CONTINUOUS_AMBIENT 0x06A9 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__TEST_PHASE_SELECT_TO_FILTER 0x06AA +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__TEST_PHASE_SELECT_TO_TIMING_GEN 0x06AB +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__INITIAL_PHASE_VALUE_1 0x06AC +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__INITIAL_PHASE_VALUE_REF_1 0x06AD +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__FORCE_UP_IN 0x06AE +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__FORCE_DN_IN 0x06AF +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__STATIC_UP_VALUE_1 0x06B0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__STATIC_UP_VALUE_REF_1 0x06B1 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__STATIC_DN_VALUE_1 0x06B2 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__STATIC_DN_VALUE_REF_1 0x06B3 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__MONITOR_UP_DN 0x06B4 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__INVERT_UP_DN 0x06B5 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__CPUMP_1 0x06B6 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__CPUMP_2 0x06B7 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__CPUMP_3 0x06B8 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__OSC_1 0x06B9 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__PLL_1 0x06BB +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__PLL_2 0x06BC +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__REFERENCE_1 0x06BD +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__REFERENCE_3 0x06BF +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__REFERENCE_4 0x06C0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__REFERENCE_5 0x06C1 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__REGAVDD1V2 0x06C3 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__CALIB_1 0x06C4 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__CALIB_2 0x06C5 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__CALIB_3 0x06C6 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__TST_MUX_SEL1 0x06C9 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__TST_MUX_SEL2 0x06CA +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__TST_MUX 0x06CB +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__GPIO_OUT_TESTMUX 0x06CC +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__CUSTOM_FE 0x06CD +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__CUSTOM_FE_2 0x06CE +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__SPAD_READOUT 0x06CF +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__SPAD_READOUT_1 0x06D0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__SPAD_READOUT_2 0x06D1 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__SPAD_PS 0x06D2 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__LASER_SAFETY_2 0x06D4 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__NVM_CTRL__MODE 0x0780 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__NVM_CTRL__PDN 0x0781 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__NVM_CTRL__PROGN 0x0782 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__NVM_CTRL__READN 0x0783 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__NVM_CTRL__PULSE_WIDTH_MSB 0x0784 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__NVM_CTRL__PULSE_WIDTH_LSB 0x0785 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__NVM_CTRL__HV_RISE_MSB 0x0786 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__NVM_CTRL__HV_RISE_LSB 0x0787 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__NVM_CTRL__HV_FALL_MSB 0x0788 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__NVM_CTRL__HV_FALL_LSB 0x0789 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__NVM_CTRL__TST 0x078A +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__NVM_CTRL__TESTREAD 0x078B +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__NVM_CTRL__DATAIN_MMM 0x078C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__NVM_CTRL__DATAIN_LMM 0x078D +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__NVM_CTRL__DATAIN_LLM 0x078E +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__NVM_CTRL__DATAIN_LLL 0x078F +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__NVM_CTRL__DATAOUT_MMM 0x0790 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__NVM_CTRL__DATAOUT_LMM 0x0791 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__NVM_CTRL__DATAOUT_LLM 0x0792 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__NVM_CTRL__DATAOUT_LLL 0x0793 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__NVM_CTRL__ADDR 0x0794 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__NVM_CTRL__DATAOUT_ECC 0x0795 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_0 0x0796 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_1 0x0797 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_2 0x0798 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_3 0x0799 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_4 0x079A +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_5 0x079B +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_6 0x079C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_7 0x079D +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_8 0x079E +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_9 0x079F +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_10 0x07A0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_11 0x07A1 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_12 0x07A2 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_13 0x07A3 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_14 0x07A4 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_15 0x07A5 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_16 0x07A6 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_17 0x07A7 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__SPAD_SHIFT_EN 0x07BA +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__SPAD_DISABLE_CTRL 0x07BB +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__SPAD_EN_SHIFT_OUT_DEBUG 0x07BC +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__SPI_MODE 0x07BD +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__GPIO_DIR 0x07BE +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__VCSEL_PERIOD 0x0880 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__VCSEL_START 0x0881 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__VCSEL_STOP 0x0882 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__VCSEL_1 0x0885 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__VCSEL_STATUS 0x088D +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__STATUS 0x0980 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__LASER_CONTINUITY_STATE 0x0981 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RANGE_1_MMM 0x0982 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RANGE_1_LMM 0x0983 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RANGE_1_LLM 0x0984 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RANGE_1_LLL 0x0985 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RANGE_REF_1_MMM 0x0986 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RANGE_REF_1_LMM 0x0987 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RANGE_REF_1_LLM 0x0988 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RANGE_REF_1_LLL 0x0989 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__AMBIENT_WINDOW_EVENTS_1_MMM 0x098A +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__AMBIENT_WINDOW_EVENTS_1_LMM 0x098B +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__AMBIENT_WINDOW_EVENTS_1_LLM 0x098C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__AMBIENT_WINDOW_EVENTS_1_LLL 0x098D +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RANGING_TOTAL_EVENTS_1_MMM 0x098E +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RANGING_TOTAL_EVENTS_1_LMM 0x098F +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RANGING_TOTAL_EVENTS_1_LLM 0x0990 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RANGING_TOTAL_EVENTS_1_LLL 0x0991 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__SIGNAL_TOTAL_EVENTS_1_MMM 0x0992 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__SIGNAL_TOTAL_EVENTS_1_LMM 0x0993 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__SIGNAL_TOTAL_EVENTS_1_LLM 0x0994 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__SIGNAL_TOTAL_EVENTS_1_LLL 0x0995 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__TOTAL_PERIODS_ELAPSED_1_MM 0x0996 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__TOTAL_PERIODS_ELAPSED_1_LM 0x0997 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__TOTAL_PERIODS_ELAPSED_1_LL 0x0998 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__AMBIENT_MISMATCH_MM 0x0999 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__AMBIENT_MISMATCH_LM 0x099A +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__AMBIENT_MISMATCH_LL 0x099B +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__AMBIENT_WINDOW_EVENTS_REF_1_MMM 0x099C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__AMBIENT_WINDOW_EVENTS_REF_1_LMM 0x099D +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__AMBIENT_WINDOW_EVENTS_REF_1_LLM 0x099E +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__AMBIENT_WINDOW_EVENTS_REF_1_LLL 0x099F +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RANGING_TOTAL_EVENTS_REF_1_MMM 0x09A0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RANGING_TOTAL_EVENTS_REF_1_LMM 0x09A1 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RANGING_TOTAL_EVENTS_REF_1_LLM 0x09A2 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RANGING_TOTAL_EVENTS_REF_1_LLL 0x09A3 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__SIGNAL_TOTAL_EVENTS_REF_1_MMM 0x09A4 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__SIGNAL_TOTAL_EVENTS_REF_1_LMM 0x09A5 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__SIGNAL_TOTAL_EVENTS_REF_1_LLM 0x09A6 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__SIGNAL_TOTAL_EVENTS_REF_1_LLL 0x09A7 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__TOTAL_PERIODS_ELAPSED_REF_1_MM 0x09A8 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__TOTAL_PERIODS_ELAPSED_REF_1_LM 0x09A9 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__TOTAL_PERIODS_ELAPSED_REF_1_LL 0x09AA +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__AMBIENT_MISMATCH_REF_MM 0x09AB +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__AMBIENT_MISMATCH_REF_LM 0x09AC +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__AMBIENT_MISMATCH_REF_LL 0x09AD +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__GPIO_CONFIG__A0 0x0A00 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RESET_CONTROL__A0 0x0A01 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__INTR_MANAGER__A0 0x0A02 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__POWER_FSM_TIME_OSC__A0 0x0A06 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__VCSEL_ATEST__A0 0x0A07 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__VCSEL_PERIOD_CLIPPED__A0 0x0A08 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__VCSEL_STOP_CLIPPED__A0 0x0A09 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__CALIB_2__A0 0x0A0A +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__STOP_CONDITION__A0 0x0A0B +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__STATUS_RESET__A0 0x0A0C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__READOUT_CFG__A0 0x0A0D +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__WINDOW_SETTING__A0 0x0A0E +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__VCSEL_DELAY__A0 0x0A1A +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__REFERENCE_2__A0 0x0A1B +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__REGAVDD1V2__A0 0x0A1D +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__TST_MUX__A0 0x0A1F +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__CUSTOM_FE_2__A0 0x0A20 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__SPAD_READOUT__A0 0x0A21 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__CPUMP_1__A0 0x0A22 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__SPARE_REGISTER__A0 0x0A23 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__VCSEL_CONT_STAGE5_BYPASS__A0 0x0A24 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_18 0x0A25 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_19 0x0A26 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_20 0x0A27 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_21 0x0A28 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_22 0x0A29 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_23 0x0A2A +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_24 0x0A2B +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_25 0x0A2C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_26 0x0A2D +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_27 0x0A2E +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_28 0x0A2F +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_29 0x0A30 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_30 0x0A31 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__RET_SPAD_EN_31 0x0A32 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__REF_SPAD_EN_0__EWOK 0x0A33 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__REF_SPAD_EN_1__EWOK 0x0A34 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__REF_SPAD_EN_2__EWOK 0x0A35 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__REF_SPAD_EN_3__EWOK 0x0A36 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__REF_SPAD_EN_4__EWOK 0x0A37 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__REF_SPAD_EN_5__EWOK 0x0A38 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__REF_EN_START_SELECT 0x0A39 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGING_CORE__REGDVDD1V2_ATEST__EWOK 0x0A41 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SOFT_RESET_GO1 0x0B00 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PRIVATE__PATCH_BASE_ADDR_RSLV 0x0E00 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__INTERRUPT_STATUS 0x0ED0 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 5 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['prev_shadow_system_results', 'results'] + + fields: \n + - [2:0] = prev_shadow_int_status + - [4:3] = prev_shadow_int_error_status + - [5] = prev_shadow_gph_id_gpio_status +*/ +#define VL53L1X_PREV_SHADOW_RESULT__RANGE_STATUS 0x0ED1 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['prev_shadow_system_results', 'results'] + + fields: \n + - [4:0] = prev_shadow_range_status + - [5] = prev_shadow_max_threshold_hit + - [6] = prev_shadow_min_threshold_hit + - [7] = prev_shadow_gph_id_range_status +*/ +#define VL53L1X_PREV_SHADOW_RESULT__REPORT_STATUS 0x0ED2 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 3 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['prev_shadow_system_results', 'results'] + + fields: \n + - [3:0] = prev_shadow_report_status +*/ +#define VL53L1X_PREV_SHADOW_RESULT__STREAM_COUNT 0x0ED3 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['prev_shadow_system_results', 'results'] + + fields: \n + - [7:0] = prev_shadow_result__stream_count +*/ +#define VL53L1X_PREV_SHADOW_RESULT__DSS_ACTUAL_EFFECTIVE_SPADS_SD0 0x0ED4 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['prev_shadow_system_results', 'results'] + + fields: \n + - [15:0] = prev_shadow_result__dss_actual_effective_spads_sd0 (fixed point 8.8) +*/ +#define VL53L1X_PREV_SHADOW_RESULT__DSS_ACTUAL_EFFECTIVE_SPADS_SD0_HI 0x0ED4 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__DSS_ACTUAL_EFFECTIVE_SPADS_SD0_LO 0x0ED5 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__PEAK_SIGNAL_COUNT_RATE_MCPS_SD0 0x0ED6 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['prev_shadow_system_results', 'results'] + + fields: \n + - [15:0] = prev_shadow_result__peak_signal_count_rate_mcps_sd0 (fixed point 9.7) +*/ +#define VL53L1X_PREV_SHADOW_RESULT__PEAK_SIGNAL_COUNT_RATE_MCPS_SD0_HI 0x0ED6 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__PEAK_SIGNAL_COUNT_RATE_MCPS_SD0_LO 0x0ED7 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__AMBIENT_COUNT_RATE_MCPS_SD0 0x0ED8 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['prev_shadow_system_results', 'results'] + + fields: \n + - [15:0] = prev_shadow_result__ambient_count_rate_mcps_sd0 (fixed point 9.7) +*/ +#define VL53L1X_PREV_SHADOW_RESULT__AMBIENT_COUNT_RATE_MCPS_SD0_HI 0x0ED8 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__AMBIENT_COUNT_RATE_MCPS_SD0_LO 0x0ED9 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__SIGMA_SD0 0x0EDA +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['prev_shadow_system_results', 'results'] + + fields: \n + - [15:0] = prev_shadow_result__sigma_sd0 (fixed point 14.2) +*/ +#define VL53L1X_PREV_SHADOW_RESULT__SIGMA_SD0_HI 0x0EDA +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__SIGMA_SD0_LO 0x0EDB +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__PHASE_SD0 0x0EDC +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['prev_shadow_system_results', 'results'] + + fields: \n + - [15:0] = prev_shadow_result__phase_sd0 (fixed point 5.11) +*/ +#define VL53L1X_PREV_SHADOW_RESULT__PHASE_SD0_HI 0x0EDC +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__PHASE_SD0_LO 0x0EDD +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__FINAL_CROSSTALK_CORRECTED_RANGE_MM_SD0 0x0EDE +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['prev_shadow_system_results', 'results'] + + fields: \n + - [15:0] = prev_shadow_result__final_crosstalk_corrected_range_mm_sd0 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__FINAL_CROSSTALK_CORRECTED_RANGE_MM_SD0_HI 0x0EDE +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__FINAL_CROSSTALK_CORRECTED_RANGE_MM_SD0_LO 0x0EDF +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__PEAK_SIGNAL_COUNT_RATE_CROSSTALK_CORRECTED_MCPS_SD0 0x0EE0 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['prev_shadow_system_results', 'results'] + + fields: \n + - [15:0] = prev_shadow_result__peak_signal_count_rate_crosstalk_corrected_mcps_sd0 (fixed point 9.7) +*/ +#define VL53L1X_PREV_SHADOW_RESULT__PEAK_SIGNAL_COUNT_RATE_CROSSTALK_CORRECTED_MCPS_SD0_HI 0x0EE0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__PEAK_SIGNAL_COUNT_RATE_CROSSTALK_CORRECTED_MCPS_SD0_LO 0x0EE1 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__MM_INNER_ACTUAL_EFFECTIVE_SPADS_SD0 0x0EE2 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['prev_shadow_system_results', 'results'] + + fields: \n + - [15:0] = prev_shadow_result__mm_inner_actual_effective_spads_sd0 (fixed point 8.8) +*/ +#define VL53L1X_PREV_SHADOW_RESULT__MM_INNER_ACTUAL_EFFECTIVE_SPADS_SD0_HI 0x0EE2 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__MM_INNER_ACTUAL_EFFECTIVE_SPADS_SD0_LO 0x0EE3 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__MM_OUTER_ACTUAL_EFFECTIVE_SPADS_SD0 0x0EE4 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['prev_shadow_system_results', 'results'] + + fields: \n + - [15:0] = prev_shadow_result__mm_outer_actual_effective_spads_sd0 (fixed point 8.8) +*/ +#define VL53L1X_PREV_SHADOW_RESULT__MM_OUTER_ACTUAL_EFFECTIVE_SPADS_SD0_HI 0x0EE4 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__MM_OUTER_ACTUAL_EFFECTIVE_SPADS_SD0_LO 0x0EE5 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__AVG_SIGNAL_COUNT_RATE_MCPS_SD0 0x0EE6 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['prev_shadow_system_results', 'results'] + + fields: \n + - [15:0] = prev_shadow_result__avg_signal_count_rate_mcps_sd0 (fixed point 9.7) +*/ +#define VL53L1X_PREV_SHADOW_RESULT__AVG_SIGNAL_COUNT_RATE_MCPS_SD0_HI 0x0EE6 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__AVG_SIGNAL_COUNT_RATE_MCPS_SD0_LO 0x0EE7 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__DSS_ACTUAL_EFFECTIVE_SPADS_SD1 0x0EE8 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['prev_shadow_system_results', 'results'] + + fields: \n + - [15:0] = prev_shadow_result__dss_actual_effective_spads_sd1 (fixed point 8.8) +*/ +#define VL53L1X_PREV_SHADOW_RESULT__DSS_ACTUAL_EFFECTIVE_SPADS_SD1_HI 0x0EE8 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__DSS_ACTUAL_EFFECTIVE_SPADS_SD1_LO 0x0EE9 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__PEAK_SIGNAL_COUNT_RATE_MCPS_SD1 0x0EEA +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['prev_shadow_system_results', 'results'] + + fields: \n + - [15:0] = prev_shadow_result__peak_signal_count_rate_mcps_sd1 (fixed point 9.7) +*/ +#define VL53L1X_PREV_SHADOW_RESULT__PEAK_SIGNAL_COUNT_RATE_MCPS_SD1_HI 0x0EEA +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__PEAK_SIGNAL_COUNT_RATE_MCPS_SD1_LO 0x0EEB +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__AMBIENT_COUNT_RATE_MCPS_SD1 0x0EEC +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['prev_shadow_system_results', 'results'] + + fields: \n + - [15:0] = prev_shadow_result__ambient_count_rate_mcps_sd1 (fixed point 9.7) +*/ +#define VL53L1X_PREV_SHADOW_RESULT__AMBIENT_COUNT_RATE_MCPS_SD1_HI 0x0EEC +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__AMBIENT_COUNT_RATE_MCPS_SD1_LO 0x0EED +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__SIGMA_SD1 0x0EEE +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['prev_shadow_system_results', 'results'] + + fields: \n + - [15:0] = prev_shadow_result__sigma_sd1 (fixed point 14.2) +*/ +#define VL53L1X_PREV_SHADOW_RESULT__SIGMA_SD1_HI 0x0EEE +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__SIGMA_SD1_LO 0x0EEF +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__PHASE_SD1 0x0EF0 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['prev_shadow_system_results', 'results'] + + fields: \n + - [15:0] = prev_shadow_result__phase_sd1 (fixed point 5.11) +*/ +#define VL53L1X_PREV_SHADOW_RESULT__PHASE_SD1_HI 0x0EF0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__PHASE_SD1_LO 0x0EF1 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__FINAL_CROSSTALK_CORRECTED_RANGE_MM_SD1 0x0EF2 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['prev_shadow_system_results', 'results'] + + fields: \n + - [15:0] = prev_shadow_result__final_crosstalk_corrected_range_mm_sd1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__FINAL_CROSSTALK_CORRECTED_RANGE_MM_SD1_HI 0x0EF2 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__FINAL_CROSSTALK_CORRECTED_RANGE_MM_SD1_LO 0x0EF3 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__SPARE_0_SD1 0x0EF4 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['prev_shadow_system_results', 'results'] + + fields: \n + - [15:0] = prev_shadow_result__spare_0_sd1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__SPARE_0_SD1_HI 0x0EF4 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__SPARE_0_SD1_LO 0x0EF5 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__SPARE_1_SD1 0x0EF6 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['prev_shadow_system_results', 'results'] + + fields: \n + - [15:0] = prev_shadow_result__spare_1_sd1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__SPARE_1_SD1_HI 0x0EF6 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__SPARE_1_SD1_LO 0x0EF7 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__SPARE_2_SD1 0x0EF8 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['prev_shadow_system_results', 'results'] + + fields: \n + - [15:0] = prev_shadow_result__spare_2_sd1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__SPARE_2_SD1_HI 0x0EF8 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__SPARE_2_SD1_LO 0x0EF9 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__SPARE_3_SD1 0x0EFA +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['prev_shadow_system_results', 'results'] + + fields: \n + - [15:0] = prev_shadow_result__spare_3_sd1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__SPARE_3_SD1_HI 0x0EFA +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT__SPARE_3_SD1_LO 0x0EFB +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD0 0x0EFC +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['prev_shadow_core_results', 'ranging_core_results'] + + fields: \n + - [31:0] = prev_shadow_result_core__ambient_window_events_sd0 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD0_3 0x0EFC +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD0_2 0x0EFD +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD0_1 0x0EFE +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD0_0 0x0EFF +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__RANGING_TOTAL_EVENTS_SD0 0x0F00 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['prev_shadow_core_results', 'ranging_core_results'] + + fields: \n + - [31:0] = prev_shadow_result_core__ranging_total_events_sd0 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__RANGING_TOTAL_EVENTS_SD0_3 0x0F00 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__RANGING_TOTAL_EVENTS_SD0_2 0x0F01 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__RANGING_TOTAL_EVENTS_SD0_1 0x0F02 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__RANGING_TOTAL_EVENTS_SD0_0 0x0F03 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD0 0x0F04 +/*!< + type: int32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['prev_shadow_core_results', 'ranging_core_results'] + + fields: \n + - [31:0] = prev_shadow_result_core__signal_total_events_sd0 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD0_3 0x0F04 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD0_2 0x0F05 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD0_1 0x0F06 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD0_0 0x0F07 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD0 0x0F08 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['prev_shadow_core_results', 'ranging_core_results'] + + fields: \n + - [31:0] = prev_shadow_result_core__total_periods_elapsed_sd0 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD0_3 0x0F08 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD0_2 0x0F09 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD0_1 0x0F0A +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD0_0 0x0F0B +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD1 0x0F0C +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['prev_shadow_core_results', 'ranging_core_results'] + + fields: \n + - [31:0] = prev_shadow_result_core__ambient_window_events_sd1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD1_3 0x0F0C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD1_2 0x0F0D +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD1_1 0x0F0E +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD1_0 0x0F0F +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__RANGING_TOTAL_EVENTS_SD1 0x0F10 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['prev_shadow_core_results', 'ranging_core_results'] + + fields: \n + - [31:0] = prev_shadow_result_core__ranging_total_events_sd1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__RANGING_TOTAL_EVENTS_SD1_3 0x0F10 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__RANGING_TOTAL_EVENTS_SD1_2 0x0F11 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__RANGING_TOTAL_EVENTS_SD1_1 0x0F12 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__RANGING_TOTAL_EVENTS_SD1_0 0x0F13 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD1 0x0F14 +/*!< + type: int32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['prev_shadow_core_results', 'ranging_core_results'] + + fields: \n + - [31:0] = prev_shadow_result_core__signal_total_events_sd1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD1_3 0x0F14 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD1_2 0x0F15 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD1_1 0x0F16 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD1_0 0x0F17 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD1 0x0F18 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['prev_shadow_core_results', 'ranging_core_results'] + + fields: \n + - [31:0] = prev_shadow_result_core__total_periods_elapsed_sd1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD1_3 0x0F18 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD1_2 0x0F19 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD1_1 0x0F1A +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD1_0 0x0F1B +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PREV_SHADOW_RESULT_CORE__SPARE_0 0x0F1C +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['prev_shadow_core_results', 'ranging_core_results'] + + fields: \n + - [7:0] = prev_shadow_result_core__spare_0 +*/ +#define VL53L1X_RESULT__DEBUG_STATUS 0x0F20 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_debug', 'misc_results'] + + fields: \n + - [7:0] = result_debug_status +*/ +#define VL53L1X_RESULT__DEBUG_STAGE 0x0F21 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_debug', 'misc_results'] + + fields: \n + - [7:0] = result_debug_stage +*/ +#define VL53L1X_GPH__SYSTEM__THRESH_RATE_HIGH 0x0F24 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['gph_general_config', 'dss_config'] + + fields: \n + - [15:0] = gph__system_thresh_rate_high (fixed point 9.7) +*/ +#define VL53L1X_GPH__SYSTEM__THRESH_RATE_HIGH_HI 0x0F24 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_GPH__SYSTEM__THRESH_RATE_HIGH_LO 0x0F25 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_GPH__SYSTEM__THRESH_RATE_LOW 0x0F26 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['gph_general_config', 'dss_config'] + + fields: \n + - [15:0] = gph__system_thresh_rate_low (fixed point 9.7) +*/ +#define VL53L1X_GPH__SYSTEM__THRESH_RATE_LOW_HI 0x0F26 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_GPH__SYSTEM__THRESH_RATE_LOW_LO 0x0F27 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_GPH__SYSTEM__INTERRUPT_CONFIG_GPIO 0x0F28 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['gph_general_config', 'gph_config'] + + fields: \n + - [1:0] = gph__int_mode_distance + - [3:2] = gph__int_mode_rate + - [4] = gph__int_spare + - [5] = gph__int_new_measure_ready + - [6] = gph__int_no_target_en + - [7] = gph__int_combined_mode +*/ +#define VL53L1X_GPH__DSS_CONFIG__ROI_MODE_CONTROL 0x0F2F +/*!< + type: uint8_t \n + default: 0x01 \n + info: \n + - msb = 2 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['gph_static_config', 'dss_config'] + + fields: \n + - [1:0] = gph__dss_config__input_mode + - [2] = gph__calculate_roi_enable +*/ +#define VL53L1X_GPH__DSS_CONFIG__MANUAL_EFFECTIVE_SPADS_SELECT 0x0F30 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['gph_static_config', 'dss_config'] + + fields: \n + - [15:0] = gph__dss_config__manual_effective_spads_select +*/ +#define VL53L1X_GPH__DSS_CONFIG__MANUAL_EFFECTIVE_SPADS_SELECT_HI 0x0F30 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_GPH__DSS_CONFIG__MANUAL_EFFECTIVE_SPADS_SELECT_LO 0x0F31 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_GPH__DSS_CONFIG__MANUAL_BLOCK_SELECT 0x0F32 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['gph_static_config', 'dss_config'] + + fields: \n + - [7:0] = gph__dss_config__manual_block_select +*/ +#define VL53L1X_GPH__DSS_CONFIG__MAX_SPADS_LIMIT 0x0F33 +/*!< + type: uint8_t \n + default: 0xFF \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['gph_static_config', 'dss_config'] + + fields: \n + - [7:0] = gph__dss_config__max_spads_limit +*/ +#define VL53L1X_GPH__DSS_CONFIG__MIN_SPADS_LIMIT 0x0F34 +/*!< + type: uint8_t \n + default: 0x01 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['gph_static_config', 'dss_config'] + + fields: \n + - [7:0] = gph__dss_config__min_spads_limit +*/ +#define VL53L1X_GPH__MM_CONFIG__TIMEOUT_MACROP_A_HI 0x0F36 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 3 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['gph_timing_config', 'mm_config'] + + fields: \n + - [3:0] = gph_mm_config__config_timeout_macrop_a_hi +*/ +#define VL53L1X_GPH__MM_CONFIG__TIMEOUT_MACROP_A_LO 0x0F37 +/*!< + type: uint8_t \n + default: 0x06 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['gph_timing_config', 'mm_config'] + + fields: \n + - [7:0] = gph_mm_config__config_timeout_macrop_a_lo +*/ +#define VL53L1X_GPH__MM_CONFIG__TIMEOUT_MACROP_B_HI 0x0F38 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 3 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['gph_timing_config', 'mm_config'] + + fields: \n + - [3:0] = gph_mm_config__config_timeout_macrop_b_hi +*/ +#define VL53L1X_GPH__MM_CONFIG__TIMEOUT_MACROP_B_LO 0x0F39 +/*!< + type: uint8_t \n + default: 0x06 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['gph_timing_config', 'mm_config'] + + fields: \n + - [7:0] = gph_mm_config__config_timeout_macrop_b_lo +*/ +#define VL53L1X_GPH__RANGE_CONFIG__TIMEOUT_MACROP_A_HI 0x0F3A +/*!< + type: uint8_t \n + default: 0x01 \n + info: \n + - msb = 3 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['gph_timing_config', 'range_config'] + + fields: \n + - [3:0] = gph_range_timeout_overall_periods_macrop_a_hi +*/ +#define VL53L1X_GPH__RANGE_CONFIG__TIMEOUT_MACROP_A_LO 0x0F3B +/*!< + type: uint8_t \n + default: 0x92 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['gph_timing_config', 'range_config'] + + fields: \n + - [7:0] = gph_range_timeout_overall_periods_macrop_a_lo +*/ +#define VL53L1X_GPH__RANGE_CONFIG__VCSEL_PERIOD_A 0x0F3C +/*!< + type: uint8_t \n + default: 0x0B \n + info: \n + - msb = 5 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['gph_timing_config', 'range_config'] + + fields: \n + - [5:0] = gph_range_config__vcsel_period_a +*/ +#define VL53L1X_GPH__RANGE_CONFIG__VCSEL_PERIOD_B 0x0F3D +/*!< + type: uint8_t \n + default: 0x09 \n + info: \n + - msb = 5 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['gph_timing_config', 'range_config'] + + fields: \n + - [5:0] = gph_range_config__vcsel_period_b +*/ +#define VL53L1X_GPH__RANGE_CONFIG__TIMEOUT_MACROP_B_HI 0x0F3E +/*!< + type: uint8_t \n + default: 0x01 \n + info: \n + - msb = 3 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['gph_timing_config', 'range_config'] + + fields: \n + - [3:0] = gph_range_timeout_overall_periods_macrop_b_hi +*/ +#define VL53L1X_GPH__RANGE_CONFIG__TIMEOUT_MACROP_B_LO 0x0F3F +/*!< + type: uint8_t \n + default: 0x92 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['gph_timing_config', 'range_config'] + + fields: \n + - [7:0] = gph_range_timeout_overall_periods_macrop_b_lo +*/ +#define VL53L1X_GPH__RANGE_CONFIG__SIGMA_THRESH 0x0F40 +/*!< + type: uint16_t \n + default: 0x0080 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['gph_timing_config', 'range_config'] + + fields: \n + - [15:0] = gph_range_config__sigma_thresh (fixed point 14.2) +*/ +#define VL53L1X_GPH__RANGE_CONFIG__SIGMA_THRESH_HI 0x0F40 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_GPH__RANGE_CONFIG__SIGMA_THRESH_LO 0x0F41 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_GPH__RANGE_CONFIG__MIN_COUNT_RATE_RTN_LIMIT_MCPS 0x0F42 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['gph_timing_config', 'range_config'] + + fields: \n + - [15:0] = gph_range_config__min_count_rate_rtn_limit_mcps (fixed point 9.7) +*/ +#define VL53L1X_GPH__RANGE_CONFIG__MIN_COUNT_RATE_RTN_LIMIT_MCPS_HI 0x0F42 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_GPH__RANGE_CONFIG__MIN_COUNT_RATE_RTN_LIMIT_MCPS_LO 0x0F43 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_GPH__RANGE_CONFIG__VALID_PHASE_LOW 0x0F44 +/*!< + type: uint8_t \n + default: 0x08 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['gph_timing_config', 'range_config'] + + fields: \n + - [7:0] = gph_range_config__valid_phase_low (fixed point 5.3) +*/ +#define VL53L1X_GPH__RANGE_CONFIG__VALID_PHASE_HIGH 0x0F45 +/*!< + type: uint8_t \n + default: 0x80 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['gph_timing_config', 'range_config'] + + fields: \n + - [7:0] = gph_range_config__valid_phase_high (fixed point 5.3) +*/ +#define VL53L1X_FIRMWARE__INTERNAL_STREAM_COUNT_DIV 0x0F46 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['fw_internal'] + + fields: \n + - [7:0] = fw__internal_stream_count_div +*/ +#define VL53L1X_FIRMWARE__INTERNAL_STREAM_COUNTER_VAL 0x0F47 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['fw_internal'] + + fields: \n + - [7:0] = fw__internal_stream_counter_val +*/ +#define VL53L1X_DSS_CALC__ROI_CTRL 0x0F54 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 1 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [0] = dss_calc__roi_intersect_enable + - [1] = dss_calc__roi_subtract_enable +*/ +#define VL53L1X_DSS_CALC__SPARE_1 0x0F55 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__spare_1 +*/ +#define VL53L1X_DSS_CALC__SPARE_2 0x0F56 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__spare_2 +*/ +#define VL53L1X_DSS_CALC__SPARE_3 0x0F57 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__spare_3 +*/ +#define VL53L1X_DSS_CALC__SPARE_4 0x0F58 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__spare_4 +*/ +#define VL53L1X_DSS_CALC__SPARE_5 0x0F59 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__spare_5 +*/ +#define VL53L1X_DSS_CALC__SPARE_6 0x0F5A +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__spare_6 +*/ +#define VL53L1X_DSS_CALC__SPARE_7 0x0F5B +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__spare_7 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_0 0x0F5C +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_0 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_1 0x0F5D +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_1 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_2 0x0F5E +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_2 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_3 0x0F5F +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_3 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_4 0x0F60 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_4 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_5 0x0F61 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_5 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_6 0x0F62 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_6 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_7 0x0F63 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_7 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_8 0x0F64 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_8 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_9 0x0F65 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_9 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_10 0x0F66 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_10 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_11 0x0F67 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_11 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_12 0x0F68 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_12 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_13 0x0F69 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_13 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_14 0x0F6A +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_14 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_15 0x0F6B +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_15 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_16 0x0F6C +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_16 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_17 0x0F6D +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_17 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_18 0x0F6E +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_18 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_19 0x0F6F +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_19 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_20 0x0F70 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_20 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_21 0x0F71 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_21 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_22 0x0F72 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_22 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_23 0x0F73 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_23 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_24 0x0F74 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_24 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_25 0x0F75 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_25 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_26 0x0F76 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_26 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_27 0x0F77 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_27 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_28 0x0F78 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_28 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_29 0x0F79 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_29 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_30 0x0F7A +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_30 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_SPAD_EN_31 0x0F7B +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_spad_en_31 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_0 0x0F7C +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_0 +*/ +#define VL53L1X_DSS_CALC__USER_ROI_1 0x0F7D +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__user_roi_1 +*/ +#define VL53L1X_DSS_CALC__MODE_ROI_0 0x0F7E +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__mode_roi_0 +*/ +#define VL53L1X_DSS_CALC__MODE_ROI_1 0x0F7F +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_calc'] + + fields: \n + - [7:0] = dss_calc__mode_roi_1 +*/ +#define VL53L1X_SIGMA_ESTIMATOR_CALC__SPARE_0 0x0F80 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'sigma_est_spare'] + + fields: \n + - [7:0] = sigma_estimator_calc__spare_0 +*/ +#define VL53L1X_VHV_RESULT__PEAK_SIGNAL_RATE_MCPS 0x0F82 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['patch_results', 'vhv_results'] + + fields: \n + - [15:0] = vhv_result__peak_signal_rate_mcps +*/ +#define VL53L1X_VHV_RESULT__PEAK_SIGNAL_RATE_MCPS_HI 0x0F82 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_VHV_RESULT__PEAK_SIGNAL_RATE_MCPS_LO 0x0F83 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_VHV_RESULT__SIGNAL_TOTAL_EVENTS_REF 0x0F84 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['patch_results', 'vhv_results'] + + fields: \n + - [31:0] = vhv_result__signal_total_events_ref +*/ +#define VL53L1X_VHV_RESULT__SIGNAL_TOTAL_EVENTS_REF_3 0x0F84 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_VHV_RESULT__SIGNAL_TOTAL_EVENTS_REF_2 0x0F85 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_VHV_RESULT__SIGNAL_TOTAL_EVENTS_REF_1 0x0F86 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_VHV_RESULT__SIGNAL_TOTAL_EVENTS_REF_0 0x0F87 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PHASECAL_RESULT__PHASE_OUTPUT_REF 0x0F88 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['patch_results', 'phasecal_results'] + + fields: \n + - [15:0] = phasecal_result__normalised_phase_ref +*/ +#define VL53L1X_PHASECAL_RESULT__PHASE_OUTPUT_REF_HI 0x0F88 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_PHASECAL_RESULT__PHASE_OUTPUT_REF_LO 0x0F89 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_DSS_RESULT__TOTAL_RATE_PER_SPAD 0x0F8A +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['patch_results', 'dss_results'] + + fields: \n + - [15:0] = dss_result__total_rate_per_spad +*/ +#define VL53L1X_DSS_RESULT__TOTAL_RATE_PER_SPAD_HI 0x0F8A +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_DSS_RESULT__TOTAL_RATE_PER_SPAD_LO 0x0F8B +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_DSS_RESULT__ENABLED_BLOCKS 0x0F8C +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['patch_results', 'dss_results'] + + fields: \n + - [7:0] = dss_result__enabled_blocks +*/ +#define VL53L1X_DSS_RESULT__NUM_REQUESTED_SPADS 0x0F8E +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['patch_results', 'dss_results'] + + fields: \n + - [15:0] = dss_result__num_requested_spads (fixed point 8.8) +*/ +#define VL53L1X_DSS_RESULT__NUM_REQUESTED_SPADS_HI 0x0F8E +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_DSS_RESULT__NUM_REQUESTED_SPADS_LO 0x0F8F +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MM_RESULT__INNER_INTERSECTION_RATE 0x0F92 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['patch_results', 'mm_results'] + + fields: \n + - [15:0] = mm_result__inner_intersection_rate +*/ +#define VL53L1X_MM_RESULT__INNER_INTERSECTION_RATE_HI 0x0F92 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MM_RESULT__INNER_INTERSECTION_RATE_LO 0x0F93 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MM_RESULT__OUTER_COMPLEMENT_RATE 0x0F94 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['patch_results', 'mm_results'] + + fields: \n + - [15:0] = mm_result__outer_complement_rate +*/ +#define VL53L1X_MM_RESULT__OUTER_COMPLEMENT_RATE_HI 0x0F94 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MM_RESULT__OUTER_COMPLEMENT_RATE_LO 0x0F95 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MM_RESULT__TOTAL_OFFSET 0x0F96 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['patch_results', 'mm_results'] + + fields: \n + - [15:0] = mm_result__total_offset +*/ +#define VL53L1X_MM_RESULT__TOTAL_OFFSET_HI 0x0F96 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_MM_RESULT__TOTAL_OFFSET_LO 0x0F97 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_XTALK_CALC__XTALK_FOR_ENABLED_SPADS 0x0F98 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 23 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['patch_results', 'xtalk_calc'] + + fields: \n + - [23:0] = xtalk_calc__xtalk_for_enabled_spads (fixed point 11.13) +*/ +#define VL53L1X_XTALK_CALC__XTALK_FOR_ENABLED_SPADS_3 0x0F98 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_XTALK_CALC__XTALK_FOR_ENABLED_SPADS_2 0x0F99 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_XTALK_CALC__XTALK_FOR_ENABLED_SPADS_1 0x0F9A +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_XTALK_CALC__XTALK_FOR_ENABLED_SPADS_0 0x0F9B +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_XTALK_RESULT__AVG_XTALK_USER_ROI_KCPS 0x0F9C +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 23 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['patch_results', 'xtalk_results'] + + fields: \n + - [23:0] = xtalk_result__avg_xtalk_user_roi_kcps (fixed point 11.13) +*/ +#define VL53L1X_XTALK_RESULT__AVG_XTALK_USER_ROI_KCPS_3 0x0F9C +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_XTALK_RESULT__AVG_XTALK_USER_ROI_KCPS_2 0x0F9D +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_XTALK_RESULT__AVG_XTALK_USER_ROI_KCPS_1 0x0F9E +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_XTALK_RESULT__AVG_XTALK_USER_ROI_KCPS_0 0x0F9F +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_XTALK_RESULT__AVG_XTALK_MM_INNER_ROI_KCPS 0x0FA0 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 23 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['patch_results', 'xtalk_results'] + + fields: \n + - [23:0] = xtalk_result__avg_xtalk_mm_inner_roi_kcps (fixed point 11.13) +*/ +#define VL53L1X_XTALK_RESULT__AVG_XTALK_MM_INNER_ROI_KCPS_3 0x0FA0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_XTALK_RESULT__AVG_XTALK_MM_INNER_ROI_KCPS_2 0x0FA1 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_XTALK_RESULT__AVG_XTALK_MM_INNER_ROI_KCPS_1 0x0FA2 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_XTALK_RESULT__AVG_XTALK_MM_INNER_ROI_KCPS_0 0x0FA3 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_XTALK_RESULT__AVG_XTALK_MM_OUTER_ROI_KCPS 0x0FA4 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 23 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['patch_results', 'xtalk_results'] + + fields: \n + - [23:0] = xtalk_result__avg_xtalk_mm_outer_roi_kcps (fixed point 11.13) +*/ +#define VL53L1X_XTALK_RESULT__AVG_XTALK_MM_OUTER_ROI_KCPS_3 0x0FA4 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_XTALK_RESULT__AVG_XTALK_MM_OUTER_ROI_KCPS_2 0x0FA5 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_XTALK_RESULT__AVG_XTALK_MM_OUTER_ROI_KCPS_1 0x0FA6 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_XTALK_RESULT__AVG_XTALK_MM_OUTER_ROI_KCPS_0 0x0FA7 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGE_RESULT__ACCUM_PHASE 0x0FA8 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['patch_results', 'range_results'] + + fields: \n + - [31:0] = range_result__accum_phase +*/ +#define VL53L1X_RANGE_RESULT__ACCUM_PHASE_3 0x0FA8 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGE_RESULT__ACCUM_PHASE_2 0x0FA9 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGE_RESULT__ACCUM_PHASE_1 0x0FAA +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGE_RESULT__ACCUM_PHASE_0 0x0FAB +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGE_RESULT__OFFSET_CORRECTED_RANGE 0x0FAC +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['patch_results', 'range_results'] + + fields: \n + - [15:0] = range_result__offset_corrected_range +*/ +#define VL53L1X_RANGE_RESULT__OFFSET_CORRECTED_RANGE_HI 0x0FAC +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_RANGE_RESULT__OFFSET_CORRECTED_RANGE_LO 0x0FAD +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_PHASECAL_RESULT__VCSEL_START 0x0FAE +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['shadow_system_results', 'histogram_results'] + + fields: \n + - [7:0] = shadow_phasecal_result__vcsel_start +*/ +#define VL53L1X_SHADOW_RESULT__INTERRUPT_STATUS 0x0FB0 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 5 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['shadow_system_results', 'results'] + + fields: \n + - [2:0] = shadow_int_status + - [4:3] = shadow_int_error_status + - [5] = shadow_gph_id_gpio_status +*/ +#define VL53L1X_SHADOW_RESULT__RANGE_STATUS 0x0FB1 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['shadow_system_results', 'results'] + + fields: \n + - [4:0] = shadow_range_status + - [5] = shadow_max_threshold_hit + - [6] = shadow_min_threshold_hit + - [7] = shadow_gph_id_range_status +*/ +#define VL53L1X_SHADOW_RESULT__REPORT_STATUS 0x0FB2 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 3 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['shadow_system_results', 'results'] + + fields: \n + - [3:0] = shadow_report_status +*/ +#define VL53L1X_SHADOW_RESULT__STREAM_COUNT 0x0FB3 +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['shadow_system_results', 'results'] + + fields: \n + - [7:0] = shadow_result__stream_count +*/ +#define VL53L1X_SHADOW_RESULT__DSS_ACTUAL_EFFECTIVE_SPADS_SD0 0x0FB4 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['shadow_system_results', 'results'] + + fields: \n + - [15:0] = shadow_result__dss_actual_effective_spads_sd0 (fixed point 8.8) +*/ +#define VL53L1X_SHADOW_RESULT__DSS_ACTUAL_EFFECTIVE_SPADS_SD0_HI 0x0FB4 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__DSS_ACTUAL_EFFECTIVE_SPADS_SD0_LO 0x0FB5 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__PEAK_SIGNAL_COUNT_RATE_MCPS_SD0 0x0FB6 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['shadow_system_results', 'results'] + + fields: \n + - [15:0] = shadow_result__peak_signal_count_rate_mcps_sd0 (fixed point 9.7) +*/ +#define VL53L1X_SHADOW_RESULT__PEAK_SIGNAL_COUNT_RATE_MCPS_SD0_HI 0x0FB6 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__PEAK_SIGNAL_COUNT_RATE_MCPS_SD0_LO 0x0FB7 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__AMBIENT_COUNT_RATE_MCPS_SD0 0x0FB8 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['shadow_system_results', 'results'] + + fields: \n + - [15:0] = shadow_result__ambient_count_rate_mcps_sd0 (fixed point 9.7) +*/ +#define VL53L1X_SHADOW_RESULT__AMBIENT_COUNT_RATE_MCPS_SD0_HI 0x0FB8 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__AMBIENT_COUNT_RATE_MCPS_SD0_LO 0x0FB9 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__SIGMA_SD0 0x0FBA +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['shadow_system_results', 'results'] + + fields: \n + - [15:0] = shadow_result__sigma_sd0 (fixed point 14.2) +*/ +#define VL53L1X_SHADOW_RESULT__SIGMA_SD0_HI 0x0FBA +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__SIGMA_SD0_LO 0x0FBB +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__PHASE_SD0 0x0FBC +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['shadow_system_results', 'results'] + + fields: \n + - [15:0] = shadow_result__phase_sd0 (fixed point 5.11) +*/ +#define VL53L1X_SHADOW_RESULT__PHASE_SD0_HI 0x0FBC +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__PHASE_SD0_LO 0x0FBD +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__FINAL_CROSSTALK_CORRECTED_RANGE_MM_SD0 0x0FBE +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['shadow_system_results', 'results'] + + fields: \n + - [15:0] = shadow_result__final_crosstalk_corrected_range_mm_sd0 +*/ +#define VL53L1X_SHADOW_RESULT__FINAL_CROSSTALK_CORRECTED_RANGE_MM_SD0_HI 0x0FBE +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__FINAL_CROSSTALK_CORRECTED_RANGE_MM_SD0_LO 0x0FBF +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__PEAK_SIGNAL_COUNT_RATE_CROSSTALK_CORRECTED_MCPS_SD0 0x0FC0 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['shadow_system_results', 'results'] + + fields: \n + - [15:0] = shadow_result__peak_signal_count_rate_crosstalk_corrected_mcps_sd0 (fixed point 9.7) +*/ +#define VL53L1X_SHADOW_RESULT__PEAK_SIGNAL_COUNT_RATE_CROSSTALK_CORRECTED_MCPS_SD0_HI 0x0FC0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__PEAK_SIGNAL_COUNT_RATE_CROSSTALK_CORRECTED_MCPS_SD0_LO 0x0FC1 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__MM_INNER_ACTUAL_EFFECTIVE_SPADS_SD0 0x0FC2 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['shadow_system_results', 'results'] + + fields: \n + - [15:0] = shadow_result__mm_inner_actual_effective_spads_sd0 (fixed point 8.8) +*/ +#define VL53L1X_SHADOW_RESULT__MM_INNER_ACTUAL_EFFECTIVE_SPADS_SD0_HI 0x0FC2 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__MM_INNER_ACTUAL_EFFECTIVE_SPADS_SD0_LO 0x0FC3 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__MM_OUTER_ACTUAL_EFFECTIVE_SPADS_SD0 0x0FC4 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['shadow_system_results', 'results'] + + fields: \n + - [15:0] = shadow_result__mm_outer_actual_effective_spads_sd0 (fixed point 8.8) +*/ +#define VL53L1X_SHADOW_RESULT__MM_OUTER_ACTUAL_EFFECTIVE_SPADS_SD0_HI 0x0FC4 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__MM_OUTER_ACTUAL_EFFECTIVE_SPADS_SD0_LO 0x0FC5 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__AVG_SIGNAL_COUNT_RATE_MCPS_SD0 0x0FC6 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['shadow_system_results', 'results'] + + fields: \n + - [15:0] = shadow_result__avg_signal_count_rate_mcps_sd0 (fixed point 9.7) +*/ +#define VL53L1X_SHADOW_RESULT__AVG_SIGNAL_COUNT_RATE_MCPS_SD0_HI 0x0FC6 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__AVG_SIGNAL_COUNT_RATE_MCPS_SD0_LO 0x0FC7 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__DSS_ACTUAL_EFFECTIVE_SPADS_SD1 0x0FC8 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['shadow_system_results', 'results'] + + fields: \n + - [15:0] = shadow_result__dss_actual_effective_spads_sd1 (fixed point 8.8) +*/ +#define VL53L1X_SHADOW_RESULT__DSS_ACTUAL_EFFECTIVE_SPADS_SD1_HI 0x0FC8 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__DSS_ACTUAL_EFFECTIVE_SPADS_SD1_LO 0x0FC9 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__PEAK_SIGNAL_COUNT_RATE_MCPS_SD1 0x0FCA +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['shadow_system_results', 'results'] + + fields: \n + - [15:0] = shadow_result__peak_signal_count_rate_mcps_sd1 (fixed point 9.7) +*/ +#define VL53L1X_SHADOW_RESULT__PEAK_SIGNAL_COUNT_RATE_MCPS_SD1_HI 0x0FCA +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__PEAK_SIGNAL_COUNT_RATE_MCPS_SD1_LO 0x0FCB +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__AMBIENT_COUNT_RATE_MCPS_SD1 0x0FCC +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['shadow_system_results', 'results'] + + fields: \n + - [15:0] = shadow_result__ambient_count_rate_mcps_sd1 (fixed point 9.7) +*/ +#define VL53L1X_SHADOW_RESULT__AMBIENT_COUNT_RATE_MCPS_SD1_HI 0x0FCC +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__AMBIENT_COUNT_RATE_MCPS_SD1_LO 0x0FCD +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__SIGMA_SD1 0x0FCE +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['shadow_system_results', 'results'] + + fields: \n + - [15:0] = shadow_result__sigma_sd1 (fixed point 14.2) +*/ +#define VL53L1X_SHADOW_RESULT__SIGMA_SD1_HI 0x0FCE +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__SIGMA_SD1_LO 0x0FCF +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__PHASE_SD1 0x0FD0 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['shadow_system_results', 'results'] + + fields: \n + - [15:0] = shadow_result__phase_sd1 (fixed point 5.11) +*/ +#define VL53L1X_SHADOW_RESULT__PHASE_SD1_HI 0x0FD0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__PHASE_SD1_LO 0x0FD1 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__FINAL_CROSSTALK_CORRECTED_RANGE_MM_SD1 0x0FD2 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['shadow_system_results', 'results'] + + fields: \n + - [15:0] = shadow_result__final_crosstalk_corrected_range_mm_sd1 +*/ +#define VL53L1X_SHADOW_RESULT__FINAL_CROSSTALK_CORRECTED_RANGE_MM_SD1_HI 0x0FD2 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__FINAL_CROSSTALK_CORRECTED_RANGE_MM_SD1_LO 0x0FD3 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__SPARE_0_SD1 0x0FD4 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['shadow_system_results', 'results'] + + fields: \n + - [15:0] = shadow_result__spare_0_sd1 +*/ +#define VL53L1X_SHADOW_RESULT__SPARE_0_SD1_HI 0x0FD4 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__SPARE_0_SD1_LO 0x0FD5 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__SPARE_1_SD1 0x0FD6 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['shadow_system_results', 'results'] + + fields: \n + - [15:0] = shadow_result__spare_1_sd1 +*/ +#define VL53L1X_SHADOW_RESULT__SPARE_1_SD1_HI 0x0FD6 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__SPARE_1_SD1_LO 0x0FD7 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__SPARE_2_SD1 0x0FD8 +/*!< + type: uint16_t \n + default: 0x0000 \n + info: \n + - msb = 15 + - lsb = 0 + - i2c_size = 2 + + groups: \n + ['shadow_system_results', 'results'] + + fields: \n + - [15:0] = shadow_result__spare_2_sd1 +*/ +#define VL53L1X_SHADOW_RESULT__SPARE_2_SD1_HI 0x0FD8 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__SPARE_2_SD1_LO 0x0FD9 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT__SPARE_3_SD1 0x0FDA +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['shadow_system_results', 'results'] + + fields: \n + - [7:0] = shadow_result__spare_3_sd1 +*/ +#define VL53L1X_SHADOW_RESULT__THRESH_INFO 0x0FDB +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['shadow_system_results', 'results'] + + fields: \n + - [3:0] = shadow_result__distance_int_info + - [7:4] = shadow_result__rate_int_info +*/ +#define VL53L1X_SHADOW_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD0 0x0FDC +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['shadow_core_results', 'ranging_core_results'] + + fields: \n + - [31:0] = shadow_result_core__ambient_window_events_sd0 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD0_3 0x0FDC +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD0_2 0x0FDD +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD0_1 0x0FDE +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD0_0 0x0FDF +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__RANGING_TOTAL_EVENTS_SD0 0x0FE0 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['shadow_core_results', 'ranging_core_results'] + + fields: \n + - [31:0] = shadow_result_core__ranging_total_events_sd0 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__RANGING_TOTAL_EVENTS_SD0_3 0x0FE0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__RANGING_TOTAL_EVENTS_SD0_2 0x0FE1 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__RANGING_TOTAL_EVENTS_SD0_1 0x0FE2 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__RANGING_TOTAL_EVENTS_SD0_0 0x0FE3 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD0 0x0FE4 +/*!< + type: int32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['shadow_core_results', 'ranging_core_results'] + + fields: \n + - [31:0] = shadow_result_core__signal_total_events_sd0 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD0_3 0x0FE4 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD0_2 0x0FE5 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD0_1 0x0FE6 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD0_0 0x0FE7 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD0 0x0FE8 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['shadow_core_results', 'ranging_core_results'] + + fields: \n + - [31:0] = shadow_result_core__total_periods_elapsed_sd0 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD0_3 0x0FE8 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD0_2 0x0FE9 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD0_1 0x0FEA +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD0_0 0x0FEB +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD1 0x0FEC +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['shadow_core_results', 'ranging_core_results'] + + fields: \n + - [31:0] = shadow_result_core__ambient_window_events_sd1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD1_3 0x0FEC +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD1_2 0x0FED +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD1_1 0x0FEE +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__AMBIENT_WINDOW_EVENTS_SD1_0 0x0FEF +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__RANGING_TOTAL_EVENTS_SD1 0x0FF0 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['shadow_core_results', 'ranging_core_results'] + + fields: \n + - [31:0] = shadow_result_core__ranging_total_events_sd1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__RANGING_TOTAL_EVENTS_SD1_3 0x0FF0 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__RANGING_TOTAL_EVENTS_SD1_2 0x0FF1 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__RANGING_TOTAL_EVENTS_SD1_1 0x0FF2 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__RANGING_TOTAL_EVENTS_SD1_0 0x0FF3 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD1 0x0FF4 +/*!< + type: int32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['shadow_core_results', 'ranging_core_results'] + + fields: \n + - [31:0] = shadow_result_core__signal_total_events_sd1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD1_3 0x0FF4 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD1_2 0x0FF5 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD1_1 0x0FF6 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__SIGNAL_TOTAL_EVENTS_SD1_0 0x0FF7 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD1 0x0FF8 +/*!< + type: uint32_t \n + default: 0x00000000 \n + info: \n + - msb = 31 + - lsb = 0 + - i2c_size = 4 + + groups: \n + ['shadow_core_results', 'ranging_core_results'] + + fields: \n + - [31:0] = shadow_result_core__total_periods_elapsed_sd1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD1_3 0x0FF8 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD1_2 0x0FF9 +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD1_1 0x0FFA +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__TOTAL_PERIODS_ELAPSED_SD1_0 0x0FFB +/*!< + info: \n + - msb = 0 + - lsb = 0 + - i2c_size = 1 +*/ +#define VL53L1X_SHADOW_RESULT_CORE__SPARE_0 0x0FFC +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['shadow_core_results', 'ranging_core_results'] + + fields: \n + - [7:0] = shadow_result_core__spare_0 +*/ +#define VL53L1X_SHADOW_PHASECAL_RESULT__REFERENCE_PHASE_HI 0x0FFE +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['shadow_system_results', 'histogram_results'] + + fields: \n + - [7:0] = shadow_phasecal_result__reference_phase_hi +*/ +#define VL53L1X_SHADOW_PHASECAL_RESULT__REFERENCE_PHASE_LO 0x0FFF +/*!< + type: uint8_t \n + default: 0x00 \n + info: \n + - msb = 7 + - lsb = 0 + - i2c_size = 1 + + groups: \n + ['shadow_system_results', 'histogram_results'] + + fields: \n + - [7:0] = shadow_phasecal_result__reference_phase_lo +*/ + +/** @} VL53L1X_register_DefineRegisters_group */ + +#ifdef __cplusplus +} +#endif + +#endif /* DOXYGEN */ +#endif /* VL53L1X_REGISTER_MAP_H */ diff --git a/drivers/vl53l1x/include/vl53l1x_regs.h b/drivers/vl53l1x/include/vl53l1x_regs.h new file mode 100644 index 000000000000..f55c02a16ca0 --- /dev/null +++ b/drivers/vl53l1x/include/vl53l1x_regs.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2021 Gunar Schorcht + * + * This file is subject to the terms and conditions of the GNU Lesser + * General Public License v2.1. See the file LICENSE in the top level + * directory for more details. + */ + +/** + * @ingroup drivers_vl53l1x + * @brief Register definitions for ST VL53L1X Time-of-Flight (ToF) ranging sensor + * @author Gunar Schorcht + * @file + * @{ + */ + +#ifndef VL53L1X_REGS_H +#define VL53L1X_REGS_H + +#ifdef __cplusplus +extern "C" +{ +#endif + +/** Register addresses are imported from ST VL53L1X Register Map definitions */ +#include "vl53l1x_register_map.h" + +#if !DOXYGEN +/** + * @name Register addresses + * + * Register addresses are included from ST VL53L1X Register Map definitions. + * Only addition addresses are defined here + * + * @{ + */ +#define VL53L1X_MM_CONFIG__TIMEOUT_MACROP_A (0x005a) +#define VL53L1X_MM_CONFIG__TIMEOUT_MACROP_B (0x005c) +#define VL53L1X_RANGE_CONFIG__TIMEOUT_MACROP_A (0x005e) +#define VL53L1X_RANGE_CONFIG__TIMEOUT_MACROP_B (0x0061) +/** @} */ +#endif /* !DOXYGEN */ + +#define VL53L1X_DEVICE_ID (0xea) /**< VL53L1X Model ID */ +#define VL53L1X_I2C_ADDRESS (0x29) /**< VL53L1X I2C address */ + +#ifdef __cplusplus +} +#endif + +#endif /* VL53L1X_REGS_H */ +/** @} */ diff --git a/drivers/vl53l1x/vl53l1x.c b/drivers/vl53l1x/vl53l1x.c new file mode 100644 index 000000000000..c35918283927 --- /dev/null +++ b/drivers/vl53l1x/vl53l1x.c @@ -0,0 +1,1316 @@ +/* + * Copyright (C) 2021 Gunar Schorcht + * + * This file is subject to the terms and conditions of the GNU Lesser + * General Public License v2.1. See the file LICENSE in the top level + * directory for more details. + * + * @note: Parts of the code are based on + * [Pololu VL53L1X library for Arduino](https://github.com/pololu/vl53l1x-arduino) + * These parts are marked accordingly and are subject to the copyright below + * [https://raw.githubusercontent.com/pololu/vl53l1x-arduino/master/LICENSE.txt] + * (https://raw.githubusercontent.com/pololu/vl53l1x-arduino/master/LICENSE.txt). + * + * ************************************************************************** + * + * Most of the functionality of this library is based on the VL53L1X API + * provided by ST (STSW-IMG007), and some of the explanatory comments are + * quoted paraphrased from the API source code, API user manual (UM2356), and + * VL53L1X datasheet. Therefore, the license terms for the API source code + * (BSD 3-clause "New" or "Revised" License) also apply to this derivative + * work, as specified below. + * + * For more information, see + * + * https://www.pololu.com/ + * https://forum.pololu.com/ + * + * --------------------------------------------------------------------------- + * + * Copyright (c) 2017, STMicroelectronics + * Copyright (c) 2018, Pololu Corporation + * All Rights Reserved + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/** + * @ingroup drivers_vl53l1x + * @brief Device driver for the ST VL53L1X Time-of-Flight (ToF) ranging sensor + * @author Gunar Schorcht + * @file + * @{ + */ + +#include +#include + +#include "vl53l1x_regs.h" +#include "vl53l1x.h" + +#include "irq.h" +#include "log.h" +#include "ztimer.h" + +#define ENABLE_DEBUG 0 +#include "debug.h" + +#if IS_ACTIVE(ENABLE_DEBUG) + +#define ASSERT_PARAM(cond) \ + if (!(cond)) { \ + DEBUG("[vl53l1x] %s: %s\n", \ + __func__, "parameter condition (" # cond ") not fulfilled"); \ + assert(cond); \ + } + +#define DEBUG_DEV(f, d, ...) \ + DEBUG("[vl53l1x] %s i2c dev=%d addr=%02x: " f "\n", \ + __func__, d->params.i2c_dev, VL53L1X_I2C_ADDRESS, ## __VA_ARGS__); + +#else /* IS_ACTIVE(ENABLE_DEBUG) */ + +#define ASSERT_PARAM(cond) assert(cond); +#define DEBUG_DEV(f, d, ...) + +#endif /* IS_ACTIVE(ENABLE_DEBUG) */ + +#define ERROR_DEV(f, d, ...) \ + LOG_ERROR("[vl53l1x] %s i2c dev=%d addr=%02x: " f "\n", \ + __func__, d->params.i2c_dev, VL53L1X_I2C_ADDRESS, ## __VA_ARGS__); + +#define EXEC_RET(f) { \ + int _r; \ + if ((_r = f) != VL53L1X_OK) { \ + DEBUG("[vl53l1x] %s: error code %d\n", __func__, _r); \ + return _r; \ + } \ +} + +#define EXEC_RET_CODE(f, c) { \ + int _r; \ + if ((_r = f) != VL53L1X_OK) { \ + DEBUG("[vl53l1x] %s: error code %d\n", __func__, _r); \ + return c; \ + } \ +} + +#define EXEC(f) { \ + int _r; \ + if ((_r = f) != VL53L1X_OK) { \ + DEBUG("[vl53l1x] %s: error code %d\n", __func__, _r); \ + return; \ + } \ +} + +/** Forward declaration of functions for internal use */ +static int _is_available(const vl53l1x_t *dev); +static int _reset(vl53l1x_t *dev); +static int _init(vl53l1x_t *dev); + +#if IS_USED(MODULE_VL53L1X_ST_API) + +/* for ST VL53L1X API basic read and write function are already implemented */ +#define _read_byte(d, i, b) VL53L1_RdByte((VL53L1_Dev_t*)d, i, b) +#define _read_word(d, i, w) VL53L1_RdWord((VL53L1_Dev_t*)d, i, w) +#define _read(d, i, p, l) VL53L1_ReadMulti((VL53L1_Dev_t*)d, i, p, l) + +#define _write_byte(d, i, b) VL53L1_WrByte((VL53L1_Dev_t*)d, i, b) +#define _write_word(d, i, w) VL53L1_WrWord((VL53L1_Dev_t*)d, i, w) +#define _write_dword(d, i, w) VL53L1_WrDWord((VL53L1_Dev_t*)d, i, w) +#define _write(d, i, p, l) VL53L1_WriteMulti((VL53L1_Dev_t*)d, i, p, l) + +#define _start(d) VL53L1_StartMeasurement((VL53L1_Dev_t*)d) + +extern VL53L1_Error VL53L1_UpdateByte(VL53L1_DEV Dev, uint16_t index, + uint8_t AndData, + uint8_t OrData); +#else + +typedef struct { + uint8_t range_status : 5; + uint8_t max_threshold_hit : 1; + uint8_t min_threshold_hit : 1; + uint8_t gph_id_range_status : 1; + uint8_t report_status : 4; + uint8_t reserved1 : 4; + uint8_t stream_count : 8; + uint8_t dss_actual_effective_spads_sd0_hi : 8; /* fixed point 8.8 */ + uint8_t dss_actual_effective_spads_sd0_lo : 8; /* fixed point 8.8 */ + uint8_t peak_signal_count_rate_mcps_sd0_hi : 8; /* fixed point 9.7 */ + uint8_t peak_signal_count_rate_mcps_sd0_lo : 8; /* fixed point 9.7 */ + uint8_t ambient_count_rate_mcps_sd0_hi : 8; /* fixed point 9.7 */ + uint8_t ambient_count_rate_mcps_sd0_lo : 8; /* fixed point 9.7 */ + uint8_t sigma_sd0_hi : 8; /* fixed point 14.2 */ + uint8_t sigma_sd0_lo : 8; /* fixed point 14.2 */ + uint8_t phase_sd0_hi : 8; /* fixed point 5.11 */ + uint8_t phase_sd0_lo : 8; /* fixed point 5.11 */ + uint8_t final_crosstalk_corrected_range_mm_sd0_hi : 8; + uint8_t final_crosstalk_corrected_range_mm_sd0_lo : 8; + uint8_t peak_signal_count_rate_crosstalk_corrected_mcps_sd0_hi : 8; /* fixed point 9.7 */ + uint8_t peak_signal_count_rate_crosstalk_corrected_mcps_sd0_lo : 8; /* fixed point 9.7 */ +} _vl53l1x_raw_data_t; + +static int _update(const vl53l1x_t *dev, uint16_t index, uint8_t mask, uint8_t data); +static int _read(const vl53l1x_t *dev, uint16_t index, uint8_t *data, uint32_t len); +static int _read_byte(const vl53l1x_t *dev, uint16_t index, uint8_t *data); +static int _read_word(const vl53l1x_t *dev, uint16_t index, uint16_t *data); +static int _write(const vl53l1x_t *dev, uint16_t index, const uint8_t *data, uint32_t len); +static int _write_byte(const vl53l1x_t *dev, uint16_t index, uint8_t data); +static int _write_word(const vl53l1x_t *dev, uint16_t index, uint16_t data); +#if !IS_USED(MODULE_VL53L1X_BASIC) +static int _write_dword(const vl53l1x_t *dev, uint16_t index, uint32_t data); +#endif /* !IS_USED(MODULE_VL53L1X_BASIC) */ + +static int _start(const vl53l1x_t *dev); +static int _update_dss(const vl53l1x_t *dev, _vl53l1x_raw_data_t* raw_data); + +#if !IS_USED(MODULE_VL53L1X_BASIC) +static int _setup_manual_calibration(const vl53l1x_t *dev); +static uint16_t _enc_timeout(uint32_t clks); +static uint32_t _dec_timeout(uint16_t val); +static uint32_t _timeout_clk_to_us(uint32_t clks, uint32_t period_us); +static uint32_t _timeout_us_to_clk(uint32_t us, uint32_t period_us); +static uint32_t _calc_macro_period(const vl53l1x_t *dev, uint8_t vcsel_period); + +#endif /* !IS_USED(MODULE_VL53L1X_BASIC) */ + +/* Copyrighted POLOLU / ST API code begin */ +#if !IS_USED(MODULE_VL53L1X_BASIC) +static const uint32_t _timing_guard = 4528; /* used in timing budget calculations */ +#endif /* !IS_USED(MODULE_VL53L1X_BASIC) */ +static const uint16_t _target_rate = 0x0A00; /* used in DSS calculations */ +/* Copyrighted POLOLU / ST API code end */ + +#endif /* IS_USED(MODULE_VL53L1X_ST_API) */ + +int vl53l1x_init(vl53l1x_t *dev, const vl53l1x_params_t *params) +{ + /* some parameter sanity checks */ + ASSERT_PARAM(dev != NULL); + ASSERT_PARAM(params != NULL); +#if !IS_USED(MODULE_VL53L1X_BASIC) + ASSERT_PARAM(params->budget <= 1000000); + ASSERT_PARAM(params->period >= params->budget/1000 + 4); +#endif /* !IS_USED(MODULE_VL53L1X_BASIC) */ + DEBUG_DEV("params=%p", dev, params); + + /* init sensor data structure */ + dev->params = *params; + dev->int_init = false; + +#if IS_USED(MODULE_VL53L1X_ST_API) + dev->dev.I2cDevAddr = VL53L1X_I2C_ADDRESS; +#elif !IS_USED(MODULE_VL53L1X_BASIC) + dev->calibrated = false; +#endif + +#if !IS_USED(MODULE_VL53L1X_BASIC) + /* if shutdown pin is defined, it is initialized first and set */ + if (params->pin_shutdown != GPIO_UNDEF) { + gpio_init(params->pin_shutdown, GPIO_OUT); + gpio_write(params->pin_shutdown, 1); + } +#endif + + /* init the sensor and start measurement */ + _init(dev); + + return VL53L1X_OK; +} + +int vl53l1x_data_ready(vl53l1x_t *dev) +{ + ASSERT_PARAM(dev != NULL); + DEBUG_DEV("", dev); + +#if IS_USED(MODULE_VL53L1X_ST_API) + uint8_t ready; + EXEC_RET(VL53L1_GetMeasurementDataReady(&dev->dev, &ready)); + return (ready) ? VL53L1X_OK : -VL53L1X_ERROR_NO_DATA; +#else + uint8_t byte; + EXEC_RET(_read_byte(dev, VL53L1X_GPIO__TIO_HV_STATUS, &byte)); + return ((byte & 0x01) == 0) ? VL53L1X_OK : -VL53L1X_ERROR_NO_DATA; +#endif +} + +#if IS_USED(MODULE_VL53L1X_ST_API) +int vl53l1x_read_details(vl53l1x_t *dev, + VL53L1_RangingMeasurementData_t *details) +{ + ASSERT_PARAM(dev != NULL); + ASSERT_PARAM(details != NULL); + DEBUG_DEV("details=%p", dev, details); + + EXEC_RET(vl53l1x_data_ready(dev)); + EXEC_RET(VL53L1_GetRangingMeasurementData(&dev->dev, details)); + EXEC_RET(VL53L1_ClearInterruptAndStartMeasurement(&dev->dev)); + + return VL53L1X_OK; +} +#endif /* IS_USED(MODULE_VL53L1X_ST_API) */ + +int vl53l1x_read_data(vl53l1x_t *dev, vl53l1x_data_t *data) +{ + ASSERT_PARAM(dev != NULL); + ASSERT_PARAM(data != NULL); + DEBUG_DEV("data=%p", dev, data); + +#if IS_USED(MODULE_VL53L1X_ST_API) + + VL53L1_RangingMeasurementData_t details; + EXEC_RET(vl53l1x_read_details(dev, &details)); + + data->status = details.RangeStatus; + data->distance = details.RangeMilliMeter; + data->signal_rate = details.SignalRateRtnMegaCps; + data->ambient_rate = details.AmbientRateRtnMegaCps; + +#else /* IS_USED(MODULE_VL53L1X_ST_API) */ + + /* read the results into data structure of type _vl53l1x_raw_data_t */ + _vl53l1x_raw_data_t raw; + EXEC_RET(_read(dev, VL53L1X_RESULT__RANGE_STATUS, + (uint8_t*)&raw, sizeof(_vl53l1x_raw_data_t))); + + /* Copyrighted POLOLU / ST API code begin */ + +#if !IS_USED(MODULE_VL53L1X_BASIC) + /* set status */ + switch (raw.range_status) { + case 1: + case 2: + case 3: + data->status = VL53L1X_RANGESTATUS_HARDWARE_FAIL; + break; + case 4: + data->status = VL53L1X_RANGESTATUS_SIGNAL_FAIL; + break; + case 5: + data->status = VL53L1X_RANGESTATUS_OUTOFBOUNDS_FAIL; + break; + case 6: + data->status = VL53L1X_RANGESTATUS_SIGMA_FAIL; + break; + case 7: + data->status = VL53L1X_RANGESTATUS_WRAP_TARGET_FAIL; + break; + case 8: + data->status = VL53L1X_RANGESTATUS_RANGE_VALID_MIN_RANGE_CLIPPED; + break; + case 9: + data->status = (raw.stream_count == 0) ? + VL53L1X_RANGESTATUS_RANGE_VALID_NO_WRAP_CHECK_FAIL : + VL53L1X_RANGESTATUS_RANGE_VALID; + break; + case 12: + data->status = VL53L1X_RANGESTATUS_XTALK_SIGNAL_FAIL; + break; + case 13: + data->status = VL53L1X_RANGESTATUS_MIN_RANGE_FAIL; + break; + case 17: + data->status = VL53L1X_RANGESTATUS_HARDWARE_FAIL; + break; + case 18: + data->status = VL53L1X_RANGESTATUS_SYNCRONISATION_INT; + break; + case 19: + data->status = VL53L1X_RANGESTATUS_RANGE_VALID_NO_WRAP_CHECK_FAIL; + break; + default: + data->status = VL53L1X_RANGESTATUS_NONE; + } + + /* calibrate if necessary */ + if (!dev->calibrated) { + _setup_manual_calibration(dev); + dev->calibrated = true; + } +#endif /* !IS_USED(MODULE_VL53L1X_BASIC) */ + + EXEC_RET(_update_dss(dev, &raw)); + + /* calculate range */ + uint16_t range; + range = (uint16_t)raw.final_crosstalk_corrected_range_mm_sd0_hi << 8; + range |= raw.final_crosstalk_corrected_range_mm_sd0_lo; + + /* + * apply correction gain + * gain factor of 2011 is tuning param default + * (VL53L1_TUNINGPARM_LITE_RANGING_GAIN_FACTOR_DEFAULT) + * Basically, this appears to scale the result by 2011/2048, or about 98% + * (with the 1024 added for proper rounding). + */ + data->distance = ((uint32_t)range * 2011 + 0x0400) / 0x0800; + /* Copyrighted POLOLU / ST API code end */ + +#if !IS_USED(MODULE_VL53L1X_BASIC) + /* peak signal rate in 9.7 fixed point format */ + data->signal_rate = (uint32_t)raw.peak_signal_count_rate_mcps_sd0_hi << 8; + data->signal_rate |= raw.peak_signal_count_rate_mcps_sd0_lo; + + /* ambient rate in in 9.7 fixed point format */ + data->ambient_rate = (uint32_t)raw.ambient_count_rate_mcps_sd0_hi << 8; + data->ambient_rate |= raw.ambient_count_rate_mcps_sd0_lo; + + /* convert values from 9.7 to 16.16 */ + data->signal_rate <<= 9; + data->ambient_rate <<= 9; + +#endif /* !IS_USED(MODULE_VL53L1X_BASIC) */ + + /* restart measurement */ + EXEC_RET(_start(dev)); + +#endif /* IS_USED(MODULE_VL53L1X_ST_API) */ + + return VL53L1X_OK; +} + +int vl53l1x_read_mm(vl53l1x_t *dev, int16_t *mm) +{ + ASSERT_PARAM(dev != NULL); + ASSERT_PARAM(mm != NULL); + DEBUG_DEV("mm=%p", dev, mm); + + vl53l1x_data_t data; + EXEC_RET(vl53l1x_read_data(dev, &data)); + *mm = data.distance; + + return VL53L1X_OK; +} + +int vl53l1x_int_config(vl53l1x_t *dev, vl53l1x_int_config_t* cfg, + void (*isr)(void *), + void *isr_arg) +{ + ASSERT_PARAM(dev != NULL); + ASSERT_PARAM(dev->params.pin_int != GPIO_UNDEF); + + DEBUG_DEV("cfg=%p isr=%p isr_arg=%p", dev, cfg, isr, isr_arg); + + if (!dev->int_init) { + dev->int_init = true; + gpio_init_int(dev->params.pin_int, GPIO_IN_PU, GPIO_FALLING, + isr, isr_arg); + } + +#if IS_USED(MODULE_VL53L1X_ST_API) + ASSERT_PARAM(cfg != NULL); + + EXEC_RET(VL53L1_StopMeasurement(&dev->dev)); + + VL53L1_DetectionConfig_t dcfg; + dcfg.DetectionMode = cfg->mode; + dcfg.Distance.CrossMode = cfg->dist_mode; + dcfg.Distance.High = cfg->dist_high; + dcfg.Distance.Low = cfg->dist_low; + dcfg.Rate.CrossMode = cfg->rate_mode; + dcfg.Rate.High = cfg->rate_high; + dcfg.Rate.Low = cfg->rate_low; + dcfg.IntrNoTarget = 0; + + EXEC_RET(VL53L1_SetThresholdConfig(&dev->dev, &dcfg)); + EXEC_RET(VL53L1_StartMeasurement(&dev->dev)); +#else + (void)cfg; + DEBUG_DEV("configuration is not used", dev); +#endif + + return VL53L1X_OK; +} + +#if !IS_USED(MODULE_VL53L1X_BASIC) + +int vl53l1x_power_down(const vl53l1x_t *dev) +{ + ASSERT_PARAM(dev != NULL); + DEBUG_DEV("", dev); + + if (dev->params.pin_shutdown == GPIO_UNDEF) { + DEBUG_DEV("Pin connected to sensor's XSHUT pin not defined", dev); + return VL53L1X_ERROR_NO_PIN; + } + + gpio_clear(dev->params.pin_shutdown); + return VL53L1X_OK; +} + +int vl53l1x_power_up(vl53l1x_t *dev) +{ + ASSERT_PARAM(dev != NULL); + DEBUG_DEV("", dev); + + if (dev->params.pin_shutdown == GPIO_UNDEF) { + DEBUG_DEV("Pin connected to sensor's XSHUT pin not defined", dev); + return VL53L1X_ERROR_NO_PIN; + } + + gpio_set(dev->params.pin_shutdown); + + /* init the sensor and start measurement */ + _init(dev); + + return VL53L1X_OK; +} + +int vl53l1x_get_timing_budget(vl53l1x_t *dev, uint32_t *budget) +{ + ASSERT_PARAM(dev != NULL); + ASSERT_PARAM(budget != NULL); + DEBUG_DEV("budget=%p", dev, budget); + +#if IS_USED(MODULE_VL53L1X_ST_API) + return VL53L1_GetMeasurementTimingBudgetMicroSeconds(&dev->dev, + budget); +#else + /* Copyrighted POLOLU / ST API code begin */ + + /* Update Macro Period for Range A VCSEL Period */ + uint8_t byte; + uint32_t period_us; + + EXEC_RET(_read_byte(dev, VL53L1X_RANGE_CONFIG__VCSEL_PERIOD_A, &byte)); + period_us = _calc_macro_period(dev, byte); + + /* Get Range Timing A timeout */ + uint16_t word; + uint32_t timeout_us; + + EXEC_RET(_read_word(dev, VL53L1X_RANGE_CONFIG__TIMEOUT_MACROP_A, &word)); + timeout_us = _timeout_clk_to_us(_dec_timeout(word), period_us); + + *budget = 2 * timeout_us + _timing_guard; + /* Copyrighted POLOLU / ST API code end */ + + return VL53L1X_OK; + +#endif +} + +int vl53l1x_set_timing_budget(vl53l1x_t *dev, uint32_t budget_us) +{ + ASSERT_PARAM(dev != NULL); + DEBUG_DEV("budget_us=%u", dev, budget_us); + +#if IS_USED(MODULE_VL53L1X_ST_API) + + EXEC_RET(VL53L1_SetMeasurementTimingBudgetMicroSeconds(&dev->dev, + budget_us)); +#else + /* Copyrighted POLOLU / ST API code begin */ + /* assumes PresetMode is LOWPOWER_AUTONOMOUS */ + + if (budget_us <= _timing_guard) { + return VL53L1X_ERROR_INV_PARAM; + } + + uint32_t timeout_us = budget_us -= _timing_guard; + if (timeout_us > 1100000) { + return VL53L1X_ERROR_INV_PARAM; + } + timeout_us /= 2; + + /* Update Macro Period for Range A VCSEL Period */ + uint8_t byte; + uint32_t period_us; + + EXEC_RET(_read_byte(dev, VL53L1X_RANGE_CONFIG__VCSEL_PERIOD_A, &byte)); + period_us = _calc_macro_period(dev, byte); + + /* + * Update Phase timeout - uses Timing A + * Timeout of 1000 is tuning param default + * (TIMED_PHASECAL_CONFIG_TIMEOUT_US_DEFAULT) + * via VL53L1_get_preset_mode_timing_cfg(). + */ + uint32_t clks = _timeout_us_to_clk(1000, period_us); + clks = (clks > 0xff) ? 0xff : clks; + EXEC_RET(_write_byte(dev, VL53L1X_PHASECAL_CONFIG__TIMEOUT_MACROP, clks)); + + /* + * Update MM Timing A timeout. + * Timeout of 1 is tuning param default + * (LOWPOWERAUTO_MM_CONFIG_TIMEOUT_US_DEFAULT) via + * VL53L1_get_preset_mode_timing_cfg(). + * With the API, the register actually ends up with a slightly different + * value because it gets assigned, retrieved, recalculated with a different + * macro period, and reassigned, but it probably doesn't matter because + * it seems like the MM ("mode mitigation"?) sequence steps are disabled + * in low power auto mode anyway. + */ + clks = _enc_timeout(_timeout_us_to_clk(1, period_us)); + EXEC_RET(_write_word(dev, VL53L1X_MM_CONFIG__TIMEOUT_MACROP_A, clks)); + + /* Update Range Timing A timeout */ + clks = _enc_timeout(_timeout_us_to_clk(timeout_us, period_us)); + EXEC_RET(_write_word(dev, VL53L1X_RANGE_CONFIG__TIMEOUT_MACROP_A, clks)); + + /* Update Macro Period for Range B VCSEL Period */ + EXEC_RET(_read_byte(dev, VL53L1X_RANGE_CONFIG__VCSEL_PERIOD_B, &byte)); + period_us = _calc_macro_period(dev, byte); + + /* Update MM Timing B timeout, see comment about MM Timing A timeout. */ + clks = _enc_timeout(_timeout_us_to_clk(1, period_us)); + EXEC_RET(_write_word(dev, VL53L1X_MM_CONFIG__TIMEOUT_MACROP_B, clks)); + + /* Update Range Timing B timeout */ + clks = _enc_timeout(_timeout_us_to_clk(timeout_us, period_us)); + EXEC_RET(_write_word(dev, VL53L1X_RANGE_CONFIG__TIMEOUT_MACROP_B, clks)); + + /* Copyrighted POLOLU / ST API code end */ +#endif + + /* save the timing budget */ + dev->params.budget = budget_us; + + return VL53L1X_OK; +} + +int vl53l1x_set_measurement_period(vl53l1x_t *dev, uint32_t period_ms) +{ + ASSERT_PARAM(dev != NULL); + ASSERT_PARAM((period_ms + 4) * 1000 > dev->params.budget); + DEBUG_DEV("period_ms=%u", dev, period_ms); + +#if IS_USED(MODULE_VL53L1X_ST_API) + + EXEC_RET(VL53L1_SetInterMeasurementPeriodMilliSeconds(&dev->dev, + period_ms)); +#else + /* Copyrighted POLOLU / ST API code begin */ + + /* from VL53L1_set_inter_measurement_period_ms() */ + uint32_t period = period_ms * dev->osc_calibrate_val; + EXEC_RET(_write_dword(dev, VL53L1X_SYSTEM__INTERMEASUREMENT_PERIOD, period)); + + /* Copyrighted POLOLU / ST API code end */ +#endif + + /* save the measurement period */ + dev->params.period = period_ms; + + return VL53L1X_OK; +} + +int vl53l1x_set_distance_mode(vl53l1x_t *dev, vl53l1x_dist_mode_t mode) +{ + ASSERT_PARAM(dev != NULL); + DEBUG_DEV("mode=%u", dev, mode); + +#if IS_USED(MODULE_VL53L1X_ST_API) + + EXEC_RET(VL53L1_SetDistanceMode(&dev->dev, mode)); + +#else + /* Copyrighted POLOLU / ST API code begin */ + + /* save existing timing budget */ + uint32_t budget_us; + EXEC_RET(vl53l1x_get_timing_budget(dev, &budget_us)); + + switch (mode) { + case VL53L1X_DIST_SHORT: + /* from VL53L1_preset_mode_standard_ranging_short_range() */ + /* timing config */ + EXEC_RET(_write_byte(dev, VL53L1X_RANGE_CONFIG__VCSEL_PERIOD_A, 0x07)); + EXEC_RET(_write_byte(dev, VL53L1X_RANGE_CONFIG__VCSEL_PERIOD_B, 0x05)); + EXEC_RET(_write_byte(dev, VL53L1X_RANGE_CONFIG__VALID_PHASE_HIGH, 0x38)); + + /* dynamic config */ + EXEC_RET(_write_byte(dev, VL53L1X_SD_CONFIG__WOI_SD0, 0x07)); + EXEC_RET(_write_byte(dev, VL53L1X_SD_CONFIG__WOI_SD1, 0x05)); + EXEC_RET(_write_byte(dev, VL53L1X_SD_CONFIG__INITIAL_PHASE_SD0, 6)); + EXEC_RET(_write_byte(dev, VL53L1X_SD_CONFIG__INITIAL_PHASE_SD1, 6)); + break; + + case VL53L1X_DIST_MEDIUM: + /* from VL53L1_preset_mode_standard_ranging() */ + /* timing config */ + EXEC_RET(_write_byte(dev, VL53L1X_RANGE_CONFIG__VCSEL_PERIOD_A, 0x0b)); + EXEC_RET(_write_byte(dev, VL53L1X_RANGE_CONFIG__VCSEL_PERIOD_B, 0x09)); + EXEC_RET(_write_byte(dev, VL53L1X_RANGE_CONFIG__VALID_PHASE_HIGH, 0x78)); + + /* dynamic config */ + EXEC_RET(_write_byte(dev, VL53L1X_SD_CONFIG__WOI_SD0, 0x0b)); + EXEC_RET(_write_byte(dev, VL53L1X_SD_CONFIG__WOI_SD1, 0x09)); + EXEC_RET(_write_byte(dev, VL53L1X_SD_CONFIG__INITIAL_PHASE_SD0, 10)); + EXEC_RET(_write_byte(dev, VL53L1X_SD_CONFIG__INITIAL_PHASE_SD1, 10)); + break; + + case VL53L1X_DIST_LONG: + /* from VL53L1_preset_mode_standard_ranging_long_range() */ + EXEC_RET(_write_byte(dev, VL53L1X_RANGE_CONFIG__VCSEL_PERIOD_A, 0x0f)); + EXEC_RET(_write_byte(dev, VL53L1X_RANGE_CONFIG__VCSEL_PERIOD_B, 0x0d)); + EXEC_RET(_write_byte(dev, VL53L1X_RANGE_CONFIG__VALID_PHASE_HIGH, 0xb8)); + + /* dynamic config */ + EXEC_RET(_write_byte(dev, VL53L1X_SD_CONFIG__WOI_SD0, 0x0f)); + EXEC_RET(_write_byte(dev, VL53L1X_SD_CONFIG__WOI_SD1, 0x0d)); + EXEC_RET(_write_byte(dev, VL53L1X_SD_CONFIG__INITIAL_PHASE_SD0, 14)); + EXEC_RET(_write_byte(dev, VL53L1X_SD_CONFIG__INITIAL_PHASE_SD1, 14)); + break; + + default: + /* unrecognized mode - do nothing */ + return VL53L1X_ERROR_INV_ARG; + } + + /* reapply timing budget */ + EXEC_RET(vl53l1x_set_timing_budget(dev, budget_us)); + + /* Copyrighted POLOLU / ST API code end */ +#endif + + /* save the distance mode */ + dev->params.mode = mode; + + return VL53L1X_OK; +} + +int vl53l1x_set_roi(vl53l1x_t *dev, vl53l1x_roi_t *roi) +{ + ASSERT_PARAM(dev != NULL); + ASSERT_PARAM(roi != NULL); + + ASSERT_PARAM(roi->x_tl <= 15 && roi->y_tl <= 15); + ASSERT_PARAM(roi->x_br <= 15 && roi->y_br <= 15); + ASSERT_PARAM(roi->x_tl < roi->x_br); + ASSERT_PARAM(roi->y_tl > roi->y_br); + ASSERT_PARAM(roi->x_br - roi->x_tl >= 3); + ASSERT_PARAM(roi->y_tl - roi->y_br >= 3); + + DEBUG_DEV("roi=%p", dev, roi); + +#if IS_USED(MODULE_VL53L1X_ST_API) + return VL53L1_SetUserROI(&dev->dev, (VL53L1_UserRoi_t*)roi); +#else /* IS_USED(MODULE_VL53L1X_ST_API) */ + + /* Copyrighted ST API code begin */ + + /* center calculation from VL53L1_encode_row_col() */ + uint8_t row = (roi->x_br + roi->x_tl + 1) / 2; + uint8_t col = (roi->y_br + roi->y_tl + 1) / 2; + uint8_t spad = (row > 7) ? 128 + (col << 3) + (15 - row) + : ((15 - col) << 3) + row; + /* dimension calculation from VL53L1_encode_zone_size() */ + uint8_t w = (roi->x_br - roi->x_tl); + uint8_t h = (roi->y_tl - roi->y_br); + uint8_t dim = (h << 4) + w; + + /* Copyrighted ST API code end */ + + EXEC_RET(_write_byte(dev, VL53L1X_ROI_CONFIG__USER_ROI_CENTRE_SPAD, spad)); + EXEC_RET(_write_byte(dev, VL53L1X_ROI_CONFIG__USER_ROI_REQUESTED_GLOBAL_XY_SIZE, dim)); + +#endif /* IS_USED(MODULE_VL53L1X_ST_API) */ + + return VL53L1X_OK; +} + +int vl53l1x_get_roi(vl53l1x_t *dev, vl53l1x_roi_t *roi) +{ + ASSERT_PARAM(dev != NULL); + ASSERT_PARAM(roi != NULL); + + DEBUG_DEV("roi=%p", dev, roi); + +#if IS_USED(MODULE_VL53L1X_ST_API) + return VL53L1_GetUserROI(&dev->dev, (VL53L1_UserRoi_t*)roi); +#else /* IS_USED(MODULE_VL53L1X_ST_API) */ + + uint8_t spad; + EXEC_RET(_read_byte(dev, VL53L1X_ROI_CONFIG__USER_ROI_CENTRE_SPAD, &spad)); + + /* Copyrighted ST API code begin */ + + /* from VL53L1_decode_row_col() */ + uint8_t row; + uint8_t col; + + if (spad > 127) { + row = 8 + ((255 - spad) & 0x07); + col = (spad - 128) >> 3; + } + else { + row = spad & 0x07; + col = (127 - spad) >> 3; + } + + uint8_t dim; + EXEC_RET(_read_byte(dev, VL53L1X_ROI_CONFIG__USER_ROI_REQUESTED_GLOBAL_XY_SIZE, &dim)); + + /* from VL53L1_decode_zone_size() */ + uint8_t h = dim >> 4; + uint8_t w = dim & 0x0f; + + /* from VL53L1_GetUserROI() */ + roi->x_tl = (2 * col - w) >> 1; + roi->y_tl = (2 * row - h) >> 1; + roi->x_br = (2 * col + w) >> 1; + roi->y_br = (2 * row + h) >> 1; + + /* Copyrighted ST API code end */ +#endif /* IS_USED(MODULE_VL53L1X_ST_API) */ + + return VL53L1X_OK; +} + +#endif /* !IS_USED(MODULE_VL53L1X_BASIC) */ + +/** Functions for internal use only */ + +/** + * @brief Check the chip ID to test whether sensor is available + */ +static int _is_available(const vl53l1x_t *dev) +{ + DEBUG_DEV("", dev); + + uint8_t id; + uint8_t rev; + uint8_t mod_type; + uint16_t mod_id = 0; + + /* read the chip id from VL53L1X_REG_ID_X */ + EXEC_RET(_read_byte(dev, VL53L1X_IDENTIFICATION__MODEL_ID, &id)); + + if (id != VL53L1X_DEVICE_ID) { + DEBUG_DEV("sensor is not available, wrong device id %02x, " + "should be %02x", dev, id, VL53L1X_DEVICE_ID); + return -VL53L1X_ERROR_WRONG_ID; + } + + EXEC_RET(_read_byte(dev, VL53L1X_IDENTIFICATION__REVISION_ID, &rev)); + EXEC_RET(_read_byte(dev, VL53L1X_IDENTIFICATION__MODULE_TYPE, &mod_type)); + EXEC_RET(_read_word(dev, VL53L1X_IDENTIFICATION__MODULE_ID, &mod_id)); + + DEBUG_DEV("rev=%02x, module type=%02x id=%04x", dev, rev, mod_type, mod_id); + return VL53L1X_OK; +} + +#if IS_USED(MODULE_VL53L1X_BASIC) +/* The following block was recorded with the + * [ST VL53L1X API implementation for Arduino] + * (https://github.com/pololu/vl53l1x-st-api-arduino) with a timing budget of + * 50 ms and a inter-measurement time of 100 ms. It is streamed to the sensor + * as configuration. + */ +static const uint8_t _init_block[] = { + /* address length */ + /* 0x0001 */ 0x29, 0x02, 0x10, 0x00, 0x27, 0xbd, 0x1e, 0x81, /* 8 */ + /* 0x0009 */ 0x80, 0x07, 0x94, 0x00, 0xff, 0xff, 0x9f, 0x9e, /* 16 */ + /* 0x0011 */ 0xff, 0x0f, 0x00, 0x0c, 0x01, 0x00, 0x00, 0x00, /* 24 */ + /* 0x0019 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 32 */ + /* 0x0021 */ 0x22, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, /* 40 */ + /* 0x0029 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, /* 48 */ + /* 0x0031 */ 0x02, 0x00, 0x02, 0x08, 0x00, 0x08, 0x10, 0x01, /* 56 */ + /* 0x0039 */ 0x01, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x02, /* 64 */ + /* 0x0041 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x0b, 0x00, /* 72 */ + /* 0x0049 */ 0x00, 0x02, 0x0a, 0x21, 0x00, 0x00, 0x02, 0x00, /* 80 */ + /* 0x0051 */ 0x00, 0x00, 0x00, 0xc8, 0x00, 0x00, 0x38, 0xff, /* 88 */ + /* 0x0059 */ 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe8, 0x0f, /* 96 */ + /* 0x0061 */ 0x01, 0x85, 0x0d, 0x01, 0x68, 0x00, 0xc0, 0x08, /* 104 */ + /* 0x0069 */ 0xb8, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x74, 0x00, /* 112 */ + /* 0x0071 */ 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0f, /* 120 */ + /* 0x0079 */ 0x0d, 0x0e, 0x0e, 0x01, 0x00, 0x02, 0xc7, 0xff, /* 128 */ + /* 0x0081 */ 0x8b, 0x00, 0x00 /* 131 */ +}; +#endif /* IS_USED(MODULE_VL53L1X_BASIC) */ + +static int _init(vl53l1x_t *dev) +{ + /* wait for 6 ms after power on reset */ + ztimer_sleep(ZTIMER_MSEC, 6); + + /* check availability of the sensor */ + EXEC_RET(_is_available(dev)); + + /* reset, wait for 4 ms, and wait that devices has been booted */ + EXEC_RET(_reset(dev)); + +#if IS_USED(MODULE_VL53L1X_BASIC) + + /* stream the initialization block to the sensor to configure it */ + EXEC_RET(_write(dev, VL53L1X_I2C_SLAVE__DEVICE_ADDRESS, + _init_block, sizeof(_init_block))); + +#else /* IS_USED(MODULE_VL53L1X_BASIC) */ + +#if IS_USED(MODULE_VL53L1X_ST_API) + + /* configure the device without calibration data */ + EXEC_RET(VL53L1_DataInit(&dev->dev)); + EXEC_RET(VL53L1_StaticInit(&dev->dev)); + +#else /* IS_USED(MODULE_VL53L1X_ST_API) */ + + /* Copyrighted POLOLU / ST API code begin */ + /* store oscillator info for later use */ + EXEC_RET(_read_word(dev, VL53L1X_OSC_MEASURED__FAST_OSC__FREQUENCY, &dev->fast_osc_frequency)); + EXEC_RET(_read_word(dev, VL53L1X_RESULT__OSC_CALIBRATE_VAL, &dev->osc_calibrate_val)); + + /* static config */ + EXEC_RET(_write_word(dev, VL53L1X_DSS_CONFIG__TARGET_TOTAL_RATE_MCPS, _target_rate)); + EXEC_RET(_write_byte(dev, VL53L1X_GPIO__TIO_HV_STATUS, 0x02)); + EXEC_RET(_write_byte(dev, VL53L1X_SIGMA_ESTIMATOR__EFFECTIVE_PULSE_WIDTH_NS, 8)); + EXEC_RET(_write_byte(dev, VL53L1X_SIGMA_ESTIMATOR__EFFECTIVE_AMBIENT_WIDTH_NS, 16)); + EXEC_RET(_write_byte(dev, VL53L1X_ALGO__CROSSTALK_COMPENSATION_VALID_HEIGHT_MM, 0x01)); + EXEC_RET(_write_byte(dev, VL53L1X_ALGO__RANGE_IGNORE_VALID_HEIGHT_MM, 0xff)); + EXEC_RET(_write_byte(dev, VL53L1X_ALGO__RANGE_MIN_CLIP, 0)); + EXEC_RET(_write_byte(dev, VL53L1X_ALGO__CONSISTENCY_CHECK__TOLERANCE, 2)); + + /* general config */ + EXEC_RET(_write_word(dev, VL53L1X_SYSTEM__THRESH_RATE_HIGH, 0x0000)); + EXEC_RET(_write_word(dev, VL53L1X_SYSTEM__THRESH_RATE_LOW, 0x0000)); + EXEC_RET(_write_byte(dev, VL53L1X_DSS_CONFIG__APERTURE_ATTENUATION, 0x38)); + + /* + * timing config (most of these settings will be determined later by distance + * and timing budget configuration + */ + EXEC_RET(_write_word(dev, VL53L1X_RANGE_CONFIG__SIGMA_THRESH, 360)); + EXEC_RET(_write_word(dev, VL53L1X_RANGE_CONFIG__MIN_COUNT_RATE_RTN_LIMIT_MCPS, 192)); + + /* dynamic config */ + + EXEC_RET(_write_byte(dev, VL53L1X_SYSTEM__GROUPED_PARAMETER_HOLD_0, 0x01)); + EXEC_RET(_write_byte(dev, VL53L1X_SYSTEM__GROUPED_PARAMETER_HOLD_1, 0x01)); + EXEC_RET(_write_byte(dev, VL53L1X_SD_CONFIG__QUANTIFIER, 2)); + + /* + * from VL53L1_preset_mode_timed_ranging_* + * GPH is 0 after reset, but writing GPH0 and GPH1 above seem to set GPH + * to 1, and things don't seem to work if we don't set GPH back to 0 (which + * the API does here). + */ + EXEC_RET(_write_byte(dev, VL53L1X_SYSTEM__GROUPED_PARAMETER_HOLD, 0x00)); + EXEC_RET(_write_byte(dev, VL53L1X_SYSTEM__SEED_CONFIG, 1)); + + /* from VL53L1_config_low_power_auto_mode */ + EXEC_RET(_write_byte(dev, VL53L1X_SYSTEM__SEQUENCE_CONFIG, 0x8B)); + EXEC_RET(_write_word(dev, VL53L1X_DSS_CONFIG__MANUAL_EFFECTIVE_SPADS_SELECT, 200 << 8)); + EXEC_RET(_write_byte(dev, VL53L1X_DSS_CONFIG__ROI_MODE_CONTROL, 2)); + + /* default to long range, 50 ms timing budget */ + EXEC_RET(vl53l1x_set_distance_mode(dev, VL53L1X_DIST_LONG)); + EXEC_RET(vl53l1x_set_timing_budget(dev, 50000)); + + /* + * the API triggers this change in VL53L1_init_and_start_range() once a + * measurement is started; assumes MM1 and MM2 are disabled + */ + uint16_t word; + EXEC_RET(_read_word(dev, VL53L1X_MM_CONFIG__OUTER_OFFSET_MM, &word)); + word *= 4; + EXEC_RET(_write_word(dev, VL53L1X_ALGO__PART_TO_PART_RANGE_OFFSET_MM, word)); + + /* Copyrighted POLOLU / ST API code end */ + +#endif /* IS_USED(MODULE_VL53L1X_ST_API) */ + + /* set measurement parameters */ + EXEC_RET(vl53l1x_set_distance_mode(dev, dev->params.mode)); + EXEC_RET(vl53l1x_set_timing_budget(dev, dev->params.budget)); + EXEC_RET(vl53l1x_set_measurement_period(dev, dev->params.period)); + +#endif /* IS_USED(MODULE_VL53L1X_BASIC) */ + + /* start measurement */ + EXEC_RET(_start(dev)); + + return VL53L1X_OK; +} + +#define VL53L1X_BOOT_TIMEOUT 10 /* 10 ms */ + +static int _reset(vl53l1x_t *dev) +{ +#if IS_USED(MODULE_VL53L1X_ST_API) + + /* write reset impuls for 150 us */ + VL53L1_software_reset(&dev->dev); + + /* give the sensor some time to boot */ + ztimer_sleep(ZTIMER_MSEC, 4); + + /* wait until the sensor has been booted */ + EXEC_RET(VL53L1_WaitDeviceBooted(&dev->dev)); + + /* set VDDIO */ + EXEC_RET(VL53L1_UpdateByte(&dev->dev, + VL53L1X_PAD_I2C_HV__EXTSUP_CONFIG, + 0xfe, dev->params.vddio_2v8 ? 1 : 0)); + +#else /* IS_USED(MODULE_VL53L1X_ST_API) */ + + /* write reset impuls of at least 100 us, we use 1 ms */ + _write_byte(dev, VL53L1X_SOFT_RESET, 0); + ztimer_sleep(ZTIMER_MSEC, 1); + _write_byte(dev, VL53L1X_SOFT_RESET, 1); + + /* wait until the sensor has been booted in 1 ms steps*/ + unsigned timeout = VL53L1X_BOOT_TIMEOUT; + uint8_t res; + while (timeout--) { + if ((_read_byte(dev, VL53L1X_FIRMWARE__SYSTEM_STATUS, &res) == VL53L1X_OK) && + (res & 0x01) == 1) { + break; + } + ztimer_sleep(ZTIMER_MSEC, 1); + } + if (timeout == 0) { + DEBUG_DEV("could not boot the sensor", dev); + return VL53L1X_ERROR_TIMEOUT; + } + + /* set VDDIO */ + EXEC_RET(_update(dev, VL53L1X_PAD_I2C_HV__EXTSUP_CONFIG, + 0xfe, dev->params.vddio_2v8 ? 1 : 0)); + +#endif /* IS_USED(MODULE_VL53L1X_ST_API) */ + + return VL53L1X_OK; +} + +#if !IS_USED(MODULE_VL53L1X_ST_API) + +static int _start(const vl53l1x_t *dev) +{ + /* Copyrighted POLOLU / ST API code begin */ + + /* from VL53L1_set_inter_measurement_period_ms() */ + EXEC_RET(_write_byte(dev, VL53L1X_SYSTEM__INTERRUPT_CLEAR, 0x01)); + EXEC_RET(_write_byte(dev, VL53L1X_SYSTEM__MODE_START, 0x40)); + + /* Copyrighted POLOLU / ST API code end */ + return VL53L1X_OK; +} + +/* Copyrighted POLOLU / ST API code begin */ + +#if !IS_USED(MODULE_VL53L1X_BASIC) + +static uint32_t _dec_timeout(uint16_t val) +{ + /* + * Decode sequence step timeout in MCLKs from register value based + * on VL53L1_decode_timeout() + */ + return ((uint32_t)(val & 0xff) << (val >> 8)) + 1; +} + +static uint16_t _enc_timeout(uint32_t clks) +{ + /* + * Encode sequence step timeout register value from timeout in MCLKs + * based on VL53L1_enc_timeout() + * encoded format: "(LSByte * 2^MSByte) + 1" + */ + if (clks > 0) { + uint32_t ls_byte = clks - 1; + uint16_t ms_byte = 0; + while ((ls_byte & 0xFFFFFF00) > 0) { + ls_byte >>= 1; + ms_byte++; + } + return (ms_byte << 8) | (ls_byte & 0xFF); + } + else { + return 0; + } +} + +static uint32_t _timeout_clk_to_us(uint32_t clks, uint32_t period_us) +{ + /* + * Convert sequence step timeout from macro periods to microseconds with + * given macro period in microseconds (12.12 format) based on + * VL53L1_calc_timeout_us() + */ + return ((uint64_t)clks * period_us + 0x800) >> 12; +} + +static uint32_t _timeout_us_to_clk(uint32_t us, uint32_t period_us) +{ + /* + * Convert sequence step timeout from microseconds to macro periods with + * given macro period in microseconds (12.12 format) based on + * VL53L1_calc_timeout_mclks() + */ + return (((uint32_t)us << 12) + (period_us >> 1)) / period_us; +} + +static uint32_t _calc_macro_period(const vl53l1x_t *dev, uint8_t vcsel_period) +{ + /* + * Calculate macro period in microseconds (12.12 format) with given VCSEL + * period assumes fast_osc_frequency has been read and stored based on + * VL53L1_calc_macro_period_us() + */ + + /* fast osc frequency in 4.12 format; PLL period in 0.24 format */ + uint32_t pll_period_us = ((uint32_t)0x01 << 30) / dev->fast_osc_frequency; + + /* from VL53L1_decode_vcsel_period() */ + uint8_t vcsel_period_pclks = (vcsel_period + 1) << 1; + + /* VL53L1_MACRO_PERIOD_VCSEL_PERIODS = 2304 */ + uint32_t period_us = (uint32_t)2304 * pll_period_us; + period_us >>= 6; + period_us *= vcsel_period_pclks; + period_us >>= 6; + + return period_us; +} + +static int _setup_manual_calibration(const vl53l1x_t *dev) +{ + ASSERT_PARAM(dev != NULL); + DEBUG_DEV("", dev); + + /* + * Setup ranges after the first one in low power auto mode by turning off + * FW calibration steps and programming static values + * based on VL53L1_low_power_auto_setup_manual_calibration() + */ + + uint8_t saved_vhv_init; + uint8_t saved_vhv_timeout; + + /* save original vhv configs */ + EXEC_RET(_read_byte(dev, VL53L1X_VHV_CONFIG__INIT, &saved_vhv_init)); + EXEC_RET(_read_byte(dev, VL53L1X_VHV_CONFIG__TIMEOUT_MACROP_LOOP_BOUND, + &saved_vhv_timeout)); + /* disable VHV init */ + EXEC_RET(_write_byte(dev, VL53L1X_VHV_CONFIG__INIT, + saved_vhv_init & 0x7f)); + + /* set loop bound to tuning param */ + EXEC_RET(_write_byte(dev, VL53L1X_VHV_CONFIG__TIMEOUT_MACROP_LOOP_BOUND, + (saved_vhv_timeout & 0x03) + (3 << 2))); + + /* override phasecal */ + uint8_t reg; + EXEC_RET(_write_byte(dev, VL53L1X_PHASECAL_CONFIG__OVERRIDE, 0x01)); + EXEC_RET(_read_byte(dev, VL53L1X_PHASECAL_RESULT__VCSEL_START, ®)); + EXEC_RET(_write_byte(dev, VL53L1X_CAL_CONFIG__VCSEL_START, reg)); + + return VL53L1X_OK; +} + +#endif /* IS_USED(MODULE_VL53L1X_BASIC) */ + +static int _update_dss(const vl53l1x_t *dev, _vl53l1x_raw_data_t* raw) +{ + ASSERT_PARAM(dev != NULL); + ASSERT_PARAM(raw != NULL); + DEBUG_DEV("raw=%p", dev, raw); + + uint16_t spad_count; + uint32_t peak; + uint32_t ambient; + + spad_count = (uint16_t)raw->dss_actual_effective_spads_sd0_hi << 8; + spad_count |= raw->dss_actual_effective_spads_sd0_lo; + + peak = (uint32_t)raw->peak_signal_count_rate_crosstalk_corrected_mcps_sd0_hi << 8; + peak |= raw->peak_signal_count_rate_crosstalk_corrected_mcps_sd0_lo; + + ambient = (uint32_t)raw->ambient_count_rate_mcps_sd0_hi << 8; + ambient |= raw->ambient_count_rate_mcps_sd0_lo; + + if (spad_count != 0) { + uint32_t total_rate; + /* Calc total rate per spad */ + total_rate = peak + ambient; + /* clip to 16 bits */ + total_rate = (total_rate > 0xffff) ? 0xffff : total_rate; + /* shift up to take advantage of 32 bits */ + total_rate <<= 16; + + total_rate /= spad_count; + + if (total_rate != 0) { + /* get the target rate and shift up by 16 */ + uint32_t req_spads = ((uint32_t)_target_rate << 16) / total_rate; + /* clip to 16 bits */ + req_spads = (req_spads > 0xffff) ? 0xffff : req_spads; + + /* override DSS config */ + EXEC_RET(_write_word(dev, VL53L1X_DSS_CONFIG__MANUAL_EFFECTIVE_SPADS_SELECT, + req_spads)); + /* + * VL53L1X_DSS_CONFIG__ROI_MODE_CONTROL should already be set to + * REQUESTED_EFFFECTIVE_SPADS + */ + + return VL53L1X_OK; + } + } + + /* + * If we reached this point, it means something above would have resulted + * in a divide by zero. We want to gracefully set a spad target, not just + * exit with an error + */ + /* set target to mid point */ + EXEC_RET(_write_word(dev, VL53L1X_DSS_CONFIG__MANUAL_EFFECTIVE_SPADS_SELECT, + 0x8000)); + return VL53L1X_OK; +} + +/* Copyrighted POLOLU / ST API code end */ + +#define VL53L1X_BUFSIZ 32 +static uint8_t _buffer[VL53L1X_BUFSIZ] = {}; + +static int _read_byte(const vl53l1x_t *dev, uint16_t index, uint8_t *data) +{ + return _read(dev, index, data, 1); +} + +static int _read_word(const vl53l1x_t *dev, uint16_t index, uint16_t *data) +{ + uint8_t bytes[2]; + EXEC_RET(_read(dev, index, bytes, 2)); + *data = ((uint16_t)bytes[0] << 8) + (bytes[1]); + + return VL53L1X_OK; +} + +static int _read(const vl53l1x_t *dev, uint16_t index, uint8_t *pdata, uint32_t len) +{ + ASSERT_PARAM(dev != NULL); + ASSERT_PARAM(pdata != NULL); + DEBUG_DEV("index=%04x pdata=%p len=%u", dev, index, pdata, len); + + /* acquire the I2C device */ + i2c_acquire(dev->params.i2c_dev); + + /* read blockwise with a maximum size of VL53L1X_BUFSIZ */ + while (len) { + + uint8_t bytes[2] = { (index >> 8) & 0xff, index & 0xff }; + + /* write the register index for the block */ + if (i2c_write_bytes(dev->params.i2c_dev, VL53L1X_I2C_ADDRESS, bytes, 2, 0) != 0) { + i2c_release(dev->params.i2c_dev); + return VL53L1X_ERROR_I2C; + } + + uint8_t cnt = (len < VL53L1X_BUFSIZ) ? len : VL53L1X_BUFSIZ; + + if (i2c_read_bytes(dev->params.i2c_dev, VL53L1X_I2C_ADDRESS, _buffer, cnt, 0) != 0) { + i2c_release(dev->params.i2c_dev); + return VL53L1X_ERROR_I2C; + } + + memcpy(pdata, _buffer, cnt); + len -= cnt; + pdata += cnt; + index += cnt; + } + + /* release the I2C device */ + i2c_release(dev->params.i2c_dev); + + return VL53L1X_OK; +} + +static int _write_byte(const vl53l1x_t *dev, uint16_t index, uint8_t data) +{ + return _write(dev, index, &data, 1); +} + +static int _write_word(const vl53l1x_t *dev, uint16_t index, uint16_t data) +{ + uint8_t bytes[2] = { (data >> 8) & 0xff, data & 0xff }; + return _write(dev, index, (uint8_t*)&bytes, 2); +} + +#if !IS_USED(MODULE_VL53L1X_BASIC) +static int _write_dword(const vl53l1x_t *dev, uint16_t index, uint32_t data) +{ + uint8_t bytes[4] = { (data >> 24) & 0xff, (data >> 16) & 0xff, + (data >> 8) & 0xff, data & 0xff }; + return _write(dev, index, (uint8_t*)&bytes, 4); +} +#endif /* !IS_USED(MODULE_VL53L1X_BASIC) */ + +static int _write(const vl53l1x_t *dev, uint16_t index, const uint8_t *pdata, uint32_t len) +{ + ASSERT_PARAM(dev != NULL); + ASSERT_PARAM(pdata != NULL); + DEBUG_DEV("index=%04x pdata=%p len=%u", dev, index, pdata, len); + + assert(!irq_is_in()); + i2c_acquire(dev->params.i2c_dev); + + /* write blockwise with a maximum size of VL53L1X_BUFSIZ-2 */ + while (len) { + + uint8_t cnt = (len < (VL53L1X_BUFSIZ - 2)) ? len : VL53L1X_BUFSIZ - 2; + + /* fill the first 2 bytes of the buffer with the index */ + _buffer[0] = (index >> 8) & 0xff; + _buffer[1] = index & 0xff; + + /* fill the buffer with data bytes */ + memcpy(_buffer + 2, pdata, cnt); + + if (i2c_write_bytes(dev->params.i2c_dev, VL53L1X_I2C_ADDRESS, _buffer, cnt + 2, 0) != 0) { + i2c_release(dev->params.i2c_dev); + return VL53L1X_ERROR_I2C; + } + len -= cnt; + pdata += cnt; + index += cnt; + } + + /* release the I2C device */ + i2c_release(dev->params.i2c_dev); + + return VL53L1X_OK; +} + +static int _update(const vl53l1x_t *dev, uint16_t index, uint8_t mask, + uint8_t data) +{ + uint8_t byte; + EXEC_RET(_read_byte(dev, index, &byte)); + byte &= mask; + byte |= data; + EXEC_RET(_write_byte(dev, index, byte)); + + return VL53L1X_OK; +} + +#endif /* !IS_USED(MODULE_VL53L1X_ST_API) */ From 31cbc2a7a8e28ecfd633c78494100e74e0b58f24 Mon Sep 17 00:00:00 2001 From: Gunar Schorcht Date: Sun, 12 Dec 2021 13:51:51 +0100 Subject: [PATCH 02/18] pkg/driver_vl53l1x_st_api: vendor API used by vl53l1x driver --- pkg/driver_vl53l1x_st_api/Makefile | 14 + pkg/driver_vl53l1x_st_api/Makefile.include | 1 + pkg/driver_vl53l1x_st_api/doc.txt | 25 ++ .../driver_vl53l1x_st_api.mk | 5 + pkg/driver_vl53l1x_st_api/platform/Makefile | 3 + .../platform/vl53l1_platform.c | 413 ++++++++++++++++++ 6 files changed, 461 insertions(+) create mode 100644 pkg/driver_vl53l1x_st_api/Makefile create mode 100644 pkg/driver_vl53l1x_st_api/Makefile.include create mode 100644 pkg/driver_vl53l1x_st_api/doc.txt create mode 100644 pkg/driver_vl53l1x_st_api/driver_vl53l1x_st_api.mk create mode 100644 pkg/driver_vl53l1x_st_api/platform/Makefile create mode 100644 pkg/driver_vl53l1x_st_api/platform/vl53l1_platform.c diff --git a/pkg/driver_vl53l1x_st_api/Makefile b/pkg/driver_vl53l1x_st_api/Makefile new file mode 100644 index 000000000000..13e04fcbb2da --- /dev/null +++ b/pkg/driver_vl53l1x_st_api/Makefile @@ -0,0 +1,14 @@ +PKG_NAME=driver_vl53l1x_st_api +PKG_URL=https://github.com/pololu/vl53l1x-st-api-arduino.git +PKG_VERSION=5713cac245a6568273b9d5def7880c50ef7ddde0 +PKG_LICENSE=BSD3 + +include $(RIOTBASE)/pkg/pkg.mk + +.PHONY: all + +all: + rm -f $(PKG_SOURCE_DIR)/vl53l1x-st-api/vl53l1x-st-api.ino + rm -f $(PKG_SOURCE_DIR)/vl53l1x-st-api/vl53l1_platform.c + rm -f $(PKG_SOURCE_DIR)/vl53l1x-st-api/vl53l1_platform.cpp + $(QQ)"$(MAKE)" -C $(PKG_SOURCE_DIR)/vl53l1x-st-api -f $(CURDIR)/$(PKG_NAME).mk diff --git a/pkg/driver_vl53l1x_st_api/Makefile.include b/pkg/driver_vl53l1x_st_api/Makefile.include new file mode 100644 index 000000000000..2a0491e52863 --- /dev/null +++ b/pkg/driver_vl53l1x_st_api/Makefile.include @@ -0,0 +1 @@ +INCLUDES += -I$(PKGDIRBASE)/driver_vl53l1x_st_api/vl53l1x-st-api diff --git a/pkg/driver_vl53l1x_st_api/doc.txt b/pkg/driver_vl53l1x_st_api/doc.txt new file mode 100644 index 000000000000..ac025e20b753 --- /dev/null +++ b/pkg/driver_vl53l1x_st_api/doc.txt @@ -0,0 +1,25 @@ +/** + * @defgroup pkg_driver_vl53l1x_st_api VL53L1X Driver API package + * @ingroup pkg + * @brief Driver API package for the ST VL53L1X Time-of-Flight (ToF) ranging sensor + * @see drivers_vl53l1x + * @see [VL53L1X API user manual](https://www.st.com/resource/en/user_manual/dm00474730.pdf) + * + * This package provides ST's STSW-IMG007 VL53L1X API as part of the + * Pololu AVL53L1X library for Arduino. It is required for the + * VL53L1X Time-of-Flight (ToF) ranging sensor driver, see @ref drivers_vl53l1x. + * + * ST's STSW-IMG007 VL53L1X API gives the application access to the complete + * functionality of ST VL53L1X Time-of-Flight (ToF) ranging sensors in + * addition to the functionality realized by the \ref drivers_vl53l1x driver + * module. + * + * For details on how to use this API, please refer + * [the users manual](https://www.st.com/resource/en/user_manual/dm00474730.pdf). + * + * ST's STSW-IMG007 VL53L1X API is very complex and therefore large. + * + * @note To use the ST VL53L1X Time-of-Flight (ToF) ranging sensor, + * the \ref vl53l1x_st_api driver module has to be used, + * see @ref drivers_vl53l1x. + */ diff --git a/pkg/driver_vl53l1x_st_api/driver_vl53l1x_st_api.mk b/pkg/driver_vl53l1x_st_api/driver_vl53l1x_st_api.mk new file mode 100644 index 000000000000..0ff3b17aa494 --- /dev/null +++ b/pkg/driver_vl53l1x_st_api/driver_vl53l1x_st_api.mk @@ -0,0 +1,5 @@ +MODULE = driver_vl53l1x_st_api + +DIRS += $(RIOTBASE)/pkg/driver_vl53l1x_st_api/platform + +include $(RIOTBASE)/Makefile.base diff --git a/pkg/driver_vl53l1x_st_api/platform/Makefile b/pkg/driver_vl53l1x_st_api/platform/Makefile new file mode 100644 index 000000000000..018efcabcb23 --- /dev/null +++ b/pkg/driver_vl53l1x_st_api/platform/Makefile @@ -0,0 +1,3 @@ +MODULE = driver_vl53l1x_st_api_platform + +include $(RIOTBASE)/Makefile.base diff --git a/pkg/driver_vl53l1x_st_api/platform/vl53l1_platform.c b/pkg/driver_vl53l1x_st_api/platform/vl53l1_platform.c new file mode 100644 index 000000000000..b8302374922f --- /dev/null +++ b/pkg/driver_vl53l1x_st_api/platform/vl53l1_platform.c @@ -0,0 +1,413 @@ +/* + * Copyright (c) 2017, STMicroelectronics - All Rights Reserved + * + * This file is part of VL53L1 Core and is dual licensed, + * either 'STMicroelectronics + * Proprietary license' + * or 'BSD 3-clause "New" or "Revised" License' , at your option. + * + ******************************************************************************* + * + * 'STMicroelectronics Proprietary license' + * + ******************************************************************************* + * + * License terms: STMicroelectronics Proprietary in accordance with licensing + * terms at www.st.com/sla0081 + * + * STMicroelectronics confidential + * Reproduction and Communication of this document is strictly prohibited unless + * specifically authorized in writing by STMicroelectronics. + * + * + ******************************************************************************* + * + * Alternatively, VL53L1 Core may be distributed under the terms of + * 'BSD 3-clause "New" or "Revised" License', in which case the following + * provisions apply instead of the ones mentioned above : + * + ******************************************************************************* + * + * License terms: BSD 3-clause "New" or "Revised" License. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * + ******************************************************************************* + */ + +/** + * Platform dependent I2C implementation + * + * Copyright (C) 2021 Gunar Schorcht + */ + + +#include "vl53l1_platform.h" +#include "vl53l1_api.h" + +#include + +#include "periph/i2c.h" +#include "xtimer.h" + +#include "vl53l1x.h" + +#define ENABLE_DEBUG (0) +#include "debug.h" + +#define VL53L1_I2C_DEV (((vl53l1x_t*)Dev)->params.i2c_dev) +#define VL53L1_I2C_ADDR (Dev->I2cDevAddr) +#define VL5321_ERROR_I2C ((VL53L1_ERROR_PLATFORM_SPECIFIC_START) - 1) + +#if ENABLE_DEBUG + +#define ASSERT_PARAM(cond) \ + if (!(cond)) { \ + DEBUG("[vl53l1x] %s: %s\n", \ + __func__, "parameter condition (" # cond ") not fulfilled"); \ + assert(cond); \ + } + +#define DEBUG_DEV(f, Dev, ...) \ + DEBUG("[vl53l1x] %s i2c dev=%d addr=%02x: " f "\n", \ + __func__, VL53L1_I2C_DEV, VL53L1_I2C_ADDR, ## __VA_ARGS__); + +#define DEBUG_NODEV(f, ...) \ + DEBUG("[vl53l1x] %s: " f "\n", \ + __func__, ## __VA_ARGS__); + +#else /* ENABLE_DEBUG */ + +#define ASSERT_PARAM(cond) assert(cond); +#define DEBUG_DEV(f, Dev, ...) +#define DEBUG_NODEV(f, ...) + +#endif /* ENABLE_DEBUG */ + +#define VL53L1_BUFSIZ 32 + +static uint8_t _buffer[VL53L1_BUFSIZ]; + +VL53L1_Error VL53L1_WriteMulti(VL53L1_DEV Dev, + uint16_t index, uint8_t *pdata, uint32_t count) +{ + ASSERT_PARAM(Dev != NULL); + ASSERT_PARAM(pdata != NULL); + DEBUG_DEV("index=%04x pdata=%p count=%u", Dev, index, pdata, count); + + i2c_acquire(VL53L1_I2C_DEV); + + /* write blockwise with a maximum size of VL53L1_BUFSIZ-2 */ + while (count) { + + uint8_t cnt = (count < (VL53L1_BUFSIZ - 2)) ? count : VL53L1_BUFSIZ - 2; + + /* fill the first 2 bytes of the buffer with the index */ + _buffer[0] = (index >> 8) & 0xff; + _buffer[1] = index & 0xff; + + /* fill the buffer with data bytes */ + memcpy(_buffer + 2, pdata, cnt); + + if (i2c_write_bytes(VL53L1_I2C_DEV, VL53L1_I2C_ADDR, _buffer, cnt + 2, 0) != 0) { + i2c_release(VL53L1_I2C_DEV); + return VL5321_ERROR_I2C; + } + count -= cnt; + pdata += cnt; + index += cnt; + } + + /* release the I2C device */ + i2c_release(VL53L1_I2C_DEV); + + return VL53L1_ERROR_NONE; +} + +VL53L1_Error VL53L1_ReadMulti(VL53L1_DEV Dev, + uint16_t index, uint8_t *pdata, uint32_t count) +{ + ASSERT_PARAM(Dev != NULL); + ASSERT_PARAM(pdata != NULL); + DEBUG_DEV("index=%04x pdata=%p count=%u", Dev, index, pdata, count); + + /* acquire the I2C device */ + i2c_acquire(VL53L1_I2C_DEV); + + /* read blockwise with a maximum size of VL53L1_BUFSIZ */ + while (count) { + + uint8_t bytes[2] = { (index >> 8) & 0xff, index & 0xff }; + + /* write the register index for the block */ + if (i2c_write_bytes(VL53L1_I2C_DEV, VL53L1_I2C_ADDR, bytes, 2, 0) != 0) { + i2c_release(VL53L1_I2C_DEV); + return VL5321_ERROR_I2C; + } + + uint8_t cnt = (count < VL53L1_BUFSIZ) ? count : VL53L1_BUFSIZ; + + if (i2c_read_bytes(VL53L1_I2C_DEV, VL53L1_I2C_ADDR, _buffer, cnt, 0) != 0) { + i2c_release(VL53L1_I2C_DEV); + return VL5321_ERROR_I2C; + } + + memcpy(pdata, _buffer, cnt); + count -= cnt; + pdata += cnt; + index += cnt; + } + + /* release the I2C device */ + i2c_release(VL53L1_I2C_DEV); + + return VL53L1_ERROR_NONE; +} + +VL53L1_Error VL53L1_WrByte(VL53L1_DEV Dev, uint16_t index, uint8_t data) +{ + VL53L1_Error Status = VL53L1_ERROR_NONE; + + ASSERT_PARAM(Dev != NULL); + DEBUG_DEV("index=%04x data=%02x", Dev, index, data); + + i2c_acquire(VL53L1_I2C_DEV); + + uint8_t bytes[3] = { (index >> 8) & 0xff, index & 0xff, data }; + + if (i2c_write_bytes(VL53L1_I2C_DEV, VL53L1_I2C_ADDR, bytes, 3, 0) != 0) { + Status = VL5321_ERROR_I2C; + } + + i2c_release(VL53L1_I2C_DEV); + + return Status; +} + +VL53L1_Error VL53L1_WrWord(VL53L1_DEV Dev, uint16_t index, uint16_t data) +{ + VL53L1_Error Status = VL53L1_ERROR_NONE; + + ASSERT_PARAM(Dev != NULL); + DEBUG_DEV("index=%04x data=%04x", Dev, index, data); + + i2c_acquire(VL53L1_I2C_DEV); + + uint8_t bytes[4] = { (index >> 8) & 0xff, index & 0xff, + (data >> 8) & 0xff, data & 0xff }; + + if (i2c_write_bytes(VL53L1_I2C_DEV, VL53L1_I2C_ADDR, bytes, 4, 0) != 0) { + Status = VL5321_ERROR_I2C; + } + + i2c_release(VL53L1_I2C_DEV); + + return Status; +} + +VL53L1_Error VL53L1_WrDWord(VL53L1_DEV Dev, uint16_t index, uint32_t data) +{ + VL53L1_Error Status = VL53L1_ERROR_NONE; + + ASSERT_PARAM(Dev != NULL); + DEBUG_DEV("index=%04x data=%08x", Dev, index, data); + + i2c_acquire(VL53L1_I2C_DEV); + + uint8_t bytes[6] = { (index >> 8) & 0xff, index & 0xff, + (data >> 24) & 0xff, (data >> 16) & 0xff, + (data >> 8) & 0xff, data & 0xff }; + + if (i2c_write_bytes(VL53L1_I2C_DEV, VL53L1_I2C_ADDR, bytes, 6, 0) != 0) { + Status = VL5321_ERROR_I2C; + } + + i2c_release(VL53L1_I2C_DEV); + + return Status; +} + +VL53L1_Error VL53L1_UpdateByte(VL53L1_DEV Dev, + uint16_t index, uint8_t AndData, uint8_t OrData) +{ + ASSERT_PARAM(Dev != NULL); + DEBUG_DEV("index=%04x and=%02x or=%02x", Dev, index, AndData, OrData); + + uint8_t data; + VL53L1_Error status = VL53L1_RdByte(Dev, index, &data); + if (status != VL53L1_ERROR_NONE) { + return status; + } + data &= AndData; + data |= OrData; + + return VL53L1_WrByte(Dev, index, data); +} + +VL53L1_Error VL53L1_RdByte(VL53L1_DEV Dev, uint16_t index, uint8_t *data) +{ + VL53L1_Error Status = VL53L1_ERROR_NONE; + + ASSERT_PARAM(Dev != NULL); + ASSERT_PARAM(data != NULL); + DEBUG_DEV("index=%04x data=%p", Dev, index, data); + + i2c_acquire(VL53L1_I2C_DEV); + + uint8_t bytes[2] = { (index >> 8) & 0xff, index & 0xff }; + + if (i2c_write_bytes(VL53L1_I2C_DEV, VL53L1_I2C_ADDR, bytes, 2, 0) != 0 || + i2c_read_byte(VL53L1_I2C_DEV, VL53L1_I2C_ADDR, data, 0) != 0) { + Status = VL5321_ERROR_I2C; + } + + i2c_release(VL53L1_I2C_DEV); + + return Status; +} + +VL53L1_Error VL53L1_RdWord(VL53L1_DEV Dev, uint16_t index, uint16_t *data) +{ + VL53L1_Error Status = VL53L1_ERROR_NONE; + + ASSERT_PARAM(Dev != NULL); + ASSERT_PARAM(data != NULL); + DEBUG_DEV("index=%04x data=%p", Dev, index, data); + + i2c_acquire(VL53L1_I2C_DEV); + + uint8_t bytes[2] = { (index >> 8) & 0xff, index & 0xff }; + + if (i2c_write_bytes(VL53L1_I2C_DEV, VL53L1_I2C_ADDR, bytes, 2, 0) != 0 || + i2c_read_bytes(VL53L1_I2C_DEV, VL53L1_I2C_ADDR, bytes, 2, 0) != 0) { + Status = VL5321_ERROR_I2C; + } + *data = (bytes[0] << 8) + (bytes[1]); + + i2c_release(VL53L1_I2C_DEV); + + return Status; +} + +VL53L1_Error VL53L1_RdDWord(VL53L1_DEV Dev, uint16_t index, uint32_t *data) +{ + VL53L1_Error Status = VL53L1_ERROR_NONE; + + ASSERT_PARAM(Dev != NULL); + ASSERT_PARAM(data != NULL); + DEBUG_DEV("index=%04x data=%p", Dev, index, data); + + i2c_acquire(VL53L1_I2C_DEV); + + uint8_t bytes[4] = { (index >> 8) & 0xff, index & 0xff }; + + if (i2c_write_bytes(VL53L1_I2C_DEV, VL53L1_I2C_ADDR, bytes, 2, 0) != 0 || + i2c_read_bytes(VL53L1_I2C_DEV, VL53L1_I2C_ADDR, bytes, 4, 0) != 0) { + Status = VL5321_ERROR_I2C; + } + *data = (bytes[0] << 24) + (bytes[1] << 16) + (bytes[2] << 8) + (bytes[3]); + + i2c_release(VL53L1_I2C_DEV); + + return Status; +} + +VL53L1_Error VL53L1_GetTickCount(uint32_t *ptick_count_ms) +{ + VL53L1_Error status = VL53L1_ERROR_NONE; + + ASSERT_PARAM(ptick_count_ms != NULL); + DEBUG_NODEV("ptick_count_ms=%p", ptick_count_ms); + + uint64_t time = xtimer_now_usec64(); + *ptick_count_ms = time / (US_PER_MS); + + return status; +} + +VL53L1_Error VL53L1_GetTimerFrequency(int32_t *ptimer_freq_hz) +{ + VL53L1_Error status = VL53L1_ERROR_NONE; + + ASSERT_PARAM(ptimer_freq_hz != NULL); + DEBUG_NODEV("ptimer_freq_hz=%p", ptimer_freq_hz); + + *ptimer_freq_hz = (US_PER_MS * MS_PER_SEC); + + return status; +} + +VL53L1_Error VL53L1_WaitMs(VL53L1_Dev_t *pdev, int32_t wait_ms){ + VL53L1_Error status = VL53L1_ERROR_NONE; + + ASSERT_PARAM(pdev != NULL); + DEBUG_NODEV("wait_ms=%d", wait_ms); + + xtimer_usleep (wait_ms * US_PER_MS); + + return status; +} + +VL53L1_Error VL53L1_WaitUs(VL53L1_Dev_t *pdev, int32_t wait_us) +{ + VL53L1_Error status = VL53L1_ERROR_NONE; + + ASSERT_PARAM(pdev != NULL); + DEBUG_NODEV("wait_us=%d", wait_us); + + xtimer_usleep (wait_us); + + return status; +} + +VL53L1_Error VL53L1_WaitValueMaskEx(VL53L1_Dev_t *pdev, + uint32_t timeout_ms, + uint16_t index, + uint8_t value, + uint8_t mask, + uint32_t poll_delay_ms) +{ + VL53L1_Error status = VL53L1_ERROR_NONE; + + ASSERT_PARAM(pdev != NULL); + DEBUG_NODEV("index=%04x value=%02x mask=%02x timeout_ms=%u poll_delay_ms=%u", + index, value, mask, timeout_ms, poll_delay_ms); + + uint8_t data; + while (timeout_ms > 0) { + if ((status = VL53L1_RdByte(pdev, index, &data)) != VL53L1_ERROR_NONE) { + return status; + } + if ((data & mask) == value) { + return VL53L1_ERROR_NONE; + } + xtimer_usleep(poll_delay_ms * US_PER_MS); + timeout_ms -= (poll_delay_ms < timeout_ms) ? poll_delay_ms : timeout_ms; + } + + return status; +} From b85d14e681c4999c2d60456c3de5a170def34759 Mon Sep 17 00:00:00 2001 From: Gunar Schorcht Date: Sun, 12 Dec 2021 13:54:16 +0100 Subject: [PATCH 03/18] drivers/vl53l1x: SAUL integration --- drivers/saul/init_devs/auto_init_vl53l1x.c | 72 ++++++++++++++++++++++ drivers/saul/init_devs/init.c | 4 ++ drivers/vl53l1x/vl53l1x_saul.c | 36 +++++++++++ 3 files changed, 112 insertions(+) create mode 100644 drivers/saul/init_devs/auto_init_vl53l1x.c create mode 100644 drivers/vl53l1x/vl53l1x_saul.c diff --git a/drivers/saul/init_devs/auto_init_vl53l1x.c b/drivers/saul/init_devs/auto_init_vl53l1x.c new file mode 100644 index 000000000000..ecbd90d9eee8 --- /dev/null +++ b/drivers/saul/init_devs/auto_init_vl53l1x.c @@ -0,0 +1,72 @@ +/* + * Copyright (C) 2021 Gunar Schorcht + * + * This file is subject to the terms and conditions of the GNU Lesser + * General Public License v2.1. See the file LICENSE in the top level + * directory for more details. + * + */ + +/* + * @ingroup drivers_vl53l1x + * @ingroup sys_auto_init_saul + * @brief Auto initialization of ST VL53L1X Time-of-Flight (ToF) ranging sensor + * @author Gunar Schorcht + * @file + */ + +#ifdef MODULE_VL53L1X + +#include "assert.h" +#include "log.h" +#include "saul_reg.h" +#include "vl53l1x.h" +#include "vl53l1x_params.h" + +/** + * @brief Define the number of configured sensors + */ +#define VL53L1X_NUM (sizeof(vl53l1x_params) / sizeof(vl53l1x_params[0])) + +/** + * @brief Allocate memory for the device descriptors + */ +static vl53l1x_t vl53l1x_devs[VL53L1X_NUM]; + +/** + * @brief Memory for the SAUL registry entries + */ +static saul_reg_t saul_entries[VL53L1X_NUM]; + +/** + * @brief Define the number of saul info + */ +#define VL53L1X_INFO_NUM (sizeof(vl53l1x_saul_info) / sizeof(vl53l1x_saul_info[0])) + +/** + * @brief Reference the driver structs + */ +extern saul_driver_t vl53l1x_saul_driver; + +void auto_init_vl53l1x(void) +{ + assert(VL53L1X_INFO_NUM == VL53L1X_NUM); + + for (unsigned i = 0; i < VL53L1X_NUM; i++) { + LOG_DEBUG("[auto_init_saul] initializing vl53l1x #%u\n", i); + + if (vl53l1x_init(&vl53l1x_devs[i], &vl53l1x_params[i]) != VL53L1X_OK) { + LOG_ERROR("[auto_init_saul] error initializing vl53l1x #%u\n", i); + continue; + } + + saul_entries[i].dev = &(vl53l1x_devs[i]); + saul_entries[i].name = vl53l1x_saul_info[i].name; + saul_entries[i].driver = &vl53l1x_saul_driver; + saul_reg_add(&(saul_entries[i])); + } +} + +#else +typedef int dont_be_pedantic; +#endif /* MODULE_VL53L1X */ diff --git a/drivers/saul/init_devs/init.c b/drivers/saul/init_devs/init.c index 685317891235..9823fb803307 100644 --- a/drivers/saul/init_devs/init.c +++ b/drivers/saul/init_devs/init.c @@ -335,6 +335,10 @@ void saul_init_devs(void) extern void auto_init_veml6070(void); auto_init_veml6070(); } + if (IS_USED(MODULE_VL53L1X)) { + extern void auto_init_vl53l1x(void); + auto_init_vl53l1x(); + } if (IS_USED(MODULE_VL6180X)) { extern void auto_init_vl6180x(void); auto_init_vl6180x(); diff --git a/drivers/vl53l1x/vl53l1x_saul.c b/drivers/vl53l1x/vl53l1x_saul.c new file mode 100644 index 000000000000..5875019fb751 --- /dev/null +++ b/drivers/vl53l1x/vl53l1x_saul.c @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2021 Gunar Schorcht + * + * This file is subject to the terms and conditions of the GNU Lesser + * General Public License v2.1. See the file LICENSE in the top level + * directory for more details. + */ + +/** + * @ingroup drivers_vl53l1x + * @brief VL53L1X adaption to the RIOT actuator/sensor interface + * @author Gunar Schorcht + * @file + */ + +#include + +#include "saul.h" +#include "vl53l1x.h" + +static int read(const void *dev, phydat_t *res) +{ + if (vl53l1x_data_ready((vl53l1x_t*)dev) == VL53L1X_OK && + vl53l1x_read_mm((vl53l1x_t*)dev, &res->val[0]) == VL53L1X_OK) { + res->unit = UNIT_M; + res->scale = -3; + return 1; + } + return -ECANCELED; +} + +const saul_driver_t vl53l1x_saul_driver = { + .read = read, + .write = saul_notsup, + .type = SAUL_SENSE_DISTANCE, +}; From 7df6f4a640937477a3403c42b369d6cf8af888a8 Mon Sep 17 00:00:00 2001 From: Gunar Schorcht Date: Sun, 12 Dec 2021 13:55:05 +0100 Subject: [PATCH 04/18] tests/driver_vl53l1x: add test app for vl53l1x driver --- tests/driver_vl53l1x/Makefile | 6 ++ tests/driver_vl53l1x/Makefile.ci | 4 + tests/driver_vl53l1x/main.c | 163 +++++++++++++++++++++++++++++++ 3 files changed, 173 insertions(+) create mode 100644 tests/driver_vl53l1x/Makefile create mode 100644 tests/driver_vl53l1x/Makefile.ci create mode 100644 tests/driver_vl53l1x/main.c diff --git a/tests/driver_vl53l1x/Makefile b/tests/driver_vl53l1x/Makefile new file mode 100644 index 000000000000..c53e642c9aa7 --- /dev/null +++ b/tests/driver_vl53l1x/Makefile @@ -0,0 +1,6 @@ +include ../Makefile.tests_common + +USEMODULE += vl53l1x +USEMODULE += ztimer_msec + +include $(RIOTBASE)/Makefile.include diff --git a/tests/driver_vl53l1x/Makefile.ci b/tests/driver_vl53l1x/Makefile.ci new file mode 100644 index 000000000000..694253c2b835 --- /dev/null +++ b/tests/driver_vl53l1x/Makefile.ci @@ -0,0 +1,4 @@ +BOARD_INSUFFICIENT_MEMORY := \ + nucleo-l011k4 \ + samd10-xmini \ + # diff --git a/tests/driver_vl53l1x/main.c b/tests/driver_vl53l1x/main.c new file mode 100644 index 000000000000..8ec65dc96ba5 --- /dev/null +++ b/tests/driver_vl53l1x/main.c @@ -0,0 +1,163 @@ +/* + * Copyright (C) 2021 Gunar Schorcht + * + * This file is subject to the terms and conditions of the GNU Lesser + * General Public License v2.1. See the file LICENSE in the top level + * directory for more details. + */ + +/** + * @ingroup tests + * @brief Test application for ST VL53L1X Time-of-Flight distance sensor + * @author Gunar Schorcht + * @file + * + * The test application demonstrates the usage of different functions + * dependent on the used driver variant: + * + * - module vl53l1x standard driver with most functionality is used + * - module vl53l1x_st_api ST API driver with complete functionality is used + * - module vl53l1x_basic basic driver with only very basic functionality is + * used + * + * What driver variant is used can be defined at make command line. By default, + * the standard driver variant vl53l1x is used: + * + * make flash -C tests/driver_vl53l1x BOARD=... + * + * To use other driver variants, module vl53l1x_st_api or module vl53l1x_basic + * have to be specified at make command line + * + * USEMODULE=vl53l1x_st_api make flash -C tests/driver_vl53l1x BOARD=... + * + * or + * + * USEMODULE=vl53l1x_basic make flash -C tests/driver_vl53l1x BOARD=... + * + * If the configuration parameter VL53L1X_PARAM_PIN_INT is defined, interrupts + * are used to get data instead of polling for new data. In the case of driver + * variant vl53l1x_st_api, threshold interrupts are configured. Otherwise + * only data interrupts are used. + * + * In all cases, the sensor is configured with following default parameters: + * + * - timing budget of 50 ms + * - intermeasurement period of 100 ms + */ + +#include + +#include "mutex.h" +#include "thread.h" +#include "ztimer.h" + +#include "vl53l1x.h" +#include "vl53l1x_params.h" + +static void isr (void *arg) +{ + /* + * The ISR function is executed in the interrupt context. It must not be + * blocking or time-consuming and must not access the sensor directly + * via I2C. + * + * Therefore, the ISR function only indicates to the waiting thread that + * an interrupt has occurred which needs to be handled in the thread + * context. + */ + mutex_unlock(arg); +} + +int main(void) +{ + /* Initialize the sensor */ + vl53l1x_t dev; + + /* initialize the sensor */ + puts("VL53L1X Time-of-Flight distance sensor\n"); + puts("Initializing VL53L1X sensor"); + + if (vl53l1x_init(&dev, &vl53l1x_params[0]) == VL53L1X_OK) { + printf("[OK]\n"); + } + else { + printf("[Failed]\n"); + return 1; + } + +#if !IS_USED(MODULE_VL53L1X_BASIC) + /* optional read and print the ROI */ + vl53l1x_roi_t roi; + if (vl53l1x_get_roi(&dev, &roi) == VL53L1X_OK) { + printf("old ROI top left [%d, %d], ROI bottom right [%d, %d]\n", + roi.x_tl, roi.y_tl, roi.x_br, roi.y_br); + } + roi.x_tl = 4; + roi.y_tl = 12; + roi.x_br = 12; + roi.y_br = 4; + if (vl53l1x_set_roi(&dev, &roi) == VL53L1X_OK && + vl53l1x_get_roi(&dev, &roi) == VL53L1X_OK) { + printf("new ROI top left [%d, %d], ROI bottom right [%d, %d]\n", + roi.x_tl, roi.y_tl, roi.x_br, roi.y_br); + } + +#endif /* !IS_USED(MODULE_VL53L1X_BASIC) */ + + mutex_t mtx = MUTEX_INIT_LOCKED; + + /* if interrupt pin is defined, enable the interrupt */ + if (vl53l1x_params[0].pin_int != GPIO_UNDEF) { +#if IS_USED(MODULE_VL53L1X_ST_API) + /* generate interrupts when distance is between 200 mm and 400 mm */ + vl53l1x_int_config_t cfg = { + .mode = VL53L1X_INT_DIST, + .dist_mode = VL53L1X_THRESH_IN, + .dist_high = 400, + .dist_low = 200, + }; + vl53l1x_int_config(&dev, &cfg, isr, &mtx); +#else /* IS_USED(MODULE_VL53L1X_ST_API) */ + vl53l1x_int_config(&dev, 0, isr, &mtx); +#endif /* IS_USED(MODULE_VL53L1X_ST_API) */ + } + + while (1) { + + /* if interrupt pin is defined, wait for the interrupt */ + if (vl53l1x_params[0].pin_int != GPIO_UNDEF) { + mutex_lock(&mtx); + } + else { + /* otherwise wait 100 ms. */ + ztimer_sleep(ZTIMER_MSEC, 100); + } + +#if IS_USED(IS_USED(MODULE_VL53L1X_BASIC)) + int16_t mm; + + if (vl53l1x_data_ready(&dev) == VL53L1X_OK && + vl53l1x_read_mm(&dev, &mm) == VL53L1X_OK) { + + printf("distance=%" PRIi16 " [mm]\n", mm); + } +#else /* IS_USED(IS_USED(MODULE_VL53L1X_BASIC)) */ + vl53l1x_data_t data; + + if (vl53l1x_data_ready(&dev) == VL53L1X_OK && + vl53l1x_read_data(&dev, &data) == VL53L1X_OK) { + + printf("distance=%" PRIi16 " [mm] status=%" PRIu8 " " + "signal=%" PRIu16 ".%03" PRIu16 " [mcps] " + "ambient=%" PRIu16 ".%03" PRIu16 " [mcps]\n", + data.distance, data.status, + (uint16_t)(data.signal_rate >> 16), + (uint16_t)((data.signal_rate & 0xffff)/65.535), + (uint16_t)(data.ambient_rate >> 16), + (uint16_t)((data.ambient_rate & 0xffff)/65.535)); + } +#endif /* IS_USED(IS_USED(MODULE_VL53L1X_BASIC)) */ + } + + return 0; +} From 2812f881ed59a1a935dfafe26d2aa64a1d0b7627 Mon Sep 17 00:00:00 2001 From: Gunar Schorcht Date: Sun, 12 Dec 2021 13:55:33 +0100 Subject: [PATCH 05/18] driver/vl53l1x: add Kconfig --- drivers/Kconfig | 1 + drivers/vl53l1x/Kconfig | 78 ++++++++++++++++++++++++++++ tests/driver_vl53l1x/app.config.test | 3 ++ 3 files changed, 82 insertions(+) create mode 100644 drivers/vl53l1x/Kconfig create mode 100644 tests/driver_vl53l1x/app.config.test diff --git a/drivers/Kconfig b/drivers/Kconfig index 692233e79e37..01710d679a56 100644 --- a/drivers/Kconfig +++ b/drivers/Kconfig @@ -150,6 +150,7 @@ rsource "tsl2561/Kconfig" rsource "tsl4531x/Kconfig" rsource "vcnl40x0/Kconfig" rsource "veml6070/Kconfig" +rsource "vl53l1x/Kconfig" rsource "vl6180x/Kconfig" endmenu # Sensor Device Drivers diff --git a/drivers/vl53l1x/Kconfig b/drivers/vl53l1x/Kconfig new file mode 100644 index 000000000000..068fa6ce2138 --- /dev/null +++ b/drivers/vl53l1x/Kconfig @@ -0,0 +1,78 @@ +# Copyright (c) 2020 HAW Hamburg +# +# This file is subject to the terms and conditions of the GNU Lesser +# General Public License v2.1. See the file LICENSE in the top level +# directory for more details. +# + +config MODULE_VL53L1X + bool "VL53L1X Time-of-Flight (ToF) ranging sensor" + depends on HAS_PERIPH_GPIO + depends on HAS_PERIPH_GPIO_IRQ + depends on HAS_PERIPH_I2C + depends on TEST_KCONFIG + select MODULE_PERIPH_GPIO + select MODULE_PERIPH_GPIO_IRQ + select MODULE_PERIPH_I2C + select MODULE_ZTIMER_MSEC + +if MODULE_VL53L1X + +choice + bool "Driver variant" + default MODULE_VL53L1X_STD + +config MODULE_VL53L1X_BASIC + bool "Basic functionality" + help + This is the smallest driver variant that only provides some basic + functions such as the distance measurement and the data-ready interrupt. + +config MODULE_VL53L1X_STD + bool "Standard functionality" + help + This driver variant is a compromise of size and functionality. It + provides the application with most functionality of the sensor. The + driver can be used when memory requirements are important and most + of the functionality should be used. + +config MODULE_VL53L1X_ST_API + bool "Full functionality using the ST VL53L1X Full API" + help + This driver variant uses ST STSW-IMG007 VL53L1X API as package. In + this case, the driver is simply a wrapper for the API which provides + a driver interface that is compatible with other driver variants. + Additionally, it provides access to the complete functionality + of the sensor by using API functions directly. This is for example + necessary to configure and use threshold interrupts, or to calibrate + the sensor. + +endchoice + +choice + bool "Distance mode" + default VL53L1X_DIST_LONG + depends on MODULE_VL53L1X_STD || MODULE_VL53L1X_ST_API + + config VL53L1X_DIST_SHORT + bool "Short - up to 1.3 m" + config VL53L1X_DIST_MEDIUM + bool "Medium - up to 2 m" + config VL53L1X_DIST_LONG + bool "Long - up to 4 m" + +endchoice + +config VL53L1X_PARAM_TIMING_BUDGET + int "Timing budget [us]" + default 50000 + range 20000 1000000 + depends on MODULE_VL53L1X_STD || MODULE_VL53L1X_ST_API + +config VL53L1X_PARAM_PERIOD + int "Inter-measurement period [ms]" + default 100 + range 20 1000 + depends on MODULE_VL53L1X_STD || MODULE_VL53L1X_ST_API + +endif # MODULE_VL53L1X diff --git a/tests/driver_vl53l1x/app.config.test b/tests/driver_vl53l1x/app.config.test new file mode 100644 index 000000000000..e4b8d43e3082 --- /dev/null +++ b/tests/driver_vl53l1x/app.config.test @@ -0,0 +1,3 @@ +# this file enables modules defined in Kconfig. Do not use this file for +# application configuration. This is only needed during migration. +CONFIG_MODULE_VL53L1X=y From b4e47ea1bd311a7b79b7642b57cec11ba6a9d176 Mon Sep 17 00:00:00 2001 From: Gunar Schorcht Date: Tue, 13 Dec 2022 02:55:18 +0100 Subject: [PATCH 06/18] fixup! drivers/vl53l1x: add driver for ST VL53L1X sensor --- drivers/vl53l1x/Makefile.dep | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/vl53l1x/Makefile.dep b/drivers/vl53l1x/Makefile.dep index 82b6e7dc0a26..501b01b14697 100644 --- a/drivers/vl53l1x/Makefile.dep +++ b/drivers/vl53l1x/Makefile.dep @@ -1,5 +1,6 @@ ifneq (,$(filter vl53l1x_st_api,$(USEMODULE))) USEMODULE += driver_vl53l1x_st_api_platform + USEMODULE += ztimer_usec USEPKG += driver_vl53l1x_st_api endif From 39ce37c3ddbb6ef40af40b53afa720d9d5bfe92c Mon Sep 17 00:00:00 2001 From: Gunar Schorcht Date: Tue, 13 Dec 2022 02:55:54 +0100 Subject: [PATCH 07/18] fixup! drivers/vl53l1x: SAUL integration --- drivers/vl53l1x/vl53l1x_saul.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/vl53l1x/vl53l1x_saul.c b/drivers/vl53l1x/vl53l1x_saul.c index 5875019fb751..0584dbe51e10 100644 --- a/drivers/vl53l1x/vl53l1x_saul.c +++ b/drivers/vl53l1x/vl53l1x_saul.c @@ -31,6 +31,6 @@ static int read(const void *dev, phydat_t *res) const saul_driver_t vl53l1x_saul_driver = { .read = read, - .write = saul_notsup, + .write = saul_write_notsup, .type = SAUL_SENSE_DISTANCE, }; From a61ebaae6f1269cc1b3bfe93b374f8eba5cdd8ec Mon Sep 17 00:00:00 2001 From: Gunar Schorcht Date: Tue, 13 Dec 2022 02:56:18 +0100 Subject: [PATCH 08/18] fixup! pkg/driver_vl53l1x_st_api: vendor API used by vl53l1x driver --- pkg/driver_vl53l1x_st_api/platform/vl53l1_platform.c | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/pkg/driver_vl53l1x_st_api/platform/vl53l1_platform.c b/pkg/driver_vl53l1x_st_api/platform/vl53l1_platform.c index b8302374922f..b4e3f642a0d4 100644 --- a/pkg/driver_vl53l1x_st_api/platform/vl53l1_platform.c +++ b/pkg/driver_vl53l1x_st_api/platform/vl53l1_platform.c @@ -72,7 +72,7 @@ #include #include "periph/i2c.h" -#include "xtimer.h" +#include "ztimer.h" #include "vl53l1x.h" @@ -343,8 +343,7 @@ VL53L1_Error VL53L1_GetTickCount(uint32_t *ptick_count_ms) ASSERT_PARAM(ptick_count_ms != NULL); DEBUG_NODEV("ptick_count_ms=%p", ptick_count_ms); - uint64_t time = xtimer_now_usec64(); - *ptick_count_ms = time / (US_PER_MS); + *ptick_count_ms = ztimer_now(ZTIMER_MSEC); return status; } @@ -367,7 +366,7 @@ VL53L1_Error VL53L1_WaitMs(VL53L1_Dev_t *pdev, int32_t wait_ms){ ASSERT_PARAM(pdev != NULL); DEBUG_NODEV("wait_ms=%d", wait_ms); - xtimer_usleep (wait_ms * US_PER_MS); + ztimer_sleep(ZTIMER_MSEC, wait_ms); return status; } @@ -379,7 +378,7 @@ VL53L1_Error VL53L1_WaitUs(VL53L1_Dev_t *pdev, int32_t wait_us) ASSERT_PARAM(pdev != NULL); DEBUG_NODEV("wait_us=%d", wait_us); - xtimer_usleep (wait_us); + ztimer_sleep(ZTIMER_USEC, wait_us); return status; } @@ -405,7 +404,7 @@ VL53L1_Error VL53L1_WaitValueMaskEx(VL53L1_Dev_t *pdev, if ((data & mask) == value) { return VL53L1_ERROR_NONE; } - xtimer_usleep(poll_delay_ms * US_PER_MS); + ztimer_sleep(ZTIMER_MSEC, poll_delay_ms); timeout_ms -= (poll_delay_ms < timeout_ms) ? poll_delay_ms : timeout_ms; } From 963837ab02626fa11cc51985ab363023d4f0f2ce Mon Sep 17 00:00:00 2001 From: Gunar Schorcht Date: Wed, 14 Dec 2022 15:09:51 +0100 Subject: [PATCH 09/18] fixup! pkg/driver_vl53l1x_st_api: vendor API used by vl53l1x driver --- pkg/driver_vl53l1x_st_api/platform/vl53l1_platform.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/pkg/driver_vl53l1x_st_api/platform/vl53l1_platform.c b/pkg/driver_vl53l1x_st_api/platform/vl53l1_platform.c index b4e3f642a0d4..3acecec1bd5a 100644 --- a/pkg/driver_vl53l1x_st_api/platform/vl53l1_platform.c +++ b/pkg/driver_vl53l1x_st_api/platform/vl53l1_platform.c @@ -71,6 +71,7 @@ #include +#include "macros/units.h" #include "periph/i2c.h" #include "ztimer.h" @@ -355,7 +356,7 @@ VL53L1_Error VL53L1_GetTimerFrequency(int32_t *ptimer_freq_hz) ASSERT_PARAM(ptimer_freq_hz != NULL); DEBUG_NODEV("ptimer_freq_hz=%p", ptimer_freq_hz); - *ptimer_freq_hz = (US_PER_MS * MS_PER_SEC); + *ptimer_freq_hz = MHZ(1); return status; } From 3f7f28a4c4d6e68c46a44ddb0694025e04da9cfd Mon Sep 17 00:00:00 2001 From: Gunar Schorcht Date: Wed, 14 Dec 2022 17:43:07 +0100 Subject: [PATCH 10/18] fixup! drivers/vl53l1x: add driver for ST VL53L1X sensor --- drivers/include/vl53l1x.h | 55 ++++++++++++++++++++---------------- drivers/vl53l1x/Makefile.dep | 1 + 2 files changed, 32 insertions(+), 24 deletions(-) diff --git a/drivers/include/vl53l1x.h b/drivers/include/vl53l1x.h index 226573b9a752..90a5d8b9b0f8 100644 --- a/drivers/include/vl53l1x.h +++ b/drivers/include/vl53l1x.h @@ -19,13 +19,14 @@ * Using the according module, the driver can be used in different variants * which differ in functionality and size: * - * Module Name | Driver | Short Description - * :-------------------|:----------------------|:---------------------------- - * \ref vl53l1x_std | Standard driver | Common functionality and medium size - * \ref vl53l1x_st_api | ST VL53L1X API driver | Complete functionality and large size - * \ref vl53l1x_basic | Basic driver | Minimum functionality and small size + * Module Name | Driver | Short Description + * :-------------------|:--------------------------|:---------------------------- + * \ref vl53l1x_std | Standard driver (default) | Common functionality and medium size + * \ref vl53l1x_st_api | ST VL53L1X API driver | Complete functionality and large size + * \ref vl53l1x_basic | Basic driver | Minimum functionality and small size * - * All driver variants provide @ref drivers_saul capabilities for distance. + * If no driver variant is explicitly specified, \ref vl53l1x_std is used by + * default. All driver variants provide \ref drivers_saul capabilities for distance. * * ## ST VL53L1X API driver (vl53l1x_st_api) {#vl53l1x_st_api} * @@ -54,6 +55,11 @@ * very large, this driver variant should only be used when memory * requirements are not an issue. * + * @warning The ST STSW-IMG007 VL53L1X API package functions use a significant + * amount of memory in the stack. If you have crashes due to memory + * access errors, try increasing the default thread stack size + * \ref THREAD_STACKSIZE_DEFAULT. + * * ## Standard driver (vl53l1x_std) {#vl53l1x_std} * * This driver variant is a compromise of size and functionality. It provides @@ -79,24 +85,25 @@ * * ## Driver Comparison Sheet * - * Function / Property | vl53l1x_basic | vl53l1x | vl53l1x_st_api - * :--------------------------------------|:------:|:----:|:--------------: - * Distance results in mm | X | X | X - * Signal rate results in MCPS | | X | X - * Measurement status information | | X | X - * SAUL capability | X | X | X - * Distance mode configuration | | X | X - * Timing budget configuration | | X | X - * Inter-measurement period configuration | | X | X - * Region of Interest (ROI) configuration | | X | X - * Data-ready interrupts | X | X | X - * Threshold interrupts | | | X - * Calibration functions | | | X [1] - * Limit check configuration | | | X [1] - * Accuracy | medium | high | high - * Size on reference platform in kByte | 1.3 | 4.2 | 27.9 - * - * [1] These functions are available by using the ST VL53L1X API directly. + * Function / Property | vl53l1x_basic | vl53l1x_std | vl53l1x_st_api + * :---------------------------------------|:-------------:|:-----------:|:--------------: + * Distance results in mm | X | X | X + * Signal rate results in MCPS | | X | X + * Measurement status information | | X | X + * SAUL capability | X | X | X + * Distance mode configuration | | X | X + * Timing budget configuration | | X | X + * Inter-measurement period configuration | | X | X + * Region of Interest (ROI) configuration | | X | X + * Data-ready interrupts | X | X | X + * Threshold interrupts | | | X + * Calibration functions | | | X [1] + * Limit check configuration | | | X [1] + * Accuracy | medium | high | high + * Size on reference platform in kByte [2] | 1.0 | 2.9 | 19.8 + * + * [1] These functions are available by using the ST VL53L1X API directly.
+ * [2] Reference platform: STM32F411RE * * @{ * diff --git a/drivers/vl53l1x/Makefile.dep b/drivers/vl53l1x/Makefile.dep index 501b01b14697..16ec4d7e0144 100644 --- a/drivers/vl53l1x/Makefile.dep +++ b/drivers/vl53l1x/Makefile.dep @@ -5,6 +5,7 @@ ifneq (,$(filter vl53l1x_st_api,$(USEMODULE))) endif ifeq (,$(filter vl53l1x_%,$(USEMODULE))) + # use vl53l1x_std if no `vl53l1x_*` driver variant is explicitly specified USEMODULE += vl53l1x_std endif From ca6ca0ed7b2f58338dc6194f218f33f5c8a43be1 Mon Sep 17 00:00:00 2001 From: Gunar Schorcht Date: Thu, 15 Dec 2022 07:37:19 +0100 Subject: [PATCH 11/18] fixup! drivers/vl53l1x: add driver for ST VL53L1X sensor --- drivers/include/vl53l1x.h | 2 +- drivers/vl53l1x/vl53l1x.c | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/drivers/include/vl53l1x.h b/drivers/include/vl53l1x.h index 90a5d8b9b0f8..b784c631be9b 100644 --- a/drivers/include/vl53l1x.h +++ b/drivers/include/vl53l1x.h @@ -332,7 +332,7 @@ typedef struct { * avalanche diode) array. The ROI is a square or rectangle defined by two * corners: top left and bottom right. */ -typedef struct{ +typedef struct { uint8_t x_tl; /**< ROI top left x coordinate [0...15] (default 0) */ uint8_t y_tl; /**< ROI top left y coordinate [0...15] (default 15) */ uint8_t x_br; /**< ROI bottom right x coordinate [0...15] (default 15) */ diff --git a/drivers/vl53l1x/vl53l1x.c b/drivers/vl53l1x/vl53l1x.c index c35918283927..9a5beb467018 100644 --- a/drivers/vl53l1x/vl53l1x.c +++ b/drivers/vl53l1x/vl53l1x.c @@ -979,7 +979,8 @@ static int _reset(vl53l1x_t *dev) /* wait until the sensor has been booted in 1 ms steps*/ unsigned timeout = VL53L1X_BOOT_TIMEOUT; uint8_t res; - while (timeout--) { + while (timeout) { + timeout--; if ((_read_byte(dev, VL53L1X_FIRMWARE__SYSTEM_STATUS, &res) == VL53L1X_OK) && (res & 0x01) == 1) { break; From 23a0cb2996b0b6b42fa1c530cb60c4d94b1a1721 Mon Sep 17 00:00:00 2001 From: Gunar Schorcht Date: Thu, 15 Dec 2022 15:45:31 +0100 Subject: [PATCH 12/18] fixup! tests/driver_vl53l1x: add test app for vl53l1x driver --- tests/driver_vl53l1x/Makefile | 4 +++- tests/driver_vl53l1x/main.c | 17 ++++++++--------- 2 files changed, 11 insertions(+), 10 deletions(-) diff --git a/tests/driver_vl53l1x/Makefile b/tests/driver_vl53l1x/Makefile index c53e642c9aa7..9c40c5b564c1 100644 --- a/tests/driver_vl53l1x/Makefile +++ b/tests/driver_vl53l1x/Makefile @@ -1,6 +1,8 @@ include ../Makefile.tests_common -USEMODULE += vl53l1x +DRIVER ?= vl53l1x + +USEMODULE += $(DRIVER) USEMODULE += ztimer_msec include $(RIOTBASE)/Makefile.include diff --git a/tests/driver_vl53l1x/main.c b/tests/driver_vl53l1x/main.c index 8ec65dc96ba5..d628213f61ab 100644 --- a/tests/driver_vl53l1x/main.c +++ b/tests/driver_vl53l1x/main.c @@ -15,24 +15,24 @@ * The test application demonstrates the usage of different functions * dependent on the used driver variant: * - * - module vl53l1x standard driver with most functionality is used - * - module vl53l1x_st_api ST API driver with complete functionality is used - * - module vl53l1x_basic basic driver with only very basic functionality is - * used + * - vl53l1x Standard driver with most functionality + * - vl53l1x_basic Basic driver with only very basic functionality + * - vl53l1x_st_api ST VL53L1X API driver with complete functionality * - * What driver variant is used can be defined at make command line. By default, - * the standard driver variant vl53l1x is used: + * The driver variant used is defined by my variable DRIVER, which is set to + * vl53l1x by default. In this case, it is not necessary to specify the DRIVER + * variable in the make command: * * make flash -C tests/driver_vl53l1x BOARD=... * * To use other driver variants, module vl53l1x_st_api or module vl53l1x_basic * have to be specified at make command line * - * USEMODULE=vl53l1x_st_api make flash -C tests/driver_vl53l1x BOARD=... + * DRIVER=vl53l1x_st_api make flash -C tests/driver_vl53l1x BOARD=... * * or * - * USEMODULE=vl53l1x_basic make flash -C tests/driver_vl53l1x BOARD=... + * DRIVER=vl53l1x_basic make flash -C tests/driver_vl53l1x BOARD=... * * If the configuration parameter VL53L1X_PARAM_PIN_INT is defined, interrupts * are used to get data instead of polling for new data. In the case of driver @@ -101,7 +101,6 @@ int main(void) printf("new ROI top left [%d, %d], ROI bottom right [%d, %d]\n", roi.x_tl, roi.y_tl, roi.x_br, roi.y_br); } - #endif /* !IS_USED(MODULE_VL53L1X_BASIC) */ mutex_t mtx = MUTEX_INIT_LOCKED; From 99476752037fcaaa7a0e83a2bc03b096f06ac7bf Mon Sep 17 00:00:00 2001 From: Gunar Schorcht Date: Thu, 15 Dec 2022 15:55:42 +0100 Subject: [PATCH 13/18] fixup! driver/vl53l1x: add Kconfig --- drivers/vl53l1x/Kconfig | 3 ++- pkg/Kconfig | 1 + pkg/driver_vl53l1x_st_api/Kconfig | 19 +++++++++++++++++++ .../platform/vl53l1_platform.c | 4 +++- 4 files changed, 25 insertions(+), 2 deletions(-) create mode 100644 pkg/driver_vl53l1x_st_api/Kconfig diff --git a/drivers/vl53l1x/Kconfig b/drivers/vl53l1x/Kconfig index 068fa6ce2138..2844f42efbf9 100644 --- a/drivers/vl53l1x/Kconfig +++ b/drivers/vl53l1x/Kconfig @@ -5,7 +5,7 @@ # directory for more details. # -config MODULE_VL53L1X +menuconfig MODULE_VL53L1X bool "VL53L1X Time-of-Flight (ToF) ranging sensor" depends on HAS_PERIPH_GPIO depends on HAS_PERIPH_GPIO_IRQ @@ -38,6 +38,7 @@ config MODULE_VL53L1X_STD config MODULE_VL53L1X_ST_API bool "Full functionality using the ST VL53L1X Full API" + select PACKAGE_DRIVER_VL53L1X_ST_API help This driver variant uses ST STSW-IMG007 VL53L1X API as package. In this case, the driver is simply a wrapper for the API which provides diff --git a/pkg/Kconfig b/pkg/Kconfig index 537594aa575f..924c9b2ff1d3 100644 --- a/pkg/Kconfig +++ b/pkg/Kconfig @@ -19,6 +19,7 @@ rsource "driver_atwinc15x0/Kconfig" rsource "driver_bme680/Kconfig" rsource "driver_cryptocell_310/Kconfig" rsource "driver_sx126x/Kconfig" +rsource "driver_vl53l1x_st_api/Kconfig" rsource "elk/Kconfig" rsource "emlearn/Kconfig" rsource "esp32_sdk/Kconfig" diff --git a/pkg/driver_vl53l1x_st_api/Kconfig b/pkg/driver_vl53l1x_st_api/Kconfig new file mode 100644 index 000000000000..4316befd5cdd --- /dev/null +++ b/pkg/driver_vl53l1x_st_api/Kconfig @@ -0,0 +1,19 @@ +# Copyright (c) 2020 HAW Hamburg +# +# This file is subject to the terms and conditions of the GNU Lesser +# General Public License v2.1. See the file LICENSE in the top level +# directory for more details. +# + +config PACKAGE_DRIVER_VL53L1X_ST_API + bool + select MODULE_DRIVER_VL53L1X_ST_API_PLATFORM + help + Driver API package for the ST VL53L1X Time-of-Flight (ToF) ranging + sensor + +config MODULE_DRIVER_VL53L1X_ST_API_PLATFORM + bool + select MODULE_ZTIMER_USEC + help + Platform implementation for the ST VL53L1X Driver API package diff --git a/pkg/driver_vl53l1x_st_api/platform/vl53l1_platform.c b/pkg/driver_vl53l1x_st_api/platform/vl53l1_platform.c index 3acecec1bd5a..735cb0d3d7bb 100644 --- a/pkg/driver_vl53l1x_st_api/platform/vl53l1_platform.c +++ b/pkg/driver_vl53l1x_st_api/platform/vl53l1_platform.c @@ -330,7 +330,9 @@ VL53L1_Error VL53L1_RdDWord(VL53L1_DEV Dev, uint16_t index, uint32_t *data) i2c_read_bytes(VL53L1_I2C_DEV, VL53L1_I2C_ADDR, bytes, 4, 0) != 0) { Status = VL5321_ERROR_I2C; } - *data = (bytes[0] << 24) + (bytes[1] << 16) + (bytes[2] << 8) + (bytes[3]); + *data = ((uint32_t)bytes[0] << 24) + + ((uint32_t)bytes[1] << 16) + + ((uint32_t)bytes[2] << 8) + bytes[3]; i2c_release(VL53L1_I2C_DEV); From e2abaf0a092ca418edfdeca7b08f0cbe1f21b2e5 Mon Sep 17 00:00:00 2001 From: Gunar Schorcht Date: Thu, 15 Dec 2022 15:56:56 +0100 Subject: [PATCH 14/18] tests/driver_vl53l1x: add test app for vl53l1x_st_api driver --- tests/driver_vl53l1x_st_api/Makefile | 6 + tests/driver_vl53l1x_st_api/Makefile.ci | 8 ++ tests/driver_vl53l1x_st_api/app.config.test | 4 + tests/driver_vl53l1x_st_api/main.c | 115 ++++++++++++++++++++ 4 files changed, 133 insertions(+) create mode 100644 tests/driver_vl53l1x_st_api/Makefile create mode 100644 tests/driver_vl53l1x_st_api/Makefile.ci create mode 100644 tests/driver_vl53l1x_st_api/app.config.test create mode 100644 tests/driver_vl53l1x_st_api/main.c diff --git a/tests/driver_vl53l1x_st_api/Makefile b/tests/driver_vl53l1x_st_api/Makefile new file mode 100644 index 000000000000..7928cec5e364 --- /dev/null +++ b/tests/driver_vl53l1x_st_api/Makefile @@ -0,0 +1,6 @@ +include ../Makefile.tests_common + +USEMODULE += vl53l1x_st_api +USEMODULE += ztimer_msec + +include $(RIOTBASE)/Makefile.include diff --git a/tests/driver_vl53l1x_st_api/Makefile.ci b/tests/driver_vl53l1x_st_api/Makefile.ci new file mode 100644 index 000000000000..c153ba2b2b80 --- /dev/null +++ b/tests/driver_vl53l1x_st_api/Makefile.ci @@ -0,0 +1,8 @@ +BOARD_INSUFFICIENT_MEMORY := \ + arduino-duemilanove \ + arduino-leonardo \ + arduino-nano \ + nucleo-l011k4 \ + samd10-xmini \ + stk3200 \ + # diff --git a/tests/driver_vl53l1x_st_api/app.config.test b/tests/driver_vl53l1x_st_api/app.config.test new file mode 100644 index 000000000000..52d711e6a9b5 --- /dev/null +++ b/tests/driver_vl53l1x_st_api/app.config.test @@ -0,0 +1,4 @@ +# this file enables modules defined in Kconfig. Do not use this file for +# application configuration. This is only needed during migration. +CONFIG_MODULE_VL53L1X=y +CONFIG_MODULE_VL53L1X_ST_API=y diff --git a/tests/driver_vl53l1x_st_api/main.c b/tests/driver_vl53l1x_st_api/main.c new file mode 100644 index 000000000000..b85ec20ef56f --- /dev/null +++ b/tests/driver_vl53l1x_st_api/main.c @@ -0,0 +1,115 @@ +/* + * Copyright (C) 2021 Gunar Schorcht + * + * This file is subject to the terms and conditions of the GNU Lesser + * General Public License v2.1. See the file LICENSE in the top level + * directory for more details. + */ + +/** + * @ingroup tests + * @brief Test application for ST VL53L1X API driver + * @author Gunar Schorcht + * @file + * + * The test application provides a direct test for the ST VL53L1X API + * driver module vl53l1x_st_api, which supports the full functionality + * of the sensor. Although the ST VL53L1X API driver could also be tested + * with tests/driver_vl53l1x, this test application allows the use of the + * ST VL53L1X API driver without additional definitions and is thus covered + * by CI compilation. + * + * If the configuration parameter VL53L1X_PARAM_PIN_INT is defined, interrupts + * are used to get data instead of polling for new data. In the case of driver + * variant vl53l1x_st_api, threshold interrupts are configured. Otherwise + * only data interrupts are used. + * + * In all cases, the sensor is configured with following default parameters: + * + * - timing budget of 50 ms + * - intermeasurement period of 100 ms + */ + +#include + +#include "mutex.h" +#include "thread.h" +#include "ztimer.h" + +#include "vl53l1x.h" +#include "vl53l1x_params.h" + +static void isr (void *arg) +{ + /* + * The ISR function is executed in the interrupt context. It must not be + * blocking or time-consuming and must not access the sensor directly + * via I2C. + * + * Therefore, the ISR function only indicates to the waiting thread that + * an interrupt has occurred which needs to be handled in the thread + * context. + */ + mutex_unlock(arg); +} + +int main(void) +{ + /* Initialize the sensor */ + vl53l1x_t dev; + + /* initialize the sensor */ + puts("VL53L1X Time-of-Flight distance sensor\n"); + puts("Initializing VL53L1X sensor"); + + if (vl53l1x_init(&dev, &vl53l1x_params[0]) == VL53L1X_OK) { + printf("[OK]\n"); + } + else { + printf("[Failed]\n"); + return 1; + } + + mutex_t mtx = MUTEX_INIT_LOCKED; + + /* if interrupt pin is defined, enable the interrupt */ + if (vl53l1x_params[0].pin_int != GPIO_UNDEF) { + /* generate interrupts when distance is between 200 mm and 400 mm */ + vl53l1x_int_config_t cfg = { + .mode = VL53L1X_INT_DIST, + .dist_mode = VL53L1X_THRESH_IN, + .dist_high = 400, + .dist_low = 200, + }; + vl53l1x_int_config(&dev, &cfg, isr, &mtx); + } + + while (1) { + + /* if interrupt pin is defined, wait for the interrupt */ + if (vl53l1x_params[0].pin_int != GPIO_UNDEF) { + mutex_lock(&mtx); + } + else { + /* otherwise wait 100 ms. */ + ztimer_sleep(ZTIMER_MSEC, 100); + } + + vl53l1x_data_t data; + + if (vl53l1x_data_ready(&dev) == VL53L1X_OK && + vl53l1x_read_data(&dev, &data) == VL53L1X_OK) { + + printf("distance=%" PRIi16 " [mm] status=%" PRIu8 " " + "signal=%" PRIu16 ".%03" PRIu16 " [mcps] " + "ambient=%" PRIu16 ".%03" PRIu16 " [mcps]\n", + data.distance, data.status, + (uint16_t)(data.signal_rate >> 16), + (uint16_t)((data.signal_rate & 0xffff)/65.535), + (uint16_t)(data.ambient_rate >> 16), + (uint16_t)((data.ambient_rate & 0xffff)/65.535)); + } + } + + return 0; +} From 4682545631c8719c54f1c4fea2d94f99e9ffbe2f Mon Sep 17 00:00:00 2001 From: Gunar Schorcht Date: Thu, 15 Dec 2022 18:15:05 +0100 Subject: [PATCH 15/18] fixup! driver/vl53l1x: add Kconfig --- pkg/driver_vl53l1x_st_api/Kconfig | 2 +- tests/driver_vl53l1x/app.config.test | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/pkg/driver_vl53l1x_st_api/Kconfig b/pkg/driver_vl53l1x_st_api/Kconfig index 4316befd5cdd..1e3b88920dab 100644 --- a/pkg/driver_vl53l1x_st_api/Kconfig +++ b/pkg/driver_vl53l1x_st_api/Kconfig @@ -14,6 +14,6 @@ config PACKAGE_DRIVER_VL53L1X_ST_API config MODULE_DRIVER_VL53L1X_ST_API_PLATFORM bool - select MODULE_ZTIMER_USEC + select ZTIMER_USEC help Platform implementation for the ST VL53L1X Driver API package diff --git a/tests/driver_vl53l1x/app.config.test b/tests/driver_vl53l1x/app.config.test index e4b8d43e3082..0ca3bf86a996 100644 --- a/tests/driver_vl53l1x/app.config.test +++ b/tests/driver_vl53l1x/app.config.test @@ -1,3 +1,4 @@ # this file enables modules defined in Kconfig. Do not use this file for # application configuration. This is only needed during migration. CONFIG_MODULE_VL53L1X=y +CONFIG_MODULE_ZTIMER_MSEC=y From 6e9ed3a38492b9def833e3e629a57bdf4bf29d94 Mon Sep 17 00:00:00 2001 From: Gunar Schorcht Date: Thu, 15 Dec 2022 18:15:32 +0100 Subject: [PATCH 16/18] fixup! tests/driver_vl53l1x: add test app for vl53l1x_st_api driver --- tests/driver_vl53l1x_st_api/app.config.test | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/driver_vl53l1x_st_api/app.config.test b/tests/driver_vl53l1x_st_api/app.config.test index 52d711e6a9b5..09466d387663 100644 --- a/tests/driver_vl53l1x_st_api/app.config.test +++ b/tests/driver_vl53l1x_st_api/app.config.test @@ -2,3 +2,4 @@ # application configuration. This is only needed during migration. CONFIG_MODULE_VL53L1X=y CONFIG_MODULE_VL53L1X_ST_API=y +CONFIG_MODULE_ZTIMER_MSEC=y From 0c1209f0a9164381778c955cc20e069261f80dc9 Mon Sep 17 00:00:00 2001 From: Gunar Schorcht Date: Sun, 10 Sep 2023 13:36:15 +0200 Subject: [PATCH 17/18] fixup! tests/driver_vl53l1x: add test app for vl53l1x driver --- tests/{driver_vl53l1x => drivers/vl53l1x}/Makefile | 0 tests/{driver_vl53l1x => drivers/vl53l1x}/Makefile.ci | 0 tests/{driver_vl53l1x => drivers/vl53l1x}/app.config.test | 0 tests/{driver_vl53l1x => drivers/vl53l1x}/main.c | 0 4 files changed, 0 insertions(+), 0 deletions(-) rename tests/{driver_vl53l1x => drivers/vl53l1x}/Makefile (100%) rename tests/{driver_vl53l1x => drivers/vl53l1x}/Makefile.ci (100%) rename tests/{driver_vl53l1x => drivers/vl53l1x}/app.config.test (100%) rename tests/{driver_vl53l1x => drivers/vl53l1x}/main.c (100%) diff --git a/tests/driver_vl53l1x/Makefile b/tests/drivers/vl53l1x/Makefile similarity index 100% rename from tests/driver_vl53l1x/Makefile rename to tests/drivers/vl53l1x/Makefile diff --git a/tests/driver_vl53l1x/Makefile.ci b/tests/drivers/vl53l1x/Makefile.ci similarity index 100% rename from tests/driver_vl53l1x/Makefile.ci rename to tests/drivers/vl53l1x/Makefile.ci diff --git a/tests/driver_vl53l1x/app.config.test b/tests/drivers/vl53l1x/app.config.test similarity index 100% rename from tests/driver_vl53l1x/app.config.test rename to tests/drivers/vl53l1x/app.config.test diff --git a/tests/driver_vl53l1x/main.c b/tests/drivers/vl53l1x/main.c similarity index 100% rename from tests/driver_vl53l1x/main.c rename to tests/drivers/vl53l1x/main.c From d52ab8fc84f44ef5c1a510e22cbb7b52f4cb28fc Mon Sep 17 00:00:00 2001 From: Gunar Schorcht Date: Sun, 10 Sep 2023 13:36:54 +0200 Subject: [PATCH 18/18] fixup! tests/driver_vl53l1x: add test app for vl53l1x_st_api driver --- tests/{driver_vl53l1x_st_api => drivers/vl53l1x_st_api}/Makefile | 0 .../{driver_vl53l1x_st_api => drivers/vl53l1x_st_api}/Makefile.ci | 0 .../vl53l1x_st_api}/app.config.test | 0 tests/{driver_vl53l1x_st_api => drivers/vl53l1x_st_api}/main.c | 0 4 files changed, 0 insertions(+), 0 deletions(-) rename tests/{driver_vl53l1x_st_api => drivers/vl53l1x_st_api}/Makefile (100%) rename tests/{driver_vl53l1x_st_api => drivers/vl53l1x_st_api}/Makefile.ci (100%) rename tests/{driver_vl53l1x_st_api => drivers/vl53l1x_st_api}/app.config.test (100%) rename tests/{driver_vl53l1x_st_api => drivers/vl53l1x_st_api}/main.c (100%) diff --git a/tests/driver_vl53l1x_st_api/Makefile b/tests/drivers/vl53l1x_st_api/Makefile similarity index 100% rename from tests/driver_vl53l1x_st_api/Makefile rename to tests/drivers/vl53l1x_st_api/Makefile diff --git a/tests/driver_vl53l1x_st_api/Makefile.ci b/tests/drivers/vl53l1x_st_api/Makefile.ci similarity index 100% rename from tests/driver_vl53l1x_st_api/Makefile.ci rename to tests/drivers/vl53l1x_st_api/Makefile.ci diff --git a/tests/driver_vl53l1x_st_api/app.config.test b/tests/drivers/vl53l1x_st_api/app.config.test similarity index 100% rename from tests/driver_vl53l1x_st_api/app.config.test rename to tests/drivers/vl53l1x_st_api/app.config.test diff --git a/tests/driver_vl53l1x_st_api/main.c b/tests/drivers/vl53l1x_st_api/main.c similarity index 100% rename from tests/driver_vl53l1x_st_api/main.c rename to tests/drivers/vl53l1x_st_api/main.c