---vl6180dr

main_prog/Drivers/BSP/custom/custom.c

@@ -0,0 +1,556 @@
+/* USER CODE BEGIN Header */
+/**
+  ******************************************************************************
+  * @file  : custom.c
+  * @brief : Source file for the BSP Common driver
+  ******************************************************************************
+  * @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 */
+
+/* Includes ------------------------------------------------------------------*/
+#include "custom.h"
+
+/** @defgroup BSP BSP
+ * @{
+ */
+
+/** @defgroup CUSTOM CUSTOM
+ * @{
+ */
+
+/** @defgroup CUSTOM_LOW_LEVEL CUSTOM LOW LEVEL
+ *  @brief This file provides set of firmware functions to manage Leds and push-button
+ *         available on STM32WBxx-Nucleo Kit from STMicroelectronics.
+ * @{
+ */
+
+/**
+ * @}
+ */
+
+/** @defgroup CUSTOM_LOW_LEVEL_Private_Defines CUSTOM LOW LEVEL Private Defines
+ * @{
+ */
+
+/** @defgroup CUSTOM_LOW_LEVEL_FunctionPrototypes CUSTOM LOW LEVEL Private Function Prototypes
+ * @{
+ */
+
+/**
+ * @}
+ */
+
+/** @defgroup CUSTOM_LOW_LEVEL_Private_Variables CUSTOM LOW LEVEL Private Variables
+ * @{
+ */
+typedef void (* BSP_LED_GPIO_Init) (void);
+static GPIO_TypeDef*  LED_PORT[LEDn] = {LED2_GPIO_PORT};
+static const uint16_t LED_PIN[LEDn]  = {LED2_PIN};
+static void LED_USER_GPIO_Init(void);
+
+USART_TypeDef* COM_USART[COMn] = {COM1_UART};
+UART_HandleTypeDef hcom_uart[COMn];
+#if (USE_COM_LOG > 0)
+static COM_TypeDef COM_ActiveLogPort;
+#endif
+#if (USE_HAL_UART_REGISTER_CALLBACKS == 1U)
+static uint32_t IslpUart1MspCbValid = 0;
+#endif
+__weak HAL_StatusTypeDef MX_LPUART1_UART_Init(UART_HandleTypeDef* huart);
+/**
+ * @}
+ */
+
+/** @defgroup CUSTOM_LOW_LEVEL_Private_Functions CUSTOM LOW LEVEL Private Functions
+ * @{
+ */
+#if (USE_BSP_COM_FEATURE > 0)
+static void LPUART1_MspInit(UART_HandleTypeDef *huart);
+static void LPUART1_MspDeInit(UART_HandleTypeDef *huart);
+#endif
+/**
+ * @brief  This method returns the STM32WBxx NUCLEO BSP Driver revision
+ * @retval version: 0xXYZR (8bits for each decimal, R for RC)
+ */
+int32_t BSP_GetVersion(void)
+{
+  return (int32_t)__CUSTOM_BSP_VERSION;
+}
+
+/**
+ * @brief  Configures LED on GPIO and/or on MFX.
+ * @param  Led: LED to be configured.
+ *              This parameter can be one of the following values:
+ *              @arg  LED2, LED4, ...
+ * @retval HAL status
+ */
+int32_t BSP_LED_Init(Led_TypeDef Led)
+{
+  static const BSP_LED_GPIO_Init LedGpioInit[LEDn] = {LED_USER_GPIO_Init};
+  LedGpioInit[Led]();
+  return BSP_ERROR_NONE;
+}
+
+/**
+ * @brief  DeInit LEDs.
+ * @param  Led: LED to be configured.
+ *              This parameter can be one of the following values:
+ *              @arg  LED2, LED4, ...
+ * @note Led DeInit does not disable the GPIO clock nor disable the Mfx
+ * @retval HAL status
+ */
+int32_t BSP_LED_DeInit(Led_TypeDef Led)
+{
+  GPIO_InitTypeDef  gpio_init_structure;
+
+  /* Turn off LED */
+  HAL_GPIO_WritePin(LED_PORT[Led], LED_PIN[Led], GPIO_PIN_RESET);
+  /* DeInit the GPIO_LED pin */
+  gpio_init_structure.Pin = LED_PIN[Led];
+  HAL_GPIO_DeInit(LED_PORT[Led], gpio_init_structure.Pin);
+
+  return BSP_ERROR_NONE;
+}
+
+/**
+ * @brief  Turns selected LED On.
+ * @param  Led: LED to be set on
+ *              This parameter can be one of the following values:
+ *              @arg  LED1
+ *              @arg  LED2
+ *              @arg  LED3
+ *              @arg  LED4
+ * @retval HAL status
+ */
+int32_t BSP_LED_On(Led_TypeDef Led)
+{
+  HAL_GPIO_WritePin(LED_PORT [Led], LED_PIN [Led], GPIO_PIN_SET);
+
+  return BSP_ERROR_NONE;
+}
+
+/**
+ * @brief  Turns selected LED Off.
+ * @param  Led: LED to be set off
+ *              This parameter can be one of the following values:
+ *              @arg  LED1
+ *              @arg  LED2
+ *              @arg  LED3
+ *              @arg  LED4
+ * @retval HAL status
+ */
+int32_t BSP_LED_Off(Led_TypeDef Led)
+{
+  HAL_GPIO_WritePin(LED_PORT [Led], LED_PIN [Led], GPIO_PIN_RESET);
+
+  return BSP_ERROR_NONE;
+}
+
+/**
+ * @brief  Toggles the selected LED.
+ * @param  Led: LED to be toggled
+ *              This parameter can be one of the following values:
+ *              @arg  LED1
+ *              @arg  LED2
+ *              @arg  LED3
+ *              @arg  LED4
+ * @retval HAL status
+ */
+int32_t BSP_LED_Toggle(Led_TypeDef Led)
+{
+  HAL_GPIO_TogglePin(LED_PORT[Led], LED_PIN[Led]);
+
+  return BSP_ERROR_NONE;
+}
+
+/**
+ * @brief  Get the status of the LED.
+ * @param  Led: LED for which get the status
+ *              This parameter can be one of the following values:
+ *              @arg  LED1
+ *              @arg  LED2
+ *              @arg  LED3
+ *              @arg  LED4
+ * @retval HAL status (1=high, 0=low)
+ */
+int32_t BSP_LED_GetState(Led_TypeDef Led)
+{
+  return (int32_t)(HAL_GPIO_ReadPin (LED_PORT [Led], LED_PIN [Led]) == GPIO_PIN_RESET);
+}
+/**
+  * @brief
+  * @retval None
+  */
+static void LED_USER_GPIO_Init(void) {
+
+  /* GPIO Ports Clock Enable */
+  __HAL_RCC_GPIOB_CLK_ENABLE();
+
+  GPIO_InitTypeDef GPIO_InitStruct = {0};
+
+  /* GPIO Ports Clock Enable */
+  __HAL_RCC_GPIOB_CLK_ENABLE();
+
+  /*Configure GPIO pin Output Level */
+  HAL_GPIO_WritePin(BUS_BSP_LED_GPIO_PORT, BUS_BSP_LED_GPIO_PIN, GPIO_PIN_RESET);
+
+  /*Configure GPIO pin : PTPIN */
+  GPIO_InitStruct.Pin = BUS_BSP_LED_GPIO_PIN;
+  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
+  GPIO_InitStruct.Pull = GPIO_NOPULL;
+  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
+  HAL_GPIO_Init(BUS_BSP_LED_GPIO_PORT, &GPIO_InitStruct);
+
+}
+
+#if (USE_BSP_COM_FEATURE > 0)
+/**
+ * @brief  Configures COM port.
+ * @param  COM: COM port to be configured.
+ *              This parameter can be COM1
+ * @param  UART_Init: Pointer to a UART_HandleTypeDef structure that contains the
+ *                    configuration information for the specified USART peripheral.
+ * @retval BSP error code
+ */
+int32_t BSP_COM_Init(COM_TypeDef COM)
+{
+  int32_t ret = BSP_ERROR_NONE;
+
+  if(COM > COMn)
+  {
+    ret = BSP_ERROR_WRONG_PARAM;
+  }
+  else
+  {
+     hcom_uart[COM].Instance = COM_USART[COM];
+#if (USE_HAL_UART_REGISTER_CALLBACKS == 0U)
+    /* Init the UART Msp */
+    LPUART1_MspInit(&hcom_uart[COM]);
+#else
+    if(IslpUart1MspCbValid == 0U)
+    {
+      if(BSP_COM_RegisterDefaultMspCallbacks(COM) != BSP_ERROR_NONE)
+      {
+        return BSP_ERROR_MSP_FAILURE;
+      }
+    }
+#endif
+    if (MX_LPUART1_UART_Init(&hcom_uart[COM]))
+    {
+      ret = BSP_ERROR_PERIPH_FAILURE;
+    }
+  }
+
+  return ret;
+}
+
+/**
+ * @brief  DeInit COM port.
+ * @param  COM COM port to be configured.
+ *             This parameter can be COM1
+ * @retval BSP status
+ */
+int32_t BSP_COM_DeInit(COM_TypeDef COM)
+{
+  int32_t ret = BSP_ERROR_NONE;
+
+  if(COM > COMn)
+  {
+    ret = BSP_ERROR_WRONG_PARAM;
+  }
+  else
+  {
+    /* USART configuration */
+    hcom_uart[COM].Instance = COM_USART[COM];
+
+    #if (USE_HAL_UART_REGISTER_CALLBACKS == 0U)
+      LPUART1_MspDeInit(&hcom_uart[COM]);
+    #endif /* (USE_HAL_UART_REGISTER_CALLBACKS == 0U) */
+
+    if(HAL_UART_DeInit(&hcom_uart[COM]) != HAL_OK)
+    {
+      ret = BSP_ERROR_PERIPH_FAILURE;
+    }
+  }
+
+  return ret;
+}
+
+/**
+ * @brief  Configures COM port.
+ * @param  huart USART handle
+ *               This parameter can be COM1
+ * @param  COM_Init Pointer to a UART_HandleTypeDef structure that contains the
+ *                  configuration information for the specified USART peripheral.
+ * @retval HAL error code
+ */
+
+/* LPUART1 init function */
+
+__weak HAL_StatusTypeDef MX_LPUART1_UART_Init(UART_HandleTypeDef* hlpuart)
+{
+  HAL_StatusTypeDef ret = HAL_OK;
+
+  hlpuart->Instance = LPUART1;
+  hlpuart->Init.BaudRate = 209700;
+  hlpuart->Init.WordLength = UART_WORDLENGTH_8B;
+  hlpuart->Init.StopBits = UART_STOPBITS_1;
+  hlpuart->Init.Parity = UART_PARITY_NONE;
+  hlpuart->Init.Mode = UART_MODE_TX_RX;
+  hlpuart->Init.HwFlowCtl = UART_HWCONTROL_NONE;
+  hlpuart->Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
+  hlpuart->Init.ClockPrescaler = UART_PRESCALER_DIV1;
+  hlpuart->AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
+  hlpuart->FifoMode = UART_FIFOMODE_DISABLE;
+  if (HAL_UART_Init(hlpuart) != HAL_OK)
+  {
+    ret = HAL_ERROR;
+  }
+
+  if (HAL_UARTEx_SetTxFifoThreshold(hlpuart, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
+  {
+    ret = HAL_ERROR;
+  }
+
+  if (HAL_UARTEx_SetRxFifoThreshold(hlpuart, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
+  {
+    ret = HAL_ERROR;
+  }
+
+  if (HAL_UARTEx_DisableFifoMode(hlpuart) != HAL_OK)
+  {
+    ret = HAL_ERROR;
+  }
+
+  return ret;
+}
+
+#endif
+#if (USE_HAL_UART_REGISTER_CALLBACKS == 1U)
+/**
+ * @brief Register Default LPUART1 Bus Msp Callbacks
+ * @retval BSP status
+ */
+int32_t BSP_COM_RegisterDefaultMspCallbacks(COM_TypeDef COM)
+{
+  int32_t ret = BSP_ERROR_NONE;
+
+  if(COM >= COMn)
+  {
+    ret = BSP_ERROR_WRONG_PARAM;
+  }
+  else
+  {
+
+    __HAL_UART_RESET_HANDLE_STATE(&hcom_uart[COM]);
+
+    /* Register default MspInit/MspDeInit Callback */
+    if(HAL_UART_RegisterCallback(&hcom_uart[COM], HAL_UART_MSPINIT_CB_ID, LPUART1_MspInit) != HAL_OK)
+    {
+      ret = BSP_ERROR_PERIPH_FAILURE;
+    }
+    else if(HAL_UART_RegisterCallback(&hcom_uart[COM], HAL_UART_MSPDEINIT_CB_ID, LPUART1_MspDeInit) != HAL_OK)
+    {
+      ret = BSP_ERROR_PERIPH_FAILURE;
+    }
+    else
+    {
+      IslpUart1MspCbValid = 1U;
+    }
+  }
+
+  /* BSP status */
+  return ret;
+}
+
+/**
+ * @brief Register LPUART1 Bus Msp Callback registering
+ * @param Callbacks pointer to LPUART1 MspInit/MspDeInit callback functions
+ * @retval BSP status
+ */
+int32_t BSP_COM_RegisterMspCallbacks (COM_TypeDef COM , BSP_COM_Cb_t *Callback)
+{
+  int32_t ret = BSP_ERROR_NONE;
+
+  if(COM >= COMn)
+  {
+    ret = BSP_ERROR_WRONG_PARAM;
+  }
+  else
+  {
+    __HAL_UART_RESET_HANDLE_STATE(&hcom_uart[COM]);
+
+    /* Register MspInit/MspDeInit Callbacks */
+    if(HAL_UART_RegisterCallback(&hcom_uart[COM], HAL_UART_MSPINIT_CB_ID, Callback->pMspInitCb) != HAL_OK)
+    {
+      ret = BSP_ERROR_PERIPH_FAILURE;
+    }
+    else if(HAL_UART_RegisterCallback(&hcom_uart[COM], HAL_UART_MSPDEINIT_CB_ID, Callback->pMspDeInitCb) != HAL_OK)
+    {
+      ret = BSP_ERROR_PERIPH_FAILURE;
+    }
+    else
+    {
+      IslpUart1MspCbValid = 1U;
+    }
+  }
+
+  /* BSP status */
+  return ret;
+}
+#endif /* USE_HAL_UART_REGISTER_CALLBACKS */
+
+#if (USE_COM_LOG > 0)
+/**
+ * @brief  Select the active COM port.
+ * @param  COM COM port to be activated.
+ *             This parameter can be COM1
+ * @retval BSP status
+ */
+int32_t BSP_COM_SelectLogPort(COM_TypeDef COM)
+{
+  if(COM_ActiveLogPort != COM)
+  {
+    COM_ActiveLogPort = COM;
+  }
+  return BSP_ERROR_NONE;
+}
+
+#if defined(__CC_ARM) /* For arm compiler 5 */
+#if !defined(__MICROLIB) /* If not Microlib */
+
+struct __FILE
+{
+  int dummyVar; //Just for the sake of redefining __FILE, we won't we using it anyways ;)
+};
+
+FILE __stdout;
+
+#endif /* If not Microlib */
+#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) /* For arm compiler 6 */
+#if !defined(__MICROLIB) /* If not Microlib */
+
+FILE __stdout;
+
+#endif /* If not Microlib */
+#endif /* For arm compiler 5 */
+#if defined(__ICCARM__) /* For IAR */
+size_t __write(int Handle, const unsigned char *Buf, size_t Bufsize)
+{
+  int i;
+
+  for(i=0; i<Bufsize; i++)
+  {
+    (void)HAL_UART_Transmit(&hcom_uart[COM_ActiveLogPort], (uint8_t *)&Buf[i], 1, COM_POLL_TIMEOUT);
+  }
+
+  return Bufsize;
+}
+#elif defined(__CC_ARM) || (defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)) /* For ARM Compiler 5 and 6 */
+int fputc (int ch, FILE *f)
+{
+  (void)HAL_UART_Transmit(&hcom_uart[COM_ActiveLogPort], (uint8_t *)&ch, 1, COM_POLL_TIMEOUT);
+  return ch;
+}
+#else /* For GCC Toolchains */
+int __io_putchar (int ch)
+{
+  (void)HAL_UART_Transmit(&hcom_uart[COM_ActiveLogPort], (uint8_t *)&ch, 1, COM_POLL_TIMEOUT);
+  return ch;
+}
+#endif /* For IAR */
+#endif /* USE_COM_LOG */
+/**
+ * @brief  Initializes LPUART1 MSP.
+ * @param  huart LPUART1 handle
+ * @retval None
+ */
+
+static void LPUART1_MspInit(UART_HandleTypeDef* uartHandle)
+{
+  GPIO_InitTypeDef GPIO_InitStruct;
+  RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};
+  /* USER CODE BEGIN LPUART1_MspInit 0 */
+
+  /* USER CODE END LPUART1_MspInit 0 */
+
+  /** Initializes the peripherals clock
+  */
+    PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
+    PeriphClkInitStruct.Lpuart1ClockSelection = RCC_LPUART1CLKSOURCE_PCLK1;
+    HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct);
+
+    /* Enable Peripheral clock */
+    __HAL_RCC_LPUART1_CLK_ENABLE();
+
+    __HAL_RCC_GPIOA_CLK_ENABLE();
+    /**LPUART1 GPIO Configuration
+    PA2     ------> LPUART1_TX
+    PA3     ------> LPUART1_RX
+    */
+    GPIO_InitStruct.Pin = BUS_LPUART1_TX_GPIO_PIN;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
+    GPIO_InitStruct.Alternate = BUS_LPUART1_TX_GPIO_AF;
+    HAL_GPIO_Init(BUS_LPUART1_TX_GPIO_PORT, &GPIO_InitStruct);
+
+    GPIO_InitStruct.Pin = BUS_LPUART1_RX_GPIO_PIN;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
+    GPIO_InitStruct.Alternate = BUS_LPUART1_RX_GPIO_AF;
+    HAL_GPIO_Init(BUS_LPUART1_RX_GPIO_PORT, &GPIO_InitStruct);
+
+  /* USER CODE BEGIN LPUART1_MspInit 1 */
+
+  /* USER CODE END LPUART1_MspInit 1 */
+}
+
+static void LPUART1_MspDeInit(UART_HandleTypeDef* uartHandle)
+{
+  /* USER CODE BEGIN LPUART1_MspDeInit 0 */
+
+  /* USER CODE END LPUART1_MspDeInit 0 */
+    /* Peripheral clock disable */
+    __HAL_RCC_LPUART1_CLK_DISABLE();
+
+    /**LPUART1 GPIO Configuration
+    PA2     ------> LPUART1_TX
+    PA3     ------> LPUART1_RX
+    */
+    HAL_GPIO_DeInit(BUS_LPUART1_TX_GPIO_PORT, BUS_LPUART1_TX_GPIO_PIN);
+
+    HAL_GPIO_DeInit(BUS_LPUART1_RX_GPIO_PORT, BUS_LPUART1_RX_GPIO_PIN);
+
+  /* USER CODE BEGIN LPUART1_MspDeInit 1 */
+
+  /* USER CODE END LPUART1_MspDeInit 1 */
+}
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+

main_prog/Drivers/BSP/custom/custom.h

@@ -0,0 +1,273 @@
+/* USER CODE BEGIN Header */
+/**
+  ******************************************************************************
+  * @file  : custom.h
+  * @brief : header file for the BSP Common driver
+  ******************************************************************************
+  * @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 -------------------------------------*/
+#ifndef __CUSTOM_H
+#define __CUSTOM_H
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+/* Includes ------------------------------------------------------------------*/
+#include "custom_conf.h"
+#include "custom_errno.h"
+#include "main.h"
+
+#if (USE_BSP_COM_FEATURE > 0)
+  #if (USE_COM_LOG > 0)
+    #if defined(__ICCARM__) || defined(__CC_ARM) || (defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)) /* For IAR and ARM Compiler 5 and 6*/
+      #include <stdio.h>
+    #endif
+  #endif
+#endif
+/** @addtogroup BSP
+ * @{
+ */
+
+/** @defgroup CUSTOM
+ * @{
+ */
+
+/** @defgroup CUSTOM_LOW_LEVEL
+ * @{
+ */
+
+/** @defgroup STM32L4XX_NUCLEO_LOW_LEVEL_Exported_Constants LOW LEVEL Exported Constants
+  * @{
+  */
+/**
+ * @brief STM32WBXX NUCLEO BSP Driver version number V1.0.0
+ */
+#define __CUSTOM_BSP_VERSION_MAIN   (uint32_t)(0x01) /*!< [31:24] main version */
+#define __CUSTOM_BSP_VERSION_SUB1   (uint32_t)(0x00) /*!< [23:16] sub1 version */
+#define __CUSTOM_BSP_VERSION_SUB2   (uint32_t)(0x00) /*!< [15:8]  sub2 version */
+#define __CUSTOM_BSP_VERSION_RC     (uint32_t)(0x00) /*!< [7:0]  release candidate */
+#define __CUSTOM_BSP_VERSION        ((__CUSTOM_BSP_VERSION_MAIN << 24)\
+                                                    |(__CUSTOM_BSP_VERSION_SUB1 << 16)\
+                                                    |(__CUSTOM_BSP_VERSION_SUB2 << 8 )\
+                                                    |(__CUSTOM_BSP_VERSION_RC))
+
+/** @defgroup CUSTOM_LOW_LEVEL_Exported_Types CUSTOM LOW LEVEL Exported Types
+ * @{
+ */
+
+ /**
+  * @brief Define for CUSTOM board
+  */
+#if !defined (USE_CUSTOM)
+ #define USE_CUSTOM
+#endif
+#ifndef USE_BSP_COM_FEATURE
+   #define USE_BSP_COM_FEATURE                  0U
+#endif
+
+/** @defgroup CUSTOM_LOW_LEVEL_LED CUSTOM LOW LEVEL LED
+ * @{
+ */
+/** Define number of LED            **/
+#define LEDn                              1U
+/**  Definition for BSP USER LED 2   **/
+#define LED2_PIN                     	  GPIO_PIN_0
+#define LED2_GPIO_PORT                    GPIOB
+#define LED2_GPIO_CLK_ENABLE()            __HAL_RCC_GPIOB_CLK_ENABLE()
+#define LED2_GPIO_CLK_DISABLE()           __HAL_RCC_GPIOB_CLK_DISABLE()
+
+#define BUS_GPIO_INSTANCE GPIO
+#define BUS_BSP_LED_GPIO_CLK_ENABLE() __HAL_RCC_GPIOB_CLK_ENABLE()
+#define BUS_BSP_LED_GPIO_PORT GPIOB
+#define BUS_BSP_LED_GPIO_CLK_DISABLE() __HAL_RCC_GPIOB_CLK_DISABLE()
+#define BUS_BSP_LED_GPIO_PIN GPIO_PIN_0
+
+/**
+ * @}
+ */
+
+/** @defgroup CUSTOM_LOW_LEVEL_COM CUSTOM LOW LEVEL COM
+ * @{
+ */
+/**
+ * @brief Definition for COM portx, connected to LPUART1
+ */
+
+#define BUS_LPUART1_INSTANCE LPUART1
+#define BUS_LPUART1_TX_GPIO_CLK_ENABLE() __HAL_RCC_GPIOA_CLK_ENABLE()
+#define BUS_LPUART1_TX_GPIO_AF GPIO_AF8_LPUART1
+#define BUS_LPUART1_TX_GPIO_CLK_DISABLE() __HAL_RCC_GPIOA_CLK_DISABLE()
+#define BUS_LPUART1_TX_GPIO_PIN GPIO_PIN_2
+#define BUS_LPUART1_TX_GPIO_PORT GPIOA
+#define BUS_LPUART1_RX_GPIO_AF GPIO_AF8_LPUART1
+#define BUS_LPUART1_RX_GPIO_CLK_ENABLE() __HAL_RCC_GPIOA_CLK_ENABLE()
+#define BUS_LPUART1_RX_GPIO_CLK_DISABLE() __HAL_RCC_GPIOA_CLK_DISABLE()
+#define BUS_LPUART1_RX_GPIO_PIN GPIO_PIN_3
+#define BUS_LPUART1_RX_GPIO_PORT GPIOA
+
+/**
+ * @}
+ */
+
+/** @defgroup CUSTOM_LOW_LEVEL_Exported_Types LOW LEVEL Exported Types
+  * @{
+  */
+#ifndef USE_BSP_COM
+  #define USE_BSP_COM                           0U
+#endif
+
+#ifndef USE_COM_LOG
+  #define USE_COM_LOG                           1U
+#endif
+
+typedef enum
+{
+  LED2 = 0,
+  LED_GREEN = LED2,
+}Led_TypeDef;
+
+#if (USE_BSP_COM_FEATURE > 0)
+typedef enum
+{
+  COM1 = 0U,
+  COMn
+}COM_TypeDef;
+
+typedef enum
+{
+ COM_WORDLENGTH_8B     =   UART_WORDLENGTH_8B,
+ COM_WORDLENGTH_9B     =   UART_WORDLENGTH_9B,
+}COM_WordLengthTypeDef;
+
+typedef enum
+{
+ COM_STOPBITS_1     =   UART_STOPBITS_1,
+ COM_STOPBITS_2     =   UART_STOPBITS_2,
+}COM_StopBitsTypeDef;
+
+typedef enum
+{
+ COM_PARITY_NONE     =  UART_PARITY_NONE,
+ COM_PARITY_EVEN     =  UART_PARITY_EVEN,
+ COM_PARITY_ODD      =  UART_PARITY_ODD,
+}COM_ParityTypeDef;
+
+typedef enum
+{
+ COM_HWCONTROL_NONE    =  UART_HWCONTROL_NONE,
+ COM_HWCONTROL_RTS     =  UART_HWCONTROL_RTS,
+ COM_HWCONTROL_CTS     =  UART_HWCONTROL_CTS,
+ COM_HWCONTROL_RTS_CTS =  UART_HWCONTROL_RTS_CTS,
+}COM_HwFlowCtlTypeDef;
+
+typedef struct
+{
+  uint32_t             BaudRate;
+  COM_WordLengthTypeDef  WordLength;
+  COM_StopBitsTypeDef  StopBits;
+  COM_ParityTypeDef    Parity;
+  COM_HwFlowCtlTypeDef HwFlowCtl;
+}COM_InitTypeDef;
+#endif
+
+#define MX_UART_InitTypeDef          COM_InitTypeDef
+#define MX_UART_StopBitsTypeDef      COM_StopBitsTypeDef
+#define MX_UART_ParityTypeDef        COM_ParityTypeDef
+#define MX_UART_HwFlowCtlTypeDef     COM_HwFlowCtlTypeDef
+#if (USE_HAL_UART_REGISTER_CALLBACKS == 1U)
+typedef struct
+{
+  void (* pMspInitCb)(UART_HandleTypeDef *);
+  void (* pMspDeInitCb)(UART_HandleTypeDef *);
+} BSP_COM_Cb_t;
+#endif /* (USE_HAL_UART_REGISTER_CALLBACKS == 1U) */
+
+/**
+ * @}
+ */
+
+#define COMn                             1U
+#define COM1_UART                        LPUART1
+
+#define COM_POLL_TIMEOUT                 1000
+extern UART_HandleTypeDef hcom_uart[COMn];
+#define  hlpuart1 hcom_uart[COM1]
+
+/**
+ * @}
+ */
+
+/**
+  * @}
+  */
+
+/**
+  * @}
+  */
+
+/** @defgroup CUSTOM_LOW_LEVEL_Exported_Variables LOW LEVEL Exported Constants
+  * @{
+  */
+/**
+  * @}
+  */
+
+/** @defgroup CUSTOM_LOW_LEVEL_Exported_Functions CUSTOM LOW LEVEL Exported Functions
+ * @{
+ */
+
+int32_t  BSP_GetVersion(void);
+int32_t  BSP_LED_Init(Led_TypeDef Led);
+int32_t  BSP_LED_DeInit(Led_TypeDef Led);
+int32_t  BSP_LED_On(Led_TypeDef Led);
+int32_t  BSP_LED_Off(Led_TypeDef Led);
+int32_t  BSP_LED_Toggle(Led_TypeDef Led);
+int32_t  BSP_LED_GetState(Led_TypeDef Led);
+#if (USE_BSP_COM_FEATURE > 0)
+int32_t  BSP_COM_Init(COM_TypeDef COM);
+int32_t  BSP_COM_DeInit(COM_TypeDef COM);
+#endif
+
+#if (USE_COM_LOG > 0)
+int32_t  BSP_COM_SelectLogPort(COM_TypeDef COM);
+#endif
+
+#if (USE_HAL_UART_REGISTER_CALLBACKS == 1U)
+int32_t BSP_COM_RegisterDefaultMspCallbacks(COM_TypeDef COM);
+int32_t BSP_COM_RegisterMspCallbacks(COM_TypeDef COM , BSP_COM_Cb_t *Callback);
+#endif /* USE_HAL_UART_REGISTER_CALLBACKS */
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CUSTOM__H */
+

main_prog/Drivers/BSP/custom/custom_errno.h

@@ -0,0 +1,58 @@
+/* USER CODE BEGIN Header */
+/**
+  ******************************************************************************
+  * @file           : custom_errno.h
+  * @brief          : Error Code
+  ******************************************************************************
+  * @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 -------------------------------------*/
+#ifndef CUSTOM_ERRNO_H
+#define CUSTOM_ERRNO_H
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+/* BSP Common Error codes */
+#define BSP_ERROR_NONE                    0
+#define BSP_ERROR_NO_INIT                -1
+#define BSP_ERROR_WRONG_PARAM            -2
+#define BSP_ERROR_BUSY                   -3
+#define BSP_ERROR_PERIPH_FAILURE         -4
+#define BSP_ERROR_COMPONENT_FAILURE      -5
+#define BSP_ERROR_UNKNOWN_FAILURE        -6
+#define BSP_ERROR_UNKNOWN_COMPONENT      -7
+#define BSP_ERROR_BUS_FAILURE            -8
+#define BSP_ERROR_CLOCK_FAILURE          -9
+#define BSP_ERROR_MSP_FAILURE            -10
+#define BSP_ERROR_FEATURE_NOT_SUPPORTED      -11
+
+/* BSP BUS error codes */
+
+#define BSP_ERROR_BUS_TRANSACTION_FAILURE    -100
+#define BSP_ERROR_BUS_ARBITRATION_LOSS       -101
+#define BSP_ERROR_BUS_ACKNOWLEDGE_FAILURE    -102
+#define BSP_ERROR_BUS_PROTOCOL_FAILURE       -103
+
+#define BSP_ERROR_BUS_MODE_FAULT             -104
+#define BSP_ERROR_BUS_FRAME_ERROR            -105
+#define BSP_ERROR_BUS_CRC_ERROR              -106
+#define BSP_ERROR_BUS_DMA_FAILURE            -107
+
+#ifdef __cplusplus
+}
+#endif
+#endif /*CUSTOM_ERRNO_H */
+

