From 40e895313f1dd66cbddbeec60d02791c61ec51b5 Mon Sep 17 00:00:00 2001 From: jazzpi Date: Sat, 12 Nov 2022 21:09:57 +0100 Subject: [PATCH] Making it work --- .mxproject | 10 +- Core/Inc/main.h | 34 +- Core/Inc/vl6180x_glue.h | 8 + Core/Lib/Inc/vl6180x_api.h | 1019 ++++++++++++ Core/Lib/Inc/vl6180x_cfg.h | 119 ++ Core/Lib/Inc/vl6180x_def.h | 773 +++++++++ Core/Lib/Inc/vl6180x_i2c.h | 166 ++ Core/Lib/Inc/vl6180x_platform.h | 312 ++++ Core/Lib/Inc/vl6180x_types.h | 104 ++ Core/Lib/Src/vl6180x_api.c | 2761 +++++++++++++++++++++++++++++++ Core/Lib/Src/vl6180x_i2c.c | 242 +++ Core/Src/main.c | 32 +- Core/Src/vl6180x_glue.c | 25 + Makefile | 6 +- STM32Make.make | 4 + 15 files changed, 5583 insertions(+), 32 deletions(-) create mode 100644 Core/Inc/vl6180x_glue.h create mode 100644 Core/Lib/Inc/vl6180x_api.h create mode 100644 Core/Lib/Inc/vl6180x_cfg.h create mode 100644 Core/Lib/Inc/vl6180x_def.h create mode 100644 Core/Lib/Inc/vl6180x_i2c.h create mode 100644 Core/Lib/Inc/vl6180x_platform.h create mode 100644 Core/Lib/Inc/vl6180x_types.h create mode 100644 Core/Lib/Src/vl6180x_api.c create mode 100644 Core/Lib/Src/vl6180x_i2c.c create mode 100644 Core/Src/vl6180x_glue.c diff --git a/.mxproject b/.mxproject index 4526754..406896c 100644 --- a/.mxproject +++ b/.mxproject @@ -6,6 +6,11 @@ SourceFiles=../Core/Src/main.c;../Core/Src/stm32l4xx_it.c;../Core/Src/stm32l4xx_ HeaderPath=../Drivers/STM32L4xx_HAL_Driver/Inc;../Drivers/STM32L4xx_HAL_Driver/Inc/Legacy;../Drivers/CMSIS/Device/ST/STM32L4xx/Include;../Drivers/CMSIS/Include;../Core/Inc; CDefines=USE_HAL_DRIVER;STM32L476xx;USE_HAL_DRIVER;USE_HAL_DRIVER; +[PreviousUsedMakefileFiles] +SourceFiles=Core/Src/main.c;Core/Src/stm32l4xx_it.c;Core/Src/stm32l4xx_hal_msp.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_i2c.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_i2c_ex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_rcc.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_rcc_ex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_flash.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_flash_ex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_flash_ramfunc.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_gpio.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_dma.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_dma_ex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_pwr.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_pwr_ex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_cortex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_exti.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_tim.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_tim_ex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_uart.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_uart_ex.c;Drivers/CMSIS/Device/ST/STM32L4xx/Source/Templates/system_stm32l4xx.c;Core/Src/system_stm32l4xx.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_i2c.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_i2c_ex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_rcc.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_rcc_ex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_flash.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_flash_ex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_flash_ramfunc.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_gpio.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_dma.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_dma_ex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_pwr.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_pwr_ex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_cortex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_exti.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_tim.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_tim_ex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_uart.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_uart_ex.c;Drivers/CMSIS/Device/ST/STM32L4xx/Source/Templates/system_stm32l4xx.c;Core/Src/system_stm32l4xx.c;;; +HeaderPath=Drivers/STM32L4xx_HAL_Driver/Inc;Drivers/STM32L4xx_HAL_Driver/Inc/Legacy;Drivers/CMSIS/Device/ST/STM32L4xx/Include;Drivers/CMSIS/Include;Core/Inc; +CDefines=USE_HAL_DRIVER;STM32L476xx;USE_HAL_DRIVER;USE_HAL_DRIVER; + [PreviousGenFiles] AdvancedFolderStructure=true HeaderFileListSize=3 @@ -23,8 +28,3 @@ SourceFolderListSize=1 SourcePath#0=../Core/Src SourceFiles=; -[PreviousUsedMakefileFiles] -SourceFiles=Core/Src/main.c;Core/Src/stm32l4xx_it.c;Core/Src/stm32l4xx_hal_msp.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_i2c.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_i2c_ex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_rcc.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_rcc_ex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_flash.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_flash_ex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_flash_ramfunc.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_gpio.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_dma.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_dma_ex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_pwr.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_pwr_ex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_cortex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_exti.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_tim.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_tim_ex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_uart.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_uart_ex.c;Drivers/CMSIS/Device/ST/STM32L4xx/Source/Templates/system_stm32l4xx.c;Core/Src/system_stm32l4xx.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_i2c.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_i2c_ex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_rcc.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_rcc_ex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_flash.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_flash_ex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_flash_ramfunc.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_gpio.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_dma.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_dma_ex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_pwr.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_pwr_ex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_cortex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_exti.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_tim.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_tim_ex.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_uart.c;Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_uart_ex.c;Drivers/CMSIS/Device/ST/STM32L4xx/Source/Templates/system_stm32l4xx.c;Core/Src/system_stm32l4xx.c;;; -HeaderPath=Drivers/STM32L4xx_HAL_Driver/Inc;Drivers/STM32L4xx_HAL_Driver/Inc/Legacy;Drivers/CMSIS/Device/ST/STM32L4xx/Include;Drivers/CMSIS/Include;Core/Inc; -CDefines=USE_HAL_DRIVER;STM32L476xx;USE_HAL_DRIVER;USE_HAL_DRIVER; - diff --git a/Core/Inc/main.h b/Core/Inc/main.h index 5f3347a..1d231d7 100644 --- a/Core/Inc/main.h +++ b/Core/Inc/main.h @@ -1,21 +1,21 @@ /* USER CODE BEGIN Header */ /** - ****************************************************************************** - * @file : main.h - * @brief : Header for main.c file. - * This file contains the common defines of the application. - ****************************************************************************** - * @attention - * - * Copyright (c) 2022 STMicroelectronics. - * All rights reserved. - * - * This software is licensed under terms that can be found in the LICENSE file - * in the root directory of this software component. - * If no LICENSE file comes with this software, it is provided AS-IS. - * - ****************************************************************************** - */ + ****************************************************************************** + * @file : main.h + * @brief : Header for main.c file. + * This file contains the common defines of the application. + ****************************************************************************** + * @attention + * + * Copyright (c) 2022 STMicroelectronics. + * All rights reserved. + * + * This software is licensed under terms that can be found in the LICENSE file + * in the root directory of this software component. + * If no LICENSE file comes with this software, it is provided AS-IS. + * + ****************************************************************************** + */ /* USER CODE END Header */ /* Define to prevent recursive inclusion -------------------------------------*/ @@ -53,7 +53,7 @@ extern "C" { void Error_Handler(void); /* USER CODE BEGIN EFP */ - +extern volatile uint16_t range; /* USER CODE END EFP */ /* Private defines -----------------------------------------------------------*/ diff --git a/Core/Inc/vl6180x_glue.h b/Core/Inc/vl6180x_glue.h new file mode 100644 index 0000000..dc7e06d --- /dev/null +++ b/Core/Inc/vl6180x_glue.h @@ -0,0 +1,8 @@ +#ifndef _INC_VL6180X_GLUE_H +#define _INC_VL6180X_GLUE_H + +#include "stm32l4xx_hal_i2c.h" + +void vl6180x_glue_init(I2C_HandleTypeDef *handle_i2c); + +#endif // _INC_VL6180X_GLUE_H \ No newline at end of file diff --git a/Core/Lib/Inc/vl6180x_api.h b/Core/Lib/Inc/vl6180x_api.h new file mode 100644 index 0000000..d3a7c91 --- /dev/null +++ b/Core/Lib/Inc/vl6180x_api.h @@ -0,0 +1,1019 @@ +/******************************************************************************* +Copyright © 2015, STMicroelectronics International N.V. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * 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. + * Neither the name of STMicroelectronics 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, FITNESS FOR A PARTICULAR PURPOSE, AND +NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED. +IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. 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 VL6180x_api.h + * $Date: 2018-07-04 16:49:57 +0200 (Wed, 04 Jul 2018) $ + * $Revision: 2768 $ + */ + + + +#ifndef VL6180x_API_H_ +#define VL6180x_API_H_ + +#include "vl6180x_platform.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** @defgroup api_ll API Low Level Functions + * @brief API Low level functions + */ + +/** @defgroup api_hl API High Level Functions + * @brief API High level functions + */ + + +/* + * Check and set default platform dependent configuration + */ +#ifndef VL6180x_SINGLE_DEVICE_DRIVER +#error "VL6180x_SINGLE_DEVICE_DRIVER not defined" +/* TODO you may remove or comment these #error but it is best you update your vl6180x_platform.h file to define it*/ +#endif + + +#ifndef VL6180x_RANGE_STATUS_ERRSTRING +#warning "VL6180x_RANGE_STATUS_ERRSTRING not defined ?" +/* TODO you may remove or comment these #warning and keep the default below to keep compatibility + or update your vl6180x_platform.h file */ +/** + * force VL6180x_RANGE_STATUS_ERRSTRING to not supported when not part of any cfg file + */ +#define VL6180x_RANGE_STATUS_ERRSTRING 0 +#endif + +#ifndef VL6180X_SAFE_POLLING_ENTER +#warning "VL6180X_SAFE_POLLING_ENTER not defined, likely old vl6180x_cfg.h file ?" +/* TODO you may remove or comment these #warning and keep the default below to keep compatibility + or update your vl6180x_platform.h file */ +/** + * force VL6180X_SAFE_POLLING_ENTER to off when not in cfg file + */ +#define VL6180X_SAFE_POLLING_ENTER 0 /* off by default as in api 2.0 */ +#endif + +#ifndef VL6180X_LOG_ENABLE +/** + * Force VL6180X_LOG_ENABLE to none as default + */ +#define VL6180X_LOG_ENABLE 0 +#endif + +#if VL6180x_RANGE_STATUS_ERRSTRING +/**@def VL6180x_HAVE_RANGE_STATUS_ERRSTRING + * @brief is defined when @a #VL6180x_RANGE_STATUS_ERRSTRING is enable + */ +#define VL6180x_HAVE_RANGE_STATUS_ERRSTRING +#endif + + +/** @brief Get API version as "hex integer" 0xMMnnss + */ +#define VL6180x_ApiRevInt ((VL6180x_API_REV_MAJOR<<24)+(VL6180x_API_REV_MINOR<<16)+VL6180x_API_REV_SUB) + +/** Get API version as string for exe "2.1.12" " + */ +#define VL6180x_ApiRevStr VL6180X_STR(VL6180x_API_REV_MAJOR) "." VL6180X_STR(VL6180x_API_REV_MINOR) "." VL6180X_STR(VL6180x_API_REV_SUB) + +/** @defgroup api_init Init functions + * @brief API init functions + * @ingroup api_hl + * @{ + */ +/** + * @brief Wait for device booted after chip enable (hardware standby) + * @par Function Description + * After Chip enable Application you can also simply wait at least 1ms to ensure device is ready + * @warning After device chip enable (gpio0) de-asserted user must wait gpio1 to get asserted (hardware standby). + * or wait at least 400usec prior to do any low level access or api call . + * + * This function implements polling for standby but you must ensure 400usec from chip enable passed\n + * @warning Calling this function if device is not fresh out of reset will result in an indefinite loop\n + * + * @param dev The device + * @return 0 on success + */ +int VL6180x_WaitDeviceBooted(VL6180xDev_t dev); + +/** + * + * @brief One time device initialization + * + * To be called once and only once after device is brought out of reset (Chip enable) and booted see @a VL6180x_WaitDeviceBooted() + * + * @par Function Description + * When not used after a fresh device "power up" or reset, it may return @a #CALIBRATION_WARNING + * meaning wrong calibration data may have been fetched from device that can result in unpredictable and wrong ranging values\n + * + * @param dev The device + * @return 0 on success, @a #CALIBRATION_WARNING if failed + */ +int VL6180x_InitData(VL6180xDev_t dev); + +/** + * @brief Configure GPIO1 function and set polarity. + * @par Function Description + * To be used prior to arm single shot measure or start continuous mode. + * + * The function uses @a VL6180x_SetupGPIOx() for setting gpio 1. + * @warning changing polarity can generate a spurious interrupt on pins. + * It sets an interrupt flags condition that must be cleared to avoid polling hangs. \n + * It is safe to run VL6180x_ClearAllInterrupt() just after. + * + * @param dev The device + * @param IntFunction The interrupt functionality to use one of :\n + * @a #GPIOx_SELECT_OFF \n + * @a #GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT + * @param ActiveHigh The interrupt line polarity see ::IntrPol_e + * use @a #INTR_POL_LOW (falling edge) or @a #INTR_POL_HIGH (rising edge) + * @return 0 on success + */ +int VL6180x_SetupGPIO1(VL6180xDev_t dev, uint8_t IntFunction, int ActiveHigh); + + /** + * @brief Prepare device for operation + * @par Function Description + * Does static initialization and reprogram common default settings \n + * Device is prepared for new measure, ready single shot ranging or ALS typical polling operation\n + * After prepare user can : \n + * @li Call other API function to set other settings\n + * @li Configure the interrupt pins, etc... \n + * @li Then start ranging or ALS operations in single shot or continuous mode + * + * @param dev The device + * @return 0 on success + */ +int VL6180x_Prepare(VL6180xDev_t dev); + + /** @} */ + + +/** @defgroup api_hl_range Ranging functions + * @brief Ranging functions + * @ingroup api_hl + * @{ + */ + +/** + * @brief Start continuous ranging mode + * + * @details End user should ensure device is in idle state and not already running + */ +int VL6180x_RangeStartContinuousMode(VL6180xDev_t dev); + +/** + * @brief Start single shot ranging measure + * + * @details End user should ensure device is in idle state and not already running + */ +int VL6180x_RangeStartSingleShot(VL6180xDev_t dev); + +/** + * @brief Set maximum convergence time + * + * @par Function Description + * Setting a low convergence time can impact maximal detectable distance. + * Refer to VL6180x Datasheet Table 7 : Typical range convergence time. + * A typical value for up to x3 scaling is 50 ms + * + * @param dev + * @param MaxConTime_msec + * @return 0 on success. <0 on error. >0 for calibration warning status + */ +int VL6180x_RangeSetMaxConvergenceTime(VL6180xDev_t dev, uint8_t MaxConTime_msec); + +/** + * @brief Single shot Range measurement in polling mode. + * + * @par Function Description + * Kick off a new single shot range then wait for ready to retrieve it by polling interrupt status \n + * Ranging must be prepared by a first call to @a VL6180x_Prepare() and it is safer to clear very first poll call \n + * This function reference VL6180x_PollDelay(dev) porting macro/call on each polling loop, + * but PollDelay(dev) may never be called if measure in ready on first poll loop \n + * Should not be use in continuous mode operation as it will stop it and cause stop/start misbehaviour \n + * VL6180x_PollDelay() is platform depending, the user has to implement this function accordingly \n + * 1 ms of wait is the recommended value to avoid excessive I2C requests for data ready check loop \n + * \n This function clears Range Interrupt status , but not error one. For that uses @a VL6180x_ClearErrorInterrupt() \n + * This range error is not related VL6180x_RangeData_t::errorStatus that refer measure status \n + * + * @param dev The device + * @param pRangeData Will be populated with the result ranging data @a VL6180x_RangeData_t + * @return 0 on success , @a #RANGE_ERROR if device reports an error case in it status (not cleared) use + * + * \sa ::VL6180x_RangeData_t + */ +int VL6180x_RangePollMeasurement(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData); + +/** + * @brief Check for measure readiness and get it if ready + * + * @par Function Description + * Using this function is an alternative to @a VL6180x_RangePollMeasurement() to avoid polling operation. This is suitable for applications + * where host CPU is triggered on a interrupt (not from VL6180X) to perform ranging operation. In this scenario, we assume that the very first ranging + * operation is triggered by a call to @a VL6180x_RangeStartSingleShot(). Then, host CPU regularly calls @a VL6180x_RangeGetMeasurementIfReady() to + * get a distance measure if ready. In case the distance is not ready, host may get it at the next call.\n + * + * @warning + * This function does not re-start a new measurement : this is up to the host CPU to do it.\n + * This function clears Range Interrupt for measure ready , but not error interrupts. For that, uses @a VL6180x_ClearErrorInterrupt() \n + * + * @param dev The device + * @param pRangeData Will be populated with the result ranging data if available + * @return 0 on success and <0 in case of error. Please check pRangeData.errorStatus to check is new measurement is ready or not. + */ +int VL6180x_RangeGetMeasurementIfReady(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData); + +/** + * @brief Retrieve range measurements set from device + * + * @par Function Description + * The measurement is made of range_mm status and error code @a VL6180x_RangeData_t \n + * Based on configuration selected extra measures are included. + * + * @warning should not be used in continuous if wrap around filter is active \n + * Does not perform any wait nor check for result availability or validity. + *\sa VL6180x_RangeGetResult for "range only" measurement + * + * @param dev The device + * @param pRangeData Pointer to the data structure to fill up + * @return 0 on success + */ +int VL6180x_RangeGetMeasurement(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData); + +/** + * @brief Get ranging result and only that + * + * @par Function Description + * Unlike @a VL6180x_RangeGetMeasurement() this function only retrieves the range in millimeter \n + * It does any required up-scale translation\n + * It can be called after success status polling or in interrupt mode \n + * @warning these function is not doing wrap around filtering \n + * This function doesn't perform any data ready check! + * + * @param dev The device + * @param pRange_mm Pointer to range distance + * @return 0 on success + */ +int VL6180x_RangeGetResult(VL6180xDev_t dev, int32_t *pRange_mm); + +/** + * @brief Configure ranging interrupt reported to application + * + * @param dev The device + * @param ConfigGpioInt Select ranging report\n select one (and only one) of:\n + * @a #CONFIG_GPIO_INTERRUPT_DISABLED \n + * @a #CONFIG_GPIO_INTERRUPT_LEVEL_LOW \n + * @a #CONFIG_GPIO_INTERRUPT_LEVEL_HIGH \n + * @a #CONFIG_GPIO_INTERRUPT_OUT_OF_WINDOW \n + * @a #CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY + * @return 0 on success + */ +int VL6180x_RangeConfigInterrupt(VL6180xDev_t dev, uint8_t ConfigGpioInt); + + +/** + * @brief Clear range interrupt + * + * @param dev The device + * @return 0 On success + */ +#define VL6180x_RangeClearInterrupt(dev) VL6180x_ClearInterrupt(dev, INTERRUPT_CLEAR_RANGING) + +/** + * @brief Return ranging error interrupt status + * + * @par Function Description + * Appropriate Interrupt report must have been selected first by @a VL6180x_RangeConfigInterrupt() or @a VL6180x_Prepare() \n + * + * Can be used in polling loop to wait for a given ranging event or in interrupt to read the trigger \n + * Events triggers are : \n + * @a #RES_INT_STAT_GPIO_LOW_LEVEL_THRESHOLD \n + * @a #RES_INT_STAT_GPIO_HIGH_LEVEL_THRESHOLD \n + * @a #RES_INT_STAT_GPIO_OUT_OF_WINDOW \n (RES_INT_STAT_GPIO_LOW_LEVEL_THRESHOLD|RES_INT_STAT_GPIO_HIGH_LEVEL_THRESHOLD) + * @a #RES_INT_STAT_GPIO_NEW_SAMPLE_READY \n + * + * @sa IntrStatus_t + * @param dev The device + * @param pIntStatus Pointer to status variable to update + * @return 0 on success + */ +int VL6180x_RangeGetInterruptStatus(VL6180xDev_t dev, uint8_t *pIntStatus); + +#if VL6180x_RANGE_STATUS_ERRSTRING + +extern const char *ROMABLE_DATA VL6180x_RangeStatusErrString[]; +/** + * @brief Human readable error string for range error status + * + * @param RangeErrCode The error code as stored on @a VL6180x_RangeData_t::errorStatus + * @return error string , NULL for invalid RangeErrCode + * @sa ::RangeError_u + */ +const char *VL6180x_RangeGetStatusErrString(uint8_t RangeErrCode); +#else +#define VL6180x_RangeGetStatusErrString(...) NULL +#endif + +/** @} */ + +#if VL6180x_ALS_SUPPORT + +/** @defgroup api_hl_als ALS functions + * @brief ALS functions + * @ingroup api_hl + * @{ + */ + +/** + * @brief Run a single ALS measurement in single shot polling mode + * + * @par Function Description + * Kick off a new single shot ALS then wait new measurement ready to retrieve it ( polling system interrupt status register for als) \n + * ALS must be prepared by a first call to @a VL6180x_Prepare() \n + * \n Should not be used in continuous or interrupt mode it will break it and create hazard in start/stop \n + * + * @param dev The device + * @param pAlsData Als data structure to fill up @a VL6180x_AlsData_t + * @return 0 on success + */ +int VL6180x_AlsPollMeasurement(VL6180xDev_t dev, VL6180x_AlsData_t *pAlsData); + + +/** + * @brief Get actual ALS measurement + * + * @par Function Description + * Can be called after success status polling or in interrupt mode to retrieve ALS measurement from device \n + * This function doesn't perform any data ready check ! + * + * @param dev The device + * @param pAlsData Pointer to measurement struct @a VL6180x_AlsData_t + * @return 0 on success + */ +int VL6180x_AlsGetMeasurement(VL6180xDev_t dev, VL6180x_AlsData_t *pAlsData); + +/** + * @brief Configure ALS interrupts provide to application + * + * @param dev The Device + * @param ConfigGpioInt Select one (and only one) of : \n + * @a #CONFIG_GPIO_INTERRUPT_DISABLED \n + * @a #CONFIG_GPIO_INTERRUPT_LEVEL_LOW \n + * @a #CONFIG_GPIO_INTERRUPT_LEVEL_HIGH \n + * @a #CONFIG_GPIO_INTERRUPT_OUT_OF_WINDOW \n + * @a #CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY + * @return 0 on success may return #INVALID_PARAMS for invalid mode + */ +int VL6180x_AlsConfigInterrupt(VL6180xDev_t dev, uint8_t ConfigGpioInt); + + +/** + * @brief Set ALS integration period + * + * @param dev The device + * @param period_ms Integration period in msec. Value in between 50 to 100 msec is recommended\n + * @return 0 on success + */ +int VL6180x_AlsSetIntegrationPeriod(VL6180xDev_t dev, uint16_t period_ms); + +/** + * @brief Set ALS "inter-measurement period" + * + * @par Function Description + * The so call data-sheet "inter measurement period" is actually an extra inter-measurement delay + * + * @param dev The device + * @param intermeasurement_period_ms Inter measurement time in milli second\n + * @warning applied value is clipped to 2550 ms\n + * @return 0 on success if value is + */ +int VL6180x_AlsSetInterMeasurementPeriod(VL6180xDev_t dev, uint16_t intermeasurement_period_ms); + +/** + * @brief Set ALS analog gain code + * + * @par Function Description + * ALS gain code value programmed in @a SYSALS_ANALOGUE_GAIN . + * @param dev The device + * @param gain Gain code see datasheet or AlsGainLookUp for real value. Value is clipped to 7. + * @return 0 on success + */ + +int VL6180x_AlsSetAnalogueGain(VL6180xDev_t dev, uint8_t gain); +/** + * @brief Set thresholds for ALS continuous mode + * @warning Threshold are raw device value not lux! + * + * @par Function Description + * Basically value programmed in @a SYSALS_THRESH_LOW and @a SYSALS_THRESH_HIGH registers + * @param dev The device + * @param low ALS low raw threshold for @a SYSALS_THRESH_LOW + * @param high ALS high raw threshold for @a SYSALS_THRESH_HIGH + * @return 0 on success + */ +int VL6180x_AlsSetThresholds(VL6180xDev_t dev, uint8_t low, uint8_t high); + +/** + * @brief Clear ALS interrupt + * + * @param dev The device + * @return 0 On success + */ + #define VL6180x_AlsClearInterrupt(dev) VL6180x_ClearInterrupt(dev, INTERRUPT_CLEAR_ALS) + +/** + * Read ALS interrupt status + * @param dev Device + * @param pIntStatus Pointer to status + * @return 0 on success + */ +int VL6180x_AlsGetInterruptStatus(VL6180xDev_t dev, uint8_t *pIntStatus); + +/** @} */ +#endif + +/** @defgroup api_ll_init Init functions + * @brief Init functions + * @ingroup api_ll + * @{ + */ + +/** + * @brief Low level ranging and ALS register static settings (you should call @a VL6180x_Prepare() function instead) + * + * @param dev + * @return 0 on success + */ +int VL6180x_StaticInit(VL6180xDev_t dev); + + /** @} */ + +/** @defgroup api_ll_range Ranging functions + * @brief Ranging Low Level functions + * @ingroup api_ll + * @{ + */ + +/** + * @brief Wait for device to be ready (before a new ranging command can be issued by application) + * @param dev The device + * @param MaxLoop Max Number of i2c polling loop see @a #msec_2_i2cloop + * @return 0 on success. <0 when fail \n + * @ref VL6180x_ErrCode_t::TIME_OUT for time out \n + * @ref VL6180x_ErrCode_t::INVALID_PARAMS if MaxLop<1 + */ +int VL6180x_RangeWaitDeviceReady(VL6180xDev_t dev, int MaxLoop); + +/** + * @brief Program Inter measurement period (used only in continuous mode) + * + * @par Function Description + * When trying to set too long time, it returns #INVALID_PARAMS + * + * @param dev The device + * @param InterMeasTime_msec Requires inter-measurement time in msec + * @return 0 on success + */ +int VL6180x_RangeSetInterMeasPeriod(VL6180xDev_t dev, uint32_t InterMeasTime_msec); + + +/** + * @brief Set device ranging scaling factor + * + * @par Function Description + * The ranging scaling factor is applied on the raw distance measured by the device to increase operating ranging at the price of the precision. + * Changing the scaling factor when device is not in f/w standby state (free running) is not safe. + * It can be source of spurious interrupt, wrongly scaled range etc ... + * @warning __This function doesns't update high/low threshold and other programmed settings linked to scaling factor__. + * To ensure proper operation, threshold and scaling changes should be done following this procedure: \n + * @li Set Group hold : @a VL6180x_SetGroupParamHold() \n + * @li Get Threshold @a VL6180x_RangeGetThresholds() \n + * @li Change scaling : @a VL6180x_UpscaleSetScaling() \n + * @li Set Threshold : @a VL6180x_RangeSetThresholds() \n + * @li Unset Group Hold : @a VL6180x_SetGroupParamHold() + * + * @param dev The device + * @param scaling Scaling factor to apply (1,2 or 3) + * @return 0 on success when up-scale support is not configured it fail for any + * scaling than the one statically configured. + */ +int VL6180x_UpscaleSetScaling(VL6180xDev_t dev, uint8_t scaling); + +/** + * @brief Get current ranging scaling factor + * + * @param dev The device + * @return The current scaling factor + */ +int VL6180x_UpscaleGetScaling(VL6180xDev_t dev); + + +/** + * @brief Give filtered state (wrap-around filter) of a range measurement + * @param pRangeData Range measurement data + * @return 0 means measure was not filtered, when not 0 range from device got filtered by filter post processing + */ +#define VL6180x_RangeIsFilteredMeasurement(pRangeData) ((pRangeData)->errorStatus == RangingFiltered) + +/** + * @brief Get the maximal distance for actual scaling + * @par Function Description + * Do not use prior to @a VL6180x_Prepare() or at least @a VL6180x_InitData() + * + * Any range value more than the value returned by this function is to be considered as "no target detected" + * or "no target in detectable range" + * @warning The maximal distance depends on the scaling + * + * @param dev The device + * @return The maximal range limit for actual mode and scaling + */ +uint16_t VL6180x_GetUpperLimit(VL6180xDev_t dev); + +/** + * @brief Apply low and high ranging thresholds that are considered only in continuous mode + * + * @par Function Description + * This function programs low and high ranging thresholds that are considered in continuous mode : + * interrupt will be raised only when an object is detected at a distance inside this [low:high] range. + * The function takes care of applying current scaling factor if any.\n + * To be safe, in continuous operation, thresholds must be changed under "group parameter hold" cover. + * Group hold can be activated/deactivated directly in the function or externally (then set 0) + * using /a VL6180x_SetGroupParamHold() function. + * + * @param dev The device + * @param low Low threshold in mm + * @param high High threshold in mm + * @param SafeHold Use of group parameters hold to surround threshold programming. + * @return 0 On success + */ +int VL6180x_RangeSetThresholds(VL6180xDev_t dev, uint16_t low, uint16_t high, int SafeHold); + +/** + * @brief Get scaled high and low threshold from device + * + * @par Function Description + * Due to scaling factor, the returned value may be different from what has been programmed first (precision lost). + * For instance VL6180x_RangeSetThresholds(dev,11,22) with scale 3 + * will read back 9 ((11/3)x3) and 21 ((22/3)x3). + + * @param dev The device + * @param low scaled low Threshold ptr can be NULL if not needed + * @param high scaled High Threshold ptr can be NULL if not needed + * @return 0 on success, return value is undefined if both low and high are NULL + * @warning return value is undefined if both low and high are NULL + */ +int VL6180x_RangeGetThresholds(VL6180xDev_t dev, uint16_t *low, uint16_t *high); + +/** + * @brief Set ranging raw thresholds (scaling not considered so not recommended to use it) + * + * @param dev The device + * @param low raw low threshold set to raw register + * @param high raw high threshold set to raw register + * @return 0 on success + */ +int VL6180x_RangeSetRawThresholds(VL6180xDev_t dev, uint8_t low, uint8_t high); + +/** + * @brief Set Early Convergence Estimate ratio + * @par Function Description + * For more information on ECE check datasheet + * @warning May return a calibration warning in some use cases + * + * @param dev The device + * @param FactorM ECE factor M in M/D + * @param FactorD ECE factor D in M/D + * @return 0 on success. <0 on error. >0 on warning + */ +int VL6180x_RangeSetEceFactor(VL6180xDev_t dev, uint16_t FactorM, uint16_t FactorD); + +/** + * @brief Set Early Convergence Estimate state (See #SYSRANGE_RANGE_CHECK_ENABLES register) + * @param dev The device + * @param enable State to be set 0=disabled, otherwise enabled + * @return 0 on success + */ +int VL6180x_RangeSetEceState(VL6180xDev_t dev, int enable); + +/** + * @brief Set activation state of the wrap around filter + * @param dev The device + * @param state New activation state (0=off, otherwise on) + * @return 0 on success + */ +int VL6180x_FilterSetState(VL6180xDev_t dev, int state); + +/** + * Get activation state of the wrap around filter + * @param dev The device + * @return Filter enabled or not, when filter is not supported it always returns 0S + */ +int VL6180x_FilterGetState(VL6180xDev_t dev); + + +/** + * @brief Set activation state of DMax computation + * @param dev The device + * @param state New activation state (0=off, otherwise on) + * @return 0 on success + */ +int VL6180x_DMaxSetState(VL6180xDev_t dev, int state); + +/** + * Get activation state of DMax computation + * @param dev The device + * @return Filter enabled or not, when filter is not supported it always returns 0S + */ +int VL6180x_DMaxGetState(VL6180xDev_t dev); + + +/** + * @brief Set ranging mode and start/stop measure (use high level functions instead : @a VL6180x_RangeStartSingleShot() or @a VL6180x_RangeStartContinuousMode()) + * + * @par Function Description + * When used outside scope of known polling single shot stopped state, \n + * user must ensure the device state is "idle" before to issue a new command. + * + * @param dev The device + * @param mode A combination of working mode (#MODE_SINGLESHOT or #MODE_CONTINUOUS) and start/stop condition (#MODE_START_STOP) \n + * @return 0 on success + */ +int VL6180x_RangeSetSystemMode(VL6180xDev_t dev, uint8_t mode); + +/** + * @brief Enable/disable range ignore feature + * + * @par Function Description + * Enable range ignore feature to ensure that the device does not range on the cover glass because of cross-talk. + * @a VL6180x_RangeIgnoreConfigure() should be run first to configure feature prior to enable it. + * + * @param dev The Device + * @param EnableState Feature state to set 0= off else =on + * @return 0 on success + */ +int VL6180x_RangeIgnoreSetEnable(VL6180xDev_t dev, int EnableState); + +/** + * @brief Configure Range ignore feature + * + * @par Function Description + * When return signal rate is below the IgnoreThreshold and return distance is below the ValidHeight, the distance will be ignored + * @warning It is recommended to enable range ignore feature and configure it only when device is in stop or idle state + * @warning Once this function is called, next call to @a VL6180x_InitData() function without reseting the device will result in wrong ranging operation + * @param dev The Device + * @param ValidHeight_mm Valid height in mm (unscaled ie not raw value before scaling) + * @param IgnoreThreshold Ignore threshold in fixpoint 9.7 MegaCount/sec + * @return + */ +int VL6180x_RangeIgnoreConfigure(VL6180xDev_t dev, uint16_t ValidHeight_mm, uint16_t IgnoreThreshold); +/** @} */ + +/** @defgroup api_ll_range_calibration Ranging calibration functions + * @brief Ranging calibration functions + * @ingroup api_ll + * @{ + */ +/** + * @brief Get part to part calibration offset + * + * @par Function Description + * Should only be used after a successful call to @a VL6180x_InitData to backup device nvm value + * + * @param dev The device + * @return part to part calibration offset from device + */ +int8_t VL6180x_GetOffsetCalibrationData(VL6180xDev_t dev); + +/** + * Set or over-write part to part calibration offset and apply it immediately + * \sa VL6180x_InitData(), VL6180x_GetOffsetCalibrationData() + * @param dev The device + * @param offset Offset + * @return 0 on success + */ +int VL6180x_SetOffsetCalibrationData(VL6180xDev_t dev, int8_t offset); + +/** + * @brief Set Cross talk compensation rate + * + * @par Function Description + * It programs register @a #SYSRANGE_CROSSTALK_COMPENSATION_RATE + * + * @param dev The device + * @param Rate Compensation rate (9.7 fix point) see datasheet for details + * @return 0 on success + */ +int VL6180x_SetXTalkCompensationRate(VL6180xDev_t dev, FixPoint97_t Rate); + +/** @} */ + + + +#if VL6180x_ALS_SUPPORT +/** @defgroup api_ll_als ALS functions + * @brief ALS functions + * @ingroup api_ll + * @{ + */ + +/** + * @brief Wait for device to be ready for new als operation or max pollign loop (time out) + * @param dev The device + * @param MaxLoop Max Number of i2c polling loop see @a #msec_2_i2cloop + * @return 0 on success. <0 when @a VL6180x_ErrCode_t::TIME_OUT if timed out + */ +int VL6180x_AlsWaitDeviceReady(VL6180xDev_t dev, int MaxLoop); + +/** + * @brief Set ALS system mode and start/stop measure + * + * @warning When used outside after single shot polling, \n + * User must ensure the device state is ready before issuing a new command (using @a VL6180x_AlsWaitDeviceReady()). \n + * Non respect of this, can cause loss of interrupt or device hanging. + * + * @param dev The device + * @param mode A combination of working mode (#MODE_SINGLESHOT or #MODE_CONTINUOUS) and start condition (#MODE_START_STOP) \n + * @return 0 on success + */ +int VL6180x_AlsSetSystemMode(VL6180xDev_t dev, uint8_t mode); + +/** @} */ +#endif + +/** @defgroup api_ll_misc Misc functions + * @brief Misc functions + * @ingroup api_ll + * @{ + */ + +/** + * Set Group parameter Hold state + * + * @par Function Description + * Group parameter holds @a #SYSTEM_GROUPED_PARAMETER_HOLD enable safe update (non atomic across multiple measure) by host + * \n The critical register group is composed of: \n + * #SYSTEM_INTERRUPT_CONFIG_GPIO \n + * #SYSRANGE_THRESH_HIGH \n + * #SYSRANGE_THRESH_LOW \n + * #SYSALS_INTEGRATION_PERIOD \n + * #SYSALS_ANALOGUE_GAIN \n + * #SYSALS_THRESH_HIGH \n + * #SYSALS_THRESH_LOW + * + * + * @param dev The device + * @param Hold Group parameter Hold state to be set (on/off) + * @return 0 on success + */ +int VL6180x_SetGroupParamHold(VL6180xDev_t dev, int Hold); + +/** + * @brief Set new device i2c address + * + * After completion the device will answer to the new address programmed. + * + * @sa AN4478: Using multiple VL6180X's in a single design + * @param dev The device + * @param NewAddr The new i2c address (8 bits) + * @return 0 on success + */ +int VL6180x_SetI2CAddress(VL6180xDev_t dev, uint8_t NewAddr); + +/** + * @brief Fully configure gpio 0/1 pin : polarity and functionality + * + * @param dev The device + * @param pin gpio pin 0 or 1 + * @param IntFunction Pin functionality : either #GPIOx_SELECT_OFF or #GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT (refer to #SYSTEM_MODE_GPIO1 register definition) + * @param ActiveHigh Set active high polarity, or active low see @a ::IntrPol_e + * @return 0 on success + */ +int VL6180x_SetupGPIOx(VL6180xDev_t dev, int pin, uint8_t IntFunction, int ActiveHigh); + + +/** + * @brief Set interrupt pin polarity for the given GPIO + * + * @param dev The device + * @param pin Pin 0 or 1 + * @param active_high select active high or low polarity using @ref IntrPol_e + * @return 0 on success + */ +int VL6180x_SetGPIOxPolarity(VL6180xDev_t dev, int pin, int active_high); + +/** + * Select interrupt functionality for the given GPIO + * + * @par Function Description + * Functionality refer to @a SYSTEM_MODE_GPIO0 + * + * @param dev The device + * @param pin Pin to configure 0 or 1 (gpio0 or gpio1)\nNote that gpio0 is chip enable at power up ! + * @param functionality Pin functionality : either #GPIOx_SELECT_OFF or #GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT (refer to #SYSTEM_MODE_GPIO1 register definition) + * @return 0 on success + */ +int VL6180x_SetGPIOxFunctionality(VL6180xDev_t dev, int pin, uint8_t functionality); + +/** + * #brief Disable and turn to Hi-Z gpio output pin + * + * @param dev The device + * @param pin The pin number to disable 0 or 1 + * @return 0 on success + */ +int VL6180x_DisableGPIOxOut(VL6180xDev_t dev, int pin); + +/** + * @def msec_2_i2cloop + * @brief Number of I2C polling loop (an 8 bit register) to run for maximal wait time. + * + * @par Function Description + * When polling via I2C the overall time is mainly the I2C transaction time because it is a slow bus + * one 8 bit register poll on I2C bus timing is shown below: \n + * start + addr_w(a) + 2x8bit index(a) + stop + start + addr_rd(a) + 1x8bit data_rd(a) + stop \n + * 1 8 1 2*(8+1) 1 1 8 1 8 1 1 \n + * so 49 serial bits + * + * @param time_ms Time to wait in milli second 10 + * @param i2c_khz I2C bus frequencies in KHz for instance 400 + * @return The number of loops (at least 1) + */ +#define msec_2_i2cloop(time_ms, i2c_khz) (((time_ms) * (i2c_khz) / 49) + 1) + +/** @} */ + + + +/** + * polarity use in @a VL6180x_SetupGPIOx() , @a VL6180x_SetupGPIO1() + */ +typedef enum { + INTR_POL_LOW = 0, /*!< set active low polarity best setup for falling edge */ + INTR_POL_HIGH = 1, /*!< set active high polarity best setup for rising edge */ +} IntrPol_e; + +/** @defgroup api_ll_intr Interrupts management functions + * @brief Interrupts management functions + * @ingroup api_ll + * @{ + */ + +/** + * @brief Get all interrupts cause + * + * @param dev The device + * @param status Ptr to interrupt status. You can use @a IntrStatus_t::val + * @return 0 on success + */ +int VL6180x_GetInterruptStatus(VL6180xDev_t dev, uint8_t *status); + +/** + * @brief Clear given system interrupt condition + * + * @par Function Description + * Clear given interrupt cause by writing into register #SYSTEM_INTERRUPT_CLEAR register. + * @param dev The device + * @param IntClear Which interrupt source to clear. Use any combinations of #INTERRUPT_CLEAR_RANGING , #INTERRUPT_CLEAR_ALS , #INTERRUPT_CLEAR_ERROR. + * @return 0 On success + */ +int VL6180x_ClearInterrupt(VL6180xDev_t dev, uint8_t IntClear); + +/** + * @brief Clear error interrupt + * + * @param dev The device + * @return 0 On success + */ + #define VL6180x_ClearErrorInterrupt(dev) VL6180x_ClearInterrupt(dev, INTERRUPT_CLEAR_ERROR) + +/** + * @brief Clear All interrupt causes (als+range+error) + * + * @param dev The device + * @return 0 On success + */ +#define VL6180x_ClearAllInterrupt(dev) VL6180x_ClearInterrupt(dev, INTERRUPT_CLEAR_ERROR|INTERRUPT_CLEAR_RANGING|INTERRUPT_CLEAR_ALS) + +/** @} */ + + +/** @defgroup api_reg API Register access functions + * @brief Registers access functions called by API core functions + * @ingroup api_ll + * @{ + */ + +/** + * Write VL6180x single byte register + * @param dev The device + * @param index The register index + * @param data 8 bit register data + * @return success + */ +int VL6180x_WrByte(VL6180xDev_t dev, uint16_t index, uint8_t data); +/** + * Thread safe VL6180x Update (rd/modify/write) single byte register + * + * Final_reg = (Initial_reg & and_data) |or_data + * + * @param dev The device + * @param index The register index + * @param AndData 8 bit and data + * @param OrData 8 bit or data + * @return 0 on success + */ +int VL6180x_UpdateByte(VL6180xDev_t dev, uint16_t index, uint8_t AndData, uint8_t OrData); +/** + * Write VL6180x word register + * @param dev The device + * @param index The register index + * @param data 16 bit register data + * @return 0 on success + */ +int VL6180x_WrWord(VL6180xDev_t dev, uint16_t index, uint16_t data); +/** + * Write VL6180x double word (4 byte) register + * @param dev The device + * @param index The register index + * @param data 32 bit register data + * @return 0 on success + */ +int VL6180x_WrDWord(VL6180xDev_t dev, uint16_t index, uint32_t data); + +/** + * Read VL6180x single byte register + * @param dev The device + * @param index The register index + * @param data pointer to 8 bit data + * @return 0 on success + */ +int VL6180x_RdByte(VL6180xDev_t dev, uint16_t index, uint8_t *data); + +/** + * Read VL6180x word (2byte) register + * @param dev The device + * @param index The register index + * @param data pointer to 16 bit data + * @return 0 on success + */ +int VL6180x_RdWord(VL6180xDev_t dev, uint16_t index, uint16_t *data); + +/** + * Read VL6180x dword (4byte) register + * @param dev The device + * @param index The register index + * @param data pointer to 32 bit data + * @return 0 on success + */ +int VL6180x_RdDWord(VL6180xDev_t dev, uint16_t index, uint32_t *data); + + +/** + * Read VL6180x multiple bytes + * @note required only if #VL6180x_HAVE_MULTI_READ is set + * @param dev The device + * @param index The register index + * @param data pointer to 8 bit data + * @param nData number of data bytes to read + * @return 0 on success + */ +int VL6180x_RdMulti(VL6180xDev_t dev, uint16_t index, uint8_t *data, int nData); + +/** @} */ + + + + +#ifdef __cplusplus +} +#endif + +#endif /* VL6180x_API_H_ */ diff --git a/Core/Lib/Inc/vl6180x_cfg.h b/Core/Lib/Inc/vl6180x_cfg.h new file mode 100644 index 0000000..cc4bd37 --- /dev/null +++ b/Core/Lib/Inc/vl6180x_cfg.h @@ -0,0 +1,119 @@ +/******************************************************************************* +Copyright © 2015, STMicroelectronics International N.V. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * 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. + * Neither the name of STMicroelectronics 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, FITNESS FOR A PARTICULAR PURPOSE, AND +NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED. +IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. 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. +********************************************************************************/ +/* + * $Date: 2015-07-07 10:05:35 +0200 (Tue, 07 Jul 2015) $ + * $Revision: 2438 $ + */ + +/** + * @file VL6180x_cfg.h + * + * Proximity and ALS configuration + */ + +#ifndef VL6180x_CFG_H_ +#define VL6180x_CFG_H_ + +/** @defgroup api_config Configuration + * @brief API static configuration + */ + + + +/** @ingroup api_config + * @{*/ + + +/** + * @def VL6180x_UPSCALE_SUPPORT + * @brief Configure up-scale capabilities and default up-scale factor for ranging operations + * + * @li 1 : Fixed scaling by 1 (no up-scaling support) + * @li 2 : Fixed scaling by 2 + * @li 3 : Fixed scaling by 3 + * @li -1 -2 -3 : Run time programmable through @a VL6180x_UpscaleSetScaling(). Default scaling factore is -VL6180x_UPSCALE_SUPPORT \n + */ +#define VL6180x_UPSCALE_SUPPORT -1 + +/** + * @def VL6180x_ALS_SUPPORT + * @brief Enable ALS support + * + * Set to 0 if ALS is not used in application. This can help reducing code size if it is a concern. + */ +#define VL6180x_ALS_SUPPORT 1 + +/** + * @def VL6180x_HAVE_DMAX_RANGING + * @brief Enable DMax calculation for ranging applications. + * + * When set to 1, __Dmax__ is returned by API typically when @a VL6180x_RangePollMeasurement() high level + * function is called (this is returned in @a VL6180x_RangeData_t structure). + * __Dmax__ is an estimation of the maximum distance (in mm) the product can report a valid distance of a 17% target for + * the current ambient light conditions (__Dmax__ decreases when ambient light increases). __Dmax__ should be used only + * when the product is not able to return a valid distance (no object or object is too far from the ranging sensor). + * Typically, this is done by checking the __errorStatus__ field of the @a VL6180x_RangeData_t structure returned by + * the @a VL6180x_RangePollMeasurement() function. + * You may refer to ::RangeError_u to get full list of supported error codes. + * @warning Dmax is estimated for a 17% grey target. If the real target has a reflectance lower than 17%, report Dmax could be over-estimated + */ +#define VL6180x_HAVE_DMAX_RANGING 1 + +/** + * @def VL6180x_WRAP_AROUND_FILTER_SUPPORT + * @brief Enable wrap around filter (WAF) feature + * + * In specific conditions, when targeting a mirror or a very reflective metal, a __wrap around__ effect can occur internally to the + * ranging product which results in returning a wrong distance (under-estimated). Goal of the WAF is to detect this wrap arround effect + * and to filter it by returning a non-valid distance : __errorStatus__ set to 16 (see ::RangeError_u) + * @warning Wrap-around filter can not be used when device is running in continuous mode + * + * @li 0 : Filter is not supported, no filtering code is included in API + * @li 1 : Filter is supported and active by default + * @li -1 : Filter is supported but is not active by default @a VL6180x_FilterSetState() can turn it on and off at any time + */ +#define VL6180x_WRAP_AROUND_FILTER_SUPPORT 1 + +/** + * @def VL6180x_EXTENDED_RANGE + * @brief Enable extended ranging support + * + * Device that do not formally support extended ranging should only be used with a scaling factor of 1. + * Correct operation with scaling factor other than 1 (>200mm ) is not granted by ST. + */ +#define VL6180x_EXTENDED_RANGE 0 + + +#if (VL6180x_EXTENDED_RANGE) && (VL6180x_ALS_SUPPORT) +#warning "Als support should be OFF for extended range" +#endif + +#endif +/** @} */ // end of api_config + +/* VL6180x_CFG_H_ */ diff --git a/Core/Lib/Inc/vl6180x_def.h b/Core/Lib/Inc/vl6180x_def.h new file mode 100644 index 0000000..dd8e5cd --- /dev/null +++ b/Core/Lib/Inc/vl6180x_def.h @@ -0,0 +1,773 @@ +/******************************************************************************* +Copyright © 2015, STMicroelectronics International N.V. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * 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. + * Neither the name of STMicroelectronics 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, FITNESS FOR A PARTICULAR PURPOSE, AND +NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED. +IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. 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. +********************************************************************************/ + +/* + * $Date: 2018-07-04 16:49:57 +0200 (Wed, 04 Jul 2018) $ + * $Revision: 2768 $ + */ + +/** + * @file VL6180x_def.h + * + * @brief Type definitions for vl6180x api. + * + */ + + +#ifndef _VL6180x_DEF +#define _VL6180x_DEF + +/** API major version */ +#define VL6180x_API_REV_MAJOR 3 +/** API minor version */ +#define VL6180x_API_REV_MINOR 2 +/** API sub version */ +#define VL6180x_API_REV_SUB 2 + +#define VL6180X_STR_HELPER(x) #x +#define VL6180X_STR(x) VL6180X_STR_HELPER(x) + +#include "vl6180x_cfg.h" +#include "vl6180x_types.h" + +/* + * check configuration macro raise error or warning and suggest a default value + */ + +#ifndef VL6180x_UPSCALE_SUPPORT +#error "VL6180x_UPSCALE_SUPPORT not defined" +/* TODO you must define value for upscale support in your vl6180x_cfg.h */ +#endif + +#ifndef VL6180x_ALS_SUPPORT +#error "VL6180x_ALS_SUPPORT not defined" +/* TODO you must define VL6180x_ALS_SUPPORT with a value in your vl6180x_cfg.h set to 0 do disable*/ +#endif + +#ifndef VL6180x_HAVE_DMAX_RANGING +#error "VL6180x_HAVE_DMAX_RANGING not defined" +/* TODO you may remove or comment these #error and keep the default below or update your vl6180x_cfg.h .h file */ +/** + * force VL6180x_HAVE_DMAX_RANGING to not supported when not part of cfg file + */ +#define VL6180x_HAVE_DMAX_RANGING 0 +#endif + +#ifndef VL6180x_EXTENDED_RANGE +#define VL6180x_EXTENDED_RANGE 0 +#endif + +#ifndef VL6180x_WRAP_AROUND_FILTER_SUPPORT +#error "VL6180x_WRAP_AROUND_FILTER_SUPPORT not defined ?" +/* TODO you may remove or comment these #error and keep the default below or update vl6180x_cfg.h file */ +/** + * force VL6180x_WRAP_AROUND_FILTER_SUPPORT to not supported when not part of cfg file + */ +#define VL6180x_WRAP_AROUND_FILTER_SUPPORT 0 +#endif + + + +#ifndef VL6180x_HAVE_MULTI_READ +# define VL6180x_HAVE_MULTI_READ 0 +#endif + +/** + * Force VL6180x_CACHED_REG to default 0 when not defined + */ +#ifndef VL6180x_CACHED_REG +# define VL6180x_CACHED_REG 0 +#else +# define VL6180x_FIRST_CACHED_INDEX 0x04D +# define VL6180x_LAST_CACHED_INDEX (VL6180x_FIRST_CACHED_INDEX+55) +# define VL6180x_CACHED_REG_CNT (VL6180x_LAST_CACHED_INDEX-VL6180x_FIRST_CACHED_INDEX+1) +#endif + +/**************************************** + * PRIVATE define do not edit + ****************************************/ + +/** Maximal buffer size ever use in i2c */ +#define VL6180x_MAX_I2C_XFER_SIZE 8 /* At present time it 6 byte max but that can change */ + +#if VL6180x_UPSCALE_SUPPORT < 0 +/** + * @def VL6180x_HAVE_UPSCALE_DATA + * @brief is defined if device data structure has data so when user configurable up-scale is active + */ +#define VL6180x_HAVE_UPSCALE_DATA /* have data only for user configurable up-scale config */ +#endif + +#if VL6180x_WRAP_AROUND_FILTER_SUPPORT +/** + * @def VL6180x_HAVE_WRAP_AROUND_DATA + * @brief is defined if device data structure has filter data so when active in cfg file + */ +#define VL6180x_HAVE_WRAP_AROUND_DATA +#endif + +#if VL6180x_ALS_SUPPORT != 0 +/** + * @def VL6180x_HAVE_ALS_DATA + * @brief is defined when als data are include in device data structure so when als suport if configured + */ +#define VL6180x_HAVE_ALS_DATA +#endif + + +#if VL6180x_WRAP_AROUND_FILTER_SUPPORT || VL6180x_HAVE_DMAX_RANGING + #define VL6180x_HAVE_RATE_DATA +#endif + +/** Error and warning code returned by API + * + * negative value are true error mostly fatal\n + * positive value are warning most of time it's ok to continue\n + */ +enum VL6180x_ErrCode_t { + API_NO_ERROR = 0, + CALIBRATION_WARNING = 1, /*!< warning invalid calibration data may be in used \a VL6180x_InitData() \a VL6180x_GetOffsetCalibrationData \a VL6180x_SetOffsetCalibrationData*/ + MIN_CLIPED = 2, /*!< warning parameter passed was clipped to min before to be applied */ + NOT_GUARANTEED = 3, /*!< Correct operation is not guaranteed typically using extended ranging on vl6180x */ + + API_ERROR = -1, /*!< Unqualified error */ + INVALID_PARAMS = -2, /*!< parameter passed is invalid or out of range */ + NOT_SUPPORTED = -3, /*!< function is not supported in current mode or configuration */ + RANGE_ERROR = -4, /*!< device report a ranging error interrupt status */ + TIME_OUT = -5, /*!< aborted due to time out */ +}; + +/** + * Filtered result data structure range data is to be used + */ +typedef struct RangeFilterResult_tag { + uint16_t range_mm; /*!< Filtered ranging value */ + uint16_t rawRange_mm; /*!< raw range value (scaled) */ + uint32_t filterError; /*!< current filter error code */ +} RangeFilterResult_t; + +/** + * "small" unsigned data type used in filter + * + * if data space saving is not a concern it can be change to platform native unsigned int + */ +typedef uint32_t FilterType1_t; + +/** + * @def FILTER_NBOF_SAMPLES + * @brief sample history len used for wrap around filtering + */ +#define FILTER_NBOF_SAMPLES 10 +/** + * Wrap around filter internal data + */ +struct FilterData_t { + uint32_t MeasurementIndex; /*!< current measurement index */ + uint32_t MeasurementsSinceLastFlush; /*!< Number of measurements done since last time buffer has been flushed */ + uint16_t LastTrueRange[FILTER_NBOF_SAMPLES]; /*!< filtered/corrected distance history */ + uint32_t LastReturnRates[FILTER_NBOF_SAMPLES]; /*!< Return rate history */ + uint16_t StdFilteredReads; /*!< internal use */ + FilterType1_t Default_ZeroVal; /*!< internal use */ + FilterType1_t Default_VAVGVal; /*!< internal use */ + FilterType1_t NoDelay_ZeroVal; /*!< internal use */ + FilterType1_t NoDelay_VAVGVal; /*!< internal use */ + FilterType1_t Previous_VAVGDiff; /*!< internal use */ + uint32_t FilteringOnGoingConsecutiveStates; /*!< internal use */ + uint32_t filterError; /*!< current filter error code */ +}; + +#if VL6180x_HAVE_DMAX_RANGING +typedef int32_t DMaxFix_t; +struct DMaxData_t { + uint32_t ambTuningWindowFactor_K; /*!< internal algo tuning (*1000) */ + + DMaxFix_t retSignalAt400mm; /*!< intermediate dmax computation value caching @a #SYSRANGE_CROSSTALK_COMPENSATION_RATE and private reg 0x02A */ + /* int32_t RegB8; */ /*!< register 0xB8 cached to speed reduce i2c traffic for dmax computation */ + /* place all word data below to optimize struct packing */ + /* int32_t minSignalNeeded; */ /*!< optimized computation intermediate base on register cached value */ + int32_t snrLimit_K; /*!< cached and optimized computation intermediate from @a #SYSRANGE_MAX_AMBIENT_LEVEL_MULT */ + uint16_t ClipSnrLimit; /*!< Max value for snr limit */ + /* place all byte data below to optimize packing */ + /* uint8_t MaxConvTime; */ /*!< cached max convergence time @a #SYSRANGE_MAX_CONVERGENCE_TIME*/ +}; +#endif + +struct RangeIgnoreData_t { + uint16_t ValidHeight; + uint16_t IgnoreThreshold; + uint8_t Enabled; +}; +/** + * @struct VL6180xDevData_t + * + * @brief Per VL6180x device St private data structure \n + * End user should never access any of these field directly + * + * These must never access directly but only via VL6180xDev/SetData(dev, field) macro + */ +struct VL6180xDevData_t { + + uint32_t Part2PartAmbNVM; /*!< backed up NVM value */ + uint32_t XTalkCompRate_KCps; /*! Cached XTlak Compensation Rate */ + + uint16_t EceFactorM; /*!< Ece Factor M numerator */ + uint16_t EceFactorD; /*!< Ece Factor D denominator*/ + + struct RangeIgnoreData_t RangeIgnore; + +#ifdef VL6180x_HAVE_ALS_DATA + uint16_t IntegrationPeriod; /*!< cached als Integration period avoid slow read from device at each measure */ + uint16_t AlsGainCode; /*!< cached Als gain avoid slow read from device at each measure */ + uint16_t AlsScaler; /*!< cached Als scaler avoid slow read from device at each measure */ +#endif + +#ifdef VL6180x_HAVE_UPSCALE_DATA + uint8_t UpscaleFactor; /*!< up-scaling factor*/ +#endif + +#ifdef VL6180x_HAVE_WRAP_AROUND_DATA + uint8_t WrapAroundFilterActive; /*!< Filter on/off */ + struct FilterData_t FilterData; /*!< Filter internal data state history ... */ +#endif + +#if VL6180x_CACHED_REG + uint8_t CacheFilled; /*!< Set if valid data got fetched use to control when to fill up register cache */ + uint8_t CachedRegs[VL6180x_CACHED_REG_CNT]; /*!< Cache register storage */ +#endif +#if VL6180x_HAVE_DMAX_RANGING + struct DMaxData_t DMaxData; + uint8_t DMaxEnable; +#endif + int8_t Part2PartOffsetNVM; /*!< backed up NVM value */ +}; + + +/** + * @struct VL6180x_RangeData_t + * @brief Range and any optional measurement data. + */ +typedef struct { + int32_t range_mm; /*!< range distance in mm. */ + int32_t signalRate_mcps; /*!< signal rate (MCPS)\n these is a 9.7 fix point value, which is effectively a measure of target reflectance.*/ + uint32_t errorStatus; /*!< Error status of the current measurement. \n see @a ::RangeError_u @a VL6180x_GetRangeStatusErrString() */ + + +#ifdef VL6180x_HAVE_RATE_DATA + uint32_t rtnAmbRate; /*!< Return Ambient rate in KCount per sec related to \a RESULT_RANGE_RETURN_AMB_COUNT */ + uint32_t rtnRate; /*!< Return rate in KCount per sec related to \a RESULT_RANGE_RETURN_SIGNAL_COUNT */ + uint32_t rtnConvTime; /*!< Return Convergence time \a RESULT_RANGE_RETURN_CONV_TIME */ + uint32_t refConvTime; /*!< Reference convergence time \a RESULT_RANGE_REFERENCE_CONV_TIME */ +#endif + + +#if VL6180x_HAVE_DMAX_RANGING + uint32_t DMax; /*!< DMax when applicable */ +#endif + +#ifdef VL6180x_HAVE_WRAP_AROUND_DATA + RangeFilterResult_t FilteredData; /*!< Filter result main range_mm is updated */ +#endif +} VL6180x_RangeData_t; + + +/** use where fix point 9.7 bit values are expected + * + * given a floating point value f it's .7 bit point is (int)(f*(1<<7))*/ +typedef uint16_t FixPoint97_t; + +/** lux data type */ +typedef uint32_t lux_t; + +/** + * @brief This data type defines als measurement data. + */ +typedef struct VL6180x_AlsData_st { + lux_t lux; /**< Light measurement (Lux) */ + uint32_t errorStatus; /**< Error status of the current measurement. \n + * No Error := 0. \n + * Refer to product sheets for other error codes. */ +} VL6180x_AlsData_t; + +/** + * @brief Range status Error code + * + * @a VL6180x_GetRangeStatusErrString() if configured ( @a #VL6180x_RANGE_STATUS_ERRSTRING ) + * related to register @a #RESULT_RANGE_STATUS and additional post processing + */ +typedef enum { + NoError = 0, /*!< 0 0b0000 NoError */ + VCSEL_Continuity_Test, /*!< 1 0b0001 VCSEL_Continuity_Test */ + VCSEL_Watchdog_Test, /*!< 2 0b0010 VCSEL_Watchdog_Test */ + VCSEL_Watchdog, /*!< 3 0b0011 VCSEL_Watchdog */ + PLL1_Lock, /*!< 4 0b0100 PLL1_Lock */ + PLL2_Lock, /*!< 5 0b0101 PLL2_Lock */ + Early_Convergence_Estimate,/*!< 6 0b0110 Early_Convergence_Estimate */ + Max_Convergence, /*!< 7 0b0111 Max_Convergence */ + No_Target_Ignore, /*!< 8 0b1000 No_Target_Ignore */ + Not_used_9, /*!< 9 0b1001 Not_used */ + Not_used_10, /*!< 10 0b1010 Not_used_ */ + Max_Signal_To_Noise_Ratio, /*!< 11 0b1011 Max_Signal_To_Noise_Ratio*/ + Raw_Ranging_Algo_Underflow,/*!< 12 0b1100 Raw_Ranging_Algo_Underflow*/ + Raw_Ranging_Algo_Overflow, /*!< 13 0b1101 Raw_Ranging_Algo_Overflow */ + Ranging_Algo_Underflow, /*!< 14 0b1110 Ranging_Algo_Underflow */ + Ranging_Algo_Overflow, /*!< 15 0b1111 Ranging_Algo_Overflow */ + + /* code below are addition for API/software side they are not hardware*/ + RangingFiltered = 0x10, /*!< 16 0b10000 filtered by post processing*/ + DataNotReady = 0x12, /*!< 18 0b10011 New data sample not ready */ + +} RangeError_u; + + +/** @defgroup device_regdef Device registers & masks definitions + * @brief Device registers and masks definitions + */ + + +/** @ingroup device_regdef + * @{*/ + +/** + * The device model ID + */ +#define IDENTIFICATION_MODEL_ID 0x000 +/** + * Revision identifier of the Device for major change. + */ +#define IDENTIFICATION_MODULE_REV_MAJOR 0x003 +/** + * Revision identifier of the Device for minor change. + */ +#define IDENTIFICATION_MODULE_REV_MINOR 0x004 + + +/** + * @def SYSTEM_MODE_GPIO0 + * @brief Configures polarity and select which function gpio 0 serves. + * Gpio0 is chip enable at power up ! Be aware of all h/w implication of turning it to output. + * Same definition as #SYSTEM_MODE_GPIO1 + * @ingroup device_regdef + */ +#define SYSTEM_MODE_GPIO0 0x010 +/** + * @def SYSTEM_MODE_GPIO1 + * @brief Configures polarity and select what als or ranging functionality gpio pin serves. + * + * Function can be #GPIOx_SELECT_OFF #GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT.\n + * Same definition apply to register GPIO0 that is used as chip enable at power up. + * @ingroup device_regdef + */ +#define SYSTEM_MODE_GPIO1 0x011 + /** gpio pad POLARITY mask in #SYSTEM_MODE_GPIO1 (and/or 0) write 1 to set active high polarity (positive edge) */ + #define GPIOx_POLARITY_SELECT_MASK 0x20 + /** gpio pad Function select shift in #SYSTEM_MODE_GPIO1 or 0 */ + #define GPIOx_FUNCTIONALITY_SELECT_SHIFT 1 + /** gpio pad Function select mask in #SYSTEM_MODE_GPIO1 or 0 */ + #define GPIOx_FUNCTIONALITY_SELECT_MASK (0xF<i2c_lock, flags) +#define DoneI2CAccess(dev) spin_unlock_irqrestore(dev->i2c_lock,flags) +@endcode + +* __POSIX pthread__ application porting could be as follows :\n +* @code +struct MyVL6180Dev_t { + struct VL6180xDevData_t StData; + ... + pthread_mutex_t *lock; +}; +typedef struct MyVL6180Dev_t *VL6180xDev_t; + +#define VL6180x_I2C_USER_VAR //no need +#define VL6180x_GetI2CAccess(dev) pthread_mutex_lock(dev->lock) +#define VL6180x_DoneI2CAcces(dev) pthread_mutex_unlock(dev->lock) + * @endcode + */ + +/** + * @def I2C_BUFFER_CONFIG + * + * @brief Configure device register I2C access + * + * @li 0 : one GLOBAL buffer \n + * Use one global buffer of MAX_I2C_XFER_SIZE byte in data space \n + * This solution is not multi-device compliant nor multi-thread cpu safe \n + * It can be the best option for small 8/16 bit MCU without stack and limited ram (STM8s, 80C51 ...) + * + * @li 1 : ON_STACK/local \n + * Use local variable (on stack) buffer \n + * This solution is multi-thread with use of i2c resource lock or mutex see @a VL6180x_GetI2CAccess() \n + * + * @li 2 : User defined \n + * Per device potentially dynamic allocated. Requires @a VL6180x_GetI2cBuffer() to be implemented. + * @ingroup Configuration + */ +#define I2C_BUFFER_CONFIG 1 + +/** + * @brief Write data buffer to VL6180x device via i2c + * @param dev The device to write to + * @param buff The data buffer + * @param len The length of the transaction in byte + * @return 0 on success + * @ingroup cci_i2c + */ +int VL6180x_I2CWrite(VL6180xDev_t dev, uint8_t *buff, uint8_t len); + +/** + * + * @brief Read data buffer from VL6180x device via i2c + * @param dev The device to read from + * @param buff The data buffer to fill + * @param len The length of the transaction in byte + * @return 0 on success + * @ingroup cci_i2c + */ +int VL6180x_I2CRead(VL6180xDev_t dev, uint8_t *buff, uint8_t len); + + +/** + * @brief Declare any required variables used by i2c lock (@a VL6180x_DoneI2CAccess() and @a VL6180x_GetI2CAccess()) + * and buffer access : @a VL6180x_GetI2cBuffer() + * + * @ingroup cci_i2c + */ +#define VL6180x_I2C_USER_VAR + +/** + * @brief Acquire lock or mutex for access to i2c data buffer and bus.\n + * Delete the default VL6180x_GetI2CAccess 'do-nothing' macro below if you decide to implement this function. + * + * This function is used to perform i2c bus level and multiple access locking required for multi thread/proccess system.\n + * Multiple access (read and update) will lock once and do multiple basic i2c rd/wr to complete the overall transfer.\n + * When no locking is needed this can be a void macro.\n + * + * @param dev the device + * @ingroup cci_i2c + */ +void VL6180x_GetI2CAccess(VL6180xDev_t dev); + +/** + * @def VL6180x_GetI2CAccess + * @brief Default 'do-nothing' macro for @a VL6180x_GetI2CAccess(). Delete if used. + * @ingroup cci_i2c + */ +#define VL6180x_GetI2CAccess(dev) (void)0 /* TODO delete if function used */ + +/** + * @brief Release acquired lock or mutex for i2c access.\n + * Delete default VL6180x_DoneI2CAccess 'do-nothing' macro below if implementing that function. + * + * This function is used to release the acquired lock. + * @param dev The device + * @ingroup cci_i2c + */ +void VL6180x_DoneI2CAccess(VL6180xDev_t dev); + +/** @def VL6180x_DoneI2CAcces + * @brief Default 'do-nothing' macro for @a VL6180x_DoneI2CAcces(). Delete if used. + * @ingroup cci_i2c + */ +#define VL6180x_DoneI2CAcces(dev) (void)0 /*TODO delete if function used */ + +/** + * @brief Provided data buffer for i2c access for at least n_byte. + * + * You must implement it when i2c @a #I2C_BUFFER_CONFIG is set to 2 (User defined).\n + * This is used used in the context of #VL6180x_I2C_USER_VAR + * + * @param dev The device + * @param n_byte Minimal number of byte + * @return The buffer (cannot fail return not checked) + * @ingroup cci_i2c + */ +uint8_t *VL6180x_GetI2cBuffer(VL6180xDev_t dev, int n_byte); +#if I2C_BUFFER_CONFIG == 2 +#error /* TODO add your macro of code here for VL6180x_GetI2cBuffer */ +#endif + + + + + +#endif /* VL6180_I2C_H_ */ diff --git a/Core/Lib/Inc/vl6180x_platform.h b/Core/Lib/Inc/vl6180x_platform.h new file mode 100644 index 0000000..27b4761 --- /dev/null +++ b/Core/Lib/Inc/vl6180x_platform.h @@ -0,0 +1,312 @@ +/******************************************************************************* +Copyright © 2014, STMicroelectronics International N.V. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * 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. + * Neither the name of STMicroelectronics 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, FITNESS FOR A PARTICULAR PURPOSE, AND +NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED. +IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. 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. +********************************************************************************/ +/* + * $Date: 2015-07-07 17:33:18 +0200 (Tue, 07 Jul 2015) $ + * $Revision: 2441 $ + */ + +#ifndef VL6180x_PLATFORM +#define VL6180x_PLATFORM + +/* this is a typical ansi and posix example with multithread and i2c lock concern */ +#include +#include + +/** + * @file vl6180x_platform.h + * + * @brief All end user OS/platform/application porting + */ + +/** @defgroup api_platform Platform + * @brief Platform-dependent code + */ + + +/** @ingroup api_platform + * @{*/ + + /** + * @brief For user convenience to place or give any required data attribute + * to the built-in single device instance \n + * Useful only when Configuration @a #VL6180x_SINGLE_DEVICE_DRIVER is active + * + * @ingroup api_platform + */ +#define VL6180x_DEV_DATA_ATTR + +/** + * @def ROMABLE_DATA + * @brief API Read only data that can be place in rom/flash are declared with that extra keyword + * + * For user convenience, use compiler specific attribute or keyword to place all read-only data in required data area. \n + * For example using gcc section : + * @code + * #define ROMABLE_DATA __attribute__ ((section ("user_rom"))) + * // you may need to edit your link script file to place user_rom section in flash/rom memory + * @endcode + * + * @ingroup api_platform + */ +#define ROMABLE_DATA +/* #define ROMABLE_DATA __attribute__ ((section ("user_rom"))) */ + +/** + * @def VL6180x_RANGE_STATUS_ERRSTRING + * @brief Activate error code translation into string. + * TODO: michel to apdate + * @ingroup api_platform + */ +#define VL6180x_RANGE_STATUS_ERRSTRING 1 + +/** + * @def VL6180x_SINGLE_DEVICE_DRIVER + * @brief Enable lightweight single vl6180x device driver. + * + * Value __1__ => Single device capable. + * Configure optimized API for single device driver with static data and minimal use of ref pointer. \n + * Limited to single device driver or application in non multi thread/core environment. \n + * + * Value __0__ => Multiple device capable. User must review "device" structure and type in vl6180x_platform.h files. + * @ingroup api_platform + */ +#define VL6180x_SINGLE_DEVICE_DRIVER 1 + +/** + * @def VL6180X_SAFE_POLLING_ENTER + * @brief Ensure safe polling method when set + * + * Polling for a condition can be hazardous and result in infinite looping if any previous interrupt status + * condition is not cleared. \n + * Setting these flags enforce error clearing on start of polling method to avoid it. + * the drawback are : \n + * @li extra use-less i2c bus usage and traffic + * @li potentially slower measure rate. + * If application ensures interrupt get cleared on mode or interrupt configuration change + * then keep option disabled. \n + * To be safe set these option to 1 + * @ingroup api_platform + */ +#define VL6180X_SAFE_POLLING_ENTER 0 + +/** + * @def VL6180x_HAVE_MULTI_READ + * @brief Enable I2C multi read support + * + * When set to 1, multi read operations are done (when necessary) by the API functions (mainly WAF) to access a bunch of registers + * instead of individual ones (for speed increase). This requires the @a VL6180x_RdMulti() function to be implemented. + */ +#define VL6180x_HAVE_MULTI_READ 1 + + +/** + * @def VL6180x_CACHED_REG + * @brief Enable Cached Register mode + * + * In addition to the multi read mode (#VL6180x_HAVE_MULTI_READ set to 1), this mode implements an advanced register access mode to speed-up + * ranging measurements by reading all results registers in one shot (using multi read operation). All post-processing operations (like WAF) + * are done by accessing the cached registers instead of doing individual register access. + * @warning It is mandatory to set #VL6180x_HAVE_MULTI_READ to 1 to benefit from this advanced mode + + */ +#define VL6180x_CACHED_REG 1 + + +/** + * @brief Enable start/end logging facilities. It can generates traces log to help problem tracking analysis and solving + * + * Requires porting @a #LOG_FUNCTION_START, @a #LOG_FUNCTION_END, @a #LOG_FUNCTION_END_FMT + * @ingroup api_platform + */ +#define VL6180X_LOG_ENABLE 0 + +#include "vl6180x_def.h" + +//TODO: modify this +#if VL6180x_SINGLE_DEVICE_DRIVER +/** + * @typedef VL6180xDev_t + * @brief Generic VL6180x device type that does link between API and platform abstraction layer + * + * @ingroup api_platform + */ + /* //![device_type_int] */ + typedef uint8_t VL6180xDev_t; /* simplest single device example "dev" is the i2c device address in the platform AL*/ + /* //![device_type_int] */ + +#else /* VL6180x_SINGLE_DEVICE_DRIVER */ + +/*! [device_type_multi] */ + +struct MyDev_t { + struct VL6180xDevData_t Data; /*!< embed ST VL6180 Dev data as "Data"*/ + //TODO ADD HERE any extra device data + /*!< user specific field */ + int i2c_bus_num; /*!< i2c bus number user specific field */ + int i2c_dev_addr; /*!< i2c devcie address user specific field */ + mutex_t dev_lock ; /*!< mutex user specific field */ + int i2c_file; /*!< sample i2c file handle */ +}; +typedef struct MyDev_t *VL6180xDev_t; + +/** + * @def VL6180xDevDataGet + * @brief Get ST private structure @a VL6180xDevData_t data access (needed only in multi devices configuration) + * + * It may be used and a real data "ref" not just as "get" for sub-structure item + * like VL6180xDevDataGet(FilterData.field)[i] or VL6180xDevDataGet(FilterData.MeasurementIndex)++ + * @param dev The device + * @param field ST structure filed name + * @ingroup api_platform + */ +#define VL6180xDevDataGet(dev, field) (dev->Data.field) + +/** + * @def VL6180xDevDataSet(dev, field, data) + * @brief Set ST private structure @a VL6180xDevData_t data field (needed only in multi devices configuration) + * @param dev The device + * @param field ST structure field name + * @param data Data to be set + * @ingroup api_platform + */ +#define VL6180xDevDataSet(dev, field, data) (dev->Data.field)=(data) +/*! [device_type_multi] */ + +#endif /* #else VL6180x_SINGLE_DEVICE_DRIVER */ + +/** + * @brief execute delay in all polling api calls : @a VL6180x_RangePollMeasurement() and @a VL6180x_AlsPollMeasurement() + * + * A typical multi-thread or RTOs implementation is to sleep the task for some 5ms (with 100Hz max rate faster polling is not needed). + * if nothing specific is needed, you can define it as an empty/void macro + * @code + * #define VL6180x_PollDelay(...) (void)0 + * @endcode + * @param dev The device + * @ingroup api_platform + */ +void VL6180x_PollDelay(VL6180xDev_t dev); /* usualy best implemanted a a real fucntion */ + +/** @def VL6180x_PollDelay + * @brief Default value : does nothing. Macro to be deleted it you implement a real function + * @ingroup api_platform + */ +#define VL6180x_PollDelay(dev) (void)0 + + + + + +#if VL6180X_LOG_ENABLE +#include +#include +extern FILE * log_file; + +#define trace_printf fprinf +#define LOG_GET_TIME() clock() + +/** + * @brief Log function start. + * + * @param fmt Text and printf formating for any extra argument.\n + * It can be " " when there is nothing else than the function entry to log. + * @param ... (\__VA_ARGS__) extra argument if any, but it can be none. + * + * @note Formatting a string can take considerable amount of cycles. Typically "sprinting" 4 int arguments and function name take 5-10K on common 32 bit µC\n + * It depends on implementation. The tracing is very intrusive and resources consuming . + * + * Example of time logging using printf and LOG_GET_TIME() macro \n + * @code + * #define LOG_FUNCTION_START(fmt, ... ) printf("beg %s @%d\t" fmt "\n", __func__, LOG_GET_TIME(), ##__VA_ARGS__) + * @endcode + * @ingroup api_platform + */ +#define LOG_FUNCTION_START(fmt, ... ) \ + fprintf(log_file, "VL61080 beg %s start @%d\t" fmt "\n", __FUNCTION__, LOG_GET_TIME(), ##__VA_ARGS__) + +/** + * @brief Logging function end with status. + * + * @param status final status (%d) + * + * Example of time logging using printf and LOG_GET_TIME() macro \n + * @code + * #define LOG_FUNCTION_END(status) printf("end %s @%d %d\n", __func__, LOG_GET_TIME(), (int)status) + * @endcode + + * @ingroup api_platform + */ +#define LOG_FUNCTION_END(status)\ + fprintf(log_file, "VL61080 end %s @%d %d\n", __FUNCTION__, LOG_GET_TIME(), (int)status) + + +/** + * @brief Log function end along with extra optional formated arguments. + * + * @param status final status (%d) + * @param fmt printf format and string + * @param ... (\__VA_ARGS__) extra argument for printf or va_args type function + * + * Example of time logging using printf and LOG_GET_TIME() macro. \n + * @code + * #define LOG_FUNCTION_END_FMT(status, fmt, ... ) printf("End %s @%d %d\t"fmt"\n" , __func__, LOG_GET_TIME(), (int)status,##__VA_ARGS__) + * @endcode + + * @ingroup api_platform + */ +#define LOG_FUNCTION_END_FMT(status, fmt, ... )\ + fprintf(log_file, "End %s @%d %d\t"fmt"\n" , __FUNCTION__, LOG_GET_TIME(), (int)status,##__VA_ARGS__) + + +/** + * @brief Log error raised in API + * + * Implementation may abort execution but it's not an API requirement + * + * @param fmt text and printf like format list + * @param ... (\__VA_ARGS__) optional variable to be formated + * + * Example of error logging using printf and LOG_GET_TIME() macro \n + * @code + * #define VL6180x_ErrLog(msg, ... ) printf("Err in %s line %d @%dt" msg "\n" , __func__, __LINE__, LOG_GET_TIME(), msg ,##__VA_ARGS__) + * @endcode + * @ingroup api_platform + */ +#define VL6180x_ErrLog( fmt, ...) fprintf(stderr, "VL6180x_ErrLog %s" fmt "\n", __func__, ##__VA_ARGS__) + +#else /* VL6180X_LOG_ENABLE no logging */ + #define LOG_FUNCTION_START(...) (void)0 + #define LOG_FUNCTION_END(...) (void)0 + #define LOG_FUNCTION_END_FMT(...) (void)0 + #define VL6180x_ErrLog(... ) (void)0 +#endif /* else */ + +#endif /* VL6180x_PLATFORM */ + + + diff --git a/Core/Lib/Inc/vl6180x_types.h b/Core/Lib/Inc/vl6180x_types.h new file mode 100644 index 0000000..b87a966 --- /dev/null +++ b/Core/Lib/Inc/vl6180x_types.h @@ -0,0 +1,104 @@ +/******************************************************************************* +Copyright © 2014, STMicroelectronics International N.V. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * 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. + * Neither the name of STMicroelectronics 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, FITNESS FOR A PARTICULAR PURPOSE, AND +NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED. +IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. 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. +********************************************************************************/ +/* + * $Date: 2015-01-08 14:30:24 +0100 (Thu, 08 Jan 2015) $ + * $Revision: 2039 $ + */ +/** + * @file vl6180x_types.h + * @brief vl6180x types definition + */ + +#ifndef VL6180x_TYPES_H_ +#define VL6180x_TYPES_H_ + +/** @defgroup porting_type Basic type definition + * @ingroup porting + * + * @brief file vl6180x_types.h file holds basic type definitions that may require porting + * + * Contains type that must be defined for the platform\n + * When target platform and compiler provide stdint.h and stddef.h, it is enough to include it.\n + * If stdint.h is not available review and adapt all signed and unsigned 8/16/32 bits basic types. \n + * If stddef.h is not available review and adapt NULL definition . + */ +#include +#include + +#ifndef NULL +#error "TODO review NULL definition or add required include " +#endif + +#if ! defined(STDINT_H) && !defined(_GCC_STDINT_H) &&!defined(__STDINT_DECLS) && !defined(_GCC_WRAP_STDINT_H) + +#pragma message("Please review type definition of STDINT define for your platform and add to list above ") + + /* + * target platform do not provide stdint or use a different #define than above + * to avoid seeing the message below addapt the #define list above or implement + * all type and delete these pragma + */ + +/** \ingroup porting_type + * @{ + */ + +/** @brief Typedef defining 32 bit unsigned int type.\n + * The developer should modify this to suit the platform being deployed. + */ +typedef unsigned int uint32_t; + +/** @brief Typedef defining 32 bit int type.\n + * The developer should modify this to suit the platform being deployed. + */ +typedef int int32_t; + +/** @brief Typedef defining 16 bit unsigned short type.\n + * The developer should modify this to suit the platform being deployed. + */ +typedef unsigned short uint16_t; + +/** @brief Typedef defining 16 bit short type.\n + * The developer should modify this to suit the platform being deployed. + */ +typedef short int16_t; + +/** @brief Typedef defining 8 bit unsigned char type.\n + * The developer should modify this to suit the platform being deployed. + */ +typedef unsigned char uint8_t; + +/** @brief Typedef defining 8 bit char type.\n + * The developer should modify this to suit the platform being deployed. + */ +typedef signed char int8_t; + +/** @} */ +#endif /* _STDINT_H */ + +#endif /* VL6180x_TYPES_H_ */ diff --git a/Core/Lib/Src/vl6180x_api.c b/Core/Lib/Src/vl6180x_api.c new file mode 100644 index 0000000..784970a --- /dev/null +++ b/Core/Lib/Src/vl6180x_api.c @@ -0,0 +1,2761 @@ +/******************************************************************************* +Copyright � 2015, STMicroelectronics International N.V. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * 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. + * Neither the name of STMicroelectronics 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, FITNESS FOR A PARTICULAR PURPOSE, AND +NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED. +IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. 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. +********************************************************************************/ + +/* + * $Date: 2018-07-04 16:49:57 +0200 (Wed, 04 Jul 2018) $ + * $Revision: 2768 $ + */ +#include "vl6180x_api.h" + +#define VL6180x_9to7Conv(x) (x) + +/* TODO when set all "cached" value with "default init" are updated after init + * from register read back */ +#define REFRESH_CACHED_DATA_AFTER_INIT 1 + +#define IsValidGPIOFunction(x) \ + ((x) == GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT || (x) == GPIOx_SELECT_OFF) + +/** default value ECE factor Molecular */ +#define DEF_ECE_FACTOR_M 85 +/** default value ECE factor Denominator */ +#define DEF_ECE_FACTOR_D 100 +/** default value ALS integration time */ +#define DEF_INT_PEFRIOD 100 +/** default value ALS gain */ +#define DEF_ALS_GAIN 1 +/** default value ALS scaler */ +#define DEF_ALS_SCALER 1 +/** default value for DMAX Enable */ +#define DEF_DMAX_ENABLE 1 +/** default ambient tuning factor %x1000 */ +#define DEF_AMBIENT_TUNING 80 + +#define DEF_CROSS_TALK_VALID_HEIGHT_VALUE 20 + +#if VL6180x_SINGLE_DEVICE_DRIVER +extern struct VL6180xDevData_t SingleVL6180xDevData; +#define VL6180xDevDataGet(dev, field) (SingleVL6180xDevData.field) +#define VL6180xDevDataSet(dev, field, data) SingleVL6180xDevData.field = (data) +#endif + +#define LUXRES_FIX_PREC 8 +#define GAIN_FIX_PREC 8 /* ! if not sme as LUX_PREC then :( adjust GetLux */ +#define AN_GAIN_MULT (1 << GAIN_FIX_PREC) + +static int32_t _GetAveTotalTime(VL6180xDev_t dev); +static int VL6180x_RangeSetEarlyConvergenceEestimateThreshold(VL6180xDev_t dev); + +/** + * ScalerLookUP scaling factor-1 to register #RANGE_SCALER lookup + */ +static const uint16_t ScalerLookUP[] ROMABLE_DATA = { + 253, 127, 84}; /* lookup table for scaling->scalar 1x2x 3x */ +/** + * scaling factor to Upper limit look up + */ +static const uint16_t UpperLimitLookUP[] ROMABLE_DATA = { + 185, 370, 580}; /* lookup table for scaling->limit 1x2x3x */ +/** + * Als Code gain to fix point gain lookup + */ +static const uint16_t AlsGainLookUp[8] ROMABLE_DATA = { + (uint16_t)(20.0f * AN_GAIN_MULT), (uint16_t)(10.0f * AN_GAIN_MULT), + (uint16_t)(5.0f * AN_GAIN_MULT), (uint16_t)(2.5f * AN_GAIN_MULT), + (uint16_t)(1.67f * AN_GAIN_MULT), (uint16_t)(1.25f * AN_GAIN_MULT), + (uint16_t)(1.0f * AN_GAIN_MULT), (uint16_t)(40.0f * AN_GAIN_MULT), +}; + +#if VL6180x_RANGE_STATUS_ERRSTRING +const char *ROMABLE_DATA VL6180x_RangeStatusErrString[] = { + "No Error", + "VCSEL Continuity Test", + "VCSEL Watchdog Test", + "VCSEL Watchdog", + "PLL1 Lock", + "PLL2 Lock", + "Early Convergence Estimate", + "Max Convergence", + "No Target Ignore", + "Not used 9", + "Not used 10", + "Max Signal To Noise Ratio", + "Raw Ranging Algo Underflow", + "Raw Ranging Algo Overflow", + "Ranging Algo Underflow", + "Ranging Algo Overflow", + + "Filtered by post processing (WAF)", + "Ranging filtering (WAF) on-going", + "Data not ready", +}; + +const char *VL6180x_RangeGetStatusErrString(uint8_t RangeErrCode) { + if (RangeErrCode > sizeof(VL6180x_RangeStatusErrString) / + sizeof(VL6180x_RangeStatusErrString[0])) + return NULL; + return VL6180x_RangeStatusErrString[RangeErrCode]; +} +#endif + +#if VL6180x_UPSCALE_SUPPORT == 1 +#define _GetUpscale(dev, ...) 1 +#define _SetUpscale(...) -1 +#define DEF_UPSCALE 1 +#elif VL6180x_UPSCALE_SUPPORT == 2 +#define _GetUpscale(dev, ...) 2 +#define _SetUpscale(...) +#define DEF_UPSCALE 2 +#elif VL6180x_UPSCALE_SUPPORT == 3 +#define _GetUpscale(dev, ...) 3 +#define _SetUpscale(...) +#define DEF_UPSCALE 3 +#else +#define DEF_UPSCALE (-(VL6180x_UPSCALE_SUPPORT)) +#define _GetUpscale(dev, ...) VL6180xDevDataGet(dev, UpscaleFactor) +#define _SetUpscale(dev, Scaling) VL6180xDevDataSet(dev, UpscaleFactor, Scaling) +#endif + +#if VL6180x_SINGLE_DEVICE_DRIVER +/** + * the unique driver data When single device driver is active + */ +struct VL6180xDevData_t VL6180x_DEV_DATA_ATTR SingleVL6180xDevData = { + .EceFactorM = DEF_ECE_FACTOR_M, + .EceFactorD = DEF_ECE_FACTOR_D, +#ifdef VL6180x_HAVE_UPSCALE_DATA + .UpscaleFactor = DEF_UPSCALE, +#endif +#ifdef VL6180x_HAVE_ALS_DATA + .IntegrationPeriod = DEF_INT_PEFRIOD, + .AlsGainCode = DEF_ALS_GAIN, + .AlsScaler = DEF_ALS_SCALER, +#endif +#ifdef VL6180x_HAVE_DMAX_RANGING + .DMaxEnable = DEF_DMAX_ENABLE, +#endif +}; +#endif /* VL6180x_SINGLE_DEVICE_DRIVER */ + +#define Fix7_2_KCPs(x) ((((uint32_t)(x)) * 1000) >> 7) + +#if VL6180x_WRAP_AROUND_FILTER_SUPPORT || VL6180x_HAVE_DMAX_RANGING +static int _GetRateResult(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData); +#endif + +#if VL6180x_WRAP_AROUND_FILTER_SUPPORT +static int _filter_Init(VL6180xDev_t dev); +static int _filter_GetResult(VL6180xDev_t dev, VL6180x_RangeData_t *pData); +#define _IsWrapArroundActive(dev) VL6180xDevDataGet(dev, WrapAroundFilterActive) +#else +#define _IsWrapArroundActive(dev) 0 +#endif + +#if VL6180x_HAVE_DMAX_RANGING +void _DMax_OneTimeInit(VL6180xDev_t dev); +static int _DMax_InitData(VL6180xDev_t dev); +static int _DMax_Compute(VL6180xDev_t dev, VL6180x_RangeData_t *pRange); +#define _IsDMaxActive(dev) VL6180xDevDataGet(dev, DMaxEnable) +#else +#define _DMax_InitData(...) 0 /* success */ +#define _DMax_OneTimeInit(...) (void)0 +#define _IsDMaxActive(...) 0 +#endif + +static int VL6180x_RangeStaticInit(VL6180xDev_t dev); +static int VL6180x_UpscaleStaticInit(VL6180xDev_t dev); + +int VL6180x_WaitDeviceBooted(VL6180xDev_t dev) { + uint8_t FreshOutReset; + int status; + LOG_FUNCTION_START(""); + do { + status = VL6180x_RdByte(dev, SYSTEM_FRESH_OUT_OF_RESET, &FreshOutReset); + } while (FreshOutReset != 1 && status == 0); + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_InitData(VL6180xDev_t dev) { + int status, dmax_status; + int8_t offset; + uint8_t FreshOutReset; + uint32_t CalValue; + uint16_t u16; + uint32_t XTalkCompRate_KCps; + + LOG_FUNCTION_START(""); + + VL6180xDevDataSet(dev, EceFactorM, DEF_ECE_FACTOR_M); + VL6180xDevDataSet(dev, EceFactorD, DEF_ECE_FACTOR_D); + + VL6180xDevDataSet(dev, RangeIgnore.Enabled, 0); + +#ifdef VL6180x_HAVE_UPSCALE_DATA + VL6180xDevDataSet(dev, UpscaleFactor, DEF_UPSCALE); +#endif + +#ifdef VL6180x_HAVE_ALS_DATA + VL6180xDevDataSet(dev, IntegrationPeriod, DEF_INT_PEFRIOD); + VL6180xDevDataSet(dev, AlsGainCode, DEF_ALS_GAIN); + VL6180xDevDataSet(dev, AlsScaler, DEF_ALS_SCALER); +#endif + +#ifdef VL6180x_HAVE_WRAP_AROUND_DATA + VL6180xDevDataSet(dev, WrapAroundFilterActive, + (VL6180x_WRAP_AROUND_FILTER_SUPPORT > 0)); + VL6180xDevDataSet(dev, DMaxEnable, DEF_DMAX_ENABLE); +#endif + + _DMax_OneTimeInit(dev); + do { + + /* backup offset initial value from nvm these must be done prior any over + * call that use offset */ + status = VL6180x_RdByte(dev, SYSRANGE_PART_TO_PART_RANGE_OFFSET, + (uint8_t *)&offset); + if (status) { + VL6180x_ErrLog("SYSRANGE_PART_TO_PART_RANGE_OFFSET rd fail"); + break; + } + VL6180xDevDataSet(dev, Part2PartOffsetNVM, offset); + + status = VL6180x_RdDWord(dev, SYSRANGE_RANGE_IGNORE_THRESHOLD, &CalValue); + if (status) { + VL6180x_ErrLog("Part2PartAmbNVM rd fail"); + break; + } + if ((CalValue & 0xFFFF0000) == 0) { + CalValue = 0x00CE03F8; + } + VL6180xDevDataSet(dev, Part2PartAmbNVM, CalValue); + + status = VL6180x_RdWord(dev, SYSRANGE_CROSSTALK_COMPENSATION_RATE, &u16); + if (status) { + VL6180x_ErrLog("SYSRANGE_CROSSTALK_COMPENSATION_RATE rd fail "); + break; + } + XTalkCompRate_KCps = Fix7_2_KCPs(u16); + VL6180xDevDataSet(dev, XTalkCompRate_KCps, XTalkCompRate_KCps); + + dmax_status = _DMax_InitData(dev); + if (dmax_status < 0) { + VL6180x_ErrLog("DMax init failure"); + break; + } + + /* Read or wait for fresh out of reset */ + status = VL6180x_RdByte(dev, SYSTEM_FRESH_OUT_OF_RESET, &FreshOutReset); + if (status) { + VL6180x_ErrLog("SYSTEM_FRESH_OUT_OF_RESET rd fail"); + break; + } + if (FreshOutReset != 1 || dmax_status) + status = CALIBRATION_WARNING; + + } while (0); + + LOG_FUNCTION_END(status); + return status; +} + +int8_t VL6180x_GetOffsetCalibrationData(VL6180xDev_t dev) { + int8_t offset; + LOG_FUNCTION_START(""); + offset = VL6180xDevDataGet(dev, Part2PartOffsetNVM); + LOG_FUNCTION_END(offset); + return offset; +} + +int VL6180x_SetOffsetCalibrationData(VL6180xDev_t dev, int8_t offset) { + int status; + LOG_FUNCTION_START("%d", offset); + VL6180xDevDataSet(dev, Part2PartOffsetNVM, offset); + offset /= _GetUpscale(dev); + status = VL6180x_WrByte(dev, SYSRANGE_PART_TO_PART_RANGE_OFFSET, offset); + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_SetXTalkCompensationRate(VL6180xDev_t dev, FixPoint97_t Rate) { + int status; + LOG_FUNCTION_START("%d", Rate); + status = VL6180x_WrWord(dev, SYSRANGE_CROSSTALK_COMPENSATION_RATE, Rate); + if (status == 0) { + uint32_t XTalkCompRate_KCps; + XTalkCompRate_KCps = Fix7_2_KCPs(Rate); + VL6180xDevDataSet(dev, XTalkCompRate_KCps, XTalkCompRate_KCps); + /* update dmax whenever xtalk rate changes */ + status = _DMax_InitData(dev); + } + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_SetI2CAddress(VL6180xDev_t dev, uint8_t NewAddress) { + int status; + LOG_FUNCTION_START(""); + + status = VL6180x_WrByte(dev, I2C_SLAVE_DEVICE_ADDRESS, NewAddress / 2); + if (status) { + VL6180x_ErrLog("new i2c addr Wr fail"); + } + LOG_FUNCTION_END(status); + return status; +} + +uint16_t VL6180x_GetUpperLimit(VL6180xDev_t dev) { + uint16_t limit; + int scaling; + + LOG_FUNCTION_START(""); + + scaling = _GetUpscale(dev); + /* FIXME we do assume here _GetUpscale is valid if user call us prior to init + * we may overflow the LUT mem area */ + limit = UpperLimitLookUP[scaling - 1]; + + LOG_FUNCTION_END((int)limit); + return limit; +} + +int VL6180x_StaticInit(VL6180xDev_t dev) { + int status = 0, init_status; + LOG_FUNCTION_START(""); + + /* TODO doc When using configurable scaling but using 1x as start condition + * load tunning upscale or not ??? */ + if (_GetUpscale(dev) == 1 && !(VL6180x_UPSCALE_SUPPORT < 0)) + init_status = VL6180x_RangeStaticInit(dev); + else + init_status = VL6180x_UpscaleStaticInit(dev); + + if (init_status < 0) { + VL6180x_ErrLog("StaticInit fail"); + goto error; + } else if (init_status > 0) { + VL6180x_ErrLog("StaticInit warning"); + } + +#if REFRESH_CACHED_DATA_AFTER_INIT +#ifdef VL6180x_HAVE_ALS_DATA + /* update cached value after tuning applied */ + do { + uint8_t data; + status = VL6180x_RdByte(dev, FW_ALS_RESULT_SCALER, &data); + if (status) + break; + VL6180xDevDataSet(dev, AlsScaler, data); + + status = VL6180x_RdByte(dev, SYSALS_ANALOGUE_GAIN, &data); + if (status) + break; + VL6180x_AlsSetAnalogueGain(dev, data); + } while (0); +#endif +#endif /* REFRESH_CACHED_DATA_AFTER_INIT */ + if (status < 0) { + VL6180x_ErrLog("StaticInit fail"); + } + if (!status && init_status) { + status = init_status; + } +error: + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_SetGroupParamHold(VL6180xDev_t dev, int Hold) { + int status; + uint8_t value; + + LOG_FUNCTION_START("%d", Hold); + if (Hold) + value = 1; + else + value = 0; + status = VL6180x_WrByte(dev, SYSTEM_GROUPED_PARAMETER_HOLD, value); + + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_Prepare(VL6180xDev_t dev) { + int status; + LOG_FUNCTION_START(""); + + do { + status = VL6180x_StaticInit(dev); + if (status < 0) + break; + + /* set range InterruptMode to new sample */ + status = VL6180x_RangeConfigInterrupt( + dev, CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY); + if (status) + break; + + /* set default threshold */ + status = VL6180x_RangeSetRawThresholds(dev, 10, 200); + if (status) { + VL6180x_ErrLog("VL6180x_RangeSetRawThresholds fail"); + break; + } +#if VL6180x_ALS_SUPPORT + status = VL6180x_AlsSetIntegrationPeriod(dev, 100); + if (status) + break; + status = VL6180x_AlsSetInterMeasurementPeriod(dev, 200); + if (status) + break; + status = VL6180x_AlsSetAnalogueGain(dev, 0); + if (status) + break; + status = VL6180x_AlsSetThresholds(dev, 0, 0xFF); + if (status) + break; + /* set Als InterruptMode to new sample */ + status = + VL6180x_AlsConfigInterrupt(dev, CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY); + if (status) { + VL6180x_ErrLog("VL6180x_AlsConfigInterrupt fail"); + break; + } +#endif +#if VL6180x_WRAP_AROUND_FILTER_SUPPORT + _filter_Init(dev); +#endif + /* make sure to reset any left previous condition that can hangs first poll + */ + status = VL6180x_ClearAllInterrupt(dev); + } while (0); + LOG_FUNCTION_END(status); + + return status; +} + +#if VL6180x_ALS_SUPPORT +int VL6180x_AlsGetLux(VL6180xDev_t dev, lux_t *pLux) { + int status; + uint16_t RawAls; + uint32_t luxValue = 0; + uint32_t IntPeriod; + uint32_t AlsAnGain; + uint32_t GainFix; + uint32_t AlsScaler; + +#if LUXRES_FIX_PREC != GAIN_FIX_PREC +#error "LUXRES_FIX_PREC != GAIN_FIX_PREC review these code to be correct" +#endif + const uint32_t LuxResxIntIme = + (uint32_t)(0.56f * DEF_INT_PEFRIOD * (1 << LUXRES_FIX_PREC)); + + LOG_FUNCTION_START("%p", pLux); + + status = VL6180x_RdWord(dev, RESULT_ALS_VAL, &RawAls); + if (!status) { + /* wer are yet here at no fix point */ + IntPeriod = VL6180xDevDataGet(dev, IntegrationPeriod); + AlsScaler = VL6180xDevDataGet(dev, AlsScaler); + IntPeriod++; /* what stored is real time ms -1 and it can be 0 for or 0 or + 1ms */ + luxValue = + (uint32_t)RawAls * LuxResxIntIme; /* max # 16+8bits + 6bit (0.56*100) */ + luxValue /= IntPeriod; /* max # 16+8bits + 6bit 16+8+1 to 9 bit */ + /* between 29 - 21 bit */ + AlsAnGain = VL6180xDevDataGet(dev, AlsGainCode); + GainFix = AlsGainLookUp[AlsAnGain]; + luxValue = luxValue / (AlsScaler * GainFix); + *pLux = luxValue; + } + + LOG_FUNCTION_END_FMT(status, "%x", (int)*pLux); + return status; +} + +int VL6180x_AlsGetMeasurement(VL6180xDev_t dev, VL6180x_AlsData_t *pAlsData) { + int status; + uint8_t ErrStatus; + + LOG_FUNCTION_START("%p", pAlsData); + + status = VL6180x_AlsGetLux(dev, &pAlsData->lux); + if (!status) { + status = VL6180x_RdByte(dev, RESULT_ALS_STATUS, &ErrStatus); + pAlsData->errorStatus = ErrStatus >> 4; + } + LOG_FUNCTION_END_FMT(status, "%d %d", (int)pAlsData->lux, + (int)pAlsData->errorStatus); + + return status; +} + +int VL6180x_AlsPollMeasurement(VL6180xDev_t dev, VL6180x_AlsData_t *pAlsData) { + int status; + int ClrStatus; + uint8_t IntStatus; + + LOG_FUNCTION_START("%p", pAlsData); +#if VL6180X_SAFE_POLLING_ENTER + /* if device get stopped with left interrupt uncleared , it is required to + * clear them now or poll for new condition will never occur*/ + status = VL6180x_AlsClearInterrupt(dev); + if (status) { + VL6180x_ErrLog("VL6180x_AlsClearInterrupt fail"); + goto over; + } +#endif + + status = VL6180x_AlsSetSystemMode(dev, MODE_START_STOP | MODE_SINGLESHOT); + if (status) { + VL6180x_ErrLog("VL6180x_AlsSetSystemMode fail"); + goto over; + } + + /* poll for new sample ready */ + while (1) { + status = VL6180x_AlsGetInterruptStatus(dev, &IntStatus); + if (status) { + break; + } + if (IntStatus == RES_INT_STAT_GPIO_NEW_SAMPLE_READY) { + break; /* break on new data (status is 0) */ + } + + VL6180x_PollDelay(dev); + }; + + if (!status) { + status = VL6180x_AlsGetMeasurement(dev, pAlsData); + } + + ClrStatus = VL6180x_AlsClearInterrupt(dev); + if (ClrStatus) { + VL6180x_ErrLog("VL6180x_AlsClearInterrupt fail"); + if (!status) { + status = ClrStatus; /* leave previous if already on error */ + } + } +over: + LOG_FUNCTION_END(status); + + return status; +} + +int VL6180x_AlsGetInterruptStatus(VL6180xDev_t dev, uint8_t *pIntStatus) { + int status; + uint8_t IntStatus; + LOG_FUNCTION_START("%p", pIntStatus); + + status = VL6180x_RdByte(dev, RESULT_INTERRUPT_STATUS_GPIO, &IntStatus); + *pIntStatus = (IntStatus >> 3) & 0x07; + + LOG_FUNCTION_END_FMT(status, "%d", (int)*pIntStatus); + return status; +} + +int VL6180x_AlsWaitDeviceReady(VL6180xDev_t dev, int MaxLoop) { + int status; + int n; + uint8_t u8; + LOG_FUNCTION_START("%d", (int)MaxLoop); + if (MaxLoop < 1) { + status = INVALID_PARAMS; + } else { + for (n = 0; n < MaxLoop; n++) { + status = VL6180x_RdByte(dev, RESULT_ALS_STATUS, &u8); + if (status) + break; + u8 = u8 & ALS_DEVICE_READY_MASK; + if (u8) + break; + } + if (!status && !u8) { + status = TIME_OUT; + } + } + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_AlsSetSystemMode(VL6180xDev_t dev, uint8_t mode) { + int status; + LOG_FUNCTION_START("%d", (int)mode); + /* FIXME if we are called back to back real fast we are not checking + * if previous mode "set" got absorbed => bit 0 must be 0 so that wr 1 work */ + if (mode <= 3) { + status = VL6180x_WrByte(dev, SYSALS_START, mode); + } else { + status = INVALID_PARAMS; + } + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_AlsConfigInterrupt(VL6180xDev_t dev, uint8_t ConfigGpioInt) { + int status; + + if (ConfigGpioInt <= CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY) { + status = VL6180x_UpdateByte(dev, SYSTEM_INTERRUPT_CONFIG_GPIO, + (uint8_t)(~CONFIG_GPIO_ALS_MASK), + (ConfigGpioInt << 3)); + } else { + VL6180x_ErrLog("Invalid config mode param %d", (int)ConfigGpioInt); + status = INVALID_PARAMS; + } + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_AlsSetThresholds(VL6180xDev_t dev, uint8_t low, uint8_t high) { + int status; + + LOG_FUNCTION_START("%d %d", (int)low, (int)high); + + status = VL6180x_WrByte(dev, SYSALS_THRESH_LOW, low); + if (!status) { + status = VL6180x_WrByte(dev, SYSALS_THRESH_HIGH, high); + } + + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_AlsSetAnalogueGain(VL6180xDev_t dev, uint8_t gain) { + int status; + uint8_t GainTotal; + + LOG_FUNCTION_START("%d", (int)gain); + gain &= ~0x40; + if (gain > 7) { + gain = 7; + } + GainTotal = gain | 0x40; + + status = VL6180x_WrByte(dev, SYSALS_ANALOGUE_GAIN, GainTotal); + if (!status) { + VL6180xDevDataSet(dev, AlsGainCode, gain); + } + + LOG_FUNCTION_END_FMT(status, "%d %d", (int)gain, (int)GainTotal); + return status; +} + +int VL6180x_AlsSetInterMeasurementPeriod(VL6180xDev_t dev, + uint16_t intermeasurement_period_ms) { + int status; + + LOG_FUNCTION_START("%d", (int)intermeasurement_period_ms); + /* clipping: range is 0-2550ms */ + if (intermeasurement_period_ms >= 255 * 10) + intermeasurement_period_ms = 255 * 10; + status = VL6180x_WrByte(dev, SYSALS_INTERMEASUREMENT_PERIOD, + (uint8_t)(intermeasurement_period_ms / 10)); + + LOG_FUNCTION_END_FMT(status, "%d", (int)intermeasurement_period_ms); + return status; +} + +int VL6180x_AlsSetIntegrationPeriod(VL6180xDev_t dev, uint16_t period_ms) { + int status; + uint16_t SetIntegrationPeriod; + + LOG_FUNCTION_START("%d", (int)period_ms); + + if (period_ms >= 1) + SetIntegrationPeriod = period_ms - 1; + else + SetIntegrationPeriod = period_ms; + + if (SetIntegrationPeriod > 464) { + SetIntegrationPeriod = 464; + } else if (SetIntegrationPeriod == 255) { + SetIntegrationPeriod++; /* can't write 255 since this causes the device to + lock out.*/ + } + + status = VL6180x_WrWord(dev, SYSALS_INTEGRATION_PERIOD, SetIntegrationPeriod); + if (!status) { + VL6180xDevDataSet(dev, IntegrationPeriod, SetIntegrationPeriod); + } + LOG_FUNCTION_END_FMT(status, "%d", (int)SetIntegrationPeriod); + return status; +} + +#endif /* HAVE_ALS_SUPPORT */ + +int VL6180x_RangePollMeasurement(VL6180xDev_t dev, + VL6180x_RangeData_t *pRangeData) { + int status; + int ClrStatus; + IntrStatus_t IntStatus; + + LOG_FUNCTION_START(""); + /* start single range measurement */ + +#if VL6180X_SAFE_POLLING_ENTER + /* if device get stopped with left interrupt uncleared , it is required to + * clear them now or poll for new condition will never occur*/ + status = VL6180x_RangeClearInterrupt(dev); + if (status) { + VL6180x_ErrLog("VL6180x_RangeClearInterrupt fail"); + goto done; + } +#endif + /* //![single_shot_snipet] */ + status = VL6180x_RangeSetSystemMode(dev, MODE_START_STOP | MODE_SINGLESHOT); + if (status) { + VL6180x_ErrLog("VL6180x_RangeSetSystemMode fail"); + goto done; + } + + /* poll for new sample ready */ + while (1) { + status = VL6180x_RangeGetInterruptStatus(dev, &IntStatus.val); + if (status) { + break; + } + if (IntStatus.status.Range == RES_INT_STAT_GPIO_NEW_SAMPLE_READY || + IntStatus.status.Error != 0) { + break; + } + + VL6180x_PollDelay(dev); + } + /* //![single_shot_snipet] */ + + if (!status) { + status = VL6180x_RangeGetMeasurement(dev, pRangeData); + } + + /* clear range interrupt source */ + ClrStatus = VL6180x_RangeClearInterrupt(dev); + if (ClrStatus) { + VL6180x_ErrLog("VL6180x_RangeClearInterrupt fail"); + /* leave initial status if already in error */ + if (!status) { + status = ClrStatus; + } + } +done: + LOG_FUNCTION_END(status); + return status; +} + +#if VL6180x_CACHED_REG + +int VL6180x_GetCachedDWord(VL6180xDev_t dev, uint16_t index, uint32_t *pValue) { + int status; + uint32_t Value; + if (VL6180xDevDataGet(dev, CacheFilled) != 0 && + index >= VL6180x_FIRST_CACHED_INDEX && + index <= (VL6180x_LAST_CACHED_INDEX - 3)) { + uint8_t *pBytes = + &VL6180xDevDataGet(dev, CachedRegs[index - VL6180x_FIRST_CACHED_INDEX]); + Value = ((uint32_t)pBytes[0] << 24) | ((uint32_t)pBytes[1] << 16) | + ((uint32_t)pBytes[2] << 8) | (uint32_t)pBytes[3]; + *pValue = Value; + status = 0; + } else { + status = VL6180x_RdDWord(dev, index, pValue); + } + return status; +} + +int VL6180x_GetCachedWord(VL6180xDev_t dev, uint16_t index, uint16_t *pValue) { + int status; + uint32_t Value; + if (VL6180xDevDataGet(dev, CacheFilled) != 0 && + index >= VL6180x_FIRST_CACHED_INDEX && + index <= (VL6180x_LAST_CACHED_INDEX - 1)) { + uint8_t *pBytes = + &VL6180xDevDataGet(dev, CachedRegs[index - VL6180x_FIRST_CACHED_INDEX]); + Value = ((uint32_t)pBytes[0] << 8) | (uint32_t)pBytes[1]; + *pValue = Value; + status = 0; + } else { + status = VL6180x_RdWord(dev, index, pValue); + } + return status; +} + +int VL6180x_GetCachedByte(VL6180xDev_t dev, uint16_t index, uint8_t *pValue) { + int status; + uint8_t Value; + if (VL6180xDevDataGet(dev, CacheFilled) != 0 && + index >= VL6180x_FIRST_CACHED_INDEX && + index <= VL6180x_LAST_CACHED_INDEX) { + Value = + VL6180xDevDataGet(dev, CachedRegs[index - VL6180x_FIRST_CACHED_INDEX]); + *pValue = Value; + status = 0; + } else { + status = VL6180x_RdByte(dev, index, pValue); + } + return status; +} + +int _CachedRegs_Fetch(VL6180xDev_t dev) { + int status; + uint8_t *Buffer; + if (VL6180xDevDataGet(dev, CacheFilled) == 0) { + VL6180xDevDataSet(dev, CacheFilled, 1); + Buffer = &VL6180xDevDataGet(dev, CachedRegs[0]); + status = VL6180x_RdMulti(dev, VL6180x_FIRST_CACHED_INDEX, Buffer, + VL6180x_CACHED_REG_CNT); + } else { + status = 0; + } + return status; +} + +void _CachedRegs_Flush(VL6180xDev_t dev) { + VL6180xDevDataSet(dev, CacheFilled, 0); +} + +#else +#define _CachedRegs_Fetch(...) 0 +#define _CachedRegs_Flush(...) (void)0 +#define _Fetch_CachedRegs(...) 0 +#define VL6180x_GetCachedByte(dev, index, pValue) \ + VL6180x_RdByte(dev, index, pValue) +#define VL6180x_GetCachedWord(dev, index, pValue) \ + VL6180x_RdWord(dev, index, pValue) +#define VL6180x_GetCachedDWord(dev, index, pValue) \ + VL6180x_RdDWord(dev, index, pValue) +#endif /* VL6180x_CACHED_REG */ + +int VL6180x_RangeGetMeasurement(VL6180xDev_t dev, + VL6180x_RangeData_t *pRangeData) { + int status; + uint16_t RawRate; + uint8_t RawStatus; + + LOG_FUNCTION_START(""); + + status = _CachedRegs_Fetch(dev); + if (status) { + VL6180x_ErrLog("Cache register read fail"); + goto error; + } + status = VL6180x_RangeGetResult(dev, &pRangeData->range_mm); + if (!status) { + status = VL6180x_GetCachedWord(dev, RESULT_RANGE_SIGNAL_RATE, &RawRate); + if (!status) { + pRangeData->signalRate_mcps = VL6180x_9to7Conv(RawRate); + status = VL6180x_GetCachedByte(dev, RESULT_RANGE_STATUS, &RawStatus); + if (!status) { + pRangeData->errorStatus = RawStatus >> 4; + } else { + VL6180x_ErrLog("Rd RESULT_RANGE_STATUS fail"); + } +#if VL6180x_WRAP_AROUND_FILTER_SUPPORT || VL6180x_HAVE_DMAX_RANGING + status = _GetRateResult(dev, pRangeData); + if (status) + goto error; +#endif +#if VL6180x_WRAP_AROUND_FILTER_SUPPORT + /* if enabled run filter */ + if (_IsWrapArroundActive(dev)) { + status = _filter_GetResult(dev, pRangeData); + if (!status) { + /* patch the range status and measure if it is filtered */ + if (pRangeData->FilteredData.filterError != NoError) { + pRangeData->errorStatus = pRangeData->FilteredData.filterError; + pRangeData->range_mm = pRangeData->FilteredData.range_mm; + } + } + } +#endif + +#if VL6180x_HAVE_DMAX_RANGING + if (_IsDMaxActive(dev)) { + _DMax_Compute(dev, pRangeData); + } +#endif + } else { + VL6180x_ErrLog("Rd RESULT_RANGE_SIGNAL_RATE fail"); + } + } else { + VL6180x_ErrLog("VL6180x_GetRangeResult fail"); + } +error: + _CachedRegs_Flush(dev); + LOG_FUNCTION_END_FMT(status, "%d %d %d", (int)pRangeData->range_mm, + (int)pRangeData->signalRate_mcps, + (int)pRangeData->errorStatus); + return status; +} + +int VL6180x_RangeGetMeasurementIfReady(VL6180xDev_t dev, + VL6180x_RangeData_t *pRangeData) { + int status; + IntrStatus_t IntStatus; + + LOG_FUNCTION_START(); + status = VL6180x_RangeGetInterruptStatus(dev, &IntStatus.val); + if (status == 0) { + if (IntStatus.status.Range == RES_INT_STAT_GPIO_NEW_SAMPLE_READY || + IntStatus.status.Error != 0) { + status = VL6180x_RangeGetMeasurement(dev, pRangeData); + if (status == 0) { + /* clear range interrupt source */ + status = VL6180x_RangeClearInterrupt(dev); + if (status) { + VL6180x_ErrLog("VL6180x_RangeClearInterrupt fail"); + } + } + } else { + pRangeData->errorStatus = DataNotReady; + } + } else { + VL6180x_ErrLog("fail to get interrupt status"); + } + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_FilterSetState(VL6180xDev_t dev, int state) { + int status; + LOG_FUNCTION_START("%d", state); +#if VL6180x_WRAP_AROUND_FILTER_SUPPORT + VL6180xDevDataSet(dev, WrapAroundFilterActive, state); + status = 0; +#else + status = NOT_SUPPORTED; +#endif + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_FilterGetState(VL6180xDev_t dev) { + int status; + LOG_FUNCTION_START(""); +#if VL6180x_WRAP_AROUND_FILTER_SUPPORT + status = VL6180xDevDataGet(dev, WrapAroundFilterActive); +#else + status = 0; +#endif + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_RangeGetResult(VL6180xDev_t dev, int32_t *pRange_mm) { + int status; + uint8_t RawRange; + int32_t Upscale; + + LOG_FUNCTION_START("%p", pRange_mm); + + status = VL6180x_GetCachedByte(dev, RESULT_RANGE_VAL, &RawRange); + if (!status) { + Upscale = _GetUpscale(dev); + *pRange_mm = Upscale * (int32_t)RawRange; + } + LOG_FUNCTION_END_FMT(status, "%d", (int)*pRange_mm); + return status; +} + +int VL6180x_RangeSetRawThresholds(VL6180xDev_t dev, uint8_t low, uint8_t high) { + int status; + LOG_FUNCTION_START("%d %d", (int)low, (int)high); + /* TODO we can optimize here grouping high/low in a word but that's cpu + * endianness dependent */ + status = VL6180x_WrByte(dev, SYSRANGE_THRESH_HIGH, high); + if (!status) { + status = VL6180x_WrByte(dev, SYSRANGE_THRESH_LOW, low); + } + + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_RangeSetThresholds(VL6180xDev_t dev, uint16_t low, uint16_t high, + int UseSafeParamHold) { + int status; + int scale; + LOG_FUNCTION_START("%d %d", (int)low, (int)high); + scale = _GetUpscale(dev, UpscaleFactor); + if (low > scale * 255 || high > scale * 255) { + status = INVALID_PARAMS; + } else { + do { + if (UseSafeParamHold) { + status = VL6180x_SetGroupParamHold(dev, 1); + if (status) + break; + } + status = VL6180x_RangeSetRawThresholds(dev, (uint8_t)(low / scale), + (uint8_t)(high / scale)); + if (status) { + VL6180x_ErrLog("VL6180x_RangeSetRawThresholds fail"); + } + if (UseSafeParamHold) { + int HoldStatus; + /* tryt to unset param hold vene if previous fail */ + HoldStatus = VL6180x_SetGroupParamHold(dev, 0); + if (!status) + status = HoldStatus; + } + } while (0); + } + + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_RangeGetThresholds(VL6180xDev_t dev, uint16_t *low, + uint16_t *high) { + int status = 0; + uint8_t RawLow, RawHigh; + int scale; + + LOG_FUNCTION_START("%p %p", low, high); + + scale = _GetUpscale(dev, UpscaleFactor); + do { + if (high != NULL) { + status = VL6180x_RdByte(dev, SYSRANGE_THRESH_HIGH, &RawHigh); + if (status) { + VL6180x_ErrLog("rd SYSRANGE_THRESH_HIGH fail"); + break; + } + *high = (uint16_t)RawHigh * scale; + } + if (low != NULL) { + status = VL6180x_RdByte(dev, SYSRANGE_THRESH_LOW, &RawLow); + if (status) { + VL6180x_ErrLog("rd SYSRANGE_THRESH_LOW fail"); + break; + } + *low = (uint16_t)RawLow * scale; + } + } while (0); + LOG_FUNCTION_END_FMT(status, "%d %d", (int)*low, (int)*high); + return status; +} + +int VL6180x_RangeGetInterruptStatus(VL6180xDev_t dev, uint8_t *pIntStatus) { + int status; + uint8_t IntStatus; + LOG_FUNCTION_START("%p", pIntStatus); + /* FIXME we are grouping "error" with over status the user must check + * implicitly for it not just new sample or over status , that will nevr show + * up in case of error*/ + status = VL6180x_GetCachedByte(dev, RESULT_INTERRUPT_STATUS_GPIO, &IntStatus); + *pIntStatus = IntStatus & 0xC7; + + LOG_FUNCTION_END_FMT(status, "%d", (int)*pIntStatus); + return status; +} + +int VL6180x_GetInterruptStatus(VL6180xDev_t dev, uint8_t *IntStatus) { + int status; + LOG_FUNCTION_START("%p", IntStatus); + status = VL6180x_RdByte(dev, RESULT_INTERRUPT_STATUS_GPIO, IntStatus); + LOG_FUNCTION_END_FMT(status, "%d", (int)*IntStatus); + return status; +} + +int VL6180x_ClearInterrupt(VL6180xDev_t dev, uint8_t IntClear) { + int status; + LOG_FUNCTION_START("%d", (int)IntClear); + if (IntClear <= 7) { + status = VL6180x_WrByte(dev, SYSTEM_INTERRUPT_CLEAR, IntClear); + } else { + status = INVALID_PARAMS; + } + LOG_FUNCTION_END(status); + return status; +} + +static int VL6180x_RangeStaticInit(VL6180xDev_t dev) { + int status; + LOG_FUNCTION_START(""); + + /* REGISTER_TUNING_SR03_270514_CustomerView.txt */ + VL6180x_WrByte(dev, 0x0207, 0x01); + VL6180x_WrByte(dev, 0x0208, 0x01); + VL6180x_WrByte(dev, 0x0096, 0x00); + VL6180x_WrByte(dev, 0x0097, 0xfd); + VL6180x_WrByte(dev, 0x00e3, 0x01); + VL6180x_WrByte(dev, 0x00e4, 0x03); + VL6180x_WrByte(dev, 0x00e5, 0x02); + VL6180x_WrByte(dev, 0x00e6, 0x01); + VL6180x_WrByte(dev, 0x00e7, 0x03); + VL6180x_WrByte(dev, 0x00f5, 0x02); + VL6180x_WrByte(dev, 0x00d9, 0x05); + VL6180x_WrByte(dev, 0x00db, 0xce); + VL6180x_WrByte(dev, 0x00dc, 0x03); + VL6180x_WrByte(dev, 0x00dd, 0xf8); + VL6180x_WrByte(dev, 0x009f, 0x00); + VL6180x_WrByte(dev, 0x00a3, 0x3c); + VL6180x_WrByte(dev, 0x00b7, 0x00); + VL6180x_WrByte(dev, 0x00bb, 0x3c); /*Recommended value = 0x28 in case very + fast ranging frequency (~ 100 Hz)*/ + VL6180x_WrByte(dev, 0x00b2, 0x09); + VL6180x_WrByte(dev, 0x00ca, 0x09); + VL6180x_WrByte(dev, 0x0198, 0x01); + VL6180x_WrByte(dev, 0x01b0, 0x17); + VL6180x_WrByte(dev, 0x01ad, 0x00); + VL6180x_WrByte(dev, 0x00ff, 0x05); + VL6180x_WrByte(dev, 0x0100, 0x05); + VL6180x_WrByte(dev, 0x0199, 0x05); + VL6180x_WrByte(dev, 0x01a6, 0x1b); + VL6180x_WrByte(dev, 0x01ac, 0x3e); + VL6180x_WrByte(dev, 0x01a7, 0x1f); + VL6180x_WrByte(dev, 0x0030, 0x00); + + /* Recommended : Public registers - See data sheet for more detail */ + VL6180x_WrByte(dev, 0x0011, 0x10); /* Enables polling for New Sample ready + when measurement completes */ + VL6180x_WrByte(dev, 0x010a, + 0x30); /* Set the averaging sample period (compromise between + lower noise and increased execution time) */ + VL6180x_WrByte(dev, 0x003f, + 0x46); /* Sets the light and dark gain (upper nibble). Dark + gain should not be changed.*/ + VL6180x_WrByte(dev, 0x0031, + 0xFF); /* sets the # of range measurements after which auto + calibration of system is performed */ + VL6180x_WrByte(dev, 0x0040, 0x63); /* Set ALS integration time to 100ms */ + VL6180x_WrByte(dev, 0x002e, 0x01); /* perform a single temperature calibration + of the ranging sensor */ + + /* Optional: Public registers - See data sheet for more detail */ + VL6180x_WrByte( + dev, 0x001b, + 0x09); /* Set default ranging inter-measurement period to 100ms */ + VL6180x_WrByte(dev, 0x003e, + 0x31); /* Set default ALS inter-measurement period to 500ms */ + VL6180x_WrByte(dev, 0x0014, + 0x24); /* Configures interrupt on New sample ready */ + + status = VL6180x_RangeSetMaxConvergenceTime( + dev, 50); /* Calculate ece value on initialization (use max conv) */ + LOG_FUNCTION_END(status); + + return status; +} + +#if VL6180x_UPSCALE_SUPPORT != 1 + +static int _UpscaleInitPatch0(VL6180xDev_t dev) { + int status; + uint32_t CalValue = 0; + CalValue = VL6180xDevDataGet(dev, Part2PartAmbNVM); + status = VL6180x_WrDWord(dev, 0xDA, CalValue); + return status; +} + +/* only include up-scaling register setting when up-scale support is configured + * in */ +int VL6180x_UpscaleRegInit(VL6180xDev_t dev) { + /* apply REGISTER_TUNING_ER02_100614_CustomerView.txt */ + VL6180x_WrByte(dev, 0x0207, 0x01); + VL6180x_WrByte(dev, 0x0208, 0x01); + VL6180x_WrByte(dev, 0x0096, 0x00); + VL6180x_WrByte(dev, 0x0097, 0x54); + VL6180x_WrByte(dev, 0x00e3, 0x01); + VL6180x_WrByte(dev, 0x00e4, 0x03); + VL6180x_WrByte(dev, 0x00e5, 0x02); + VL6180x_WrByte(dev, 0x00e6, 0x01); + VL6180x_WrByte(dev, 0x00e7, 0x03); + VL6180x_WrByte(dev, 0x00f5, 0x02); + VL6180x_WrByte(dev, 0x00d9, 0x05); + + _UpscaleInitPatch0(dev); + + VL6180x_WrByte(dev, 0x009f, 0x00); + VL6180x_WrByte(dev, 0x00a3, 0x28); + VL6180x_WrByte(dev, 0x00b7, 0x00); + VL6180x_WrByte(dev, 0x00bb, 0x28); + VL6180x_WrByte(dev, 0x00b2, 0x09); + VL6180x_WrByte(dev, 0x00ca, 0x09); + VL6180x_WrByte(dev, 0x0198, 0x01); + VL6180x_WrByte(dev, 0x01b0, 0x17); + VL6180x_WrByte(dev, 0x01ad, 0x00); + VL6180x_WrByte(dev, 0x00ff, 0x05); + VL6180x_WrByte(dev, 0x0100, 0x05); + VL6180x_WrByte(dev, 0x0199, 0x05); + VL6180x_WrByte(dev, 0x01a6, 0x1b); + VL6180x_WrByte(dev, 0x01ac, 0x3e); + VL6180x_WrByte(dev, 0x01a7, 0x1f); + VL6180x_WrByte(dev, 0x0030, 0x00); + VL6180x_WrByte(dev, 0x0011, 0x10); + VL6180x_WrByte(dev, 0x010a, 0x30); + VL6180x_WrByte(dev, 0x003f, 0x46); + VL6180x_WrByte(dev, 0x0031, 0xFF); + VL6180x_WrByte(dev, 0x0040, 0x63); + VL6180x_WrByte(dev, 0x002e, 0x01); + VL6180x_WrByte(dev, 0x002c, 0xff); + VL6180x_WrByte(dev, 0x001b, 0x09); + VL6180x_WrByte(dev, 0x003e, 0x31); + VL6180x_WrByte(dev, 0x0014, 0x24); +#if VL6180x_EXTENDED_RANGE + VL6180x_RangeSetMaxConvergenceTime(dev, 63); +#else + VL6180x_RangeSetMaxConvergenceTime(dev, 50); +#endif + return 0; +} +#else +#define VL6180x_UpscaleRegInit(...) -1 +#endif + +int VL6180x_UpscaleSetScaling(VL6180xDev_t dev, uint8_t scaling) { + int status; + uint16_t Scaler; + uint16_t ValidHeight; + int8_t Offset; + + LOG_FUNCTION_START("%d", (int)scaling); + +#ifdef VL6180x_HAVE_UPSCALE_DATA +#define min_scaling 1 +#define max_scaling (sizeof(ScalerLookUP) / sizeof(ScalerLookUP[0])) +#else +/* we are in fixed config so only allow configured factor */ +#define min_scaling VL6180x_UPSCALE_SUPPORT +#define max_scaling VL6180x_UPSCALE_SUPPORT +#endif + + if (scaling >= min_scaling && scaling <= max_scaling) { + + Scaler = ScalerLookUP[scaling - 1]; + status = VL6180x_WrWord(dev, RANGE_SCALER, Scaler); + _SetUpscale(dev, scaling); + + /* Apply scaling on part-2-part offset */ + Offset = VL6180xDevDataGet(dev, Part2PartOffsetNVM) / scaling; + status = VL6180x_WrByte(dev, SYSRANGE_PART_TO_PART_RANGE_OFFSET, Offset); + + /* Apply scaling on CrossTalkValidHeight */ + if (status == 0) { + status = VL6180x_WrByte(dev, SYSRANGE_CROSSTALK_VALID_HEIGHT, + DEF_CROSS_TALK_VALID_HEIGHT_VALUE / scaling); + } + /* Apply scaling on RangeIgnore ValidHeight if enabled */ + if (status == 0) { + if (VL6180xDevDataGet(dev, RangeIgnore.Enabled) != 0) { + ValidHeight = VL6180xDevDataGet(dev, RangeIgnore.ValidHeight); + ValidHeight /= _GetUpscale(dev); + if (ValidHeight > 255) + ValidHeight = 255; + + status = VL6180x_WrByte(dev, SYSRANGE_RANGE_IGNORE_VALID_HEIGHT, + ValidHeight); + } + } + +#if !VL6180x_EXTENDED_RANGE + if (status == 0) { + status = VL6180x_RangeSetEceState( + dev, scaling == 1); /* enable ece only at 1x scaling */ + } + if (status == 0 && !VL6180x_EXTENDED_RANGE && scaling != 1) { + status = NOT_GUARANTEED; + } +#endif + } else { + status = INVALID_PARAMS; + } +#undef min_scaling +#undef max_scaling + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_UpscaleGetScaling(VL6180xDev_t dev) { + int status; + LOG_FUNCTION_START(""); + status = _GetUpscale(dev); + LOG_FUNCTION_END(status); + + return status; +} + +static int VL6180x_UpscaleStaticInit(VL6180xDev_t dev) { + /* todo make these a fail macro in case only 1x is suppoted */ + int status; + + LOG_FUNCTION_START(""); + do { + status = VL6180x_UpscaleRegInit(dev); + if (status) { + VL6180x_ErrLog("regInit fail"); + break; + } +#if VL6180x_EXTENDED_RANGE + status = VL6180x_RangeSetEceState(dev, 0); + if (status) { + VL6180x_ErrLog("VL6180x_RangeSetEceState fail"); + break; + } +#endif + } while (0); + if (!status) { + /* must write the scaler at least once to the device to ensure the scaler + * is in a known state. */ + status = VL6180x_UpscaleSetScaling(dev, _GetUpscale(dev)); + VL6180x_WrByte(dev, 0x016, 0x00); /* change fresh out of set status to 0 */ + } + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_SetGPIOxPolarity(VL6180xDev_t dev, int pin, int active_high) { + int status; + LOG_FUNCTION_START("%d %d", (int)pin, (int)active_high); + + if (pin == 0 || pin == 1) { + uint16_t RegIndex; + uint8_t DataSet; + if (pin == 0) + RegIndex = SYSTEM_MODE_GPIO0; + else + RegIndex = SYSTEM_MODE_GPIO1; + + if (active_high) + DataSet = GPIOx_POLARITY_SELECT_MASK; + else + DataSet = 0; + + status = VL6180x_UpdateByte(dev, RegIndex, + (uint8_t)~GPIOx_POLARITY_SELECT_MASK, DataSet); + } else { + VL6180x_ErrLog("Invalid pin param %d", (int)pin); + status = INVALID_PARAMS; + } + + LOG_FUNCTION_END(status); + + return status; +} + +int VL6180x_SetGPIOxFunctionality(VL6180xDev_t dev, int pin, + uint8_t functionality) { + int status; + + LOG_FUNCTION_START("%d %d", (int)pin, (int)functionality); + + if (((pin == 0) || (pin == 1)) && IsValidGPIOFunction(functionality)) { + uint16_t RegIndex; + + if (pin == 0) + RegIndex = SYSTEM_MODE_GPIO0; + else + RegIndex = SYSTEM_MODE_GPIO1; + + status = VL6180x_UpdateByte( + dev, RegIndex, (uint8_t)~GPIOx_FUNCTIONALITY_SELECT_MASK, + functionality << GPIOx_FUNCTIONALITY_SELECT_SHIFT); + if (status) { + VL6180x_ErrLog("Update SYSTEM_MODE_GPIO%d fail", (int)pin); + } + } else { + VL6180x_ErrLog("Invalid pin %d or function %d", (int)pin, + (int)functionality); + status = INVALID_PARAMS; + } + + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_SetupGPIOx(VL6180xDev_t dev, int pin, uint8_t IntFunction, + int ActiveHigh) { + int status; + + LOG_FUNCTION_START("%d %d", (int)pin, (int)IntFunction); + + if (((pin == 0) || (pin == 1)) && IsValidGPIOFunction(IntFunction)) { + uint16_t RegIndex; + uint8_t value = 0; + + if (pin == 0) + RegIndex = SYSTEM_MODE_GPIO0; + else + RegIndex = SYSTEM_MODE_GPIO1; + + if (ActiveHigh) + value |= GPIOx_POLARITY_SELECT_MASK; + + value |= IntFunction << GPIOx_FUNCTIONALITY_SELECT_SHIFT; + status = VL6180x_WrByte(dev, RegIndex, value); + if (status) { + VL6180x_ErrLog("SYSTEM_MODE_GPIO%d wr fail", + (int)pin - SYSTEM_MODE_GPIO0); + } + } else { + VL6180x_ErrLog("Invalid pin %d or function %d", (int)pin, (int)IntFunction); + status = INVALID_PARAMS; + } + + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_DisableGPIOxOut(VL6180xDev_t dev, int pin) { + int status; + + LOG_FUNCTION_START("%d", (int)pin); + + status = VL6180x_SetGPIOxFunctionality(dev, pin, GPIOx_SELECT_OFF); + + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_SetupGPIO1(VL6180xDev_t dev, uint8_t IntFunction, int ActiveHigh) { + int status; + LOG_FUNCTION_START("%d %d", (int)IntFunction, (int)ActiveHigh); + status = VL6180x_SetupGPIOx(dev, 1, IntFunction, ActiveHigh); + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_RangeConfigInterrupt(VL6180xDev_t dev, uint8_t ConfigGpioInt) { + int status; + + if (ConfigGpioInt <= CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY) { + status = + VL6180x_UpdateByte(dev, SYSTEM_INTERRUPT_CONFIG_GPIO, + (uint8_t)(~CONFIG_GPIO_RANGE_MASK), ConfigGpioInt); + } else { + VL6180x_ErrLog("Invalid config mode param %d", (int)ConfigGpioInt); + status = INVALID_PARAMS; + } + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_RangeSetEceFactor(VL6180xDev_t dev, uint16_t FactorM, + uint16_t FactorD) { + int status; + uint8_t u8; + + LOG_FUNCTION_START("%d %d", (int)FactorM, (int)FactorD); + do { + /* D cannot be 0 M must be <=D and >= 0 */ + if (FactorM <= FactorD && FactorD > 0) { + VL6180xDevDataSet(dev, EceFactorM, FactorM); + VL6180xDevDataSet(dev, EceFactorD, FactorD); + /* read and re-apply max conv time to get new ece factor set */ + status = VL6180x_RdByte(dev, SYSRANGE_MAX_CONVERGENCE_TIME, &u8); + if (status) { + VL6180x_ErrLog("SYSRANGE_MAX_CONVERGENCE_TIME rd fail "); + break; + } + status = VL6180x_RangeSetMaxConvergenceTime(dev, u8); + if (status < 0) { + VL6180x_ErrLog("fail to apply time after ece m/d change"); + break; + } + } else { + VL6180x_ErrLog("invalid factor %d/%d", (int)FactorM, (int)FactorD); + status = INVALID_PARAMS; + } + } while (0); + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_RangeSetEceState(VL6180xDev_t dev, int enable) { + int status; + uint8_t or_mask; + + LOG_FUNCTION_START("%d", (int)enable); + if (enable) + or_mask = RANGE_CHECK_ECE_ENABLE_MASK; + else + or_mask = 0; + + status = VL6180x_UpdateByte(dev, SYSRANGE_RANGE_CHECK_ENABLES, + ~RANGE_CHECK_ECE_ENABLE_MASK, or_mask); + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_RangeSetMaxConvergenceTime(VL6180xDev_t dev, + uint8_t MaxConTime_msec) { + int status = 0; + LOG_FUNCTION_START("%d", (int)MaxConTime_msec); + do { + status = + VL6180x_WrByte(dev, SYSRANGE_MAX_CONVERGENCE_TIME, MaxConTime_msec); + if (status) { + break; + } + status = VL6180x_RangeSetEarlyConvergenceEestimateThreshold(dev); + if (status) { + break; + } + status = _DMax_InitData(dev); + } while (0); + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_RangeSetInterMeasPeriod(VL6180xDev_t dev, + uint32_t InterMeasTime_msec) { + uint8_t SetTime; + int status; + + LOG_FUNCTION_START("%d", (int)InterMeasTime_msec); + do { + if (InterMeasTime_msec > 2550) { + status = INVALID_PARAMS; + break; + } + /* doc in not 100% clear and confusing about the limit practically all value + * are OK but 0 that can hang device in continuous mode */ + if (InterMeasTime_msec < 10) { + InterMeasTime_msec = 10; + } + SetTime = (uint8_t)(InterMeasTime_msec / 10); + status = VL6180x_WrByte(dev, SYSRANGE_INTERMEASUREMENT_PERIOD, SetTime); + if (status) { + VL6180x_ErrLog("SYSRANGE_INTERMEASUREMENT_PERIOD wr fail"); + } else if (SetTime != InterMeasTime_msec / 10) { + status = MIN_CLIPED; /* on success change status to clip if it did */ + } + } while (0); + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_RangeGetDeviceReady(VL6180xDev_t dev, int *Ready) { + int status; + uint8_t u8; + LOG_FUNCTION_START("%p", (int)Ready); + status = VL6180x_RdByte(dev, RESULT_RANGE_STATUS, &u8); + if (!status) + *Ready = u8 & RANGE_DEVICE_READY_MASK; + LOG_FUNCTION_END_FMT(status, "%d", *Ready); + return status; +} + +int VL6180x_RangeWaitDeviceReady(VL6180xDev_t dev, int MaxLoop) { + int status = + 0; /* if user specify an invalid <=0 loop count we'll return error */ + int n; + uint8_t u8; + LOG_FUNCTION_START("%d", (int)MaxLoop); + if (MaxLoop < 1) { + status = INVALID_PARAMS; + } else { + for (n = 0; n < MaxLoop; n++) { + status = VL6180x_RdByte(dev, RESULT_RANGE_STATUS, &u8); + if (status) + break; + u8 = u8 & RANGE_DEVICE_READY_MASK; + if (u8) + break; + } + if (!status && !u8) { + status = TIME_OUT; + } + } + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_RangeSetSystemMode(VL6180xDev_t dev, uint8_t mode) { + int status; + LOG_FUNCTION_START("%d", (int)mode); + /* FIXME we are not checking device is ready via @a + * VL6180x_RangeWaitDeviceReady so if called back to back real fast we are not + * checking if previous mode "set" got absorbed => bit 0 must be 0 so that it + * work + */ + if (mode <= 3) { + status = VL6180x_WrByte(dev, SYSRANGE_START, mode); + if (status) { + VL6180x_ErrLog("SYSRANGE_START wr fail"); + } + } else { + status = INVALID_PARAMS; + } + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_RangeStartContinuousMode(VL6180xDev_t dev) { + int status; + LOG_FUNCTION_START(""); + status = VL6180x_RangeSetSystemMode(dev, MODE_START_STOP | MODE_CONTINUOUS); + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_RangeStartSingleShot(VL6180xDev_t dev) { + int status; + LOG_FUNCTION_START(""); + status = VL6180x_RangeSetSystemMode(dev, MODE_START_STOP | MODE_SINGLESHOT); + LOG_FUNCTION_END(status); + return status; +} + +static int +VL6180x_RangeSetEarlyConvergenceEestimateThreshold(VL6180xDev_t dev) { + int status; + + const uint32_t cMicroSecPerMilliSec = 1000; + const uint32_t cEceSampleTime_us = 500; + uint32_t ece_factor_m = VL6180xDevDataGet(dev, EceFactorM); + uint32_t ece_factor_d = VL6180xDevDataGet(dev, EceFactorD); + uint32_t convergTime_us; + uint32_t fineThresh; + uint32_t eceThresh; + uint8_t u8; + uint32_t maxConv_ms; + int32_t AveTime; + + LOG_FUNCTION_START(""); + + do { + status = VL6180x_RdByte(dev, SYSRANGE_MAX_CONVERGENCE_TIME, &u8); + if (status) { + VL6180x_ErrLog("SYSRANGE_MAX_CONVERGENCE_TIME rd fail"); + break; + } + maxConv_ms = u8; + AveTime = _GetAveTotalTime(dev); + if (AveTime < 0) { + status = -1; + break; + } + + convergTime_us = maxConv_ms * cMicroSecPerMilliSec - AveTime; + status = VL6180x_RdDWord(dev, 0xB8, &fineThresh); + if (status) { + VL6180x_ErrLog("reg 0xB8 rd fail"); + break; + } + fineThresh *= 256; + eceThresh = ece_factor_m * cEceSampleTime_us * fineThresh / + (convergTime_us * ece_factor_d); + + status = VL6180x_WrWord(dev, SYSRANGE_EARLY_CONVERGENCE_ESTIMATE, + (uint16_t)eceThresh); + } while (0); + + LOG_FUNCTION_END(status); + return status; +} + +static int _RangeIgnore_UpdateDevice(VL6180xDev_t dev) { + int status; + int enable; + int threshold; + int range; + int or_mask; + enable = VL6180xDevDataGet(dev, RangeIgnore.Enabled); + if (enable) { + // if to be nabled program first range value and threshold + range = VL6180xDevDataGet(dev, RangeIgnore.ValidHeight); + range /= _GetUpscale(dev); + if (range > 255) + range = 255; + + status = VL6180x_WrByte(dev, SYSRANGE_RANGE_IGNORE_VALID_HEIGHT, range); + if (status) { + goto done; + } + + threshold = VL6180xDevDataGet(dev, RangeIgnore.IgnoreThreshold); + status = VL6180x_WrWord(dev, SYSRANGE_RANGE_IGNORE_THRESHOLD, threshold); + if (status) { + goto done; + } + or_mask = RANGE_CHECK_RANGE_ENABLE_MASK; + } else { + or_mask = 0; + } + status = VL6180x_UpdateByte(dev, SYSRANGE_RANGE_CHECK_ENABLES, + ~RANGE_CHECK_RANGE_ENABLE_MASK, or_mask); + _DMax_InitData(dev); +done: + return status; +} + +int VL6180x_RangeIgnoreSetEnable(VL6180xDev_t dev, int EnableState) { + int CurEnable; + int status; + LOG_FUNCTION_START("enable %d", EnableState); + + if (EnableState) + EnableState = 1; + + CurEnable = VL6180xDevDataGet(dev, RangeIgnore.Enabled); + if (EnableState != CurEnable) { + VL6180xDevDataSet(dev, RangeIgnore.Enabled, EnableState); + status = _RangeIgnore_UpdateDevice(dev); + } + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_RangeIgnoreConfigure(VL6180xDev_t dev, uint16_t ValidHeight_mm, + uint16_t IgnoreThreshold) { + int status; + int enabled; + + LOG_FUNCTION_START("height= %d Threshold=%d", (int)ValidHeight_mm, + (int)Threshold); + + enabled = VL6180xDevDataGet(dev, RangeIgnore.Enabled); + VL6180xDevDataSet(dev, RangeIgnore.ValidHeight, ValidHeight_mm); + VL6180xDevDataSet(dev, RangeIgnore.IgnoreThreshold, IgnoreThreshold); + if (enabled) { + status = _RangeIgnore_UpdateDevice(dev); + } else { + status = 0; + } + LOG_FUNCTION_END(status); + return status; +} + +/* + * Return >0 = time + * <0 1 if fail to get read data from device to compute time + */ +static int32_t _GetAveTotalTime(VL6180xDev_t dev) { + uint32_t cFwOverhead_us = 24; + uint32_t cVcpSetupTime_us = 70; + uint32_t cPLL2_StartupDelay_us = 200; + uint8_t cMeasMask = 0x07; + uint32_t Samples; + uint32_t SamplePeriod; + uint32_t SingleTime_us; + int32_t TotalAveTime_us; + uint8_t u8; + int status; + + LOG_FUNCTION_START(""); + + status = VL6180x_RdByte(dev, 0x109, &u8); + if (status) { + VL6180x_ErrLog("rd 0x109 fail"); + return -1; + } + Samples = u8 & cMeasMask; + status = VL6180x_RdByte(dev, READOUT_AVERAGING_SAMPLE_PERIOD, &u8); + if (status) { + VL6180x_ErrLog("i2c READOUT_AVERAGING_SAMPLE_PERIOD fail"); + return -1; + } + SamplePeriod = u8; + SingleTime_us = cFwOverhead_us + cVcpSetupTime_us + (SamplePeriod * 10); + TotalAveTime_us = (Samples + 1) * SingleTime_us + cPLL2_StartupDelay_us; + + LOG_FUNCTION_END(TotalAveTime_us); + return TotalAveTime_us; +} + +#if VL6180x_HAVE_DMAX_RANGING +#define _GetDMaxDataRetSignalAt400mm(dev) \ + VL6180xDevDataGet(dev, DMaxData.retSignalAt400mm) +#else +#define _GetDMaxDataRetSignalAt400mm(dev) 375 /* Use a default high value */ +#endif + +#if VL6180x_WRAP_AROUND_FILTER_SUPPORT + +#define PRESERVE_DEVICE_ERROR_CODE /* If uncommented, device error code will \ + be preserved on top of wraparound error \ + code, but this may lead to some error \ + code instability like overflow error \ + <==> RangingFilteringOnGoing error \ + oscillations */ +#define SENSITIVE_FILTERING_ON_GOING /* If uncommented, filter will go back to \ + RangingFilteringOnGoing if it must go \ + through the std dev testing */ + +#define FILTER_STDDEV_SAMPLES 6 +#define MIN_FILTER_STDDEV_SAMPLES 3 +#define MIN_FILTER_STDDEV_SAMPLES_AFTER_FLUSH_OR_BYPASS 5 +#define STDDEV_BASE_VALUE 150 + +#define FILTER_INVALID_DISTANCE 65535 + +#define _FilterData(field) VL6180xDevDataGet(dev, FilterData.field) +/* + * One time init + */ +int _filter_Init(VL6180xDev_t dev) { + int i; + _FilterData(MeasurementIndex) = 0; + + _FilterData(Default_ZeroVal) = 0; + _FilterData(Default_VAVGVal) = 0; + _FilterData(NoDelay_ZeroVal) = 0; + _FilterData(NoDelay_VAVGVal) = 0; + _FilterData(Previous_VAVGDiff) = 0; + + _FilterData(StdFilteredReads) = 0; + _FilterData(FilteringOnGoingConsecutiveStates) = 0; + + for (i = 0; i < FILTER_NBOF_SAMPLES; i++) { + _FilterData(LastTrueRange)[i] = FILTER_INVALID_DISTANCE; + _FilterData(LastReturnRates)[i] = 0; + } + _FilterData(MeasurementsSinceLastFlush) = 0; + return 0; +} + +static uint32_t _filter_StdDevDamper(uint32_t AmbientRate, uint32_t SignalRate, + const uint32_t StdDevLimitLowLight, + const uint32_t StdDevLimitLowLightSNR, + const uint32_t StdDevLimitHighLight, + const uint32_t StdDevLimitHighLightSNR) { + uint32_t newStdDev; + uint16_t SNR; + + if (AmbientRate > 0) + SNR = (uint16_t)((100 * SignalRate) / AmbientRate); + else + SNR = 9999; + + if (SNR >= StdDevLimitLowLightSNR) { + newStdDev = StdDevLimitLowLight; + } else { + if (SNR <= StdDevLimitHighLightSNR) + newStdDev = StdDevLimitHighLight; + else { + newStdDev = + (uint32_t)(StdDevLimitHighLight - + (SNR - StdDevLimitHighLightSNR) * + (StdDevLimitHighLight - StdDevLimitLowLight) / + (StdDevLimitLowLightSNR - StdDevLimitHighLightSNR)); + } + } + + return newStdDev; +} + +/* + * Return <0 on error + */ +static int32_t _filter_Start(VL6180xDev_t dev, uint16_t m_trueRange_mm, + uint16_t m_rawRange_mm, uint32_t m_rtnSignalRate, + uint32_t m_rtnAmbientRate, uint16_t errorCode) { + int status; + uint16_t m_newTrueRange_mm = 0; +#if VL6180x_HAVE_MULTI_READ + uint8_t MultiReadBuf[8]; +#endif + uint16_t i; + uint16_t bypassFilter = 0; + uint16_t resetVAVGData = 1; + + uint16_t filterErrorCode = NoError; + uint16_t filterErrorCodeOnRangingErrorCode = NoError; + + uint16_t registerValue; + + uint32_t register32BitsValue1; + uint32_t register32BitsValue2; + + uint16_t ValidDistance = 0; + uint16_t SuspicuousRangingZone = 0; + + uint16_t WrapAroundFlag = 0; + uint16_t NoWrapAroundFlag = 0; + uint16_t NoWrapAroundHighConfidenceFlag = 0; + + uint16_t FlushFilter = 0; + uint32_t RateChange = 0; + + uint16_t StdDevSamplesMinNeeded = 0; + uint16_t StdDevSamples = 0; + uint32_t StdDevDistanceSum = 0; + uint32_t StdDevDistanceMean = 0; + uint32_t StdDevDistance = 0; + uint32_t StdDevRateSum = 0; + uint32_t StdDevRateMean = 0; + uint32_t StdDevRate = 0; + uint32_t StdDevLimitWithTargetMove = 0; + + uint32_t VAVGDiff; + uint32_t IdealVAVGDiff; + uint32_t MinVAVGDiff; + uint32_t MaxVAVGDiff; + + /* Filter Parameters */ + static const uint16_t ROMABLE_DATA WrapAroundLowRawRangeLimit = 60; + static const uint32_t ROMABLE_DATA WrapAroundLowReturnRateLimit_ROM = 800; + /* Shall be adapted depending on crossTalk */ + static const uint16_t ROMABLE_DATA WrapAroundLowRawRangeLimit2 = 165; + static const uint32_t ROMABLE_DATA WrapAroundLowReturnRateLimit2_ROM = 180; + /* Shall be adapted depending on crossTalk and device sensitivity*/ + static const uint32_t ROMABLE_DATA + WrapAroundLowRawRangeLimit2SuspicuousAddedSignalRate = 150; + + static const uint32_t ROMABLE_DATA WrapAroundLowReturnRateFilterLimit_ROM = + 850; + /* Shall be adapted depending on crossTalk and device sensitivity*/ + static const uint16_t ROMABLE_DATA WrapAroundHighRawRangeFilterLimit = 350; + static const uint32_t ROMABLE_DATA WrapAroundHighReturnRateFilterLimit_ROM = + 1400; + /* Shall be adapted depending on crossTalk and device sensitivity*/ + + static const uint32_t ROMABLE_DATA WrapAroundMaximumAmbientRateFilterLimit = + 15000; + + /* Temporal filter data and flush values */ + static const uint32_t ROMABLE_DATA MinReturnRateFilterFlush = 75; + static const uint32_t ROMABLE_DATA MaxReturnRateChangeFilterFlush = 50; + + /* STDDEV values and damper values */ + static const uint32_t ROMABLE_DATA StdDevLimitLowLight = STDDEV_BASE_VALUE; + static const uint32_t ROMABLE_DATA StdDevLimitLowLightSNR = 30; /* 0.3 */ + static const uint32_t ROMABLE_DATA StdDevLimitHighLight = + STDDEV_BASE_VALUE * 6; + static const uint32_t ROMABLE_DATA StdDevLimitHighLightSNR = 5; /* 0.05 */ + + static const uint32_t ROMABLE_DATA StdDevHighConfidenceSNRLimit = 8; + static const uint32_t ROMABLE_DATA StdDevNoWrapDetectedMultiplier = 4; + + static const uint32_t ROMABLE_DATA StdDevMovingTargetStdDevLimit = 90000; + + static const uint32_t ROMABLE_DATA StdDevMovingTargetReturnRateLimit = 3500; + static const uint32_t ROMABLE_DATA + StdDevMovingTargetStdDevForReturnRateLimit = STDDEV_BASE_VALUE * 25; + + static const uint32_t ROMABLE_DATA MAX_VAVGDiff_ROM = 1800; + static const uint32_t ROMABLE_DATA SuspicuousMAX_VAVGDiffRatio = 2; + + /* WrapAroundDetection variables */ + static const uint16_t ROMABLE_DATA WrapAroundNoDelayCheckPeriod = 2; + static const uint16_t ROMABLE_DATA StdFilteredReadsIncrement = 2; + static const uint16_t ROMABLE_DATA StdFilteredReadsDecrement = 1; + static const uint16_t ROMABLE_DATA StdMaxFilteredReads = 4; + + uint32_t SignalRateDMax; + uint32_t WrapAroundLowReturnRateLimit; + uint32_t WrapAroundLowReturnRateLimit2; + uint32_t WrapAroundLowReturnRateFilterLimit; + uint32_t WrapAroundHighReturnRateFilterLimit; + + uint32_t MAX_VAVGDiff = 1800; + + uint8_t u8; //, u8_2; + uint32_t XTalkCompRate_KCps; + uint32_t StdDevLimit = 300; + uint32_t MaxOrInvalidDistance = 255 * _GetUpscale(dev); + /* #define MaxOrInvalidDistance (uint16_t) (255 * 3) */ + + /* Check if distance is Valid or not */ + switch (errorCode) { + case Raw_Ranging_Algo_Underflow: + case Ranging_Algo_Underflow: + filterErrorCodeOnRangingErrorCode = + RangingFiltered; /* If we have to go through filter, mean we have here a + wraparound case */ + ValidDistance = 0; + break; + case Raw_Ranging_Algo_Overflow: + case Ranging_Algo_Overflow: + filterErrorCodeOnRangingErrorCode = + RangingFiltered; /* If we have to go through filter, mean we have here a + wraparound case */ + // m_trueRange_mm = MaxOrInvalidDistance; + m_trueRange_mm = 200 * _GetUpscale(dev); + ValidDistance = 1; + break; + default: + if (m_rawRange_mm >= MaxOrInvalidDistance) { + ValidDistance = 0; + bypassFilter = + 1; /* Bypass the filter in this case as produced distance is not + usable (and also the VAVGVal and ZeroVal values) */ + } else { + ValidDistance = 1; + } + break; + } + m_newTrueRange_mm = m_trueRange_mm; + + XTalkCompRate_KCps = VL6180xDevDataGet(dev, XTalkCompRate_KCps); + + /* Update signal rate limits depending on crosstalk */ + SignalRateDMax = (uint32_t)_GetDMaxDataRetSignalAt400mm(dev); + WrapAroundLowReturnRateLimit = + WrapAroundLowReturnRateLimit_ROM + XTalkCompRate_KCps; + WrapAroundLowReturnRateLimit2 = + ((WrapAroundLowReturnRateLimit2_ROM * SignalRateDMax) / 312) + + XTalkCompRate_KCps; + WrapAroundLowReturnRateFilterLimit = + ((WrapAroundLowReturnRateFilterLimit_ROM * SignalRateDMax) / 312) + + XTalkCompRate_KCps; + WrapAroundHighReturnRateFilterLimit = + ((WrapAroundHighReturnRateFilterLimit_ROM * SignalRateDMax) / 312) + + XTalkCompRate_KCps; + + /* Checks on low range data */ + if ((m_rawRange_mm < WrapAroundLowRawRangeLimit) && + (m_rtnSignalRate < WrapAroundLowReturnRateLimit)) { + filterErrorCode = + RangingFiltered; /* On this condition, wraparound case is ensured */ + bypassFilter = 1; + } + if ((m_rawRange_mm < WrapAroundLowRawRangeLimit2) && + (m_rtnSignalRate < WrapAroundLowReturnRateLimit2)) { + filterErrorCode = + RangingFiltered; /* On this condition, wraparound case is ensured */ + bypassFilter = 1; + } + if ((m_rawRange_mm < WrapAroundLowRawRangeLimit2) && + (m_rtnSignalRate < + (WrapAroundLowReturnRateLimit2 + + WrapAroundLowRawRangeLimit2SuspicuousAddedSignalRate))) { + SuspicuousRangingZone = + 1; /* On this area, we are in an highly suspicuous wraparound ares, + filter parameter will be stengthen */ + } + + /* Checks on Ambient rate level */ + if (m_rtnAmbientRate > WrapAroundMaximumAmbientRateFilterLimit) { + /* Too high ambient rate */ + FlushFilter = 1; + bypassFilter = 1; + } + + /* Checks on Filter flush */ + if (m_rtnSignalRate < MinReturnRateFilterFlush) { + /* Completely lost target, so flush the filter */ + FlushFilter = 1; + bypassFilter = 1; + } + if (_FilterData(LastReturnRates)[0] != 0) { + if (m_rtnSignalRate > _FilterData(LastReturnRates)[0]) + RateChange = (100 * (m_rtnSignalRate - _FilterData(LastReturnRates)[0])) / + _FilterData(LastReturnRates)[0]; + else + RateChange = (100 * (_FilterData(LastReturnRates)[0] - m_rtnSignalRate)) / + _FilterData(LastReturnRates)[0]; + } else + RateChange = 0; + if (RateChange > MaxReturnRateChangeFilterFlush) { + FlushFilter = 1; + } + /* TODO optimize filter using circular buffer */ + if (FlushFilter == 1) { + _FilterData(MeasurementIndex) = 0; + for (i = 0; i < FILTER_NBOF_SAMPLES; i++) { + _FilterData(LastTrueRange)[i] = FILTER_INVALID_DISTANCE; + _FilterData(LastReturnRates)[i] = 0; + } + _FilterData(MeasurementsSinceLastFlush) = 0; + } else { + for (i = (uint16_t)(FILTER_NBOF_SAMPLES - 1); i > 0; i--) { + _FilterData(LastTrueRange)[i] = _FilterData(LastTrueRange)[i - 1]; + _FilterData(LastReturnRates)[i] = _FilterData(LastReturnRates)[i - 1]; + } + } + + if (ValidDistance == 1) + _FilterData(LastTrueRange)[0] = m_trueRange_mm; + else + _FilterData(LastTrueRange)[0] = FILTER_INVALID_DISTANCE; + _FilterData(LastReturnRates)[0] = m_rtnSignalRate; + _FilterData(MeasurementsSinceLastFlush)++; + + /* Check if we need to go through the filter or not */ + if (!(((m_rawRange_mm < WrapAroundHighRawRangeFilterLimit) && + (m_rtnSignalRate < WrapAroundLowReturnRateFilterLimit)) || + ((m_rawRange_mm >= WrapAroundHighRawRangeFilterLimit) && + (m_rtnSignalRate < WrapAroundHighReturnRateFilterLimit)))) + bypassFilter = 1; + else { + /* if some wraparound filtering due to some ranging error code has been + * detected, update the filter status and bypass the filter */ + if (filterErrorCodeOnRangingErrorCode != NoError) { +#ifndef PRESERVE_DEVICE_ERROR_CODE + filterErrorCode = filterErrorCodeOnRangingErrorCode; +#else + if ((errorCode == Raw_Ranging_Algo_Underflow) || + (errorCode == Ranging_Algo_Underflow)) { + /* Preserves the error codes except for Raw_Ranging_Algo_Underflow and + * Ranging_Algo_Underflow */ + filterErrorCode = filterErrorCodeOnRangingErrorCode; + } +#endif + bypassFilter = 1; + resetVAVGData = 0; + } + } + + /* Check which kind of measurement has been made */ + status = VL6180x_RdByte(dev, 0x01AC, &u8); + if (status) { + VL6180x_ErrLog("0x01AC rd fail"); + goto done_err; + } + registerValue = u8; + + /* Read data for filtering */ +#if VL6180x_HAVE_MULTI_READ + status = + VL6180x_RdMulti(dev, 0x10C, MultiReadBuf, 8); /* read only 8 lsb bits */ + if (status) { + VL6180x_ErrLog("0x10C multi rd fail"); + goto done_err; + } + register32BitsValue1 = + ((uint32_t)MultiReadBuf[0] << 24) + ((uint32_t)MultiReadBuf[1] << 16) + + ((uint32_t)MultiReadBuf[2] << 8) + ((uint32_t)MultiReadBuf[3] << 0); + register32BitsValue2 = + ((uint32_t)MultiReadBuf[4] << 24) + ((uint32_t)MultiReadBuf[5] << 16) + + ((uint32_t)MultiReadBuf[6] << 8) + ((uint32_t)MultiReadBuf[7] << 0); +#else + status = VL6180x_RdDWord(dev, 0x10C, + ®ister32BitsValue1); /* read 32 bits, lower 17 + bits are the one useful */ + if (status) { + VL6180x_ErrLog("0x010C rd fail"); + goto done_err; + } + status = VL6180x_RdDWord(dev, 0x0110, + ®ister32BitsValue2); /* read 32 bits, lower 17 + bits are the one useful */ + if (status) { + VL6180x_ErrLog("0x0110 rd fail"); + goto done_err; + } +#endif + + if ((FlushFilter == 1) || ((bypassFilter == 1) && (resetVAVGData == 1))) { + if (registerValue != 0x3E) { + status = VL6180x_WrByte(dev, 0x1AC, 0x3E); + if (status) { + VL6180x_ErrLog("0x01AC bypass wr fail"); + goto done_err; + } + // status = VL6180x_WrByte(dev, 0x0F2, 0x01); + // if (status) { + // VL6180x_ErrLog("0x0F2 bypass wr fail"); + // goto done_err; + // } + } + /* Set both Default and NoDelay To same value */ + _FilterData(Default_ZeroVal) = register32BitsValue1; + _FilterData(Default_VAVGVal) = register32BitsValue2; + _FilterData(NoDelay_ZeroVal) = register32BitsValue1; + _FilterData(NoDelay_VAVGVal) = register32BitsValue2; + + _FilterData(MeasurementIndex) = 0; + } else { + if (registerValue == 0x3E) { + _FilterData(Default_ZeroVal) = register32BitsValue1; + _FilterData(Default_VAVGVal) = register32BitsValue2; + } else { + _FilterData(NoDelay_ZeroVal) = register32BitsValue1; + _FilterData(NoDelay_VAVGVal) = register32BitsValue2; + } + + if (_FilterData(MeasurementIndex) % WrapAroundNoDelayCheckPeriod == 0) { + u8 = 0x3C; + // u8_2 = 0x05; + } else { + u8 = 0x3E; + // u8_2 = 0x01; + } + status = VL6180x_WrByte(dev, 0x01AC, u8); + if (status) { + VL6180x_ErrLog("0x01AC wr fail"); + goto done_err; + } + // status = VL6180x_WrByte(dev, 0x0F2, u8_2); + // if (status) { + // VL6180x_ErrLog("0x0F2 wr fail"); + // goto done_err; + // } + _FilterData(MeasurementIndex)++; + } + + if (bypassFilter == 1) { + /* Do not go through the filter */ + + /* Update filter error code */ + _FilterData(filterError) = filterErrorCode; + + /* Update reported range */ + if (filterErrorCode == RangingFiltered) + m_newTrueRange_mm = MaxOrInvalidDistance; /* Set to invalid distance */ + + return m_newTrueRange_mm; + } + + /* Computes current VAVGDiff */ + if (_FilterData(Default_VAVGVal) > _FilterData(NoDelay_VAVGVal)) + VAVGDiff = _FilterData(Default_VAVGVal) - _FilterData(NoDelay_VAVGVal); + else + VAVGDiff = 0; + _FilterData(Previous_VAVGDiff) = VAVGDiff; + + if (SuspicuousRangingZone == 0) + MAX_VAVGDiff = MAX_VAVGDiff_ROM; + else + /* In suspicuous area, strengthen the filter */ + MAX_VAVGDiff = MAX_VAVGDiff_ROM / SuspicuousMAX_VAVGDiffRatio; + + /* Check the VAVGDiff */ + if (_FilterData(Default_ZeroVal) > _FilterData(NoDelay_ZeroVal)) + IdealVAVGDiff = _FilterData(Default_ZeroVal) - _FilterData(NoDelay_ZeroVal); + else + IdealVAVGDiff = _FilterData(NoDelay_ZeroVal) - _FilterData(Default_ZeroVal); + if (IdealVAVGDiff > MAX_VAVGDiff) + MinVAVGDiff = IdealVAVGDiff - MAX_VAVGDiff; + else + MinVAVGDiff = 0; + MaxVAVGDiff = IdealVAVGDiff + MAX_VAVGDiff; + if (VAVGDiff < MinVAVGDiff || VAVGDiff > MaxVAVGDiff) { + WrapAroundFlag = 1; + filterErrorCode = RangingFiltered; + } else { + /* Go through filtering check */ + + if (_FilterData(MeasurementIndex) <= 1) + /* On measurement after a bypass, uses an increase number of samples */ + StdDevSamplesMinNeeded = MIN_FILTER_STDDEV_SAMPLES_AFTER_FLUSH_OR_BYPASS; + else + StdDevSamplesMinNeeded = MIN_FILTER_STDDEV_SAMPLES; + + /* StdDevLimit Damper on SNR */ + StdDevLimit = _filter_StdDevDamper( + m_rtnAmbientRate, m_rtnSignalRate, StdDevLimitLowLight, + StdDevLimitLowLightSNR, StdDevLimitHighLight, StdDevLimitHighLightSNR); + + /* Standard deviations computations */ + StdDevSamples = 0; + StdDevDistanceSum = 0; + StdDevDistanceMean = 0; + StdDevDistance = 0; + StdDevRateSum = 0; + StdDevRateMean = 0; + StdDevRate = 0; + for (i = 0; + (i < FILTER_NBOF_SAMPLES) && (StdDevSamples < FILTER_STDDEV_SAMPLES); + i++) { + if (_FilterData(LastTrueRange)[i] != FILTER_INVALID_DISTANCE) { + StdDevSamples = (uint16_t)(StdDevSamples + 1); + StdDevDistanceSum = + (uint32_t)(StdDevDistanceSum + _FilterData(LastTrueRange)[i]); + StdDevRateSum = + (uint32_t)(StdDevRateSum + _FilterData(LastReturnRates)[i]); + } + } + if (StdDevSamples > 0) { + StdDevDistanceMean = (uint32_t)(StdDevDistanceSum / StdDevSamples); + StdDevRateMean = (uint32_t)(StdDevRateSum / StdDevSamples); + } + /* TODO optimize shorten Std dev in aisngle loop computation using sum of x2 + * - (sum of x)2 */ + StdDevSamples = 0; + StdDevDistanceSum = 0; + StdDevRateSum = 0; + for (i = 0; + (i < FILTER_NBOF_SAMPLES) && (StdDevSamples < FILTER_STDDEV_SAMPLES); + i++) { + if (_FilterData(LastTrueRange)[i] != FILTER_INVALID_DISTANCE) { + StdDevSamples = (uint16_t)(StdDevSamples + 1); + StdDevDistanceSum = (uint32_t)(StdDevDistanceSum + + (int)(_FilterData(LastTrueRange)[i] - + StdDevDistanceMean) * + (int)(_FilterData(LastTrueRange)[i] - + StdDevDistanceMean)); + StdDevRateSum = + (uint32_t)(StdDevRateSum + + (int)(_FilterData(LastReturnRates)[i] - StdDevRateMean) * + (int)(_FilterData(LastReturnRates)[i] - + StdDevRateMean)); + } + } + if (StdDevSamples >= StdDevSamplesMinNeeded) { + StdDevDistance = (uint16_t)(StdDevDistanceSum / StdDevSamples); + StdDevRate = (uint16_t)(StdDevRateSum / StdDevSamples); + } else { + StdDevDistance = 0; + StdDevRate = 0; + } + + /* Check Return rate standard deviation */ + if (StdDevRate < StdDevMovingTargetStdDevLimit) { + if (StdDevSamples < StdDevSamplesMinNeeded) { + // m_newTrueRange_mm = MaxOrInvalidDistance; + filterErrorCode = RangingFiltered; + } else { + /* Check distance standard deviation */ + if (StdDevRate < StdDevMovingTargetReturnRateLimit) + StdDevLimitWithTargetMove = + StdDevLimit + + (((StdDevMovingTargetStdDevForReturnRateLimit - StdDevLimit) * + StdDevRate) / + StdDevMovingTargetReturnRateLimit); + else + StdDevLimitWithTargetMove = + StdDevMovingTargetStdDevForReturnRateLimit; + + if (_FilterData(filterError) == NoError) { + /* No wrapAround detected yet, so relax constraints on the std dev */ + StdDevLimitWithTargetMove = + StdDevLimitWithTargetMove * StdDevNoWrapDetectedMultiplier; + } + + if (((StdDevDistance * StdDevHighConfidenceSNRLimit) < StdDevLimit) && + (StdDevSamples >= FILTER_STDDEV_SAMPLES)) { + NoWrapAroundHighConfidenceFlag = 1; + } else { + if (StdDevDistance < StdDevLimitWithTargetMove) { + NoWrapAroundFlag = 1; + } else { + WrapAroundFlag = 1; + filterErrorCode = RangingFiltered; + } + } + } + } else { + /* Target moving too fast */ + WrapAroundFlag = 1; + filterErrorCode = RangingFiltered; + } + } + + if (ValidDistance == 0) { + /* In case of invalid distance */ + if (_FilterData(StdFilteredReads) > 0) + _FilterData(StdFilteredReads) = + (uint16_t)(_FilterData(StdFilteredReads) - 1); + } else { + if (WrapAroundFlag == 1) { + _FilterData(StdFilteredReads) = + (uint16_t)(_FilterData(StdFilteredReads) + StdFilteredReadsIncrement); + if (_FilterData(StdFilteredReads) > StdMaxFilteredReads) + _FilterData(StdFilteredReads) = StdMaxFilteredReads; + } else { + if (NoWrapAroundFlag == 1) { + if (_FilterData(StdFilteredReads) > 0) { + filterErrorCode = RangingFiltered; + if (_FilterData(StdFilteredReads) > StdFilteredReadsDecrement) + _FilterData(StdFilteredReads) = + (uint16_t)(_FilterData(StdFilteredReads) - + StdFilteredReadsDecrement); + else + _FilterData(StdFilteredReads) = 0; + } + } else { + if (NoWrapAroundHighConfidenceFlag == 1) { + _FilterData(StdFilteredReads) = 0; + } + } + } + } + + /* If we detect a change from no Error to RangingFilteringOnGoing, then it + * means that the filter detected a change in te scene, so discard all + * previous measurements. + */ + if ((_FilterData(filterError) == NoError) && (filterErrorCode != NoError)) { + for (i = 1; i < FILTER_NBOF_SAMPLES; i++) { + _FilterData(LastTrueRange)[i] = FILTER_INVALID_DISTANCE; + _FilterData(LastReturnRates)[i] = 0; + } + } + + /* Update filter error code */ + _FilterData(filterError) = filterErrorCode; + + /* Update reported range */ + if (filterErrorCode == RangingFiltered) + m_newTrueRange_mm = MaxOrInvalidDistance; /* Set to invalid distance */ + + return m_newTrueRange_mm; +done_err: + return -1; + +#undef MaxOrInvalidDistance +} + +static int _filter_GetResult(VL6180xDev_t dev, + VL6180x_RangeData_t *pRangeData) { + uint32_t m_rawRange_mm = 0; + int32_t FilteredRange; + const uint8_t scaler = _GetUpscale(dev); + uint8_t u8; + int status; + + do { + status = VL6180x_GetCachedByte(dev, RESULT_RANGE_RAW, &u8); + if (status) { + VL6180x_ErrLog("RESULT_RANGE_RAW rd fail"); + break; + } + m_rawRange_mm = u8; + + FilteredRange = _filter_Start( + dev, pRangeData->range_mm, (m_rawRange_mm * scaler), + pRangeData->rtnRate, pRangeData->rtnAmbRate, pRangeData->errorStatus); + if (FilteredRange < 0) { + status = -1; + break; + } + pRangeData->FilteredData.range_mm = FilteredRange; + pRangeData->FilteredData.rawRange_mm = m_rawRange_mm * scaler; + pRangeData->FilteredData.filterError = _FilterData(filterError); + } while (0); + return status; +} + +#undef _FilterData +#ifdef PRESERVE_DEVICE_ERROR_CODE +#undef PRESERVE_DEVICE_ERROR_CODE +#endif +#ifdef SENSITIVE_FILTERING_ON_GOING +#undef SENSITIVE_FILTERING_ON_GOING +#endif +#undef FILTER_STDDEV_SAMPLES +#undef MIN_FILTER_STDDEV_SAMPLES +#undef MIN_FILTER_STDDEV_SAMPLES_AFTER_FLUSH_OR_BYPASS +#undef STDDEV_BASE_VALUE +#undef FILTER_INVALID_DISTANCE + +#endif /* VL6180x_WRAP_AROUND_FILTER_SUPPORT */ + +#ifdef VL6180x_HAVE_RATE_DATA + +static int _GetRateResult(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData) { + uint32_t m_rtnConvTime = 0; + uint32_t m_rtnSignalRate = 0; + uint32_t m_rtnAmbientRate = 0; + uint32_t m_rtnSignalCount = 0; + uint32_t m_rtnAmbientCount = 0; + uint32_t m_refConvTime = 0; + uint32_t cRtnSignalCountMax = 0x7FFFFFFF; + uint32_t cDllPeriods = 6; + uint32_t calcConvTime = 0; + + int status; + + do { + status = VL6180x_GetCachedDWord(dev, RESULT_RANGE_RETURN_SIGNAL_COUNT, + &m_rtnSignalCount); + if (status) { + VL6180x_ErrLog("RESULT_RANGE_RETURN_SIGNAL_COUNT rd fail"); + break; + } + if (m_rtnSignalCount > cRtnSignalCountMax) { + m_rtnSignalCount = 0; + } + + status = VL6180x_GetCachedDWord(dev, RESULT_RANGE_RETURN_AMB_COUNT, + &m_rtnAmbientCount); + if (status) { + VL6180x_ErrLog("RESULT_RANGE_RETURN_AMB_COUNTrd fail"); + break; + } + + status = VL6180x_GetCachedDWord(dev, RESULT_RANGE_RETURN_CONV_TIME, + &m_rtnConvTime); + if (status) { + VL6180x_ErrLog("RESULT_RANGE_RETURN_CONV_TIME rd fail"); + break; + } + + status = VL6180x_GetCachedDWord(dev, RESULT_RANGE_REFERENCE_CONV_TIME, + &m_refConvTime); + if (status) { + VL6180x_ErrLog("RESULT_RANGE_REFERENCE_CONV_TIME rd fail"); + break; + } + + pRangeData->rtnConvTime = m_rtnConvTime; + pRangeData->refConvTime = m_refConvTime; + + calcConvTime = m_refConvTime; + if (m_rtnConvTime > m_refConvTime) { + calcConvTime = m_rtnConvTime; + } + if (calcConvTime == 0) + calcConvTime = 63000; + + m_rtnSignalRate = (m_rtnSignalCount * 1000) / calcConvTime; + m_rtnAmbientRate = (m_rtnAmbientCount * cDllPeriods * 1000) / calcConvTime; + + pRangeData->rtnRate = m_rtnSignalRate; + pRangeData->rtnAmbRate = m_rtnAmbientRate; + + } while (0); + return status; +} +#endif /* VL6180x_HAVE_RATE_DATA */ + +int VL6180x_DMaxSetState(VL6180xDev_t dev, int state) { + int status; + LOG_FUNCTION_START("%d", state); +#if VL6180x_HAVE_DMAX_RANGING + VL6180xDevDataSet(dev, DMaxEnable, state); + if (state) { + status = _DMax_InitData(dev); + } else { + status = 0; + } +#else + status = NOT_SUPPORTED; +#endif + LOG_FUNCTION_END(status); + return status; +} + +int VL6180x_DMaxGetState(VL6180xDev_t dev) { + int status; + LOG_FUNCTION_START(""); +#if VL6180x_HAVE_DMAX_RANGING + status = VL6180xDevDataGet(dev, DMaxEnable); +#else + status = 0; +#endif + LOG_FUNCTION_END(status); + return status; +} + +#if VL6180x_HAVE_DMAX_RANGING + +#define _DMaxData(field) VL6180xDevDataGet(dev, DMaxData.field) +/* + * Convert fix point x.7 to KCpount per sec + */ + +#ifndef VL6180x_PLATFORM_PROVIDE_SQRT + +/* + * 32 bit integer square root with not so bad precision (integer result) and is + * quite fast see http://en.wikipedia.org/wiki/Methods_of_computing_square_roots + */ +uint32_t VL6180x_SqrtUint32(uint32_t num) { + uint32_t res = 0; + uint32_t bit = + 1 << 30; /* The second-to-top bit is set: 1 << 30 for 32 bits */ + + /* "bit" starts at the highest power of four <= the argument. */ + while (bit > num) + bit >>= 2; + + while (bit != 0) { + if (num >= res + bit) { + num -= res + bit; + res = (res >> 1) + bit; + } else + res >>= 1; + bit >>= 2; + } + return res; +} +#endif + +/* DMax one time init */ +void _DMax_OneTimeInit(VL6180xDev_t dev) { + _DMaxData(ambTuningWindowFactor_K) = DEF_AMBIENT_TUNING; +} + +static uint32_t _DMax_RawValueAtRateKCps(VL6180xDev_t dev, int32_t rate) { + uint32_t snrLimit_K; + int32_t DMaxSq; + uint32_t RawDMax; + DMaxFix_t retSignalAt400mm; + uint32_t ambTuningWindowFactor_K; + + ambTuningWindowFactor_K = _DMaxData(ambTuningWindowFactor_K); + snrLimit_K = _DMaxData(snrLimit_K); + retSignalAt400mm = _DMaxData(retSignalAt400mm); + /* 12 to 18 bits Kcps */ + if (rate > 0) { + DMaxSq = 400 * 400 * 1000 / rate - (400 * 400 / 330); + /* K of (1/RtnAmb -1/330 )=> 30bit- (12-18)bit => 12-18 bits*/ + if (DMaxSq <= 0) { + RawDMax = 0; + } else { + /* value can be more 32 bit so base on raneg apply + * retSignalAt400mm before or after division to presevr accuracy */ + if (DMaxSq < (2 << 12)) { + DMaxSq = + DMaxSq * retSignalAt400mm / (snrLimit_K + ambTuningWindowFactor_K); + /* max 12 + 12 to 18 -10 => 12-26 bit */ + } else { + DMaxSq = + DMaxSq / (snrLimit_K + ambTuningWindowFactor_K) * retSignalAt400mm; + /* 12 to 18 -10 + 12 to 18 *=> 12-26 bit */ + } + RawDMax = VL6180x_SqrtUint32(DMaxSq); + } + } else { + RawDMax = 0x7FFFFFFF; /* bigest possibmle 32bit signed value */ + } + return RawDMax; +} + +/* + * fetch static data from register to avoid re-read + * precompute all intermediate constant and cliipings + * + * to be re-used/call on changes of : + * 0x2A + * SYSRANGE_MAX_AMBIENT_LEVEL_MULT + * Dev Data XtalkComRate_KCPs + * SYSRANGE_MAX_CONVERGENCE_TIME + * SYSRANGE_RANGE_CHECK_ENABLES mask RANGE_CHECK_RANGE_ENABLE_MASK + * range 0xb8-0xbb (0xbb) + */ +static int _DMax_InitData(VL6180xDev_t dev) { + int status, warning; + uint8_t u8; + uint16_t u16; + uint32_t u32; + uint32_t Reg2A_KCps; + uint32_t RegB8; + uint8_t MaxConvTime; + uint32_t XTalkCompRate_KCps; + uint32_t RangeIgnoreThreshold; + int32_t minSignalNeeded; + uint8_t SysRangeCheckEn; + uint8_t snrLimit; + static const int ROMABLE_DATA MaxConvTimeAdjust = -4; + + warning = 0; + + LOG_FUNCTION_START(""); + do { + status = VL6180x_RdByte(dev, 0x02A, &u8); + if (status) { + VL6180x_ErrLog("Reg 0x02A rd fail"); + break; + } + + if (u8 == 0) { + warning = CALIBRATION_WARNING; + u8 = 40; /* use a default average value */ + } + Reg2A_KCps = Fix7_2_KCPs(u8); /* convert to KCPs */ + + status = + VL6180x_RdByte(dev, SYSRANGE_RANGE_CHECK_ENABLES, &SysRangeCheckEn); + if (status) { + VL6180x_ErrLog("SYSRANGE_RANGE_CHECK_ENABLES rd fail "); + break; + } + + status = VL6180x_RdByte(dev, SYSRANGE_MAX_CONVERGENCE_TIME, &MaxConvTime); + if (status) { + VL6180x_ErrLog("SYSRANGE_MAX_CONVERGENCE_TIME rd fail "); + break; + } + + status = VL6180x_RdDWord(dev, 0x0B8, &RegB8); + if (status) { + VL6180x_ErrLog("reg 0x0B8 rd fail "); + break; + } + + status = VL6180x_RdByte(dev, SYSRANGE_MAX_AMBIENT_LEVEL_MULT, &snrLimit); + if (status) { + VL6180x_ErrLog("SYSRANGE_MAX_AMBIENT_LEVEL_MULT rd fail "); + break; + } + _DMaxData(snrLimit_K) = (int32_t)16 * 1000 / snrLimit; + XTalkCompRate_KCps = VL6180xDevDataGet(dev, XTalkCompRate_KCps); + + if (Reg2A_KCps >= XTalkCompRate_KCps) { + _DMaxData(retSignalAt400mm) = Reg2A_KCps; + } else { + _DMaxData(retSignalAt400mm) = 0; + /* Reg2A_K - XTalkCompRate_KCp <0 is invalid */ + } + + /* if xtalk range check is off omit it in snr clipping */ + if (SysRangeCheckEn & RANGE_CHECK_RANGE_ENABLE_MASK) { + status = VL6180x_RdWord(dev, SYSRANGE_RANGE_IGNORE_THRESHOLD, &u16); + if (status) { + VL6180x_ErrLog("SYSRANGE_RANGE_IGNORE_THRESHOLD rd fail "); + break; + } + RangeIgnoreThreshold = Fix7_2_KCPs(u16); + } else { + RangeIgnoreThreshold = 0; + } + + minSignalNeeded = + (RegB8 * 256) / ((int32_t)MaxConvTime + (int32_t)MaxConvTimeAdjust); + /* KCps 8+8 bit -(1 to 6 bit) => 15-10 bit */ + /* minSignalNeeded = max ( minSignalNeeded, RangeIgnoreThreshold - + * XTalkCompRate_KCps) */ + if (minSignalNeeded <= + (int32_t)RangeIgnoreThreshold - (int32_t)XTalkCompRate_KCps) + minSignalNeeded = RangeIgnoreThreshold - XTalkCompRate_KCps; + + u32 = (minSignalNeeded * (uint32_t)snrLimit) / 16; + _DMaxData(ClipSnrLimit) = _DMax_RawValueAtRateKCps(dev, u32); + /* clip to dmax to min signal snr limit rate*/ + } while (0); + if (!status) + status = warning; + LOG_FUNCTION_END(status); + return status; +} + +static int _DMax_Compute(VL6180xDev_t dev, VL6180x_RangeData_t *pRange) { + uint32_t rtnAmbRate; + int32_t DMax; + int scaling; + uint16_t HwLimitAtScale; + static const int ROMABLE_DATA rtnAmbLowLimit_KCps = 330 * 1000; + + rtnAmbRate = pRange->rtnAmbRate; + if (rtnAmbRate < rtnAmbLowLimit_KCps) { + DMax = _DMax_RawValueAtRateKCps(dev, rtnAmbRate); + scaling = _GetUpscale(dev); + HwLimitAtScale = UpperLimitLookUP[scaling - 1]; + + if (DMax > _DMaxData(ClipSnrLimit)) { + DMax = _DMaxData(ClipSnrLimit); + } + if (DMax > HwLimitAtScale) { + DMax = HwLimitAtScale; + } + pRange->DMax = DMax; + } else { + pRange->DMax = 0; + } + return 0; +} + +#undef _DMaxData +#undef Fix7_2_KCPs + +#endif /* VL6180x_HAVE_DMAX_RANGING */ diff --git a/Core/Lib/Src/vl6180x_i2c.c b/Core/Lib/Src/vl6180x_i2c.c new file mode 100644 index 0000000..a613948 --- /dev/null +++ b/Core/Lib/Src/vl6180x_i2c.c @@ -0,0 +1,242 @@ + +/******************************************************************************* +Copyright � 2014, STMicroelectronics International N.V. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * 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. + * Neither the name of STMicroelectronics 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, FITNESS FOR A PARTICULAR PURPOSE, AND +NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED. +IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. 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. +********************************************************************************/ +/* + * $Date: 2015-07-06 15:44:31 +0200 (Mon, 06 Jul 2015) $ + * $Revision: 2430 $ + */ + +/** + * @file vl6180x_i2c.c + * + * Copyright (C) 2014 ST MicroElectronics + * + * provide variable word size byte/Word/dword VL6180x register access via i2c + * + */ +#include "vl6180x_i2c.h" + +#ifndef I2C_BUFFER_CONFIG +#error "I2C_BUFFER_CONFIG not defined" +/* TODO you must define value for I2C_BUFFER_CONFIG in configuration or + * platform h */ +#endif + +#if I2C_BUFFER_CONFIG == 0 +/* GLOBAL config buffer */ +uint8_t i2c_global_buffer[VL6180x_MAX_I2C_XFER_SIZE]; + +#define DECL_I2C_BUFFER +#define VL6180x_GetI2cBuffer(dev, n_byte) i2c_global_buffer + +#elif I2C_BUFFER_CONFIG == 1 +/* ON STACK */ +#define DECL_I2C_BUFFER uint8_t LocBuffer[VL6180x_MAX_I2C_XFER_SIZE]; +#define VL6180x_GetI2cBuffer(dev, n_byte) LocBuffer +#elif I2C_BUFFER_CONFIG == 2 +/* user define buffer type declare DECL_I2C_BUFFER as access via + * VL6180x_GetI2cBuffer */ +#define DECL_I2C_BUFFER +#else +#error "invalid I2C_BUFFER_CONFIG " +#endif + +int VL6180x_WrByte(VL6180xDev_t dev, uint16_t index, uint8_t data) { + int status; + uint8_t *buffer; + DECL_I2C_BUFFER + VL6180x_I2C_USER_VAR + + VL6180x_GetI2CAccess(dev); + + buffer = VL6180x_GetI2cBuffer(dev, 3); + buffer[0] = index >> 8; + buffer[1] = index & 0xFF; + buffer[2] = data; + + status = VL6180x_I2CWrite(dev, buffer, (uint8_t)3); + VL6180x_DoneI2CAcces(dev); + return status; +} + +int VL6180x_WrWord(VL6180xDev_t dev, uint16_t index, uint16_t data) { + int status; + DECL_I2C_BUFFER + uint8_t *buffer; + VL6180x_I2C_USER_VAR + + VL6180x_GetI2CAccess(dev); + + buffer = VL6180x_GetI2cBuffer(dev, 4); + buffer[0] = index >> 8; + buffer[1] = index & 0xFF; + buffer[2] = data >> 8; + buffer[3] = data & 0xFF; + + status = VL6180x_I2CWrite(dev, buffer, (uint8_t)4); + VL6180x_DoneI2CAcces(dev); + return status; +} + +int VL6180x_WrDWord(VL6180xDev_t dev, uint16_t index, uint32_t data) { + VL6180x_I2C_USER_VAR DECL_I2C_BUFFER int status; + uint8_t *buffer; + + VL6180x_GetI2CAccess(dev); + buffer = VL6180x_GetI2cBuffer(dev, 6); + buffer[0] = index >> 8; + buffer[1] = index & 0xFF; + buffer[2] = data >> 24; + buffer[3] = (data >> 16) & 0xFF; + buffer[4] = (data >> 8) & 0xFF; + ; + buffer[5] = data & 0xFF; + status = VL6180x_I2CWrite(dev, buffer, (uint8_t)6); + VL6180x_DoneI2CAcces(dev); + + return status; +} + +int VL6180x_UpdateByte(VL6180xDev_t dev, uint16_t index, uint8_t AndData, + uint8_t OrData) { + VL6180x_I2C_USER_VAR int status; + uint8_t *buffer; + DECL_I2C_BUFFER + + VL6180x_GetI2CAccess(dev); + + buffer = VL6180x_GetI2cBuffer(dev, 3); + buffer[0] = index >> 8; + buffer[1] = index & 0xFF; + + status = VL6180x_I2CWrite(dev, (uint8_t *)buffer, (uint8_t)2); + if (!status) { + /* read data direct onto buffer */ + status = VL6180x_I2CRead(dev, &buffer[2], 1); + if (!status) { + buffer[2] = (buffer[2] & AndData) | OrData; + status = VL6180x_I2CWrite(dev, buffer, (uint8_t)3); + } + } + + VL6180x_DoneI2CAcces(dev); + + return status; +} + +int VL6180x_RdByte(VL6180xDev_t dev, uint16_t index, uint8_t *data) { + VL6180x_I2C_USER_VAR int status; + uint8_t *buffer; + DECL_I2C_BUFFER + + VL6180x_GetI2CAccess(dev); + + buffer = VL6180x_GetI2cBuffer(dev, 2); + buffer[0] = index >> 8; + buffer[1] = index & 0xFF; + + status = VL6180x_I2CWrite(dev, buffer, (uint8_t)2); + if (!status) { + status = VL6180x_I2CRead(dev, buffer, 1); + if (!status) { + *data = buffer[0]; + } + } + VL6180x_DoneI2CAcces(dev); + + return status; +} + +int VL6180x_RdWord(VL6180xDev_t dev, uint16_t index, uint16_t *data) { + VL6180x_I2C_USER_VAR int status; + uint8_t *buffer; + DECL_I2C_BUFFER + + VL6180x_GetI2CAccess(dev); + + buffer = VL6180x_GetI2cBuffer(dev, 2); + buffer[0] = index >> 8; + buffer[1] = index & 0xFF; + + status = VL6180x_I2CWrite(dev, buffer, (uint8_t)2); + if (!status) { + status = VL6180x_I2CRead(dev, buffer, 2); + if (!status) { + /* VL6180x register are Big endian if cpu is be direct read direct into + * *data is possible */ + *data = ((uint16_t)buffer[0] << 8) | (uint16_t)buffer[1]; + } + } + VL6180x_DoneI2CAcces(dev); + return status; +} + +int VL6180x_RdDWord(VL6180xDev_t dev, uint16_t index, uint32_t *data) { + VL6180x_I2C_USER_VAR int status; + uint8_t *buffer; + DECL_I2C_BUFFER + + VL6180x_GetI2CAccess(dev); + buffer = VL6180x_GetI2cBuffer(dev, 4); + + buffer[0] = index >> 8; + buffer[1] = index & 0xFF; + + status = VL6180x_I2CWrite(dev, (uint8_t *)buffer, (uint8_t)2); + if (!status) { + status = VL6180x_I2CRead(dev, buffer, 4); + if (!status) { + /* VL6180x register are Big endian if cpu is be direct read direct into + * data is possible */ + *data = ((uint32_t)buffer[0] << 24) | ((uint32_t)buffer[1] << 16) | + ((uint32_t)buffer[2] << 8) | ((uint32_t)buffer[3]); + } + } + VL6180x_DoneI2CAcces(dev); + return status; +} + +int VL6180x_RdMulti(VL6180xDev_t dev, uint16_t index, uint8_t *data, + int nData) { + VL6180x_I2C_USER_VAR int status; + uint8_t *buffer; + DECL_I2C_BUFFER + + VL6180x_GetI2CAccess(dev); + buffer = VL6180x_GetI2cBuffer(dev, 2); + + buffer[0] = index >> 8; + buffer[1] = index & 0xFF; + + status = VL6180x_I2CWrite(dev, (uint8_t *)buffer, (uint8_t)2); + if (!status) { + status = VL6180x_I2CRead(dev, data, nData); + } + VL6180x_DoneI2CAcces(dev); + return status; +} diff --git a/Core/Src/main.c b/Core/Src/main.c index e2e4115..36380d4 100644 --- a/Core/Src/main.c +++ b/Core/Src/main.c @@ -18,11 +18,12 @@ /* USER CODE END Header */ /* Includes ------------------------------------------------------------------*/ #include "main.h" -#include "stm32l4xx_hal.h" -#include "stm32l4xx_hal_i2c.h" /* Private includes ----------------------------------------------------------*/ /* USER CODE BEGIN Includes */ +#include "stm32l4xx_hal.h" +#include "vl6180x_api.h" +#include "vl6180x_glue.h" /* USER CODE END Includes */ @@ -70,6 +71,7 @@ static void MX_USART2_UART_Init(void); /* USER CODE BEGIN 0 */ volatile uint16_t range = 0; +#if false void tof_write_reg(uint16_t reg_addr, uint32_t data, int len_bytes) { uint8_t buf[len_bytes + 2]; buf[0] = reg_addr >> 8; @@ -170,12 +172,18 @@ void tof_init(void) { // Ready threshold event’ tof_write_reg(VL6180X_REG_SYSTEM_FRESH_OUT_OF_RESET, 0, 1); + HAL_Delay(10); + if (tof_read_reg(VL6180X_REG_SYSTEM_FRESH_OUT_OF_RESET, 1) & 1) { + Error_Handler(); + } } // tof_write_reg(VL6180X_REG_SYSTEM_INTERRUPT_CONFIG_GPIO, 4, 1); } uint8_t tof_range_poll(void) { - if (tof_read_reg(VL6180X_REG_RESULT_RANGE_STATUS, 1) & 1) { + uint8_t status = tof_read_reg(VL6180X_REG_RESULT_RANGE_STATUS, 1); + uint8_t fresh = tof_read_reg(VL6180X_REG_SYSTEM_FRESH_OUT_OF_RESET, 1); + if (!(status & 1) || (fresh & 1)) { // Not ready Error_Handler(); } @@ -205,6 +213,7 @@ uint8_t tof_range_poll(void) { return range; } +#endif /* USER CODE END 0 */ /** @@ -237,19 +246,28 @@ int main(void) { MX_GPIO_Init(); MX_I2C1_Init(); MX_USART2_UART_Init(); - HAL_Delay(100); - tof_init(); - HAL_Delay(100); /* USER CODE BEGIN 2 */ + HAL_Delay(10); + vl6180x_glue_init(&hi2c1); + VL6180xDev_t my_dev; + VL6180x_RangeData_t my_range; + VL6180x_InitData(my_dev); + VL6180x_Prepare(my_dev); /* USER CODE END 2 */ /* Infinite loop */ /* USER CODE BEGIN WHILE */ while (1) { /* USER CODE END WHILE */ + /* USER CODE BEGIN 3 */ - range = tof_range_poll(); + VL6180x_RangePollMeasurement(my_dev, &my_range); + if (my_range.errorStatus == 0) { + range = my_range.range_mm; + } else { + HAL_Delay(100); + } } /* USER CODE END 3 */ } diff --git a/Core/Src/vl6180x_glue.c b/Core/Src/vl6180x_glue.c new file mode 100644 index 0000000..e34c745 --- /dev/null +++ b/Core/Src/vl6180x_glue.c @@ -0,0 +1,25 @@ +#include "main.h" +#include "stm32l4xx_hal_i2c.h" +#include "vl6180x_i2c.h" + +#define VL6180X_ADDR (0x29 << 1) + +I2C_HandleTypeDef *handle; + +void vl6180x_glue_init(I2C_HandleTypeDef *handle_i2c) { handle = handle_i2c; } + +int VL6180x_I2CWrite(VL6180xDev_t dev, uint8_t *buff, uint8_t len) { + if (HAL_I2C_Master_Transmit(handle, VL6180X_ADDR, buff, len, 100) != HAL_OK) { + Error_Handler(); + } + + return 0; +} + +int VL6180x_I2CRead(VL6180xDev_t dev, uint8_t *buff, uint8_t len) { + if (HAL_I2C_Master_Receive(handle, VL6180X_ADDR | 1, buff, len, 100) != 0) { + Error_Handler(); + } + + return 0; +} \ No newline at end of file diff --git a/Makefile b/Makefile index d9096c8..6e4519d 100644 --- a/Makefile +++ b/Makefile @@ -1,5 +1,5 @@ ########################################################################################################################## -# File automatically-generated by tool: [projectgenerator] version: [3.17.1] date: [Sat Nov 12 12:53:14 CET 2022] +# File automatically-generated by tool: [projectgenerator] version: [3.17.1] date: [Sat Nov 12 16:28:05 CET 2022] ########################################################################################################################## # ------------------------------------------------ @@ -58,7 +58,7 @@ Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_tim.c \ Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_tim_ex.c \ Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_uart.c \ Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_uart_ex.c \ -Core/Src/system_stm32l4xx.c +Core/Src/system_stm32l4xx.c # ASM sources ASM_SOURCES = \ @@ -191,4 +191,4 @@ clean: ####################################### -include $(wildcard $(BUILD_DIR)/*.d) -# *** EOF *** \ No newline at end of file +# *** EOF *** diff --git a/STM32Make.make b/STM32Make.make index 14ce15a..ef75604 100644 --- a/STM32Make.make +++ b/STM32Make.make @@ -36,10 +36,13 @@ BUILD_DIR = build ###################################### # C sources C_SOURCES = \ +Core/Lib/Src/vl6180x_api.c \ +Core/Lib/Src/vl6180x_i2c.c \ Core/Src/main.c \ Core/Src/stm32l4xx_hal_msp.c \ Core/Src/stm32l4xx_it.c \ Core/Src/system_stm32l4xx.c \ +Core/Src/vl6180x_glue.c \ Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal.c \ Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_cortex.c \ Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_dma.c \ @@ -131,6 +134,7 @@ AS_INCLUDES = \ # C includes C_INCLUDES = \ -ICore/Inc \ +-ICore/Lib/Inc \ -IDrivers/CMSIS/Device/ST/STM32L4xx/Include \ -IDrivers/CMSIS/Include \ -IDrivers/STM32L4xx_HAL_Driver/Inc \