Library for use with VL53L0X, cut 1.1, based on mass-market API v1.1.

Dependencies:   ST_INTERFACES X_NUCLEO_COMMON

Dependents:   ConcorsoFinal HelloWorld_IHM01A1 m3pi_BT m3pi_LIDAR ... more

Fork of X_NUCLEO_53L0A1 by ST Expansion SW Team

X-NUCLEO-53L0A1 Proximity Sensor Expansion Board Firmware Package

Introduction

This firmware package includes Component Device Drivers and the Board Support Package for STMicroelectronics' X-NUCLEO-53L0A1 Proximity sensor expansion board based on VL53L0X.

Firmware Library

Class X_NUCLEO_53L0A1 is intended to represent the Proximity sensor expansion board with the same name.

The expansion board provides support for the following components:

  1. on-board VL53L0X proximity sensor,
  2. up to two additional VL53L0X Satellites,
  3. on-board 4-digit display

It is intentionally implemented as a singleton because only one X-NUCLEO-VL53L0A1 may be deployed at a time in a HW component stack. In order to get the singleton instance you have to call class method `Instance()`, e.g.:

// Sensors expansion board singleton instance
static X_NUCLEO_53L0A1 *board = X_NUCLEO_53L0A1::Instance(device_i2c, A2, D8, D2);

Example Applications

The library and sample application code were tested against mbed revision 143, dated 26th May 2017.

Committer:
Davidroid
Date:
Tue Aug 22 14:39:51 2017 +0000
Revision:
16:27d3d95c8593
Parent:
Components/VL53L0X/vl53l0x_class.cpp@14:8320b5ff96fa
Aligning to ARM mbed coding style.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
johnAlexander 0:c523920bcc09 1 /**
johnAlexander 0:c523920bcc09 2 ******************************************************************************
Davidroid 16:27d3d95c8593 3 * @file VL53L0X_class.cpp
johnAlexander 0:c523920bcc09 4 * @author IMG
johnAlexander 0:c523920bcc09 5 * @version V0.0.1
johnAlexander 0:c523920bcc09 6 * @date 28-June-2016
johnAlexander 0:c523920bcc09 7 * @brief Implementation file for the VL53L0X driver class
johnAlexander 0:c523920bcc09 8 ******************************************************************************
johnAlexander 0:c523920bcc09 9 * @attention
johnAlexander 0:c523920bcc09 10 *
johnAlexander 0:c523920bcc09 11 * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
johnAlexander 0:c523920bcc09 12 *
johnAlexander 0:c523920bcc09 13 * Redistribution and use in source and binary forms, with or without modification,
johnAlexander 0:c523920bcc09 14 * are permitted provided that the following conditions are met:
johnAlexander 0:c523920bcc09 15 * 1. Redistributions of source code must retain the above copyright notice,
johnAlexander 0:c523920bcc09 16 * this list of conditions and the following disclaimer.
johnAlexander 0:c523920bcc09 17 * 2. Redistributions in binary form must reproduce the above copyright notice,
johnAlexander 0:c523920bcc09 18 * this list of conditions and the following disclaimer in the documentation
johnAlexander 0:c523920bcc09 19 * and/or other materials provided with the distribution.
johnAlexander 0:c523920bcc09 20 * 3. Neither the name of STMicroelectronics nor the names of its contributors
johnAlexander 0:c523920bcc09 21 * may be used to endorse or promote products derived from this software
johnAlexander 0:c523920bcc09 22 * without specific prior written permission.
johnAlexander 0:c523920bcc09 23 *
johnAlexander 0:c523920bcc09 24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
johnAlexander 0:c523920bcc09 25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
johnAlexander 0:c523920bcc09 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
johnAlexander 0:c523920bcc09 27 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
johnAlexander 0:c523920bcc09 28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
johnAlexander 0:c523920bcc09 29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
johnAlexander 0:c523920bcc09 30 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
johnAlexander 0:c523920bcc09 31 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
johnAlexander 0:c523920bcc09 32 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
johnAlexander 0:c523920bcc09 33 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
johnAlexander 0:c523920bcc09 34 *
johnAlexander 0:c523920bcc09 35 ******************************************************************************
johnAlexander 0:c523920bcc09 36 */
johnAlexander 14:8320b5ff96fa 37
johnAlexander 0:c523920bcc09 38 /* Includes */
johnAlexander 0:c523920bcc09 39 #include <stdlib.h>
johnAlexander 0:c523920bcc09 40
Davidroid 16:27d3d95c8593 41 #include "VL53L0X.h"
Davidroid 16:27d3d95c8593 42
Davidroid 16:27d3d95c8593 43 //#include "VL53L0X_api_core.h"
Davidroid 16:27d3d95c8593 44 //#include "VL53L0X_api_calibration.h"
Davidroid 16:27d3d95c8593 45 //#include "VL53L0X_api_strings.h"
Davidroid 16:27d3d95c8593 46 #include "VL53L0X_interrupt_threshold_settings.h"
Davidroid 16:27d3d95c8593 47 #include "VL53L0X_tuning.h"
Davidroid 16:27d3d95c8593 48 #include "VL53L0X_types.h"
johnAlexander 0:c523920bcc09 49
johnAlexander 0:c523920bcc09 50
johnAlexander 0:c523920bcc09 51 /****************** define for i2c configuration *******************************/
johnAlexander 14:8320b5ff96fa 52
johnAlexander 0:c523920bcc09 53 #define TEMP_BUF_SIZE 64
johnAlexander 0:c523920bcc09 54
johnAlexander 0:c523920bcc09 55 /** Maximum buffer size to be used in i2c */
johnAlexander 0:c523920bcc09 56 #define VL53L0X_MAX_I2C_XFER_SIZE 64 /* Maximum buffer size to be used in i2c */
johnAlexander 0:c523920bcc09 57 #define VL53L0X_I2C_USER_VAR /* none but could be for a flag var to get/pass to mutex interruptible return flags and try again */
johnAlexander 14:8320b5ff96fa 58
johnAlexander 0:c523920bcc09 59
johnAlexander 0:c523920bcc09 60 #define LOG_FUNCTION_START(fmt, ...) \
johnAlexander 0:c523920bcc09 61 _LOG_FUNCTION_START(TRACE_MODULE_API, fmt, ##__VA_ARGS__)
johnAlexander 0:c523920bcc09 62 #define LOG_FUNCTION_END(status, ...) \
johnAlexander 0:c523920bcc09 63 _LOG_FUNCTION_END(TRACE_MODULE_API, status, ##__VA_ARGS__)
johnAlexander 0:c523920bcc09 64 #define LOG_FUNCTION_END_FMT(status, fmt, ...) \
johnAlexander 0:c523920bcc09 65 _LOG_FUNCTION_END_FMT(TRACE_MODULE_API, status, fmt, ##__VA_ARGS__)
johnAlexander 0:c523920bcc09 66
johnAlexander 0:c523920bcc09 67 #ifdef VL53L0X_LOG_ENABLE
johnAlexander 0:c523920bcc09 68 #define trace_print(level, ...) trace_print_module_function(TRACE_MODULE_API, \
johnAlexander 0:c523920bcc09 69 level, TRACE_FUNCTION_NONE, ##__VA_ARGS__)
johnAlexander 0:c523920bcc09 70 #endif
johnAlexander 0:c523920bcc09 71
johnAlexander 0:c523920bcc09 72 #define REF_ARRAY_SPAD_0 0
johnAlexander 0:c523920bcc09 73 #define REF_ARRAY_SPAD_5 5
johnAlexander 0:c523920bcc09 74 #define REF_ARRAY_SPAD_10 10
johnAlexander 0:c523920bcc09 75
johnAlexander 0:c523920bcc09 76 uint32_t refArrayQuadrants[4] = {REF_ARRAY_SPAD_10, REF_ARRAY_SPAD_5,
johnAlexander 14:8320b5ff96fa 77 REF_ARRAY_SPAD_0, REF_ARRAY_SPAD_5
johnAlexander 14:8320b5ff96fa 78 };
johnAlexander 14:8320b5ff96fa 79
johnAlexander 14:8320b5ff96fa 80
johnAlexander 14:8320b5ff96fa 81
johnAlexander 14:8320b5ff96fa 82
Davidroid 16:27d3d95c8593 83 VL53L0X_Error VL53L0X::VL53L0X_device_read_strobe(VL53L0X_DEV dev)
johnAlexander 0:c523920bcc09 84 {
johnAlexander 14:8320b5ff96fa 85 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 86 uint8_t strobe;
johnAlexander 14:8320b5ff96fa 87 uint32_t loop_nb;
johnAlexander 14:8320b5ff96fa 88 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 89
Davidroid 16:27d3d95c8593 90 status |= VL53L0X_write_byte(dev, 0x83, 0x00);
johnAlexander 14:8320b5ff96fa 91
johnAlexander 14:8320b5ff96fa 92 /* polling
johnAlexander 14:8320b5ff96fa 93 * use timeout to avoid deadlock*/
johnAlexander 14:8320b5ff96fa 94 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 95 loop_nb = 0;
johnAlexander 14:8320b5ff96fa 96 do {
Davidroid 16:27d3d95c8593 97 status = VL53L0X_read_byte(dev, 0x83, &strobe);
Davidroid 16:27d3d95c8593 98 if ((strobe != 0x00) || status != VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 99 break;
Davidroid 16:27d3d95c8593 100 }
johnAlexander 14:8320b5ff96fa 101
johnAlexander 14:8320b5ff96fa 102 loop_nb = loop_nb + 1;
johnAlexander 14:8320b5ff96fa 103 } while (loop_nb < VL53L0X_DEFAULT_MAX_LOOP);
johnAlexander 14:8320b5ff96fa 104
Davidroid 16:27d3d95c8593 105 if (loop_nb >= VL53L0X_DEFAULT_MAX_LOOP) {
johnAlexander 14:8320b5ff96fa 106 status = VL53L0X_ERROR_TIME_OUT;
Davidroid 16:27d3d95c8593 107 }
johnAlexander 14:8320b5ff96fa 108 }
johnAlexander 14:8320b5ff96fa 109
Davidroid 16:27d3d95c8593 110 status |= VL53L0X_write_byte(dev, 0x83, 0x01);
johnAlexander 14:8320b5ff96fa 111
johnAlexander 14:8320b5ff96fa 112 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 113 return status;
johnAlexander 0:c523920bcc09 114 }
johnAlexander 0:c523920bcc09 115
Davidroid 16:27d3d95c8593 116 VL53L0X_Error VL53L0X::VL53L0X_get_info_from_device(VL53L0X_DEV dev, uint8_t option)
johnAlexander 0:c523920bcc09 117 {
johnAlexander 14:8320b5ff96fa 118 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 119 uint8_t byte;
johnAlexander 14:8320b5ff96fa 120 uint32_t tmp_dword;
johnAlexander 14:8320b5ff96fa 121 uint8_t module_id;
johnAlexander 14:8320b5ff96fa 122 uint8_t revision;
johnAlexander 14:8320b5ff96fa 123 uint8_t reference_spad_count = 0;
johnAlexander 14:8320b5ff96fa 124 uint8_t reference_spad_type = 0;
johnAlexander 14:8320b5ff96fa 125 uint32_t part_uid_upper = 0;
johnAlexander 14:8320b5ff96fa 126 uint32_t part_uid_lower = 0;
johnAlexander 14:8320b5ff96fa 127 uint32_t offset_fixed1104_mm = 0;
johnAlexander 14:8320b5ff96fa 128 int16_t offset_micro_meters = 0;
johnAlexander 14:8320b5ff96fa 129 uint32_t dist_meas_tgt_fixed1104_mm = 400 << 4;
johnAlexander 14:8320b5ff96fa 130 uint32_t dist_meas_fixed1104_400_mm = 0;
johnAlexander 14:8320b5ff96fa 131 uint32_t signal_rate_meas_fixed1104_400_mm = 0;
johnAlexander 14:8320b5ff96fa 132 char product_id[19];
johnAlexander 14:8320b5ff96fa 133 char *product_id_tmp;
johnAlexander 14:8320b5ff96fa 134 uint8_t read_data_from_device_done;
johnAlexander 14:8320b5ff96fa 135 FixPoint1616_t signal_rate_meas_fixed400_mm_fix = 0;
johnAlexander 14:8320b5ff96fa 136 uint8_t nvm_ref_good_spad_map[VL53L0X_REF_SPAD_BUFFER_SIZE];
johnAlexander 14:8320b5ff96fa 137 int i;
johnAlexander 14:8320b5ff96fa 138
johnAlexander 14:8320b5ff96fa 139
johnAlexander 14:8320b5ff96fa 140 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 141
johnAlexander 14:8320b5ff96fa 142 read_data_from_device_done = VL53L0X_GETDEVICESPECIFICPARAMETER(dev,
johnAlexander 14:8320b5ff96fa 143 ReadDataFromDeviceDone);
johnAlexander 14:8320b5ff96fa 144
johnAlexander 14:8320b5ff96fa 145 /* This access is done only once after that a GetDeviceInfo or
johnAlexander 14:8320b5ff96fa 146 * datainit is done*/
johnAlexander 14:8320b5ff96fa 147 if (read_data_from_device_done != 7) {
johnAlexander 14:8320b5ff96fa 148
Davidroid 16:27d3d95c8593 149 status |= VL53L0X_write_byte(dev, 0x80, 0x01);
Davidroid 16:27d3d95c8593 150 status |= VL53L0X_write_byte(dev, 0xFF, 0x01);
Davidroid 16:27d3d95c8593 151 status |= VL53L0X_write_byte(dev, 0x00, 0x00);
Davidroid 16:27d3d95c8593 152
Davidroid 16:27d3d95c8593 153 status |= VL53L0X_write_byte(dev, 0xFF, 0x06);
Davidroid 16:27d3d95c8593 154 status |= VL53L0X_read_byte(dev, 0x83, &byte);
Davidroid 16:27d3d95c8593 155 status |= VL53L0X_write_byte(dev, 0x83, byte | 4);
Davidroid 16:27d3d95c8593 156 status |= VL53L0X_write_byte(dev, 0xFF, 0x07);
Davidroid 16:27d3d95c8593 157 status |= VL53L0X_write_byte(dev, 0x81, 0x01);
Davidroid 16:27d3d95c8593 158
Davidroid 16:27d3d95c8593 159 status |= VL53L0X_polling_delay(dev);
Davidroid 16:27d3d95c8593 160
Davidroid 16:27d3d95c8593 161 status |= VL53L0X_write_byte(dev, 0x80, 0x01);
johnAlexander 14:8320b5ff96fa 162
johnAlexander 14:8320b5ff96fa 163 if (((option & 1) == 1) &&
johnAlexander 14:8320b5ff96fa 164 ((read_data_from_device_done & 1) == 0)) {
Davidroid 16:27d3d95c8593 165 status |= VL53L0X_write_byte(dev, 0x94, 0x6b);
Davidroid 16:27d3d95c8593 166 status |= VL53L0X_device_read_strobe(dev);
Davidroid 16:27d3d95c8593 167 status |= VL53L0X_read_dword(dev, 0x90, &tmp_dword);
johnAlexander 14:8320b5ff96fa 168
johnAlexander 14:8320b5ff96fa 169 reference_spad_count = (uint8_t)((tmp_dword >> 8) & 0x07f);
johnAlexander 14:8320b5ff96fa 170 reference_spad_type = (uint8_t)((tmp_dword >> 15) & 0x01);
johnAlexander 14:8320b5ff96fa 171
Davidroid 16:27d3d95c8593 172 status |= VL53L0X_write_byte(dev, 0x94, 0x24);
Davidroid 16:27d3d95c8593 173 status |= VL53L0X_device_read_strobe(dev);
Davidroid 16:27d3d95c8593 174 status |= VL53L0X_read_dword(dev, 0x90, &tmp_dword);
johnAlexander 14:8320b5ff96fa 175
johnAlexander 14:8320b5ff96fa 176
johnAlexander 14:8320b5ff96fa 177 nvm_ref_good_spad_map[0] = (uint8_t)((tmp_dword >> 24)
johnAlexander 14:8320b5ff96fa 178 & 0xff);
johnAlexander 14:8320b5ff96fa 179 nvm_ref_good_spad_map[1] = (uint8_t)((tmp_dword >> 16)
johnAlexander 14:8320b5ff96fa 180 & 0xff);
johnAlexander 14:8320b5ff96fa 181 nvm_ref_good_spad_map[2] = (uint8_t)((tmp_dword >> 8)
johnAlexander 14:8320b5ff96fa 182 & 0xff);
johnAlexander 14:8320b5ff96fa 183 nvm_ref_good_spad_map[3] = (uint8_t)(tmp_dword & 0xff);
johnAlexander 14:8320b5ff96fa 184
Davidroid 16:27d3d95c8593 185 status |= VL53L0X_write_byte(dev, 0x94, 0x25);
Davidroid 16:27d3d95c8593 186 status |= VL53L0X_device_read_strobe(dev);
Davidroid 16:27d3d95c8593 187 status |= VL53L0X_read_dword(dev, 0x90, &tmp_dword);
johnAlexander 14:8320b5ff96fa 188
johnAlexander 14:8320b5ff96fa 189 nvm_ref_good_spad_map[4] = (uint8_t)((tmp_dword >> 24)
johnAlexander 14:8320b5ff96fa 190 & 0xff);
johnAlexander 14:8320b5ff96fa 191 nvm_ref_good_spad_map[5] = (uint8_t)((tmp_dword >> 16)
johnAlexander 14:8320b5ff96fa 192 & 0xff);
johnAlexander 14:8320b5ff96fa 193 }
johnAlexander 14:8320b5ff96fa 194
johnAlexander 14:8320b5ff96fa 195 if (((option & 2) == 2) &&
johnAlexander 14:8320b5ff96fa 196 ((read_data_from_device_done & 2) == 0)) {
johnAlexander 14:8320b5ff96fa 197
Davidroid 16:27d3d95c8593 198 status |= VL53L0X_write_byte(dev, 0x94, 0x02);
Davidroid 16:27d3d95c8593 199 status |= VL53L0X_device_read_strobe(dev);
Davidroid 16:27d3d95c8593 200 status |= VL53L0X_read_byte(dev, 0x90, &module_id);
Davidroid 16:27d3d95c8593 201
Davidroid 16:27d3d95c8593 202 status |= VL53L0X_write_byte(dev, 0x94, 0x7B);
Davidroid 16:27d3d95c8593 203 status |= VL53L0X_device_read_strobe(dev);
Davidroid 16:27d3d95c8593 204 status |= VL53L0X_read_byte(dev, 0x90, &revision);
Davidroid 16:27d3d95c8593 205
Davidroid 16:27d3d95c8593 206 status |= VL53L0X_write_byte(dev, 0x94, 0x77);
Davidroid 16:27d3d95c8593 207 status |= VL53L0X_device_read_strobe(dev);
Davidroid 16:27d3d95c8593 208 status |= VL53L0X_read_dword(dev, 0x90, &tmp_dword);
johnAlexander 14:8320b5ff96fa 209
johnAlexander 14:8320b5ff96fa 210 product_id[0] = (char)((tmp_dword >> 25) & 0x07f);
johnAlexander 14:8320b5ff96fa 211 product_id[1] = (char)((tmp_dword >> 18) & 0x07f);
johnAlexander 14:8320b5ff96fa 212 product_id[2] = (char)((tmp_dword >> 11) & 0x07f);
johnAlexander 14:8320b5ff96fa 213 product_id[3] = (char)((tmp_dword >> 4) & 0x07f);
johnAlexander 14:8320b5ff96fa 214
johnAlexander 14:8320b5ff96fa 215 byte = (uint8_t)((tmp_dword & 0x00f) << 3);
johnAlexander 14:8320b5ff96fa 216
Davidroid 16:27d3d95c8593 217 status |= VL53L0X_write_byte(dev, 0x94, 0x78);
Davidroid 16:27d3d95c8593 218 status |= VL53L0X_device_read_strobe(dev);
Davidroid 16:27d3d95c8593 219 status |= VL53L0X_read_dword(dev, 0x90, &tmp_dword);
johnAlexander 14:8320b5ff96fa 220
johnAlexander 14:8320b5ff96fa 221 product_id[4] = (char)(byte +
johnAlexander 14:8320b5ff96fa 222 ((tmp_dword >> 29) & 0x07f));
johnAlexander 14:8320b5ff96fa 223 product_id[5] = (char)((tmp_dword >> 22) & 0x07f);
johnAlexander 14:8320b5ff96fa 224 product_id[6] = (char)((tmp_dword >> 15) & 0x07f);
johnAlexander 14:8320b5ff96fa 225 product_id[7] = (char)((tmp_dword >> 8) & 0x07f);
johnAlexander 14:8320b5ff96fa 226 product_id[8] = (char)((tmp_dword >> 1) & 0x07f);
johnAlexander 14:8320b5ff96fa 227
johnAlexander 14:8320b5ff96fa 228 byte = (uint8_t)((tmp_dword & 0x001) << 6);
johnAlexander 14:8320b5ff96fa 229
Davidroid 16:27d3d95c8593 230 status |= VL53L0X_write_byte(dev, 0x94, 0x79);
Davidroid 16:27d3d95c8593 231
Davidroid 16:27d3d95c8593 232 status |= VL53L0X_device_read_strobe(dev);
Davidroid 16:27d3d95c8593 233
Davidroid 16:27d3d95c8593 234 status |= VL53L0X_read_dword(dev, 0x90, &tmp_dword);
johnAlexander 14:8320b5ff96fa 235
johnAlexander 14:8320b5ff96fa 236 product_id[9] = (char)(byte +
johnAlexander 14:8320b5ff96fa 237 ((tmp_dword >> 26) & 0x07f));
johnAlexander 14:8320b5ff96fa 238 product_id[10] = (char)((tmp_dword >> 19) & 0x07f);
johnAlexander 14:8320b5ff96fa 239 product_id[11] = (char)((tmp_dword >> 12) & 0x07f);
johnAlexander 14:8320b5ff96fa 240 product_id[12] = (char)((tmp_dword >> 5) & 0x07f);
johnAlexander 14:8320b5ff96fa 241
johnAlexander 14:8320b5ff96fa 242 byte = (uint8_t)((tmp_dword & 0x01f) << 2);
johnAlexander 14:8320b5ff96fa 243
Davidroid 16:27d3d95c8593 244 status |= VL53L0X_write_byte(dev, 0x94, 0x7A);
Davidroid 16:27d3d95c8593 245
Davidroid 16:27d3d95c8593 246 status |= VL53L0X_device_read_strobe(dev);
Davidroid 16:27d3d95c8593 247
Davidroid 16:27d3d95c8593 248 status |= VL53L0X_read_dword(dev, 0x90, &tmp_dword);
johnAlexander 14:8320b5ff96fa 249
johnAlexander 14:8320b5ff96fa 250 product_id[13] = (char)(byte +
johnAlexander 14:8320b5ff96fa 251 ((tmp_dword >> 30) & 0x07f));
johnAlexander 14:8320b5ff96fa 252 product_id[14] = (char)((tmp_dword >> 23) & 0x07f);
johnAlexander 14:8320b5ff96fa 253 product_id[15] = (char)((tmp_dword >> 16) & 0x07f);
johnAlexander 14:8320b5ff96fa 254 product_id[16] = (char)((tmp_dword >> 9) & 0x07f);
johnAlexander 14:8320b5ff96fa 255 product_id[17] = (char)((tmp_dword >> 2) & 0x07f);
johnAlexander 14:8320b5ff96fa 256 product_id[18] = '\0';
johnAlexander 14:8320b5ff96fa 257
johnAlexander 14:8320b5ff96fa 258 }
johnAlexander 14:8320b5ff96fa 259
johnAlexander 14:8320b5ff96fa 260 if (((option & 4) == 4) &&
johnAlexander 14:8320b5ff96fa 261 ((read_data_from_device_done & 4) == 0)) {
johnAlexander 14:8320b5ff96fa 262
Davidroid 16:27d3d95c8593 263 status |= VL53L0X_write_byte(dev, 0x94, 0x7B);
Davidroid 16:27d3d95c8593 264 status |= VL53L0X_device_read_strobe(dev);
Davidroid 16:27d3d95c8593 265 status |= VL53L0X_read_dword(dev, 0x90, &part_uid_upper);
Davidroid 16:27d3d95c8593 266
Davidroid 16:27d3d95c8593 267 status |= VL53L0X_write_byte(dev, 0x94, 0x7C);
Davidroid 16:27d3d95c8593 268 status |= VL53L0X_device_read_strobe(dev);
Davidroid 16:27d3d95c8593 269 status |= VL53L0X_read_dword(dev, 0x90, &part_uid_lower);
Davidroid 16:27d3d95c8593 270
Davidroid 16:27d3d95c8593 271 status |= VL53L0X_write_byte(dev, 0x94, 0x73);
Davidroid 16:27d3d95c8593 272 status |= VL53L0X_device_read_strobe(dev);
Davidroid 16:27d3d95c8593 273 status |= VL53L0X_read_dword(dev, 0x90, &tmp_dword);
johnAlexander 14:8320b5ff96fa 274
johnAlexander 14:8320b5ff96fa 275 signal_rate_meas_fixed1104_400_mm = (tmp_dword &
johnAlexander 14:8320b5ff96fa 276 0x0000000ff) << 8;
johnAlexander 14:8320b5ff96fa 277
Davidroid 16:27d3d95c8593 278 status |= VL53L0X_write_byte(dev, 0x94, 0x74);
Davidroid 16:27d3d95c8593 279 status |= VL53L0X_device_read_strobe(dev);
Davidroid 16:27d3d95c8593 280 status |= VL53L0X_read_dword(dev, 0x90, &tmp_dword);
johnAlexander 14:8320b5ff96fa 281
johnAlexander 14:8320b5ff96fa 282 signal_rate_meas_fixed1104_400_mm |= ((tmp_dword &
johnAlexander 14:8320b5ff96fa 283 0xff000000) >> 24);
johnAlexander 14:8320b5ff96fa 284
Davidroid 16:27d3d95c8593 285 status |= VL53L0X_write_byte(dev, 0x94, 0x75);
Davidroid 16:27d3d95c8593 286 status |= VL53L0X_device_read_strobe(dev);
Davidroid 16:27d3d95c8593 287 status |= VL53L0X_read_dword(dev, 0x90, &tmp_dword);
johnAlexander 14:8320b5ff96fa 288
johnAlexander 14:8320b5ff96fa 289 dist_meas_fixed1104_400_mm = (tmp_dword & 0x0000000ff)
johnAlexander 14:8320b5ff96fa 290 << 8;
johnAlexander 14:8320b5ff96fa 291
Davidroid 16:27d3d95c8593 292 status |= VL53L0X_write_byte(dev, 0x94, 0x76);
Davidroid 16:27d3d95c8593 293 status |= VL53L0X_device_read_strobe(dev);
Davidroid 16:27d3d95c8593 294 status |= VL53L0X_read_dword(dev, 0x90, &tmp_dword);
johnAlexander 14:8320b5ff96fa 295
johnAlexander 14:8320b5ff96fa 296 dist_meas_fixed1104_400_mm |= ((tmp_dword & 0xff000000)
johnAlexander 14:8320b5ff96fa 297 >> 24);
johnAlexander 14:8320b5ff96fa 298 }
johnAlexander 14:8320b5ff96fa 299
Davidroid 16:27d3d95c8593 300 status |= VL53L0X_write_byte(dev, 0x81, 0x00);
Davidroid 16:27d3d95c8593 301 status |= VL53L0X_write_byte(dev, 0xFF, 0x06);
Davidroid 16:27d3d95c8593 302 status |= VL53L0X_read_byte(dev, 0x83, &byte);
Davidroid 16:27d3d95c8593 303 status |= VL53L0X_write_byte(dev, 0x83, byte & 0xfb);
Davidroid 16:27d3d95c8593 304 status |= VL53L0X_write_byte(dev, 0xFF, 0x01);
Davidroid 16:27d3d95c8593 305 status |= VL53L0X_write_byte(dev, 0x00, 0x01);
Davidroid 16:27d3d95c8593 306
Davidroid 16:27d3d95c8593 307 status |= VL53L0X_write_byte(dev, 0xFF, 0x00);
Davidroid 16:27d3d95c8593 308 status |= VL53L0X_write_byte(dev, 0x80, 0x00);
johnAlexander 14:8320b5ff96fa 309 }
johnAlexander 14:8320b5ff96fa 310
johnAlexander 14:8320b5ff96fa 311 if ((status == VL53L0X_ERROR_NONE) &&
johnAlexander 14:8320b5ff96fa 312 (read_data_from_device_done != 7)) {
johnAlexander 14:8320b5ff96fa 313 /* Assign to variable if status is ok */
johnAlexander 14:8320b5ff96fa 314 if (((option & 1) == 1) &&
johnAlexander 14:8320b5ff96fa 315 ((read_data_from_device_done & 1) == 0)) {
johnAlexander 14:8320b5ff96fa 316 VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
johnAlexander 14:8320b5ff96fa 317 ReferenceSpadCount, reference_spad_count);
johnAlexander 14:8320b5ff96fa 318
johnAlexander 14:8320b5ff96fa 319 VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
johnAlexander 14:8320b5ff96fa 320 ReferenceSpadType, reference_spad_type);
johnAlexander 14:8320b5ff96fa 321
johnAlexander 14:8320b5ff96fa 322 for (i = 0; i < VL53L0X_REF_SPAD_BUFFER_SIZE; i++) {
johnAlexander 14:8320b5ff96fa 323 dev->Data.SpadData.RefGoodSpadMap[i] =
johnAlexander 14:8320b5ff96fa 324 nvm_ref_good_spad_map[i];
johnAlexander 14:8320b5ff96fa 325 }
johnAlexander 14:8320b5ff96fa 326 }
johnAlexander 14:8320b5ff96fa 327
johnAlexander 14:8320b5ff96fa 328 if (((option & 2) == 2) &&
johnAlexander 14:8320b5ff96fa 329 ((read_data_from_device_done & 2) == 0)) {
johnAlexander 14:8320b5ff96fa 330 VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
johnAlexander 14:8320b5ff96fa 331 ModuleId, module_id);
johnAlexander 14:8320b5ff96fa 332
johnAlexander 14:8320b5ff96fa 333 VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
johnAlexander 14:8320b5ff96fa 334 Revision, revision);
johnAlexander 14:8320b5ff96fa 335
johnAlexander 14:8320b5ff96fa 336 product_id_tmp = VL53L0X_GETDEVICESPECIFICPARAMETER(dev,
johnAlexander 14:8320b5ff96fa 337 ProductId);
johnAlexander 14:8320b5ff96fa 338 VL53L0X_COPYSTRING(product_id_tmp, product_id);
johnAlexander 14:8320b5ff96fa 339
johnAlexander 14:8320b5ff96fa 340 }
johnAlexander 14:8320b5ff96fa 341
johnAlexander 14:8320b5ff96fa 342 if (((option & 4) == 4) &&
johnAlexander 14:8320b5ff96fa 343 ((read_data_from_device_done & 4) == 0)) {
johnAlexander 14:8320b5ff96fa 344 VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
johnAlexander 14:8320b5ff96fa 345 PartUIDUpper, part_uid_upper);
johnAlexander 14:8320b5ff96fa 346
johnAlexander 14:8320b5ff96fa 347 VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
johnAlexander 14:8320b5ff96fa 348 PartUIDLower, part_uid_lower);
johnAlexander 14:8320b5ff96fa 349
johnAlexander 14:8320b5ff96fa 350 signal_rate_meas_fixed400_mm_fix =
johnAlexander 14:8320b5ff96fa 351 VL53L0X_FIXPOINT97TOFIXPOINT1616(
johnAlexander 14:8320b5ff96fa 352 signal_rate_meas_fixed1104_400_mm);
johnAlexander 14:8320b5ff96fa 353
johnAlexander 14:8320b5ff96fa 354 VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
johnAlexander 14:8320b5ff96fa 355 SignalRateMeasFixed400mm,
johnAlexander 14:8320b5ff96fa 356 signal_rate_meas_fixed400_mm_fix);
johnAlexander 14:8320b5ff96fa 357
johnAlexander 14:8320b5ff96fa 358 offset_micro_meters = 0;
johnAlexander 14:8320b5ff96fa 359 if (dist_meas_fixed1104_400_mm != 0) {
johnAlexander 14:8320b5ff96fa 360 offset_fixed1104_mm =
johnAlexander 14:8320b5ff96fa 361 dist_meas_fixed1104_400_mm -
johnAlexander 14:8320b5ff96fa 362 dist_meas_tgt_fixed1104_mm;
johnAlexander 14:8320b5ff96fa 363 offset_micro_meters = (offset_fixed1104_mm
johnAlexander 14:8320b5ff96fa 364 * 1000) >> 4;
johnAlexander 14:8320b5ff96fa 365 offset_micro_meters *= -1;
johnAlexander 14:8320b5ff96fa 366 }
johnAlexander 14:8320b5ff96fa 367
johnAlexander 14:8320b5ff96fa 368 PALDevDataSet(dev,
johnAlexander 14:8320b5ff96fa 369 Part2PartOffsetAdjustmentNVMMicroMeter,
johnAlexander 14:8320b5ff96fa 370 offset_micro_meters);
johnAlexander 14:8320b5ff96fa 371 }
johnAlexander 14:8320b5ff96fa 372 byte = (uint8_t)(read_data_from_device_done | option);
johnAlexander 14:8320b5ff96fa 373 VL53L0X_SETDEVICESPECIFICPARAMETER(dev, ReadDataFromDeviceDone,
johnAlexander 14:8320b5ff96fa 374 byte);
johnAlexander 14:8320b5ff96fa 375 }
johnAlexander 14:8320b5ff96fa 376
johnAlexander 14:8320b5ff96fa 377 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 378 return status;
johnAlexander 0:c523920bcc09 379 }
johnAlexander 0:c523920bcc09 380
Davidroid 16:27d3d95c8593 381 VL53L0X_Error VL53L0X::wrapped_VL53L0X_get_offset_calibration_data_micro_meter(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 382 int32_t *p_offset_calibration_data_micro_meter)
johnAlexander 0:c523920bcc09 383 {
johnAlexander 14:8320b5ff96fa 384 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 385 uint16_t range_offset_register;
johnAlexander 14:8320b5ff96fa 386 int16_t c_max_offset = 2047;
johnAlexander 14:8320b5ff96fa 387 int16_t c_offset_range = 4096;
johnAlexander 14:8320b5ff96fa 388
johnAlexander 14:8320b5ff96fa 389 /* Note that offset has 10.2 format */
johnAlexander 14:8320b5ff96fa 390
Davidroid 16:27d3d95c8593 391 status = VL53L0X_read_word(dev,
johnAlexander 14:8320b5ff96fa 392 VL53L0X_REG_ALGO_PART_TO_PART_RANGE_OFFSET_MM,
johnAlexander 14:8320b5ff96fa 393 &range_offset_register);
johnAlexander 14:8320b5ff96fa 394
johnAlexander 14:8320b5ff96fa 395 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 396 range_offset_register = (range_offset_register & 0x0fff);
johnAlexander 14:8320b5ff96fa 397
johnAlexander 14:8320b5ff96fa 398 /* Apply 12 bit 2's compliment conversion */
Davidroid 16:27d3d95c8593 399 if (range_offset_register > c_max_offset) {
johnAlexander 14:8320b5ff96fa 400 *p_offset_calibration_data_micro_meter =
johnAlexander 14:8320b5ff96fa 401 (int16_t)(range_offset_register - c_offset_range)
johnAlexander 14:8320b5ff96fa 402 * 250;
Davidroid 16:27d3d95c8593 403 } else {
johnAlexander 14:8320b5ff96fa 404 *p_offset_calibration_data_micro_meter =
johnAlexander 14:8320b5ff96fa 405 (int16_t)range_offset_register * 250;
Davidroid 16:27d3d95c8593 406 }
johnAlexander 14:8320b5ff96fa 407
johnAlexander 14:8320b5ff96fa 408 }
johnAlexander 14:8320b5ff96fa 409
johnAlexander 14:8320b5ff96fa 410 return status;
johnAlexander 0:c523920bcc09 411 }
johnAlexander 0:c523920bcc09 412
Davidroid 16:27d3d95c8593 413 VL53L0X_Error VL53L0X::VL53L0X_get_offset_calibration_data_micro_meter(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 414 int32_t *p_offset_calibration_data_micro_meter)
johnAlexander 0:c523920bcc09 415 {
johnAlexander 14:8320b5ff96fa 416 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 417 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 418
Davidroid 16:27d3d95c8593 419 status = wrapped_VL53L0X_get_offset_calibration_data_micro_meter(dev,
johnAlexander 14:8320b5ff96fa 420 p_offset_calibration_data_micro_meter);
johnAlexander 14:8320b5ff96fa 421
johnAlexander 14:8320b5ff96fa 422 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 423 return status;
johnAlexander 0:c523920bcc09 424 }
johnAlexander 0:c523920bcc09 425
Davidroid 16:27d3d95c8593 426 VL53L0X_Error VL53L0X::wrapped_VL53L0X_set_offset_calibration_data_micro_meter(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 427 int32_t offset_calibration_data_micro_meter)
johnAlexander 0:c523920bcc09 428 {
johnAlexander 14:8320b5ff96fa 429 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 430 int32_t c_max_offset_micro_meter = 511000;
johnAlexander 14:8320b5ff96fa 431 int32_t c_min_offset_micro_meter = -512000;
johnAlexander 14:8320b5ff96fa 432 int16_t c_offset_range = 4096;
johnAlexander 14:8320b5ff96fa 433 uint32_t encoded_offset_val;
johnAlexander 14:8320b5ff96fa 434
johnAlexander 14:8320b5ff96fa 435 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 436
Davidroid 16:27d3d95c8593 437 if (offset_calibration_data_micro_meter > c_max_offset_micro_meter) {
johnAlexander 14:8320b5ff96fa 438 offset_calibration_data_micro_meter = c_max_offset_micro_meter;
Davidroid 16:27d3d95c8593 439 } else {
Davidroid 16:27d3d95c8593 440 if (offset_calibration_data_micro_meter < c_min_offset_micro_meter) {
Davidroid 16:27d3d95c8593 441 offset_calibration_data_micro_meter = c_min_offset_micro_meter;
Davidroid 16:27d3d95c8593 442 }
Davidroid 16:27d3d95c8593 443 }
johnAlexander 14:8320b5ff96fa 444
johnAlexander 14:8320b5ff96fa 445 /* The offset register is 10.2 format and units are mm
johnAlexander 14:8320b5ff96fa 446 * therefore conversion is applied by a division of
johnAlexander 14:8320b5ff96fa 447 * 250.
johnAlexander 14:8320b5ff96fa 448 */
johnAlexander 14:8320b5ff96fa 449 if (offset_calibration_data_micro_meter >= 0) {
johnAlexander 14:8320b5ff96fa 450 encoded_offset_val =
johnAlexander 14:8320b5ff96fa 451 offset_calibration_data_micro_meter / 250;
johnAlexander 14:8320b5ff96fa 452 } else {
johnAlexander 14:8320b5ff96fa 453 encoded_offset_val =
johnAlexander 14:8320b5ff96fa 454 c_offset_range +
johnAlexander 14:8320b5ff96fa 455 offset_calibration_data_micro_meter / 250;
johnAlexander 14:8320b5ff96fa 456 }
johnAlexander 14:8320b5ff96fa 457
Davidroid 16:27d3d95c8593 458 status = VL53L0X_write_word(dev,
johnAlexander 14:8320b5ff96fa 459 VL53L0X_REG_ALGO_PART_TO_PART_RANGE_OFFSET_MM,
johnAlexander 14:8320b5ff96fa 460 encoded_offset_val);
johnAlexander 14:8320b5ff96fa 461
johnAlexander 14:8320b5ff96fa 462 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 463 return status;
johnAlexander 0:c523920bcc09 464 }
johnAlexander 0:c523920bcc09 465
Davidroid 16:27d3d95c8593 466 VL53L0X_Error VL53L0X::VL53L0X_set_offset_calibration_data_micro_meter(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 467 int32_t offset_calibration_data_micro_meter)
johnAlexander 0:c523920bcc09 468 {
johnAlexander 14:8320b5ff96fa 469 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 470 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 471
Davidroid 16:27d3d95c8593 472 status = wrapped_VL53L0X_set_offset_calibration_data_micro_meter(dev,
johnAlexander 14:8320b5ff96fa 473 offset_calibration_data_micro_meter);
johnAlexander 14:8320b5ff96fa 474
johnAlexander 14:8320b5ff96fa 475 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 476 return status;
johnAlexander 0:c523920bcc09 477 }
johnAlexander 0:c523920bcc09 478
Davidroid 16:27d3d95c8593 479 VL53L0X_Error VL53L0X::VL53L0X_apply_offset_adjustment(VL53L0X_DEV dev)
johnAlexander 0:c523920bcc09 480 {
johnAlexander 14:8320b5ff96fa 481 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 482 int32_t corrected_offset_micro_meters;
johnAlexander 14:8320b5ff96fa 483 int32_t current_offset_micro_meters;
johnAlexander 14:8320b5ff96fa 484
johnAlexander 14:8320b5ff96fa 485 /* if we run on this function we can read all the NVM info
johnAlexander 14:8320b5ff96fa 486 * used by the API */
Davidroid 16:27d3d95c8593 487 status = VL53L0X_get_info_from_device(dev, 7);
johnAlexander 14:8320b5ff96fa 488
johnAlexander 14:8320b5ff96fa 489 /* Read back current device offset */
johnAlexander 14:8320b5ff96fa 490 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 491 status = VL53L0X_get_offset_calibration_data_micro_meter(dev,
johnAlexander 14:8320b5ff96fa 492 &current_offset_micro_meters);
johnAlexander 14:8320b5ff96fa 493 }
johnAlexander 14:8320b5ff96fa 494
johnAlexander 14:8320b5ff96fa 495 /* Apply Offset Adjustment derived from 400mm measurements */
johnAlexander 14:8320b5ff96fa 496 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 497
johnAlexander 14:8320b5ff96fa 498 /* Store initial device offset */
johnAlexander 14:8320b5ff96fa 499 PALDevDataSet(dev, Part2PartOffsetNVMMicroMeter,
johnAlexander 14:8320b5ff96fa 500 current_offset_micro_meters);
johnAlexander 14:8320b5ff96fa 501
johnAlexander 14:8320b5ff96fa 502 corrected_offset_micro_meters = current_offset_micro_meters +
johnAlexander 14:8320b5ff96fa 503 (int32_t)PALDevDataGet(dev,
johnAlexander 14:8320b5ff96fa 504 Part2PartOffsetAdjustmentNVMMicroMeter);
johnAlexander 14:8320b5ff96fa 505
Davidroid 16:27d3d95c8593 506 status = VL53L0X_set_offset_calibration_data_micro_meter(dev,
johnAlexander 14:8320b5ff96fa 507 corrected_offset_micro_meters);
johnAlexander 14:8320b5ff96fa 508
johnAlexander 14:8320b5ff96fa 509 /* store current, adjusted offset */
johnAlexander 14:8320b5ff96fa 510 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 511 VL53L0X_SETPARAMETERFIELD(dev, RangeOffsetMicroMeters,
johnAlexander 14:8320b5ff96fa 512 corrected_offset_micro_meters);
johnAlexander 14:8320b5ff96fa 513 }
johnAlexander 14:8320b5ff96fa 514 }
johnAlexander 14:8320b5ff96fa 515
johnAlexander 14:8320b5ff96fa 516 return status;
johnAlexander 0:c523920bcc09 517 }
johnAlexander 0:c523920bcc09 518
Davidroid 16:27d3d95c8593 519 VL53L0X_Error VL53L0X::VL53L0X_get_device_mode(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 520 VL53L0X_DeviceModes *p_device_mode)
johnAlexander 0:c523920bcc09 521 {
johnAlexander 14:8320b5ff96fa 522 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 523 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 524
johnAlexander 14:8320b5ff96fa 525 VL53L0X_GETPARAMETERFIELD(dev, DeviceMode, *p_device_mode);
johnAlexander 14:8320b5ff96fa 526
johnAlexander 14:8320b5ff96fa 527 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 528 return status;
johnAlexander 0:c523920bcc09 529 }
johnAlexander 0:c523920bcc09 530
Davidroid 16:27d3d95c8593 531 VL53L0X_Error VL53L0X::VL53L0X_get_inter_measurement_period_milli_seconds(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 532 uint32_t *p_inter_measurement_period_milli_seconds)
johnAlexander 0:c523920bcc09 533 {
johnAlexander 14:8320b5ff96fa 534 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 535 uint16_t osc_calibrate_val;
johnAlexander 14:8320b5ff96fa 536 uint32_t im_period_milli_seconds;
johnAlexander 14:8320b5ff96fa 537
johnAlexander 14:8320b5ff96fa 538 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 539
Davidroid 16:27d3d95c8593 540 status = VL53L0X_read_word(dev, VL53L0X_REG_OSC_CALIBRATE_VAL,
johnAlexander 14:8320b5ff96fa 541 &osc_calibrate_val);
johnAlexander 14:8320b5ff96fa 542
johnAlexander 14:8320b5ff96fa 543 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 544 status = VL53L0X_read_dword(dev,
johnAlexander 14:8320b5ff96fa 545 VL53L0X_REG_SYSTEM_INTERMEASUREMENT_PERIOD,
johnAlexander 14:8320b5ff96fa 546 &im_period_milli_seconds);
johnAlexander 14:8320b5ff96fa 547 }
johnAlexander 14:8320b5ff96fa 548
johnAlexander 14:8320b5ff96fa 549 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 550 if (osc_calibrate_val != 0) {
johnAlexander 14:8320b5ff96fa 551 *p_inter_measurement_period_milli_seconds =
johnAlexander 14:8320b5ff96fa 552 im_period_milli_seconds / osc_calibrate_val;
johnAlexander 14:8320b5ff96fa 553 }
johnAlexander 14:8320b5ff96fa 554 VL53L0X_SETPARAMETERFIELD(dev,
johnAlexander 14:8320b5ff96fa 555 InterMeasurementPeriodMilliSeconds,
johnAlexander 14:8320b5ff96fa 556 *p_inter_measurement_period_milli_seconds);
johnAlexander 14:8320b5ff96fa 557 }
johnAlexander 14:8320b5ff96fa 558
johnAlexander 14:8320b5ff96fa 559 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 560 return status;
johnAlexander 0:c523920bcc09 561 }
johnAlexander 0:c523920bcc09 562
Davidroid 16:27d3d95c8593 563 VL53L0X_Error VL53L0X::VL53L0X_get_x_talk_compensation_rate_mega_cps(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 564 FixPoint1616_t *p_xtalk_compensation_rate_mega_cps)
johnAlexander 0:c523920bcc09 565 {
johnAlexander 14:8320b5ff96fa 566 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 567 uint16_t value;
johnAlexander 14:8320b5ff96fa 568 FixPoint1616_t temp_fix1616;
johnAlexander 14:8320b5ff96fa 569
johnAlexander 14:8320b5ff96fa 570 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 571
Davidroid 16:27d3d95c8593 572 status = VL53L0X_read_word(dev,
johnAlexander 14:8320b5ff96fa 573 VL53L0X_REG_CROSSTALK_COMPENSATION_PEAK_RATE_MCPS, (uint16_t *)&value);
johnAlexander 14:8320b5ff96fa 574 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 575 if (value == 0) {
johnAlexander 14:8320b5ff96fa 576 /* the Xtalk is disabled return value from memory */
johnAlexander 14:8320b5ff96fa 577 VL53L0X_GETPARAMETERFIELD(dev,
johnAlexander 14:8320b5ff96fa 578 XTalkCompensationRateMegaCps, temp_fix1616);
johnAlexander 14:8320b5ff96fa 579 *p_xtalk_compensation_rate_mega_cps = temp_fix1616;
johnAlexander 14:8320b5ff96fa 580 VL53L0X_SETPARAMETERFIELD(dev, XTalkCompensationEnable,
johnAlexander 14:8320b5ff96fa 581 0);
johnAlexander 14:8320b5ff96fa 582 } else {
johnAlexander 14:8320b5ff96fa 583 temp_fix1616 = VL53L0X_FIXPOINT313TOFIXPOINT1616(value);
johnAlexander 14:8320b5ff96fa 584 *p_xtalk_compensation_rate_mega_cps = temp_fix1616;
johnAlexander 14:8320b5ff96fa 585 VL53L0X_SETPARAMETERFIELD(dev,
johnAlexander 14:8320b5ff96fa 586 XTalkCompensationRateMegaCps, temp_fix1616);
johnAlexander 14:8320b5ff96fa 587 VL53L0X_SETPARAMETERFIELD(dev, XTalkCompensationEnable,
johnAlexander 14:8320b5ff96fa 588 1);
johnAlexander 14:8320b5ff96fa 589 }
johnAlexander 14:8320b5ff96fa 590 }
johnAlexander 14:8320b5ff96fa 591
johnAlexander 14:8320b5ff96fa 592 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 593 return status;
johnAlexander 0:c523920bcc09 594 }
johnAlexander 0:c523920bcc09 595
Davidroid 16:27d3d95c8593 596 VL53L0X_Error VL53L0X::VL53L0X_get_limit_check_value(VL53L0X_DEV dev, uint16_t limit_check_id,
johnAlexander 14:8320b5ff96fa 597 FixPoint1616_t *p_limit_check_value)
johnAlexander 0:c523920bcc09 598 {
johnAlexander 14:8320b5ff96fa 599 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 600 uint8_t enable_zero_value = 0;
johnAlexander 14:8320b5ff96fa 601 uint16_t temp16;
johnAlexander 14:8320b5ff96fa 602 FixPoint1616_t temp_fix1616;
johnAlexander 14:8320b5ff96fa 603
johnAlexander 14:8320b5ff96fa 604 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 605
johnAlexander 14:8320b5ff96fa 606 switch (limit_check_id) {
johnAlexander 14:8320b5ff96fa 607
johnAlexander 14:8320b5ff96fa 608 case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
johnAlexander 14:8320b5ff96fa 609 /* internal computation: */
johnAlexander 14:8320b5ff96fa 610 VL53L0X_GETARRAYPARAMETERFIELD(dev, LimitChecksValue,
johnAlexander 14:8320b5ff96fa 611 VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, temp_fix1616);
johnAlexander 14:8320b5ff96fa 612 enable_zero_value = 0;
johnAlexander 14:8320b5ff96fa 613 break;
johnAlexander 14:8320b5ff96fa 614
johnAlexander 14:8320b5ff96fa 615 case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
Davidroid 16:27d3d95c8593 616 status = VL53L0X_read_word(dev,
johnAlexander 14:8320b5ff96fa 617 VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
johnAlexander 14:8320b5ff96fa 618 &temp16);
johnAlexander 14:8320b5ff96fa 619 if (status == VL53L0X_ERROR_NONE)
johnAlexander 14:8320b5ff96fa 620 temp_fix1616 = VL53L0X_FIXPOINT97TOFIXPOINT1616(temp16);
johnAlexander 14:8320b5ff96fa 621
johnAlexander 14:8320b5ff96fa 622
johnAlexander 14:8320b5ff96fa 623 enable_zero_value = 1;
johnAlexander 14:8320b5ff96fa 624 break;
johnAlexander 14:8320b5ff96fa 625
johnAlexander 14:8320b5ff96fa 626 case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
johnAlexander 14:8320b5ff96fa 627 /* internal computation: */
johnAlexander 14:8320b5ff96fa 628 VL53L0X_GETARRAYPARAMETERFIELD(dev, LimitChecksValue,
johnAlexander 14:8320b5ff96fa 629 VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP, temp_fix1616);
johnAlexander 14:8320b5ff96fa 630 enable_zero_value = 0;
johnAlexander 14:8320b5ff96fa 631 break;
johnAlexander 14:8320b5ff96fa 632
johnAlexander 14:8320b5ff96fa 633 case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
johnAlexander 14:8320b5ff96fa 634 /* internal computation: */
johnAlexander 14:8320b5ff96fa 635 VL53L0X_GETARRAYPARAMETERFIELD(dev, LimitChecksValue,
johnAlexander 14:8320b5ff96fa 636 VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, temp_fix1616);
johnAlexander 14:8320b5ff96fa 637 enable_zero_value = 0;
johnAlexander 14:8320b5ff96fa 638 break;
johnAlexander 14:8320b5ff96fa 639
johnAlexander 14:8320b5ff96fa 640 case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
johnAlexander 14:8320b5ff96fa 641 case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
Davidroid 16:27d3d95c8593 642 status = VL53L0X_read_word(dev,
johnAlexander 14:8320b5ff96fa 643 VL53L0X_REG_PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT,
johnAlexander 14:8320b5ff96fa 644 &temp16);
johnAlexander 14:8320b5ff96fa 645 if (status == VL53L0X_ERROR_NONE)
johnAlexander 14:8320b5ff96fa 646 temp_fix1616 = VL53L0X_FIXPOINT97TOFIXPOINT1616(temp16);
johnAlexander 14:8320b5ff96fa 647
johnAlexander 14:8320b5ff96fa 648
johnAlexander 14:8320b5ff96fa 649 enable_zero_value = 0;
johnAlexander 14:8320b5ff96fa 650 break;
johnAlexander 14:8320b5ff96fa 651
johnAlexander 14:8320b5ff96fa 652 default:
johnAlexander 14:8320b5ff96fa 653 status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander 14:8320b5ff96fa 654
johnAlexander 14:8320b5ff96fa 655 }
johnAlexander 14:8320b5ff96fa 656
johnAlexander 14:8320b5ff96fa 657 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 658
johnAlexander 14:8320b5ff96fa 659 if (enable_zero_value == 1) {
johnAlexander 14:8320b5ff96fa 660
johnAlexander 14:8320b5ff96fa 661 if (temp_fix1616 == 0) {
johnAlexander 14:8320b5ff96fa 662 /* disabled: return value from memory */
johnAlexander 14:8320b5ff96fa 663 VL53L0X_GETARRAYPARAMETERFIELD(dev,
johnAlexander 14:8320b5ff96fa 664 LimitChecksValue, limit_check_id,
johnAlexander 14:8320b5ff96fa 665 temp_fix1616);
johnAlexander 14:8320b5ff96fa 666 *p_limit_check_value = temp_fix1616;
johnAlexander 14:8320b5ff96fa 667 VL53L0X_SETARRAYPARAMETERFIELD(dev,
johnAlexander 14:8320b5ff96fa 668 LimitChecksEnable, limit_check_id, 0);
johnAlexander 14:8320b5ff96fa 669 } else {
johnAlexander 14:8320b5ff96fa 670 *p_limit_check_value = temp_fix1616;
johnAlexander 14:8320b5ff96fa 671 VL53L0X_SETARRAYPARAMETERFIELD(dev,
johnAlexander 14:8320b5ff96fa 672 LimitChecksValue, limit_check_id,
johnAlexander 14:8320b5ff96fa 673 temp_fix1616);
johnAlexander 14:8320b5ff96fa 674 VL53L0X_SETARRAYPARAMETERFIELD(dev,
johnAlexander 14:8320b5ff96fa 675 LimitChecksEnable, limit_check_id, 1);
johnAlexander 14:8320b5ff96fa 676 }
johnAlexander 14:8320b5ff96fa 677 } else {
johnAlexander 14:8320b5ff96fa 678 *p_limit_check_value = temp_fix1616;
johnAlexander 14:8320b5ff96fa 679 }
johnAlexander 14:8320b5ff96fa 680 }
johnAlexander 14:8320b5ff96fa 681
johnAlexander 14:8320b5ff96fa 682 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 683 return status;
johnAlexander 0:c523920bcc09 684
johnAlexander 0:c523920bcc09 685 }
johnAlexander 0:c523920bcc09 686
Davidroid 16:27d3d95c8593 687 VL53L0X_Error VL53L0X::VL53L0X_get_limit_check_enable(VL53L0X_DEV dev, uint16_t limit_check_id,
johnAlexander 14:8320b5ff96fa 688 uint8_t *p_limit_check_enable)
johnAlexander 0:c523920bcc09 689 {
johnAlexander 14:8320b5ff96fa 690 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 691 uint8_t temp8;
johnAlexander 14:8320b5ff96fa 692
johnAlexander 14:8320b5ff96fa 693 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 694
johnAlexander 14:8320b5ff96fa 695 if (limit_check_id >= VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS) {
johnAlexander 14:8320b5ff96fa 696 status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander 14:8320b5ff96fa 697 *p_limit_check_enable = 0;
johnAlexander 14:8320b5ff96fa 698 } else {
johnAlexander 14:8320b5ff96fa 699 VL53L0X_GETARRAYPARAMETERFIELD(dev, LimitChecksEnable,
johnAlexander 14:8320b5ff96fa 700 limit_check_id, temp8);
johnAlexander 14:8320b5ff96fa 701 *p_limit_check_enable = temp8;
johnAlexander 14:8320b5ff96fa 702 }
johnAlexander 14:8320b5ff96fa 703
johnAlexander 14:8320b5ff96fa 704 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 705 return status;
johnAlexander 0:c523920bcc09 706 }
johnAlexander 0:c523920bcc09 707
Davidroid 16:27d3d95c8593 708 VL53L0X_Error VL53L0X::VL53L0X_get_wrap_around_check_enable(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 709 uint8_t *p_wrap_around_check_enable)
johnAlexander 0:c523920bcc09 710 {
johnAlexander 14:8320b5ff96fa 711 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 712 uint8_t data;
johnAlexander 14:8320b5ff96fa 713
johnAlexander 14:8320b5ff96fa 714 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 715
Davidroid 16:27d3d95c8593 716 status = VL53L0X_read_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &data);
johnAlexander 14:8320b5ff96fa 717 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 718 PALDevDataSet(dev, SequenceConfig, data);
johnAlexander 14:8320b5ff96fa 719 if (data & (0x01 << 7))
johnAlexander 14:8320b5ff96fa 720 *p_wrap_around_check_enable = 0x01;
johnAlexander 14:8320b5ff96fa 721 else
johnAlexander 14:8320b5ff96fa 722 *p_wrap_around_check_enable = 0x00;
johnAlexander 14:8320b5ff96fa 723 }
johnAlexander 14:8320b5ff96fa 724 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 725 VL53L0X_SETPARAMETERFIELD(dev, WrapAroundCheckEnable,
johnAlexander 14:8320b5ff96fa 726 *p_wrap_around_check_enable);
johnAlexander 14:8320b5ff96fa 727 }
johnAlexander 14:8320b5ff96fa 728
johnAlexander 14:8320b5ff96fa 729 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 730 return status;
johnAlexander 0:c523920bcc09 731 }
johnAlexander 0:c523920bcc09 732
johnAlexander 14:8320b5ff96fa 733 VL53L0X_Error VL53L0X::sequence_step_enabled(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 734 VL53L0X_SequenceStepId sequence_step_id, uint8_t sequence_config,
johnAlexander 14:8320b5ff96fa 735 uint8_t *p_sequence_step_enabled)
johnAlexander 0:c523920bcc09 736 {
johnAlexander 14:8320b5ff96fa 737 VL53L0X_Error Status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 738 *p_sequence_step_enabled = 0;
johnAlexander 14:8320b5ff96fa 739 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 740
johnAlexander 14:8320b5ff96fa 741 switch (sequence_step_id) {
johnAlexander 14:8320b5ff96fa 742 case VL53L0X_SEQUENCESTEP_TCC:
johnAlexander 14:8320b5ff96fa 743 *p_sequence_step_enabled = (sequence_config & 0x10) >> 4;
johnAlexander 14:8320b5ff96fa 744 break;
johnAlexander 14:8320b5ff96fa 745 case VL53L0X_SEQUENCESTEP_DSS:
johnAlexander 14:8320b5ff96fa 746 *p_sequence_step_enabled = (sequence_config & 0x08) >> 3;
johnAlexander 14:8320b5ff96fa 747 break;
johnAlexander 14:8320b5ff96fa 748 case VL53L0X_SEQUENCESTEP_MSRC:
johnAlexander 14:8320b5ff96fa 749 *p_sequence_step_enabled = (sequence_config & 0x04) >> 2;
johnAlexander 14:8320b5ff96fa 750 break;
johnAlexander 14:8320b5ff96fa 751 case VL53L0X_SEQUENCESTEP_PRE_RANGE:
johnAlexander 14:8320b5ff96fa 752 *p_sequence_step_enabled = (sequence_config & 0x40) >> 6;
johnAlexander 14:8320b5ff96fa 753 break;
johnAlexander 14:8320b5ff96fa 754 case VL53L0X_SEQUENCESTEP_FINAL_RANGE:
johnAlexander 14:8320b5ff96fa 755 *p_sequence_step_enabled = (sequence_config & 0x80) >> 7;
johnAlexander 14:8320b5ff96fa 756 break;
johnAlexander 14:8320b5ff96fa 757 default:
johnAlexander 14:8320b5ff96fa 758 Status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander 14:8320b5ff96fa 759 }
johnAlexander 14:8320b5ff96fa 760
johnAlexander 14:8320b5ff96fa 761 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 762 return Status;
johnAlexander 0:c523920bcc09 763 }
johnAlexander 0:c523920bcc09 764
Davidroid 16:27d3d95c8593 765 VL53L0X_Error VL53L0X::VL53L0X_get_sequence_step_enables(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 766 VL53L0X_SchedulerSequenceSteps_t *p_scheduler_sequence_steps)
johnAlexander 0:c523920bcc09 767 {
johnAlexander 14:8320b5ff96fa 768 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 769 uint8_t sequence_config = 0;
johnAlexander 14:8320b5ff96fa 770 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 771
Davidroid 16:27d3d95c8593 772 status = VL53L0X_read_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
johnAlexander 14:8320b5ff96fa 773 &sequence_config);
johnAlexander 14:8320b5ff96fa 774
johnAlexander 14:8320b5ff96fa 775 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 776 status = sequence_step_enabled(dev,
johnAlexander 14:8320b5ff96fa 777 VL53L0X_SEQUENCESTEP_TCC, sequence_config,
johnAlexander 14:8320b5ff96fa 778 &p_scheduler_sequence_steps->TccOn);
johnAlexander 14:8320b5ff96fa 779 }
johnAlexander 14:8320b5ff96fa 780 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 781 status = sequence_step_enabled(dev,
johnAlexander 14:8320b5ff96fa 782 VL53L0X_SEQUENCESTEP_DSS, sequence_config,
johnAlexander 14:8320b5ff96fa 783 &p_scheduler_sequence_steps->DssOn);
johnAlexander 14:8320b5ff96fa 784 }
johnAlexander 14:8320b5ff96fa 785 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 786 status = sequence_step_enabled(dev,
johnAlexander 14:8320b5ff96fa 787 VL53L0X_SEQUENCESTEP_MSRC, sequence_config,
johnAlexander 14:8320b5ff96fa 788 &p_scheduler_sequence_steps->MsrcOn);
johnAlexander 14:8320b5ff96fa 789 }
johnAlexander 14:8320b5ff96fa 790 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 791 status = sequence_step_enabled(dev,
johnAlexander 14:8320b5ff96fa 792 VL53L0X_SEQUENCESTEP_PRE_RANGE, sequence_config,
johnAlexander 14:8320b5ff96fa 793 &p_scheduler_sequence_steps->PreRangeOn);
johnAlexander 14:8320b5ff96fa 794 }
johnAlexander 14:8320b5ff96fa 795 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 796 status = sequence_step_enabled(dev,
johnAlexander 14:8320b5ff96fa 797 VL53L0X_SEQUENCESTEP_FINAL_RANGE, sequence_config,
johnAlexander 14:8320b5ff96fa 798 &p_scheduler_sequence_steps->FinalRangeOn);
johnAlexander 14:8320b5ff96fa 799 }
johnAlexander 14:8320b5ff96fa 800
johnAlexander 14:8320b5ff96fa 801 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 802 return status;
johnAlexander 0:c523920bcc09 803 }
johnAlexander 0:c523920bcc09 804
Davidroid 16:27d3d95c8593 805 uint8_t VL53L0X::VL53L0X_decode_vcsel_period(uint8_t vcsel_period_reg)
johnAlexander 0:c523920bcc09 806 {
johnAlexander 14:8320b5ff96fa 807 /*!
johnAlexander 14:8320b5ff96fa 808 * Converts the encoded VCSEL period register value into the real
johnAlexander 14:8320b5ff96fa 809 * period in PLL clocks
johnAlexander 14:8320b5ff96fa 810 */
johnAlexander 14:8320b5ff96fa 811
johnAlexander 14:8320b5ff96fa 812 uint8_t vcsel_period_pclks = 0;
johnAlexander 14:8320b5ff96fa 813
johnAlexander 14:8320b5ff96fa 814 vcsel_period_pclks = (vcsel_period_reg + 1) << 1;
johnAlexander 14:8320b5ff96fa 815
johnAlexander 14:8320b5ff96fa 816 return vcsel_period_pclks;
johnAlexander 0:c523920bcc09 817 }
johnAlexander 0:c523920bcc09 818
johnAlexander 14:8320b5ff96fa 819 uint8_t VL53L0X::lv53l0x_encode_vcsel_period(uint8_t vcsel_period_pclks)
johnAlexander 0:c523920bcc09 820 {
johnAlexander 14:8320b5ff96fa 821 /*!
johnAlexander 14:8320b5ff96fa 822 * Converts the encoded VCSEL period register value into the real period
johnAlexander 14:8320b5ff96fa 823 * in PLL clocks
johnAlexander 14:8320b5ff96fa 824 */
johnAlexander 14:8320b5ff96fa 825
johnAlexander 14:8320b5ff96fa 826 uint8_t vcsel_period_reg = 0;
johnAlexander 14:8320b5ff96fa 827
johnAlexander 14:8320b5ff96fa 828 vcsel_period_reg = (vcsel_period_pclks >> 1) - 1;
johnAlexander 14:8320b5ff96fa 829
johnAlexander 14:8320b5ff96fa 830 return vcsel_period_reg;
johnAlexander 0:c523920bcc09 831 }
johnAlexander 0:c523920bcc09 832
johnAlexander 0:c523920bcc09 833
Davidroid 16:27d3d95c8593 834 VL53L0X_Error VL53L0X::wrapped_VL53L0X_set_vcsel_pulse_period(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 835 VL53L0X_VcselPeriod vcsel_period_type, uint8_t vcsel_pulse_period_pclk)
johnAlexander 0:c523920bcc09 836 {
johnAlexander 14:8320b5ff96fa 837 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 838 uint8_t vcsel_period_reg;
johnAlexander 14:8320b5ff96fa 839 uint8_t min_pre_vcsel_period_pclk = 12;
johnAlexander 14:8320b5ff96fa 840 uint8_t max_pre_vcsel_period_pclk = 18;
johnAlexander 14:8320b5ff96fa 841 uint8_t min_final_vcsel_period_pclk = 8;
johnAlexander 14:8320b5ff96fa 842 uint8_t max_final_vcsel_period_pclk = 14;
johnAlexander 14:8320b5ff96fa 843 uint32_t measurement_timing_budget_micro_seconds;
johnAlexander 14:8320b5ff96fa 844 uint32_t final_range_timeout_micro_seconds;
johnAlexander 14:8320b5ff96fa 845 uint32_t pre_range_timeout_micro_seconds;
johnAlexander 14:8320b5ff96fa 846 uint32_t msrc_timeout_micro_seconds;
johnAlexander 14:8320b5ff96fa 847 uint8_t phase_cal_int = 0;
johnAlexander 14:8320b5ff96fa 848
johnAlexander 14:8320b5ff96fa 849 /* Check if valid clock period requested */
johnAlexander 14:8320b5ff96fa 850
johnAlexander 14:8320b5ff96fa 851 if ((vcsel_pulse_period_pclk % 2) != 0) {
johnAlexander 14:8320b5ff96fa 852 /* Value must be an even number */
johnAlexander 14:8320b5ff96fa 853 status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander 14:8320b5ff96fa 854 } else if (vcsel_period_type == VL53L0X_VCSEL_PERIOD_PRE_RANGE &&
johnAlexander 14:8320b5ff96fa 855 (vcsel_pulse_period_pclk < min_pre_vcsel_period_pclk ||
johnAlexander 14:8320b5ff96fa 856 vcsel_pulse_period_pclk > max_pre_vcsel_period_pclk)) {
johnAlexander 14:8320b5ff96fa 857 status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander 14:8320b5ff96fa 858 } else if (vcsel_period_type == VL53L0X_VCSEL_PERIOD_FINAL_RANGE &&
johnAlexander 14:8320b5ff96fa 859 (vcsel_pulse_period_pclk < min_final_vcsel_period_pclk ||
johnAlexander 14:8320b5ff96fa 860 vcsel_pulse_period_pclk > max_final_vcsel_period_pclk)) {
johnAlexander 14:8320b5ff96fa 861
johnAlexander 14:8320b5ff96fa 862 status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander 14:8320b5ff96fa 863 }
johnAlexander 14:8320b5ff96fa 864
johnAlexander 14:8320b5ff96fa 865 /* Apply specific settings for the requested clock period */
johnAlexander 14:8320b5ff96fa 866
johnAlexander 14:8320b5ff96fa 867 if (status != VL53L0X_ERROR_NONE)
johnAlexander 14:8320b5ff96fa 868 return status;
johnAlexander 14:8320b5ff96fa 869
johnAlexander 14:8320b5ff96fa 870
johnAlexander 14:8320b5ff96fa 871 if (vcsel_period_type == VL53L0X_VCSEL_PERIOD_PRE_RANGE) {
johnAlexander 14:8320b5ff96fa 872
johnAlexander 14:8320b5ff96fa 873 /* Set phase check limits */
johnAlexander 14:8320b5ff96fa 874 if (vcsel_pulse_period_pclk == 12) {
johnAlexander 14:8320b5ff96fa 875
Davidroid 16:27d3d95c8593 876 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 877 VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
johnAlexander 14:8320b5ff96fa 878 0x18);
Davidroid 16:27d3d95c8593 879 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 880 VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
johnAlexander 14:8320b5ff96fa 881 0x08);
johnAlexander 14:8320b5ff96fa 882 } else if (vcsel_pulse_period_pclk == 14) {
johnAlexander 14:8320b5ff96fa 883
Davidroid 16:27d3d95c8593 884 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 885 VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
johnAlexander 14:8320b5ff96fa 886 0x30);
Davidroid 16:27d3d95c8593 887 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 888 VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
johnAlexander 14:8320b5ff96fa 889 0x08);
johnAlexander 14:8320b5ff96fa 890 } else if (vcsel_pulse_period_pclk == 16) {
johnAlexander 14:8320b5ff96fa 891
Davidroid 16:27d3d95c8593 892 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 893 VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
johnAlexander 14:8320b5ff96fa 894 0x40);
Davidroid 16:27d3d95c8593 895 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 896 VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
johnAlexander 14:8320b5ff96fa 897 0x08);
johnAlexander 14:8320b5ff96fa 898 } else if (vcsel_pulse_period_pclk == 18) {
johnAlexander 14:8320b5ff96fa 899
Davidroid 16:27d3d95c8593 900 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 901 VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
johnAlexander 14:8320b5ff96fa 902 0x50);
Davidroid 16:27d3d95c8593 903 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 904 VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
johnAlexander 14:8320b5ff96fa 905 0x08);
johnAlexander 14:8320b5ff96fa 906 }
johnAlexander 14:8320b5ff96fa 907 } else if (vcsel_period_type == VL53L0X_VCSEL_PERIOD_FINAL_RANGE) {
johnAlexander 14:8320b5ff96fa 908
johnAlexander 14:8320b5ff96fa 909 if (vcsel_pulse_period_pclk == 8) {
johnAlexander 14:8320b5ff96fa 910
Davidroid 16:27d3d95c8593 911 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 912 VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
johnAlexander 14:8320b5ff96fa 913 0x10);
Davidroid 16:27d3d95c8593 914 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 915 VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,
johnAlexander 14:8320b5ff96fa 916 0x08);
johnAlexander 14:8320b5ff96fa 917
Davidroid 16:27d3d95c8593 918 status |= VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 919 VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x02);
Davidroid 16:27d3d95c8593 920 status |= VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 921 VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x0C);
johnAlexander 14:8320b5ff96fa 922
Davidroid 16:27d3d95c8593 923 status |= VL53L0X_write_byte(dev, 0xff, 0x01);
Davidroid 16:27d3d95c8593 924 status |= VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 925 VL53L0X_REG_ALGO_PHASECAL_LIM,
johnAlexander 14:8320b5ff96fa 926 0x30);
Davidroid 16:27d3d95c8593 927 status |= VL53L0X_write_byte(dev, 0xff, 0x00);
johnAlexander 14:8320b5ff96fa 928 } else if (vcsel_pulse_period_pclk == 10) {
johnAlexander 14:8320b5ff96fa 929
Davidroid 16:27d3d95c8593 930 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 931 VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
johnAlexander 14:8320b5ff96fa 932 0x28);
Davidroid 16:27d3d95c8593 933 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 934 VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,
johnAlexander 14:8320b5ff96fa 935 0x08);
johnAlexander 14:8320b5ff96fa 936
Davidroid 16:27d3d95c8593 937 status |= VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 938 VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x03);
Davidroid 16:27d3d95c8593 939 status |= VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 940 VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x09);
johnAlexander 14:8320b5ff96fa 941
Davidroid 16:27d3d95c8593 942 status |= VL53L0X_write_byte(dev, 0xff, 0x01);
Davidroid 16:27d3d95c8593 943 status |= VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 944 VL53L0X_REG_ALGO_PHASECAL_LIM,
johnAlexander 14:8320b5ff96fa 945 0x20);
Davidroid 16:27d3d95c8593 946 status |= VL53L0X_write_byte(dev, 0xff, 0x00);
johnAlexander 14:8320b5ff96fa 947 } else if (vcsel_pulse_period_pclk == 12) {
johnAlexander 14:8320b5ff96fa 948
Davidroid 16:27d3d95c8593 949 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 950 VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
johnAlexander 14:8320b5ff96fa 951 0x38);
Davidroid 16:27d3d95c8593 952 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 953 VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,
johnAlexander 14:8320b5ff96fa 954 0x08);
johnAlexander 14:8320b5ff96fa 955
Davidroid 16:27d3d95c8593 956 status |= VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 957 VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x03);
Davidroid 16:27d3d95c8593 958 status |= VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 959 VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x08);
johnAlexander 14:8320b5ff96fa 960
Davidroid 16:27d3d95c8593 961 status |= VL53L0X_write_byte(dev, 0xff, 0x01);
Davidroid 16:27d3d95c8593 962 status |= VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 963 VL53L0X_REG_ALGO_PHASECAL_LIM,
johnAlexander 14:8320b5ff96fa 964 0x20);
Davidroid 16:27d3d95c8593 965 status |= VL53L0X_write_byte(dev, 0xff, 0x00);
johnAlexander 14:8320b5ff96fa 966 } else if (vcsel_pulse_period_pclk == 14) {
johnAlexander 14:8320b5ff96fa 967
Davidroid 16:27d3d95c8593 968 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 969 VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
johnAlexander 14:8320b5ff96fa 970 0x048);
Davidroid 16:27d3d95c8593 971 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 972 VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,
johnAlexander 14:8320b5ff96fa 973 0x08);
johnAlexander 14:8320b5ff96fa 974
Davidroid 16:27d3d95c8593 975 status |= VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 976 VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x03);
Davidroid 16:27d3d95c8593 977 status |= VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 978 VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x07);
johnAlexander 14:8320b5ff96fa 979
Davidroid 16:27d3d95c8593 980 status |= VL53L0X_write_byte(dev, 0xff, 0x01);
Davidroid 16:27d3d95c8593 981 status |= VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 982 VL53L0X_REG_ALGO_PHASECAL_LIM,
johnAlexander 14:8320b5ff96fa 983 0x20);
Davidroid 16:27d3d95c8593 984 status |= VL53L0X_write_byte(dev, 0xff, 0x00);
johnAlexander 14:8320b5ff96fa 985 }
johnAlexander 14:8320b5ff96fa 986 }
johnAlexander 14:8320b5ff96fa 987
johnAlexander 14:8320b5ff96fa 988
johnAlexander 14:8320b5ff96fa 989 /* Re-calculate and apply timeouts, in macro periods */
johnAlexander 14:8320b5ff96fa 990
johnAlexander 14:8320b5ff96fa 991 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 992 vcsel_period_reg = lv53l0x_encode_vcsel_period((uint8_t)
johnAlexander 14:8320b5ff96fa 993 vcsel_pulse_period_pclk);
johnAlexander 14:8320b5ff96fa 994
johnAlexander 14:8320b5ff96fa 995 /* When the VCSEL period for the pre or final range is changed,
johnAlexander 14:8320b5ff96fa 996 * the corresponding timeout must be read from the device using
johnAlexander 14:8320b5ff96fa 997 * the current VCSEL period, then the new VCSEL period can be
johnAlexander 14:8320b5ff96fa 998 * applied. The timeout then must be written back to the device
johnAlexander 14:8320b5ff96fa 999 * using the new VCSEL period.
johnAlexander 14:8320b5ff96fa 1000 *
johnAlexander 14:8320b5ff96fa 1001 * For the MSRC timeout, the same applies - this timeout being
johnAlexander 14:8320b5ff96fa 1002 * dependant on the pre-range vcsel period.
johnAlexander 14:8320b5ff96fa 1003 */
johnAlexander 14:8320b5ff96fa 1004 switch (vcsel_period_type) {
johnAlexander 14:8320b5ff96fa 1005 case VL53L0X_VCSEL_PERIOD_PRE_RANGE:
johnAlexander 14:8320b5ff96fa 1006 status = get_sequence_step_timeout(dev,
johnAlexander 14:8320b5ff96fa 1007 VL53L0X_SEQUENCESTEP_PRE_RANGE,
johnAlexander 14:8320b5ff96fa 1008 &pre_range_timeout_micro_seconds);
johnAlexander 14:8320b5ff96fa 1009
johnAlexander 14:8320b5ff96fa 1010 if (status == VL53L0X_ERROR_NONE)
johnAlexander 14:8320b5ff96fa 1011 status = get_sequence_step_timeout(dev,
johnAlexander 14:8320b5ff96fa 1012 VL53L0X_SEQUENCESTEP_MSRC,
johnAlexander 14:8320b5ff96fa 1013 &msrc_timeout_micro_seconds);
johnAlexander 14:8320b5ff96fa 1014
johnAlexander 14:8320b5ff96fa 1015 if (status == VL53L0X_ERROR_NONE)
Davidroid 16:27d3d95c8593 1016 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 1017 VL53L0X_REG_PRE_RANGE_CONFIG_VCSEL_PERIOD,
johnAlexander 14:8320b5ff96fa 1018 vcsel_period_reg);
johnAlexander 14:8320b5ff96fa 1019
johnAlexander 14:8320b5ff96fa 1020
johnAlexander 14:8320b5ff96fa 1021 if (status == VL53L0X_ERROR_NONE)
johnAlexander 14:8320b5ff96fa 1022 status = set_sequence_step_timeout(dev,
johnAlexander 14:8320b5ff96fa 1023 VL53L0X_SEQUENCESTEP_PRE_RANGE,
johnAlexander 14:8320b5ff96fa 1024 pre_range_timeout_micro_seconds);
johnAlexander 14:8320b5ff96fa 1025
johnAlexander 14:8320b5ff96fa 1026
johnAlexander 14:8320b5ff96fa 1027 if (status == VL53L0X_ERROR_NONE)
johnAlexander 14:8320b5ff96fa 1028 status = set_sequence_step_timeout(dev,
johnAlexander 14:8320b5ff96fa 1029 VL53L0X_SEQUENCESTEP_MSRC,
johnAlexander 14:8320b5ff96fa 1030 msrc_timeout_micro_seconds);
johnAlexander 14:8320b5ff96fa 1031
johnAlexander 14:8320b5ff96fa 1032 VL53L0X_SETDEVICESPECIFICPARAMETER(
johnAlexander 14:8320b5ff96fa 1033 dev,
johnAlexander 14:8320b5ff96fa 1034 PreRangeVcselPulsePeriod,
johnAlexander 14:8320b5ff96fa 1035 vcsel_pulse_period_pclk);
johnAlexander 14:8320b5ff96fa 1036 break;
johnAlexander 14:8320b5ff96fa 1037 case VL53L0X_VCSEL_PERIOD_FINAL_RANGE:
johnAlexander 14:8320b5ff96fa 1038 status = get_sequence_step_timeout(dev,
johnAlexander 14:8320b5ff96fa 1039 VL53L0X_SEQUENCESTEP_FINAL_RANGE,
johnAlexander 14:8320b5ff96fa 1040 &final_range_timeout_micro_seconds);
johnAlexander 14:8320b5ff96fa 1041
johnAlexander 14:8320b5ff96fa 1042 if (status == VL53L0X_ERROR_NONE)
Davidroid 16:27d3d95c8593 1043 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 1044 VL53L0X_REG_FINAL_RANGE_CONFIG_VCSEL_PERIOD,
johnAlexander 14:8320b5ff96fa 1045 vcsel_period_reg);
johnAlexander 14:8320b5ff96fa 1046
johnAlexander 14:8320b5ff96fa 1047
johnAlexander 14:8320b5ff96fa 1048 if (status == VL53L0X_ERROR_NONE)
johnAlexander 14:8320b5ff96fa 1049 status = set_sequence_step_timeout(dev,
johnAlexander 14:8320b5ff96fa 1050 VL53L0X_SEQUENCESTEP_FINAL_RANGE,
johnAlexander 14:8320b5ff96fa 1051 final_range_timeout_micro_seconds);
johnAlexander 14:8320b5ff96fa 1052
johnAlexander 14:8320b5ff96fa 1053 VL53L0X_SETDEVICESPECIFICPARAMETER(
johnAlexander 14:8320b5ff96fa 1054 dev,
johnAlexander 14:8320b5ff96fa 1055 FinalRangeVcselPulsePeriod,
johnAlexander 14:8320b5ff96fa 1056 vcsel_pulse_period_pclk);
johnAlexander 14:8320b5ff96fa 1057 break;
johnAlexander 14:8320b5ff96fa 1058 default:
johnAlexander 14:8320b5ff96fa 1059 status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander 14:8320b5ff96fa 1060 }
johnAlexander 14:8320b5ff96fa 1061 }
johnAlexander 14:8320b5ff96fa 1062
johnAlexander 14:8320b5ff96fa 1063 /* Finally, the timing budget must be re-applied */
johnAlexander 14:8320b5ff96fa 1064 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 1065 VL53L0X_GETPARAMETERFIELD(dev,
johnAlexander 14:8320b5ff96fa 1066 MeasurementTimingBudgetMicroSeconds,
johnAlexander 14:8320b5ff96fa 1067 measurement_timing_budget_micro_seconds);
johnAlexander 14:8320b5ff96fa 1068
Davidroid 16:27d3d95c8593 1069 status = VL53L0X_set_measurement_timing_budget_micro_seconds(dev,
johnAlexander 14:8320b5ff96fa 1070 measurement_timing_budget_micro_seconds);
johnAlexander 14:8320b5ff96fa 1071 }
johnAlexander 14:8320b5ff96fa 1072
johnAlexander 14:8320b5ff96fa 1073 /* Perform the phase calibration. This is needed after changing on
johnAlexander 14:8320b5ff96fa 1074 * vcsel period.
johnAlexander 14:8320b5ff96fa 1075 * get_data_enable = 0, restore_config = 1 */
johnAlexander 14:8320b5ff96fa 1076 if (status == VL53L0X_ERROR_NONE)
Davidroid 16:27d3d95c8593 1077 status = VL53L0X_perform_phase_calibration(
johnAlexander 14:8320b5ff96fa 1078 dev, &phase_cal_int, 0, 1);
johnAlexander 14:8320b5ff96fa 1079
johnAlexander 14:8320b5ff96fa 1080 return status;
johnAlexander 0:c523920bcc09 1081 }
johnAlexander 0:c523920bcc09 1082
Davidroid 16:27d3d95c8593 1083 VL53L0X_Error VL53L0X::VL53L0X_set_vcsel_pulse_period(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 1084 VL53L0X_VcselPeriod vcsel_period_type, uint8_t vcsel_pulse_period)
johnAlexander 0:c523920bcc09 1085 {
johnAlexander 14:8320b5ff96fa 1086 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 1087 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 1088
Davidroid 16:27d3d95c8593 1089 status = wrapped_VL53L0X_set_vcsel_pulse_period(dev, vcsel_period_type,
johnAlexander 14:8320b5ff96fa 1090 vcsel_pulse_period);
johnAlexander 14:8320b5ff96fa 1091
johnAlexander 14:8320b5ff96fa 1092 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 1093 return status;
johnAlexander 0:c523920bcc09 1094 }
johnAlexander 0:c523920bcc09 1095
Davidroid 16:27d3d95c8593 1096 VL53L0X_Error VL53L0X::wrapped_VL53L0X_get_vcsel_pulse_period(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 1097 VL53L0X_VcselPeriod vcsel_period_type, uint8_t *p_vcsel_pulse_period_pclk)
johnAlexander 0:c523920bcc09 1098 {
johnAlexander 14:8320b5ff96fa 1099 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 1100 uint8_t vcsel_period_reg;
johnAlexander 14:8320b5ff96fa 1101
johnAlexander 14:8320b5ff96fa 1102 switch (vcsel_period_type) {
johnAlexander 14:8320b5ff96fa 1103 case VL53L0X_VCSEL_PERIOD_PRE_RANGE:
Davidroid 16:27d3d95c8593 1104 status = VL53L0X_read_byte(dev,
johnAlexander 14:8320b5ff96fa 1105 VL53L0X_REG_PRE_RANGE_CONFIG_VCSEL_PERIOD,
johnAlexander 14:8320b5ff96fa 1106 &vcsel_period_reg);
johnAlexander 14:8320b5ff96fa 1107 break;
johnAlexander 14:8320b5ff96fa 1108 case VL53L0X_VCSEL_PERIOD_FINAL_RANGE:
Davidroid 16:27d3d95c8593 1109 status = VL53L0X_read_byte(dev,
johnAlexander 14:8320b5ff96fa 1110 VL53L0X_REG_FINAL_RANGE_CONFIG_VCSEL_PERIOD,
johnAlexander 14:8320b5ff96fa 1111 &vcsel_period_reg);
johnAlexander 14:8320b5ff96fa 1112 break;
johnAlexander 14:8320b5ff96fa 1113 default:
johnAlexander 14:8320b5ff96fa 1114 status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander 14:8320b5ff96fa 1115 }
johnAlexander 14:8320b5ff96fa 1116
johnAlexander 14:8320b5ff96fa 1117 if (status == VL53L0X_ERROR_NONE)
johnAlexander 14:8320b5ff96fa 1118 *p_vcsel_pulse_period_pclk =
Davidroid 16:27d3d95c8593 1119 VL53L0X_decode_vcsel_period(vcsel_period_reg);
johnAlexander 14:8320b5ff96fa 1120
johnAlexander 14:8320b5ff96fa 1121 return status;
johnAlexander 0:c523920bcc09 1122 }
johnAlexander 0:c523920bcc09 1123
Davidroid 16:27d3d95c8593 1124 VL53L0X_Error VL53L0X::VL53L0X_get_vcsel_pulse_period(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 1125 VL53L0X_VcselPeriod vcsel_period_type, uint8_t *p_vcsel_pulse_period_pclk)
johnAlexander 0:c523920bcc09 1126 {
johnAlexander 14:8320b5ff96fa 1127 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 1128 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 1129
Davidroid 16:27d3d95c8593 1130 status = wrapped_VL53L0X_get_vcsel_pulse_period(dev, vcsel_period_type,
johnAlexander 14:8320b5ff96fa 1131 p_vcsel_pulse_period_pclk);
johnAlexander 14:8320b5ff96fa 1132
johnAlexander 14:8320b5ff96fa 1133 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 1134 return status;
johnAlexander 0:c523920bcc09 1135 }
johnAlexander 0:c523920bcc09 1136
Davidroid 16:27d3d95c8593 1137 uint32_t VL53L0X::VL53L0X_decode_timeout(uint16_t encoded_timeout)
johnAlexander 0:c523920bcc09 1138 {
johnAlexander 14:8320b5ff96fa 1139 /*!
johnAlexander 14:8320b5ff96fa 1140 * Decode 16-bit timeout register value - format (LSByte * 2^MSByte) + 1
johnAlexander 14:8320b5ff96fa 1141 */
johnAlexander 14:8320b5ff96fa 1142
johnAlexander 14:8320b5ff96fa 1143 uint32_t timeout_macro_clks = 0;
johnAlexander 14:8320b5ff96fa 1144
johnAlexander 14:8320b5ff96fa 1145 timeout_macro_clks = ((uint32_t)(encoded_timeout & 0x00FF)
johnAlexander 14:8320b5ff96fa 1146 << (uint32_t)((encoded_timeout & 0xFF00) >> 8)) + 1;
johnAlexander 14:8320b5ff96fa 1147
johnAlexander 14:8320b5ff96fa 1148 return timeout_macro_clks;
johnAlexander 0:c523920bcc09 1149 }
johnAlexander 0:c523920bcc09 1150
Davidroid 16:27d3d95c8593 1151 uint32_t VL53L0X::VL53L0X_calc_macro_period_ps(VL53L0X_DEV dev, uint8_t vcsel_period_pclks)
johnAlexander 0:c523920bcc09 1152 {
johnAlexander 14:8320b5ff96fa 1153 uint64_t pll_period_ps;
johnAlexander 14:8320b5ff96fa 1154 uint32_t macro_period_vclks;
johnAlexander 14:8320b5ff96fa 1155 uint32_t macro_period_ps;
johnAlexander 14:8320b5ff96fa 1156
johnAlexander 14:8320b5ff96fa 1157 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 1158
johnAlexander 14:8320b5ff96fa 1159 /* The above calculation will produce rounding errors,
johnAlexander 14:8320b5ff96fa 1160 therefore set fixed value
johnAlexander 14:8320b5ff96fa 1161 */
johnAlexander 14:8320b5ff96fa 1162 pll_period_ps = 1655;
johnAlexander 14:8320b5ff96fa 1163
johnAlexander 14:8320b5ff96fa 1164 macro_period_vclks = 2304;
johnAlexander 14:8320b5ff96fa 1165 macro_period_ps = (uint32_t)(macro_period_vclks
johnAlexander 14:8320b5ff96fa 1166 * vcsel_period_pclks * pll_period_ps);
johnAlexander 14:8320b5ff96fa 1167
johnAlexander 14:8320b5ff96fa 1168 LOG_FUNCTION_END("");
johnAlexander 14:8320b5ff96fa 1169 return macro_period_ps;
johnAlexander 0:c523920bcc09 1170 }
johnAlexander 0:c523920bcc09 1171
johnAlexander 0:c523920bcc09 1172 /* To convert register value into us */
Davidroid 16:27d3d95c8593 1173 uint32_t VL53L0X::VL53L0X_calc_timeout_us(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 1174 uint16_t timeout_period_mclks,
johnAlexander 14:8320b5ff96fa 1175 uint8_t vcsel_period_pclks)
johnAlexander 0:c523920bcc09 1176 {
johnAlexander 14:8320b5ff96fa 1177 uint32_t macro_period_ps;
johnAlexander 14:8320b5ff96fa 1178 uint32_t macro_period_ns;
johnAlexander 14:8320b5ff96fa 1179 uint32_t actual_timeout_period_us = 0;
johnAlexander 14:8320b5ff96fa 1180
Davidroid 16:27d3d95c8593 1181 macro_period_ps = VL53L0X_calc_macro_period_ps(dev, vcsel_period_pclks);
johnAlexander 14:8320b5ff96fa 1182 macro_period_ns = (macro_period_ps + 500) / 1000;
johnAlexander 14:8320b5ff96fa 1183
johnAlexander 14:8320b5ff96fa 1184 actual_timeout_period_us =
johnAlexander 14:8320b5ff96fa 1185 ((timeout_period_mclks * macro_period_ns) + 500) / 1000;
johnAlexander 14:8320b5ff96fa 1186
johnAlexander 14:8320b5ff96fa 1187 return actual_timeout_period_us;
johnAlexander 0:c523920bcc09 1188 }
johnAlexander 0:c523920bcc09 1189
johnAlexander 14:8320b5ff96fa 1190 VL53L0X_Error VL53L0X::get_sequence_step_timeout(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 1191 VL53L0X_SequenceStepId sequence_step_id,
johnAlexander 14:8320b5ff96fa 1192 uint32_t *p_time_out_micro_secs)
johnAlexander 0:c523920bcc09 1193 {
johnAlexander 14:8320b5ff96fa 1194 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 1195 uint8_t current_vcsel_pulse_period_p_clk;
johnAlexander 14:8320b5ff96fa 1196 uint8_t encoded_time_out_byte = 0;
johnAlexander 14:8320b5ff96fa 1197 uint32_t timeout_micro_seconds = 0;
johnAlexander 14:8320b5ff96fa 1198 uint16_t pre_range_encoded_time_out = 0;
johnAlexander 14:8320b5ff96fa 1199 uint16_t msrc_time_out_m_clks;
johnAlexander 14:8320b5ff96fa 1200 uint16_t pre_range_time_out_m_clks;
johnAlexander 14:8320b5ff96fa 1201 uint16_t final_range_time_out_m_clks = 0;
johnAlexander 14:8320b5ff96fa 1202 uint16_t final_range_encoded_time_out;
johnAlexander 14:8320b5ff96fa 1203 VL53L0X_SchedulerSequenceSteps_t scheduler_sequence_steps;
johnAlexander 14:8320b5ff96fa 1204
johnAlexander 14:8320b5ff96fa 1205 if ((sequence_step_id == VL53L0X_SEQUENCESTEP_TCC) ||
johnAlexander 14:8320b5ff96fa 1206 (sequence_step_id == VL53L0X_SEQUENCESTEP_DSS) ||
johnAlexander 14:8320b5ff96fa 1207 (sequence_step_id == VL53L0X_SEQUENCESTEP_MSRC)) {
johnAlexander 14:8320b5ff96fa 1208
Davidroid 16:27d3d95c8593 1209 status = VL53L0X_get_vcsel_pulse_period(dev,
johnAlexander 14:8320b5ff96fa 1210 VL53L0X_VCSEL_PERIOD_PRE_RANGE,
johnAlexander 14:8320b5ff96fa 1211 &current_vcsel_pulse_period_p_clk);
johnAlexander 14:8320b5ff96fa 1212 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 1213 status = VL53L0X_read_byte(dev,
johnAlexander 14:8320b5ff96fa 1214 VL53L0X_REG_MSRC_CONFIG_TIMEOUT_MACROP,
johnAlexander 14:8320b5ff96fa 1215 &encoded_time_out_byte);
johnAlexander 14:8320b5ff96fa 1216 }
Davidroid 16:27d3d95c8593 1217 msrc_time_out_m_clks = VL53L0X_decode_timeout(encoded_time_out_byte);
Davidroid 16:27d3d95c8593 1218
Davidroid 16:27d3d95c8593 1219 timeout_micro_seconds = VL53L0X_calc_timeout_us(dev,
johnAlexander 14:8320b5ff96fa 1220 msrc_time_out_m_clks,
johnAlexander 14:8320b5ff96fa 1221 current_vcsel_pulse_period_p_clk);
johnAlexander 14:8320b5ff96fa 1222 } else if (sequence_step_id == VL53L0X_SEQUENCESTEP_PRE_RANGE) {
johnAlexander 14:8320b5ff96fa 1223 /* Retrieve PRE-RANGE VCSEL Period */
Davidroid 16:27d3d95c8593 1224 status = VL53L0X_get_vcsel_pulse_period(dev,
johnAlexander 14:8320b5ff96fa 1225 VL53L0X_VCSEL_PERIOD_PRE_RANGE,
johnAlexander 14:8320b5ff96fa 1226 &current_vcsel_pulse_period_p_clk);
johnAlexander 14:8320b5ff96fa 1227
johnAlexander 14:8320b5ff96fa 1228 /* Retrieve PRE-RANGE Timeout in Macro periods (MCLKS) */
johnAlexander 14:8320b5ff96fa 1229 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 1230
johnAlexander 14:8320b5ff96fa 1231 /* Retrieve PRE-RANGE VCSEL Period */
Davidroid 16:27d3d95c8593 1232 status = VL53L0X_get_vcsel_pulse_period(dev,
johnAlexander 14:8320b5ff96fa 1233 VL53L0X_VCSEL_PERIOD_PRE_RANGE,
johnAlexander 14:8320b5ff96fa 1234 &current_vcsel_pulse_period_p_clk);
johnAlexander 14:8320b5ff96fa 1235
johnAlexander 14:8320b5ff96fa 1236 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 1237 status = VL53L0X_read_word(dev,
johnAlexander 14:8320b5ff96fa 1238 VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI,
johnAlexander 14:8320b5ff96fa 1239 &pre_range_encoded_time_out);
johnAlexander 14:8320b5ff96fa 1240 }
johnAlexander 14:8320b5ff96fa 1241
Davidroid 16:27d3d95c8593 1242 pre_range_time_out_m_clks = VL53L0X_decode_timeout(
johnAlexander 14:8320b5ff96fa 1243 pre_range_encoded_time_out);
johnAlexander 14:8320b5ff96fa 1244
Davidroid 16:27d3d95c8593 1245 timeout_micro_seconds = VL53L0X_calc_timeout_us(dev,
johnAlexander 14:8320b5ff96fa 1246 pre_range_time_out_m_clks,
johnAlexander 14:8320b5ff96fa 1247 current_vcsel_pulse_period_p_clk);
johnAlexander 14:8320b5ff96fa 1248 }
johnAlexander 14:8320b5ff96fa 1249 } else if (sequence_step_id == VL53L0X_SEQUENCESTEP_FINAL_RANGE) {
johnAlexander 14:8320b5ff96fa 1250
Davidroid 16:27d3d95c8593 1251 VL53L0X_get_sequence_step_enables(dev, &scheduler_sequence_steps);
johnAlexander 14:8320b5ff96fa 1252 pre_range_time_out_m_clks = 0;
johnAlexander 14:8320b5ff96fa 1253
johnAlexander 14:8320b5ff96fa 1254 if (scheduler_sequence_steps.PreRangeOn) {
johnAlexander 14:8320b5ff96fa 1255 /* Retrieve PRE-RANGE VCSEL Period */
Davidroid 16:27d3d95c8593 1256 status = VL53L0X_get_vcsel_pulse_period(dev,
johnAlexander 14:8320b5ff96fa 1257 VL53L0X_VCSEL_PERIOD_PRE_RANGE,
johnAlexander 14:8320b5ff96fa 1258 &current_vcsel_pulse_period_p_clk);
johnAlexander 14:8320b5ff96fa 1259
johnAlexander 14:8320b5ff96fa 1260 /* Retrieve PRE-RANGE Timeout in Macro periods
johnAlexander 14:8320b5ff96fa 1261 * (MCLKS) */
johnAlexander 14:8320b5ff96fa 1262 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 1263 status = VL53L0X_read_word(dev,
johnAlexander 14:8320b5ff96fa 1264 VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI,
johnAlexander 14:8320b5ff96fa 1265 &pre_range_encoded_time_out);
Davidroid 16:27d3d95c8593 1266 pre_range_time_out_m_clks = VL53L0X_decode_timeout(
johnAlexander 14:8320b5ff96fa 1267 pre_range_encoded_time_out);
johnAlexander 14:8320b5ff96fa 1268 }
johnAlexander 14:8320b5ff96fa 1269 }
johnAlexander 14:8320b5ff96fa 1270
johnAlexander 14:8320b5ff96fa 1271 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 1272 /* Retrieve FINAL-RANGE VCSEL Period */
Davidroid 16:27d3d95c8593 1273 status = VL53L0X_get_vcsel_pulse_period(dev,
johnAlexander 14:8320b5ff96fa 1274 VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
johnAlexander 14:8320b5ff96fa 1275 &current_vcsel_pulse_period_p_clk);
johnAlexander 14:8320b5ff96fa 1276 }
johnAlexander 14:8320b5ff96fa 1277
johnAlexander 14:8320b5ff96fa 1278 /* Retrieve FINAL-RANGE Timeout in Macro periods (MCLKS) */
johnAlexander 14:8320b5ff96fa 1279 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 1280 status = VL53L0X_read_word(dev,
johnAlexander 14:8320b5ff96fa 1281 VL53L0X_REG_FINAL_RANGE_CONFIG_TIMEOUT_MACROP_HI,
johnAlexander 14:8320b5ff96fa 1282 &final_range_encoded_time_out);
Davidroid 16:27d3d95c8593 1283 final_range_time_out_m_clks = VL53L0X_decode_timeout(
johnAlexander 14:8320b5ff96fa 1284 final_range_encoded_time_out);
johnAlexander 14:8320b5ff96fa 1285 }
johnAlexander 14:8320b5ff96fa 1286
johnAlexander 14:8320b5ff96fa 1287 final_range_time_out_m_clks -= pre_range_time_out_m_clks;
Davidroid 16:27d3d95c8593 1288 timeout_micro_seconds = VL53L0X_calc_timeout_us(dev,
johnAlexander 14:8320b5ff96fa 1289 final_range_time_out_m_clks,
johnAlexander 14:8320b5ff96fa 1290 current_vcsel_pulse_period_p_clk);
johnAlexander 14:8320b5ff96fa 1291 }
johnAlexander 14:8320b5ff96fa 1292
johnAlexander 14:8320b5ff96fa 1293 *p_time_out_micro_secs = timeout_micro_seconds;
johnAlexander 14:8320b5ff96fa 1294
johnAlexander 14:8320b5ff96fa 1295 return status;
johnAlexander 0:c523920bcc09 1296 }
johnAlexander 0:c523920bcc09 1297
Davidroid 16:27d3d95c8593 1298 VL53L0X_Error VL53L0X::wrapped_VL53L0X_get_measurement_timing_budget_micro_seconds(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 1299 uint32_t *p_measurement_timing_budget_micro_seconds)
johnAlexander 0:c523920bcc09 1300 {
johnAlexander 14:8320b5ff96fa 1301 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 1302 VL53L0X_SchedulerSequenceSteps_t scheduler_sequence_steps;
johnAlexander 14:8320b5ff96fa 1303 uint32_t final_range_timeout_micro_seconds;
johnAlexander 14:8320b5ff96fa 1304 uint32_t msrc_dcc_tcc_timeout_micro_seconds = 2000;
johnAlexander 14:8320b5ff96fa 1305 uint32_t start_overhead_micro_seconds = 1910;
johnAlexander 14:8320b5ff96fa 1306 uint32_t end_overhead_micro_seconds = 960;
johnAlexander 14:8320b5ff96fa 1307 uint32_t msrc_overhead_micro_seconds = 660;
johnAlexander 14:8320b5ff96fa 1308 uint32_t tcc_overhead_micro_seconds = 590;
johnAlexander 14:8320b5ff96fa 1309 uint32_t dss_overhead_micro_seconds = 690;
johnAlexander 14:8320b5ff96fa 1310 uint32_t pre_range_overhead_micro_seconds = 660;
johnAlexander 14:8320b5ff96fa 1311 uint32_t final_range_overhead_micro_seconds = 550;
johnAlexander 14:8320b5ff96fa 1312 uint32_t pre_range_timeout_micro_seconds = 0;
johnAlexander 14:8320b5ff96fa 1313
johnAlexander 14:8320b5ff96fa 1314 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 1315
johnAlexander 14:8320b5ff96fa 1316 /* Start and end overhead times always present */
johnAlexander 14:8320b5ff96fa 1317 *p_measurement_timing_budget_micro_seconds
johnAlexander 14:8320b5ff96fa 1318 = start_overhead_micro_seconds + end_overhead_micro_seconds;
johnAlexander 14:8320b5ff96fa 1319
Davidroid 16:27d3d95c8593 1320 status = VL53L0X_get_sequence_step_enables(dev, &scheduler_sequence_steps);
johnAlexander 14:8320b5ff96fa 1321
johnAlexander 14:8320b5ff96fa 1322 if (status != VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 1323 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 1324 return status;
johnAlexander 14:8320b5ff96fa 1325 }
johnAlexander 14:8320b5ff96fa 1326
johnAlexander 14:8320b5ff96fa 1327
johnAlexander 14:8320b5ff96fa 1328 if (scheduler_sequence_steps.TccOn ||
johnAlexander 14:8320b5ff96fa 1329 scheduler_sequence_steps.MsrcOn ||
johnAlexander 14:8320b5ff96fa 1330 scheduler_sequence_steps.DssOn) {
johnAlexander 14:8320b5ff96fa 1331
johnAlexander 14:8320b5ff96fa 1332 status = get_sequence_step_timeout(dev,
johnAlexander 14:8320b5ff96fa 1333 VL53L0X_SEQUENCESTEP_MSRC,
johnAlexander 14:8320b5ff96fa 1334 &msrc_dcc_tcc_timeout_micro_seconds);
johnAlexander 14:8320b5ff96fa 1335
johnAlexander 14:8320b5ff96fa 1336 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 1337 if (scheduler_sequence_steps.TccOn) {
johnAlexander 14:8320b5ff96fa 1338 *p_measurement_timing_budget_micro_seconds +=
johnAlexander 14:8320b5ff96fa 1339 msrc_dcc_tcc_timeout_micro_seconds +
johnAlexander 14:8320b5ff96fa 1340 tcc_overhead_micro_seconds;
johnAlexander 14:8320b5ff96fa 1341 }
johnAlexander 14:8320b5ff96fa 1342
johnAlexander 14:8320b5ff96fa 1343 if (scheduler_sequence_steps.DssOn) {
johnAlexander 14:8320b5ff96fa 1344 *p_measurement_timing_budget_micro_seconds +=
johnAlexander 14:8320b5ff96fa 1345 2 * (msrc_dcc_tcc_timeout_micro_seconds +
johnAlexander 14:8320b5ff96fa 1346 dss_overhead_micro_seconds);
johnAlexander 14:8320b5ff96fa 1347 } else if (scheduler_sequence_steps.MsrcOn) {
johnAlexander 14:8320b5ff96fa 1348 *p_measurement_timing_budget_micro_seconds +=
johnAlexander 14:8320b5ff96fa 1349 msrc_dcc_tcc_timeout_micro_seconds +
johnAlexander 14:8320b5ff96fa 1350 msrc_overhead_micro_seconds;
johnAlexander 14:8320b5ff96fa 1351 }
johnAlexander 14:8320b5ff96fa 1352 }
johnAlexander 14:8320b5ff96fa 1353 }
johnAlexander 14:8320b5ff96fa 1354
johnAlexander 14:8320b5ff96fa 1355 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 1356 if (scheduler_sequence_steps.PreRangeOn) {
johnAlexander 14:8320b5ff96fa 1357 status = get_sequence_step_timeout(dev,
johnAlexander 14:8320b5ff96fa 1358 VL53L0X_SEQUENCESTEP_PRE_RANGE,
johnAlexander 14:8320b5ff96fa 1359 &pre_range_timeout_micro_seconds);
johnAlexander 14:8320b5ff96fa 1360 *p_measurement_timing_budget_micro_seconds +=
johnAlexander 14:8320b5ff96fa 1361 pre_range_timeout_micro_seconds +
johnAlexander 14:8320b5ff96fa 1362 pre_range_overhead_micro_seconds;
johnAlexander 14:8320b5ff96fa 1363 }
johnAlexander 14:8320b5ff96fa 1364 }
johnAlexander 14:8320b5ff96fa 1365
johnAlexander 14:8320b5ff96fa 1366 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 1367 if (scheduler_sequence_steps.FinalRangeOn) {
johnAlexander 14:8320b5ff96fa 1368 status = get_sequence_step_timeout(dev,
johnAlexander 14:8320b5ff96fa 1369 VL53L0X_SEQUENCESTEP_FINAL_RANGE,
johnAlexander 14:8320b5ff96fa 1370 &final_range_timeout_micro_seconds);
johnAlexander 14:8320b5ff96fa 1371 *p_measurement_timing_budget_micro_seconds +=
johnAlexander 14:8320b5ff96fa 1372 (final_range_timeout_micro_seconds +
johnAlexander 14:8320b5ff96fa 1373 final_range_overhead_micro_seconds);
johnAlexander 14:8320b5ff96fa 1374 }
johnAlexander 14:8320b5ff96fa 1375 }
johnAlexander 14:8320b5ff96fa 1376
johnAlexander 14:8320b5ff96fa 1377 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 1378 VL53L0X_SETPARAMETERFIELD(dev,
johnAlexander 14:8320b5ff96fa 1379 MeasurementTimingBudgetMicroSeconds,
johnAlexander 14:8320b5ff96fa 1380 *p_measurement_timing_budget_micro_seconds);
johnAlexander 14:8320b5ff96fa 1381 }
johnAlexander 14:8320b5ff96fa 1382
johnAlexander 14:8320b5ff96fa 1383 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 1384 return status;
johnAlexander 0:c523920bcc09 1385 }
johnAlexander 0:c523920bcc09 1386
Davidroid 16:27d3d95c8593 1387 VL53L0X_Error VL53L0X::VL53L0X_get_measurement_timing_budget_micro_seconds(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 1388 uint32_t *p_measurement_timing_budget_micro_seconds)
johnAlexander 0:c523920bcc09 1389 {
johnAlexander 14:8320b5ff96fa 1390 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 1391 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 1392
Davidroid 16:27d3d95c8593 1393 status = wrapped_VL53L0X_get_measurement_timing_budget_micro_seconds(dev,
johnAlexander 14:8320b5ff96fa 1394 p_measurement_timing_budget_micro_seconds);
johnAlexander 14:8320b5ff96fa 1395
johnAlexander 14:8320b5ff96fa 1396 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 1397 return status;
johnAlexander 0:c523920bcc09 1398 }
johnAlexander 0:c523920bcc09 1399
Davidroid 16:27d3d95c8593 1400 VL53L0X_Error VL53L0X::VL53L0X_get_device_parameters(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 1401 VL53L0X_DeviceParameters_t *p_device_parameters)
johnAlexander 0:c523920bcc09 1402 {
johnAlexander 14:8320b5ff96fa 1403 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 1404 int i;
johnAlexander 14:8320b5ff96fa 1405
johnAlexander 14:8320b5ff96fa 1406 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 1407
Davidroid 16:27d3d95c8593 1408 status = VL53L0X_get_device_mode(dev, &(p_device_parameters->DeviceMode));
johnAlexander 14:8320b5ff96fa 1409
johnAlexander 14:8320b5ff96fa 1410 if (status == VL53L0X_ERROR_NONE)
Davidroid 16:27d3d95c8593 1411 status = VL53L0X_get_inter_measurement_period_milli_seconds(dev,
johnAlexander 14:8320b5ff96fa 1412 &(p_device_parameters->InterMeasurementPeriodMilliSeconds));
johnAlexander 14:8320b5ff96fa 1413
johnAlexander 14:8320b5ff96fa 1414
johnAlexander 14:8320b5ff96fa 1415 if (status == VL53L0X_ERROR_NONE)
johnAlexander 14:8320b5ff96fa 1416 p_device_parameters->XTalkCompensationEnable = 0;
johnAlexander 14:8320b5ff96fa 1417
johnAlexander 14:8320b5ff96fa 1418 if (status == VL53L0X_ERROR_NONE)
Davidroid 16:27d3d95c8593 1419 status = VL53L0X_get_x_talk_compensation_rate_mega_cps(dev,
johnAlexander 14:8320b5ff96fa 1420 &(p_device_parameters->XTalkCompensationRateMegaCps));
johnAlexander 14:8320b5ff96fa 1421
johnAlexander 14:8320b5ff96fa 1422
johnAlexander 14:8320b5ff96fa 1423 if (status == VL53L0X_ERROR_NONE)
Davidroid 16:27d3d95c8593 1424 status = VL53L0X_get_offset_calibration_data_micro_meter(dev,
johnAlexander 14:8320b5ff96fa 1425 &(p_device_parameters->RangeOffsetMicroMeters));
johnAlexander 14:8320b5ff96fa 1426
johnAlexander 14:8320b5ff96fa 1427
johnAlexander 14:8320b5ff96fa 1428 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 1429 for (i = 0; i < VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS; i++) {
johnAlexander 14:8320b5ff96fa 1430 /* get first the values, then the enables.
johnAlexander 14:8320b5ff96fa 1431 * VL53L0X_GetLimitCheckValue will modify the enable
johnAlexander 14:8320b5ff96fa 1432 * flags
johnAlexander 14:8320b5ff96fa 1433 */
johnAlexander 14:8320b5ff96fa 1434 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 1435 status |= VL53L0X_get_limit_check_value(dev, i,
johnAlexander 14:8320b5ff96fa 1436 &(p_device_parameters->LimitChecksValue[i]));
johnAlexander 14:8320b5ff96fa 1437 } else {
johnAlexander 14:8320b5ff96fa 1438 break;
johnAlexander 14:8320b5ff96fa 1439 }
johnAlexander 14:8320b5ff96fa 1440 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 1441 status |= VL53L0X_get_limit_check_enable(dev, i,
johnAlexander 14:8320b5ff96fa 1442 &(p_device_parameters->LimitChecksEnable[i]));
johnAlexander 14:8320b5ff96fa 1443 } else {
johnAlexander 14:8320b5ff96fa 1444 break;
johnAlexander 14:8320b5ff96fa 1445 }
johnAlexander 14:8320b5ff96fa 1446 }
johnAlexander 14:8320b5ff96fa 1447 }
johnAlexander 14:8320b5ff96fa 1448
johnAlexander 14:8320b5ff96fa 1449 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 1450 status = VL53L0X_get_wrap_around_check_enable(dev,
johnAlexander 14:8320b5ff96fa 1451 &(p_device_parameters->WrapAroundCheckEnable));
johnAlexander 14:8320b5ff96fa 1452 }
johnAlexander 14:8320b5ff96fa 1453
johnAlexander 14:8320b5ff96fa 1454 /* Need to be done at the end as it uses VCSELPulsePeriod */
johnAlexander 14:8320b5ff96fa 1455 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 1456 status = VL53L0X_get_measurement_timing_budget_micro_seconds(dev,
johnAlexander 14:8320b5ff96fa 1457 &(p_device_parameters->MeasurementTimingBudgetMicroSeconds));
johnAlexander 14:8320b5ff96fa 1458 }
johnAlexander 14:8320b5ff96fa 1459
johnAlexander 14:8320b5ff96fa 1460 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 1461 return status;
johnAlexander 0:c523920bcc09 1462 }
johnAlexander 0:c523920bcc09 1463
Davidroid 16:27d3d95c8593 1464 VL53L0X_Error VL53L0X::VL53L0X_set_limit_check_value(VL53L0X_DEV dev, uint16_t limit_check_id,
johnAlexander 14:8320b5ff96fa 1465 FixPoint1616_t limit_check_value)
johnAlexander 0:c523920bcc09 1466 {
johnAlexander 14:8320b5ff96fa 1467 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 1468 uint8_t temp8;
johnAlexander 14:8320b5ff96fa 1469
johnAlexander 14:8320b5ff96fa 1470 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 1471
johnAlexander 14:8320b5ff96fa 1472 VL53L0X_GETARRAYPARAMETERFIELD(dev, LimitChecksEnable, limit_check_id,
johnAlexander 14:8320b5ff96fa 1473 temp8);
johnAlexander 14:8320b5ff96fa 1474
johnAlexander 14:8320b5ff96fa 1475 if (temp8 == 0) { /* disabled write only internal value */
johnAlexander 14:8320b5ff96fa 1476 VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksValue,
johnAlexander 14:8320b5ff96fa 1477 limit_check_id, limit_check_value);
johnAlexander 14:8320b5ff96fa 1478 } else {
johnAlexander 14:8320b5ff96fa 1479
johnAlexander 14:8320b5ff96fa 1480 switch (limit_check_id) {
johnAlexander 14:8320b5ff96fa 1481
johnAlexander 14:8320b5ff96fa 1482 case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
johnAlexander 14:8320b5ff96fa 1483 /* internal computation: */
johnAlexander 14:8320b5ff96fa 1484 VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksValue,
johnAlexander 14:8320b5ff96fa 1485 VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
johnAlexander 14:8320b5ff96fa 1486 limit_check_value);
johnAlexander 14:8320b5ff96fa 1487 break;
johnAlexander 14:8320b5ff96fa 1488
johnAlexander 14:8320b5ff96fa 1489 case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
johnAlexander 14:8320b5ff96fa 1490
Davidroid 16:27d3d95c8593 1491 status = VL53L0X_write_word(dev,
johnAlexander 14:8320b5ff96fa 1492 VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
johnAlexander 14:8320b5ff96fa 1493 VL53L0X_FIXPOINT1616TOFIXPOINT97(
johnAlexander 14:8320b5ff96fa 1494 limit_check_value));
johnAlexander 14:8320b5ff96fa 1495
johnAlexander 14:8320b5ff96fa 1496 break;
johnAlexander 14:8320b5ff96fa 1497
johnAlexander 14:8320b5ff96fa 1498 case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
johnAlexander 14:8320b5ff96fa 1499
johnAlexander 14:8320b5ff96fa 1500 /* internal computation: */
johnAlexander 14:8320b5ff96fa 1501 VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksValue,
johnAlexander 14:8320b5ff96fa 1502 VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
johnAlexander 14:8320b5ff96fa 1503 limit_check_value);
johnAlexander 14:8320b5ff96fa 1504
johnAlexander 14:8320b5ff96fa 1505 break;
johnAlexander 14:8320b5ff96fa 1506
johnAlexander 14:8320b5ff96fa 1507 case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
johnAlexander 14:8320b5ff96fa 1508
johnAlexander 14:8320b5ff96fa 1509 /* internal computation: */
johnAlexander 14:8320b5ff96fa 1510 VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksValue,
johnAlexander 14:8320b5ff96fa 1511 VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
johnAlexander 14:8320b5ff96fa 1512 limit_check_value);
johnAlexander 14:8320b5ff96fa 1513
johnAlexander 14:8320b5ff96fa 1514 break;
johnAlexander 14:8320b5ff96fa 1515
johnAlexander 14:8320b5ff96fa 1516 case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
johnAlexander 14:8320b5ff96fa 1517 case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
johnAlexander 14:8320b5ff96fa 1518
Davidroid 16:27d3d95c8593 1519 status = VL53L0X_write_word(dev,
johnAlexander 14:8320b5ff96fa 1520 VL53L0X_REG_PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT,
johnAlexander 14:8320b5ff96fa 1521 VL53L0X_FIXPOINT1616TOFIXPOINT97(
johnAlexander 14:8320b5ff96fa 1522 limit_check_value));
johnAlexander 14:8320b5ff96fa 1523
johnAlexander 14:8320b5ff96fa 1524 break;
johnAlexander 14:8320b5ff96fa 1525
johnAlexander 14:8320b5ff96fa 1526 default:
johnAlexander 14:8320b5ff96fa 1527 status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander 14:8320b5ff96fa 1528
johnAlexander 14:8320b5ff96fa 1529 }
johnAlexander 14:8320b5ff96fa 1530
johnAlexander 14:8320b5ff96fa 1531 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 1532 VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksValue,
johnAlexander 14:8320b5ff96fa 1533 limit_check_id, limit_check_value);
johnAlexander 14:8320b5ff96fa 1534 }
johnAlexander 14:8320b5ff96fa 1535 }
johnAlexander 14:8320b5ff96fa 1536
johnAlexander 14:8320b5ff96fa 1537 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 1538 return status;
johnAlexander 0:c523920bcc09 1539 }
johnAlexander 0:c523920bcc09 1540
Davidroid 16:27d3d95c8593 1541 VL53L0X_Error VL53L0X::VL53L0X_data_init(VL53L0X_DEV dev)
johnAlexander 0:c523920bcc09 1542 {
johnAlexander 14:8320b5ff96fa 1543 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 1544 VL53L0X_DeviceParameters_t CurrentParameters;
johnAlexander 14:8320b5ff96fa 1545 int i;
johnAlexander 14:8320b5ff96fa 1546 uint8_t StopVariable;
johnAlexander 14:8320b5ff96fa 1547
johnAlexander 14:8320b5ff96fa 1548 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 1549
johnAlexander 14:8320b5ff96fa 1550 /* by default the I2C is running at 1V8 if you want to change it you
johnAlexander 14:8320b5ff96fa 1551 * need to include this define at compilation level. */
johnAlexander 0:c523920bcc09 1552 #ifdef USE_I2C_2V8
johnAlexander 14:8320b5ff96fa 1553 Status = VL53L0X_UpdateByte(Dev,
johnAlexander 14:8320b5ff96fa 1554 VL53L0X_REG_VHV_CONFIG_PAD_SCL_SDA__EXTSUP_HV,
johnAlexander 14:8320b5ff96fa 1555 0xFE,
johnAlexander 14:8320b5ff96fa 1556 0x01);
johnAlexander 0:c523920bcc09 1557 #endif
johnAlexander 0:c523920bcc09 1558
johnAlexander 14:8320b5ff96fa 1559 /* Set I2C standard mode */
johnAlexander 14:8320b5ff96fa 1560 if (status == VL53L0X_ERROR_NONE)
Davidroid 16:27d3d95c8593 1561 status = VL53L0X_write_byte(dev, 0x88, 0x00);
johnAlexander 14:8320b5ff96fa 1562
johnAlexander 14:8320b5ff96fa 1563 VL53L0X_SETDEVICESPECIFICPARAMETER(dev, ReadDataFromDeviceDone, 0);
johnAlexander 0:c523920bcc09 1564
johnAlexander 0:c523920bcc09 1565 #ifdef USE_IQC_STATION
johnAlexander 14:8320b5ff96fa 1566 if (Status == VL53L0X_ERROR_NONE)
johnAlexander 14:8320b5ff96fa 1567 Status = VL53L0X_apply_offset_adjustment(Dev);
johnAlexander 0:c523920bcc09 1568 #endif
johnAlexander 0:c523920bcc09 1569
johnAlexander 14:8320b5ff96fa 1570 /* Default value is 1000 for Linearity Corrective Gain */
johnAlexander 14:8320b5ff96fa 1571 PALDevDataSet(dev, LinearityCorrectiveGain, 1000);
johnAlexander 14:8320b5ff96fa 1572
johnAlexander 14:8320b5ff96fa 1573 /* Dmax default Parameter */
johnAlexander 14:8320b5ff96fa 1574 PALDevDataSet(dev, DmaxCalRangeMilliMeter, 400);
johnAlexander 14:8320b5ff96fa 1575 PALDevDataSet(dev, DmaxCalSignalRateRtnMegaCps,
johnAlexander 14:8320b5ff96fa 1576 (FixPoint1616_t)((0x00016B85))); /* 1.42 No Cover Glass*/
johnAlexander 14:8320b5ff96fa 1577
johnAlexander 14:8320b5ff96fa 1578 /* Set Default static parameters
johnAlexander 14:8320b5ff96fa 1579 *set first temporary values 9.44MHz * 65536 = 618660 */
johnAlexander 14:8320b5ff96fa 1580 VL53L0X_SETDEVICESPECIFICPARAMETER(dev, OscFrequencyMHz, 618660);
johnAlexander 14:8320b5ff96fa 1581
johnAlexander 14:8320b5ff96fa 1582 /* Set Default XTalkCompensationRateMegaCps to 0 */
johnAlexander 14:8320b5ff96fa 1583 VL53L0X_SETPARAMETERFIELD(dev, XTalkCompensationRateMegaCps, 0);
johnAlexander 14:8320b5ff96fa 1584
johnAlexander 14:8320b5ff96fa 1585 /* Get default parameters */
Davidroid 16:27d3d95c8593 1586 status = VL53L0X_get_device_parameters(dev, &CurrentParameters);
johnAlexander 14:8320b5ff96fa 1587 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 1588 /* initialize PAL values */
johnAlexander 14:8320b5ff96fa 1589 CurrentParameters.DeviceMode = VL53L0X_DEVICEMODE_SINGLE_RANGING;
johnAlexander 14:8320b5ff96fa 1590 CurrentParameters.HistogramMode = VL53L0X_HISTOGRAMMODE_DISABLED;
johnAlexander 14:8320b5ff96fa 1591 PALDevDataSet(dev, CurrentParameters, CurrentParameters);
johnAlexander 14:8320b5ff96fa 1592 }
johnAlexander 14:8320b5ff96fa 1593
johnAlexander 14:8320b5ff96fa 1594 /* Sigma estimator variable */
johnAlexander 14:8320b5ff96fa 1595 PALDevDataSet(dev, SigmaEstRefArray, 100);
johnAlexander 14:8320b5ff96fa 1596 PALDevDataSet(dev, SigmaEstEffPulseWidth, 900);
johnAlexander 14:8320b5ff96fa 1597 PALDevDataSet(dev, SigmaEstEffAmbWidth, 500);
johnAlexander 14:8320b5ff96fa 1598 PALDevDataSet(dev, targetRefRate, 0x0A00); /* 20 MCPS in 9:7 format */
johnAlexander 14:8320b5ff96fa 1599
johnAlexander 14:8320b5ff96fa 1600 /* Use internal default settings */
johnAlexander 14:8320b5ff96fa 1601 PALDevDataSet(dev, UseInternalTuningSettings, 1);
johnAlexander 14:8320b5ff96fa 1602
Davidroid 16:27d3d95c8593 1603 status |= VL53L0X_write_byte(dev, 0x80, 0x01);
Davidroid 16:27d3d95c8593 1604 status |= VL53L0X_write_byte(dev, 0xFF, 0x01);
Davidroid 16:27d3d95c8593 1605 status |= VL53L0X_write_byte(dev, 0x00, 0x00);
Davidroid 16:27d3d95c8593 1606 status |= VL53L0X_read_byte(dev, 0x91, &StopVariable);
johnAlexander 14:8320b5ff96fa 1607 PALDevDataSet(dev, StopVariable, StopVariable);
Davidroid 16:27d3d95c8593 1608 status |= VL53L0X_write_byte(dev, 0x00, 0x01);
Davidroid 16:27d3d95c8593 1609 status |= VL53L0X_write_byte(dev, 0xFF, 0x00);
Davidroid 16:27d3d95c8593 1610 status |= VL53L0X_write_byte(dev, 0x80, 0x00);
johnAlexander 14:8320b5ff96fa 1611
johnAlexander 14:8320b5ff96fa 1612 /* Enable all check */
johnAlexander 14:8320b5ff96fa 1613 for (i = 0; i < VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS; i++) {
johnAlexander 14:8320b5ff96fa 1614 if (status == VL53L0X_ERROR_NONE)
Davidroid 16:27d3d95c8593 1615 status |= VL53L0X_set_limit_check_enable(dev, i, 1);
johnAlexander 14:8320b5ff96fa 1616 else
johnAlexander 14:8320b5ff96fa 1617 break;
johnAlexander 14:8320b5ff96fa 1618
johnAlexander 14:8320b5ff96fa 1619 }
johnAlexander 14:8320b5ff96fa 1620
johnAlexander 14:8320b5ff96fa 1621 /* Disable the following checks */
johnAlexander 14:8320b5ff96fa 1622 if (status == VL53L0X_ERROR_NONE)
Davidroid 16:27d3d95c8593 1623 status = VL53L0X_set_limit_check_enable(dev,
johnAlexander 14:8320b5ff96fa 1624 VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP, 0);
johnAlexander 14:8320b5ff96fa 1625
johnAlexander 14:8320b5ff96fa 1626 if (status == VL53L0X_ERROR_NONE)
Davidroid 16:27d3d95c8593 1627 status = VL53L0X_set_limit_check_enable(dev,
johnAlexander 14:8320b5ff96fa 1628 VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, 0);
johnAlexander 14:8320b5ff96fa 1629
johnAlexander 14:8320b5ff96fa 1630 if (status == VL53L0X_ERROR_NONE)
Davidroid 16:27d3d95c8593 1631 status = VL53L0X_set_limit_check_enable(dev,
johnAlexander 14:8320b5ff96fa 1632 VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC, 0);
johnAlexander 14:8320b5ff96fa 1633
johnAlexander 14:8320b5ff96fa 1634 if (status == VL53L0X_ERROR_NONE)
Davidroid 16:27d3d95c8593 1635 status = VL53L0X_set_limit_check_enable(dev,
johnAlexander 14:8320b5ff96fa 1636 VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE, 0);
johnAlexander 14:8320b5ff96fa 1637
johnAlexander 14:8320b5ff96fa 1638 /* Limit default values */
johnAlexander 14:8320b5ff96fa 1639 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 1640 status = VL53L0X_set_limit_check_value(dev,
johnAlexander 14:8320b5ff96fa 1641 VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
johnAlexander 14:8320b5ff96fa 1642 (FixPoint1616_t)(18 * 65536));
johnAlexander 14:8320b5ff96fa 1643 }
johnAlexander 14:8320b5ff96fa 1644 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 1645 status = VL53L0X_set_limit_check_value(dev,
johnAlexander 14:8320b5ff96fa 1646 VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
johnAlexander 14:8320b5ff96fa 1647 (FixPoint1616_t)(25 * 65536 / 100));
johnAlexander 14:8320b5ff96fa 1648 /* 0.25 * 65536 */
johnAlexander 14:8320b5ff96fa 1649 }
johnAlexander 14:8320b5ff96fa 1650
johnAlexander 14:8320b5ff96fa 1651 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 1652 status = VL53L0X_set_limit_check_value(dev,
johnAlexander 14:8320b5ff96fa 1653 VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
johnAlexander 14:8320b5ff96fa 1654 (FixPoint1616_t)(35 * 65536));
johnAlexander 14:8320b5ff96fa 1655 }
johnAlexander 14:8320b5ff96fa 1656
johnAlexander 14:8320b5ff96fa 1657 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 1658 status = VL53L0X_set_limit_check_value(dev,
johnAlexander 14:8320b5ff96fa 1659 VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
johnAlexander 14:8320b5ff96fa 1660 (FixPoint1616_t)(0 * 65536));
johnAlexander 14:8320b5ff96fa 1661 }
johnAlexander 14:8320b5ff96fa 1662
johnAlexander 14:8320b5ff96fa 1663 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 1664
johnAlexander 14:8320b5ff96fa 1665 PALDevDataSet(dev, SequenceConfig, 0xFF);
Davidroid 16:27d3d95c8593 1666 status = VL53L0X_write_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
johnAlexander 14:8320b5ff96fa 1667 0xFF);
johnAlexander 14:8320b5ff96fa 1668
johnAlexander 14:8320b5ff96fa 1669 /* Set PAL state to tell that we are waiting for call to
johnAlexander 14:8320b5ff96fa 1670 * VL53L0X_StaticInit */
johnAlexander 14:8320b5ff96fa 1671 PALDevDataSet(dev, PalState, VL53L0X_STATE_WAIT_STATICINIT);
johnAlexander 14:8320b5ff96fa 1672 }
johnAlexander 14:8320b5ff96fa 1673
johnAlexander 14:8320b5ff96fa 1674 if (status == VL53L0X_ERROR_NONE)
johnAlexander 14:8320b5ff96fa 1675 VL53L0X_SETDEVICESPECIFICPARAMETER(dev, RefSpadsInitialised, 0);
johnAlexander 14:8320b5ff96fa 1676
johnAlexander 14:8320b5ff96fa 1677
johnAlexander 14:8320b5ff96fa 1678 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 1679 return status;
johnAlexander 0:c523920bcc09 1680 }
johnAlexander 0:c523920bcc09 1681
Davidroid 16:27d3d95c8593 1682 VL53L0X_Error VL53L0X::VL53L0X_check_part_used(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 1683 uint8_t *revision,
Davidroid 16:27d3d95c8593 1684 VL53L0X_DeviceInfo_t *p_VL53L0X_device_info)
johnAlexander 0:c523920bcc09 1685 {
johnAlexander 14:8320b5ff96fa 1686 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 1687 uint8_t module_id_int;
johnAlexander 14:8320b5ff96fa 1688 char *product_id_tmp;
johnAlexander 14:8320b5ff96fa 1689
johnAlexander 14:8320b5ff96fa 1690 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 1691
Davidroid 16:27d3d95c8593 1692 status = VL53L0X_get_info_from_device(dev, 2);
johnAlexander 14:8320b5ff96fa 1693
johnAlexander 14:8320b5ff96fa 1694 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 1695 module_id_int = VL53L0X_GETDEVICESPECIFICPARAMETER(dev, ModuleId);
johnAlexander 14:8320b5ff96fa 1696
johnAlexander 14:8320b5ff96fa 1697 if (module_id_int == 0) {
johnAlexander 14:8320b5ff96fa 1698 *revision = 0;
Davidroid 16:27d3d95c8593 1699 VL53L0X_COPYSTRING(p_VL53L0X_device_info->ProductId, "");
johnAlexander 14:8320b5ff96fa 1700 } else {
johnAlexander 14:8320b5ff96fa 1701 *revision = VL53L0X_GETDEVICESPECIFICPARAMETER(dev, Revision);
johnAlexander 14:8320b5ff96fa 1702 product_id_tmp = VL53L0X_GETDEVICESPECIFICPARAMETER(dev,
johnAlexander 14:8320b5ff96fa 1703 ProductId);
Davidroid 16:27d3d95c8593 1704 VL53L0X_COPYSTRING(p_VL53L0X_device_info->ProductId, product_id_tmp);
johnAlexander 14:8320b5ff96fa 1705 }
johnAlexander 14:8320b5ff96fa 1706 }
johnAlexander 14:8320b5ff96fa 1707
johnAlexander 14:8320b5ff96fa 1708 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 1709 return status;
johnAlexander 0:c523920bcc09 1710 }
johnAlexander 0:c523920bcc09 1711
Davidroid 16:27d3d95c8593 1712 VL53L0X_Error VL53L0X::wrapped_VL53L0X_get_device_info(VL53L0X_DEV dev,
Davidroid 16:27d3d95c8593 1713 VL53L0X_DeviceInfo_t *p_VL53L0X_device_info)
johnAlexander 0:c523920bcc09 1714 {
johnAlexander 14:8320b5ff96fa 1715 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 1716 uint8_t revision_id;
johnAlexander 14:8320b5ff96fa 1717 uint8_t revision;
johnAlexander 14:8320b5ff96fa 1718
Davidroid 16:27d3d95c8593 1719 status = VL53L0X_check_part_used(dev, &revision, p_VL53L0X_device_info);
johnAlexander 14:8320b5ff96fa 1720
johnAlexander 14:8320b5ff96fa 1721 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 1722 if (revision == 0) {
Davidroid 16:27d3d95c8593 1723 VL53L0X_COPYSTRING(p_VL53L0X_device_info->Name,
johnAlexander 14:8320b5ff96fa 1724 VL53L0X_STRING_DEVICE_INFO_NAME_TS0);
johnAlexander 14:8320b5ff96fa 1725 } else if ((revision <= 34) && (revision != 32)) {
Davidroid 16:27d3d95c8593 1726 VL53L0X_COPYSTRING(p_VL53L0X_device_info->Name,
johnAlexander 14:8320b5ff96fa 1727 VL53L0X_STRING_DEVICE_INFO_NAME_TS1);
johnAlexander 14:8320b5ff96fa 1728 } else if (revision < 39) {
Davidroid 16:27d3d95c8593 1729 VL53L0X_COPYSTRING(p_VL53L0X_device_info->Name,
johnAlexander 14:8320b5ff96fa 1730 VL53L0X_STRING_DEVICE_INFO_NAME_TS2);
johnAlexander 14:8320b5ff96fa 1731 } else {
Davidroid 16:27d3d95c8593 1732 VL53L0X_COPYSTRING(p_VL53L0X_device_info->Name,
johnAlexander 14:8320b5ff96fa 1733 VL53L0X_STRING_DEVICE_INFO_NAME_ES1);
johnAlexander 14:8320b5ff96fa 1734 }
johnAlexander 14:8320b5ff96fa 1735
Davidroid 16:27d3d95c8593 1736 VL53L0X_COPYSTRING(p_VL53L0X_device_info->Type,
johnAlexander 14:8320b5ff96fa 1737 VL53L0X_STRING_DEVICE_INFO_TYPE);
johnAlexander 14:8320b5ff96fa 1738
johnAlexander 14:8320b5ff96fa 1739 }
johnAlexander 14:8320b5ff96fa 1740
johnAlexander 14:8320b5ff96fa 1741 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 1742 status = VL53L0X_read_byte(dev, VL53L0X_REG_IDENTIFICATION_MODEL_ID,
Davidroid 16:27d3d95c8593 1743 &p_VL53L0X_device_info->ProductType);
johnAlexander 14:8320b5ff96fa 1744 }
johnAlexander 14:8320b5ff96fa 1745
johnAlexander 14:8320b5ff96fa 1746 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 1747 status = VL53L0X_read_byte(dev,
johnAlexander 14:8320b5ff96fa 1748 VL53L0X_REG_IDENTIFICATION_REVISION_ID,
johnAlexander 14:8320b5ff96fa 1749 &revision_id);
Davidroid 16:27d3d95c8593 1750 p_VL53L0X_device_info->ProductRevisionMajor = 1;
Davidroid 16:27d3d95c8593 1751 p_VL53L0X_device_info->ProductRevisionMinor =
johnAlexander 14:8320b5ff96fa 1752 (revision_id & 0xF0) >> 4;
johnAlexander 14:8320b5ff96fa 1753 }
johnAlexander 14:8320b5ff96fa 1754
johnAlexander 14:8320b5ff96fa 1755 return status;
johnAlexander 0:c523920bcc09 1756 }
johnAlexander 0:c523920bcc09 1757
Davidroid 16:27d3d95c8593 1758 VL53L0X_Error VL53L0X::VL53L0X_get_device_info(VL53L0X_DEV dev,
Davidroid 16:27d3d95c8593 1759 VL53L0X_DeviceInfo_t *p_VL53L0X_device_info)
johnAlexander 0:c523920bcc09 1760 {
johnAlexander 14:8320b5ff96fa 1761 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 1762 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 1763
Davidroid 16:27d3d95c8593 1764 status = wrapped_VL53L0X_get_device_info(dev, p_VL53L0X_device_info);
johnAlexander 14:8320b5ff96fa 1765
johnAlexander 14:8320b5ff96fa 1766 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 1767 return status;
johnAlexander 0:c523920bcc09 1768 }
johnAlexander 0:c523920bcc09 1769
Davidroid 16:27d3d95c8593 1770 VL53L0X_Error VL53L0X::VL53L0X_get_interrupt_mask_status(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 1771 uint32_t *p_interrupt_mask_status)
johnAlexander 0:c523920bcc09 1772 {
johnAlexander 14:8320b5ff96fa 1773 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 1774 uint8_t byte;
johnAlexander 14:8320b5ff96fa 1775 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 1776
Davidroid 16:27d3d95c8593 1777 status = VL53L0X_read_byte(dev, VL53L0X_REG_RESULT_INTERRUPT_STATUS, &byte);
johnAlexander 14:8320b5ff96fa 1778 *p_interrupt_mask_status = byte & 0x07;
johnAlexander 14:8320b5ff96fa 1779
Davidroid 16:27d3d95c8593 1780 if (byte & 0x18) {
johnAlexander 14:8320b5ff96fa 1781 status = VL53L0X_ERROR_RANGE_ERROR;
Davidroid 16:27d3d95c8593 1782 }
johnAlexander 14:8320b5ff96fa 1783
johnAlexander 14:8320b5ff96fa 1784 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 1785 return status;
johnAlexander 0:c523920bcc09 1786 }
johnAlexander 0:c523920bcc09 1787
Davidroid 16:27d3d95c8593 1788 VL53L0X_Error VL53L0X::VL53L0X_get_measurement_data_ready(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 1789 uint8_t *p_measurement_data_ready)
johnAlexander 0:c523920bcc09 1790 {
johnAlexander 14:8320b5ff96fa 1791 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 1792 uint8_t sys_range_status_register;
johnAlexander 14:8320b5ff96fa 1793 uint8_t interrupt_config;
johnAlexander 14:8320b5ff96fa 1794 uint32_t interrupt_mask;
johnAlexander 14:8320b5ff96fa 1795 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 1796
johnAlexander 14:8320b5ff96fa 1797 interrupt_config = VL53L0X_GETDEVICESPECIFICPARAMETER(dev,
johnAlexander 14:8320b5ff96fa 1798 Pin0GpioFunctionality);
johnAlexander 14:8320b5ff96fa 1799
johnAlexander 14:8320b5ff96fa 1800 if (interrupt_config ==
johnAlexander 14:8320b5ff96fa 1801 VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY) {
Davidroid 16:27d3d95c8593 1802 status = VL53L0X_get_interrupt_mask_status(dev, &interrupt_mask);
johnAlexander 14:8320b5ff96fa 1803 if (interrupt_mask ==
Davidroid 16:27d3d95c8593 1804 VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY) {
johnAlexander 14:8320b5ff96fa 1805 *p_measurement_data_ready = 1;
Davidroid 16:27d3d95c8593 1806 } else {
johnAlexander 14:8320b5ff96fa 1807 *p_measurement_data_ready = 0;
Davidroid 16:27d3d95c8593 1808 }
johnAlexander 14:8320b5ff96fa 1809 } else {
Davidroid 16:27d3d95c8593 1810 status = VL53L0X_read_byte(dev, VL53L0X_REG_RESULT_RANGE_STATUS,
johnAlexander 14:8320b5ff96fa 1811 &sys_range_status_register);
johnAlexander 14:8320b5ff96fa 1812 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 1813 if (sys_range_status_register & 0x01) {
johnAlexander 14:8320b5ff96fa 1814 *p_measurement_data_ready = 1;
Davidroid 16:27d3d95c8593 1815 } else {
johnAlexander 14:8320b5ff96fa 1816 *p_measurement_data_ready = 0;
Davidroid 16:27d3d95c8593 1817 }
johnAlexander 14:8320b5ff96fa 1818 }
johnAlexander 14:8320b5ff96fa 1819 }
johnAlexander 14:8320b5ff96fa 1820
johnAlexander 14:8320b5ff96fa 1821 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 1822 return status;
johnAlexander 0:c523920bcc09 1823 }
johnAlexander 0:c523920bcc09 1824
Davidroid 16:27d3d95c8593 1825 VL53L0X_Error VL53L0X::VL53L0X_polling_delay(VL53L0X_DEV dev)
johnAlexander 14:8320b5ff96fa 1826 {
johnAlexander 0:c523920bcc09 1827 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 0:c523920bcc09 1828
johnAlexander 0:c523920bcc09 1829 // do nothing
johnAlexander 0:c523920bcc09 1830 VL53L0X_OsDelay();
johnAlexander 0:c523920bcc09 1831 return status;
johnAlexander 0:c523920bcc09 1832 }
johnAlexander 0:c523920bcc09 1833
Davidroid 16:27d3d95c8593 1834 VL53L0X_Error VL53L0X::VL53L0X_measurement_poll_for_completion(VL53L0X_DEV dev)
johnAlexander 0:c523920bcc09 1835 {
johnAlexander 14:8320b5ff96fa 1836 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 1837 uint8_t new_data_ready = 0;
johnAlexander 14:8320b5ff96fa 1838 uint32_t loop_nb;
johnAlexander 14:8320b5ff96fa 1839
johnAlexander 14:8320b5ff96fa 1840 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 1841
johnAlexander 14:8320b5ff96fa 1842 loop_nb = 0;
johnAlexander 14:8320b5ff96fa 1843
johnAlexander 14:8320b5ff96fa 1844 do {
Davidroid 16:27d3d95c8593 1845 status = VL53L0X_get_measurement_data_ready(dev, &new_data_ready);
Davidroid 16:27d3d95c8593 1846 if (status != 0) {
johnAlexander 14:8320b5ff96fa 1847 break; /* the error is set */
Davidroid 16:27d3d95c8593 1848 }
Davidroid 16:27d3d95c8593 1849
Davidroid 16:27d3d95c8593 1850 if (new_data_ready == 1) {
johnAlexander 14:8320b5ff96fa 1851 break; /* done note that status == 0 */
Davidroid 16:27d3d95c8593 1852 }
johnAlexander 14:8320b5ff96fa 1853
johnAlexander 14:8320b5ff96fa 1854 loop_nb++;
johnAlexander 14:8320b5ff96fa 1855 if (loop_nb >= VL53L0X_DEFAULT_MAX_LOOP) {
johnAlexander 14:8320b5ff96fa 1856 status = VL53L0X_ERROR_TIME_OUT;
johnAlexander 14:8320b5ff96fa 1857 break;
johnAlexander 14:8320b5ff96fa 1858 }
johnAlexander 14:8320b5ff96fa 1859
Davidroid 16:27d3d95c8593 1860 VL53L0X_polling_delay(dev);
johnAlexander 14:8320b5ff96fa 1861 } while (1);
johnAlexander 14:8320b5ff96fa 1862
johnAlexander 14:8320b5ff96fa 1863 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 1864
johnAlexander 14:8320b5ff96fa 1865 return status;
johnAlexander 0:c523920bcc09 1866 }
johnAlexander 0:c523920bcc09 1867
johnAlexander 0:c523920bcc09 1868 /* Group PAL Interrupt Functions */
Davidroid 16:27d3d95c8593 1869 VL53L0X_Error VL53L0X::VL53L0X_clear_interrupt_mask(VL53L0X_DEV dev, uint32_t interrupt_mask)
johnAlexander 0:c523920bcc09 1870 {
johnAlexander 14:8320b5ff96fa 1871 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 1872 uint8_t loop_count;
johnAlexander 14:8320b5ff96fa 1873 uint8_t byte;
johnAlexander 14:8320b5ff96fa 1874 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 1875
johnAlexander 14:8320b5ff96fa 1876 /* clear bit 0 range interrupt, bit 1 error interrupt */
johnAlexander 14:8320b5ff96fa 1877 loop_count = 0;
johnAlexander 14:8320b5ff96fa 1878 do {
Davidroid 16:27d3d95c8593 1879 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 1880 VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR, 0x01);
Davidroid 16:27d3d95c8593 1881 status |= VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 1882 VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR, 0x00);
Davidroid 16:27d3d95c8593 1883 status |= VL53L0X_read_byte(dev,
johnAlexander 14:8320b5ff96fa 1884 VL53L0X_REG_RESULT_INTERRUPT_STATUS, &byte);
johnAlexander 14:8320b5ff96fa 1885 loop_count++;
johnAlexander 14:8320b5ff96fa 1886 } while (((byte & 0x07) != 0x00)
johnAlexander 14:8320b5ff96fa 1887 && (loop_count < 3)
johnAlexander 14:8320b5ff96fa 1888 && (status == VL53L0X_ERROR_NONE));
johnAlexander 14:8320b5ff96fa 1889
johnAlexander 14:8320b5ff96fa 1890
Davidroid 16:27d3d95c8593 1891 if (loop_count >= 3) {
johnAlexander 14:8320b5ff96fa 1892 status = VL53L0X_ERROR_INTERRUPT_NOT_CLEARED;
Davidroid 16:27d3d95c8593 1893 }
johnAlexander 14:8320b5ff96fa 1894
johnAlexander 14:8320b5ff96fa 1895 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 1896 return status;
johnAlexander 0:c523920bcc09 1897 }
johnAlexander 0:c523920bcc09 1898
Davidroid 16:27d3d95c8593 1899 VL53L0X_Error VL53L0X::VL53L0X_perform_single_ref_calibration(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 1900 uint8_t vhv_init_byte)
johnAlexander 0:c523920bcc09 1901 {
johnAlexander 14:8320b5ff96fa 1902 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 1903
Davidroid 16:27d3d95c8593 1904 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 1905 status = VL53L0X_write_byte(dev, VL53L0X_REG_SYSRANGE_START,
johnAlexander 14:8320b5ff96fa 1906 VL53L0X_REG_SYSRANGE_MODE_START_STOP |
johnAlexander 14:8320b5ff96fa 1907 vhv_init_byte);
Davidroid 16:27d3d95c8593 1908 }
Davidroid 16:27d3d95c8593 1909
Davidroid 16:27d3d95c8593 1910 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 1911 status = VL53L0X_measurement_poll_for_completion(dev);
Davidroid 16:27d3d95c8593 1912 }
Davidroid 16:27d3d95c8593 1913
Davidroid 16:27d3d95c8593 1914 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 1915 status = VL53L0X_clear_interrupt_mask(dev, 0);
Davidroid 16:27d3d95c8593 1916 }
Davidroid 16:27d3d95c8593 1917
Davidroid 16:27d3d95c8593 1918 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 1919 status = VL53L0X_write_byte(dev, VL53L0X_REG_SYSRANGE_START, 0x00);
Davidroid 16:27d3d95c8593 1920 }
johnAlexander 14:8320b5ff96fa 1921
johnAlexander 14:8320b5ff96fa 1922 return status;
johnAlexander 0:c523920bcc09 1923 }
johnAlexander 0:c523920bcc09 1924
Davidroid 16:27d3d95c8593 1925 VL53L0X_Error VL53L0X::VL53L0X_ref_calibration_io(VL53L0X_DEV dev, uint8_t read_not_write,
johnAlexander 14:8320b5ff96fa 1926 uint8_t vhv_settings, uint8_t phase_cal,
johnAlexander 14:8320b5ff96fa 1927 uint8_t *p_vhv_settings, uint8_t *p_phase_cal,
johnAlexander 14:8320b5ff96fa 1928 const uint8_t vhv_enable, const uint8_t phase_enable)
johnAlexander 0:c523920bcc09 1929 {
johnAlexander 14:8320b5ff96fa 1930 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 1931 uint8_t phase_calint = 0;
johnAlexander 14:8320b5ff96fa 1932
johnAlexander 14:8320b5ff96fa 1933 /* Read VHV from device */
Davidroid 16:27d3d95c8593 1934 status |= VL53L0X_write_byte(dev, 0xFF, 0x01);
Davidroid 16:27d3d95c8593 1935 status |= VL53L0X_write_byte(dev, 0x00, 0x00);
Davidroid 16:27d3d95c8593 1936 status |= VL53L0X_write_byte(dev, 0xFF, 0x00);
johnAlexander 14:8320b5ff96fa 1937
johnAlexander 14:8320b5ff96fa 1938 if (read_not_write) {
Davidroid 16:27d3d95c8593 1939 if (vhv_enable) {
Davidroid 16:27d3d95c8593 1940 status |= VL53L0X_read_byte(dev, 0xCB, p_vhv_settings);
Davidroid 16:27d3d95c8593 1941 }
Davidroid 16:27d3d95c8593 1942 if (phase_enable) {
Davidroid 16:27d3d95c8593 1943 status |= VL53L0X_read_byte(dev, 0xEE, &phase_calint);
Davidroid 16:27d3d95c8593 1944 }
johnAlexander 14:8320b5ff96fa 1945 } else {
Davidroid 16:27d3d95c8593 1946 if (vhv_enable) {
Davidroid 16:27d3d95c8593 1947 status |= VL53L0X_write_byte(dev, 0xCB, vhv_settings);
Davidroid 16:27d3d95c8593 1948 }
Davidroid 16:27d3d95c8593 1949 if (phase_enable) {
Davidroid 16:27d3d95c8593 1950 status |= VL53L0X_update_byte(dev, 0xEE, 0x80, phase_cal);
Davidroid 16:27d3d95c8593 1951 }
johnAlexander 14:8320b5ff96fa 1952 }
johnAlexander 14:8320b5ff96fa 1953
Davidroid 16:27d3d95c8593 1954 status |= VL53L0X_write_byte(dev, 0xFF, 0x01);
Davidroid 16:27d3d95c8593 1955 status |= VL53L0X_write_byte(dev, 0x00, 0x01);
Davidroid 16:27d3d95c8593 1956 status |= VL53L0X_write_byte(dev, 0xFF, 0x00);
johnAlexander 14:8320b5ff96fa 1957
johnAlexander 14:8320b5ff96fa 1958 *p_phase_cal = (uint8_t)(phase_calint & 0xEF);
johnAlexander 14:8320b5ff96fa 1959
johnAlexander 14:8320b5ff96fa 1960 return status;
johnAlexander 0:c523920bcc09 1961 }
johnAlexander 0:c523920bcc09 1962
Davidroid 16:27d3d95c8593 1963 VL53L0X_Error VL53L0X::VL53L0X_perform_vhv_calibration(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 1964 uint8_t *p_vhv_settings, const uint8_t get_data_enable,
johnAlexander 14:8320b5ff96fa 1965 const uint8_t restore_config)
johnAlexander 0:c523920bcc09 1966 {
johnAlexander 14:8320b5ff96fa 1967 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 1968 uint8_t sequence_config = 0;
johnAlexander 14:8320b5ff96fa 1969 uint8_t vhv_settings = 0;
johnAlexander 14:8320b5ff96fa 1970 uint8_t phase_cal = 0;
johnAlexander 14:8320b5ff96fa 1971 uint8_t phase_cal_int = 0;
johnAlexander 14:8320b5ff96fa 1972
johnAlexander 14:8320b5ff96fa 1973 /* store the value of the sequence config,
johnAlexander 14:8320b5ff96fa 1974 * this will be reset before the end of the function
johnAlexander 14:8320b5ff96fa 1975 */
johnAlexander 14:8320b5ff96fa 1976
Davidroid 16:27d3d95c8593 1977 if (restore_config) {
johnAlexander 14:8320b5ff96fa 1978 sequence_config = PALDevDataGet(dev, SequenceConfig);
Davidroid 16:27d3d95c8593 1979 }
johnAlexander 14:8320b5ff96fa 1980
johnAlexander 14:8320b5ff96fa 1981 /* Run VHV */
Davidroid 16:27d3d95c8593 1982 status = VL53L0X_write_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, 0x01);
Davidroid 16:27d3d95c8593 1983
Davidroid 16:27d3d95c8593 1984 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 1985 status = VL53L0X_perform_single_ref_calibration(dev, 0x40);
Davidroid 16:27d3d95c8593 1986 }
johnAlexander 14:8320b5ff96fa 1987
johnAlexander 14:8320b5ff96fa 1988 /* Read VHV from device */
johnAlexander 14:8320b5ff96fa 1989 if ((status == VL53L0X_ERROR_NONE) && (get_data_enable == 1)) {
Davidroid 16:27d3d95c8593 1990 status = VL53L0X_ref_calibration_io(dev, 1,
johnAlexander 14:8320b5ff96fa 1991 vhv_settings, phase_cal, /* Not used here */
johnAlexander 14:8320b5ff96fa 1992 p_vhv_settings, &phase_cal_int,
johnAlexander 14:8320b5ff96fa 1993 1, 0);
Davidroid 16:27d3d95c8593 1994 } else {
johnAlexander 14:8320b5ff96fa 1995 *p_vhv_settings = 0;
Davidroid 16:27d3d95c8593 1996 }
johnAlexander 14:8320b5ff96fa 1997
johnAlexander 14:8320b5ff96fa 1998
johnAlexander 14:8320b5ff96fa 1999 if ((status == VL53L0X_ERROR_NONE) && restore_config) {
johnAlexander 14:8320b5ff96fa 2000 /* restore the previous Sequence Config */
Davidroid 16:27d3d95c8593 2001 status = VL53L0X_write_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
johnAlexander 14:8320b5ff96fa 2002 sequence_config);
Davidroid 16:27d3d95c8593 2003 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 2004 PALDevDataSet(dev, SequenceConfig, sequence_config);
Davidroid 16:27d3d95c8593 2005 }
johnAlexander 14:8320b5ff96fa 2006
johnAlexander 14:8320b5ff96fa 2007 }
johnAlexander 14:8320b5ff96fa 2008
johnAlexander 14:8320b5ff96fa 2009 return status;
johnAlexander 0:c523920bcc09 2010 }
johnAlexander 0:c523920bcc09 2011
Davidroid 16:27d3d95c8593 2012 VL53L0X_Error VL53L0X::VL53L0X_perform_phase_calibration(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 2013 uint8_t *p_phase_cal, const uint8_t get_data_enable,
johnAlexander 14:8320b5ff96fa 2014 const uint8_t restore_config)
johnAlexander 0:c523920bcc09 2015 {
johnAlexander 14:8320b5ff96fa 2016 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 2017 uint8_t sequence_config = 0;
johnAlexander 14:8320b5ff96fa 2018 uint8_t vhv_settings = 0;
johnAlexander 14:8320b5ff96fa 2019 uint8_t phase_cal = 0;
johnAlexander 14:8320b5ff96fa 2020 uint8_t vhv_settingsint;
johnAlexander 14:8320b5ff96fa 2021
johnAlexander 14:8320b5ff96fa 2022 /* store the value of the sequence config,
johnAlexander 14:8320b5ff96fa 2023 * this will be reset before the end of the function
johnAlexander 14:8320b5ff96fa 2024 */
johnAlexander 14:8320b5ff96fa 2025
johnAlexander 14:8320b5ff96fa 2026 if (restore_config)
johnAlexander 14:8320b5ff96fa 2027 sequence_config = PALDevDataGet(dev, SequenceConfig);
johnAlexander 14:8320b5ff96fa 2028
johnAlexander 14:8320b5ff96fa 2029 /* Run PhaseCal */
Davidroid 16:27d3d95c8593 2030 status = VL53L0X_write_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, 0x02);
Davidroid 16:27d3d95c8593 2031
Davidroid 16:27d3d95c8593 2032 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 2033 status = VL53L0X_perform_single_ref_calibration(dev, 0x0);
Davidroid 16:27d3d95c8593 2034 }
johnAlexander 14:8320b5ff96fa 2035
johnAlexander 14:8320b5ff96fa 2036 /* Read PhaseCal from device */
johnAlexander 14:8320b5ff96fa 2037 if ((status == VL53L0X_ERROR_NONE) && (get_data_enable == 1)) {
Davidroid 16:27d3d95c8593 2038 status = VL53L0X_ref_calibration_io(dev, 1,
johnAlexander 14:8320b5ff96fa 2039 vhv_settings, phase_cal, /* Not used here */
johnAlexander 14:8320b5ff96fa 2040 &vhv_settingsint, p_phase_cal,
johnAlexander 14:8320b5ff96fa 2041 0, 1);
Davidroid 16:27d3d95c8593 2042 } else {
johnAlexander 14:8320b5ff96fa 2043 *p_phase_cal = 0;
Davidroid 16:27d3d95c8593 2044 }
johnAlexander 14:8320b5ff96fa 2045
johnAlexander 14:8320b5ff96fa 2046
johnAlexander 14:8320b5ff96fa 2047 if ((status == VL53L0X_ERROR_NONE) && restore_config) {
johnAlexander 14:8320b5ff96fa 2048 /* restore the previous Sequence Config */
Davidroid 16:27d3d95c8593 2049 status = VL53L0X_write_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
johnAlexander 14:8320b5ff96fa 2050 sequence_config);
Davidroid 16:27d3d95c8593 2051 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 2052 PALDevDataSet(dev, SequenceConfig, sequence_config);
Davidroid 16:27d3d95c8593 2053 }
johnAlexander 14:8320b5ff96fa 2054
johnAlexander 14:8320b5ff96fa 2055 }
johnAlexander 14:8320b5ff96fa 2056
johnAlexander 14:8320b5ff96fa 2057 return status;
johnAlexander 0:c523920bcc09 2058 }
johnAlexander 0:c523920bcc09 2059
Davidroid 16:27d3d95c8593 2060 VL53L0X_Error VL53L0X::VL53L0X_perform_ref_calibration(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 2061 uint8_t *p_vhv_settings, uint8_t *p_phase_cal, uint8_t get_data_enable)
johnAlexander 0:c523920bcc09 2062 {
johnAlexander 14:8320b5ff96fa 2063 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 2064 uint8_t sequence_config = 0;
johnAlexander 14:8320b5ff96fa 2065
johnAlexander 14:8320b5ff96fa 2066 /* store the value of the sequence config,
johnAlexander 14:8320b5ff96fa 2067 * this will be reset before the end of the function
johnAlexander 14:8320b5ff96fa 2068 */
johnAlexander 14:8320b5ff96fa 2069
johnAlexander 14:8320b5ff96fa 2070 sequence_config = PALDevDataGet(dev, SequenceConfig);
johnAlexander 14:8320b5ff96fa 2071
johnAlexander 14:8320b5ff96fa 2072 /* In the following function we don't save the config to optimize
johnAlexander 14:8320b5ff96fa 2073 * writes on device. Config is saved and restored only once. */
Davidroid 16:27d3d95c8593 2074 status = VL53L0X_perform_vhv_calibration(
johnAlexander 14:8320b5ff96fa 2075 dev, p_vhv_settings, get_data_enable, 0);
johnAlexander 14:8320b5ff96fa 2076
Davidroid 16:27d3d95c8593 2077 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 2078 status = VL53L0X_perform_phase_calibration(
johnAlexander 14:8320b5ff96fa 2079 dev, p_phase_cal, get_data_enable, 0);
Davidroid 16:27d3d95c8593 2080 }
johnAlexander 14:8320b5ff96fa 2081
johnAlexander 14:8320b5ff96fa 2082
johnAlexander 14:8320b5ff96fa 2083 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 2084 /* restore the previous Sequence Config */
Davidroid 16:27d3d95c8593 2085 status = VL53L0X_write_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
johnAlexander 14:8320b5ff96fa 2086 sequence_config);
Davidroid 16:27d3d95c8593 2087 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 2088 PALDevDataSet(dev, SequenceConfig, sequence_config);
Davidroid 16:27d3d95c8593 2089 }
johnAlexander 14:8320b5ff96fa 2090
johnAlexander 14:8320b5ff96fa 2091 }
johnAlexander 14:8320b5ff96fa 2092
johnAlexander 14:8320b5ff96fa 2093 return status;
johnAlexander 0:c523920bcc09 2094 }
johnAlexander 0:c523920bcc09 2095
johnAlexander 14:8320b5ff96fa 2096 void VL53L0X::get_next_good_spad(uint8_t good_spad_array[], uint32_t size,
johnAlexander 14:8320b5ff96fa 2097 uint32_t curr, int32_t *p_next)
johnAlexander 0:c523920bcc09 2098 {
johnAlexander 14:8320b5ff96fa 2099 uint32_t start_index;
johnAlexander 14:8320b5ff96fa 2100 uint32_t fine_offset;
johnAlexander 14:8320b5ff96fa 2101 uint32_t c_spads_per_byte = 8;
johnAlexander 14:8320b5ff96fa 2102 uint32_t coarse_index;
johnAlexander 14:8320b5ff96fa 2103 uint32_t fine_index;
johnAlexander 14:8320b5ff96fa 2104 uint8_t data_byte;
johnAlexander 14:8320b5ff96fa 2105 uint8_t success = 0;
johnAlexander 14:8320b5ff96fa 2106
johnAlexander 14:8320b5ff96fa 2107 /*
johnAlexander 14:8320b5ff96fa 2108 * Starting with the current good spad, loop through the array to find
johnAlexander 14:8320b5ff96fa 2109 * the next. i.e. the next bit set in the sequence.
johnAlexander 14:8320b5ff96fa 2110 *
johnAlexander 14:8320b5ff96fa 2111 * The coarse index is the byte index of the array and the fine index is
johnAlexander 14:8320b5ff96fa 2112 * the index of the bit within each byte.
johnAlexander 14:8320b5ff96fa 2113 */
johnAlexander 14:8320b5ff96fa 2114
johnAlexander 14:8320b5ff96fa 2115 *p_next = -1;
johnAlexander 14:8320b5ff96fa 2116
johnAlexander 14:8320b5ff96fa 2117 start_index = curr / c_spads_per_byte;
johnAlexander 14:8320b5ff96fa 2118 fine_offset = curr % c_spads_per_byte;
johnAlexander 14:8320b5ff96fa 2119
johnAlexander 14:8320b5ff96fa 2120 for (coarse_index = start_index; ((coarse_index < size) && !success);
johnAlexander 14:8320b5ff96fa 2121 coarse_index++) {
johnAlexander 14:8320b5ff96fa 2122 fine_index = 0;
johnAlexander 14:8320b5ff96fa 2123 data_byte = good_spad_array[coarse_index];
johnAlexander 14:8320b5ff96fa 2124
johnAlexander 14:8320b5ff96fa 2125 if (coarse_index == start_index) {
johnAlexander 14:8320b5ff96fa 2126 /* locate the bit position of the provided current
johnAlexander 14:8320b5ff96fa 2127 * spad bit before iterating */
johnAlexander 14:8320b5ff96fa 2128 data_byte >>= fine_offset;
johnAlexander 14:8320b5ff96fa 2129 fine_index = fine_offset;
johnAlexander 14:8320b5ff96fa 2130 }
johnAlexander 14:8320b5ff96fa 2131
johnAlexander 14:8320b5ff96fa 2132 while (fine_index < c_spads_per_byte) {
johnAlexander 14:8320b5ff96fa 2133 if ((data_byte & 0x1) == 1) {
johnAlexander 14:8320b5ff96fa 2134 success = 1;
johnAlexander 14:8320b5ff96fa 2135 *p_next = coarse_index * c_spads_per_byte + fine_index;
johnAlexander 14:8320b5ff96fa 2136 break;
johnAlexander 14:8320b5ff96fa 2137 }
johnAlexander 14:8320b5ff96fa 2138 data_byte >>= 1;
johnAlexander 14:8320b5ff96fa 2139 fine_index++;
johnAlexander 14:8320b5ff96fa 2140 }
johnAlexander 14:8320b5ff96fa 2141 }
johnAlexander 0:c523920bcc09 2142 }
johnAlexander 0:c523920bcc09 2143
johnAlexander 14:8320b5ff96fa 2144 uint8_t VL53L0X::is_aperture(uint32_t spad_index)
johnAlexander 0:c523920bcc09 2145 {
johnAlexander 14:8320b5ff96fa 2146 /*
johnAlexander 14:8320b5ff96fa 2147 * This function reports if a given spad index is an aperture SPAD by
johnAlexander 14:8320b5ff96fa 2148 * deriving the quadrant.
johnAlexander 14:8320b5ff96fa 2149 */
johnAlexander 14:8320b5ff96fa 2150 uint32_t quadrant;
johnAlexander 14:8320b5ff96fa 2151 uint8_t is_aperture = 1;
johnAlexander 14:8320b5ff96fa 2152 quadrant = spad_index >> 6;
Davidroid 16:27d3d95c8593 2153 if (refArrayQuadrants[quadrant] == REF_ARRAY_SPAD_0) {
johnAlexander 14:8320b5ff96fa 2154 is_aperture = 0;
Davidroid 16:27d3d95c8593 2155 }
johnAlexander 14:8320b5ff96fa 2156
johnAlexander 14:8320b5ff96fa 2157 return is_aperture;
johnAlexander 0:c523920bcc09 2158 }
johnAlexander 0:c523920bcc09 2159
johnAlexander 14:8320b5ff96fa 2160 VL53L0X_Error VL53L0X::enable_spad_bit(uint8_t spad_array[], uint32_t size,
johnAlexander 14:8320b5ff96fa 2161 uint32_t spad_index)
johnAlexander 0:c523920bcc09 2162 {
johnAlexander 14:8320b5ff96fa 2163 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 2164 uint32_t c_spads_per_byte = 8;
johnAlexander 14:8320b5ff96fa 2165 uint32_t coarse_index;
johnAlexander 14:8320b5ff96fa 2166 uint32_t fine_index;
johnAlexander 14:8320b5ff96fa 2167
johnAlexander 14:8320b5ff96fa 2168 coarse_index = spad_index / c_spads_per_byte;
johnAlexander 14:8320b5ff96fa 2169 fine_index = spad_index % c_spads_per_byte;
Davidroid 16:27d3d95c8593 2170 if (coarse_index >= size) {
johnAlexander 14:8320b5ff96fa 2171 status = VL53L0X_ERROR_REF_SPAD_INIT;
Davidroid 16:27d3d95c8593 2172 } else {
johnAlexander 14:8320b5ff96fa 2173 spad_array[coarse_index] |= (1 << fine_index);
Davidroid 16:27d3d95c8593 2174 }
johnAlexander 14:8320b5ff96fa 2175
johnAlexander 14:8320b5ff96fa 2176 return status;
johnAlexander 0:c523920bcc09 2177 }
johnAlexander 0:c523920bcc09 2178
johnAlexander 14:8320b5ff96fa 2179 VL53L0X_Error VL53L0X::set_ref_spad_map(VL53L0X_DEV dev, uint8_t *p_ref_spad_array)
johnAlexander 0:c523920bcc09 2180 {
Davidroid 16:27d3d95c8593 2181 VL53L0X_Error status = VL53L0X_write_multi(dev,
johnAlexander 14:8320b5ff96fa 2182 VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_0,
johnAlexander 14:8320b5ff96fa 2183 p_ref_spad_array, 6);
johnAlexander 14:8320b5ff96fa 2184
johnAlexander 14:8320b5ff96fa 2185 return status;
johnAlexander 0:c523920bcc09 2186 }
johnAlexander 0:c523920bcc09 2187
johnAlexander 14:8320b5ff96fa 2188 VL53L0X_Error VL53L0X::get_ref_spad_map(VL53L0X_DEV dev, uint8_t *p_ref_spad_array)
johnAlexander 0:c523920bcc09 2189 {
Davidroid 16:27d3d95c8593 2190 VL53L0X_Error status = VL53L0X_read_multi(dev,
johnAlexander 14:8320b5ff96fa 2191 VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_0,
johnAlexander 14:8320b5ff96fa 2192 p_ref_spad_array,
johnAlexander 14:8320b5ff96fa 2193 6);
johnAlexander 0:c523920bcc09 2194 // VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 0:c523920bcc09 2195 // uint8_t count=0;
johnAlexander 0:c523920bcc09 2196
johnAlexander 0:c523920bcc09 2197 // for (count = 0; count < 6; count++)
johnAlexander 0:c523920bcc09 2198 // status = VL53L0X_RdByte(Dev, (VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_0 + count), &refSpadArray[count]);
johnAlexander 14:8320b5ff96fa 2199 return status;
johnAlexander 0:c523920bcc09 2200 }
johnAlexander 0:c523920bcc09 2201
johnAlexander 14:8320b5ff96fa 2202 VL53L0X_Error VL53L0X::enable_ref_spads(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 2203 uint8_t aperture_spads,
johnAlexander 14:8320b5ff96fa 2204 uint8_t good_spad_array[],
johnAlexander 14:8320b5ff96fa 2205 uint8_t spad_array[],
johnAlexander 14:8320b5ff96fa 2206 uint32_t size,
johnAlexander 14:8320b5ff96fa 2207 uint32_t start,
johnAlexander 14:8320b5ff96fa 2208 uint32_t offset,
johnAlexander 14:8320b5ff96fa 2209 uint32_t spad_count,
johnAlexander 14:8320b5ff96fa 2210 uint32_t *p_last_spad)
johnAlexander 0:c523920bcc09 2211 {
johnAlexander 14:8320b5ff96fa 2212 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 2213 uint32_t index;
johnAlexander 14:8320b5ff96fa 2214 uint32_t i;
johnAlexander 14:8320b5ff96fa 2215 int32_t next_good_spad = offset;
johnAlexander 14:8320b5ff96fa 2216 uint32_t current_spad;
johnAlexander 14:8320b5ff96fa 2217 uint8_t check_spad_array[6];
johnAlexander 14:8320b5ff96fa 2218
johnAlexander 14:8320b5ff96fa 2219 /*
johnAlexander 14:8320b5ff96fa 2220 * This function takes in a spad array which may or may not have SPADS
johnAlexander 14:8320b5ff96fa 2221 * already enabled and appends from a given offset a requested number
johnAlexander 14:8320b5ff96fa 2222 * of new SPAD enables. The 'good spad map' is applied to
johnAlexander 14:8320b5ff96fa 2223 * determine the next SPADs to enable.
johnAlexander 14:8320b5ff96fa 2224 *
johnAlexander 14:8320b5ff96fa 2225 * This function applies to only aperture or only non-aperture spads.
johnAlexander 14:8320b5ff96fa 2226 * Checks are performed to ensure this.
johnAlexander 14:8320b5ff96fa 2227 */
johnAlexander 14:8320b5ff96fa 2228
johnAlexander 14:8320b5ff96fa 2229 current_spad = offset;
johnAlexander 14:8320b5ff96fa 2230 for (index = 0; index < spad_count; index++) {
johnAlexander 14:8320b5ff96fa 2231 get_next_good_spad(good_spad_array, size, current_spad,
johnAlexander 14:8320b5ff96fa 2232 &next_good_spad);
johnAlexander 14:8320b5ff96fa 2233
johnAlexander 14:8320b5ff96fa 2234 if (next_good_spad == -1) {
johnAlexander 14:8320b5ff96fa 2235 status = VL53L0X_ERROR_REF_SPAD_INIT;
johnAlexander 14:8320b5ff96fa 2236 break;
johnAlexander 14:8320b5ff96fa 2237 }
johnAlexander 14:8320b5ff96fa 2238
johnAlexander 14:8320b5ff96fa 2239 /* Confirm that the next good SPAD is non-aperture */
johnAlexander 14:8320b5ff96fa 2240 if (is_aperture(start + next_good_spad) != aperture_spads) {
johnAlexander 14:8320b5ff96fa 2241 /* if we can't get the required number of good aperture
johnAlexander 14:8320b5ff96fa 2242 * spads from the current quadrant then this is an error
johnAlexander 14:8320b5ff96fa 2243 */
johnAlexander 14:8320b5ff96fa 2244 status = VL53L0X_ERROR_REF_SPAD_INIT;
johnAlexander 14:8320b5ff96fa 2245 break;
johnAlexander 14:8320b5ff96fa 2246 }
johnAlexander 14:8320b5ff96fa 2247 current_spad = (uint32_t)next_good_spad;
johnAlexander 14:8320b5ff96fa 2248 enable_spad_bit(spad_array, size, current_spad);
johnAlexander 14:8320b5ff96fa 2249 current_spad++;
johnAlexander 14:8320b5ff96fa 2250 }
johnAlexander 14:8320b5ff96fa 2251 *p_last_spad = current_spad;
johnAlexander 14:8320b5ff96fa 2252
Davidroid 16:27d3d95c8593 2253 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 2254 status = set_ref_spad_map(dev, spad_array);
Davidroid 16:27d3d95c8593 2255 }
johnAlexander 14:8320b5ff96fa 2256
johnAlexander 14:8320b5ff96fa 2257
johnAlexander 14:8320b5ff96fa 2258 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 2259 status = get_ref_spad_map(dev, check_spad_array);
johnAlexander 14:8320b5ff96fa 2260
johnAlexander 14:8320b5ff96fa 2261 i = 0;
johnAlexander 14:8320b5ff96fa 2262
johnAlexander 14:8320b5ff96fa 2263 /* Compare spad maps. If not equal report error. */
johnAlexander 14:8320b5ff96fa 2264 while (i < size) {
johnAlexander 14:8320b5ff96fa 2265 if (spad_array[i] != check_spad_array[i]) {
johnAlexander 14:8320b5ff96fa 2266 status = VL53L0X_ERROR_REF_SPAD_INIT;
johnAlexander 14:8320b5ff96fa 2267 break;
johnAlexander 14:8320b5ff96fa 2268 }
johnAlexander 14:8320b5ff96fa 2269 i++;
johnAlexander 14:8320b5ff96fa 2270 }
johnAlexander 14:8320b5ff96fa 2271 }
johnAlexander 14:8320b5ff96fa 2272 return status;
johnAlexander 0:c523920bcc09 2273 }
johnAlexander 0:c523920bcc09 2274
Davidroid 16:27d3d95c8593 2275 VL53L0X_Error VL53L0X::VL53L0X_set_device_mode(VL53L0X_DEV dev, VL53L0X_DeviceModes device_mode)
johnAlexander 0:c523920bcc09 2276 {
johnAlexander 14:8320b5ff96fa 2277 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 2278
johnAlexander 14:8320b5ff96fa 2279 LOG_FUNCTION_START("%d", (int)DeviceMode);
johnAlexander 14:8320b5ff96fa 2280
johnAlexander 14:8320b5ff96fa 2281 switch (device_mode) {
johnAlexander 14:8320b5ff96fa 2282 case VL53L0X_DEVICEMODE_SINGLE_RANGING:
johnAlexander 14:8320b5ff96fa 2283 case VL53L0X_DEVICEMODE_CONTINUOUS_RANGING:
johnAlexander 14:8320b5ff96fa 2284 case VL53L0X_DEVICEMODE_CONTINUOUS_TIMED_RANGING:
johnAlexander 14:8320b5ff96fa 2285 case VL53L0X_DEVICEMODE_GPIO_DRIVE:
johnAlexander 14:8320b5ff96fa 2286 case VL53L0X_DEVICEMODE_GPIO_OSC:
johnAlexander 14:8320b5ff96fa 2287 /* Supported modes */
johnAlexander 14:8320b5ff96fa 2288 VL53L0X_SETPARAMETERFIELD(dev, DeviceMode, device_mode);
johnAlexander 14:8320b5ff96fa 2289 break;
johnAlexander 14:8320b5ff96fa 2290 default:
johnAlexander 14:8320b5ff96fa 2291 /* Unsupported mode */
johnAlexander 14:8320b5ff96fa 2292 status = VL53L0X_ERROR_MODE_NOT_SUPPORTED;
johnAlexander 14:8320b5ff96fa 2293 }
johnAlexander 14:8320b5ff96fa 2294
johnAlexander 14:8320b5ff96fa 2295 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 2296 return status;
johnAlexander 0:c523920bcc09 2297 }
johnAlexander 0:c523920bcc09 2298
Davidroid 16:27d3d95c8593 2299 VL53L0X_Error VL53L0X::VL53L0X_set_interrupt_thresholds(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 2300 VL53L0X_DeviceModes device_mode, FixPoint1616_t threshold_low,
johnAlexander 14:8320b5ff96fa 2301 FixPoint1616_t threshold_high)
johnAlexander 13:615f7e38568c 2302 {
johnAlexander 14:8320b5ff96fa 2303 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 2304 uint16_t threshold16;
johnAlexander 14:8320b5ff96fa 2305 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 2306
johnAlexander 14:8320b5ff96fa 2307 /* no dependency on DeviceMode for Ewok */
johnAlexander 14:8320b5ff96fa 2308 /* Need to divide by 2 because the FW will apply a x2 */
johnAlexander 14:8320b5ff96fa 2309 threshold16 = (uint16_t)((threshold_low >> 17) & 0x00fff);
Davidroid 16:27d3d95c8593 2310 status = VL53L0X_write_word(dev, VL53L0X_REG_SYSTEM_THRESH_LOW, threshold16);
johnAlexander 14:8320b5ff96fa 2311
johnAlexander 14:8320b5ff96fa 2312 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 2313 /* Need to divide by 2 because the FW will apply a x2 */
johnAlexander 14:8320b5ff96fa 2314 threshold16 = (uint16_t)((threshold_high >> 17) & 0x00fff);
Davidroid 16:27d3d95c8593 2315 status = VL53L0X_write_word(dev, VL53L0X_REG_SYSTEM_THRESH_HIGH,
johnAlexander 14:8320b5ff96fa 2316 threshold16);
johnAlexander 14:8320b5ff96fa 2317 }
johnAlexander 14:8320b5ff96fa 2318
johnAlexander 14:8320b5ff96fa 2319 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 2320 return status;
johnAlexander 13:615f7e38568c 2321 }
johnAlexander 13:615f7e38568c 2322
Davidroid 16:27d3d95c8593 2323 VL53L0X_Error VL53L0X::VL53L0X_get_interrupt_thresholds(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 2324 VL53L0X_DeviceModes device_mode, FixPoint1616_t *p_threshold_low,
johnAlexander 14:8320b5ff96fa 2325 FixPoint1616_t *p_threshold_high)
johnAlexander 0:c523920bcc09 2326 {
johnAlexander 14:8320b5ff96fa 2327 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 2328 uint16_t threshold16;
johnAlexander 14:8320b5ff96fa 2329 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 2330
johnAlexander 14:8320b5ff96fa 2331 /* no dependency on DeviceMode for Ewok */
johnAlexander 14:8320b5ff96fa 2332
Davidroid 16:27d3d95c8593 2333 status = VL53L0X_read_word(dev, VL53L0X_REG_SYSTEM_THRESH_LOW, &threshold16);
johnAlexander 14:8320b5ff96fa 2334 /* Need to multiply by 2 because the FW will apply a x2 */
johnAlexander 14:8320b5ff96fa 2335 *p_threshold_low = (FixPoint1616_t)((0x00fff & threshold16) << 17);
johnAlexander 14:8320b5ff96fa 2336
johnAlexander 14:8320b5ff96fa 2337 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 2338 status = VL53L0X_read_word(dev, VL53L0X_REG_SYSTEM_THRESH_HIGH,
johnAlexander 14:8320b5ff96fa 2339 &threshold16);
johnAlexander 14:8320b5ff96fa 2340 /* Need to multiply by 2 because the FW will apply a x2 */
johnAlexander 14:8320b5ff96fa 2341 *p_threshold_high =
johnAlexander 14:8320b5ff96fa 2342 (FixPoint1616_t)((0x00fff & threshold16) << 17);
johnAlexander 14:8320b5ff96fa 2343 }
johnAlexander 14:8320b5ff96fa 2344
johnAlexander 14:8320b5ff96fa 2345 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 2346 return status;
johnAlexander 0:c523920bcc09 2347 }
johnAlexander 0:c523920bcc09 2348
Davidroid 16:27d3d95c8593 2349 VL53L0X_Error VL53L0X::VL53L0X_load_tuning_settings(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 2350 uint8_t *p_tuning_setting_buffer)
johnAlexander 0:c523920bcc09 2351 {
johnAlexander 14:8320b5ff96fa 2352 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 2353 int i;
johnAlexander 14:8320b5ff96fa 2354 int index;
johnAlexander 14:8320b5ff96fa 2355 uint8_t msb;
johnAlexander 14:8320b5ff96fa 2356 uint8_t lsb;
johnAlexander 14:8320b5ff96fa 2357 uint8_t select_param;
johnAlexander 14:8320b5ff96fa 2358 uint8_t number_of_writes;
johnAlexander 14:8320b5ff96fa 2359 uint8_t address;
johnAlexander 14:8320b5ff96fa 2360 uint8_t local_buffer[4]; /* max */
johnAlexander 14:8320b5ff96fa 2361 uint16_t temp16;
johnAlexander 14:8320b5ff96fa 2362
johnAlexander 14:8320b5ff96fa 2363 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 2364
johnAlexander 14:8320b5ff96fa 2365 index = 0;
johnAlexander 14:8320b5ff96fa 2366
johnAlexander 14:8320b5ff96fa 2367 while ((*(p_tuning_setting_buffer + index) != 0) &&
johnAlexander 14:8320b5ff96fa 2368 (status == VL53L0X_ERROR_NONE)) {
johnAlexander 14:8320b5ff96fa 2369 number_of_writes = *(p_tuning_setting_buffer + index);
johnAlexander 14:8320b5ff96fa 2370 index++;
johnAlexander 14:8320b5ff96fa 2371 if (number_of_writes == 0xFF) {
johnAlexander 14:8320b5ff96fa 2372 /* internal parameters */
johnAlexander 14:8320b5ff96fa 2373 select_param = *(p_tuning_setting_buffer + index);
johnAlexander 14:8320b5ff96fa 2374 index++;
johnAlexander 14:8320b5ff96fa 2375 switch (select_param) {
johnAlexander 14:8320b5ff96fa 2376 case 0: /* uint16_t SigmaEstRefArray -> 2 bytes */
johnAlexander 14:8320b5ff96fa 2377 msb = *(p_tuning_setting_buffer + index);
johnAlexander 14:8320b5ff96fa 2378 index++;
johnAlexander 14:8320b5ff96fa 2379 lsb = *(p_tuning_setting_buffer + index);
johnAlexander 14:8320b5ff96fa 2380 index++;
johnAlexander 14:8320b5ff96fa 2381 temp16 = VL53L0X_MAKEUINT16(lsb, msb);
johnAlexander 14:8320b5ff96fa 2382 PALDevDataSet(dev, SigmaEstRefArray, temp16);
johnAlexander 14:8320b5ff96fa 2383 break;
johnAlexander 14:8320b5ff96fa 2384 case 1: /* uint16_t SigmaEstEffPulseWidth -> 2 bytes */
johnAlexander 14:8320b5ff96fa 2385 msb = *(p_tuning_setting_buffer + index);
johnAlexander 14:8320b5ff96fa 2386 index++;
johnAlexander 14:8320b5ff96fa 2387 lsb = *(p_tuning_setting_buffer + index);
johnAlexander 14:8320b5ff96fa 2388 index++;
johnAlexander 14:8320b5ff96fa 2389 temp16 = VL53L0X_MAKEUINT16(lsb, msb);
johnAlexander 14:8320b5ff96fa 2390 PALDevDataSet(dev, SigmaEstEffPulseWidth,
johnAlexander 14:8320b5ff96fa 2391 temp16);
johnAlexander 14:8320b5ff96fa 2392 break;
johnAlexander 14:8320b5ff96fa 2393 case 2: /* uint16_t SigmaEstEffAmbWidth -> 2 bytes */
johnAlexander 14:8320b5ff96fa 2394 msb = *(p_tuning_setting_buffer + index);
johnAlexander 14:8320b5ff96fa 2395 index++;
johnAlexander 14:8320b5ff96fa 2396 lsb = *(p_tuning_setting_buffer + index);
johnAlexander 14:8320b5ff96fa 2397 index++;
johnAlexander 14:8320b5ff96fa 2398 temp16 = VL53L0X_MAKEUINT16(lsb, msb);
johnAlexander 14:8320b5ff96fa 2399 PALDevDataSet(dev, SigmaEstEffAmbWidth, temp16);
johnAlexander 14:8320b5ff96fa 2400 break;
johnAlexander 14:8320b5ff96fa 2401 case 3: /* uint16_t targetRefRate -> 2 bytes */
johnAlexander 14:8320b5ff96fa 2402 msb = *(p_tuning_setting_buffer + index);
johnAlexander 14:8320b5ff96fa 2403 index++;
johnAlexander 14:8320b5ff96fa 2404 lsb = *(p_tuning_setting_buffer + index);
johnAlexander 14:8320b5ff96fa 2405 index++;
johnAlexander 14:8320b5ff96fa 2406 temp16 = VL53L0X_MAKEUINT16(lsb, msb);
johnAlexander 14:8320b5ff96fa 2407 PALDevDataSet(dev, targetRefRate, temp16);
johnAlexander 14:8320b5ff96fa 2408 break;
johnAlexander 14:8320b5ff96fa 2409 default: /* invalid parameter */
johnAlexander 14:8320b5ff96fa 2410 status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander 14:8320b5ff96fa 2411 }
johnAlexander 14:8320b5ff96fa 2412
johnAlexander 14:8320b5ff96fa 2413 } else if (number_of_writes <= 4) {
johnAlexander 14:8320b5ff96fa 2414 address = *(p_tuning_setting_buffer + index);
johnAlexander 14:8320b5ff96fa 2415 index++;
johnAlexander 14:8320b5ff96fa 2416
johnAlexander 14:8320b5ff96fa 2417 for (i = 0; i < number_of_writes; i++) {
johnAlexander 14:8320b5ff96fa 2418 local_buffer[i] = *(p_tuning_setting_buffer +
johnAlexander 14:8320b5ff96fa 2419 index);
johnAlexander 14:8320b5ff96fa 2420 index++;
johnAlexander 14:8320b5ff96fa 2421 }
johnAlexander 14:8320b5ff96fa 2422
Davidroid 16:27d3d95c8593 2423 status = VL53L0X_write_multi(dev, address, local_buffer,
johnAlexander 14:8320b5ff96fa 2424 number_of_writes);
johnAlexander 14:8320b5ff96fa 2425
johnAlexander 14:8320b5ff96fa 2426 } else {
johnAlexander 14:8320b5ff96fa 2427 status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander 14:8320b5ff96fa 2428 }
johnAlexander 14:8320b5ff96fa 2429 }
johnAlexander 14:8320b5ff96fa 2430
johnAlexander 14:8320b5ff96fa 2431 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 2432 return status;
johnAlexander 0:c523920bcc09 2433 }
johnAlexander 0:c523920bcc09 2434
Davidroid 16:27d3d95c8593 2435 VL53L0X_Error VL53L0X::VL53L0X_check_and_load_interrupt_settings(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 2436 uint8_t start_not_stopflag)
johnAlexander 0:c523920bcc09 2437 {
johnAlexander 14:8320b5ff96fa 2438 uint8_t interrupt_config;
johnAlexander 14:8320b5ff96fa 2439 FixPoint1616_t threshold_low;
johnAlexander 14:8320b5ff96fa 2440 FixPoint1616_t threshold_high;
johnAlexander 14:8320b5ff96fa 2441 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 2442
johnAlexander 14:8320b5ff96fa 2443 interrupt_config = VL53L0X_GETDEVICESPECIFICPARAMETER(dev,
johnAlexander 14:8320b5ff96fa 2444 Pin0GpioFunctionality);
johnAlexander 14:8320b5ff96fa 2445
johnAlexander 14:8320b5ff96fa 2446 if ((interrupt_config ==
johnAlexander 14:8320b5ff96fa 2447 VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_LOW) ||
johnAlexander 14:8320b5ff96fa 2448 (interrupt_config ==
johnAlexander 14:8320b5ff96fa 2449 VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_HIGH) ||
johnAlexander 14:8320b5ff96fa 2450 (interrupt_config ==
johnAlexander 14:8320b5ff96fa 2451 VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_OUT)) {
johnAlexander 14:8320b5ff96fa 2452
Davidroid 16:27d3d95c8593 2453 status = VL53L0X_get_interrupt_thresholds(dev,
johnAlexander 14:8320b5ff96fa 2454 VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
johnAlexander 14:8320b5ff96fa 2455 &threshold_low, &threshold_high);
johnAlexander 14:8320b5ff96fa 2456
johnAlexander 14:8320b5ff96fa 2457 if (((threshold_low > 255 * 65536) ||
johnAlexander 14:8320b5ff96fa 2458 (threshold_high > 255 * 65536)) &&
johnAlexander 14:8320b5ff96fa 2459 (status == VL53L0X_ERROR_NONE)) {
johnAlexander 14:8320b5ff96fa 2460
johnAlexander 14:8320b5ff96fa 2461 if (start_not_stopflag != 0) {
Davidroid 16:27d3d95c8593 2462 status = VL53L0X_load_tuning_settings(dev,
johnAlexander 14:8320b5ff96fa 2463 InterruptThresholdSettings);
johnAlexander 14:8320b5ff96fa 2464 } else {
Davidroid 16:27d3d95c8593 2465 status |= VL53L0X_write_byte(dev, 0xFF, 0x04);
Davidroid 16:27d3d95c8593 2466 status |= VL53L0X_write_byte(dev, 0x70, 0x00);
Davidroid 16:27d3d95c8593 2467 status |= VL53L0X_write_byte(dev, 0xFF, 0x00);
Davidroid 16:27d3d95c8593 2468 status |= VL53L0X_write_byte(dev, 0x80, 0x00);
johnAlexander 14:8320b5ff96fa 2469 }
johnAlexander 14:8320b5ff96fa 2470
johnAlexander 14:8320b5ff96fa 2471 }
johnAlexander 14:8320b5ff96fa 2472
johnAlexander 14:8320b5ff96fa 2473
johnAlexander 14:8320b5ff96fa 2474 }
johnAlexander 14:8320b5ff96fa 2475
johnAlexander 14:8320b5ff96fa 2476 return status;
johnAlexander 0:c523920bcc09 2477
johnAlexander 0:c523920bcc09 2478 }
johnAlexander 0:c523920bcc09 2479
Davidroid 16:27d3d95c8593 2480 VL53L0X_Error VL53L0X::VL53L0X_start_measurement(VL53L0X_DEV dev)
johnAlexander 0:c523920bcc09 2481 {
johnAlexander 14:8320b5ff96fa 2482 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 2483 VL53L0X_DeviceModes device_mode;
johnAlexander 14:8320b5ff96fa 2484 uint8_t byte;
johnAlexander 14:8320b5ff96fa 2485 uint8_t start_stop_byte = VL53L0X_REG_SYSRANGE_MODE_START_STOP;
johnAlexander 14:8320b5ff96fa 2486 uint32_t loop_nb;
johnAlexander 14:8320b5ff96fa 2487 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 2488
johnAlexander 14:8320b5ff96fa 2489 /* Get Current DeviceMode */
Davidroid 16:27d3d95c8593 2490 VL53L0X_get_device_mode(dev, &device_mode);
Davidroid 16:27d3d95c8593 2491
Davidroid 16:27d3d95c8593 2492 status = VL53L0X_write_byte(dev, 0x80, 0x01);
Davidroid 16:27d3d95c8593 2493 status = VL53L0X_write_byte(dev, 0xFF, 0x01);
Davidroid 16:27d3d95c8593 2494 status = VL53L0X_write_byte(dev, 0x00, 0x00);
Davidroid 16:27d3d95c8593 2495 status = VL53L0X_write_byte(dev, 0x91, PALDevDataGet(dev, StopVariable));
Davidroid 16:27d3d95c8593 2496 status = VL53L0X_write_byte(dev, 0x00, 0x01);
Davidroid 16:27d3d95c8593 2497 status = VL53L0X_write_byte(dev, 0xFF, 0x00);
Davidroid 16:27d3d95c8593 2498 status = VL53L0X_write_byte(dev, 0x80, 0x00);
johnAlexander 14:8320b5ff96fa 2499
johnAlexander 14:8320b5ff96fa 2500 switch (device_mode) {
johnAlexander 14:8320b5ff96fa 2501 case VL53L0X_DEVICEMODE_SINGLE_RANGING:
Davidroid 16:27d3d95c8593 2502 status = VL53L0X_write_byte(dev, VL53L0X_REG_SYSRANGE_START, 0x01);
johnAlexander 14:8320b5ff96fa 2503
johnAlexander 14:8320b5ff96fa 2504 byte = start_stop_byte;
johnAlexander 14:8320b5ff96fa 2505 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 2506 /* Wait until start bit has been cleared */
johnAlexander 14:8320b5ff96fa 2507 loop_nb = 0;
johnAlexander 14:8320b5ff96fa 2508 do {
johnAlexander 14:8320b5ff96fa 2509 if (loop_nb > 0)
Davidroid 16:27d3d95c8593 2510 status = VL53L0X_read_byte(dev,
johnAlexander 14:8320b5ff96fa 2511 VL53L0X_REG_SYSRANGE_START, &byte);
johnAlexander 14:8320b5ff96fa 2512 loop_nb = loop_nb + 1;
johnAlexander 14:8320b5ff96fa 2513 } while (((byte & start_stop_byte) == start_stop_byte)
johnAlexander 14:8320b5ff96fa 2514 && (status == VL53L0X_ERROR_NONE)
johnAlexander 14:8320b5ff96fa 2515 && (loop_nb < VL53L0X_DEFAULT_MAX_LOOP));
johnAlexander 14:8320b5ff96fa 2516
johnAlexander 14:8320b5ff96fa 2517 if (loop_nb >= VL53L0X_DEFAULT_MAX_LOOP)
johnAlexander 14:8320b5ff96fa 2518 status = VL53L0X_ERROR_TIME_OUT;
johnAlexander 14:8320b5ff96fa 2519
johnAlexander 14:8320b5ff96fa 2520 }
johnAlexander 14:8320b5ff96fa 2521
johnAlexander 14:8320b5ff96fa 2522 break;
johnAlexander 14:8320b5ff96fa 2523 case VL53L0X_DEVICEMODE_CONTINUOUS_RANGING:
johnAlexander 14:8320b5ff96fa 2524 /* Back-to-back mode */
johnAlexander 14:8320b5ff96fa 2525
johnAlexander 14:8320b5ff96fa 2526 /* Check if need to apply interrupt settings */
johnAlexander 14:8320b5ff96fa 2527 if (status == VL53L0X_ERROR_NONE)
Davidroid 16:27d3d95c8593 2528 status = VL53L0X_check_and_load_interrupt_settings(dev, 1);
Davidroid 16:27d3d95c8593 2529
Davidroid 16:27d3d95c8593 2530 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 2531 VL53L0X_REG_SYSRANGE_START,
johnAlexander 14:8320b5ff96fa 2532 VL53L0X_REG_SYSRANGE_MODE_BACKTOBACK);
johnAlexander 14:8320b5ff96fa 2533 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 2534 /* Set PAL State to Running */
johnAlexander 14:8320b5ff96fa 2535 PALDevDataSet(dev, PalState, VL53L0X_STATE_RUNNING);
johnAlexander 14:8320b5ff96fa 2536 }
johnAlexander 14:8320b5ff96fa 2537 break;
johnAlexander 14:8320b5ff96fa 2538 case VL53L0X_DEVICEMODE_CONTINUOUS_TIMED_RANGING:
johnAlexander 14:8320b5ff96fa 2539 /* Continuous mode */
johnAlexander 14:8320b5ff96fa 2540 /* Check if need to apply interrupt settings */
johnAlexander 14:8320b5ff96fa 2541 if (status == VL53L0X_ERROR_NONE)
Davidroid 16:27d3d95c8593 2542 status = VL53L0X_check_and_load_interrupt_settings(dev, 1);
Davidroid 16:27d3d95c8593 2543
Davidroid 16:27d3d95c8593 2544 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 2545 VL53L0X_REG_SYSRANGE_START,
johnAlexander 14:8320b5ff96fa 2546 VL53L0X_REG_SYSRANGE_MODE_TIMED);
johnAlexander 14:8320b5ff96fa 2547
johnAlexander 14:8320b5ff96fa 2548 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 2549 /* Set PAL State to Running */
johnAlexander 14:8320b5ff96fa 2550 PALDevDataSet(dev, PalState, VL53L0X_STATE_RUNNING);
johnAlexander 14:8320b5ff96fa 2551 }
johnAlexander 14:8320b5ff96fa 2552 break;
johnAlexander 14:8320b5ff96fa 2553 default:
johnAlexander 14:8320b5ff96fa 2554 /* Selected mode not supported */
johnAlexander 14:8320b5ff96fa 2555 status = VL53L0X_ERROR_MODE_NOT_SUPPORTED;
johnAlexander 14:8320b5ff96fa 2556 }
johnAlexander 14:8320b5ff96fa 2557
johnAlexander 14:8320b5ff96fa 2558
johnAlexander 14:8320b5ff96fa 2559 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 2560 return status;
johnAlexander 0:c523920bcc09 2561 }
johnAlexander 0:c523920bcc09 2562
johnAlexander 0:c523920bcc09 2563 /* Group PAL Measurement Functions */
Davidroid 16:27d3d95c8593 2564 VL53L0X_Error VL53L0X::VL53L0X_perform_single_measurement(VL53L0X_DEV dev)
johnAlexander 0:c523920bcc09 2565 {
johnAlexander 14:8320b5ff96fa 2566 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 2567 VL53L0X_DeviceModes device_mode;
johnAlexander 14:8320b5ff96fa 2568
johnAlexander 14:8320b5ff96fa 2569 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 2570
johnAlexander 14:8320b5ff96fa 2571 /* Get Current DeviceMode */
Davidroid 16:27d3d95c8593 2572 status = VL53L0X_get_device_mode(dev, &device_mode);
johnAlexander 14:8320b5ff96fa 2573
johnAlexander 14:8320b5ff96fa 2574 /* Start immediately to run a single ranging measurement in case of
johnAlexander 14:8320b5ff96fa 2575 * single ranging or single histogram */
johnAlexander 14:8320b5ff96fa 2576 if (status == VL53L0X_ERROR_NONE
Davidroid 16:27d3d95c8593 2577 && device_mode == VL53L0X_DEVICEMODE_SINGLE_RANGING) {
Davidroid 16:27d3d95c8593 2578 status = VL53L0X_start_measurement(dev);
Davidroid 16:27d3d95c8593 2579 }
Davidroid 16:27d3d95c8593 2580
Davidroid 16:27d3d95c8593 2581
Davidroid 16:27d3d95c8593 2582 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 2583 status = VL53L0X_measurement_poll_for_completion(dev);
Davidroid 16:27d3d95c8593 2584 }
johnAlexander 14:8320b5ff96fa 2585
johnAlexander 14:8320b5ff96fa 2586
johnAlexander 14:8320b5ff96fa 2587 /* Change PAL State in case of single ranging or single histogram */
johnAlexander 14:8320b5ff96fa 2588 if (status == VL53L0X_ERROR_NONE
johnAlexander 14:8320b5ff96fa 2589 && device_mode == VL53L0X_DEVICEMODE_SINGLE_RANGING)
johnAlexander 14:8320b5ff96fa 2590 PALDevDataSet(dev, PalState, VL53L0X_STATE_IDLE);
johnAlexander 14:8320b5ff96fa 2591
johnAlexander 14:8320b5ff96fa 2592
johnAlexander 14:8320b5ff96fa 2593 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 2594 return status;
johnAlexander 0:c523920bcc09 2595 }
johnAlexander 0:c523920bcc09 2596
Davidroid 16:27d3d95c8593 2597 VL53L0X_Error VL53L0X::VL53L0X_get_x_talk_compensation_enable(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 2598 uint8_t *p_x_talk_compensation_enable)
johnAlexander 0:c523920bcc09 2599 {
johnAlexander 14:8320b5ff96fa 2600 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 2601 uint8_t temp8;
johnAlexander 14:8320b5ff96fa 2602 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 2603
johnAlexander 14:8320b5ff96fa 2604 VL53L0X_GETPARAMETERFIELD(dev, XTalkCompensationEnable, temp8);
johnAlexander 14:8320b5ff96fa 2605 *p_x_talk_compensation_enable = temp8;
johnAlexander 14:8320b5ff96fa 2606
johnAlexander 14:8320b5ff96fa 2607 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 2608 return status;
johnAlexander 0:c523920bcc09 2609 }
johnAlexander 0:c523920bcc09 2610
Davidroid 16:27d3d95c8593 2611 VL53L0X_Error VL53L0X::VL53L0X_get_total_xtalk_rate(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 2612 VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data,
johnAlexander 14:8320b5ff96fa 2613 FixPoint1616_t *p_total_xtalk_rate_mcps)
johnAlexander 0:c523920bcc09 2614 {
johnAlexander 14:8320b5ff96fa 2615 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 2616
johnAlexander 14:8320b5ff96fa 2617 uint8_t xtalk_comp_enable;
johnAlexander 14:8320b5ff96fa 2618 FixPoint1616_t total_xtalk_mega_cps;
johnAlexander 14:8320b5ff96fa 2619 FixPoint1616_t xtalk_per_spad_mega_cps;
johnAlexander 14:8320b5ff96fa 2620
johnAlexander 14:8320b5ff96fa 2621 *p_total_xtalk_rate_mcps = 0;
johnAlexander 14:8320b5ff96fa 2622
Davidroid 16:27d3d95c8593 2623 status = VL53L0X_get_x_talk_compensation_enable(dev, &xtalk_comp_enable);
johnAlexander 14:8320b5ff96fa 2624 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 2625
johnAlexander 14:8320b5ff96fa 2626 if (xtalk_comp_enable) {
johnAlexander 14:8320b5ff96fa 2627
johnAlexander 14:8320b5ff96fa 2628 VL53L0X_GETPARAMETERFIELD(
johnAlexander 14:8320b5ff96fa 2629 dev,
johnAlexander 14:8320b5ff96fa 2630 XTalkCompensationRateMegaCps,
johnAlexander 14:8320b5ff96fa 2631 xtalk_per_spad_mega_cps);
johnAlexander 14:8320b5ff96fa 2632
johnAlexander 14:8320b5ff96fa 2633 /* FixPoint1616 * FixPoint 8:8 = FixPoint0824 */
johnAlexander 14:8320b5ff96fa 2634 total_xtalk_mega_cps =
johnAlexander 14:8320b5ff96fa 2635 p_ranging_measurement_data->EffectiveSpadRtnCount *
johnAlexander 14:8320b5ff96fa 2636 xtalk_per_spad_mega_cps;
johnAlexander 14:8320b5ff96fa 2637
johnAlexander 14:8320b5ff96fa 2638 /* FixPoint0824 >> 8 = FixPoint1616 */
johnAlexander 14:8320b5ff96fa 2639 *p_total_xtalk_rate_mcps =
johnAlexander 14:8320b5ff96fa 2640 (total_xtalk_mega_cps + 0x80) >> 8;
johnAlexander 14:8320b5ff96fa 2641 }
johnAlexander 14:8320b5ff96fa 2642 }
johnAlexander 14:8320b5ff96fa 2643
johnAlexander 14:8320b5ff96fa 2644 return status;
johnAlexander 0:c523920bcc09 2645 }
johnAlexander 0:c523920bcc09 2646
Davidroid 16:27d3d95c8593 2647 VL53L0X_Error VL53L0X::VL53L0X_get_total_signal_rate(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 2648 VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data,
johnAlexander 14:8320b5ff96fa 2649 FixPoint1616_t *p_total_signal_rate_mcps)
johnAlexander 0:c523920bcc09 2650 {
johnAlexander 14:8320b5ff96fa 2651 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 2652 FixPoint1616_t total_xtalk_mega_cps;
johnAlexander 14:8320b5ff96fa 2653
johnAlexander 14:8320b5ff96fa 2654 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 2655
johnAlexander 14:8320b5ff96fa 2656 *p_total_signal_rate_mcps =
johnAlexander 14:8320b5ff96fa 2657 p_ranging_measurement_data->SignalRateRtnMegaCps;
johnAlexander 14:8320b5ff96fa 2658
Davidroid 16:27d3d95c8593 2659 status = VL53L0X_get_total_xtalk_rate(
johnAlexander 14:8320b5ff96fa 2660 dev, p_ranging_measurement_data, &total_xtalk_mega_cps);
johnAlexander 14:8320b5ff96fa 2661
Davidroid 16:27d3d95c8593 2662 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 2663 *p_total_signal_rate_mcps += total_xtalk_mega_cps;
Davidroid 16:27d3d95c8593 2664 }
johnAlexander 14:8320b5ff96fa 2665
johnAlexander 14:8320b5ff96fa 2666 return status;
johnAlexander 0:c523920bcc09 2667 }
johnAlexander 0:c523920bcc09 2668
johnAlexander 0:c523920bcc09 2669 /* To convert ms into register value */
Davidroid 16:27d3d95c8593 2670 uint32_t VL53L0X::VL53L0X_calc_timeout_mclks(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 2671 uint32_t timeout_period_us,
johnAlexander 14:8320b5ff96fa 2672 uint8_t vcsel_period_pclks)
johnAlexander 0:c523920bcc09 2673 {
johnAlexander 14:8320b5ff96fa 2674 uint32_t macro_period_ps;
johnAlexander 14:8320b5ff96fa 2675 uint32_t macro_period_ns;
johnAlexander 14:8320b5ff96fa 2676 uint32_t timeout_period_mclks = 0;
johnAlexander 14:8320b5ff96fa 2677
Davidroid 16:27d3d95c8593 2678 macro_period_ps = VL53L0X_calc_macro_period_ps(dev, vcsel_period_pclks);
johnAlexander 14:8320b5ff96fa 2679 macro_period_ns = (macro_period_ps + 500) / 1000;
johnAlexander 14:8320b5ff96fa 2680
johnAlexander 14:8320b5ff96fa 2681 timeout_period_mclks =
johnAlexander 14:8320b5ff96fa 2682 (uint32_t)(((timeout_period_us * 1000)
johnAlexander 14:8320b5ff96fa 2683 + (macro_period_ns / 2)) / macro_period_ns);
johnAlexander 0:c523920bcc09 2684
johnAlexander 0:c523920bcc09 2685 return timeout_period_mclks;
johnAlexander 0:c523920bcc09 2686 }
johnAlexander 0:c523920bcc09 2687
Davidroid 16:27d3d95c8593 2688 uint32_t VL53L0X::VL53L0X_isqrt(uint32_t num)
johnAlexander 0:c523920bcc09 2689 {
johnAlexander 14:8320b5ff96fa 2690 /*
johnAlexander 14:8320b5ff96fa 2691 * Implements an integer square root
johnAlexander 14:8320b5ff96fa 2692 *
johnAlexander 14:8320b5ff96fa 2693 * From: http://en.wikipedia.org/wiki/Methods_of_computing_square_roots
johnAlexander 14:8320b5ff96fa 2694 */
johnAlexander 14:8320b5ff96fa 2695
johnAlexander 14:8320b5ff96fa 2696 uint32_t res = 0;
johnAlexander 14:8320b5ff96fa 2697 uint32_t bit = 1 << 30;
johnAlexander 14:8320b5ff96fa 2698 /* The second-to-top bit is set:
johnAlexander 14:8320b5ff96fa 2699 * 1 << 14 for 16-bits, 1 << 30 for 32 bits */
johnAlexander 14:8320b5ff96fa 2700
johnAlexander 14:8320b5ff96fa 2701 /* "bit" starts at the highest power of four <= the argument. */
Davidroid 16:27d3d95c8593 2702 while (bit > num) {
johnAlexander 14:8320b5ff96fa 2703 bit >>= 2;
Davidroid 16:27d3d95c8593 2704 }
johnAlexander 14:8320b5ff96fa 2705
johnAlexander 14:8320b5ff96fa 2706
johnAlexander 14:8320b5ff96fa 2707 while (bit != 0) {
johnAlexander 14:8320b5ff96fa 2708 if (num >= res + bit) {
johnAlexander 14:8320b5ff96fa 2709 num -= res + bit;
johnAlexander 14:8320b5ff96fa 2710 res = (res >> 1) + bit;
johnAlexander 14:8320b5ff96fa 2711 } else
johnAlexander 14:8320b5ff96fa 2712 res >>= 1;
johnAlexander 14:8320b5ff96fa 2713
johnAlexander 14:8320b5ff96fa 2714 bit >>= 2;
johnAlexander 14:8320b5ff96fa 2715 }
johnAlexander 14:8320b5ff96fa 2716
johnAlexander 14:8320b5ff96fa 2717 return res;
johnAlexander 0:c523920bcc09 2718 }
johnAlexander 0:c523920bcc09 2719
Davidroid 16:27d3d95c8593 2720 VL53L0X_Error VL53L0X::VL53L0X_calc_dmax(
johnAlexander 14:8320b5ff96fa 2721 VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 2722 FixPoint1616_t total_signal_rate_mcps,
johnAlexander 14:8320b5ff96fa 2723 FixPoint1616_t total_corr_signal_rate_mcps,
johnAlexander 14:8320b5ff96fa 2724 FixPoint1616_t pw_mult,
johnAlexander 14:8320b5ff96fa 2725 uint32_t sigma_estimate_p1,
johnAlexander 14:8320b5ff96fa 2726 FixPoint1616_t sigma_estimate_p2,
johnAlexander 14:8320b5ff96fa 2727 uint32_t peak_vcsel_duration_us,
johnAlexander 14:8320b5ff96fa 2728 uint32_t *pd_max_mm)
johnAlexander 0:c523920bcc09 2729 {
johnAlexander 14:8320b5ff96fa 2730 const uint32_t c_sigma_limit = 18;
johnAlexander 14:8320b5ff96fa 2731 const FixPoint1616_t c_signal_limit = 0x4000; /* 0.25 */
johnAlexander 14:8320b5ff96fa 2732 const FixPoint1616_t c_sigma_est_ref = 0x00000042; /* 0.001 */
johnAlexander 14:8320b5ff96fa 2733 const uint32_t c_amb_eff_width_sigma_est_ns = 6;
johnAlexander 14:8320b5ff96fa 2734 const uint32_t c_amb_eff_width_d_max_ns = 7;
johnAlexander 14:8320b5ff96fa 2735 uint32_t dmax_cal_range_mm;
johnAlexander 14:8320b5ff96fa 2736 FixPoint1616_t dmax_cal_signal_rate_rtn_mcps;
johnAlexander 14:8320b5ff96fa 2737 FixPoint1616_t min_signal_needed;
johnAlexander 14:8320b5ff96fa 2738 FixPoint1616_t min_signal_needed_p1;
johnAlexander 14:8320b5ff96fa 2739 FixPoint1616_t min_signal_needed_p2;
johnAlexander 14:8320b5ff96fa 2740 FixPoint1616_t min_signal_needed_p3;
johnAlexander 14:8320b5ff96fa 2741 FixPoint1616_t min_signal_needed_p4;
johnAlexander 14:8320b5ff96fa 2742 FixPoint1616_t sigma_limit_tmp;
johnAlexander 14:8320b5ff96fa 2743 FixPoint1616_t sigma_est_sq_tmp;
johnAlexander 14:8320b5ff96fa 2744 FixPoint1616_t signal_limit_tmp;
johnAlexander 14:8320b5ff96fa 2745 FixPoint1616_t signal_at0_mm;
johnAlexander 14:8320b5ff96fa 2746 FixPoint1616_t dmax_dark;
johnAlexander 14:8320b5ff96fa 2747 FixPoint1616_t dmax_ambient;
johnAlexander 14:8320b5ff96fa 2748 FixPoint1616_t dmax_dark_tmp;
johnAlexander 14:8320b5ff96fa 2749 FixPoint1616_t sigma_est_p2_tmp;
johnAlexander 14:8320b5ff96fa 2750 uint32_t signal_rate_temp_mcps;
johnAlexander 14:8320b5ff96fa 2751
johnAlexander 14:8320b5ff96fa 2752 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 2753
johnAlexander 14:8320b5ff96fa 2754 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 2755
johnAlexander 14:8320b5ff96fa 2756 dmax_cal_range_mm =
johnAlexander 14:8320b5ff96fa 2757 PALDevDataGet(dev, DmaxCalRangeMilliMeter);
johnAlexander 14:8320b5ff96fa 2758
johnAlexander 14:8320b5ff96fa 2759 dmax_cal_signal_rate_rtn_mcps =
johnAlexander 14:8320b5ff96fa 2760 PALDevDataGet(dev, DmaxCalSignalRateRtnMegaCps);
johnAlexander 14:8320b5ff96fa 2761
johnAlexander 14:8320b5ff96fa 2762 /* uint32 * FixPoint1616 = FixPoint1616 */
johnAlexander 14:8320b5ff96fa 2763 signal_at0_mm = dmax_cal_range_mm * dmax_cal_signal_rate_rtn_mcps;
johnAlexander 14:8320b5ff96fa 2764
johnAlexander 14:8320b5ff96fa 2765 /* FixPoint1616 >> 8 = FixPoint2408 */
johnAlexander 14:8320b5ff96fa 2766 signal_at0_mm = (signal_at0_mm + 0x80) >> 8;
johnAlexander 14:8320b5ff96fa 2767 signal_at0_mm *= dmax_cal_range_mm;
johnAlexander 14:8320b5ff96fa 2768
johnAlexander 14:8320b5ff96fa 2769 min_signal_needed_p1 = 0;
johnAlexander 14:8320b5ff96fa 2770 if (total_corr_signal_rate_mcps > 0) {
johnAlexander 14:8320b5ff96fa 2771
johnAlexander 14:8320b5ff96fa 2772 /* Shift by 10 bits to increase resolution prior to the
johnAlexander 14:8320b5ff96fa 2773 * division */
johnAlexander 14:8320b5ff96fa 2774 signal_rate_temp_mcps = total_signal_rate_mcps << 10;
johnAlexander 14:8320b5ff96fa 2775
johnAlexander 14:8320b5ff96fa 2776 /* Add rounding value prior to division */
johnAlexander 14:8320b5ff96fa 2777 min_signal_needed_p1 = signal_rate_temp_mcps +
johnAlexander 14:8320b5ff96fa 2778 (total_corr_signal_rate_mcps / 2);
johnAlexander 14:8320b5ff96fa 2779
johnAlexander 14:8320b5ff96fa 2780 /* FixPoint0626/FixPoint1616 = FixPoint2210 */
johnAlexander 14:8320b5ff96fa 2781 min_signal_needed_p1 /= total_corr_signal_rate_mcps;
johnAlexander 14:8320b5ff96fa 2782
johnAlexander 14:8320b5ff96fa 2783 /* Apply a factored version of the speed of light.
johnAlexander 14:8320b5ff96fa 2784 Correction to be applied at the end */
johnAlexander 14:8320b5ff96fa 2785 min_signal_needed_p1 *= 3;
johnAlexander 14:8320b5ff96fa 2786
johnAlexander 14:8320b5ff96fa 2787 /* FixPoint2210 * FixPoint2210 = FixPoint1220 */
johnAlexander 14:8320b5ff96fa 2788 min_signal_needed_p1 *= min_signal_needed_p1;
johnAlexander 14:8320b5ff96fa 2789
johnAlexander 14:8320b5ff96fa 2790 /* FixPoint1220 >> 16 = FixPoint2804 */
johnAlexander 14:8320b5ff96fa 2791 min_signal_needed_p1 = (min_signal_needed_p1 + 0x8000) >> 16;
johnAlexander 14:8320b5ff96fa 2792 }
johnAlexander 14:8320b5ff96fa 2793
johnAlexander 14:8320b5ff96fa 2794 min_signal_needed_p2 = pw_mult * sigma_estimate_p1;
johnAlexander 14:8320b5ff96fa 2795
johnAlexander 14:8320b5ff96fa 2796 /* FixPoint1616 >> 16 = uint32 */
johnAlexander 14:8320b5ff96fa 2797 min_signal_needed_p2 = (min_signal_needed_p2 + 0x8000) >> 16;
johnAlexander 14:8320b5ff96fa 2798
johnAlexander 14:8320b5ff96fa 2799 /* uint32 * uint32 = uint32 */
johnAlexander 14:8320b5ff96fa 2800 min_signal_needed_p2 *= min_signal_needed_p2;
johnAlexander 14:8320b5ff96fa 2801
johnAlexander 14:8320b5ff96fa 2802 /* Check sigmaEstimateP2
johnAlexander 14:8320b5ff96fa 2803 * If this value is too high there is not enough signal rate
johnAlexander 14:8320b5ff96fa 2804 * to calculate dmax value so set a suitable value to ensure
johnAlexander 14:8320b5ff96fa 2805 * a very small dmax.
johnAlexander 14:8320b5ff96fa 2806 */
johnAlexander 14:8320b5ff96fa 2807 sigma_est_p2_tmp = (sigma_estimate_p2 + 0x8000) >> 16;
johnAlexander 14:8320b5ff96fa 2808 sigma_est_p2_tmp = (sigma_est_p2_tmp + c_amb_eff_width_sigma_est_ns / 2) /
johnAlexander 14:8320b5ff96fa 2809 c_amb_eff_width_sigma_est_ns;
johnAlexander 14:8320b5ff96fa 2810 sigma_est_p2_tmp *= c_amb_eff_width_d_max_ns;
johnAlexander 14:8320b5ff96fa 2811
johnAlexander 14:8320b5ff96fa 2812 if (sigma_est_p2_tmp > 0xffff) {
johnAlexander 14:8320b5ff96fa 2813 min_signal_needed_p3 = 0xfff00000;
johnAlexander 14:8320b5ff96fa 2814 } else {
johnAlexander 14:8320b5ff96fa 2815
johnAlexander 14:8320b5ff96fa 2816 /* DMAX uses a different ambient width from sigma, so apply
johnAlexander 14:8320b5ff96fa 2817 * correction.
johnAlexander 14:8320b5ff96fa 2818 * Perform division before multiplication to prevent overflow.
johnAlexander 14:8320b5ff96fa 2819 */
johnAlexander 14:8320b5ff96fa 2820 sigma_estimate_p2 = (sigma_estimate_p2 + c_amb_eff_width_sigma_est_ns / 2) /
johnAlexander 14:8320b5ff96fa 2821 c_amb_eff_width_sigma_est_ns;
johnAlexander 14:8320b5ff96fa 2822 sigma_estimate_p2 *= c_amb_eff_width_d_max_ns;
johnAlexander 14:8320b5ff96fa 2823
johnAlexander 14:8320b5ff96fa 2824 /* FixPoint1616 >> 16 = uint32 */
johnAlexander 14:8320b5ff96fa 2825 min_signal_needed_p3 = (sigma_estimate_p2 + 0x8000) >> 16;
johnAlexander 14:8320b5ff96fa 2826
johnAlexander 14:8320b5ff96fa 2827 min_signal_needed_p3 *= min_signal_needed_p3;
johnAlexander 14:8320b5ff96fa 2828
johnAlexander 14:8320b5ff96fa 2829 }
johnAlexander 14:8320b5ff96fa 2830
johnAlexander 14:8320b5ff96fa 2831 /* FixPoint1814 / uint32 = FixPoint1814 */
johnAlexander 14:8320b5ff96fa 2832 sigma_limit_tmp = ((c_sigma_limit << 14) + 500) / 1000;
johnAlexander 14:8320b5ff96fa 2833
johnAlexander 14:8320b5ff96fa 2834 /* FixPoint1814 * FixPoint1814 = FixPoint3628 := FixPoint0428 */
johnAlexander 14:8320b5ff96fa 2835 sigma_limit_tmp *= sigma_limit_tmp;
johnAlexander 14:8320b5ff96fa 2836
johnAlexander 14:8320b5ff96fa 2837 /* FixPoint1616 * FixPoint1616 = FixPoint3232 */
johnAlexander 14:8320b5ff96fa 2838 sigma_est_sq_tmp = c_sigma_est_ref * c_sigma_est_ref;
johnAlexander 14:8320b5ff96fa 2839
johnAlexander 14:8320b5ff96fa 2840 /* FixPoint3232 >> 4 = FixPoint0428 */
johnAlexander 14:8320b5ff96fa 2841 sigma_est_sq_tmp = (sigma_est_sq_tmp + 0x08) >> 4;
johnAlexander 14:8320b5ff96fa 2842
johnAlexander 14:8320b5ff96fa 2843 /* FixPoint0428 - FixPoint0428 = FixPoint0428 */
johnAlexander 14:8320b5ff96fa 2844 sigma_limit_tmp -= sigma_est_sq_tmp;
johnAlexander 14:8320b5ff96fa 2845
johnAlexander 14:8320b5ff96fa 2846 /* uint32_t * FixPoint0428 = FixPoint0428 */
johnAlexander 14:8320b5ff96fa 2847 min_signal_needed_p4 = 4 * 12 * sigma_limit_tmp;
johnAlexander 14:8320b5ff96fa 2848
johnAlexander 14:8320b5ff96fa 2849 /* FixPoint0428 >> 14 = FixPoint1814 */
johnAlexander 14:8320b5ff96fa 2850 min_signal_needed_p4 = (min_signal_needed_p4 + 0x2000) >> 14;
johnAlexander 14:8320b5ff96fa 2851
johnAlexander 14:8320b5ff96fa 2852 /* uint32 + uint32 = uint32 */
johnAlexander 14:8320b5ff96fa 2853 min_signal_needed = (min_signal_needed_p2 + min_signal_needed_p3);
johnAlexander 14:8320b5ff96fa 2854
johnAlexander 14:8320b5ff96fa 2855 /* uint32 / uint32 = uint32 */
johnAlexander 14:8320b5ff96fa 2856 min_signal_needed += (peak_vcsel_duration_us / 2);
johnAlexander 14:8320b5ff96fa 2857 min_signal_needed /= peak_vcsel_duration_us;
johnAlexander 14:8320b5ff96fa 2858
johnAlexander 14:8320b5ff96fa 2859 /* uint32 << 14 = FixPoint1814 */
johnAlexander 14:8320b5ff96fa 2860 min_signal_needed <<= 14;
johnAlexander 14:8320b5ff96fa 2861
johnAlexander 14:8320b5ff96fa 2862 /* FixPoint1814 / FixPoint1814 = uint32 */
johnAlexander 14:8320b5ff96fa 2863 min_signal_needed += (min_signal_needed_p4 / 2);
johnAlexander 14:8320b5ff96fa 2864 min_signal_needed /= min_signal_needed_p4;
johnAlexander 14:8320b5ff96fa 2865
johnAlexander 14:8320b5ff96fa 2866 /* FixPoint3200 * FixPoint2804 := FixPoint2804*/
johnAlexander 14:8320b5ff96fa 2867 min_signal_needed *= min_signal_needed_p1;
johnAlexander 14:8320b5ff96fa 2868
johnAlexander 14:8320b5ff96fa 2869 /* Apply correction by dividing by 1000000.
johnAlexander 14:8320b5ff96fa 2870 * This assumes 10E16 on the numerator of the equation
johnAlexander 14:8320b5ff96fa 2871 * and 10E-22 on the denominator.
johnAlexander 14:8320b5ff96fa 2872 * We do this because 32bit fix point calculation can't
johnAlexander 14:8320b5ff96fa 2873 * handle the larger and smaller elements of this equation,
johnAlexander 14:8320b5ff96fa 2874 * i.e. speed of light and pulse widths.
johnAlexander 14:8320b5ff96fa 2875 */
johnAlexander 14:8320b5ff96fa 2876 min_signal_needed = (min_signal_needed + 500) / 1000;
johnAlexander 14:8320b5ff96fa 2877 min_signal_needed <<= 4;
johnAlexander 14:8320b5ff96fa 2878
johnAlexander 14:8320b5ff96fa 2879 min_signal_needed = (min_signal_needed + 500) / 1000;
johnAlexander 14:8320b5ff96fa 2880
johnAlexander 14:8320b5ff96fa 2881 /* FixPoint1616 >> 8 = FixPoint2408 */
johnAlexander 14:8320b5ff96fa 2882 signal_limit_tmp = (c_signal_limit + 0x80) >> 8;
johnAlexander 14:8320b5ff96fa 2883
johnAlexander 14:8320b5ff96fa 2884 /* FixPoint2408/FixPoint2408 = uint32 */
Davidroid 16:27d3d95c8593 2885 if (signal_limit_tmp != 0) {
johnAlexander 14:8320b5ff96fa 2886 dmax_dark_tmp = (signal_at0_mm + (signal_limit_tmp / 2))
johnAlexander 14:8320b5ff96fa 2887 / signal_limit_tmp;
Davidroid 16:27d3d95c8593 2888 } else {
johnAlexander 14:8320b5ff96fa 2889 dmax_dark_tmp = 0;
Davidroid 16:27d3d95c8593 2890 }
Davidroid 16:27d3d95c8593 2891
Davidroid 16:27d3d95c8593 2892 dmax_dark = VL53L0X_isqrt(dmax_dark_tmp);
johnAlexander 14:8320b5ff96fa 2893
johnAlexander 14:8320b5ff96fa 2894 /* FixPoint2408/FixPoint2408 = uint32 */
Davidroid 16:27d3d95c8593 2895 if (min_signal_needed != 0) {
johnAlexander 14:8320b5ff96fa 2896 dmax_ambient = (signal_at0_mm + min_signal_needed / 2)
johnAlexander 14:8320b5ff96fa 2897 / min_signal_needed;
Davidroid 16:27d3d95c8593 2898 } else {
johnAlexander 14:8320b5ff96fa 2899 dmax_ambient = 0;
Davidroid 16:27d3d95c8593 2900 }
Davidroid 16:27d3d95c8593 2901
Davidroid 16:27d3d95c8593 2902 dmax_ambient = VL53L0X_isqrt(dmax_ambient);
johnAlexander 14:8320b5ff96fa 2903
johnAlexander 14:8320b5ff96fa 2904 *pd_max_mm = dmax_dark;
Davidroid 16:27d3d95c8593 2905 if (dmax_dark > dmax_ambient) {
johnAlexander 14:8320b5ff96fa 2906 *pd_max_mm = dmax_ambient;
Davidroid 16:27d3d95c8593 2907 }
johnAlexander 14:8320b5ff96fa 2908
johnAlexander 14:8320b5ff96fa 2909 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 2910
johnAlexander 14:8320b5ff96fa 2911 return status;
johnAlexander 0:c523920bcc09 2912 }
johnAlexander 0:c523920bcc09 2913
Davidroid 16:27d3d95c8593 2914 VL53L0X_Error VL53L0X::VL53L0X_calc_sigma_estimate(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 2915 VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data,
johnAlexander 14:8320b5ff96fa 2916 FixPoint1616_t *p_sigma_estimate,
johnAlexander 14:8320b5ff96fa 2917 uint32_t *p_dmax_mm)
johnAlexander 0:c523920bcc09 2918 {
johnAlexander 14:8320b5ff96fa 2919 /* Expressed in 100ths of a ns, i.e. centi-ns */
johnAlexander 14:8320b5ff96fa 2920 const uint32_t c_pulse_effective_width_centi_ns = 800;
johnAlexander 14:8320b5ff96fa 2921 /* Expressed in 100ths of a ns, i.e. centi-ns */
johnAlexander 14:8320b5ff96fa 2922 const uint32_t c_ambient_effective_width_centi_ns = 600;
johnAlexander 14:8320b5ff96fa 2923 const FixPoint1616_t c_dflt_final_range_integration_time_milli_secs = 0x00190000; /* 25ms */
johnAlexander 14:8320b5ff96fa 2924 const uint32_t c_vcsel_pulse_width_ps = 4700; /* pico secs */
johnAlexander 14:8320b5ff96fa 2925 const FixPoint1616_t c_sigma_est_max = 0x028F87AE;
johnAlexander 14:8320b5ff96fa 2926 const FixPoint1616_t c_sigma_est_rtn_max = 0xF000;
johnAlexander 14:8320b5ff96fa 2927 const FixPoint1616_t c_amb_to_signal_ratio_max = 0xF0000000 /
johnAlexander 14:8320b5ff96fa 2928 c_ambient_effective_width_centi_ns;
johnAlexander 14:8320b5ff96fa 2929 /* Time Of Flight per mm (6.6 pico secs) */
johnAlexander 14:8320b5ff96fa 2930 const FixPoint1616_t c_tof_per_mm_ps = 0x0006999A;
johnAlexander 14:8320b5ff96fa 2931 const uint32_t c_16bit_rounding_param = 0x00008000;
johnAlexander 14:8320b5ff96fa 2932 const FixPoint1616_t c_max_x_talk_kcps = 0x00320000;
johnAlexander 14:8320b5ff96fa 2933 const uint32_t c_pll_period_ps = 1655;
johnAlexander 14:8320b5ff96fa 2934
johnAlexander 14:8320b5ff96fa 2935 uint32_t vcsel_total_events_rtn;
johnAlexander 14:8320b5ff96fa 2936 uint32_t final_range_timeout_micro_secs;
johnAlexander 14:8320b5ff96fa 2937 uint32_t pre_range_timeout_micro_secs;
johnAlexander 14:8320b5ff96fa 2938 uint32_t final_range_integration_time_milli_secs;
johnAlexander 14:8320b5ff96fa 2939 FixPoint1616_t sigma_estimate_p1;
johnAlexander 14:8320b5ff96fa 2940 FixPoint1616_t sigma_estimate_p2;
johnAlexander 14:8320b5ff96fa 2941 FixPoint1616_t sigma_estimate_p3;
johnAlexander 14:8320b5ff96fa 2942 FixPoint1616_t delta_t_ps;
johnAlexander 14:8320b5ff96fa 2943 FixPoint1616_t pw_mult;
johnAlexander 14:8320b5ff96fa 2944 FixPoint1616_t sigma_est_rtn;
johnAlexander 14:8320b5ff96fa 2945 FixPoint1616_t sigma_estimate;
johnAlexander 14:8320b5ff96fa 2946 FixPoint1616_t x_talk_correction;
johnAlexander 14:8320b5ff96fa 2947 FixPoint1616_t ambient_rate_kcps;
johnAlexander 14:8320b5ff96fa 2948 FixPoint1616_t peak_signal_rate_kcps;
johnAlexander 14:8320b5ff96fa 2949 FixPoint1616_t x_talk_comp_rate_mcps;
johnAlexander 14:8320b5ff96fa 2950 uint32_t x_talk_comp_rate_kcps;
johnAlexander 14:8320b5ff96fa 2951 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 2952 FixPoint1616_t diff1_mcps;
johnAlexander 14:8320b5ff96fa 2953 FixPoint1616_t diff2_mcps;
johnAlexander 14:8320b5ff96fa 2954 FixPoint1616_t sqr1;
johnAlexander 14:8320b5ff96fa 2955 FixPoint1616_t sqr2;
johnAlexander 14:8320b5ff96fa 2956 FixPoint1616_t sqr_sum;
johnAlexander 14:8320b5ff96fa 2957 FixPoint1616_t sqrt_result_centi_ns;
johnAlexander 14:8320b5ff96fa 2958 FixPoint1616_t sqrt_result;
johnAlexander 14:8320b5ff96fa 2959 FixPoint1616_t total_signal_rate_mcps;
johnAlexander 14:8320b5ff96fa 2960 FixPoint1616_t corrected_signal_rate_mcps;
johnAlexander 14:8320b5ff96fa 2961 FixPoint1616_t sigma_est_ref;
johnAlexander 14:8320b5ff96fa 2962 uint32_t vcsel_width;
johnAlexander 14:8320b5ff96fa 2963 uint32_t final_range_macro_pclks;
johnAlexander 14:8320b5ff96fa 2964 uint32_t pre_range_macro_pclks;
johnAlexander 14:8320b5ff96fa 2965 uint32_t peak_vcsel_duration_us;
johnAlexander 14:8320b5ff96fa 2966 uint8_t final_range_vcsel_pclks;
johnAlexander 14:8320b5ff96fa 2967 uint8_t pre_range_vcsel_pclks;
johnAlexander 14:8320b5ff96fa 2968 /*! \addtogroup calc_sigma_estimate
johnAlexander 14:8320b5ff96fa 2969 * @{
johnAlexander 14:8320b5ff96fa 2970 *
johnAlexander 14:8320b5ff96fa 2971 * Estimates the range sigma
johnAlexander 14:8320b5ff96fa 2972 */
johnAlexander 14:8320b5ff96fa 2973
johnAlexander 14:8320b5ff96fa 2974 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 2975
johnAlexander 14:8320b5ff96fa 2976 VL53L0X_GETPARAMETERFIELD(dev, XTalkCompensationRateMegaCps,
johnAlexander 14:8320b5ff96fa 2977 x_talk_comp_rate_mcps);
johnAlexander 14:8320b5ff96fa 2978
johnAlexander 14:8320b5ff96fa 2979 /*
johnAlexander 14:8320b5ff96fa 2980 * We work in kcps rather than mcps as this helps keep within the
johnAlexander 14:8320b5ff96fa 2981 * confines of the 32 Fix1616 type.
johnAlexander 14:8320b5ff96fa 2982 */
johnAlexander 14:8320b5ff96fa 2983
johnAlexander 14:8320b5ff96fa 2984 ambient_rate_kcps =
johnAlexander 14:8320b5ff96fa 2985 (p_ranging_measurement_data->AmbientRateRtnMegaCps * 1000) >> 16;
johnAlexander 14:8320b5ff96fa 2986
johnAlexander 14:8320b5ff96fa 2987 corrected_signal_rate_mcps =
johnAlexander 14:8320b5ff96fa 2988 p_ranging_measurement_data->SignalRateRtnMegaCps;
johnAlexander 14:8320b5ff96fa 2989
johnAlexander 14:8320b5ff96fa 2990
Davidroid 16:27d3d95c8593 2991 status = VL53L0X_get_total_signal_rate(
johnAlexander 14:8320b5ff96fa 2992 dev, p_ranging_measurement_data, &total_signal_rate_mcps);
Davidroid 16:27d3d95c8593 2993 status = VL53L0X_get_total_xtalk_rate(
johnAlexander 14:8320b5ff96fa 2994 dev, p_ranging_measurement_data, &x_talk_comp_rate_mcps);
johnAlexander 14:8320b5ff96fa 2995
johnAlexander 14:8320b5ff96fa 2996
johnAlexander 14:8320b5ff96fa 2997 /* Signal rate measurement provided by device is the
johnAlexander 14:8320b5ff96fa 2998 * peak signal rate, not average.
johnAlexander 14:8320b5ff96fa 2999 */
johnAlexander 14:8320b5ff96fa 3000 peak_signal_rate_kcps = (total_signal_rate_mcps * 1000);
johnAlexander 14:8320b5ff96fa 3001 peak_signal_rate_kcps = (peak_signal_rate_kcps + 0x8000) >> 16;
johnAlexander 14:8320b5ff96fa 3002
johnAlexander 14:8320b5ff96fa 3003 x_talk_comp_rate_kcps = x_talk_comp_rate_mcps * 1000;
johnAlexander 14:8320b5ff96fa 3004
Davidroid 16:27d3d95c8593 3005 if (x_talk_comp_rate_kcps > c_max_x_talk_kcps) {
johnAlexander 14:8320b5ff96fa 3006 x_talk_comp_rate_kcps = c_max_x_talk_kcps;
Davidroid 16:27d3d95c8593 3007 }
johnAlexander 14:8320b5ff96fa 3008
johnAlexander 14:8320b5ff96fa 3009 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 3010
johnAlexander 14:8320b5ff96fa 3011 /* Calculate final range macro periods */
johnAlexander 14:8320b5ff96fa 3012 final_range_timeout_micro_secs = VL53L0X_GETDEVICESPECIFICPARAMETER(
johnAlexander 14:8320b5ff96fa 3013 dev, FinalRangeTimeoutMicroSecs);
johnAlexander 14:8320b5ff96fa 3014
johnAlexander 14:8320b5ff96fa 3015 final_range_vcsel_pclks = VL53L0X_GETDEVICESPECIFICPARAMETER(
johnAlexander 14:8320b5ff96fa 3016 dev, FinalRangeVcselPulsePeriod);
johnAlexander 14:8320b5ff96fa 3017
Davidroid 16:27d3d95c8593 3018 final_range_macro_pclks = VL53L0X_calc_timeout_mclks(
johnAlexander 14:8320b5ff96fa 3019 dev, final_range_timeout_micro_secs, final_range_vcsel_pclks);
johnAlexander 14:8320b5ff96fa 3020
johnAlexander 14:8320b5ff96fa 3021 /* Calculate pre-range macro periods */
johnAlexander 14:8320b5ff96fa 3022 pre_range_timeout_micro_secs = VL53L0X_GETDEVICESPECIFICPARAMETER(
johnAlexander 14:8320b5ff96fa 3023 dev, PreRangeTimeoutMicroSecs);
johnAlexander 14:8320b5ff96fa 3024
johnAlexander 14:8320b5ff96fa 3025 pre_range_vcsel_pclks = VL53L0X_GETDEVICESPECIFICPARAMETER(
johnAlexander 14:8320b5ff96fa 3026 dev, PreRangeVcselPulsePeriod);
johnAlexander 14:8320b5ff96fa 3027
Davidroid 16:27d3d95c8593 3028 pre_range_macro_pclks = VL53L0X_calc_timeout_mclks(
johnAlexander 14:8320b5ff96fa 3029 dev, pre_range_timeout_micro_secs, pre_range_vcsel_pclks);
johnAlexander 14:8320b5ff96fa 3030
johnAlexander 14:8320b5ff96fa 3031 vcsel_width = 3;
Davidroid 16:27d3d95c8593 3032 if (final_range_vcsel_pclks == 8) {
johnAlexander 14:8320b5ff96fa 3033 vcsel_width = 2;
Davidroid 16:27d3d95c8593 3034 }
johnAlexander 14:8320b5ff96fa 3035
johnAlexander 14:8320b5ff96fa 3036
johnAlexander 14:8320b5ff96fa 3037 peak_vcsel_duration_us = vcsel_width * 2048 *
johnAlexander 14:8320b5ff96fa 3038 (pre_range_macro_pclks + final_range_macro_pclks);
johnAlexander 14:8320b5ff96fa 3039 peak_vcsel_duration_us = (peak_vcsel_duration_us + 500) / 1000;
johnAlexander 14:8320b5ff96fa 3040 peak_vcsel_duration_us *= c_pll_period_ps;
johnAlexander 14:8320b5ff96fa 3041 peak_vcsel_duration_us = (peak_vcsel_duration_us + 500) / 1000;
johnAlexander 14:8320b5ff96fa 3042
johnAlexander 14:8320b5ff96fa 3043 /* Fix1616 >> 8 = Fix2408 */
johnAlexander 14:8320b5ff96fa 3044 total_signal_rate_mcps = (total_signal_rate_mcps + 0x80) >> 8;
johnAlexander 14:8320b5ff96fa 3045
johnAlexander 14:8320b5ff96fa 3046 /* Fix2408 * uint32 = Fix2408 */
johnAlexander 14:8320b5ff96fa 3047 vcsel_total_events_rtn = total_signal_rate_mcps *
johnAlexander 14:8320b5ff96fa 3048 peak_vcsel_duration_us;
johnAlexander 14:8320b5ff96fa 3049
johnAlexander 14:8320b5ff96fa 3050 /* Fix2408 >> 8 = uint32 */
johnAlexander 14:8320b5ff96fa 3051 vcsel_total_events_rtn = (vcsel_total_events_rtn + 0x80) >> 8;
johnAlexander 14:8320b5ff96fa 3052
johnAlexander 14:8320b5ff96fa 3053 /* Fix2408 << 8 = Fix1616 = */
johnAlexander 14:8320b5ff96fa 3054 total_signal_rate_mcps <<= 8;
johnAlexander 14:8320b5ff96fa 3055 }
johnAlexander 14:8320b5ff96fa 3056
johnAlexander 14:8320b5ff96fa 3057 if (status != VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 3058 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 3059 return status;
johnAlexander 14:8320b5ff96fa 3060 }
johnAlexander 14:8320b5ff96fa 3061
johnAlexander 14:8320b5ff96fa 3062 if (peak_signal_rate_kcps == 0) {
johnAlexander 14:8320b5ff96fa 3063 *p_sigma_estimate = c_sigma_est_max;
johnAlexander 14:8320b5ff96fa 3064 PALDevDataSet(dev, SigmaEstimate, c_sigma_est_max);
johnAlexander 14:8320b5ff96fa 3065 *p_dmax_mm = 0;
johnAlexander 14:8320b5ff96fa 3066 } else {
Davidroid 16:27d3d95c8593 3067 if (vcsel_total_events_rtn < 1) {
johnAlexander 14:8320b5ff96fa 3068 vcsel_total_events_rtn = 1;
Davidroid 16:27d3d95c8593 3069 }
johnAlexander 14:8320b5ff96fa 3070
johnAlexander 14:8320b5ff96fa 3071 sigma_estimate_p1 = c_pulse_effective_width_centi_ns;
johnAlexander 14:8320b5ff96fa 3072
johnAlexander 14:8320b5ff96fa 3073 /* ((FixPoint1616 << 16)* uint32)/uint32 = FixPoint1616 */
johnAlexander 14:8320b5ff96fa 3074 sigma_estimate_p2 = (ambient_rate_kcps << 16) / peak_signal_rate_kcps;
johnAlexander 14:8320b5ff96fa 3075 if (sigma_estimate_p2 > c_amb_to_signal_ratio_max) {
johnAlexander 14:8320b5ff96fa 3076 /* Clip to prevent overflow. Will ensure safe
johnAlexander 14:8320b5ff96fa 3077 * max result. */
johnAlexander 14:8320b5ff96fa 3078 sigma_estimate_p2 = c_amb_to_signal_ratio_max;
johnAlexander 14:8320b5ff96fa 3079 }
johnAlexander 14:8320b5ff96fa 3080 sigma_estimate_p2 *= c_ambient_effective_width_centi_ns;
johnAlexander 14:8320b5ff96fa 3081
Davidroid 16:27d3d95c8593 3082 sigma_estimate_p3 = 2 * VL53L0X_isqrt(vcsel_total_events_rtn * 12);
johnAlexander 14:8320b5ff96fa 3083
johnAlexander 14:8320b5ff96fa 3084 /* uint32 * FixPoint1616 = FixPoint1616 */
johnAlexander 14:8320b5ff96fa 3085 delta_t_ps = p_ranging_measurement_data->RangeMilliMeter *
johnAlexander 14:8320b5ff96fa 3086 c_tof_per_mm_ps;
johnAlexander 14:8320b5ff96fa 3087
johnAlexander 14:8320b5ff96fa 3088 /*
johnAlexander 14:8320b5ff96fa 3089 * vcselRate - xtalkCompRate
johnAlexander 14:8320b5ff96fa 3090 * (uint32 << 16) - FixPoint1616 = FixPoint1616.
johnAlexander 14:8320b5ff96fa 3091 * Divide result by 1000 to convert to mcps.
johnAlexander 14:8320b5ff96fa 3092 * 500 is added to ensure rounding when integer division
johnAlexander 14:8320b5ff96fa 3093 * truncates.
johnAlexander 14:8320b5ff96fa 3094 */
johnAlexander 14:8320b5ff96fa 3095 diff1_mcps = (((peak_signal_rate_kcps << 16) -
johnAlexander 14:8320b5ff96fa 3096 2 * x_talk_comp_rate_kcps) + 500) / 1000;
johnAlexander 14:8320b5ff96fa 3097
johnAlexander 14:8320b5ff96fa 3098 /* vcselRate + xtalkCompRate */
johnAlexander 14:8320b5ff96fa 3099 diff2_mcps = ((peak_signal_rate_kcps << 16) + 500) / 1000;
johnAlexander 14:8320b5ff96fa 3100
johnAlexander 14:8320b5ff96fa 3101 /* Shift by 8 bits to increase resolution prior to the
johnAlexander 14:8320b5ff96fa 3102 * division */
johnAlexander 14:8320b5ff96fa 3103 diff1_mcps <<= 8;
johnAlexander 14:8320b5ff96fa 3104
johnAlexander 14:8320b5ff96fa 3105 /* FixPoint0824/FixPoint1616 = FixPoint2408 */
johnAlexander 0:c523920bcc09 3106 // xTalkCorrection = abs(diff1_mcps/diff2_mcps);
johnAlexander 0:c523920bcc09 3107 // abs is causing compiler overloading isue in C++, but unsigned types. So, redundant call anyway!
johnAlexander 14:8320b5ff96fa 3108 x_talk_correction = diff1_mcps / diff2_mcps;
johnAlexander 14:8320b5ff96fa 3109
johnAlexander 14:8320b5ff96fa 3110 /* FixPoint2408 << 8 = FixPoint1616 */
johnAlexander 14:8320b5ff96fa 3111 x_talk_correction <<= 8;
johnAlexander 14:8320b5ff96fa 3112
johnAlexander 14:8320b5ff96fa 3113 if (p_ranging_measurement_data->RangeStatus != 0) {
johnAlexander 14:8320b5ff96fa 3114 pw_mult = 1 << 16;
johnAlexander 14:8320b5ff96fa 3115 } else {
johnAlexander 14:8320b5ff96fa 3116 /* FixPoint1616/uint32 = FixPoint1616 */
johnAlexander 14:8320b5ff96fa 3117 pw_mult = delta_t_ps / c_vcsel_pulse_width_ps; /* smaller than 1.0f */
johnAlexander 14:8320b5ff96fa 3118
johnAlexander 14:8320b5ff96fa 3119 /*
johnAlexander 14:8320b5ff96fa 3120 * FixPoint1616 * FixPoint1616 = FixPoint3232, however both
johnAlexander 14:8320b5ff96fa 3121 * values are small enough such that32 bits will not be
johnAlexander 14:8320b5ff96fa 3122 * exceeded.
johnAlexander 14:8320b5ff96fa 3123 */
johnAlexander 14:8320b5ff96fa 3124 pw_mult *= ((1 << 16) - x_talk_correction);
johnAlexander 14:8320b5ff96fa 3125
johnAlexander 14:8320b5ff96fa 3126 /* (FixPoint3232 >> 16) = FixPoint1616 */
johnAlexander 14:8320b5ff96fa 3127 pw_mult = (pw_mult + c_16bit_rounding_param) >> 16;
johnAlexander 14:8320b5ff96fa 3128
johnAlexander 14:8320b5ff96fa 3129 /* FixPoint1616 + FixPoint1616 = FixPoint1616 */
johnAlexander 14:8320b5ff96fa 3130 pw_mult += (1 << 16);
johnAlexander 14:8320b5ff96fa 3131
johnAlexander 14:8320b5ff96fa 3132 /*
johnAlexander 14:8320b5ff96fa 3133 * At this point the value will be 1.xx, therefore if we square
johnAlexander 14:8320b5ff96fa 3134 * the value this will exceed 32 bits. To address this perform
johnAlexander 14:8320b5ff96fa 3135 * a single shift to the right before the multiplication.
johnAlexander 14:8320b5ff96fa 3136 */
johnAlexander 14:8320b5ff96fa 3137 pw_mult >>= 1;
johnAlexander 14:8320b5ff96fa 3138 /* FixPoint1715 * FixPoint1715 = FixPoint3430 */
johnAlexander 14:8320b5ff96fa 3139 pw_mult = pw_mult * pw_mult;
johnAlexander 14:8320b5ff96fa 3140
johnAlexander 14:8320b5ff96fa 3141 /* (FixPoint3430 >> 14) = Fix1616 */
johnAlexander 14:8320b5ff96fa 3142 pw_mult >>= 14;
johnAlexander 14:8320b5ff96fa 3143 }
johnAlexander 14:8320b5ff96fa 3144
johnAlexander 14:8320b5ff96fa 3145 /* FixPoint1616 * uint32 = FixPoint1616 */
johnAlexander 14:8320b5ff96fa 3146 sqr1 = pw_mult * sigma_estimate_p1;
johnAlexander 14:8320b5ff96fa 3147
johnAlexander 14:8320b5ff96fa 3148 /* (FixPoint1616 >> 16) = FixPoint3200 */
johnAlexander 14:8320b5ff96fa 3149 sqr1 = (sqr1 + 0x8000) >> 16;
johnAlexander 14:8320b5ff96fa 3150
johnAlexander 14:8320b5ff96fa 3151 /* FixPoint3200 * FixPoint3200 = FixPoint6400 */
johnAlexander 14:8320b5ff96fa 3152 sqr1 *= sqr1;
johnAlexander 14:8320b5ff96fa 3153
johnAlexander 14:8320b5ff96fa 3154 sqr2 = sigma_estimate_p2;
johnAlexander 14:8320b5ff96fa 3155
johnAlexander 14:8320b5ff96fa 3156 /* (FixPoint1616 >> 16) = FixPoint3200 */
johnAlexander 14:8320b5ff96fa 3157 sqr2 = (sqr2 + 0x8000) >> 16;
johnAlexander 14:8320b5ff96fa 3158
johnAlexander 14:8320b5ff96fa 3159 /* FixPoint3200 * FixPoint3200 = FixPoint6400 */
johnAlexander 14:8320b5ff96fa 3160 sqr2 *= sqr2;
johnAlexander 14:8320b5ff96fa 3161
johnAlexander 14:8320b5ff96fa 3162 /* FixPoint64000 + FixPoint6400 = FixPoint6400 */
johnAlexander 14:8320b5ff96fa 3163 sqr_sum = sqr1 + sqr2;
johnAlexander 14:8320b5ff96fa 3164
johnAlexander 14:8320b5ff96fa 3165 /* SQRT(FixPoin6400) = FixPoint3200 */
Davidroid 16:27d3d95c8593 3166 sqrt_result_centi_ns = VL53L0X_isqrt(sqr_sum);
johnAlexander 14:8320b5ff96fa 3167
johnAlexander 14:8320b5ff96fa 3168 /* (FixPoint3200 << 16) = FixPoint1616 */
johnAlexander 14:8320b5ff96fa 3169 sqrt_result_centi_ns <<= 16;
johnAlexander 14:8320b5ff96fa 3170
johnAlexander 14:8320b5ff96fa 3171 /*
johnAlexander 14:8320b5ff96fa 3172 * Note that the Speed Of Light is expressed in um per 1E-10
johnAlexander 14:8320b5ff96fa 3173 * seconds (2997) Therefore to get mm/ns we have to divide by
johnAlexander 14:8320b5ff96fa 3174 * 10000
johnAlexander 14:8320b5ff96fa 3175 */
johnAlexander 14:8320b5ff96fa 3176 sigma_est_rtn = (((sqrt_result_centi_ns + 50) / 100) /
johnAlexander 14:8320b5ff96fa 3177 sigma_estimate_p3);
johnAlexander 14:8320b5ff96fa 3178 sigma_est_rtn *= VL53L0X_SPEED_OF_LIGHT_IN_AIR;
johnAlexander 14:8320b5ff96fa 3179
johnAlexander 14:8320b5ff96fa 3180 /* Add 5000 before dividing by 10000 to ensure rounding. */
johnAlexander 14:8320b5ff96fa 3181 sigma_est_rtn += 5000;
johnAlexander 14:8320b5ff96fa 3182 sigma_est_rtn /= 10000;
johnAlexander 14:8320b5ff96fa 3183
johnAlexander 14:8320b5ff96fa 3184 if (sigma_est_rtn > c_sigma_est_rtn_max) {
johnAlexander 14:8320b5ff96fa 3185 /* Clip to prevent overflow. Will ensure safe
johnAlexander 14:8320b5ff96fa 3186 * max result. */
johnAlexander 14:8320b5ff96fa 3187 sigma_est_rtn = c_sigma_est_rtn_max;
johnAlexander 14:8320b5ff96fa 3188 }
johnAlexander 14:8320b5ff96fa 3189 final_range_integration_time_milli_secs =
johnAlexander 14:8320b5ff96fa 3190 (final_range_timeout_micro_secs + pre_range_timeout_micro_secs + 500) / 1000;
johnAlexander 14:8320b5ff96fa 3191
johnAlexander 14:8320b5ff96fa 3192 /* sigmaEstRef = 1mm * 25ms/final range integration time (inc pre-range)
johnAlexander 14:8320b5ff96fa 3193 * sqrt(FixPoint1616/int) = FixPoint2408)
johnAlexander 14:8320b5ff96fa 3194 */
johnAlexander 14:8320b5ff96fa 3195 sigma_est_ref =
Davidroid 16:27d3d95c8593 3196 VL53L0X_isqrt((c_dflt_final_range_integration_time_milli_secs +
johnAlexander 14:8320b5ff96fa 3197 final_range_integration_time_milli_secs / 2) /
johnAlexander 14:8320b5ff96fa 3198 final_range_integration_time_milli_secs);
johnAlexander 14:8320b5ff96fa 3199
johnAlexander 14:8320b5ff96fa 3200 /* FixPoint2408 << 8 = FixPoint1616 */
johnAlexander 14:8320b5ff96fa 3201 sigma_est_ref <<= 8;
johnAlexander 14:8320b5ff96fa 3202 sigma_est_ref = (sigma_est_ref + 500) / 1000;
johnAlexander 14:8320b5ff96fa 3203
johnAlexander 14:8320b5ff96fa 3204 /* FixPoint1616 * FixPoint1616 = FixPoint3232 */
johnAlexander 14:8320b5ff96fa 3205 sqr1 = sigma_est_rtn * sigma_est_rtn;
johnAlexander 14:8320b5ff96fa 3206 /* FixPoint1616 * FixPoint1616 = FixPoint3232 */
johnAlexander 14:8320b5ff96fa 3207 sqr2 = sigma_est_ref * sigma_est_ref;
johnAlexander 14:8320b5ff96fa 3208
johnAlexander 14:8320b5ff96fa 3209 /* sqrt(FixPoint3232) = FixPoint1616 */
Davidroid 16:27d3d95c8593 3210 sqrt_result = VL53L0X_isqrt((sqr1 + sqr2));
johnAlexander 14:8320b5ff96fa 3211 /*
johnAlexander 14:8320b5ff96fa 3212 * Note that the Shift by 4 bits increases resolution prior to
johnAlexander 14:8320b5ff96fa 3213 * the sqrt, therefore the result must be shifted by 2 bits to
johnAlexander 14:8320b5ff96fa 3214 * the right to revert back to the FixPoint1616 format.
johnAlexander 14:8320b5ff96fa 3215 */
johnAlexander 14:8320b5ff96fa 3216
johnAlexander 14:8320b5ff96fa 3217 sigma_estimate = 1000 * sqrt_result;
johnAlexander 14:8320b5ff96fa 3218
johnAlexander 14:8320b5ff96fa 3219 if ((peak_signal_rate_kcps < 1) || (vcsel_total_events_rtn < 1) ||
johnAlexander 14:8320b5ff96fa 3220 (sigma_estimate > c_sigma_est_max)) {
johnAlexander 14:8320b5ff96fa 3221 sigma_estimate = c_sigma_est_max;
johnAlexander 14:8320b5ff96fa 3222 }
johnAlexander 14:8320b5ff96fa 3223
johnAlexander 14:8320b5ff96fa 3224 *p_sigma_estimate = (uint32_t)(sigma_estimate);
johnAlexander 14:8320b5ff96fa 3225 PALDevDataSet(dev, SigmaEstimate, *p_sigma_estimate);
Davidroid 16:27d3d95c8593 3226 status = VL53L0X_calc_dmax(
johnAlexander 14:8320b5ff96fa 3227 dev,
johnAlexander 14:8320b5ff96fa 3228 total_signal_rate_mcps,
johnAlexander 14:8320b5ff96fa 3229 corrected_signal_rate_mcps,
johnAlexander 14:8320b5ff96fa 3230 pw_mult,
johnAlexander 14:8320b5ff96fa 3231 sigma_estimate_p1,
johnAlexander 14:8320b5ff96fa 3232 sigma_estimate_p2,
johnAlexander 14:8320b5ff96fa 3233 peak_vcsel_duration_us,
johnAlexander 14:8320b5ff96fa 3234 p_dmax_mm);
johnAlexander 14:8320b5ff96fa 3235 }
johnAlexander 14:8320b5ff96fa 3236
johnAlexander 14:8320b5ff96fa 3237 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 3238 return status;
johnAlexander 0:c523920bcc09 3239 }
johnAlexander 0:c523920bcc09 3240
Davidroid 16:27d3d95c8593 3241 VL53L0X_Error VL53L0X::VL53L0X_get_pal_range_status(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 3242 uint8_t device_range_status,
johnAlexander 14:8320b5ff96fa 3243 FixPoint1616_t signal_rate,
johnAlexander 14:8320b5ff96fa 3244 uint16_t effective_spad_rtn_count,
johnAlexander 14:8320b5ff96fa 3245 VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data,
johnAlexander 14:8320b5ff96fa 3246 uint8_t *p_pal_range_status)
johnAlexander 0:c523920bcc09 3247 {
johnAlexander 14:8320b5ff96fa 3248 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 3249 uint8_t none_flag;
johnAlexander 14:8320b5ff96fa 3250 uint8_t sigma_limitflag = 0;
johnAlexander 14:8320b5ff96fa 3251 uint8_t signal_ref_clipflag = 0;
johnAlexander 14:8320b5ff96fa 3252 uint8_t range_ignore_thresholdflag = 0;
johnAlexander 14:8320b5ff96fa 3253 uint8_t sigma_limit_check_enable = 0;
johnAlexander 14:8320b5ff96fa 3254 uint8_t signal_rate_final_range_limit_check_enable = 0;
johnAlexander 14:8320b5ff96fa 3255 uint8_t signal_ref_clip_limit_check_enable = 0;
johnAlexander 14:8320b5ff96fa 3256 uint8_t range_ignore_threshold_limit_check_enable = 0;
johnAlexander 14:8320b5ff96fa 3257 FixPoint1616_t sigma_estimate;
johnAlexander 14:8320b5ff96fa 3258 FixPoint1616_t sigma_limit_value;
johnAlexander 14:8320b5ff96fa 3259 FixPoint1616_t signal_ref_clip_value;
johnAlexander 14:8320b5ff96fa 3260 FixPoint1616_t range_ignore_threshold_value;
johnAlexander 14:8320b5ff96fa 3261 FixPoint1616_t signal_rate_per_spad;
johnAlexander 14:8320b5ff96fa 3262 uint8_t device_range_status_internal = 0;
johnAlexander 14:8320b5ff96fa 3263 uint16_t tmp_word = 0;
johnAlexander 14:8320b5ff96fa 3264 uint8_t temp8;
johnAlexander 14:8320b5ff96fa 3265 uint32_t dmax_mm = 0;
johnAlexander 14:8320b5ff96fa 3266 FixPoint1616_t last_signal_ref_mcps;
johnAlexander 14:8320b5ff96fa 3267
johnAlexander 14:8320b5ff96fa 3268 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 3269
johnAlexander 14:8320b5ff96fa 3270
johnAlexander 14:8320b5ff96fa 3271 /*
johnAlexander 14:8320b5ff96fa 3272 * VL53L0X has a good ranging when the value of the
johnAlexander 14:8320b5ff96fa 3273 * DeviceRangeStatus = 11. This function will replace the value 0 with
johnAlexander 14:8320b5ff96fa 3274 * the value 11 in the DeviceRangeStatus.
johnAlexander 14:8320b5ff96fa 3275 * In addition, the SigmaEstimator is not included in the VL53L0X
johnAlexander 14:8320b5ff96fa 3276 * DeviceRangeStatus, this will be added in the PalRangeStatus.
johnAlexander 14:8320b5ff96fa 3277 */
johnAlexander 14:8320b5ff96fa 3278
johnAlexander 14:8320b5ff96fa 3279 device_range_status_internal = ((device_range_status & 0x78) >> 3);
johnAlexander 14:8320b5ff96fa 3280
johnAlexander 14:8320b5ff96fa 3281 if (device_range_status_internal == 0 ||
johnAlexander 14:8320b5ff96fa 3282 device_range_status_internal == 5 ||
johnAlexander 14:8320b5ff96fa 3283 device_range_status_internal == 7 ||
johnAlexander 14:8320b5ff96fa 3284 device_range_status_internal == 12 ||
johnAlexander 14:8320b5ff96fa 3285 device_range_status_internal == 13 ||
johnAlexander 14:8320b5ff96fa 3286 device_range_status_internal == 14 ||
johnAlexander 14:8320b5ff96fa 3287 device_range_status_internal == 15
johnAlexander 14:8320b5ff96fa 3288 ) {
johnAlexander 14:8320b5ff96fa 3289 none_flag = 1;
johnAlexander 14:8320b5ff96fa 3290 } else {
johnAlexander 14:8320b5ff96fa 3291 none_flag = 0;
johnAlexander 14:8320b5ff96fa 3292 }
johnAlexander 14:8320b5ff96fa 3293
johnAlexander 14:8320b5ff96fa 3294 /*
johnAlexander 14:8320b5ff96fa 3295 * Check if Sigma limit is enabled, if yes then do comparison with limit
johnAlexander 14:8320b5ff96fa 3296 * value and put the result back into pPalRangeStatus.
johnAlexander 14:8320b5ff96fa 3297 */
Davidroid 16:27d3d95c8593 3298 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 3299 status = VL53L0X_get_limit_check_enable(dev,
johnAlexander 14:8320b5ff96fa 3300 VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
johnAlexander 14:8320b5ff96fa 3301 &sigma_limit_check_enable);
Davidroid 16:27d3d95c8593 3302 }
johnAlexander 14:8320b5ff96fa 3303
johnAlexander 14:8320b5ff96fa 3304 if ((sigma_limit_check_enable != 0) && (status == VL53L0X_ERROR_NONE)) {
johnAlexander 14:8320b5ff96fa 3305 /*
johnAlexander 14:8320b5ff96fa 3306 * compute the Sigma and check with limit
johnAlexander 14:8320b5ff96fa 3307 */
Davidroid 16:27d3d95c8593 3308 status = VL53L0X_calc_sigma_estimate(
johnAlexander 14:8320b5ff96fa 3309 dev,
johnAlexander 14:8320b5ff96fa 3310 p_ranging_measurement_data,
johnAlexander 14:8320b5ff96fa 3311 &sigma_estimate,
johnAlexander 14:8320b5ff96fa 3312 &dmax_mm);
Davidroid 16:27d3d95c8593 3313 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 3314 p_ranging_measurement_data->RangeDMaxMilliMeter = dmax_mm;
Davidroid 16:27d3d95c8593 3315 }
johnAlexander 14:8320b5ff96fa 3316
johnAlexander 14:8320b5ff96fa 3317 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 3318 status = VL53L0X_get_limit_check_value(dev,
johnAlexander 14:8320b5ff96fa 3319 VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
johnAlexander 14:8320b5ff96fa 3320 &sigma_limit_value);
johnAlexander 14:8320b5ff96fa 3321
johnAlexander 14:8320b5ff96fa 3322 if ((sigma_limit_value > 0) &&
Davidroid 16:27d3d95c8593 3323 (sigma_estimate > sigma_limit_value)) {
johnAlexander 14:8320b5ff96fa 3324 /* Limit Fail */
johnAlexander 14:8320b5ff96fa 3325 sigma_limitflag = 1;
Davidroid 16:27d3d95c8593 3326 }
johnAlexander 14:8320b5ff96fa 3327 }
johnAlexander 14:8320b5ff96fa 3328 }
johnAlexander 14:8320b5ff96fa 3329
johnAlexander 14:8320b5ff96fa 3330 /*
johnAlexander 14:8320b5ff96fa 3331 * Check if Signal ref clip limit is enabled, if yes then do comparison
johnAlexander 14:8320b5ff96fa 3332 * with limit value and put the result back into pPalRangeStatus.
johnAlexander 14:8320b5ff96fa 3333 */
Davidroid 16:27d3d95c8593 3334 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 3335 status = VL53L0X_get_limit_check_enable(dev,
johnAlexander 14:8320b5ff96fa 3336 VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
johnAlexander 14:8320b5ff96fa 3337 &signal_ref_clip_limit_check_enable);
Davidroid 16:27d3d95c8593 3338 }
johnAlexander 14:8320b5ff96fa 3339
johnAlexander 14:8320b5ff96fa 3340 if ((signal_ref_clip_limit_check_enable != 0) &&
johnAlexander 14:8320b5ff96fa 3341 (status == VL53L0X_ERROR_NONE)) {
johnAlexander 14:8320b5ff96fa 3342
Davidroid 16:27d3d95c8593 3343 status = VL53L0X_get_limit_check_value(dev,
johnAlexander 14:8320b5ff96fa 3344 VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
johnAlexander 14:8320b5ff96fa 3345 &signal_ref_clip_value);
johnAlexander 14:8320b5ff96fa 3346
johnAlexander 14:8320b5ff96fa 3347 /* Read LastSignalRefMcps from device */
Davidroid 16:27d3d95c8593 3348 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 3349 status = VL53L0X_write_byte(dev, 0xFF, 0x01);
Davidroid 16:27d3d95c8593 3350 }
Davidroid 16:27d3d95c8593 3351
Davidroid 16:27d3d95c8593 3352 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 3353 status = VL53L0X_read_word(dev,
johnAlexander 14:8320b5ff96fa 3354 VL53L0X_REG_RESULT_PEAK_SIGNAL_RATE_REF,
johnAlexander 14:8320b5ff96fa 3355 &tmp_word);
Davidroid 16:27d3d95c8593 3356 }
Davidroid 16:27d3d95c8593 3357
Davidroid 16:27d3d95c8593 3358 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 3359 status = VL53L0X_write_byte(dev, 0xFF, 0x00);
Davidroid 16:27d3d95c8593 3360 }
johnAlexander 14:8320b5ff96fa 3361
johnAlexander 14:8320b5ff96fa 3362 last_signal_ref_mcps = VL53L0X_FIXPOINT97TOFIXPOINT1616(tmp_word);
johnAlexander 14:8320b5ff96fa 3363 PALDevDataSet(dev, LastSignalRefMcps, last_signal_ref_mcps);
johnAlexander 14:8320b5ff96fa 3364
johnAlexander 14:8320b5ff96fa 3365 if ((signal_ref_clip_value > 0) &&
johnAlexander 14:8320b5ff96fa 3366 (last_signal_ref_mcps > signal_ref_clip_value)) {
johnAlexander 14:8320b5ff96fa 3367 /* Limit Fail */
johnAlexander 14:8320b5ff96fa 3368 signal_ref_clipflag = 1;
johnAlexander 14:8320b5ff96fa 3369 }
johnAlexander 14:8320b5ff96fa 3370 }
johnAlexander 14:8320b5ff96fa 3371
johnAlexander 14:8320b5ff96fa 3372 /*
johnAlexander 14:8320b5ff96fa 3373 * Check if Signal ref clip limit is enabled, if yes then do comparison
johnAlexander 14:8320b5ff96fa 3374 * with limit value and put the result back into pPalRangeStatus.
johnAlexander 14:8320b5ff96fa 3375 * EffectiveSpadRtnCount has a format 8.8
johnAlexander 14:8320b5ff96fa 3376 * If (Return signal rate < (1.5 x Xtalk x number of Spads)) : FAIL
johnAlexander 14:8320b5ff96fa 3377 */
Davidroid 16:27d3d95c8593 3378 if (status == VL53L0X_ERROR_NONE){
Davidroid 16:27d3d95c8593 3379 status = VL53L0X_get_limit_check_enable(dev,
johnAlexander 14:8320b5ff96fa 3380 VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
johnAlexander 14:8320b5ff96fa 3381 &range_ignore_threshold_limit_check_enable);
Davidroid 16:27d3d95c8593 3382 }
johnAlexander 14:8320b5ff96fa 3383
johnAlexander 14:8320b5ff96fa 3384 if ((range_ignore_threshold_limit_check_enable != 0) &&
johnAlexander 14:8320b5ff96fa 3385 (status == VL53L0X_ERROR_NONE)) {
johnAlexander 14:8320b5ff96fa 3386
johnAlexander 14:8320b5ff96fa 3387 /* Compute the signal rate per spad */
johnAlexander 14:8320b5ff96fa 3388 if (effective_spad_rtn_count == 0) {
johnAlexander 14:8320b5ff96fa 3389 signal_rate_per_spad = 0;
johnAlexander 14:8320b5ff96fa 3390 } else {
johnAlexander 14:8320b5ff96fa 3391 signal_rate_per_spad = (FixPoint1616_t)((256 * signal_rate)
johnAlexander 14:8320b5ff96fa 3392 / effective_spad_rtn_count);
johnAlexander 14:8320b5ff96fa 3393 }
johnAlexander 14:8320b5ff96fa 3394
Davidroid 16:27d3d95c8593 3395 status = VL53L0X_get_limit_check_value(dev,
johnAlexander 14:8320b5ff96fa 3396 VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
johnAlexander 14:8320b5ff96fa 3397 &range_ignore_threshold_value);
johnAlexander 14:8320b5ff96fa 3398
johnAlexander 14:8320b5ff96fa 3399 if ((range_ignore_threshold_value > 0) &&
johnAlexander 14:8320b5ff96fa 3400 (signal_rate_per_spad < range_ignore_threshold_value)) {
johnAlexander 14:8320b5ff96fa 3401 /* Limit Fail add 2^6 to range status */
johnAlexander 14:8320b5ff96fa 3402 range_ignore_thresholdflag = 1;
johnAlexander 14:8320b5ff96fa 3403 }
johnAlexander 14:8320b5ff96fa 3404 }
johnAlexander 14:8320b5ff96fa 3405
johnAlexander 14:8320b5ff96fa 3406 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 3407 if (none_flag == 1) {
johnAlexander 14:8320b5ff96fa 3408 *p_pal_range_status = 255; /* NONE */
johnAlexander 14:8320b5ff96fa 3409 } else if (device_range_status_internal == 1 ||
johnAlexander 14:8320b5ff96fa 3410 device_range_status_internal == 2 ||
johnAlexander 14:8320b5ff96fa 3411 device_range_status_internal == 3) {
johnAlexander 14:8320b5ff96fa 3412 *p_pal_range_status = 5; /* HW fail */
johnAlexander 14:8320b5ff96fa 3413 } else if (device_range_status_internal == 6 ||
johnAlexander 14:8320b5ff96fa 3414 device_range_status_internal == 9) {
johnAlexander 14:8320b5ff96fa 3415 *p_pal_range_status = 4; /* Phase fail */
johnAlexander 14:8320b5ff96fa 3416 } else if (device_range_status_internal == 8 ||
johnAlexander 14:8320b5ff96fa 3417 device_range_status_internal == 10 ||
johnAlexander 14:8320b5ff96fa 3418 signal_ref_clipflag == 1) {
johnAlexander 14:8320b5ff96fa 3419 *p_pal_range_status = 3; /* Min range */
johnAlexander 14:8320b5ff96fa 3420 } else if (device_range_status_internal == 4 ||
johnAlexander 14:8320b5ff96fa 3421 range_ignore_thresholdflag == 1) {
johnAlexander 14:8320b5ff96fa 3422 *p_pal_range_status = 2; /* Signal Fail */
johnAlexander 14:8320b5ff96fa 3423 } else if (sigma_limitflag == 1) {
johnAlexander 14:8320b5ff96fa 3424 *p_pal_range_status = 1; /* Sigma Fail */
johnAlexander 14:8320b5ff96fa 3425 } else {
johnAlexander 14:8320b5ff96fa 3426 *p_pal_range_status = 0; /* Range Valid */
johnAlexander 14:8320b5ff96fa 3427 }
johnAlexander 14:8320b5ff96fa 3428 }
johnAlexander 14:8320b5ff96fa 3429
johnAlexander 14:8320b5ff96fa 3430 /* DMAX only relevant during range error */
johnAlexander 14:8320b5ff96fa 3431 if (*p_pal_range_status == 0)
johnAlexander 14:8320b5ff96fa 3432 p_ranging_measurement_data->RangeDMaxMilliMeter = 0;
johnAlexander 14:8320b5ff96fa 3433
johnAlexander 14:8320b5ff96fa 3434 /* fill the Limit Check Status */
johnAlexander 14:8320b5ff96fa 3435
Davidroid 16:27d3d95c8593 3436 status = VL53L0X_get_limit_check_enable(dev,
johnAlexander 14:8320b5ff96fa 3437 VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
johnAlexander 14:8320b5ff96fa 3438 &signal_rate_final_range_limit_check_enable);
johnAlexander 14:8320b5ff96fa 3439
johnAlexander 14:8320b5ff96fa 3440 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 3441 if ((sigma_limit_check_enable == 0) || (sigma_limitflag == 1)) {
johnAlexander 14:8320b5ff96fa 3442 temp8 = 1;
Davidroid 16:27d3d95c8593 3443 } else {
johnAlexander 14:8320b5ff96fa 3444 temp8 = 0;
Davidroid 16:27d3d95c8593 3445 }
johnAlexander 14:8320b5ff96fa 3446 VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksStatus,
johnAlexander 14:8320b5ff96fa 3447 VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, temp8);
johnAlexander 14:8320b5ff96fa 3448
johnAlexander 14:8320b5ff96fa 3449 if ((device_range_status_internal == 4) ||
Davidroid 16:27d3d95c8593 3450 (signal_rate_final_range_limit_check_enable == 0)) {
johnAlexander 14:8320b5ff96fa 3451 temp8 = 1;
Davidroid 16:27d3d95c8593 3452 } else {
johnAlexander 14:8320b5ff96fa 3453 temp8 = 0;
Davidroid 16:27d3d95c8593 3454 }
johnAlexander 14:8320b5ff96fa 3455 VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksStatus,
johnAlexander 14:8320b5ff96fa 3456 VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
johnAlexander 14:8320b5ff96fa 3457 temp8);
johnAlexander 14:8320b5ff96fa 3458
johnAlexander 14:8320b5ff96fa 3459 if ((signal_ref_clip_limit_check_enable == 0) ||
Davidroid 16:27d3d95c8593 3460 (signal_ref_clipflag == 1)) {
johnAlexander 14:8320b5ff96fa 3461 temp8 = 1;
Davidroid 16:27d3d95c8593 3462 } else {
johnAlexander 14:8320b5ff96fa 3463 temp8 = 0;
Davidroid 16:27d3d95c8593 3464 }
johnAlexander 14:8320b5ff96fa 3465
johnAlexander 14:8320b5ff96fa 3466 VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksStatus,
johnAlexander 14:8320b5ff96fa 3467 VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP, temp8);
johnAlexander 14:8320b5ff96fa 3468
johnAlexander 14:8320b5ff96fa 3469 if ((range_ignore_threshold_limit_check_enable == 0) ||
Davidroid 16:27d3d95c8593 3470 (range_ignore_thresholdflag == 1)) {
johnAlexander 14:8320b5ff96fa 3471 temp8 = 1;
Davidroid 16:27d3d95c8593 3472 } else {
johnAlexander 14:8320b5ff96fa 3473 temp8 = 0;
Davidroid 16:27d3d95c8593 3474 }
johnAlexander 14:8320b5ff96fa 3475
johnAlexander 14:8320b5ff96fa 3476 VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksStatus,
johnAlexander 14:8320b5ff96fa 3477 VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
johnAlexander 14:8320b5ff96fa 3478 temp8);
johnAlexander 14:8320b5ff96fa 3479 }
johnAlexander 14:8320b5ff96fa 3480
johnAlexander 14:8320b5ff96fa 3481 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 3482 return status;
johnAlexander 0:c523920bcc09 3483
johnAlexander 0:c523920bcc09 3484 }
johnAlexander 0:c523920bcc09 3485
Davidroid 16:27d3d95c8593 3486 VL53L0X_Error VL53L0X::VL53L0X_get_ranging_measurement_data(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 3487 VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data)
johnAlexander 0:c523920bcc09 3488 {
johnAlexander 14:8320b5ff96fa 3489 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 3490 uint8_t device_range_status;
johnAlexander 14:8320b5ff96fa 3491 uint8_t range_fractional_enable;
johnAlexander 14:8320b5ff96fa 3492 uint8_t pal_range_status;
johnAlexander 14:8320b5ff96fa 3493 uint8_t x_talk_compensation_enable;
johnAlexander 14:8320b5ff96fa 3494 uint16_t ambient_rate;
johnAlexander 14:8320b5ff96fa 3495 FixPoint1616_t signal_rate;
johnAlexander 14:8320b5ff96fa 3496 uint16_t x_talk_compensation_rate_mega_cps;
johnAlexander 14:8320b5ff96fa 3497 uint16_t effective_spad_rtn_count;
johnAlexander 14:8320b5ff96fa 3498 uint16_t tmpuint16;
johnAlexander 14:8320b5ff96fa 3499 uint16_t xtalk_range_milli_meter;
johnAlexander 14:8320b5ff96fa 3500 uint16_t linearity_corrective_gain;
johnAlexander 14:8320b5ff96fa 3501 uint8_t localBuffer[12];
johnAlexander 14:8320b5ff96fa 3502 VL53L0X_RangingMeasurementData_t last_range_data_buffer;
johnAlexander 14:8320b5ff96fa 3503
johnAlexander 14:8320b5ff96fa 3504 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 3505
johnAlexander 14:8320b5ff96fa 3506 /*
johnAlexander 14:8320b5ff96fa 3507 * use multi read even if some registers are not useful, result will
johnAlexander 14:8320b5ff96fa 3508 * be more efficient
johnAlexander 14:8320b5ff96fa 3509 * start reading at 0x14 dec20
johnAlexander 14:8320b5ff96fa 3510 * end reading at 0x21 dec33 total 14 bytes to read
johnAlexander 14:8320b5ff96fa 3511 */
Davidroid 16:27d3d95c8593 3512 status = VL53L0X_read_multi(dev, 0x14, localBuffer, 12);
johnAlexander 14:8320b5ff96fa 3513
johnAlexander 14:8320b5ff96fa 3514 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 3515
johnAlexander 14:8320b5ff96fa 3516 p_ranging_measurement_data->ZoneId = 0; /* Only one zone */
johnAlexander 14:8320b5ff96fa 3517 p_ranging_measurement_data->TimeStamp = 0; /* Not Implemented */
johnAlexander 14:8320b5ff96fa 3518
johnAlexander 14:8320b5ff96fa 3519 tmpuint16 = VL53L0X_MAKEUINT16(localBuffer[11], localBuffer[10]);
johnAlexander 14:8320b5ff96fa 3520 /* cut1.1 if SYSTEM__RANGE_CONFIG if 1 range is 2bits fractional
johnAlexander 14:8320b5ff96fa 3521 *(format 11.2) else no fractional
johnAlexander 14:8320b5ff96fa 3522 */
johnAlexander 14:8320b5ff96fa 3523
johnAlexander 14:8320b5ff96fa 3524 p_ranging_measurement_data->MeasurementTimeUsec = 0;
johnAlexander 14:8320b5ff96fa 3525
johnAlexander 14:8320b5ff96fa 3526 signal_rate = VL53L0X_FIXPOINT97TOFIXPOINT1616(
johnAlexander 14:8320b5ff96fa 3527 VL53L0X_MAKEUINT16(localBuffer[7], localBuffer[6]));
johnAlexander 14:8320b5ff96fa 3528 /* peak_signal_count_rate_rtn_mcps */
johnAlexander 14:8320b5ff96fa 3529 p_ranging_measurement_data->SignalRateRtnMegaCps = signal_rate;
johnAlexander 14:8320b5ff96fa 3530
johnAlexander 14:8320b5ff96fa 3531 ambient_rate = VL53L0X_MAKEUINT16(localBuffer[9], localBuffer[8]);
johnAlexander 14:8320b5ff96fa 3532 p_ranging_measurement_data->AmbientRateRtnMegaCps =
johnAlexander 14:8320b5ff96fa 3533 VL53L0X_FIXPOINT97TOFIXPOINT1616(ambient_rate);
johnAlexander 14:8320b5ff96fa 3534
johnAlexander 14:8320b5ff96fa 3535 effective_spad_rtn_count = VL53L0X_MAKEUINT16(localBuffer[3],
johnAlexander 14:8320b5ff96fa 3536 localBuffer[2]);
johnAlexander 14:8320b5ff96fa 3537 /* EffectiveSpadRtnCount is 8.8 format */
johnAlexander 14:8320b5ff96fa 3538 p_ranging_measurement_data->EffectiveSpadRtnCount =
johnAlexander 14:8320b5ff96fa 3539 effective_spad_rtn_count;
johnAlexander 14:8320b5ff96fa 3540
johnAlexander 14:8320b5ff96fa 3541 device_range_status = localBuffer[0];
johnAlexander 14:8320b5ff96fa 3542
johnAlexander 14:8320b5ff96fa 3543 /* Get Linearity Corrective Gain */
johnAlexander 14:8320b5ff96fa 3544 linearity_corrective_gain = PALDevDataGet(dev,
johnAlexander 14:8320b5ff96fa 3545 LinearityCorrectiveGain);
johnAlexander 14:8320b5ff96fa 3546
johnAlexander 14:8320b5ff96fa 3547 /* Get ranging configuration */
johnAlexander 14:8320b5ff96fa 3548 range_fractional_enable = PALDevDataGet(dev,
johnAlexander 14:8320b5ff96fa 3549 RangeFractionalEnable);
johnAlexander 14:8320b5ff96fa 3550
johnAlexander 14:8320b5ff96fa 3551 if (linearity_corrective_gain != 1000) {
johnAlexander 14:8320b5ff96fa 3552
johnAlexander 14:8320b5ff96fa 3553 tmpuint16 = (uint16_t)((linearity_corrective_gain
johnAlexander 14:8320b5ff96fa 3554 * tmpuint16 + 500) / 1000);
johnAlexander 14:8320b5ff96fa 3555
johnAlexander 14:8320b5ff96fa 3556 /* Implement Xtalk */
johnAlexander 14:8320b5ff96fa 3557 VL53L0X_GETPARAMETERFIELD(dev,
johnAlexander 14:8320b5ff96fa 3558 XTalkCompensationRateMegaCps,
johnAlexander 14:8320b5ff96fa 3559 x_talk_compensation_rate_mega_cps);
johnAlexander 14:8320b5ff96fa 3560 VL53L0X_GETPARAMETERFIELD(dev, XTalkCompensationEnable,
johnAlexander 14:8320b5ff96fa 3561 x_talk_compensation_enable);
johnAlexander 14:8320b5ff96fa 3562
johnAlexander 14:8320b5ff96fa 3563 if (x_talk_compensation_enable) {
johnAlexander 14:8320b5ff96fa 3564
johnAlexander 14:8320b5ff96fa 3565 if ((signal_rate
johnAlexander 14:8320b5ff96fa 3566 - ((x_talk_compensation_rate_mega_cps
johnAlexander 14:8320b5ff96fa 3567 * effective_spad_rtn_count) >> 8))
johnAlexander 14:8320b5ff96fa 3568 <= 0) {
Davidroid 16:27d3d95c8593 3569 if (range_fractional_enable) {
johnAlexander 14:8320b5ff96fa 3570 xtalk_range_milli_meter = 8888;
Davidroid 16:27d3d95c8593 3571 } else {
Davidroid 16:27d3d95c8593 3572 xtalk_range_milli_meter = 8888 << 2;
Davidroid 16:27d3d95c8593 3573 }
johnAlexander 14:8320b5ff96fa 3574 } else {
johnAlexander 14:8320b5ff96fa 3575 xtalk_range_milli_meter =
johnAlexander 14:8320b5ff96fa 3576 (tmpuint16 * signal_rate)
johnAlexander 14:8320b5ff96fa 3577 / (signal_rate
johnAlexander 14:8320b5ff96fa 3578 - ((x_talk_compensation_rate_mega_cps
johnAlexander 14:8320b5ff96fa 3579 * effective_spad_rtn_count)
johnAlexander 14:8320b5ff96fa 3580 >> 8));
johnAlexander 14:8320b5ff96fa 3581 }
johnAlexander 14:8320b5ff96fa 3582
johnAlexander 14:8320b5ff96fa 3583 tmpuint16 = xtalk_range_milli_meter;
johnAlexander 14:8320b5ff96fa 3584 }
johnAlexander 14:8320b5ff96fa 3585
johnAlexander 14:8320b5ff96fa 3586 }
johnAlexander 14:8320b5ff96fa 3587
johnAlexander 14:8320b5ff96fa 3588 if (range_fractional_enable) {
johnAlexander 14:8320b5ff96fa 3589 p_ranging_measurement_data->RangeMilliMeter =
johnAlexander 14:8320b5ff96fa 3590 (uint16_t)((tmpuint16) >> 2);
johnAlexander 14:8320b5ff96fa 3591 p_ranging_measurement_data->RangeFractionalPart =
johnAlexander 14:8320b5ff96fa 3592 (uint8_t)((tmpuint16 & 0x03) << 6);
johnAlexander 14:8320b5ff96fa 3593 } else {
johnAlexander 14:8320b5ff96fa 3594 p_ranging_measurement_data->RangeMilliMeter = tmpuint16;
johnAlexander 14:8320b5ff96fa 3595 p_ranging_measurement_data->RangeFractionalPart = 0;
johnAlexander 14:8320b5ff96fa 3596 }
johnAlexander 14:8320b5ff96fa 3597
johnAlexander 14:8320b5ff96fa 3598 /*
johnAlexander 14:8320b5ff96fa 3599 * For a standard definition of RangeStatus, this should
johnAlexander 14:8320b5ff96fa 3600 * return 0 in case of good result after a ranging
johnAlexander 14:8320b5ff96fa 3601 * The range status depends on the device so call a device
johnAlexander 14:8320b5ff96fa 3602 * specific function to obtain the right Status.
johnAlexander 14:8320b5ff96fa 3603 */
Davidroid 16:27d3d95c8593 3604 status |= VL53L0X_get_pal_range_status(dev, device_range_status,
johnAlexander 14:8320b5ff96fa 3605 signal_rate, effective_spad_rtn_count,
johnAlexander 14:8320b5ff96fa 3606 p_ranging_measurement_data, &pal_range_status);
johnAlexander 14:8320b5ff96fa 3607
Davidroid 16:27d3d95c8593 3608 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 3609 p_ranging_measurement_data->RangeStatus = pal_range_status;
Davidroid 16:27d3d95c8593 3610 }
johnAlexander 14:8320b5ff96fa 3611
johnAlexander 14:8320b5ff96fa 3612 }
johnAlexander 14:8320b5ff96fa 3613
johnAlexander 14:8320b5ff96fa 3614 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 3615 /* Copy last read data into Dev buffer */
johnAlexander 14:8320b5ff96fa 3616 last_range_data_buffer = PALDevDataGet(dev, LastRangeMeasure);
johnAlexander 14:8320b5ff96fa 3617
johnAlexander 14:8320b5ff96fa 3618 last_range_data_buffer.RangeMilliMeter =
johnAlexander 14:8320b5ff96fa 3619 p_ranging_measurement_data->RangeMilliMeter;
johnAlexander 14:8320b5ff96fa 3620 last_range_data_buffer.RangeFractionalPart =
johnAlexander 14:8320b5ff96fa 3621 p_ranging_measurement_data->RangeFractionalPart;
johnAlexander 14:8320b5ff96fa 3622 last_range_data_buffer.RangeDMaxMilliMeter =
johnAlexander 14:8320b5ff96fa 3623 p_ranging_measurement_data->RangeDMaxMilliMeter;
johnAlexander 14:8320b5ff96fa 3624 last_range_data_buffer.MeasurementTimeUsec =
johnAlexander 14:8320b5ff96fa 3625 p_ranging_measurement_data->MeasurementTimeUsec;
johnAlexander 14:8320b5ff96fa 3626 last_range_data_buffer.SignalRateRtnMegaCps =
johnAlexander 14:8320b5ff96fa 3627 p_ranging_measurement_data->SignalRateRtnMegaCps;
johnAlexander 14:8320b5ff96fa 3628 last_range_data_buffer.AmbientRateRtnMegaCps =
johnAlexander 14:8320b5ff96fa 3629 p_ranging_measurement_data->AmbientRateRtnMegaCps;
johnAlexander 14:8320b5ff96fa 3630 last_range_data_buffer.EffectiveSpadRtnCount =
johnAlexander 14:8320b5ff96fa 3631 p_ranging_measurement_data->EffectiveSpadRtnCount;
johnAlexander 14:8320b5ff96fa 3632 last_range_data_buffer.RangeStatus =
johnAlexander 14:8320b5ff96fa 3633 p_ranging_measurement_data->RangeStatus;
johnAlexander 14:8320b5ff96fa 3634
johnAlexander 14:8320b5ff96fa 3635 PALDevDataSet(dev, LastRangeMeasure, last_range_data_buffer);
johnAlexander 14:8320b5ff96fa 3636 }
johnAlexander 14:8320b5ff96fa 3637
johnAlexander 14:8320b5ff96fa 3638 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 3639 return status;
johnAlexander 0:c523920bcc09 3640 }
johnAlexander 0:c523920bcc09 3641
Davidroid 16:27d3d95c8593 3642 VL53L0X_Error VL53L0X::VL53L0X_perform_single_ranging_measurement(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 3643 VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data)
johnAlexander 0:c523920bcc09 3644 {
johnAlexander 14:8320b5ff96fa 3645 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 3646
johnAlexander 14:8320b5ff96fa 3647 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 3648
johnAlexander 14:8320b5ff96fa 3649 /* This function will do a complete single ranging
johnAlexander 14:8320b5ff96fa 3650 * Here we fix the mode! */
Davidroid 16:27d3d95c8593 3651 status = VL53L0X_set_device_mode(dev, VL53L0X_DEVICEMODE_SINGLE_RANGING);
Davidroid 16:27d3d95c8593 3652
Davidroid 16:27d3d95c8593 3653 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 3654 status = VL53L0X_perform_single_measurement(dev);
Davidroid 16:27d3d95c8593 3655 }
Davidroid 16:27d3d95c8593 3656
Davidroid 16:27d3d95c8593 3657 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 3658 status = VL53L0X_get_ranging_measurement_data(dev,
johnAlexander 14:8320b5ff96fa 3659 p_ranging_measurement_data);
Davidroid 16:27d3d95c8593 3660 }
Davidroid 16:27d3d95c8593 3661
Davidroid 16:27d3d95c8593 3662 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 3663 status = VL53L0X_clear_interrupt_mask(dev, 0);
Davidroid 16:27d3d95c8593 3664 }
johnAlexander 14:8320b5ff96fa 3665
johnAlexander 14:8320b5ff96fa 3666 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 3667 return status;
johnAlexander 0:c523920bcc09 3668 }
johnAlexander 0:c523920bcc09 3669
johnAlexander 14:8320b5ff96fa 3670 VL53L0X_Error VL53L0X::perform_ref_signal_measurement(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 3671 uint16_t *p_ref_signal_rate)
johnAlexander 0:c523920bcc09 3672 {
johnAlexander 14:8320b5ff96fa 3673 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 3674 VL53L0X_RangingMeasurementData_t ranging_measurement_data;
johnAlexander 14:8320b5ff96fa 3675
johnAlexander 14:8320b5ff96fa 3676 uint8_t sequence_config = 0;
johnAlexander 14:8320b5ff96fa 3677
johnAlexander 14:8320b5ff96fa 3678 /* store the value of the sequence config,
johnAlexander 14:8320b5ff96fa 3679 * this will be reset before the end of the function
johnAlexander 14:8320b5ff96fa 3680 */
johnAlexander 14:8320b5ff96fa 3681
johnAlexander 14:8320b5ff96fa 3682 sequence_config = PALDevDataGet(dev, SequenceConfig);
johnAlexander 14:8320b5ff96fa 3683
johnAlexander 14:8320b5ff96fa 3684 /*
johnAlexander 14:8320b5ff96fa 3685 * This function performs a reference signal rate measurement.
johnAlexander 14:8320b5ff96fa 3686 */
Davidroid 16:27d3d95c8593 3687 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 3688 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 3689 VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, 0xC0);
Davidroid 16:27d3d95c8593 3690 }
Davidroid 16:27d3d95c8593 3691
Davidroid 16:27d3d95c8593 3692 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 3693 status = VL53L0X_perform_single_ranging_measurement(dev,
johnAlexander 14:8320b5ff96fa 3694 &ranging_measurement_data);
Davidroid 16:27d3d95c8593 3695 }
Davidroid 16:27d3d95c8593 3696
Davidroid 16:27d3d95c8593 3697 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 3698 status = VL53L0X_write_byte(dev, 0xFF, 0x01);
Davidroid 16:27d3d95c8593 3699 }
Davidroid 16:27d3d95c8593 3700
Davidroid 16:27d3d95c8593 3701 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 3702 status = VL53L0X_read_word(dev,
johnAlexander 14:8320b5ff96fa 3703 VL53L0X_REG_RESULT_PEAK_SIGNAL_RATE_REF,
johnAlexander 14:8320b5ff96fa 3704 p_ref_signal_rate);
Davidroid 16:27d3d95c8593 3705 }
Davidroid 16:27d3d95c8593 3706
Davidroid 16:27d3d95c8593 3707 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 3708 status = VL53L0X_write_byte(dev, 0xFF, 0x00);
Davidroid 16:27d3d95c8593 3709 }
johnAlexander 14:8320b5ff96fa 3710
johnAlexander 14:8320b5ff96fa 3711 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 3712 /* restore the previous Sequence Config */
Davidroid 16:27d3d95c8593 3713 status = VL53L0X_write_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
johnAlexander 14:8320b5ff96fa 3714 sequence_config);
Davidroid 16:27d3d95c8593 3715 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 3716 PALDevDataSet(dev, SequenceConfig, sequence_config);
Davidroid 16:27d3d95c8593 3717 }
johnAlexander 14:8320b5ff96fa 3718 }
johnAlexander 14:8320b5ff96fa 3719
johnAlexander 14:8320b5ff96fa 3720 return status;
johnAlexander 0:c523920bcc09 3721 }
johnAlexander 0:c523920bcc09 3722
Davidroid 16:27d3d95c8593 3723 VL53L0X_Error VL53L0X::wrapped_VL53L0X_perform_ref_spad_management(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 3724 uint32_t *ref_spad_count,
johnAlexander 14:8320b5ff96fa 3725 uint8_t *is_aperture_spads)
johnAlexander 0:c523920bcc09 3726 {
johnAlexander 14:8320b5ff96fa 3727 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 3728 uint8_t last_spad_array[6];
johnAlexander 14:8320b5ff96fa 3729 uint8_t start_select = 0xB4;
johnAlexander 14:8320b5ff96fa 3730 uint32_t minimum_spad_count = 3;
johnAlexander 14:8320b5ff96fa 3731 uint32_t max_spad_count = 44;
johnAlexander 14:8320b5ff96fa 3732 uint32_t current_spad_index = 0;
johnAlexander 14:8320b5ff96fa 3733 uint32_t last_spad_index = 0;
johnAlexander 14:8320b5ff96fa 3734 int32_t next_good_spad = 0;
johnAlexander 14:8320b5ff96fa 3735 uint16_t target_ref_rate = 0x0A00; /* 20 MCPS in 9:7 format */
johnAlexander 14:8320b5ff96fa 3736 uint16_t peak_signal_rate_ref;
johnAlexander 14:8320b5ff96fa 3737 uint32_t need_apt_spads = 0;
johnAlexander 14:8320b5ff96fa 3738 uint32_t index = 0;
johnAlexander 14:8320b5ff96fa 3739 uint32_t spad_array_size = 6;
johnAlexander 14:8320b5ff96fa 3740 uint32_t signal_rate_diff = 0;
johnAlexander 14:8320b5ff96fa 3741 uint32_t last_signal_rate_diff = 0;
johnAlexander 14:8320b5ff96fa 3742 uint8_t complete = 0;
johnAlexander 14:8320b5ff96fa 3743 uint8_t vhv_settings = 0;
johnAlexander 14:8320b5ff96fa 3744 uint8_t phase_cal = 0;
johnAlexander 14:8320b5ff96fa 3745 uint32_t ref_spad_count_int = 0;
johnAlexander 14:8320b5ff96fa 3746 uint8_t is_aperture_spads_int = 0;
johnAlexander 14:8320b5ff96fa 3747
johnAlexander 14:8320b5ff96fa 3748 /*
johnAlexander 14:8320b5ff96fa 3749 * The reference SPAD initialization procedure determines the minimum
johnAlexander 14:8320b5ff96fa 3750 * amount of reference spads to be enables to achieve a target reference
johnAlexander 14:8320b5ff96fa 3751 * signal rate and should be performed once during initialization.
johnAlexander 14:8320b5ff96fa 3752 *
johnAlexander 14:8320b5ff96fa 3753 * Either aperture or non-aperture spads are applied but never both.
johnAlexander 14:8320b5ff96fa 3754 * Firstly non-aperture spads are set, begining with 5 spads, and
johnAlexander 14:8320b5ff96fa 3755 * increased one spad at a time until the closest measurement to the
johnAlexander 14:8320b5ff96fa 3756 * target rate is achieved.
johnAlexander 14:8320b5ff96fa 3757 *
johnAlexander 14:8320b5ff96fa 3758 * If the target rate is exceeded when 5 non-aperture spads are enabled,
johnAlexander 14:8320b5ff96fa 3759 * initialization is performed instead with aperture spads.
johnAlexander 14:8320b5ff96fa 3760 *
johnAlexander 14:8320b5ff96fa 3761 * When setting spads, a 'Good Spad Map' is applied.
johnAlexander 14:8320b5ff96fa 3762 *
johnAlexander 14:8320b5ff96fa 3763 * This procedure operates within a SPAD window of interest of a maximum
johnAlexander 14:8320b5ff96fa 3764 * 44 spads.
johnAlexander 14:8320b5ff96fa 3765 * The start point is currently fixed to 180, which lies towards the end
johnAlexander 14:8320b5ff96fa 3766 * of the non-aperture quadrant and runs in to the adjacent aperture
johnAlexander 14:8320b5ff96fa 3767 * quadrant.
johnAlexander 14:8320b5ff96fa 3768 */
johnAlexander 14:8320b5ff96fa 3769 target_ref_rate = PALDevDataGet(dev, targetRefRate);
johnAlexander 14:8320b5ff96fa 3770
johnAlexander 14:8320b5ff96fa 3771 /*
johnAlexander 14:8320b5ff96fa 3772 * Initialize Spad arrays.
johnAlexander 14:8320b5ff96fa 3773 * Currently the good spad map is initialised to 'All good'.
johnAlexander 14:8320b5ff96fa 3774 * This is a short term implementation. The good spad map will be
johnAlexander 14:8320b5ff96fa 3775 * provided as an input.
johnAlexander 14:8320b5ff96fa 3776 * Note that there are 6 bytes. Only the first 44 bits will be used to
johnAlexander 14:8320b5ff96fa 3777 * represent spads.
johnAlexander 14:8320b5ff96fa 3778 */
johnAlexander 14:8320b5ff96fa 3779 for (index = 0; index < spad_array_size; index++)
johnAlexander 14:8320b5ff96fa 3780 dev->Data.SpadData.RefSpadEnables[index] = 0;
johnAlexander 14:8320b5ff96fa 3781
johnAlexander 14:8320b5ff96fa 3782
Davidroid 16:27d3d95c8593 3783 status = VL53L0X_write_byte(dev, 0xFF, 0x01);
Davidroid 16:27d3d95c8593 3784
Davidroid 16:27d3d95c8593 3785 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 3786 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 3787 VL53L0X_REG_DYNAMIC_SPAD_REF_EN_START_OFFSET, 0x00);
Davidroid 16:27d3d95c8593 3788 }
Davidroid 16:27d3d95c8593 3789
Davidroid 16:27d3d95c8593 3790 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 3791 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 3792 VL53L0X_REG_DYNAMIC_SPAD_NUM_REQUESTED_REF_SPAD, 0x2C);
Davidroid 16:27d3d95c8593 3793 }
Davidroid 16:27d3d95c8593 3794
Davidroid 16:27d3d95c8593 3795 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 3796 status = VL53L0X_write_byte(dev, 0xFF, 0x00);
Davidroid 16:27d3d95c8593 3797 }
Davidroid 16:27d3d95c8593 3798
Davidroid 16:27d3d95c8593 3799 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 3800 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 3801 VL53L0X_REG_GLOBAL_CONFIG_REF_EN_START_SELECT,
johnAlexander 14:8320b5ff96fa 3802 start_select);
Davidroid 16:27d3d95c8593 3803 }
Davidroid 16:27d3d95c8593 3804
Davidroid 16:27d3d95c8593 3805 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 3806 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 3807 VL53L0X_REG_POWER_MANAGEMENT_GO1_POWER_FORCE, 0);
Davidroid 16:27d3d95c8593 3808 }
johnAlexander 14:8320b5ff96fa 3809
johnAlexander 14:8320b5ff96fa 3810 /* Perform ref calibration */
Davidroid 16:27d3d95c8593 3811 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 3812 status = VL53L0X_perform_ref_calibration(dev, &vhv_settings,
johnAlexander 14:8320b5ff96fa 3813 &phase_cal, 0);
Davidroid 16:27d3d95c8593 3814 }
johnAlexander 14:8320b5ff96fa 3815
johnAlexander 14:8320b5ff96fa 3816 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 3817 /* Enable Minimum NON-APERTURE Spads */
johnAlexander 14:8320b5ff96fa 3818 current_spad_index = 0;
johnAlexander 14:8320b5ff96fa 3819 last_spad_index = current_spad_index;
johnAlexander 14:8320b5ff96fa 3820 need_apt_spads = 0;
johnAlexander 14:8320b5ff96fa 3821 status = enable_ref_spads(dev,
johnAlexander 14:8320b5ff96fa 3822 need_apt_spads,
johnAlexander 14:8320b5ff96fa 3823 dev->Data.SpadData.RefGoodSpadMap,
johnAlexander 14:8320b5ff96fa 3824 dev->Data.SpadData.RefSpadEnables,
johnAlexander 14:8320b5ff96fa 3825 spad_array_size,
johnAlexander 14:8320b5ff96fa 3826 start_select,
johnAlexander 14:8320b5ff96fa 3827 current_spad_index,
johnAlexander 14:8320b5ff96fa 3828 minimum_spad_count,
johnAlexander 14:8320b5ff96fa 3829 &last_spad_index);
johnAlexander 14:8320b5ff96fa 3830 }
johnAlexander 14:8320b5ff96fa 3831
johnAlexander 14:8320b5ff96fa 3832 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 3833 current_spad_index = last_spad_index;
johnAlexander 14:8320b5ff96fa 3834
johnAlexander 14:8320b5ff96fa 3835 status = perform_ref_signal_measurement(dev,
johnAlexander 14:8320b5ff96fa 3836 &peak_signal_rate_ref);
johnAlexander 14:8320b5ff96fa 3837 if ((status == VL53L0X_ERROR_NONE) &&
johnAlexander 14:8320b5ff96fa 3838 (peak_signal_rate_ref > target_ref_rate)) {
johnAlexander 14:8320b5ff96fa 3839 /* Signal rate measurement too high,
johnAlexander 14:8320b5ff96fa 3840 * switch to APERTURE SPADs */
johnAlexander 14:8320b5ff96fa 3841
Davidroid 16:27d3d95c8593 3842 for (index = 0; index < spad_array_size; index++) {
johnAlexander 14:8320b5ff96fa 3843 dev->Data.SpadData.RefSpadEnables[index] = 0;
Davidroid 16:27d3d95c8593 3844 }
johnAlexander 14:8320b5ff96fa 3845
johnAlexander 14:8320b5ff96fa 3846
johnAlexander 14:8320b5ff96fa 3847 /* Increment to the first APERTURE spad */
johnAlexander 14:8320b5ff96fa 3848 while ((is_aperture(start_select + current_spad_index)
johnAlexander 14:8320b5ff96fa 3849 == 0) && (current_spad_index < max_spad_count)) {
johnAlexander 14:8320b5ff96fa 3850 current_spad_index++;
johnAlexander 14:8320b5ff96fa 3851 }
johnAlexander 14:8320b5ff96fa 3852
johnAlexander 14:8320b5ff96fa 3853 need_apt_spads = 1;
johnAlexander 14:8320b5ff96fa 3854
johnAlexander 14:8320b5ff96fa 3855 status = enable_ref_spads(dev,
johnAlexander 14:8320b5ff96fa 3856 need_apt_spads,
johnAlexander 14:8320b5ff96fa 3857 dev->Data.SpadData.RefGoodSpadMap,
johnAlexander 14:8320b5ff96fa 3858 dev->Data.SpadData.RefSpadEnables,
johnAlexander 14:8320b5ff96fa 3859 spad_array_size,
johnAlexander 14:8320b5ff96fa 3860 start_select,
johnAlexander 14:8320b5ff96fa 3861 current_spad_index,
johnAlexander 14:8320b5ff96fa 3862 minimum_spad_count,
johnAlexander 14:8320b5ff96fa 3863 &last_spad_index);
johnAlexander 14:8320b5ff96fa 3864
johnAlexander 14:8320b5ff96fa 3865 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 3866 current_spad_index = last_spad_index;
johnAlexander 14:8320b5ff96fa 3867 status = perform_ref_signal_measurement(dev,
johnAlexander 14:8320b5ff96fa 3868 &peak_signal_rate_ref);
johnAlexander 14:8320b5ff96fa 3869
johnAlexander 14:8320b5ff96fa 3870 if ((status == VL53L0X_ERROR_NONE) &&
johnAlexander 14:8320b5ff96fa 3871 (peak_signal_rate_ref > target_ref_rate)) {
johnAlexander 14:8320b5ff96fa 3872 /* Signal rate still too high after
johnAlexander 14:8320b5ff96fa 3873 * setting the minimum number of
johnAlexander 14:8320b5ff96fa 3874 * APERTURE spads. Can do no more
johnAlexander 14:8320b5ff96fa 3875 * therefore set the min number of
johnAlexander 14:8320b5ff96fa 3876 * aperture spads as the result.
johnAlexander 14:8320b5ff96fa 3877 */
johnAlexander 14:8320b5ff96fa 3878 is_aperture_spads_int = 1;
johnAlexander 14:8320b5ff96fa 3879 ref_spad_count_int = minimum_spad_count;
johnAlexander 14:8320b5ff96fa 3880 }
johnAlexander 14:8320b5ff96fa 3881 }
johnAlexander 14:8320b5ff96fa 3882 } else {
johnAlexander 14:8320b5ff96fa 3883 need_apt_spads = 0;
johnAlexander 14:8320b5ff96fa 3884 }
johnAlexander 14:8320b5ff96fa 3885 }
johnAlexander 14:8320b5ff96fa 3886
johnAlexander 14:8320b5ff96fa 3887 if ((status == VL53L0X_ERROR_NONE) &&
johnAlexander 14:8320b5ff96fa 3888 (peak_signal_rate_ref < target_ref_rate)) {
johnAlexander 14:8320b5ff96fa 3889 /* At this point, the minimum number of either aperture
johnAlexander 14:8320b5ff96fa 3890 * or non-aperture spads have been set. Proceed to add
johnAlexander 14:8320b5ff96fa 3891 * spads and perform measurements until the target
johnAlexander 14:8320b5ff96fa 3892 * reference is reached.
johnAlexander 14:8320b5ff96fa 3893 */
johnAlexander 14:8320b5ff96fa 3894 is_aperture_spads_int = need_apt_spads;
johnAlexander 14:8320b5ff96fa 3895 ref_spad_count_int = minimum_spad_count;
johnAlexander 14:8320b5ff96fa 3896
johnAlexander 14:8320b5ff96fa 3897 memcpy(last_spad_array, dev->Data.SpadData.RefSpadEnables,
johnAlexander 14:8320b5ff96fa 3898 spad_array_size);
johnAlexander 14:8320b5ff96fa 3899 last_signal_rate_diff = abs(peak_signal_rate_ref -
johnAlexander 14:8320b5ff96fa 3900 target_ref_rate);
johnAlexander 14:8320b5ff96fa 3901 complete = 0;
johnAlexander 14:8320b5ff96fa 3902
johnAlexander 14:8320b5ff96fa 3903 while (!complete) {
johnAlexander 14:8320b5ff96fa 3904 get_next_good_spad(
johnAlexander 14:8320b5ff96fa 3905 dev->Data.SpadData.RefGoodSpadMap,
johnAlexander 14:8320b5ff96fa 3906 spad_array_size, current_spad_index,
johnAlexander 14:8320b5ff96fa 3907 &next_good_spad);
johnAlexander 14:8320b5ff96fa 3908
johnAlexander 14:8320b5ff96fa 3909 if (next_good_spad == -1) {
johnAlexander 14:8320b5ff96fa 3910 status = VL53L0X_ERROR_REF_SPAD_INIT;
johnAlexander 14:8320b5ff96fa 3911 break;
johnAlexander 14:8320b5ff96fa 3912 }
johnAlexander 14:8320b5ff96fa 3913
johnAlexander 14:8320b5ff96fa 3914 /* Cannot combine Aperture and Non-Aperture spads, so
johnAlexander 14:8320b5ff96fa 3915 * ensure the current spad is of the correct type.
johnAlexander 14:8320b5ff96fa 3916 */
johnAlexander 14:8320b5ff96fa 3917 if (is_aperture((uint32_t)start_select + next_good_spad) !=
johnAlexander 14:8320b5ff96fa 3918 need_apt_spads) {
johnAlexander 14:8320b5ff96fa 3919 /* At this point we have enabled the maximum
johnAlexander 14:8320b5ff96fa 3920 * number of Aperture spads.
johnAlexander 14:8320b5ff96fa 3921 */
johnAlexander 14:8320b5ff96fa 3922 complete = 1;
johnAlexander 14:8320b5ff96fa 3923 break;
johnAlexander 14:8320b5ff96fa 3924 }
johnAlexander 14:8320b5ff96fa 3925
johnAlexander 14:8320b5ff96fa 3926 (ref_spad_count_int)++;
johnAlexander 14:8320b5ff96fa 3927
johnAlexander 14:8320b5ff96fa 3928 current_spad_index = next_good_spad;
johnAlexander 14:8320b5ff96fa 3929 status = enable_spad_bit(
johnAlexander 14:8320b5ff96fa 3930 dev->Data.SpadData.RefSpadEnables,
johnAlexander 14:8320b5ff96fa 3931 spad_array_size, current_spad_index);
johnAlexander 14:8320b5ff96fa 3932
johnAlexander 14:8320b5ff96fa 3933 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 3934 current_spad_index++;
johnAlexander 14:8320b5ff96fa 3935 /* Proceed to apply the additional spad and
johnAlexander 14:8320b5ff96fa 3936 * perform measurement. */
johnAlexander 14:8320b5ff96fa 3937 status = set_ref_spad_map(dev,
johnAlexander 14:8320b5ff96fa 3938 dev->Data.SpadData.RefSpadEnables);
johnAlexander 14:8320b5ff96fa 3939 }
johnAlexander 14:8320b5ff96fa 3940
Davidroid 16:27d3d95c8593 3941 if (status != VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 3942 break;
Davidroid 16:27d3d95c8593 3943 }
johnAlexander 14:8320b5ff96fa 3944
johnAlexander 14:8320b5ff96fa 3945 status = perform_ref_signal_measurement(dev,
johnAlexander 14:8320b5ff96fa 3946 &peak_signal_rate_ref);
johnAlexander 14:8320b5ff96fa 3947
Davidroid 16:27d3d95c8593 3948 if (status != VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 3949 break;
Davidroid 16:27d3d95c8593 3950 }
johnAlexander 14:8320b5ff96fa 3951
johnAlexander 14:8320b5ff96fa 3952 signal_rate_diff = abs(peak_signal_rate_ref - target_ref_rate);
johnAlexander 14:8320b5ff96fa 3953
johnAlexander 14:8320b5ff96fa 3954 if (peak_signal_rate_ref > target_ref_rate) {
johnAlexander 14:8320b5ff96fa 3955 /* Select the spad map that provides the
johnAlexander 14:8320b5ff96fa 3956 * measurement closest to the target rate,
johnAlexander 14:8320b5ff96fa 3957 * either above or below it.
johnAlexander 14:8320b5ff96fa 3958 */
johnAlexander 14:8320b5ff96fa 3959 if (signal_rate_diff > last_signal_rate_diff) {
johnAlexander 14:8320b5ff96fa 3960 /* Previous spad map produced a closer
johnAlexander 14:8320b5ff96fa 3961 * measurement, so choose this. */
johnAlexander 14:8320b5ff96fa 3962 status = set_ref_spad_map(dev,
johnAlexander 14:8320b5ff96fa 3963 last_spad_array);
johnAlexander 14:8320b5ff96fa 3964 memcpy(
johnAlexander 14:8320b5ff96fa 3965 dev->Data.SpadData.RefSpadEnables,
johnAlexander 14:8320b5ff96fa 3966 last_spad_array, spad_array_size);
johnAlexander 14:8320b5ff96fa 3967
johnAlexander 14:8320b5ff96fa 3968 (ref_spad_count_int)--;
johnAlexander 14:8320b5ff96fa 3969 }
johnAlexander 14:8320b5ff96fa 3970 complete = 1;
johnAlexander 14:8320b5ff96fa 3971 } else {
johnAlexander 14:8320b5ff96fa 3972 /* Continue to add spads */
johnAlexander 14:8320b5ff96fa 3973 last_signal_rate_diff = signal_rate_diff;
johnAlexander 14:8320b5ff96fa 3974 memcpy(last_spad_array,
johnAlexander 14:8320b5ff96fa 3975 dev->Data.SpadData.RefSpadEnables,
johnAlexander 14:8320b5ff96fa 3976 spad_array_size);
johnAlexander 14:8320b5ff96fa 3977 }
johnAlexander 14:8320b5ff96fa 3978
johnAlexander 14:8320b5ff96fa 3979 } /* while */
johnAlexander 14:8320b5ff96fa 3980 }
johnAlexander 14:8320b5ff96fa 3981
johnAlexander 14:8320b5ff96fa 3982 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 3983 *ref_spad_count = ref_spad_count_int;
johnAlexander 14:8320b5ff96fa 3984 *is_aperture_spads = is_aperture_spads_int;
johnAlexander 14:8320b5ff96fa 3985
johnAlexander 14:8320b5ff96fa 3986 VL53L0X_SETDEVICESPECIFICPARAMETER(dev, RefSpadsInitialised, 1);
johnAlexander 14:8320b5ff96fa 3987 VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
johnAlexander 14:8320b5ff96fa 3988 ReferenceSpadCount, (uint8_t)(*ref_spad_count));
johnAlexander 14:8320b5ff96fa 3989 VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
johnAlexander 14:8320b5ff96fa 3990 ReferenceSpadType, *is_aperture_spads);
johnAlexander 14:8320b5ff96fa 3991 }
johnAlexander 14:8320b5ff96fa 3992
johnAlexander 14:8320b5ff96fa 3993 return status;
johnAlexander 0:c523920bcc09 3994 }
johnAlexander 0:c523920bcc09 3995
Davidroid 16:27d3d95c8593 3996 VL53L0X_Error VL53L0X::VL53L0X_set_reference_spads(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 3997 uint32_t count, uint8_t is_aperture_spads)
johnAlexander 0:c523920bcc09 3998 {
johnAlexander 14:8320b5ff96fa 3999 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 4000 uint32_t current_spad_index = 0;
johnAlexander 14:8320b5ff96fa 4001 uint8_t start_select = 0xB4;
johnAlexander 14:8320b5ff96fa 4002 uint32_t spad_array_size = 6;
johnAlexander 14:8320b5ff96fa 4003 uint32_t max_spad_count = 44;
johnAlexander 14:8320b5ff96fa 4004 uint32_t last_spad_index;
johnAlexander 14:8320b5ff96fa 4005 uint32_t index;
johnAlexander 14:8320b5ff96fa 4006
johnAlexander 14:8320b5ff96fa 4007 /*
johnAlexander 14:8320b5ff96fa 4008 * This function applies a requested number of reference spads, either
johnAlexander 14:8320b5ff96fa 4009 * aperture or
johnAlexander 14:8320b5ff96fa 4010 * non-aperture, as requested.
johnAlexander 14:8320b5ff96fa 4011 * The good spad map will be applied.
johnAlexander 14:8320b5ff96fa 4012 */
johnAlexander 14:8320b5ff96fa 4013
Davidroid 16:27d3d95c8593 4014 status = VL53L0X_write_byte(dev, 0xFF, 0x01);
Davidroid 16:27d3d95c8593 4015
Davidroid 16:27d3d95c8593 4016 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4017 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 4018 VL53L0X_REG_DYNAMIC_SPAD_REF_EN_START_OFFSET, 0x00);
Davidroid 16:27d3d95c8593 4019 }
Davidroid 16:27d3d95c8593 4020
Davidroid 16:27d3d95c8593 4021 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4022 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 4023 VL53L0X_REG_DYNAMIC_SPAD_NUM_REQUESTED_REF_SPAD, 0x2C);
Davidroid 16:27d3d95c8593 4024 }
Davidroid 16:27d3d95c8593 4025
Davidroid 16:27d3d95c8593 4026 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4027 status = VL53L0X_write_byte(dev, 0xFF, 0x00);
Davidroid 16:27d3d95c8593 4028 }
Davidroid 16:27d3d95c8593 4029
Davidroid 16:27d3d95c8593 4030 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4031 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 4032 VL53L0X_REG_GLOBAL_CONFIG_REF_EN_START_SELECT,
johnAlexander 14:8320b5ff96fa 4033 start_select);
Davidroid 16:27d3d95c8593 4034 }
Davidroid 16:27d3d95c8593 4035
Davidroid 16:27d3d95c8593 4036 for (index = 0; index < spad_array_size; index++) {
johnAlexander 14:8320b5ff96fa 4037 dev->Data.SpadData.RefSpadEnables[index] = 0;
Davidroid 16:27d3d95c8593 4038 }
johnAlexander 14:8320b5ff96fa 4039
johnAlexander 14:8320b5ff96fa 4040 if (is_aperture_spads) {
johnAlexander 14:8320b5ff96fa 4041 /* Increment to the first APERTURE spad */
johnAlexander 14:8320b5ff96fa 4042 while ((is_aperture(start_select + current_spad_index) == 0) &&
johnAlexander 14:8320b5ff96fa 4043 (current_spad_index < max_spad_count)) {
johnAlexander 14:8320b5ff96fa 4044 current_spad_index++;
johnAlexander 14:8320b5ff96fa 4045 }
johnAlexander 14:8320b5ff96fa 4046 }
johnAlexander 14:8320b5ff96fa 4047 status = enable_ref_spads(dev,
johnAlexander 14:8320b5ff96fa 4048 is_aperture_spads,
johnAlexander 14:8320b5ff96fa 4049 dev->Data.SpadData.RefGoodSpadMap,
johnAlexander 14:8320b5ff96fa 4050 dev->Data.SpadData.RefSpadEnables,
johnAlexander 14:8320b5ff96fa 4051 spad_array_size,
johnAlexander 14:8320b5ff96fa 4052 start_select,
johnAlexander 14:8320b5ff96fa 4053 current_spad_index,
johnAlexander 14:8320b5ff96fa 4054 count,
johnAlexander 14:8320b5ff96fa 4055 &last_spad_index);
johnAlexander 14:8320b5ff96fa 4056
johnAlexander 14:8320b5ff96fa 4057 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 4058 VL53L0X_SETDEVICESPECIFICPARAMETER(dev, RefSpadsInitialised, 1);
johnAlexander 14:8320b5ff96fa 4059 VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
johnAlexander 14:8320b5ff96fa 4060 ReferenceSpadCount, (uint8_t)(count));
johnAlexander 14:8320b5ff96fa 4061 VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
johnAlexander 14:8320b5ff96fa 4062 ReferenceSpadType, is_aperture_spads);
johnAlexander 14:8320b5ff96fa 4063 }
johnAlexander 14:8320b5ff96fa 4064
johnAlexander 14:8320b5ff96fa 4065 return status;
johnAlexander 0:c523920bcc09 4066 }
johnAlexander 0:c523920bcc09 4067
Davidroid 16:27d3d95c8593 4068 VL53L0X_Error VL53L0X::VL53L0X_wait_device_booted(VL53L0X_DEV dev)
johnAlexander 0:c523920bcc09 4069 {
johnAlexander 14:8320b5ff96fa 4070 VL53L0X_Error status = VL53L0X_ERROR_NOT_IMPLEMENTED;
johnAlexander 14:8320b5ff96fa 4071 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 4072
johnAlexander 14:8320b5ff96fa 4073 /* not implemented on VL53L0X */
johnAlexander 14:8320b5ff96fa 4074
johnAlexander 14:8320b5ff96fa 4075 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 4076 return status;
johnAlexander 0:c523920bcc09 4077 }
johnAlexander 0:c523920bcc09 4078
Davidroid 16:27d3d95c8593 4079 VL53L0X_Error VL53L0X::VL53L0X_perform_ref_calibration(VL53L0X_DEV dev, uint8_t *p_vhv_settings,
johnAlexander 14:8320b5ff96fa 4080 uint8_t *p_phase_cal)
johnAlexander 0:c523920bcc09 4081 {
johnAlexander 14:8320b5ff96fa 4082 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 4083 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 4084
Davidroid 16:27d3d95c8593 4085 status = VL53L0X_perform_ref_calibration(dev, p_vhv_settings,
johnAlexander 14:8320b5ff96fa 4086 p_phase_cal, 1);
johnAlexander 14:8320b5ff96fa 4087
johnAlexander 14:8320b5ff96fa 4088 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 4089 return status;
johnAlexander 0:c523920bcc09 4090 }
johnAlexander 0:c523920bcc09 4091
Davidroid 16:27d3d95c8593 4092 VL53L0X_Error VL53L0X::VL53L0X_perform_ref_spad_management(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 4093 uint32_t *ref_spad_count, uint8_t *is_aperture_spads)
johnAlexander 0:c523920bcc09 4094 {
johnAlexander 14:8320b5ff96fa 4095 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 4096 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 4097
Davidroid 16:27d3d95c8593 4098 status = wrapped_VL53L0X_perform_ref_spad_management(dev, ref_spad_count,
johnAlexander 14:8320b5ff96fa 4099 is_aperture_spads);
johnAlexander 14:8320b5ff96fa 4100
johnAlexander 14:8320b5ff96fa 4101 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 4102
johnAlexander 14:8320b5ff96fa 4103 return status;
johnAlexander 0:c523920bcc09 4104 }
johnAlexander 0:c523920bcc09 4105
johnAlexander 0:c523920bcc09 4106 /* Group PAL Init Functions */
Davidroid 16:27d3d95c8593 4107 VL53L0X_Error VL53L0X::VL53L0X_set_device_address(VL53L0X_DEV dev, uint8_t device_address)
johnAlexander 0:c523920bcc09 4108 {
johnAlexander 14:8320b5ff96fa 4109 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 4110 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 4111
Davidroid 16:27d3d95c8593 4112 status = VL53L0X_write_byte(dev, VL53L0X_REG_I2C_SLAVE_DEVICE_ADDRESS,
johnAlexander 14:8320b5ff96fa 4113 device_address / 2);
johnAlexander 14:8320b5ff96fa 4114
johnAlexander 14:8320b5ff96fa 4115 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 4116 return status;
johnAlexander 0:c523920bcc09 4117 }
johnAlexander 0:c523920bcc09 4118
Davidroid 16:27d3d95c8593 4119 VL53L0X_Error VL53L0X::VL53L0X_set_gpio_config(VL53L0X_DEV dev, uint8_t pin,
johnAlexander 14:8320b5ff96fa 4120 VL53L0X_DeviceModes device_mode, VL53L0X_GpioFunctionality functionality,
johnAlexander 14:8320b5ff96fa 4121 VL53L0X_InterruptPolarity polarity)
johnAlexander 0:c523920bcc09 4122 {
johnAlexander 14:8320b5ff96fa 4123 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 4124 uint8_t data;
johnAlexander 14:8320b5ff96fa 4125
johnAlexander 14:8320b5ff96fa 4126 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 4127
johnAlexander 14:8320b5ff96fa 4128 if (pin != 0) {
johnAlexander 14:8320b5ff96fa 4129 status = VL53L0X_ERROR_GPIO_NOT_EXISTING;
johnAlexander 14:8320b5ff96fa 4130 } else if (device_mode == VL53L0X_DEVICEMODE_GPIO_DRIVE) {
Davidroid 16:27d3d95c8593 4131 if (polarity == VL53L0X_INTERRUPTPOLARITY_LOW) {
johnAlexander 14:8320b5ff96fa 4132 data = 0x10;
Davidroid 16:27d3d95c8593 4133 } else {
johnAlexander 14:8320b5ff96fa 4134 data = 1;
Davidroid 16:27d3d95c8593 4135 }
Davidroid 16:27d3d95c8593 4136
Davidroid 16:27d3d95c8593 4137 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 4138 VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH, data);
johnAlexander 14:8320b5ff96fa 4139
johnAlexander 14:8320b5ff96fa 4140 } else {
Davidroid 16:27d3d95c8593 4141 if (device_mode == VL53L0X_DEVICEMODE_GPIO_OSC) {
Davidroid 16:27d3d95c8593 4142
Davidroid 16:27d3d95c8593 4143 status |= VL53L0X_write_byte(dev, 0xff, 0x01);
Davidroid 16:27d3d95c8593 4144 status |= VL53L0X_write_byte(dev, 0x00, 0x00);
Davidroid 16:27d3d95c8593 4145
Davidroid 16:27d3d95c8593 4146 status |= VL53L0X_write_byte(dev, 0xff, 0x00);
Davidroid 16:27d3d95c8593 4147 status |= VL53L0X_write_byte(dev, 0x80, 0x01);
Davidroid 16:27d3d95c8593 4148 status |= VL53L0X_write_byte(dev, 0x85, 0x02);
Davidroid 16:27d3d95c8593 4149
Davidroid 16:27d3d95c8593 4150 status |= VL53L0X_write_byte(dev, 0xff, 0x04);
Davidroid 16:27d3d95c8593 4151 status |= VL53L0X_write_byte(dev, 0xcd, 0x00);
Davidroid 16:27d3d95c8593 4152 status |= VL53L0X_write_byte(dev, 0xcc, 0x11);
Davidroid 16:27d3d95c8593 4153
Davidroid 16:27d3d95c8593 4154 status |= VL53L0X_write_byte(dev, 0xff, 0x07);
Davidroid 16:27d3d95c8593 4155 status |= VL53L0X_write_byte(dev, 0xbe, 0x00);
Davidroid 16:27d3d95c8593 4156
Davidroid 16:27d3d95c8593 4157 status |= VL53L0X_write_byte(dev, 0xff, 0x06);
Davidroid 16:27d3d95c8593 4158 status |= VL53L0X_write_byte(dev, 0xcc, 0x09);
Davidroid 16:27d3d95c8593 4159
Davidroid 16:27d3d95c8593 4160 status |= VL53L0X_write_byte(dev, 0xff, 0x00);
Davidroid 16:27d3d95c8593 4161 status |= VL53L0X_write_byte(dev, 0xff, 0x01);
Davidroid 16:27d3d95c8593 4162 status |= VL53L0X_write_byte(dev, 0x00, 0x00);
Davidroid 16:27d3d95c8593 4163
Davidroid 16:27d3d95c8593 4164 } else {
Davidroid 16:27d3d95c8593 4165
Davidroid 16:27d3d95c8593 4166 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4167 switch (functionality) {
Davidroid 16:27d3d95c8593 4168 case VL53L0X_GPIOFUNCTIONALITY_OFF:
Davidroid 16:27d3d95c8593 4169 data = 0x00;
Davidroid 16:27d3d95c8593 4170 break;
Davidroid 16:27d3d95c8593 4171 case VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_LOW:
Davidroid 16:27d3d95c8593 4172 data = 0x01;
Davidroid 16:27d3d95c8593 4173 break;
Davidroid 16:27d3d95c8593 4174 case VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_HIGH:
Davidroid 16:27d3d95c8593 4175 data = 0x02;
Davidroid 16:27d3d95c8593 4176 break;
Davidroid 16:27d3d95c8593 4177 case VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_OUT:
Davidroid 16:27d3d95c8593 4178 data = 0x03;
Davidroid 16:27d3d95c8593 4179 break;
Davidroid 16:27d3d95c8593 4180 case VL53L0X_GPIOFUNCTIONALITY_NEW_MEASURE_READY:
Davidroid 16:27d3d95c8593 4181 data = 0x04;
Davidroid 16:27d3d95c8593 4182 break;
Davidroid 16:27d3d95c8593 4183 default:
Davidroid 16:27d3d95c8593 4184 status =
Davidroid 16:27d3d95c8593 4185 VL53L0X_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED;
Davidroid 16:27d3d95c8593 4186 }
Davidroid 16:27d3d95c8593 4187 }
Davidroid 16:27d3d95c8593 4188
Davidroid 16:27d3d95c8593 4189 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4190 status = VL53L0X_write_byte(dev,
Davidroid 16:27d3d95c8593 4191 VL53L0X_REG_SYSTEM_INTERRUPT_CONFIG_GPIO, data);
Davidroid 16:27d3d95c8593 4192 }
Davidroid 16:27d3d95c8593 4193
Davidroid 16:27d3d95c8593 4194 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4195 if (polarity == VL53L0X_INTERRUPTPOLARITY_LOW) {
Davidroid 16:27d3d95c8593 4196 data = 0;
Davidroid 16:27d3d95c8593 4197 } else {
Davidroid 16:27d3d95c8593 4198 data = (uint8_t)(1 << 4);
Davidroid 16:27d3d95c8593 4199 }
Davidroid 16:27d3d95c8593 4200 status = VL53L0X_update_byte(dev,
Davidroid 16:27d3d95c8593 4201 VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH, 0xEF, data);
Davidroid 16:27d3d95c8593 4202 }
Davidroid 16:27d3d95c8593 4203
Davidroid 16:27d3d95c8593 4204 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4205 VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
Davidroid 16:27d3d95c8593 4206 Pin0GpioFunctionality, functionality);
Davidroid 16:27d3d95c8593 4207 }
Davidroid 16:27d3d95c8593 4208
Davidroid 16:27d3d95c8593 4209 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4210 status = VL53L0X_clear_interrupt_mask(dev, 0);
Davidroid 16:27d3d95c8593 4211 }
Davidroid 16:27d3d95c8593 4212 }
johnAlexander 14:8320b5ff96fa 4213 }
johnAlexander 14:8320b5ff96fa 4214 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 4215 return status;
johnAlexander 0:c523920bcc09 4216 }
johnAlexander 0:c523920bcc09 4217
Davidroid 16:27d3d95c8593 4218 VL53L0X_Error VL53L0X::VL53L0X_get_fraction_enable(VL53L0X_DEV dev, uint8_t *p_enabled)
johnAlexander 0:c523920bcc09 4219 {
johnAlexander 14:8320b5ff96fa 4220 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 4221 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 4222
Davidroid 16:27d3d95c8593 4223 status = VL53L0X_read_byte(dev, VL53L0X_REG_SYSTEM_RANGE_CONFIG, p_enabled);
Davidroid 16:27d3d95c8593 4224
Davidroid 16:27d3d95c8593 4225 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 4226 *p_enabled = (*p_enabled & 1);
Davidroid 16:27d3d95c8593 4227 }
johnAlexander 14:8320b5ff96fa 4228
johnAlexander 14:8320b5ff96fa 4229 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 4230 return status;
johnAlexander 0:c523920bcc09 4231 }
johnAlexander 0:c523920bcc09 4232
Davidroid 16:27d3d95c8593 4233 uint16_t VL53L0X::VL53L0X_encode_timeout(uint32_t timeout_macro_clks)
johnAlexander 0:c523920bcc09 4234 {
johnAlexander 14:8320b5ff96fa 4235 /*!
johnAlexander 14:8320b5ff96fa 4236 * Encode timeout in macro periods in (LSByte * 2^MSByte) + 1 format
johnAlexander 14:8320b5ff96fa 4237 */
johnAlexander 14:8320b5ff96fa 4238
johnAlexander 14:8320b5ff96fa 4239 uint16_t encoded_timeout = 0;
johnAlexander 14:8320b5ff96fa 4240 uint32_t ls_byte = 0;
johnAlexander 14:8320b5ff96fa 4241 uint16_t ms_byte = 0;
johnAlexander 14:8320b5ff96fa 4242
johnAlexander 14:8320b5ff96fa 4243 if (timeout_macro_clks > 0) {
johnAlexander 14:8320b5ff96fa 4244 ls_byte = timeout_macro_clks - 1;
johnAlexander 14:8320b5ff96fa 4245
johnAlexander 14:8320b5ff96fa 4246 while ((ls_byte & 0xFFFFFF00) > 0) {
johnAlexander 14:8320b5ff96fa 4247 ls_byte = ls_byte >> 1;
johnAlexander 14:8320b5ff96fa 4248 ms_byte++;
johnAlexander 14:8320b5ff96fa 4249 }
johnAlexander 14:8320b5ff96fa 4250
johnAlexander 14:8320b5ff96fa 4251 encoded_timeout = (ms_byte << 8)
johnAlexander 14:8320b5ff96fa 4252 + (uint16_t)(ls_byte & 0x000000FF);
johnAlexander 14:8320b5ff96fa 4253 }
johnAlexander 14:8320b5ff96fa 4254
johnAlexander 14:8320b5ff96fa 4255 return encoded_timeout;
johnAlexander 0:c523920bcc09 4256
johnAlexander 0:c523920bcc09 4257 }
johnAlexander 0:c523920bcc09 4258
johnAlexander 14:8320b5ff96fa 4259 VL53L0X_Error VL53L0X::set_sequence_step_timeout(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 4260 VL53L0X_SequenceStepId sequence_step_id,
johnAlexander 14:8320b5ff96fa 4261 uint32_t timeout_micro_secs)
johnAlexander 0:c523920bcc09 4262 {
johnAlexander 14:8320b5ff96fa 4263 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 4264 uint8_t current_vcsel_pulse_period_p_clk;
johnAlexander 14:8320b5ff96fa 4265 uint8_t msrc_encoded_time_out;
johnAlexander 14:8320b5ff96fa 4266 uint16_t pre_range_encoded_time_out;
johnAlexander 14:8320b5ff96fa 4267 uint16_t pre_range_time_out_m_clks;
johnAlexander 14:8320b5ff96fa 4268 uint16_t msrc_range_time_out_m_clks;
johnAlexander 14:8320b5ff96fa 4269 uint32_t final_range_time_out_m_clks;
johnAlexander 14:8320b5ff96fa 4270 uint16_t final_range_encoded_time_out;
johnAlexander 14:8320b5ff96fa 4271 VL53L0X_SchedulerSequenceSteps_t scheduler_sequence_steps;
johnAlexander 14:8320b5ff96fa 4272
johnAlexander 14:8320b5ff96fa 4273 if ((sequence_step_id == VL53L0X_SEQUENCESTEP_TCC) ||
johnAlexander 14:8320b5ff96fa 4274 (sequence_step_id == VL53L0X_SEQUENCESTEP_DSS) ||
johnAlexander 14:8320b5ff96fa 4275 (sequence_step_id == VL53L0X_SEQUENCESTEP_MSRC)) {
johnAlexander 14:8320b5ff96fa 4276
Davidroid 16:27d3d95c8593 4277 status = VL53L0X_get_vcsel_pulse_period(dev,
johnAlexander 14:8320b5ff96fa 4278 VL53L0X_VCSEL_PERIOD_PRE_RANGE,
johnAlexander 14:8320b5ff96fa 4279 &current_vcsel_pulse_period_p_clk);
johnAlexander 14:8320b5ff96fa 4280
johnAlexander 14:8320b5ff96fa 4281 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4282 msrc_range_time_out_m_clks = VL53L0X_calc_timeout_mclks(dev,
johnAlexander 14:8320b5ff96fa 4283 timeout_micro_secs,
johnAlexander 14:8320b5ff96fa 4284 (uint8_t)current_vcsel_pulse_period_p_clk);
johnAlexander 14:8320b5ff96fa 4285
Davidroid 16:27d3d95c8593 4286 if (msrc_range_time_out_m_clks > 256) {
johnAlexander 14:8320b5ff96fa 4287 msrc_encoded_time_out = 255;
Davidroid 16:27d3d95c8593 4288 } else {
johnAlexander 14:8320b5ff96fa 4289 msrc_encoded_time_out =
johnAlexander 14:8320b5ff96fa 4290 (uint8_t)msrc_range_time_out_m_clks - 1;
Davidroid 16:27d3d95c8593 4291 }
johnAlexander 14:8320b5ff96fa 4292
johnAlexander 14:8320b5ff96fa 4293 VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
johnAlexander 14:8320b5ff96fa 4294 LastEncodedTimeout,
johnAlexander 14:8320b5ff96fa 4295 msrc_encoded_time_out);
johnAlexander 14:8320b5ff96fa 4296 }
johnAlexander 14:8320b5ff96fa 4297
johnAlexander 14:8320b5ff96fa 4298 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4299 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 4300 VL53L0X_REG_MSRC_CONFIG_TIMEOUT_MACROP,
johnAlexander 14:8320b5ff96fa 4301 msrc_encoded_time_out);
johnAlexander 14:8320b5ff96fa 4302 }
johnAlexander 14:8320b5ff96fa 4303 } else {
johnAlexander 14:8320b5ff96fa 4304
johnAlexander 14:8320b5ff96fa 4305 if (sequence_step_id == VL53L0X_SEQUENCESTEP_PRE_RANGE) {
johnAlexander 14:8320b5ff96fa 4306
johnAlexander 14:8320b5ff96fa 4307 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4308 status = VL53L0X_get_vcsel_pulse_period(dev,
johnAlexander 14:8320b5ff96fa 4309 VL53L0X_VCSEL_PERIOD_PRE_RANGE,
johnAlexander 14:8320b5ff96fa 4310 &current_vcsel_pulse_period_p_clk);
johnAlexander 14:8320b5ff96fa 4311 pre_range_time_out_m_clks =
Davidroid 16:27d3d95c8593 4312 VL53L0X_calc_timeout_mclks(dev,
johnAlexander 14:8320b5ff96fa 4313 timeout_micro_secs,
johnAlexander 14:8320b5ff96fa 4314 (uint8_t)current_vcsel_pulse_period_p_clk);
Davidroid 16:27d3d95c8593 4315 pre_range_encoded_time_out = VL53L0X_encode_timeout(
johnAlexander 14:8320b5ff96fa 4316 pre_range_time_out_m_clks);
johnAlexander 14:8320b5ff96fa 4317
johnAlexander 14:8320b5ff96fa 4318 VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
johnAlexander 14:8320b5ff96fa 4319 LastEncodedTimeout,
johnAlexander 14:8320b5ff96fa 4320 pre_range_encoded_time_out);
johnAlexander 14:8320b5ff96fa 4321 }
johnAlexander 14:8320b5ff96fa 4322
johnAlexander 14:8320b5ff96fa 4323 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4324 status = VL53L0X_write_word(dev,
johnAlexander 14:8320b5ff96fa 4325 VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI,
johnAlexander 14:8320b5ff96fa 4326 pre_range_encoded_time_out);
johnAlexander 14:8320b5ff96fa 4327 }
johnAlexander 14:8320b5ff96fa 4328
johnAlexander 14:8320b5ff96fa 4329 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 4330 VL53L0X_SETDEVICESPECIFICPARAMETER(
johnAlexander 14:8320b5ff96fa 4331 dev,
johnAlexander 14:8320b5ff96fa 4332 PreRangeTimeoutMicroSecs,
johnAlexander 14:8320b5ff96fa 4333 timeout_micro_secs);
johnAlexander 14:8320b5ff96fa 4334 }
johnAlexander 14:8320b5ff96fa 4335 } else if (sequence_step_id == VL53L0X_SEQUENCESTEP_FINAL_RANGE) {
johnAlexander 14:8320b5ff96fa 4336
johnAlexander 14:8320b5ff96fa 4337 /* For the final range timeout, the pre-range timeout
johnAlexander 14:8320b5ff96fa 4338 * must be added. To do this both final and pre-range
johnAlexander 14:8320b5ff96fa 4339 * timeouts must be expressed in macro periods MClks
johnAlexander 14:8320b5ff96fa 4340 * because they have different vcsel periods.
johnAlexander 14:8320b5ff96fa 4341 */
johnAlexander 14:8320b5ff96fa 4342
Davidroid 16:27d3d95c8593 4343 VL53L0X_get_sequence_step_enables(dev,
johnAlexander 14:8320b5ff96fa 4344 &scheduler_sequence_steps);
johnAlexander 14:8320b5ff96fa 4345 pre_range_time_out_m_clks = 0;
johnAlexander 14:8320b5ff96fa 4346 if (scheduler_sequence_steps.PreRangeOn) {
johnAlexander 14:8320b5ff96fa 4347
johnAlexander 14:8320b5ff96fa 4348 /* Retrieve PRE-RANGE VCSEL Period */
Davidroid 16:27d3d95c8593 4349 status = VL53L0X_get_vcsel_pulse_period(dev,
johnAlexander 14:8320b5ff96fa 4350 VL53L0X_VCSEL_PERIOD_PRE_RANGE,
johnAlexander 14:8320b5ff96fa 4351 &current_vcsel_pulse_period_p_clk);
johnAlexander 14:8320b5ff96fa 4352
johnAlexander 14:8320b5ff96fa 4353 /* Retrieve PRE-RANGE Timeout in Macro periods
johnAlexander 14:8320b5ff96fa 4354 * (MCLKS) */
johnAlexander 14:8320b5ff96fa 4355 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4356 status = VL53L0X_read_word(dev, 0x51,
johnAlexander 14:8320b5ff96fa 4357 &pre_range_encoded_time_out);
johnAlexander 14:8320b5ff96fa 4358 pre_range_time_out_m_clks =
Davidroid 16:27d3d95c8593 4359 VL53L0X_decode_timeout(
johnAlexander 14:8320b5ff96fa 4360 pre_range_encoded_time_out);
johnAlexander 14:8320b5ff96fa 4361 }
johnAlexander 14:8320b5ff96fa 4362 }
johnAlexander 14:8320b5ff96fa 4363
johnAlexander 14:8320b5ff96fa 4364 /* Calculate FINAL RANGE Timeout in Macro Periods
johnAlexander 14:8320b5ff96fa 4365 * (MCLKS) and add PRE-RANGE value
johnAlexander 14:8320b5ff96fa 4366 */
johnAlexander 14:8320b5ff96fa 4367 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4368 status = VL53L0X_get_vcsel_pulse_period(dev,
johnAlexander 14:8320b5ff96fa 4369 VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
johnAlexander 14:8320b5ff96fa 4370 &current_vcsel_pulse_period_p_clk);
johnAlexander 14:8320b5ff96fa 4371 }
johnAlexander 14:8320b5ff96fa 4372 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 4373 final_range_time_out_m_clks =
Davidroid 16:27d3d95c8593 4374 VL53L0X_calc_timeout_mclks(dev,
johnAlexander 14:8320b5ff96fa 4375 timeout_micro_secs,
johnAlexander 14:8320b5ff96fa 4376 (uint8_t) current_vcsel_pulse_period_p_clk);
johnAlexander 14:8320b5ff96fa 4377
johnAlexander 14:8320b5ff96fa 4378 final_range_time_out_m_clks += pre_range_time_out_m_clks;
johnAlexander 14:8320b5ff96fa 4379
johnAlexander 14:8320b5ff96fa 4380 final_range_encoded_time_out =
Davidroid 16:27d3d95c8593 4381 VL53L0X_encode_timeout(final_range_time_out_m_clks);
johnAlexander 14:8320b5ff96fa 4382
johnAlexander 14:8320b5ff96fa 4383 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4384 status = VL53L0X_write_word(dev, 0x71,
johnAlexander 14:8320b5ff96fa 4385 final_range_encoded_time_out);
johnAlexander 14:8320b5ff96fa 4386 }
johnAlexander 14:8320b5ff96fa 4387
johnAlexander 14:8320b5ff96fa 4388 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 4389 VL53L0X_SETDEVICESPECIFICPARAMETER(
johnAlexander 14:8320b5ff96fa 4390 dev,
johnAlexander 14:8320b5ff96fa 4391 FinalRangeTimeoutMicroSecs,
johnAlexander 14:8320b5ff96fa 4392 timeout_micro_secs);
johnAlexander 14:8320b5ff96fa 4393 }
johnAlexander 14:8320b5ff96fa 4394 }
Davidroid 16:27d3d95c8593 4395 } else {
johnAlexander 14:8320b5ff96fa 4396 status = VL53L0X_ERROR_INVALID_PARAMS;
Davidroid 16:27d3d95c8593 4397 }
johnAlexander 14:8320b5ff96fa 4398
johnAlexander 14:8320b5ff96fa 4399 }
johnAlexander 14:8320b5ff96fa 4400 return status;
johnAlexander 0:c523920bcc09 4401 }
johnAlexander 0:c523920bcc09 4402
Davidroid 16:27d3d95c8593 4403 VL53L0X_Error VL53L0X::wrapped_VL53L0X_set_measurement_timing_budget_micro_seconds(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 4404 uint32_t measurement_timing_budget_micro_seconds)
johnAlexander 0:c523920bcc09 4405 {
johnAlexander 14:8320b5ff96fa 4406 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 4407 uint32_t final_range_timing_budget_micro_seconds;
johnAlexander 14:8320b5ff96fa 4408 VL53L0X_SchedulerSequenceSteps_t scheduler_sequence_steps;
johnAlexander 14:8320b5ff96fa 4409 uint32_t msrc_dcc_tcc_timeout_micro_seconds = 2000;
johnAlexander 14:8320b5ff96fa 4410 uint32_t start_overhead_micro_seconds = 1910;
johnAlexander 14:8320b5ff96fa 4411 uint32_t end_overhead_micro_seconds = 960;
johnAlexander 14:8320b5ff96fa 4412 uint32_t msrc_overhead_micro_seconds = 660;
johnAlexander 14:8320b5ff96fa 4413 uint32_t tcc_overhead_micro_seconds = 590;
johnAlexander 14:8320b5ff96fa 4414 uint32_t dss_overhead_micro_seconds = 690;
johnAlexander 14:8320b5ff96fa 4415 uint32_t pre_range_overhead_micro_seconds = 660;
johnAlexander 14:8320b5ff96fa 4416 uint32_t final_range_overhead_micro_seconds = 550;
johnAlexander 14:8320b5ff96fa 4417 uint32_t pre_range_timeout_micro_seconds = 0;
johnAlexander 14:8320b5ff96fa 4418 uint32_t c_min_timing_budget_micro_seconds = 20000;
johnAlexander 14:8320b5ff96fa 4419 uint32_t sub_timeout = 0;
johnAlexander 14:8320b5ff96fa 4420
johnAlexander 14:8320b5ff96fa 4421 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 4422
johnAlexander 14:8320b5ff96fa 4423 if (measurement_timing_budget_micro_seconds
johnAlexander 14:8320b5ff96fa 4424 < c_min_timing_budget_micro_seconds) {
johnAlexander 14:8320b5ff96fa 4425 status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander 14:8320b5ff96fa 4426 return status;
johnAlexander 14:8320b5ff96fa 4427 }
johnAlexander 14:8320b5ff96fa 4428
johnAlexander 14:8320b5ff96fa 4429 final_range_timing_budget_micro_seconds =
johnAlexander 14:8320b5ff96fa 4430 measurement_timing_budget_micro_seconds -
johnAlexander 14:8320b5ff96fa 4431 (start_overhead_micro_seconds + end_overhead_micro_seconds);
johnAlexander 14:8320b5ff96fa 4432
Davidroid 16:27d3d95c8593 4433 status = VL53L0X_get_sequence_step_enables(dev, &scheduler_sequence_steps);
johnAlexander 14:8320b5ff96fa 4434
johnAlexander 14:8320b5ff96fa 4435 if (status == VL53L0X_ERROR_NONE &&
johnAlexander 14:8320b5ff96fa 4436 (scheduler_sequence_steps.TccOn ||
johnAlexander 14:8320b5ff96fa 4437 scheduler_sequence_steps.MsrcOn ||
johnAlexander 14:8320b5ff96fa 4438 scheduler_sequence_steps.DssOn)) {
johnAlexander 14:8320b5ff96fa 4439
johnAlexander 14:8320b5ff96fa 4440 /* TCC, MSRC and DSS all share the same timeout */
johnAlexander 14:8320b5ff96fa 4441 status = get_sequence_step_timeout(dev,
johnAlexander 14:8320b5ff96fa 4442 VL53L0X_SEQUENCESTEP_MSRC,
johnAlexander 14:8320b5ff96fa 4443 &msrc_dcc_tcc_timeout_micro_seconds);
johnAlexander 14:8320b5ff96fa 4444
johnAlexander 14:8320b5ff96fa 4445 /* Subtract the TCC, MSRC and DSS timeouts if they are
johnAlexander 14:8320b5ff96fa 4446 * enabled. */
johnAlexander 14:8320b5ff96fa 4447
Davidroid 16:27d3d95c8593 4448 if (status != VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 4449 return status;
Davidroid 16:27d3d95c8593 4450 }
johnAlexander 14:8320b5ff96fa 4451
johnAlexander 14:8320b5ff96fa 4452 /* TCC */
johnAlexander 14:8320b5ff96fa 4453 if (scheduler_sequence_steps.TccOn) {
johnAlexander 14:8320b5ff96fa 4454
johnAlexander 14:8320b5ff96fa 4455 sub_timeout = msrc_dcc_tcc_timeout_micro_seconds
johnAlexander 14:8320b5ff96fa 4456 + tcc_overhead_micro_seconds;
johnAlexander 14:8320b5ff96fa 4457
johnAlexander 14:8320b5ff96fa 4458 if (sub_timeout <
johnAlexander 14:8320b5ff96fa 4459 final_range_timing_budget_micro_seconds) {
johnAlexander 14:8320b5ff96fa 4460 final_range_timing_budget_micro_seconds -=
johnAlexander 14:8320b5ff96fa 4461 sub_timeout;
johnAlexander 14:8320b5ff96fa 4462 } else {
johnAlexander 14:8320b5ff96fa 4463 /* Requested timeout too big. */
johnAlexander 14:8320b5ff96fa 4464 status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander 14:8320b5ff96fa 4465 }
johnAlexander 14:8320b5ff96fa 4466 }
johnAlexander 14:8320b5ff96fa 4467
johnAlexander 14:8320b5ff96fa 4468 if (status != VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 4469 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 4470 return status;
johnAlexander 14:8320b5ff96fa 4471 }
johnAlexander 14:8320b5ff96fa 4472
johnAlexander 14:8320b5ff96fa 4473 /* DSS */
johnAlexander 14:8320b5ff96fa 4474 if (scheduler_sequence_steps.DssOn) {
johnAlexander 14:8320b5ff96fa 4475
johnAlexander 14:8320b5ff96fa 4476 sub_timeout = 2 * (msrc_dcc_tcc_timeout_micro_seconds +
johnAlexander 14:8320b5ff96fa 4477 dss_overhead_micro_seconds);
johnAlexander 14:8320b5ff96fa 4478
johnAlexander 14:8320b5ff96fa 4479 if (sub_timeout < final_range_timing_budget_micro_seconds) {
johnAlexander 14:8320b5ff96fa 4480 final_range_timing_budget_micro_seconds
johnAlexander 14:8320b5ff96fa 4481 -= sub_timeout;
johnAlexander 14:8320b5ff96fa 4482 } else {
johnAlexander 14:8320b5ff96fa 4483 /* Requested timeout too big. */
johnAlexander 14:8320b5ff96fa 4484 status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander 14:8320b5ff96fa 4485 }
johnAlexander 14:8320b5ff96fa 4486 } else if (scheduler_sequence_steps.MsrcOn) {
johnAlexander 14:8320b5ff96fa 4487 /* MSRC */
johnAlexander 14:8320b5ff96fa 4488 sub_timeout = msrc_dcc_tcc_timeout_micro_seconds +
johnAlexander 14:8320b5ff96fa 4489 msrc_overhead_micro_seconds;
johnAlexander 14:8320b5ff96fa 4490
johnAlexander 14:8320b5ff96fa 4491 if (sub_timeout < final_range_timing_budget_micro_seconds) {
johnAlexander 14:8320b5ff96fa 4492 final_range_timing_budget_micro_seconds
johnAlexander 14:8320b5ff96fa 4493 -= sub_timeout;
johnAlexander 14:8320b5ff96fa 4494 } else {
johnAlexander 14:8320b5ff96fa 4495 /* Requested timeout too big. */
johnAlexander 14:8320b5ff96fa 4496 status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander 14:8320b5ff96fa 4497 }
johnAlexander 14:8320b5ff96fa 4498 }
johnAlexander 14:8320b5ff96fa 4499
johnAlexander 14:8320b5ff96fa 4500 }
johnAlexander 14:8320b5ff96fa 4501
johnAlexander 14:8320b5ff96fa 4502 if (status != VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 4503 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 4504 return status;
johnAlexander 14:8320b5ff96fa 4505 }
johnAlexander 14:8320b5ff96fa 4506
johnAlexander 14:8320b5ff96fa 4507 if (scheduler_sequence_steps.PreRangeOn) {
johnAlexander 14:8320b5ff96fa 4508
johnAlexander 14:8320b5ff96fa 4509 /* Subtract the Pre-range timeout if enabled. */
johnAlexander 14:8320b5ff96fa 4510
johnAlexander 14:8320b5ff96fa 4511 status = get_sequence_step_timeout(dev,
johnAlexander 14:8320b5ff96fa 4512 VL53L0X_SEQUENCESTEP_PRE_RANGE,
johnAlexander 14:8320b5ff96fa 4513 &pre_range_timeout_micro_seconds);
johnAlexander 14:8320b5ff96fa 4514
johnAlexander 14:8320b5ff96fa 4515 sub_timeout = pre_range_timeout_micro_seconds +
johnAlexander 14:8320b5ff96fa 4516 pre_range_overhead_micro_seconds;
johnAlexander 14:8320b5ff96fa 4517
johnAlexander 14:8320b5ff96fa 4518 if (sub_timeout < final_range_timing_budget_micro_seconds) {
johnAlexander 14:8320b5ff96fa 4519 final_range_timing_budget_micro_seconds -= sub_timeout;
johnAlexander 14:8320b5ff96fa 4520 } else {
johnAlexander 14:8320b5ff96fa 4521 /* Requested timeout too big. */
johnAlexander 14:8320b5ff96fa 4522 status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander 14:8320b5ff96fa 4523 }
johnAlexander 14:8320b5ff96fa 4524 }
johnAlexander 14:8320b5ff96fa 4525
johnAlexander 14:8320b5ff96fa 4526
johnAlexander 14:8320b5ff96fa 4527 if (status == VL53L0X_ERROR_NONE &&
johnAlexander 14:8320b5ff96fa 4528 scheduler_sequence_steps.FinalRangeOn) {
johnAlexander 14:8320b5ff96fa 4529
johnAlexander 14:8320b5ff96fa 4530 final_range_timing_budget_micro_seconds -=
johnAlexander 14:8320b5ff96fa 4531 final_range_overhead_micro_seconds;
johnAlexander 14:8320b5ff96fa 4532
johnAlexander 14:8320b5ff96fa 4533 /* Final Range Timeout
johnAlexander 14:8320b5ff96fa 4534 * Note that the final range timeout is determined by the timing
johnAlexander 14:8320b5ff96fa 4535 * budget and the sum of all other timeouts within the sequence.
johnAlexander 14:8320b5ff96fa 4536 * If there is no room for the final range timeout, then an error
johnAlexander 14:8320b5ff96fa 4537 * will be set. Otherwise the remaining time will be applied to
johnAlexander 14:8320b5ff96fa 4538 * the final range.
johnAlexander 14:8320b5ff96fa 4539 */
johnAlexander 14:8320b5ff96fa 4540 status = set_sequence_step_timeout(dev,
johnAlexander 14:8320b5ff96fa 4541 VL53L0X_SEQUENCESTEP_FINAL_RANGE,
johnAlexander 14:8320b5ff96fa 4542 final_range_timing_budget_micro_seconds);
johnAlexander 14:8320b5ff96fa 4543
johnAlexander 14:8320b5ff96fa 4544 VL53L0X_SETPARAMETERFIELD(dev,
johnAlexander 14:8320b5ff96fa 4545 MeasurementTimingBudgetMicroSeconds,
johnAlexander 14:8320b5ff96fa 4546 measurement_timing_budget_micro_seconds);
johnAlexander 14:8320b5ff96fa 4547 }
johnAlexander 14:8320b5ff96fa 4548
johnAlexander 14:8320b5ff96fa 4549 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 4550
johnAlexander 14:8320b5ff96fa 4551 return status;
johnAlexander 0:c523920bcc09 4552 }
johnAlexander 0:c523920bcc09 4553
Davidroid 16:27d3d95c8593 4554 VL53L0X_Error VL53L0X::VL53L0X_set_measurement_timing_budget_micro_seconds(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 4555 uint32_t measurement_timing_budget_micro_seconds)
johnAlexander 0:c523920bcc09 4556 {
johnAlexander 14:8320b5ff96fa 4557 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 4558 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 4559
Davidroid 16:27d3d95c8593 4560 status = wrapped_VL53L0X_set_measurement_timing_budget_micro_seconds(dev,
johnAlexander 14:8320b5ff96fa 4561 measurement_timing_budget_micro_seconds);
johnAlexander 14:8320b5ff96fa 4562
johnAlexander 14:8320b5ff96fa 4563 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 4564
johnAlexander 14:8320b5ff96fa 4565 return status;
johnAlexander 0:c523920bcc09 4566 }
johnAlexander 0:c523920bcc09 4567
Davidroid 16:27d3d95c8593 4568 VL53L0X_Error VL53L0X::VL53L0X_set_sequence_step_enable(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 4569 VL53L0X_SequenceStepId sequence_step_id, uint8_t sequence_step_enabled)
johnAlexander 0:c523920bcc09 4570 {
johnAlexander 14:8320b5ff96fa 4571 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 4572 uint8_t sequence_config = 0;
johnAlexander 14:8320b5ff96fa 4573 uint8_t sequence_config_new = 0;
johnAlexander 14:8320b5ff96fa 4574 uint32_t measurement_timing_budget_micro_seconds;
johnAlexander 14:8320b5ff96fa 4575 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 4576
Davidroid 16:27d3d95c8593 4577 status = VL53L0X_read_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
johnAlexander 14:8320b5ff96fa 4578 &sequence_config);
johnAlexander 14:8320b5ff96fa 4579
johnAlexander 14:8320b5ff96fa 4580 sequence_config_new = sequence_config;
johnAlexander 14:8320b5ff96fa 4581
johnAlexander 14:8320b5ff96fa 4582 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 4583 if (sequence_step_enabled == 1) {
johnAlexander 14:8320b5ff96fa 4584
johnAlexander 14:8320b5ff96fa 4585 /* Enable requested sequence step
johnAlexander 14:8320b5ff96fa 4586 */
johnAlexander 14:8320b5ff96fa 4587 switch (sequence_step_id) {
johnAlexander 14:8320b5ff96fa 4588 case VL53L0X_SEQUENCESTEP_TCC:
johnAlexander 14:8320b5ff96fa 4589 sequence_config_new |= 0x10;
johnAlexander 14:8320b5ff96fa 4590 break;
johnAlexander 14:8320b5ff96fa 4591 case VL53L0X_SEQUENCESTEP_DSS:
johnAlexander 14:8320b5ff96fa 4592 sequence_config_new |= 0x28;
johnAlexander 14:8320b5ff96fa 4593 break;
johnAlexander 14:8320b5ff96fa 4594 case VL53L0X_SEQUENCESTEP_MSRC:
johnAlexander 14:8320b5ff96fa 4595 sequence_config_new |= 0x04;
johnAlexander 14:8320b5ff96fa 4596 break;
johnAlexander 14:8320b5ff96fa 4597 case VL53L0X_SEQUENCESTEP_PRE_RANGE:
johnAlexander 14:8320b5ff96fa 4598 sequence_config_new |= 0x40;
johnAlexander 14:8320b5ff96fa 4599 break;
johnAlexander 14:8320b5ff96fa 4600 case VL53L0X_SEQUENCESTEP_FINAL_RANGE:
johnAlexander 14:8320b5ff96fa 4601 sequence_config_new |= 0x80;
johnAlexander 14:8320b5ff96fa 4602 break;
johnAlexander 14:8320b5ff96fa 4603 default:
johnAlexander 14:8320b5ff96fa 4604 status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander 14:8320b5ff96fa 4605 }
johnAlexander 14:8320b5ff96fa 4606 } else {
johnAlexander 14:8320b5ff96fa 4607 /* Disable requested sequence step
johnAlexander 14:8320b5ff96fa 4608 */
johnAlexander 14:8320b5ff96fa 4609 switch (sequence_step_id) {
johnAlexander 14:8320b5ff96fa 4610 case VL53L0X_SEQUENCESTEP_TCC:
johnAlexander 14:8320b5ff96fa 4611 sequence_config_new &= 0xef;
johnAlexander 14:8320b5ff96fa 4612 break;
johnAlexander 14:8320b5ff96fa 4613 case VL53L0X_SEQUENCESTEP_DSS:
johnAlexander 14:8320b5ff96fa 4614 sequence_config_new &= 0xd7;
johnAlexander 14:8320b5ff96fa 4615 break;
johnAlexander 14:8320b5ff96fa 4616 case VL53L0X_SEQUENCESTEP_MSRC:
johnAlexander 14:8320b5ff96fa 4617 sequence_config_new &= 0xfb;
johnAlexander 14:8320b5ff96fa 4618 break;
johnAlexander 14:8320b5ff96fa 4619 case VL53L0X_SEQUENCESTEP_PRE_RANGE:
johnAlexander 14:8320b5ff96fa 4620 sequence_config_new &= 0xbf;
johnAlexander 14:8320b5ff96fa 4621 break;
johnAlexander 14:8320b5ff96fa 4622 case VL53L0X_SEQUENCESTEP_FINAL_RANGE:
johnAlexander 14:8320b5ff96fa 4623 sequence_config_new &= 0x7f;
johnAlexander 14:8320b5ff96fa 4624 break;
johnAlexander 14:8320b5ff96fa 4625 default:
johnAlexander 14:8320b5ff96fa 4626 status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander 14:8320b5ff96fa 4627 }
johnAlexander 14:8320b5ff96fa 4628 }
johnAlexander 14:8320b5ff96fa 4629 }
johnAlexander 14:8320b5ff96fa 4630
johnAlexander 14:8320b5ff96fa 4631 if (sequence_config_new != sequence_config) {
johnAlexander 14:8320b5ff96fa 4632 /* Apply New Setting */
johnAlexander 14:8320b5ff96fa 4633 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4634 status = VL53L0X_write_byte(dev,
johnAlexander 14:8320b5ff96fa 4635 VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, sequence_config_new);
johnAlexander 14:8320b5ff96fa 4636 }
Davidroid 16:27d3d95c8593 4637 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 4638 PALDevDataSet(dev, SequenceConfig, sequence_config_new);
Davidroid 16:27d3d95c8593 4639 }
johnAlexander 14:8320b5ff96fa 4640
johnAlexander 14:8320b5ff96fa 4641
johnAlexander 14:8320b5ff96fa 4642 /* Recalculate timing budget */
johnAlexander 14:8320b5ff96fa 4643 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 4644 VL53L0X_GETPARAMETERFIELD(dev,
johnAlexander 14:8320b5ff96fa 4645 MeasurementTimingBudgetMicroSeconds,
johnAlexander 14:8320b5ff96fa 4646 measurement_timing_budget_micro_seconds);
johnAlexander 14:8320b5ff96fa 4647
Davidroid 16:27d3d95c8593 4648 VL53L0X_set_measurement_timing_budget_micro_seconds(dev,
johnAlexander 14:8320b5ff96fa 4649 measurement_timing_budget_micro_seconds);
johnAlexander 14:8320b5ff96fa 4650 }
johnAlexander 14:8320b5ff96fa 4651 }
johnAlexander 14:8320b5ff96fa 4652
johnAlexander 14:8320b5ff96fa 4653 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 4654
johnAlexander 14:8320b5ff96fa 4655 return status;
johnAlexander 0:c523920bcc09 4656 }
johnAlexander 0:c523920bcc09 4657
Davidroid 16:27d3d95c8593 4658 VL53L0X_Error VL53L0X::VL53L0X_set_limit_check_enable(VL53L0X_DEV dev, uint16_t limit_check_id,
johnAlexander 14:8320b5ff96fa 4659 uint8_t limit_check_enable)
johnAlexander 0:c523920bcc09 4660 {
johnAlexander 14:8320b5ff96fa 4661 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 4662 FixPoint1616_t temp_fix1616 = 0;
johnAlexander 14:8320b5ff96fa 4663 uint8_t limit_check_enable_int = 0;
johnAlexander 14:8320b5ff96fa 4664 uint8_t limit_check_disable = 0;
johnAlexander 14:8320b5ff96fa 4665 uint8_t temp8;
johnAlexander 14:8320b5ff96fa 4666
johnAlexander 14:8320b5ff96fa 4667 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 4668
johnAlexander 14:8320b5ff96fa 4669 if (limit_check_id >= VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS) {
johnAlexander 14:8320b5ff96fa 4670 status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander 14:8320b5ff96fa 4671 } else {
johnAlexander 14:8320b5ff96fa 4672 if (limit_check_enable == 0) {
johnAlexander 14:8320b5ff96fa 4673 temp_fix1616 = 0;
johnAlexander 14:8320b5ff96fa 4674 limit_check_enable_int = 0;
johnAlexander 14:8320b5ff96fa 4675 limit_check_disable = 1;
johnAlexander 14:8320b5ff96fa 4676
johnAlexander 14:8320b5ff96fa 4677 } else {
johnAlexander 14:8320b5ff96fa 4678 VL53L0X_GETARRAYPARAMETERFIELD(dev, LimitChecksValue,
johnAlexander 14:8320b5ff96fa 4679 limit_check_id, temp_fix1616);
johnAlexander 14:8320b5ff96fa 4680 limit_check_disable = 0;
johnAlexander 14:8320b5ff96fa 4681 /* this to be sure to have either 0 or 1 */
johnAlexander 14:8320b5ff96fa 4682 limit_check_enable_int = 1;
johnAlexander 14:8320b5ff96fa 4683 }
johnAlexander 14:8320b5ff96fa 4684
johnAlexander 14:8320b5ff96fa 4685 switch (limit_check_id) {
johnAlexander 14:8320b5ff96fa 4686
johnAlexander 14:8320b5ff96fa 4687 case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
johnAlexander 14:8320b5ff96fa 4688 /* internal computation: */
johnAlexander 14:8320b5ff96fa 4689 VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksEnable,
johnAlexander 14:8320b5ff96fa 4690 VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
johnAlexander 14:8320b5ff96fa 4691 limit_check_enable_int);
johnAlexander 14:8320b5ff96fa 4692
johnAlexander 14:8320b5ff96fa 4693 break;
johnAlexander 14:8320b5ff96fa 4694
johnAlexander 14:8320b5ff96fa 4695 case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
johnAlexander 14:8320b5ff96fa 4696
Davidroid 16:27d3d95c8593 4697 status = VL53L0X_write_word(dev,
johnAlexander 14:8320b5ff96fa 4698 VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
johnAlexander 14:8320b5ff96fa 4699 VL53L0X_FIXPOINT1616TOFIXPOINT97(temp_fix1616));
johnAlexander 14:8320b5ff96fa 4700
johnAlexander 14:8320b5ff96fa 4701 break;
johnAlexander 14:8320b5ff96fa 4702
johnAlexander 14:8320b5ff96fa 4703 case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
johnAlexander 14:8320b5ff96fa 4704
johnAlexander 14:8320b5ff96fa 4705 /* internal computation: */
johnAlexander 14:8320b5ff96fa 4706 VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksEnable,
johnAlexander 14:8320b5ff96fa 4707 VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
johnAlexander 14:8320b5ff96fa 4708 limit_check_enable_int);
johnAlexander 14:8320b5ff96fa 4709
johnAlexander 14:8320b5ff96fa 4710 break;
johnAlexander 14:8320b5ff96fa 4711
johnAlexander 14:8320b5ff96fa 4712 case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
johnAlexander 14:8320b5ff96fa 4713
johnAlexander 14:8320b5ff96fa 4714 /* internal computation: */
johnAlexander 14:8320b5ff96fa 4715 VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksEnable,
johnAlexander 14:8320b5ff96fa 4716 VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
johnAlexander 14:8320b5ff96fa 4717 limit_check_enable_int);
johnAlexander 14:8320b5ff96fa 4718
johnAlexander 14:8320b5ff96fa 4719 break;
johnAlexander 14:8320b5ff96fa 4720
johnAlexander 14:8320b5ff96fa 4721 case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
johnAlexander 14:8320b5ff96fa 4722
johnAlexander 14:8320b5ff96fa 4723 temp8 = (uint8_t)(limit_check_disable << 1);
Davidroid 16:27d3d95c8593 4724 status = VL53L0X_update_byte(dev,
johnAlexander 14:8320b5ff96fa 4725 VL53L0X_REG_MSRC_CONFIG_CONTROL,
johnAlexander 14:8320b5ff96fa 4726 0xFE, temp8);
johnAlexander 14:8320b5ff96fa 4727
johnAlexander 14:8320b5ff96fa 4728 break;
johnAlexander 14:8320b5ff96fa 4729
johnAlexander 14:8320b5ff96fa 4730 case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
johnAlexander 14:8320b5ff96fa 4731
johnAlexander 14:8320b5ff96fa 4732 temp8 = (uint8_t)(limit_check_disable << 4);
Davidroid 16:27d3d95c8593 4733 status = VL53L0X_update_byte(dev,
johnAlexander 14:8320b5ff96fa 4734 VL53L0X_REG_MSRC_CONFIG_CONTROL,
johnAlexander 14:8320b5ff96fa 4735 0xEF, temp8);
johnAlexander 14:8320b5ff96fa 4736
johnAlexander 14:8320b5ff96fa 4737 break;
johnAlexander 14:8320b5ff96fa 4738
johnAlexander 14:8320b5ff96fa 4739
johnAlexander 14:8320b5ff96fa 4740 default:
johnAlexander 14:8320b5ff96fa 4741 status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander 14:8320b5ff96fa 4742
johnAlexander 14:8320b5ff96fa 4743 }
johnAlexander 14:8320b5ff96fa 4744
johnAlexander 14:8320b5ff96fa 4745 }
johnAlexander 14:8320b5ff96fa 4746
johnAlexander 14:8320b5ff96fa 4747 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 4748 if (limit_check_enable == 0) {
johnAlexander 14:8320b5ff96fa 4749 VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksEnable,
johnAlexander 14:8320b5ff96fa 4750 limit_check_id, 0);
johnAlexander 14:8320b5ff96fa 4751 } else {
johnAlexander 14:8320b5ff96fa 4752 VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksEnable,
johnAlexander 14:8320b5ff96fa 4753 limit_check_id, 1);
johnAlexander 14:8320b5ff96fa 4754 }
johnAlexander 14:8320b5ff96fa 4755 }
johnAlexander 14:8320b5ff96fa 4756
johnAlexander 14:8320b5ff96fa 4757 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 4758 return status;
johnAlexander 0:c523920bcc09 4759 }
johnAlexander 0:c523920bcc09 4760
Davidroid 16:27d3d95c8593 4761 VL53L0X_Error VL53L0X::VL53L0X_static_init(VL53L0X_DEV dev)
johnAlexander 0:c523920bcc09 4762 {
johnAlexander 14:8320b5ff96fa 4763 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 4764 VL53L0X_DeviceParameters_t current_parameters = {0};
johnAlexander 14:8320b5ff96fa 4765 uint8_t *p_tuning_setting_buffer;
johnAlexander 14:8320b5ff96fa 4766 uint16_t tempword = 0;
johnAlexander 14:8320b5ff96fa 4767 uint8_t tempbyte = 0;
johnAlexander 14:8320b5ff96fa 4768 uint8_t use_internal_tuning_settings = 0;
johnAlexander 14:8320b5ff96fa 4769 uint32_t count = 0;
johnAlexander 14:8320b5ff96fa 4770 uint8_t is_aperture_spads = 0;
johnAlexander 14:8320b5ff96fa 4771 uint32_t ref_spad_count = 0;
johnAlexander 14:8320b5ff96fa 4772 uint8_t aperture_spads = 0;
johnAlexander 14:8320b5ff96fa 4773 uint8_t vcsel_pulse_period_pclk;
johnAlexander 14:8320b5ff96fa 4774 uint32_t seq_timeout_micro_secs;
johnAlexander 14:8320b5ff96fa 4775
johnAlexander 14:8320b5ff96fa 4776 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 4777
Davidroid 16:27d3d95c8593 4778 status = VL53L0X_get_info_from_device(dev, 1);
johnAlexander 14:8320b5ff96fa 4779
johnAlexander 14:8320b5ff96fa 4780 /* set the ref spad from NVM */
johnAlexander 14:8320b5ff96fa 4781 count = (uint32_t)VL53L0X_GETDEVICESPECIFICPARAMETER(dev,
johnAlexander 14:8320b5ff96fa 4782 ReferenceSpadCount);
johnAlexander 14:8320b5ff96fa 4783 aperture_spads = VL53L0X_GETDEVICESPECIFICPARAMETER(dev,
johnAlexander 14:8320b5ff96fa 4784 ReferenceSpadType);
johnAlexander 14:8320b5ff96fa 4785
johnAlexander 14:8320b5ff96fa 4786 /* NVM value invalid */
johnAlexander 14:8320b5ff96fa 4787 if ((aperture_spads > 1) ||
johnAlexander 14:8320b5ff96fa 4788 ((aperture_spads == 1) && (count > 32)) ||
Davidroid 16:27d3d95c8593 4789 ((aperture_spads == 0) && (count > 12))) {
Davidroid 16:27d3d95c8593 4790 status = wrapped_VL53L0X_perform_ref_spad_management(dev, &ref_spad_count,
johnAlexander 14:8320b5ff96fa 4791 &is_aperture_spads);
Davidroid 16:27d3d95c8593 4792 } else {
Davidroid 16:27d3d95c8593 4793 status = VL53L0X_set_reference_spads(dev, count, aperture_spads);
Davidroid 16:27d3d95c8593 4794 }
johnAlexander 14:8320b5ff96fa 4795
johnAlexander 14:8320b5ff96fa 4796
johnAlexander 14:8320b5ff96fa 4797 /* Initialize tuning settings buffer to prevent compiler warning. */
johnAlexander 14:8320b5ff96fa 4798 p_tuning_setting_buffer = DefaultTuningSettings;
johnAlexander 14:8320b5ff96fa 4799
johnAlexander 14:8320b5ff96fa 4800 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 4801 use_internal_tuning_settings = PALDevDataGet(dev,
johnAlexander 14:8320b5ff96fa 4802 UseInternalTuningSettings);
johnAlexander 14:8320b5ff96fa 4803
Davidroid 16:27d3d95c8593 4804 if (use_internal_tuning_settings == 0) {
johnAlexander 14:8320b5ff96fa 4805 p_tuning_setting_buffer = PALDevDataGet(dev,
johnAlexander 14:8320b5ff96fa 4806 pTuningSettingsPointer);
Davidroid 16:27d3d95c8593 4807 } else {
johnAlexander 14:8320b5ff96fa 4808 p_tuning_setting_buffer = DefaultTuningSettings;
Davidroid 16:27d3d95c8593 4809 }
johnAlexander 14:8320b5ff96fa 4810
johnAlexander 14:8320b5ff96fa 4811 }
johnAlexander 14:8320b5ff96fa 4812
Davidroid 16:27d3d95c8593 4813 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4814 status = VL53L0X_load_tuning_settings(dev, p_tuning_setting_buffer);
Davidroid 16:27d3d95c8593 4815 }
johnAlexander 14:8320b5ff96fa 4816
johnAlexander 14:8320b5ff96fa 4817
johnAlexander 14:8320b5ff96fa 4818 /* Set interrupt config to new sample ready */
johnAlexander 14:8320b5ff96fa 4819 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4820 status = VL53L0X_set_gpio_config(dev, 0, 0,
johnAlexander 14:8320b5ff96fa 4821 VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY,
johnAlexander 14:8320b5ff96fa 4822 VL53L0X_INTERRUPTPOLARITY_LOW);
johnAlexander 14:8320b5ff96fa 4823 }
johnAlexander 14:8320b5ff96fa 4824
johnAlexander 14:8320b5ff96fa 4825 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4826 status = VL53L0X_write_byte(dev, 0xFF, 0x01);
Davidroid 16:27d3d95c8593 4827 status |= VL53L0X_read_word(dev, 0x84, &tempword);
Davidroid 16:27d3d95c8593 4828 status |= VL53L0X_write_byte(dev, 0xFF, 0x00);
johnAlexander 14:8320b5ff96fa 4829 }
johnAlexander 14:8320b5ff96fa 4830
johnAlexander 14:8320b5ff96fa 4831 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 4832 VL53L0X_SETDEVICESPECIFICPARAMETER(dev, OscFrequencyMHz,
johnAlexander 14:8320b5ff96fa 4833 VL53L0X_FIXPOINT412TOFIXPOINT1616(tempword));
johnAlexander 14:8320b5ff96fa 4834 }
johnAlexander 14:8320b5ff96fa 4835
johnAlexander 14:8320b5ff96fa 4836 /* After static init, some device parameters may be changed,
johnAlexander 14:8320b5ff96fa 4837 * so update them */
Davidroid 16:27d3d95c8593 4838 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4839 status = VL53L0X_get_device_parameters(dev, &current_parameters);
Davidroid 16:27d3d95c8593 4840 }
johnAlexander 14:8320b5ff96fa 4841
johnAlexander 14:8320b5ff96fa 4842
johnAlexander 14:8320b5ff96fa 4843 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4844 status = VL53L0X_get_fraction_enable(dev, &tempbyte);
johnAlexander 14:8320b5ff96fa 4845 if (status == VL53L0X_ERROR_NONE)
johnAlexander 14:8320b5ff96fa 4846 PALDevDataSet(dev, RangeFractionalEnable, tempbyte);
johnAlexander 14:8320b5ff96fa 4847
johnAlexander 14:8320b5ff96fa 4848 }
johnAlexander 14:8320b5ff96fa 4849
Davidroid 16:27d3d95c8593 4850 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 4851 PALDevDataSet(dev, CurrentParameters, current_parameters);
Davidroid 16:27d3d95c8593 4852 }
johnAlexander 14:8320b5ff96fa 4853
johnAlexander 14:8320b5ff96fa 4854
johnAlexander 14:8320b5ff96fa 4855 /* read the sequence config and save it */
johnAlexander 14:8320b5ff96fa 4856 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4857 status = VL53L0X_read_byte(dev,
johnAlexander 14:8320b5ff96fa 4858 VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &tempbyte);
Davidroid 16:27d3d95c8593 4859 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 4860 PALDevDataSet(dev, SequenceConfig, tempbyte);
Davidroid 16:27d3d95c8593 4861 }
johnAlexander 14:8320b5ff96fa 4862 }
johnAlexander 14:8320b5ff96fa 4863
johnAlexander 14:8320b5ff96fa 4864 /* Disable MSRC and TCC by default */
Davidroid 16:27d3d95c8593 4865 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4866 status = VL53L0X_set_sequence_step_enable(dev,
johnAlexander 14:8320b5ff96fa 4867 VL53L0X_SEQUENCESTEP_TCC, 0);
Davidroid 16:27d3d95c8593 4868 }
Davidroid 16:27d3d95c8593 4869
Davidroid 16:27d3d95c8593 4870 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4871 status = VL53L0X_set_sequence_step_enable(dev,
johnAlexander 14:8320b5ff96fa 4872 VL53L0X_SEQUENCESTEP_MSRC, 0);
Davidroid 16:27d3d95c8593 4873 }
johnAlexander 14:8320b5ff96fa 4874
johnAlexander 14:8320b5ff96fa 4875 /* Set PAL State to standby */
Davidroid 16:27d3d95c8593 4876 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 4877 PALDevDataSet(dev, PalState, VL53L0X_STATE_IDLE);
Davidroid 16:27d3d95c8593 4878 }
johnAlexander 14:8320b5ff96fa 4879
johnAlexander 14:8320b5ff96fa 4880 /* Store pre-range vcsel period */
johnAlexander 14:8320b5ff96fa 4881 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4882 status = VL53L0X_get_vcsel_pulse_period(
johnAlexander 14:8320b5ff96fa 4883 dev,
johnAlexander 14:8320b5ff96fa 4884 VL53L0X_VCSEL_PERIOD_PRE_RANGE,
johnAlexander 14:8320b5ff96fa 4885 &vcsel_pulse_period_pclk);
johnAlexander 14:8320b5ff96fa 4886 }
johnAlexander 14:8320b5ff96fa 4887
johnAlexander 14:8320b5ff96fa 4888 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 4889 VL53L0X_SETDEVICESPECIFICPARAMETER(
johnAlexander 14:8320b5ff96fa 4890 dev,
johnAlexander 14:8320b5ff96fa 4891 PreRangeVcselPulsePeriod,
johnAlexander 14:8320b5ff96fa 4892 vcsel_pulse_period_pclk);
johnAlexander 14:8320b5ff96fa 4893 }
johnAlexander 14:8320b5ff96fa 4894
johnAlexander 14:8320b5ff96fa 4895 /* Store final-range vcsel period */
johnAlexander 14:8320b5ff96fa 4896 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4897 status = VL53L0X_get_vcsel_pulse_period(
johnAlexander 14:8320b5ff96fa 4898 dev,
johnAlexander 14:8320b5ff96fa 4899 VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
johnAlexander 14:8320b5ff96fa 4900 &vcsel_pulse_period_pclk);
johnAlexander 14:8320b5ff96fa 4901 }
johnAlexander 14:8320b5ff96fa 4902
johnAlexander 14:8320b5ff96fa 4903 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 4904 VL53L0X_SETDEVICESPECIFICPARAMETER(
johnAlexander 14:8320b5ff96fa 4905 dev,
johnAlexander 14:8320b5ff96fa 4906 FinalRangeVcselPulsePeriod,
johnAlexander 14:8320b5ff96fa 4907 vcsel_pulse_period_pclk);
johnAlexander 14:8320b5ff96fa 4908 }
johnAlexander 14:8320b5ff96fa 4909
johnAlexander 14:8320b5ff96fa 4910 /* Store pre-range timeout */
johnAlexander 14:8320b5ff96fa 4911 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 4912 status = get_sequence_step_timeout(
johnAlexander 14:8320b5ff96fa 4913 dev,
johnAlexander 14:8320b5ff96fa 4914 VL53L0X_SEQUENCESTEP_PRE_RANGE,
johnAlexander 14:8320b5ff96fa 4915 &seq_timeout_micro_secs);
johnAlexander 14:8320b5ff96fa 4916 }
johnAlexander 14:8320b5ff96fa 4917
johnAlexander 14:8320b5ff96fa 4918 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 4919 VL53L0X_SETDEVICESPECIFICPARAMETER(
johnAlexander 14:8320b5ff96fa 4920 dev,
johnAlexander 14:8320b5ff96fa 4921 PreRangeTimeoutMicroSecs,
johnAlexander 14:8320b5ff96fa 4922 seq_timeout_micro_secs);
johnAlexander 14:8320b5ff96fa 4923 }
johnAlexander 14:8320b5ff96fa 4924
johnAlexander 14:8320b5ff96fa 4925 /* Store final-range timeout */
johnAlexander 14:8320b5ff96fa 4926 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 4927 status = get_sequence_step_timeout(
johnAlexander 14:8320b5ff96fa 4928 dev,
johnAlexander 14:8320b5ff96fa 4929 VL53L0X_SEQUENCESTEP_FINAL_RANGE,
johnAlexander 14:8320b5ff96fa 4930 &seq_timeout_micro_secs);
johnAlexander 14:8320b5ff96fa 4931 }
johnAlexander 14:8320b5ff96fa 4932
johnAlexander 14:8320b5ff96fa 4933 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 4934 VL53L0X_SETDEVICESPECIFICPARAMETER(
johnAlexander 14:8320b5ff96fa 4935 dev,
johnAlexander 14:8320b5ff96fa 4936 FinalRangeTimeoutMicroSecs,
johnAlexander 14:8320b5ff96fa 4937 seq_timeout_micro_secs);
johnAlexander 14:8320b5ff96fa 4938 }
johnAlexander 14:8320b5ff96fa 4939
johnAlexander 14:8320b5ff96fa 4940 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 4941 return status;
johnAlexander 0:c523920bcc09 4942 }
johnAlexander 0:c523920bcc09 4943
johnAlexander 0:c523920bcc09 4944
Davidroid 16:27d3d95c8593 4945 VL53L0X_Error VL53L0X::VL53L0X_stop_measurement(VL53L0X_DEV dev)
johnAlexander 0:c523920bcc09 4946 {
johnAlexander 14:8320b5ff96fa 4947 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 4948 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 4949
Davidroid 16:27d3d95c8593 4950 status = VL53L0X_write_byte(dev, VL53L0X_REG_SYSRANGE_START,
johnAlexander 14:8320b5ff96fa 4951 VL53L0X_REG_SYSRANGE_MODE_SINGLESHOT);
johnAlexander 14:8320b5ff96fa 4952
Davidroid 16:27d3d95c8593 4953 status = VL53L0X_write_byte(dev, 0xFF, 0x01);
Davidroid 16:27d3d95c8593 4954 status = VL53L0X_write_byte(dev, 0x00, 0x00);
Davidroid 16:27d3d95c8593 4955 status = VL53L0X_write_byte(dev, 0x91, 0x00);
Davidroid 16:27d3d95c8593 4956 status = VL53L0X_write_byte(dev, 0x00, 0x01);
Davidroid 16:27d3d95c8593 4957 status = VL53L0X_write_byte(dev, 0xFF, 0x00);
johnAlexander 14:8320b5ff96fa 4958
johnAlexander 14:8320b5ff96fa 4959 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 4960 /* Set PAL State to Idle */
johnAlexander 14:8320b5ff96fa 4961 PALDevDataSet(dev, PalState, VL53L0X_STATE_IDLE);
johnAlexander 14:8320b5ff96fa 4962 }
johnAlexander 14:8320b5ff96fa 4963
johnAlexander 14:8320b5ff96fa 4964 /* Check if need to apply interrupt settings */
Davidroid 16:27d3d95c8593 4965 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4966 status = VL53L0X_check_and_load_interrupt_settings(dev, 0);
Davidroid 16:27d3d95c8593 4967 }
johnAlexander 14:8320b5ff96fa 4968
johnAlexander 14:8320b5ff96fa 4969 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 4970 return status;
johnAlexander 0:c523920bcc09 4971 }
johnAlexander 0:c523920bcc09 4972
Davidroid 16:27d3d95c8593 4973 VL53L0X_Error VL53L0X::VL53L0X_get_stop_completed_status(VL53L0X_DEV dev,
johnAlexander 14:8320b5ff96fa 4974 uint32_t *p_stop_status)
johnAlexander 0:c523920bcc09 4975 {
johnAlexander 14:8320b5ff96fa 4976 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 4977 uint8_t byte = 0;
johnAlexander 14:8320b5ff96fa 4978 LOG_FUNCTION_START("");
johnAlexander 14:8320b5ff96fa 4979
Davidroid 16:27d3d95c8593 4980 status = VL53L0X_write_byte(dev, 0xFF, 0x01);
Davidroid 16:27d3d95c8593 4981
Davidroid 16:27d3d95c8593 4982 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4983 status = VL53L0X_read_byte(dev, 0x04, &byte);
Davidroid 16:27d3d95c8593 4984 }
Davidroid 16:27d3d95c8593 4985
Davidroid 16:27d3d95c8593 4986 if (status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 4987 status = VL53L0X_write_byte(dev, 0xFF, 0x0);
Davidroid 16:27d3d95c8593 4988 }
johnAlexander 14:8320b5ff96fa 4989
johnAlexander 14:8320b5ff96fa 4990 *p_stop_status = byte;
johnAlexander 14:8320b5ff96fa 4991
johnAlexander 14:8320b5ff96fa 4992 if (byte == 0) {
Davidroid 16:27d3d95c8593 4993 status = VL53L0X_write_byte(dev, 0x80, 0x01);
Davidroid 16:27d3d95c8593 4994 status = VL53L0X_write_byte(dev, 0xFF, 0x01);
Davidroid 16:27d3d95c8593 4995 status = VL53L0X_write_byte(dev, 0x00, 0x00);
Davidroid 16:27d3d95c8593 4996 status = VL53L0X_write_byte(dev, 0x91,
johnAlexander 14:8320b5ff96fa 4997 PALDevDataGet(dev, StopVariable));
Davidroid 16:27d3d95c8593 4998 status = VL53L0X_write_byte(dev, 0x00, 0x01);
Davidroid 16:27d3d95c8593 4999 status = VL53L0X_write_byte(dev, 0xFF, 0x00);
Davidroid 16:27d3d95c8593 5000 status = VL53L0X_write_byte(dev, 0x80, 0x00);
johnAlexander 14:8320b5ff96fa 5001 }
johnAlexander 14:8320b5ff96fa 5002
johnAlexander 14:8320b5ff96fa 5003 LOG_FUNCTION_END(status);
johnAlexander 14:8320b5ff96fa 5004 return status;
johnAlexander 0:c523920bcc09 5005 }
johnAlexander 0:c523920bcc09 5006
johnAlexander 0:c523920bcc09 5007 /****************** Write and read functions from I2C *************************/
johnAlexander 0:c523920bcc09 5008
Davidroid 16:27d3d95c8593 5009 VL53L0X_Error VL53L0X::VL53L0X_write_multi(VL53L0X_DEV dev, uint8_t index, uint8_t *p_data, uint32_t count)
johnAlexander 0:c523920bcc09 5010 {
johnAlexander 14:8320b5ff96fa 5011 int status;
johnAlexander 14:8320b5ff96fa 5012
Davidroid 16:27d3d95c8593 5013 status = VL53L0X_i2c_write(dev->I2cDevAddr, index, p_data, (uint16_t)count);
johnAlexander 14:8320b5ff96fa 5014 return status;
johnAlexander 0:c523920bcc09 5015 }
johnAlexander 0:c523920bcc09 5016
Davidroid 16:27d3d95c8593 5017 VL53L0X_Error VL53L0X::VL53L0X_read_multi(VL53L0X_DEV dev, uint8_t index, uint8_t *p_data, uint32_t count)
johnAlexander 0:c523920bcc09 5018 {
johnAlexander 0:c523920bcc09 5019 int status;
johnAlexander 0:c523920bcc09 5020
johnAlexander 14:8320b5ff96fa 5021 if (count >= VL53L0X_MAX_I2C_XFER_SIZE) {
johnAlexander 0:c523920bcc09 5022 status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander 0:c523920bcc09 5023 }
johnAlexander 0:c523920bcc09 5024
Davidroid 16:27d3d95c8593 5025 status = VL53L0X_i2c_read(dev->I2cDevAddr, index, p_data, (uint16_t)count);
johnAlexander 0:c523920bcc09 5026
johnAlexander 0:c523920bcc09 5027 return status;
johnAlexander 0:c523920bcc09 5028 }
johnAlexander 0:c523920bcc09 5029
johnAlexander 0:c523920bcc09 5030
Davidroid 16:27d3d95c8593 5031 VL53L0X_Error VL53L0X::VL53L0X_write_byte(VL53L0X_DEV Dev, uint8_t index, uint8_t data)
johnAlexander 0:c523920bcc09 5032 {
johnAlexander 14:8320b5ff96fa 5033 int status;
johnAlexander 14:8320b5ff96fa 5034
Davidroid 16:27d3d95c8593 5035 status = VL53L0X_i2c_write(Dev->I2cDevAddr, index, &data, 1);
johnAlexander 14:8320b5ff96fa 5036 return status;
johnAlexander 0:c523920bcc09 5037 }
johnAlexander 14:8320b5ff96fa 5038
Davidroid 16:27d3d95c8593 5039 VL53L0X_Error VL53L0X::VL53L0X_write_word(VL53L0X_DEV dev, uint8_t index, uint16_t data)
johnAlexander 0:c523920bcc09 5040 {
johnAlexander 14:8320b5ff96fa 5041 int status;
johnAlexander 14:8320b5ff96fa 5042 uint8_t buffer[2];
johnAlexander 14:8320b5ff96fa 5043
johnAlexander 14:8320b5ff96fa 5044 buffer[0] = data >> 8;
johnAlexander 14:8320b5ff96fa 5045 buffer[1] = data & 0x00FF;
Davidroid 16:27d3d95c8593 5046 status = VL53L0X_i2c_write(dev->I2cDevAddr, index, (uint8_t *)buffer, 2);
johnAlexander 14:8320b5ff96fa 5047 return status;
johnAlexander 0:c523920bcc09 5048 }
johnAlexander 14:8320b5ff96fa 5049
Davidroid 16:27d3d95c8593 5050 VL53L0X_Error VL53L0X::VL53L0X_write_dword(VL53L0X_DEV Dev, uint8_t index, uint32_t data)
johnAlexander 0:c523920bcc09 5051 {
johnAlexander 14:8320b5ff96fa 5052 int status;
johnAlexander 14:8320b5ff96fa 5053 uint8_t buffer[4];
johnAlexander 14:8320b5ff96fa 5054
johnAlexander 14:8320b5ff96fa 5055 buffer[0] = (data >> 24) & 0xFF;
johnAlexander 14:8320b5ff96fa 5056 buffer[1] = (data >> 16) & 0xFF;
johnAlexander 14:8320b5ff96fa 5057 buffer[2] = (data >> 8) & 0xFF;
johnAlexander 14:8320b5ff96fa 5058 buffer[3] = (data >> 0) & 0xFF;
Davidroid 16:27d3d95c8593 5059 status = VL53L0X_i2c_write(Dev->I2cDevAddr, index, (uint8_t *)buffer, 4);
johnAlexander 14:8320b5ff96fa 5060 return status;
johnAlexander 0:c523920bcc09 5061 }
johnAlexander 0:c523920bcc09 5062
johnAlexander 0:c523920bcc09 5063
Davidroid 16:27d3d95c8593 5064 VL53L0X_Error VL53L0X::VL53L0X_read_byte(VL53L0X_DEV Dev, uint8_t index, uint8_t *p_data)
johnAlexander 0:c523920bcc09 5065 {
johnAlexander 14:8320b5ff96fa 5066 int status;
johnAlexander 14:8320b5ff96fa 5067
Davidroid 16:27d3d95c8593 5068 status = VL53L0X_i2c_read(Dev->I2cDevAddr, index, p_data, 1);
johnAlexander 14:8320b5ff96fa 5069
johnAlexander 14:8320b5ff96fa 5070 if (status)
johnAlexander 14:8320b5ff96fa 5071 return -1;
johnAlexander 14:8320b5ff96fa 5072
johnAlexander 14:8320b5ff96fa 5073 return 0;
johnAlexander 0:c523920bcc09 5074 }
johnAlexander 14:8320b5ff96fa 5075
Davidroid 16:27d3d95c8593 5076 VL53L0X_Error VL53L0X::VL53L0X_read_word(VL53L0X_DEV Dev, uint8_t index, uint16_t *p_data)
johnAlexander 0:c523920bcc09 5077 {
johnAlexander 14:8320b5ff96fa 5078 int status;
johnAlexander 14:8320b5ff96fa 5079 uint8_t buffer[2] = {0, 0};
johnAlexander 14:8320b5ff96fa 5080
Davidroid 16:27d3d95c8593 5081 status = VL53L0X_i2c_read(Dev->I2cDevAddr, index, buffer, 2);
johnAlexander 14:8320b5ff96fa 5082 if (!status) {
johnAlexander 14:8320b5ff96fa 5083 *p_data = (buffer[0] << 8) + buffer[1];
johnAlexander 14:8320b5ff96fa 5084 }
johnAlexander 14:8320b5ff96fa 5085 return status;
johnAlexander 0:c523920bcc09 5086
johnAlexander 0:c523920bcc09 5087 }
johnAlexander 14:8320b5ff96fa 5088
Davidroid 16:27d3d95c8593 5089 VL53L0X_Error VL53L0X::VL53L0X_read_dword(VL53L0X_DEV Dev, uint8_t index, uint32_t *p_data)
johnAlexander 0:c523920bcc09 5090 {
johnAlexander 14:8320b5ff96fa 5091 int status;
johnAlexander 14:8320b5ff96fa 5092 uint8_t buffer[4] = {0, 0, 0, 0};
johnAlexander 14:8320b5ff96fa 5093
Davidroid 16:27d3d95c8593 5094 status = VL53L0X_i2c_read(Dev->I2cDevAddr, index, buffer, 4);
johnAlexander 14:8320b5ff96fa 5095 if (!status) {
johnAlexander 14:8320b5ff96fa 5096 *p_data = (buffer[0] << 24) + (buffer[1] << 16) + (buffer[2] << 8) + buffer[3];
johnAlexander 14:8320b5ff96fa 5097 }
johnAlexander 14:8320b5ff96fa 5098 return status;
johnAlexander 0:c523920bcc09 5099
johnAlexander 0:c523920bcc09 5100 }
johnAlexander 0:c523920bcc09 5101
Davidroid 16:27d3d95c8593 5102 VL53L0X_Error VL53L0X::VL53L0X_update_byte(VL53L0X_DEV Dev, uint8_t index, uint8_t and_data, uint8_t or_data)
johnAlexander 0:c523920bcc09 5103 {
johnAlexander 14:8320b5ff96fa 5104 int status;
johnAlexander 14:8320b5ff96fa 5105 uint8_t buffer = 0;
johnAlexander 14:8320b5ff96fa 5106
johnAlexander 14:8320b5ff96fa 5107 /* read data direct onto buffer */
Davidroid 16:27d3d95c8593 5108 status = VL53L0X_i2c_read(Dev->I2cDevAddr, index, &buffer, 1);
johnAlexander 14:8320b5ff96fa 5109 if (!status) {
johnAlexander 14:8320b5ff96fa 5110 buffer = (buffer & and_data) | or_data;
Davidroid 16:27d3d95c8593 5111 status = VL53L0X_i2c_write(Dev->I2cDevAddr, index, &buffer, (uint8_t)1);
johnAlexander 14:8320b5ff96fa 5112 }
johnAlexander 14:8320b5ff96fa 5113 return status;
johnAlexander 0:c523920bcc09 5114 }
johnAlexander 14:8320b5ff96fa 5115
Davidroid 16:27d3d95c8593 5116 VL53L0X_Error VL53L0X::VL53L0X_i2c_write(uint8_t DeviceAddr, uint8_t RegisterAddr, uint8_t *p_data,
johnAlexander 14:8320b5ff96fa 5117 uint16_t NumByteToWrite)
johnAlexander 0:c523920bcc09 5118 {
johnAlexander 14:8320b5ff96fa 5119 int ret;
johnAlexander 14:8320b5ff96fa 5120
Davidroid 16:27d3d95c8593 5121 ret = _dev_i2c->i2c_write(p_data, DeviceAddr, RegisterAddr, NumByteToWrite);
Davidroid 16:27d3d95c8593 5122
Davidroid 16:27d3d95c8593 5123 if (ret) {
johnAlexander 14:8320b5ff96fa 5124 return -1;
Davidroid 16:27d3d95c8593 5125 }
johnAlexander 14:8320b5ff96fa 5126 return 0;
johnAlexander 0:c523920bcc09 5127 }
johnAlexander 14:8320b5ff96fa 5128
Davidroid 16:27d3d95c8593 5129 VL53L0X_Error VL53L0X::VL53L0X_i2c_read(uint8_t DeviceAddr, uint8_t RegisterAddr, uint8_t *p_data,
johnAlexander 14:8320b5ff96fa 5130 uint16_t NumByteToRead)
johnAlexander 0:c523920bcc09 5131 {
johnAlexander 14:8320b5ff96fa 5132 int ret;
johnAlexander 14:8320b5ff96fa 5133
Davidroid 16:27d3d95c8593 5134 ret = _dev_i2c->i2c_read(p_data, DeviceAddr, RegisterAddr, NumByteToRead);
Davidroid 16:27d3d95c8593 5135
Davidroid 16:27d3d95c8593 5136 if (ret) {
johnAlexander 14:8320b5ff96fa 5137 return -1;
Davidroid 16:27d3d95c8593 5138 }
johnAlexander 14:8320b5ff96fa 5139 return 0;
johnAlexander 14:8320b5ff96fa 5140 }
johnAlexander 0:c523920bcc09 5141
JerrySzczurak 11:ceaa5a026412 5142 int VL53L0X::read_id(uint8_t *id)
johnAlexander 0:c523920bcc09 5143 {
johnAlexander 0:c523920bcc09 5144 int status = 0;
johnAlexander 14:8320b5ff96fa 5145 uint16_t rl_id = 0;
johnAlexander 14:8320b5ff96fa 5146
Davidroid 16:27d3d95c8593 5147 status = VL53L0X_read_word(_device, VL53L0X_REG_IDENTIFICATION_MODEL_ID, &rl_id);
Davidroid 16:27d3d95c8593 5148 if (rl_id == 0xEEAA) {
johnAlexander 0:c523920bcc09 5149 return status;
Davidroid 16:27d3d95c8593 5150 }
johnAlexander 14:8320b5ff96fa 5151
johnAlexander 0:c523920bcc09 5152 return -1;
johnAlexander 0:c523920bcc09 5153 }
JerrySzczurak 11:ceaa5a026412 5154
johnAlexander 14:8320b5ff96fa 5155
johnAlexander 14:8320b5ff96fa 5156 VL53L0X_Error VL53L0X::wait_measurement_data_ready(VL53L0X_DEV dev)
JerrySzczurak 11:ceaa5a026412 5157 {
johnAlexander 14:8320b5ff96fa 5158 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 5159 uint8_t new_dat_ready = 0;
johnAlexander 14:8320b5ff96fa 5160 uint32_t loop_nb;
johnAlexander 0:c523920bcc09 5161
johnAlexander 0:c523920bcc09 5162 // Wait until it finished
johnAlexander 0:c523920bcc09 5163 // use timeout to avoid deadlock
johnAlexander 14:8320b5ff96fa 5164 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 5165 loop_nb = 0;
johnAlexander 0:c523920bcc09 5166 do {
Davidroid 16:27d3d95c8593 5167 status = VL53L0X_get_measurement_data_ready(dev, &new_dat_ready);
johnAlexander 14:8320b5ff96fa 5168 if ((new_dat_ready == 0x01) || status != VL53L0X_ERROR_NONE) {
johnAlexander 0:c523920bcc09 5169 break;
johnAlexander 0:c523920bcc09 5170 }
johnAlexander 14:8320b5ff96fa 5171 loop_nb = loop_nb + 1;
Davidroid 16:27d3d95c8593 5172 VL53L0X_polling_delay(dev);
johnAlexander 14:8320b5ff96fa 5173 } while (loop_nb < VL53L0X_DEFAULT_MAX_LOOP);
johnAlexander 14:8320b5ff96fa 5174
johnAlexander 14:8320b5ff96fa 5175 if (loop_nb >= VL53L0X_DEFAULT_MAX_LOOP) {
johnAlexander 14:8320b5ff96fa 5176 status = VL53L0X_ERROR_TIME_OUT;
johnAlexander 0:c523920bcc09 5177 }
johnAlexander 0:c523920bcc09 5178 }
johnAlexander 0:c523920bcc09 5179
johnAlexander 14:8320b5ff96fa 5180 return status;
johnAlexander 0:c523920bcc09 5181 }
johnAlexander 0:c523920bcc09 5182
johnAlexander 14:8320b5ff96fa 5183 VL53L0X_Error VL53L0X::wait_stop_completed(VL53L0X_DEV dev)
johnAlexander 0:c523920bcc09 5184 {
johnAlexander 14:8320b5ff96fa 5185 VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander 14:8320b5ff96fa 5186 uint32_t stop_completed = 0;
johnAlexander 14:8320b5ff96fa 5187 uint32_t loop_nb;
johnAlexander 0:c523920bcc09 5188
johnAlexander 0:c523920bcc09 5189 // Wait until it finished
johnAlexander 0:c523920bcc09 5190 // use timeout to avoid deadlock
johnAlexander 14:8320b5ff96fa 5191 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 5192 loop_nb = 0;
johnAlexander 0:c523920bcc09 5193 do {
Davidroid 16:27d3d95c8593 5194 status = VL53L0X_get_stop_completed_status(dev, &stop_completed);
johnAlexander 14:8320b5ff96fa 5195 if ((stop_completed == 0x00) || status != VL53L0X_ERROR_NONE) {
johnAlexander 0:c523920bcc09 5196 break;
johnAlexander 0:c523920bcc09 5197 }
johnAlexander 14:8320b5ff96fa 5198 loop_nb = loop_nb + 1;
Davidroid 16:27d3d95c8593 5199 VL53L0X_polling_delay(dev);
johnAlexander 14:8320b5ff96fa 5200 } while (loop_nb < VL53L0X_DEFAULT_MAX_LOOP);
johnAlexander 14:8320b5ff96fa 5201
johnAlexander 14:8320b5ff96fa 5202 if (loop_nb >= VL53L0X_DEFAULT_MAX_LOOP) {
johnAlexander 14:8320b5ff96fa 5203 status = VL53L0X_ERROR_TIME_OUT;
johnAlexander 0:c523920bcc09 5204 }
johnAlexander 0:c523920bcc09 5205
johnAlexander 0:c523920bcc09 5206 }
johnAlexander 0:c523920bcc09 5207
johnAlexander 14:8320b5ff96fa 5208 return status;
johnAlexander 0:c523920bcc09 5209 }
johnAlexander 0:c523920bcc09 5210
johnAlexander 0:c523920bcc09 5211
johnAlexander 14:8320b5ff96fa 5212 int VL53L0X::init_sensor(uint8_t new_addr)
johnAlexander 0:c523920bcc09 5213 {
johnAlexander 14:8320b5ff96fa 5214 int status;
johnAlexander 14:8320b5ff96fa 5215
Davidroid 16:27d3d95c8593 5216 VL53L0X_off();
Davidroid 16:27d3d95c8593 5217 VL53L0X_on();
johnAlexander 0:c523920bcc09 5218
johnAlexander 0:c523920bcc09 5219 // status=VL53L0X_WaitDeviceBooted(Device);
johnAlexander 0:c523920bcc09 5220 // if(status)
johnAlexander 0:c523920bcc09 5221 // printf("WaitDeviceBooted fail\n\r");
johnAlexander 14:8320b5ff96fa 5222 status = is_present();
johnAlexander 14:8320b5ff96fa 5223 if (!status) {
johnAlexander 14:8320b5ff96fa 5224 status = init(&_my_device);
johnAlexander 14:8320b5ff96fa 5225 if (status != VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 5226 printf("Failed to init VL53L0X sensor!\n\r");
johnAlexander 14:8320b5ff96fa 5227 return status;
johnAlexander 14:8320b5ff96fa 5228 }
johnAlexander 14:8320b5ff96fa 5229
johnAlexander 14:8320b5ff96fa 5230 // deduce silicon version
Davidroid 16:27d3d95c8593 5231 status = VL53L0X_get_device_info(&_my_device, &_device_info);
johnAlexander 14:8320b5ff96fa 5232
johnAlexander 14:8320b5ff96fa 5233 status = prepare();
johnAlexander 14:8320b5ff96fa 5234 if (status != VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 5235 printf("Failed to prepare VL53L0X!\n\r");
johnAlexander 0:c523920bcc09 5236 return status;
johnAlexander 14:8320b5ff96fa 5237 }
johnAlexander 14:8320b5ff96fa 5238
johnAlexander 14:8320b5ff96fa 5239 if (new_addr != DEFAULT_DEVICE_ADDRESS) {
johnAlexander 14:8320b5ff96fa 5240 status = set_device_address(new_addr);
johnAlexander 14:8320b5ff96fa 5241 if (status) {
johnAlexander 14:8320b5ff96fa 5242 printf("Failed to change I2C address!\n\r");
johnAlexander 14:8320b5ff96fa 5243 return status;
johnAlexander 14:8320b5ff96fa 5244 }
johnAlexander 14:8320b5ff96fa 5245 } else {
johnAlexander 14:8320b5ff96fa 5246 printf("Invalid new address!\n\r");
johnAlexander 14:8320b5ff96fa 5247 return VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander 14:8320b5ff96fa 5248 }
johnAlexander 14:8320b5ff96fa 5249 }
johnAlexander 14:8320b5ff96fa 5250 return status;
johnAlexander 0:c523920bcc09 5251 }
johnAlexander 12:f6e2bad00dc7 5252
johnAlexander 14:8320b5ff96fa 5253 int VL53L0X::range_meas_int_continuous_mode(void (*fptr)(void))
johnAlexander 12:f6e2bad00dc7 5254 {
johnAlexander 14:8320b5ff96fa 5255 int status, clr_status;
johnAlexander 14:8320b5ff96fa 5256
Davidroid 16:27d3d95c8593 5257 status = VL53L0X_stop_measurement(_device); // it is safer to do this while sensor is stopped
johnAlexander 13:615f7e38568c 5258
johnAlexander 13:615f7e38568c 5259 // status = VL53L0X_SetInterruptThresholds(Device, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING, 0, 300);
johnAlexander 13:615f7e38568c 5260
Davidroid 16:27d3d95c8593 5261 status = VL53L0X_set_gpio_config(_device, 0, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
johnAlexander 14:8320b5ff96fa 5262 VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY,
johnAlexander 14:8320b5ff96fa 5263 VL53L0X_INTERRUPTPOLARITY_HIGH);
johnAlexander 14:8320b5ff96fa 5264
johnAlexander 14:8320b5ff96fa 5265 if (!status) {
johnAlexander 14:8320b5ff96fa 5266 attach_interrupt_measure_detection_irq(fptr);
johnAlexander 14:8320b5ff96fa 5267 enable_interrupt_measure_detection_irq();
johnAlexander 14:8320b5ff96fa 5268 }
johnAlexander 14:8320b5ff96fa 5269
johnAlexander 14:8320b5ff96fa 5270 clr_status = clear_interrupt(VL53L0X_REG_RESULT_INTERRUPT_STATUS | VL53L0X_REG_RESULT_RANGE_STATUS);
Davidroid 16:27d3d95c8593 5271 if (clr_status) {
johnAlexander 14:8320b5ff96fa 5272 VL53L0X_ErrLog("VL53L0X_ClearErrorInterrupt fail\r\n");
Davidroid 16:27d3d95c8593 5273 }
johnAlexander 14:8320b5ff96fa 5274
johnAlexander 14:8320b5ff96fa 5275 if (!status) {
johnAlexander 14:8320b5ff96fa 5276 status = range_start_continuous_mode();
johnAlexander 14:8320b5ff96fa 5277 }
johnAlexander 14:8320b5ff96fa 5278 return status;
johnAlexander 12:f6e2bad00dc7 5279 }
johnAlexander 0:c523920bcc09 5280
johnAlexander 0:c523920bcc09 5281
johnAlexander 14:8320b5ff96fa 5282 int VL53L0X::start_measurement(OperatingMode operating_mode, void (*fptr)(void))
johnAlexander 0:c523920bcc09 5283 {
johnAlexander 0:c523920bcc09 5284 int Status = VL53L0X_ERROR_NONE;
johnAlexander 13:615f7e38568c 5285 int ClrStatus;
johnAlexander 0:c523920bcc09 5286
johnAlexander 0:c523920bcc09 5287 uint8_t VhvSettings;
johnAlexander 0:c523920bcc09 5288 uint8_t PhaseCal;
johnAlexander 0:c523920bcc09 5289 // *** from mass market cube expansion v1.1, ranging with satellites.
johnAlexander 0:c523920bcc09 5290 // default settings, for normal range.
johnAlexander 14:8320b5ff96fa 5291 FixPoint1616_t signalLimit = (FixPoint1616_t)(0.25 * 65536);
johnAlexander 14:8320b5ff96fa 5292 FixPoint1616_t sigmaLimit = (FixPoint1616_t)(18 * 65536);
johnAlexander 14:8320b5ff96fa 5293 uint32_t timingBudget = 33000;
johnAlexander 14:8320b5ff96fa 5294 uint8_t preRangeVcselPeriod = 14;
johnAlexander 14:8320b5ff96fa 5295 uint8_t finalRangeVcselPeriod = 10;
johnAlexander 14:8320b5ff96fa 5296
johnAlexander 14:8320b5ff96fa 5297 if (operating_mode == range_continuous_interrupt) {
Davidroid 16:27d3d95c8593 5298 if (_gpio1Int == NULL) {
johnAlexander 14:8320b5ff96fa 5299 printf("GPIO1 Error\r\n");
johnAlexander 12:f6e2bad00dc7 5300 return 1;
johnAlexander 12:f6e2bad00dc7 5301 }
johnAlexander 13:615f7e38568c 5302
Davidroid 16:27d3d95c8593 5303 Status = VL53L0X_stop_measurement(_device); // it is safer to do this while sensor is stopped
johnAlexander 13:615f7e38568c 5304
johnAlexander 13:615f7e38568c 5305 // Status = VL53L0X_SetInterruptThresholds(Device, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING, 0, 300);
johnAlexander 13:615f7e38568c 5306
Davidroid 16:27d3d95c8593 5307 Status = VL53L0X_set_gpio_config(_device, 0, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
johnAlexander 14:8320b5ff96fa 5308 VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY,
johnAlexander 14:8320b5ff96fa 5309 VL53L0X_INTERRUPTPOLARITY_HIGH);
johnAlexander 14:8320b5ff96fa 5310
johnAlexander 14:8320b5ff96fa 5311 if (Status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 5312 attach_interrupt_measure_detection_irq(fptr);
johnAlexander 14:8320b5ff96fa 5313 enable_interrupt_measure_detection_irq();
johnAlexander 12:f6e2bad00dc7 5314 }
johnAlexander 13:615f7e38568c 5315
johnAlexander 14:8320b5ff96fa 5316 ClrStatus = clear_interrupt(VL53L0X_REG_RESULT_INTERRUPT_STATUS | VL53L0X_REG_RESULT_RANGE_STATUS);
Davidroid 16:27d3d95c8593 5317 if (ClrStatus) {
johnAlexander 14:8320b5ff96fa 5318 VL53L0X_ErrLog("VL53L0X_ClearErrorInterrupt fail\r\n");
johnAlexander 13:615f7e38568c 5319 }
johnAlexander 13:615f7e38568c 5320
johnAlexander 14:8320b5ff96fa 5321 if (Status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 5322 Status = VL53L0X_set_device_mode(_device, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING); // Setup in continuous ranging mode
Davidroid 16:27d3d95c8593 5323 }
Davidroid 16:27d3d95c8593 5324
Davidroid 16:27d3d95c8593 5325 if (Status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 5326 Status = VL53L0X_start_measurement(_device);
johnAlexander 13:615f7e38568c 5327 }
johnAlexander 12:f6e2bad00dc7 5328 }
johnAlexander 0:c523920bcc09 5329
johnAlexander 14:8320b5ff96fa 5330 if (operating_mode == range_single_shot_polling) {
johnAlexander 0:c523920bcc09 5331 // singelshot, polled ranging
johnAlexander 14:8320b5ff96fa 5332 if (Status == VL53L0X_ERROR_NONE) {
johnAlexander 0:c523920bcc09 5333 // no need to do this when we use VL53L0X_PerformSingleRangingMeasurement
Davidroid 16:27d3d95c8593 5334 Status = VL53L0X_set_device_mode(_device, VL53L0X_DEVICEMODE_SINGLE_RANGING); // Setup in single ranging mode
johnAlexander 0:c523920bcc09 5335 }
johnAlexander 0:c523920bcc09 5336
johnAlexander 0:c523920bcc09 5337 // Enable/Disable Sigma and Signal check
johnAlexander 0:c523920bcc09 5338 if (Status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 5339 Status = VL53L0X_set_limit_check_enable(_device,
johnAlexander 14:8320b5ff96fa 5340 VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, 1);
johnAlexander 0:c523920bcc09 5341 }
johnAlexander 0:c523920bcc09 5342 if (Status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 5343 Status = VL53L0X_set_limit_check_enable(_device,
johnAlexander 14:8320b5ff96fa 5344 VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, 1);
johnAlexander 0:c523920bcc09 5345 }
johnAlexander 0:c523920bcc09 5346
johnAlexander 0:c523920bcc09 5347 // *** from mass market cube expansion v1.1, ranging with satellites.
johnAlexander 14:8320b5ff96fa 5348 /* Ranging configuration */
johnAlexander 0:c523920bcc09 5349 //*
johnAlexander 0:c523920bcc09 5350 // switch(rangingConfig) {
johnAlexander 0:c523920bcc09 5351 // case LONG_RANGE:
johnAlexander 14:8320b5ff96fa 5352 signalLimit = (FixPoint1616_t)(0.1 * 65536);
johnAlexander 14:8320b5ff96fa 5353 sigmaLimit = (FixPoint1616_t)(60 * 65536);
johnAlexander 14:8320b5ff96fa 5354 timingBudget = 33000;
johnAlexander 14:8320b5ff96fa 5355 preRangeVcselPeriod = 18;
johnAlexander 14:8320b5ff96fa 5356 finalRangeVcselPeriod = 14;
johnAlexander 14:8320b5ff96fa 5357 /* break;
johnAlexander 14:8320b5ff96fa 5358 case HIGH_ACCURACY:
johnAlexander 14:8320b5ff96fa 5359 signalLimit = (FixPoint1616_t)(0.25*65536);
johnAlexander 14:8320b5ff96fa 5360 sigmaLimit = (FixPoint1616_t)(18*65536);
johnAlexander 14:8320b5ff96fa 5361 timingBudget = 200000;
johnAlexander 14:8320b5ff96fa 5362 preRangeVcselPeriod = 14;
johnAlexander 14:8320b5ff96fa 5363 finalRangeVcselPeriod = 10;
johnAlexander 14:8320b5ff96fa 5364 break;
johnAlexander 14:8320b5ff96fa 5365 case HIGH_SPEED:
johnAlexander 14:8320b5ff96fa 5366 signalLimit = (FixPoint1616_t)(0.25*65536);
johnAlexander 14:8320b5ff96fa 5367 sigmaLimit = (FixPoint1616_t)(32*65536);
johnAlexander 14:8320b5ff96fa 5368 timingBudget = 20000;
johnAlexander 14:8320b5ff96fa 5369 preRangeVcselPeriod = 14;
johnAlexander 14:8320b5ff96fa 5370 finalRangeVcselPeriod = 10;
johnAlexander 14:8320b5ff96fa 5371 break;
johnAlexander 14:8320b5ff96fa 5372 default:
johnAlexander 14:8320b5ff96fa 5373 debug_printf("Not Supported");
johnAlexander 14:8320b5ff96fa 5374 }
johnAlexander 14:8320b5ff96fa 5375 */
johnAlexander 0:c523920bcc09 5376
johnAlexander 0:c523920bcc09 5377 if (Status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 5378 Status = VL53L0X_set_limit_check_value(_device,
johnAlexander 14:8320b5ff96fa 5379 VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, signalLimit);
johnAlexander 0:c523920bcc09 5380 }
johnAlexander 0:c523920bcc09 5381
johnAlexander 0:c523920bcc09 5382 if (Status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 5383 Status = VL53L0X_set_limit_check_value(_device,
johnAlexander 14:8320b5ff96fa 5384 VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, sigmaLimit);
johnAlexander 14:8320b5ff96fa 5385 }
johnAlexander 14:8320b5ff96fa 5386
johnAlexander 14:8320b5ff96fa 5387 if (Status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 5388 Status = VL53L0X_set_measurement_timing_budget_micro_seconds(_device, timingBudget);
johnAlexander 14:8320b5ff96fa 5389 }
johnAlexander 0:c523920bcc09 5390
johnAlexander 0:c523920bcc09 5391 if (Status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 5392 Status = VL53L0X_set_vcsel_pulse_period(_device,
johnAlexander 14:8320b5ff96fa 5393 VL53L0X_VCSEL_PERIOD_PRE_RANGE, preRangeVcselPeriod);
johnAlexander 14:8320b5ff96fa 5394 }
johnAlexander 0:c523920bcc09 5395
johnAlexander 0:c523920bcc09 5396 if (Status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 5397 Status = VL53L0X_set_vcsel_pulse_period(_device,
johnAlexander 14:8320b5ff96fa 5398 VL53L0X_VCSEL_PERIOD_FINAL_RANGE, finalRangeVcselPeriod);
johnAlexander 14:8320b5ff96fa 5399 }
johnAlexander 14:8320b5ff96fa 5400
johnAlexander 14:8320b5ff96fa 5401 if (Status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 5402 Status = VL53L0X_perform_ref_calibration(_device, &VhvSettings, &PhaseCal);
johnAlexander 14:8320b5ff96fa 5403 }
johnAlexander 0:c523920bcc09 5404
johnAlexander 0:c523920bcc09 5405 }
johnAlexander 0:c523920bcc09 5406
johnAlexander 14:8320b5ff96fa 5407 if (operating_mode == range_continuous_polling) {
johnAlexander 14:8320b5ff96fa 5408 if (Status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 5409 printf("Call of VL53L0X_SetDeviceMode\n");
Davidroid 16:27d3d95c8593 5410 Status = VL53L0X_set_device_mode(_device, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING); // Setup in continuous ranging mode
johnAlexander 0:c523920bcc09 5411 }
johnAlexander 0:c523920bcc09 5412
johnAlexander 14:8320b5ff96fa 5413 if (Status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 5414 printf("Call of VL53L0X_StartMeasurement\n");
Davidroid 16:27d3d95c8593 5415 Status = VL53L0X_start_measurement(_device);
johnAlexander 0:c523920bcc09 5416 }
johnAlexander 0:c523920bcc09 5417 }
johnAlexander 0:c523920bcc09 5418
johnAlexander 0:c523920bcc09 5419 return Status;
johnAlexander 0:c523920bcc09 5420 }
johnAlexander 14:8320b5ff96fa 5421
johnAlexander 14:8320b5ff96fa 5422
johnAlexander 14:8320b5ff96fa 5423 int VL53L0X::get_measurement(OperatingMode operating_mode, VL53L0X_RangingMeasurementData_t *p_data)
johnAlexander 0:c523920bcc09 5424 {
johnAlexander 0:c523920bcc09 5425 int Status = VL53L0X_ERROR_NONE;
johnAlexander 0:c523920bcc09 5426
johnAlexander 14:8320b5ff96fa 5427 if (operating_mode == range_single_shot_polling) {
Davidroid 16:27d3d95c8593 5428 Status = VL53L0X_perform_single_ranging_measurement(_device, p_data);
johnAlexander 0:c523920bcc09 5429 }
johnAlexander 0:c523920bcc09 5430
johnAlexander 14:8320b5ff96fa 5431 if (operating_mode == range_continuous_polling) {
johnAlexander 14:8320b5ff96fa 5432 if (Status == VL53L0X_ERROR_NONE)
Davidroid 16:27d3d95c8593 5433 Status = VL53L0X_measurement_poll_for_completion(_device);
johnAlexander 14:8320b5ff96fa 5434
johnAlexander 14:8320b5ff96fa 5435 if (Status == VL53L0X_ERROR_NONE) {
Davidroid 16:27d3d95c8593 5436 Status = VL53L0X_get_ranging_measurement_data(_device, p_data);
johnAlexander 14:8320b5ff96fa 5437
johnAlexander 14:8320b5ff96fa 5438 // Clear the interrupt
Davidroid 16:27d3d95c8593 5439 VL53L0X_clear_interrupt_mask(_device, VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY);
Davidroid 16:27d3d95c8593 5440 VL53L0X_polling_delay(_device);
johnAlexander 0:c523920bcc09 5441 }
johnAlexander 0:c523920bcc09 5442 }
johnAlexander 0:c523920bcc09 5443
johnAlexander 14:8320b5ff96fa 5444 if (operating_mode == range_continuous_interrupt) {
Davidroid 16:27d3d95c8593 5445 Status = VL53L0X_get_ranging_measurement_data(_device, p_data);
Davidroid 16:27d3d95c8593 5446 VL53L0X_clear_interrupt_mask(_device, VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR | VL53L0X_REG_RESULT_INTERRUPT_STATUS);
johnAlexander 14:8320b5ff96fa 5447 }
johnAlexander 0:c523920bcc09 5448
johnAlexander 0:c523920bcc09 5449 return Status;
johnAlexander 0:c523920bcc09 5450 }
johnAlexander 14:8320b5ff96fa 5451
johnAlexander 14:8320b5ff96fa 5452
johnAlexander 14:8320b5ff96fa 5453 int VL53L0X::stop_measurement(OperatingMode operating_mode)
johnAlexander 0:c523920bcc09 5454 {
johnAlexander 0:c523920bcc09 5455 int status = VL53L0X_ERROR_NONE;
johnAlexander 0:c523920bcc09 5456
johnAlexander 0:c523920bcc09 5457
johnAlexander 14:8320b5ff96fa 5458 // don't need to stop for a singleshot range!
johnAlexander 14:8320b5ff96fa 5459 if (operating_mode == range_single_shot_polling) {
johnAlexander 0:c523920bcc09 5460 }
johnAlexander 0:c523920bcc09 5461
johnAlexander 14:8320b5ff96fa 5462 if (operating_mode == range_continuous_interrupt || operating_mode == range_continuous_polling) {
johnAlexander 14:8320b5ff96fa 5463 // continuous mode
johnAlexander 14:8320b5ff96fa 5464 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 5465 printf("Call of VL53L0X_StopMeasurement\n");
Davidroid 16:27d3d95c8593 5466 status = VL53L0X_stop_measurement(_device);
johnAlexander 0:c523920bcc09 5467 }
johnAlexander 0:c523920bcc09 5468
johnAlexander 14:8320b5ff96fa 5469 if (status == VL53L0X_ERROR_NONE) {
johnAlexander 14:8320b5ff96fa 5470 printf("Wait Stop to be competed\n");
johnAlexander 14:8320b5ff96fa 5471 status = wait_stop_completed(_device);
johnAlexander 0:c523920bcc09 5472 }
johnAlexander 0:c523920bcc09 5473
johnAlexander 14:8320b5ff96fa 5474 if (status == VL53L0X_ERROR_NONE)
Davidroid 16:27d3d95c8593 5475 status = VL53L0X_clear_interrupt_mask(_device,
johnAlexander 14:8320b5ff96fa 5476 VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY);
johnAlexander 0:c523920bcc09 5477 }
johnAlexander 0:c523920bcc09 5478
johnAlexander 0:c523920bcc09 5479 return status;
johnAlexander 0:c523920bcc09 5480 }
johnAlexander 0:c523920bcc09 5481
johnAlexander 0:c523920bcc09 5482
johnAlexander 14:8320b5ff96fa 5483 int VL53L0X::handle_irq(OperatingMode operating_mode, VL53L0X_RangingMeasurementData_t *data)
johnAlexander 0:c523920bcc09 5484 {
johnAlexander 14:8320b5ff96fa 5485 int status;
johnAlexander 14:8320b5ff96fa 5486 status = get_measurement(operating_mode, data);
johnAlexander 14:8320b5ff96fa 5487 enable_interrupt_measure_detection_irq();
johnAlexander 14:8320b5ff96fa 5488 return status;
johnAlexander 0:c523920bcc09 5489 }
johnAlexander 14:8320b5ff96fa 5490
johnAlexander 14:8320b5ff96fa 5491
johnAlexander 0:c523920bcc09 5492 /******************************************************************************/