main_prog/Drivers/BSP/vl6180/Release_Notes_files/colorschememapping.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<a:clrMap xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" bg1="lt1" tx1="dk1" bg2="lt2" tx2="dk2" accent1="accent1" accent2="accent2" accent3="accent3" accent4="accent4" accent5="accent5" accent6="accent6" hlink="hlink" folHlink="folHlink"/>

main_prog/Drivers/BSP/vl6180/Release_Notes_files/filelist.xml

@@ -0,0 +1,6 @@
+<xml xmlns:o="urn:schemas-microsoft-com:office:office">
+ <o:MainFile HRef="../Release_Notes.html"/>
+ <o:File HRef="themedata.thmx"/>
+ <o:File HRef="colorschememapping.xml"/>
+ <o:File HRef="filelist.xml"/>
+</xml>

main_prog/Drivers/BSP/vl6180/vl6180_api.h

@@ -0,0 +1,866 @@
+/*******************************************************************************
+Copyright © 2019, 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.
+********************************************************************************/
+
+
+#ifndef VL6180_API_H_
+#define VL6180_API_H_
+
+#include "vl6180_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 VL6180_SINGLE_DEVICE_DRIVER
+#error "VL6180_SINGLE_DEVICE_DRIVER not defined"
+/* TODO you may remove or comment these #error but it is best you update your vl6180_platform.h file to define it*/
+#endif
+
+
+#ifndef VL6180_RANGE_STATUS_ERRSTRING
+#warning "VL6180_RANGE_STATUS_ERRSTRING not defined ?"
+/* TODO you may remove or comment these #warning and keep the default below to keep compatibility
+   or update your vl6180_platform.h file */
+/**
+ * force VL6180_RANGE_STATUS_ERRSTRING to not supported when not part of any cfg file
+ */
+#define VL6180_RANGE_STATUS_ERRSTRING  0
+#endif
+
+#ifndef VL6180_SAFE_POLLING_ENTER
+#warning "VL6180_SAFE_POLLING_ENTER not defined, likely old vl6180_cfg.h file ?"
+/* TODO you may remove or comment these #warning and keep the default below to keep compatibility
+   or update your vl6180_platform.h file */
+/**
+ * force VL6180_SAFE_POLLING_ENTER to off when not in cfg file
+ */
+#define VL6180_SAFE_POLLING_ENTER 0 /* off by default as in api 2.0 */
+#endif
+
+#ifndef VL6180_LOG_ENABLE
+/**
+ * Force VL6180_LOG_ENABLE to none as default
+ */
+#define VL6180_LOG_ENABLE  0
+#endif
+
+#if VL6180_RANGE_STATUS_ERRSTRING
+/**@def VL6180_HAVE_RANGE_STATUS_ERRSTRING
+ * @brief is defined when @a #VL6180_RANGE_STATUS_ERRSTRING is enable
+ */
+#define  VL6180_HAVE_RANGE_STATUS_ERRSTRING
+#endif
+
+
+/** @brief Get API version as "hex integer" 0xMMnnss
+ */
+#define VL6180_ApiRevInt  ((VL6180_API_REV_MAJOR<<24)+(VL6180_API_REV_MINOR<<16)+VL6180_API_REV_SUB)
+
+/** Get API version as string for exe "2.1.12" "
+ */
+#define VL6180_ApiRevStr  VL6180_STR(VL6180_API_REV_MAJOR) "." VL6180_STR(VL6180_API_REV_MINOR) "." VL6180_STR(VL6180_API_REV_SUB)
+
+#ifndef VL6180_API
+#   define VL6180_API
+#endif
+
+/** @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
+ */
+VL6180_API int VL6180_WaitDeviceBooted(VL6180Dev_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 VL6180_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
+ */
+VL6180_API int VL6180_InitData(VL6180Dev_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 VL6180_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 VL6180_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
+ */
+VL6180_API int VL6180_SetupGPIO1(VL6180Dev_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 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 operations in single shot or continuous mode
+  *
+  * @param dev   The device
+  * @return      0 on success
+  */
+VL6180_API int VL6180_Prepare(VL6180Dev_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
+ */
+VL6180_API int VL6180_RangeStartContinuousMode(VL6180Dev_t dev);
+
+/**
+ * @brief Start single shot ranging measure
+ *
+ * @details End user should ensure device is in idle state and not already running
+ */
+VL6180_API int VL6180_RangeStartSingleShot(VL6180Dev_t dev);
+
+/**
+ * @brief Set maximum convergence time
+ *
+ * @par Function Description
+ * Setting a low convergence time can impact maximal detectable distance.
+ * Refer to VL6180 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
+ */
+VL6180_API int VL6180_RangeSetMaxConvergenceTime(VL6180Dev_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 VL6180_Prepare() and it is safer to clear  very first poll call \n
+  * This function reference VL6180_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
+  * \n This function clears Range Interrupt status , but not error one. For that uses  @a VL6180_ClearErrorInterrupt() \n
+  * This range error is not related VL6180_RangeData_t::errorStatus that refer measure status \n
+  *
+  * @param dev          The device
+  * @param pRangeData   Will be populated with the result ranging data @a  VL6180_RangeData_t
+  * @return 0 on success , @a #RANGE_ERROR if device reports an error case in it status (not cleared) use
+  *
+  * \sa ::VL6180_RangeData_t
+  */
+VL6180_API int VL6180_RangePollMeasurement(VL6180Dev_t dev, VL6180_RangeData_t *pRangeData);
+
+/**
+ * @brief Check for measure readiness and get it if ready
+ *
+ * @par Function Description
+ * Using this function is an alternative to @a VL6180_RangePollMeasurement() to avoid polling operation. This is suitable for applications
+ * where host CPU is triggered on a interrupt (not from VL6180) to perform ranging operation. In this scenario, we assume that the very first ranging
+ * operation is triggered by a call to @a VL6180_RangeStartSingleShot(). Then, host CPU regularly calls @a VL6180_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 VL6180_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.
+ */
+VL6180_API int VL6180_RangeGetMeasurementIfReady(VL6180Dev_t dev, VL6180_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 VL6180_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 VL6180_RangeGetResult for "range only" measurement
+ *
+ * @param dev         The device
+ * @param pRangeData  Pointer to the data structure to fill up
+ * @return            0 on success
+ */
+VL6180_API int VL6180_RangeGetMeasurement(VL6180Dev_t dev, VL6180_RangeData_t *pRangeData);
+
+/**
+ * @brief Get ranging result and only that
+ *
+ * @par Function Description
+ * Unlike @a VL6180_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
+ */
+VL6180_API int VL6180_RangeGetResult(VL6180Dev_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
+ */
+VL6180_API int VL6180_RangeConfigInterrupt(VL6180Dev_t dev, uint8_t ConfigGpioInt);
+
+
+/**
+ * @brief Clear range interrupt
+ *
+ * @param dev    The device
+ * @return  0    On success
+ */
+#define VL6180_RangeClearInterrupt(dev) VL6180_ClearInterrupt(dev, INTERRUPT_CLEAR_RANGING)
+
+/**
+ * @brief Return ranging error interrupt status
+ *
+ * @par Function Description
+ * Appropriate Interrupt report must have been selected first by @a VL6180_RangeConfigInterrupt() or @a  VL6180_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
+ */
+VL6180_API int VL6180_RangeGetInterruptStatus(VL6180Dev_t dev, uint8_t *pIntStatus);
+
+#if VL6180_RANGE_STATUS_ERRSTRING
+
+extern const char *ROMABLE_DATA VL6180_RangeStatusErrString[];
+/**
+ * @brief Human readable error string for range error status
+ *
+ * @param RangeErrCode  The error code as stored on @a VL6180_RangeData_t::errorStatus
+ * @return  error string , NULL for invalid RangeErrCode
+ * @sa ::RangeError_u
+ */
+const char *VL6180_RangeGetStatusErrString(uint8_t RangeErrCode);
+#else
+#define VL6180_RangeGetStatusErrString(...) NULL
+#endif
+
+/** @}  */
+
+
+/** @defgroup api_ll_init Init functions
+ *  @brief    Init functions
+ *  @ingroup api_ll
+ *  @{
+ */
+
+/**
+ * @brief Low level ranging register static settings (you should call @a VL6180_Prepare() function instead)
+ *
+ * @param dev
+ * @return 0 on success
+ */
+VL6180_API int VL6180_StaticInit(VL6180Dev_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 VL6180_ErrCode_t::TIME_OUT for time out \n
+ *                   @ref VL6180_ErrCode_t::INVALID_PARAMS if MaxLop<1
+ */
+VL6180_API int VL6180_RangeWaitDeviceReady(VL6180Dev_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
+ */
+VL6180_API int VL6180_RangeSetInterMeasPeriod(VL6180Dev_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 VL6180_SetGroupParamHold() \n
+ *  @li Get Threshold @a VL6180_RangeGetThresholds() \n
+ *  @li Change scaling : @a VL6180_UpscaleSetScaling() \n
+ *  @li Set Threshold : @a VL6180_RangeSetThresholds() \n
+ *  @li Unset Group Hold : @a VL6180_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.
+ */
+VL6180_API int VL6180_UpscaleSetScaling(VL6180Dev_t dev, uint8_t scaling);
+
+/**
+ * @brief Get current ranging scaling factor
+ *
+ * @param dev The device
+ * @return    The current scaling factor
+ */
+VL6180_API int VL6180_UpscaleGetScaling(VL6180Dev_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 VL6180_RangeIsFilteredMeasurement(pRangeData) ((pRangeData)->errorStatus == RangingFiltered)
+
+/**
+ * @brief Get the maximal distance for actual scaling
+ * @par Function Description
+ * Do not use prior to @a VL6180_Prepare() or at least @a VL6180_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 VL6180_GetUpperLimit(VL6180Dev_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 VL6180_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
+ */
+VL6180_API int VL6180_RangeSetThresholds(VL6180Dev_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 VL6180_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
+ */
+VL6180_API int VL6180_RangeGetThresholds(VL6180Dev_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
+ */
+VL6180_API int VL6180_RangeSetRawThresholds(VL6180Dev_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
+ */
+VL6180_API int VL6180_RangeSetEceFactor(VL6180Dev_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
+ */
+VL6180_API int VL6180_RangeSetEceState(VL6180Dev_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
+ */
+VL6180_API int VL6180_FilterSetState(VL6180Dev_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
+ */
+VL6180_API int VL6180_FilterGetState(VL6180Dev_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
+ */
+VL6180_API int VL6180_DMaxSetState(VL6180Dev_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
+ */
+VL6180_API int VL6180_DMaxGetState(VL6180Dev_t dev);
+
+
+/**
+ * @brief Set ranging mode and start/stop measure (use high level functions instead : @a VL6180_RangeStartSingleShot() or @a VL6180_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
+ */
+VL6180_API int VL6180_RangeSetSystemMode(VL6180Dev_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 VL6180_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
+ */
+VL6180_API int VL6180_RangeIgnoreSetEnable(VL6180Dev_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 VL6180_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
+ */
+VL6180_API int VL6180_RangeIgnoreConfigure(VL6180Dev_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 VL6180_InitData to backup device nvm value
+ *
+ * @param dev  The device
+ * @return part to part calibration offset from device
+ */
+VL6180_API int8_t VL6180_GetOffsetCalibrationData(VL6180Dev_t dev);
+
+/**
+ * Set or over-write part to part calibration offset and apply it immediately
+ * \sa VL6180_InitData(), VL6180_GetOffsetCalibrationData()
+ * @param dev     The device
+ * @param offset   Offset
+ * @return  0 on success
+ */
+VL6180_API int  VL6180_SetOffsetCalibrationData(VL6180Dev_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
+ */
+VL6180_API int  VL6180_SetXTalkCompensationRate(VL6180Dev_t dev, FixPoint97_t Rate);
+
+/** @}  */
+
+
+
+
+/** @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
+ *
+ *
+ * @param dev   The device
+ * @param Hold  Group parameter Hold state to be set (on/off)
+ * @return      0 on success
+ */
+VL6180_API int VL6180_SetGroupParamHold(VL6180Dev_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 VL6180's in a single design
+ * @param dev       The device
+ * @param NewAddr   The new i2c address (8 bits)
+ * @return          0 on success
+ */
+VL6180_API int VL6180_SetI2CAddress(VL6180Dev_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
+ */
+VL6180_API int VL6180_SetupGPIOx(VL6180Dev_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
+ */
+VL6180_API int VL6180_SetGPIOxPolarity(VL6180Dev_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)Note 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
+ */
+VL6180_API int VL6180_SetGPIOxFunctionality(VL6180Dev_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
+ */
+VL6180_API int VL6180_DisableGPIOxOut(VL6180Dev_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 VL6180_SetupGPIOx() , @a VL6180_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
+ */
+VL6180_API int VL6180_GetInterruptStatus(VL6180Dev_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_ERROR.
+ * @return  0       On success
+ */
+VL6180_API int VL6180_ClearInterrupt(VL6180Dev_t dev, uint8_t IntClear);
+
+/**
+ * @brief Clear error interrupt
+ *
+ * @param dev    The device
+ * @return  0    On success
+ */
+ #define VL6180_ClearErrorInterrupt(dev) VL6180_ClearInterrupt(dev, INTERRUPT_CLEAR_ERROR)
+
+/**
+ * @brief Clear All interrupt causes (range+error)
+ *
+ * @param dev    The device
+ * @return  0    On success
+ */
+#define VL6180_ClearAllInterrupt(dev) VL6180_ClearInterrupt(dev, INTERRUPT_CLEAR_ERROR|INTERRUPT_CLEAR_RANGING)
+
+/** @}  */
+
+
+/** @defgroup api_reg API Register access functions
+ *  @brief    Registers access functions called by API core functions
+ *  @ingroup api_ll
+ *  @{
+ */
+
+/**
+ * Write VL6180 single byte register
+ * @param dev   The device
+ * @param index The register index
+ * @param data  8 bit register data
+ * @return success
+ */
+VL6180_API int VL6180_WrByte(VL6180Dev_t dev, uint16_t index, uint8_t data);
+/**
+ * Thread safe VL6180 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
+ */
+VL6180_API int VL6180_UpdateByte(VL6180Dev_t dev, uint16_t index, uint8_t AndData, uint8_t OrData);
+/**
+ * Write VL6180 word register
+ * @param dev   The device
+ * @param index The register index
+ * @param data  16 bit register data
+ * @return  0 on success
+ */
+VL6180_API int VL6180_WrWord(VL6180Dev_t dev, uint16_t index, uint16_t data);
+/**
+ * Write VL6180 double word (4 byte) register
+ * @param dev   The device
+ * @param index The register index
+ * @param data  32 bit register data
+ * @return  0 on success
+ */
+VL6180_API int VL6180_WrDWord(VL6180Dev_t dev, uint16_t index, uint32_t data);
+
+/**
+ * Read VL6180 single byte register
+ * @param dev   The device
+ * @param index The register index
+ * @param data  pointer to 8 bit data
+ * @return 0 on success
+ */
+VL6180_API int VL6180_RdByte(VL6180Dev_t dev, uint16_t index, uint8_t *data);
+
+/**
+ * Read VL6180 word (2byte) register
+ * @param dev   The device
+ * @param index The register index
+ * @param data  pointer to 16 bit data
+ * @return 0 on success
+ */
+VL6180_API int VL6180_RdWord(VL6180Dev_t dev, uint16_t index, uint16_t *data);
+
+/**
+ * Read VL6180 dword (4byte) register
+ * @param dev   The device
+ * @param index The register index
+ * @param data  pointer to 32 bit data
+ * @return 0 on success
+ */
+VL6180_API int VL6180_RdDWord(VL6180Dev_t dev, uint16_t index, uint32_t *data);
+
+
+/**
+ * Read VL6180 multiple bytes
+ * @note required only if #VL6180_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
+ */
+VL6180_API int VL6180_RdMulti(VL6180Dev_t dev, uint16_t index, uint8_t *data, int nData);
+
+/** @}  */
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* VL6180_API_H_ */

main_prog/Drivers/BSP/vl6180/vl6180_cfg.h

@@ -0,0 +1,104 @@
+/*******************************************************************************
+Copyright <20> 2019, 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 VL6180_cfg.h
+ *
+ * Proximity configuration
+ */
+
+#ifndef VL6180_CFG_H_
+#define VL6180_CFG_H_
+
+/** @defgroup api_config Configuration
+ *  @brief API static configuration
+ */
+
+
+
+/** @ingroup api_config
+ * @{*/
+
+
+/**
+ * @def VL6180_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 VL6180_UpscaleSetScaling(). Default scaling factore is -VL6180_UPSCALE_SUPPORT \n
+ */
+#define VL6180_UPSCALE_SUPPORT -3
+
+
+/**
+ * @def VL6180_HAVE_DMAX_RANGING
+ * @brief Enable DMax calculation for ranging applications.
+ *  
+ * When set to 1, __Dmax__ is returned by API typically when  @a VL6180_RangePollMeasurement() high level
+ * function is called (this is returned in @a VL6180_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 VL6180_RangeData_t structure returned by 
+ * the @a VL6180_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 VL6180_HAVE_DMAX_RANGING   1
+
+/**
+ * @def VL6180_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 VL6180_FilterSetState() can turn it on and off at any time
+ */
+#define VL6180_WRAP_AROUND_FILTER_SUPPORT   1
+
+/**
+ * @def VL6180_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 VL6180_EXTENDED_RANGE 0
+
+
+#endif
+/** @} */ // end of api_config
+
+/* VL6180_CFG_H_ */

main_prog/Drivers/BSP/vl6180/vl6180_def.h

@@ -0,0 +1,677 @@
+/*******************************************************************************
+Copyright © 2019, 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 VL6180_def.h
+ *
+ * @brief Type definitions for vl6180 api.
+ *
+ */
+
+
+#ifndef _VL6180_DEF
+#define _VL6180_DEF
+
+/** API major version */
+#define VL6180_API_REV_MAJOR   1
+/** API minor version */
+#define VL6180_API_REV_MINOR   3
+/** API sub version */
+#define VL6180_API_REV_SUB     0
+
+#define VL6180_STR_HELPER(x) #x
+#define VL6180_STR(x) VL6180_STR_HELPER(x)
+
+#include "vl6180_cfg.h"
+#include "vl6180_types.h"
+
+/*
+ * check configuration macro raise error or warning and suggest a default value
+ */
+
+#ifndef VL6180_UPSCALE_SUPPORT
+#error "VL6180_UPSCALE_SUPPORT not defined"
+/* TODO you must define value for  upscale support in your vl6180_cfg.h  */
+#endif
+
+#ifndef VL6180_HAVE_DMAX_RANGING
+#error "VL6180_HAVE_DMAX_RANGING not defined"
+/* TODO you may remove or comment these #error and keep the default below  or update your vl6180_cfg.h .h file */
+/**
+ * force VL6180_HAVE_DMAX_RANGING to not supported when not part of cfg file
+ */
+#define VL6180_HAVE_DMAX_RANGING   0
+#endif
+
+#ifndef VL6180_EXTENDED_RANGE
+#define VL6180_EXTENDED_RANGE   1
+#endif
+
+#ifndef VL6180_WRAP_AROUND_FILTER_SUPPORT
+#error "VL6180_WRAP_AROUND_FILTER_SUPPORT not defined ?"
+/* TODO you may remove or comment these #error and keep the default below  or update vl6180_cfg.h file */
+/**
+ * force VL6180_WRAP_AROUND_FILTER_SUPPORT to not supported when not part of cfg file
+ */
+#define VL6180_WRAP_AROUND_FILTER_SUPPORT 0
+#endif
+
+
+
+#ifndef VL6180_HAVE_MULTI_READ
+#   define VL6180_HAVE_MULTI_READ  0
+#endif
+
+/**
+ * Force VL6180_CACHED_REG to default 0 when not defined
+ */
+#ifndef VL6180_CACHED_REG
+#   define VL6180_CACHED_REG  0
+#else
+#   define VL6180_FIRST_CACHED_INDEX      0x04D
+#   define VL6180_LAST_CACHED_INDEX       (VL6180_FIRST_CACHED_INDEX+55)
+#   define VL6180_CACHED_REG_CNT           (VL6180_LAST_CACHED_INDEX-VL6180_FIRST_CACHED_INDEX+1)
+#endif
+
+/****************************************
+ * PRIVATE define do not edit
+ ****************************************/
+
+/** Maximal buffer size ever use in i2c */
+#define VL6180_MAX_I2C_XFER_SIZE   8 /* At present time it 6 byte max but that can change */
+
+#if VL6180_UPSCALE_SUPPORT < 0
+/**
+ * @def VL6180_HAVE_UPSCALE_DATA
+ * @brief  is defined if device data structure has data so when user configurable up-scale is active
+ */
+#define VL6180_HAVE_UPSCALE_DATA /* have data only for user configurable up-scale config */
+#endif
+
+#if VL6180_WRAP_AROUND_FILTER_SUPPORT
+/**
+ * @def VL6180_HAVE_WRAP_AROUND_DATA
+ * @brief  is defined if device data structure has filter data so when active in cfg file
+ */
+#define  VL6180_HAVE_WRAP_AROUND_DATA
+#endif
+
+
+#if VL6180_WRAP_AROUND_FILTER_SUPPORT || VL6180_HAVE_DMAX_RANGING
+	#define	VL6180_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 VL6180_ErrCode_t {
+	API_NO_ERROR        = 0,
+	CALIBRATION_WARNING = 1,  /*!< warning invalid calibration data may be in used \a  VL6180_InitData() \a VL6180_GetOffsetCalibrationData \a VL6180_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 vl6180 */
+
+	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  VL6180_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 VL6180DevData_t
+ *
+ * @brief Per VL6180 device St private data structure \n
+ * End user should never access any of these field directly
+ *
+ * These must never access directly but only via VL6180Dev/SetData(dev, field) macro
+ */
+struct VL6180DevData_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 VL6180_HAVE_UPSCALE_DATA
+	uint8_t UpscaleFactor;      /*!<  up-scaling factor*/
+#endif
+
+#ifdef VL6180_HAVE_WRAP_AROUND_DATA
+	uint8_t WrapAroundFilterActive; /*!< Filter on/off */
+	struct FilterData_t FilterData; /*!< Filter internal data state history ... */
+#endif
+
+#if VL6180_CACHED_REG
+	uint8_t CacheFilled;             /*!< Set if valid data got fetched use to control when to fill up register cache */
+	uint8_t CachedRegs[VL6180_CACHED_REG_CNT];          /*!< Cache register storage */
+#endif
+#if VL6180_HAVE_DMAX_RANGING
+	struct DMaxData_t DMaxData;
+	uint8_t DMaxEnable;
+#endif
+	int8_t  Part2PartOffsetNVM;     /*!< backed up NVM value */
+};
+
+
+/**
+ * @struct VL6180_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 VL6180_GetRangeStatusErrString() */
+
+
+#ifdef VL6180_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 VL6180_HAVE_DMAX_RANGING
+	uint32_t DMax;              /*!< DMax  when applicable */
+#endif
+
+#ifdef VL6180_HAVE_WRAP_AROUND_DATA
+	RangeFilterResult_t FilteredData; /*!< Filter result main range_mm is updated */
+#endif
+} VL6180_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 Range status Error code
+ *
+ * @a VL6180_GetRangeStatusErrString() if configured ( @a #VL6180_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 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<<GPIOx_FUNCTIONALITY_SELECT_SHIFT)
+    /** select no interrupt in #SYSTEM_MODE_GPIO1 pad is put in  Hi-Z*/
+    #define GPIOx_SELECT_OFF                        0x00
+    /** select gpiox as interrupt output in  #SYSTEM_MODE_GPIO1 */
+    #define GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT      0x08
+    /** select range as source for interrupt on in #SYSTEM_MODE_GPIO1 */
+    #define GPIOx_MODE_SELECT_RANGING               0x00
+
+
+/**
+ * @def SYSTEM_INTERRUPT_CONFIG_GPIO
+ *
+ * @brief   Configure Ranging interrupt reporting
+ *
+ * Possible values for Range \n
+ *
+ * #CONFIG_GPIO_INTERRUPT_DISABLED\n
+ * #CONFIG_GPIO_INTERRUPT_LEVEL_LOW\n
+ * #CONFIG_GPIO_INTERRUPT_LEVEL_HIGH\n
+ * #CONFIG_GPIO_INTERRUPT_OUT_OF_WINDOW\n
+ * #CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY\n
+ * Apply respective rang shift and mask \n
+ *  #CONFIG_GPIO_RANGE_SHIFT and full reg mask #CONFIG_GPIO_RANGE_MASK\n
+ *
+ * \sa GPIO use for interrupt #SYSTEM_MODE_GPIO0 or #SYSTEM_MODE_GPIO1\n
+ * @ingroup device_regdef
+ */
+#define SYSTEM_INTERRUPT_CONFIG_GPIO           0x014
+    /** RANGE bits shift in #SYSTEM_INTERRUPT_CONFIG_GPIO */
+    #define CONFIG_GPIO_RANGE_SHIFT            0
+    /** RANGE bits mask in #SYSTEM_INTERRUPT_CONFIG_GPIO  (unshifted)*/
+    #define CONFIG_GPIO_RANGE_MASK             (0x7<<CONFIG_GPIO_RANGE_SHIFT)
+    /** interrupt is disabled */
+    #define CONFIG_GPIO_INTERRUPT_DISABLED         0x00
+    /** trigger when value < low threshold */
+    #define CONFIG_GPIO_INTERRUPT_LEVEL_LOW        0x01
+    /** trigger when value < low threshold */
+    #define CONFIG_GPIO_INTERRUPT_LEVEL_HIGH       0x02
+    /** trigger when outside range defined by high low threshold */
+    #define CONFIG_GPIO_INTERRUPT_OUT_OF_WINDOW    0x03
+    /** trigger when new sample are ready */
+    #define CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY 0x04
+
+/**
+ *  @def SYSTEM_INTERRUPT_CLEAR
+ *  @brief Writing to this register will clear interrupt source
+ *
+ *  Use or combination of any #INTERRUPT_CLEAR_RANGING , #INTERRUPT_CLEAR_ERROR
+ *  @ingroup device_regdef
+ */
+#define SYSTEM_INTERRUPT_CLEAR                0x015
+    /** clear ranging interrupt in write to #SYSTEM_INTERRUPT_CLEAR */
+    #define INTERRUPT_CLEAR_RANGING                0x01
+    /** clear error interrupt in write to #SYSTEM_INTERRUPT_CLEAR */
+    #define INTERRUPT_CLEAR_ERROR                  0x04
+
+/** After power up or reset this register will start reading 1 when device is ready */
+#define SYSTEM_FRESH_OUT_OF_RESET             0x016
+
+/**
+ * @def SYSTEM_GROUPED_PARAMETER_HOLD
+ * @brief Writing 1/0 activate/deactivate safe host update of multiple register in critical group \n
+ *        rather use \a VL6180_SetGroupParamHold()
+ *
+ * The critical register group is made of: \n
+ * #SYSTEM_INTERRUPT_CONFIG_GPIO \n
+ * #SYSRANGE_THRESH_HIGH \n
+ * #SYSRANGE_THRESH_LOW \n
+ * @ingroup device_regdef
+ */
+#define SYSTEM_GROUPED_PARAMETER_HOLD         0x017
+
+
+/**
+ * @def SYSRANGE_START
+ * @brief Start/stop and set operating range mode
+ *
+ * Write Combination of #MODE_START_STOP  and #MODE_CONTINUOUS to select and start desired operation.
+ *
+ * @ingroup device_regdef
+ */
+#define SYSRANGE_START                        0x018
+    /** mask existing bit in #SYSRANGE_START*/
+    #define SYSRANGE_START_MODE_MASK          0x03
+    /** bit 0 in #SYSRANGE_START write 1 toggle state in continuous mode and arm next shot in single shot mode */
+    #define MODE_START_STOP                   0x01
+    /** bit 1 write 1 in #SYSRANGE_START set continuous operation mode */
+    #define MODE_CONTINUOUS                   0x02
+    /** bit 1 write 0 in #SYSRANGE_START set single shot mode */
+    #define MODE_SINGLESHOT                   0x00
+
+/**
+ * @def SYSRANGE_THRESH_HIGH
+ * High level range  threshold (must be scaled)
+ * @ingroup device_regdef
+ */
+#define SYSRANGE_THRESH_HIGH                  0x019
+
+/**
+ * @def SYSRANGE_THRESH_LOW
+ * Low level range  threshold (must be scaled)
+ * @ingroup device_regdef
+ */
+#define SYSRANGE_THRESH_LOW                   0x01A
+
+/**
+ * @def SYSRANGE_INTERMEASUREMENT_PERIOD
+ * @brief Continuous mode intermeasurement delay \a VL6180_RangeSetInterMeasPeriod()
+ *
+ * Time delay between measurements in Ranging continuous mode.\n
+ * Range 0-254 (0 = 10ms).\n Step size = 10ms.
+ *
+ * @ingroup device_regdef
+ */
+#define SYSRANGE_INTERMEASUREMENT_PERIOD      0x01B
+
+/**
+ * @brief Maximum time to run measurement in Ranging modes.
+ * Range 1 - 63 ms (1 code = 1 ms);
+ *
+ * Measurement aborted when limit reached to aid power  reduction.\
+ * For example, 0x01 = 1ms, 0x0a = 10ms.\
+ * Note: Effective max_convergence_time depends on readout_averaging_sample_period setting.
+ *
+ * @ingroup device_regdef
+ */
+#define SYSRANGE_MAX_CONVERGENCE_TIME         0x01C
+/**@brief Cross talk compensation rate
+ * @warning  never write register directly use @a VL6180_SetXTalkCompensationRate()
+ * refer to manual for calibration procedure and computation
+ * @ingroup device_regdef
+ */
+#define SYSRANGE_CROSSTALK_COMPENSATION_RATE  0x01E
+/**
+ * @brief Minimum range value in mm to qualify for crosstalk compensation
+ */
+#define SYSRANGE_CROSSTALK_VALID_HEIGHT       0x021
+#define SYSRANGE_EARLY_CONVERGENCE_ESTIMATE   0x022
+#define SYSRANGE_PART_TO_PART_RANGE_OFFSET    0x024
+/**
+ * @brief range ignore valid height
+ * @warning  do not program directly use @a VL6180_RangeIgnoreConfigure() and @a VL6180_RangeIgnoreSetEnable()
+ */
+#define SYSRANGE_RANGE_IGNORE_VALID_HEIGHT    0x025
+/**
+ * @brief range ignore threshold
+ * @warning  do not program directly use @a VL6180_RangeIgnoreConfigure() and @a VL6180_RangeIgnoreSetEnable()
+ */
+#define SYSRANGE_RANGE_IGNORE_THRESHOLD       0x026
+#define SYSRANGE_EMITTER_BLOCK_THRESHOLD      0x028
+#define SYSRANGE_MAX_AMBIENT_LEVEL_THRESH     0x02A
+#define SYSRANGE_MAX_AMBIENT_LEVEL_MULT       0x02C
+/** @brief  various Enable check enable register
+ *  @a VL6180_RangeSetEceState()
+ *  @a VL6180_RangeIgnoreConfigure() and @a VL6180_RangeIgnoreSetEnable()
+ */
+#define SYSRANGE_RANGE_CHECK_ENABLES          0x02D
+    #define RANGE_CHECK_ECE_ENABLE_MASK      0x01
+    #define RANGE_CHECK_RANGE_ENABLE_MASK    0x02
+    #define RANGE_CHECK_SNR_ENABLE           0x10
+
+#define SYSRANGE_VHV_RECALIBRATE              0x02E
+#define SYSRANGE_VHV_REPEAT_RATE              0x031
+
+
+/**
+ * @brief Result range status
+ *
+ *  Hold the various range interrupt flags and error Specific error codes
+ */
+#define RESULT_RANGE_STATUS                   0x04D
+    /** Device ready for new command bit 0*/
+    #define RANGE_DEVICE_READY_MASK       0x01
+    /** mask for error status covers bits [7:4]  in #RESULT_RANGE_STATUS @a ::RangeError_u */
+    #define RANGE_ERROR_CODE_MASK         0xF0 /* */
+    /** range error bit position in #RESULT_RANGE_STATUS */
+    #define RANGE_ERROR_CODE_SHIFT        4
+
+
+
+/**
+ * these union can be use as a generic bit field type for map #RESULT_INTERRUPT_STATUS_GPIO register
+ * @ingroup device_regdef
+ */
+typedef union IntrStatus_u {
+	uint8_t val;           /*!< raw 8 bit register value*/
+	struct  {
+		unsigned Range:3; /*!< Range status one of :\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 \a #RES_INT_STAT_GPIO_NEW_SAMPLE_READY */
+		unsigned Error:2; /*!<  Error status of: \n \a #RES_INT_ERROR_LASER_SAFETY  \n \a #RES_INT_ERROR_PLL */
+	} status;                 /*!< interrupt status as bit field */
+} IntrStatus_t;
+
+/**
+ * @def RESULT_INTERRUPT_STATUS_GPIO
+ * @brief System interrupt status report selected interrupt for ranging
+ *
+ * These register can be polled even if no gpio pins is active\n
+ * What reported is selected by \a  #SYSTEM_INTERRUPT_CONFIG_GPIO \n
+ * Range mask with \a #RES_INT_RANGE_MASK and shit by \a #RES_INT_RANGE_SHIFT
+ * Result value express condition (or combination?)
+ * \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
+ * \a #RES_INT_STAT_GPIO_NEW_SAMPLE_READY
+ *
+ * @ingroup device_regdef
+ */
+#define RESULT_INTERRUPT_STATUS_GPIO          0x4F
+    /** ranging interrupt 1st bit position in #RESULT_INTERRUPT_STATUS_GPIO */
+    #define RES_INT_RANGE_SHIFT  0
+    /** interrupt bit position in #RESULT_INTERRUPT_STATUS_GPIO */
+    #define RES_INT_ERROR_SHIFT  6
+    /** Ranging interrupt mask in #RESULT_INTERRUPT_STATUS_GPIO (prior to shift)  \sa IntrStatus_t */
+    #define RES_INT_RANGE_MASK (0x7<<RES_INT_RANGE_SHIFT)
+
+    /** low threshold condition in #RESULT_INTERRUPT_STATUS_GPIO  */
+    #define RES_INT_STAT_GPIO_LOW_LEVEL_THRESHOLD  0x01
+    /** high threshold condition in #RESULT_INTERRUPT_STATUS_GPIO for Range*/
+    #define RES_INT_STAT_GPIO_HIGH_LEVEL_THRESHOLD 0x02
+    /** out of window condition in #RESULT_INTERRUPT_STATUS_GPIO */
+    #define RES_INT_STAT_GPIO_OUT_OF_WINDOW        0x03
+    /** new sample ready in #RESULT_INTERRUPT_STATUS_GPIO */
+    #define RES_INT_STAT_GPIO_NEW_SAMPLE_READY     0x04
+    /** error  in #RESULT_INTERRUPT_STATUS_GPIO */
+    #define RES_INT_ERROR_MASK (0x3<<RES_INT_ERROR_SHIFT)
+	/** laser safety error on #RES_INT_ERROR_MASK of #RESULT_INTERRUPT_STATUS_GPIO */
+	#define RES_INT_ERROR_LASER_SAFETY  1
+	/** pll 1 or 2 error on #RES_INT_ERROR_MASK of #RESULT_INTERRUPT_STATUS_GPIO*/
+	#define RES_INT_ERROR_PLL           2
+
+/**
+ * Final range result value presented to the user for use. Unit is in mm.
+ */
+#define RESULT_RANGE_VAL                        0x062
+
+/**
+ * Raw Range result value with offset applied (no cross talk compensation applied). Unit is in mm.
+ */
+#define RESULT_RANGE_RAW                        0x064
+
+/**
+ * @brief Sensor count rate of signal returns correlated to IR emitter.
+ *
+ * Computed from RETURN_SIGNAL_COUNT / RETURN_CONV_TIME. Mcps 9.7 format
+ */
+#define RESULT_RANGE_SIGNAL_RATE                0x066
+
+/**
+ * @brief Return signal count
+ *
+ *  Sensor count output value attributed to signal correlated to IR emitter on the Return array.
+ */
+#define RESULT_RANGE_RETURN_SIGNAL_COUNT        0x06C
+
+/**
+ * @brief Reference signal count
+ *
+ * sensor count output value attributed to signal correlated to IR emitter on the Reference array.
+ */
+#define RESULT_RANGE_REFERENCE_SIGNAL_COUNT     0x070
+
+/**
+ * @brief Return ambient count
+ *
+ * sensor count output value attributed to uncorrelated ambient signal on the Return array.
+ * Must be multiplied by 6 if used to calculate the ambient to signal threshold
+ */
+#define RESULT_RANGE_RETURN_AMB_COUNT           0x074
+
+/**
+ * @brief   Reference ambient count
+ *
+ * Sensor count output value attributed to uncorrelated ambient signal on the Reference array.
+ */
+#define RESULT_RANGE_REFERENCE_AMB_COUNT        0x078
+
+/**
+ * sensor count output value attributed to signal on the Return array.
+ */
+#define RESULT_RANGE_RETURN_CONV_TIME           0x07C
+
+/**
+ * sensor count output value attributed to signal on the Reference array.
+ */
+#define RESULT_RANGE_REFERENCE_CONV_TIME        0x080
+
+
+/**
+ * @def RANGE_SCALER
+ * @brief RANGE scaling register
+ *
+ * Never should  user write directly onto that register directly \a VL6180_UpscaleSetScaling()
+ */
+#define RANGE_SCALER                            0x096
+
+/**
+ * @def READOUT_AVERAGING_SAMPLE_PERIOD
+ * @brief Readout averaging sample period register
+ *
+ *
+ * The internal readout averaging sample period can be adjusted from 0 to 255.
+ * Increasing the sampling period decreases noise but also reduces the effective
+ * max convergence time and increases power consumption
+ * Each unit sample period corresponds to around 64.5 μs additional processing time.
+ * The recommended setting is 48 which equates to around 4.3 ms.
+ *
+ * see datasheet for more detail
+ */
+#define READOUT_AVERAGING_SAMPLE_PERIOD     0x10A
+
+/**
+ * @def I2C_SLAVE_DEVICE_ADDRESS
+ * User programmable I2C address (7-bit). Device address can be re-designated after power-up.
+ * @warning What programmed in the register 7-0 are bit 8-1 of i2c address on bus (bit 0 is rd/wr)
+ * so what prohamd is commonly whar ergfer as adrerss /2
+ * @sa VL6180_SetI2CAddress()
+ */
+#define I2C_SLAVE_DEVICE_ADDRESS               0x212
+
+#endif /* _VL6180_DEF */