### Start Continuous Distance Measurement Mode

Source: https://context7.com/pololu/vl53l0x-arduino/llms.txt

Configures the sensor for continuous ranging mode with fast, back-to-back measurements. Supports both fastest possible measurements and timed intervals between readings.

```cpp
#include <Wire.h>
#include <VL53L0X.h>

VL53L0X sensor;

void setup() {
  Serial.begin(9600);
  Wire.begin();

  sensor.setTimeout(500);
  if (!sensor.init()) {
    Serial.println("Failed to detect and initialize sensor!");
    while (1) {}
  }

  // Start continuous back-to-back mode (fastest possible)
  sensor.startContinuous();

  // Alternative: Continuous timed mode with 100ms between measurements
  // sensor.startContinuous(100);
}

void loop() {
  // Read range in continuous mode
  uint16_t distance = sensor.readRangeContinuousMillimeters();

  Serial.print(distance);
  if (sensor.timeoutOccurred()) {
    Serial.print(" TIMEOUT");
  }
  Serial.println();
}
```

--------------------------------

### Configure VL53L0X Signal Rate Limit

Source: https://context7.com/pololu/vl53l0x-arduino/llms.txt

Shows how to query and set the sensor's signal rate limit, balancing measurement range and accuracy. The example reads the default limit, applies a new value (0.5 MCPS), and verifies the change during continuous distance measurements. Requires a functional VL53L0X sensor and the library.

```C++
#include <Wire.h>\n#include <VL53L0X.h>\n\nVL53L0X sensor;\n\nvoid setup() {\n  Serial.begin(9600);\n  Wire.begin();\n\n  sensor.setTimeout(500);\n  if (!sensor.init()) {\n    Serial.println(\"Failed to initialize sensor!\");\n    while (1) {}\n  }\n\n  // Get current signal rate limit\n  float currentLimit = sensor.getSignalRateLimit();\n  Serial.print(\"Default signal rate limit: \\");\n  Serial.print(currentLimit);\n  Serial.println(\" MCPS\");\n\n  // Set new signal rate limit (0.1 to 0.5 MCPS typical)\n  if (sensor.setSignalRateLimit(0.5)) {\n    Serial.println(\"Signal rate limit set to 0.5 MCPS\");\n  } else {\n    Serial.println(\"Failed to set signal rate limit!\");\n  }\n\n  // Verify new setting\n  Serial.print(\"New signal rate limit: \\");\n  Serial.print(sensor.getSignalRateLimit());\n  Serial.println(\" MCPS\");\n}\n\nvoid loop() {\n  uint16_t distance = sensor.readRangeSingleMillimeters();\n  Serial.print(\"Distance: \\");\n  Serial.print(distance);\n  Serial.println(\" mm\");\n  delay(100);\n}\n
```

--------------------------------

### Initialize and Use Multiple VL53L0X Sensors on Same I2C Bus

Source: https://context7.com/pololu/vl53l0x-arduino/llms.txt

Shows how to connect two VL53L0X sensors to a single I2C bus by controlling their XSHUT pins and assigning a new I2C address to one sensor. The sketch initializes both sensors, starts continuous ranging, and prints distance readings from each. Requires the VL53L0X library and Arduino Wire library.

```C++
#include <Wire.h>\n#include <VL53L0X.h>\n\nVL53L0X sensor1;\nVL53L0X sensor2;\n\n#define XSHUT_PIN1 2\n#define XSHUT_PIN2 3\n\nvoid setup() {\n  Serial.begin(9600);\n  Wire.begin();\n\n  // Setup XSHUT pins to control sensor power\n  pinMode(XSHUT_PIN1, OUTPUT);\n  pinMode(XSHUT_PIN2, OUTPUT);\n\n  // Disable both sensors\n  digitalWrite(XSHUT1, LOW);\n  digitalWrite(XSHUT_PIN2, LOW);\n  delay(10);\n\n  // Enable sensor 1 and change its address\n  digitalWrite(XSHUT_PIN1, HIGH);\n  delay(10);\n  sensor1.setTimeout(500);\n  if (!sensor1.init()) {\n    Serial.println(\"Sensor 1 init failed!\");\n    while (1) {}\n  }\n  sensor1.setAddress(0x30);\n\n  // Enable sensor 2 (keeps default address 0x29)\n  digitalWrite(XSHUT_PIN2, HIGH);\n  delay(10);\n  sensor2.setTimeout(500);\n  if (!sensor2.init()) {\n    Serial.println(\"Sensor 2 init failed!\");\n    while (1) {}\n  }\n\n  sensor1.startContinuous();\n  sensor2.startContinuous();\n\n  Serial.println(\"Both sensors initialized\");\n}\n\nvoid loop() {\n  Serial.print(\"Sensor 1 (0x30): \\");\n  Serial.print(sensor1.readRangeContinuousMillimeters());\n  Serial.print(\" mm | Sensor 2 (0x29): \\");\n  Serial.print(sensor2.readRangeContinuousMillimeters());\n  Serial.println(\" mm\");\n  delay(100);\n}
```

--------------------------------

### Implement Timeout Handling for VL53L0X Sensor (Arduino)

Source: https://context7.com/pololu/vl53l0x-arduino/llms.txt

This code example shows how to implement timeout detection when reading the VL53L0X sensor using the Arduino library. It sets a specific timeout duration and checks if a timeout occurred during readings, providing error messages and statistics for reliability monitoring.

```cpp
#include <Wire.h>
#include <VL53L0X.h>

VL53L0X sensor;
uint16_t timeoutCount = 0;
uint16_t successCount = 0;

void setup() {
  Serial.begin(9600);
  Wire.begin();

  // Set 500ms timeout for I2C operations
  sensor.setTimeout(500);

  if (!sensor.init()) {
    Serial.println("Failed to initialize sensor!");
    while (1) {}
  }

  sensor.startContinuous();
  Serial.println("Monitoring sensor with timeout detection");
}

void loop() {
  uint16_t distance = sensor.readRangeContinuousMillimeters();

  if (sensor.timeoutOccurred()) {
    timeoutCount++;
    Serial.println("ERROR: Timeout occurred!");
  } else {
    successCount++;
    Serial.print("Distance: ");
    Serial.print(distance);
    Serial.println(" mm");
  }

  // Print statistics every 100 readings
  if ((successCount + timeoutCount) % 100 == 0) {
    Serial.print("Success: ");
    Serial.print(successCount);
    Serial.print(" | Timeouts: ");
    Serial.println(timeoutCount);
  }

  delay(50);
}
```

--------------------------------

### VL53L0X Continuous Ranging Mode

Source: https://github.com/pololu/vl53l0x-arduino/blob/master/README.md

Functions for starting and stopping continuous ranging measurements and reading distance values in millimeters.

```APIDOC
## VL53L0X Continuous Ranging Mode

### Description
Enables and disables continuous distance measurements and provides a method to retrieve range readings in millimeters.

### Methods

*   **`void startContinuous(uint32_t period_ms = 0)`**
    *   **Description**: Starts continuous ranging measurements.
    *   **Method**: void
    *   **Parameters**: 
        *   `period_ms` (uint32_t) - Optional - If 0 (default), continuous back-to-back mode is used (fastest measurements). If non-zero, specifies the inter-measurement period in milliseconds for timed continuous mode.

*   **`void stopContinuous()`**
    *   **Description**: Stops continuous ranging mode.
    *   **Method**: void

*   **`uint16_t readRangeContinuousMillimeters()`**
    *   **Description**: Returns the latest range reading in millimeters when continuous mode is active.
    *   **Method**: uint16_t
    *   **Returns**: The measured distance in millimeters. Returns 0 if no valid reading is available.

### Example Usage
```cpp
#include <Wire.h>
#include <VL53L0X.h>

VL53L0X sensor;

void setup() {
  Serial.begin(9600);
  Wire.begin();
  sensor.init();

  // Start continuous ranging in back-to-back mode
  sensor.startContinuous();
  Serial.println("Continuous ranging started (back-to-back).");

  // To start in timed mode (e.g., every 100ms):
  // sensor.startContinuous(100);
  // Serial.println("Continuous ranging started (timed 100ms).");
}

void loop() {
  // Read range in continuous mode
  uint16_t distance = sensor.readRangeContinuousMillimeters();
  
  if (distance > 0) {
    Serial.print("Distance: ");
    Serial.print(distance);
    Serial.println(" mm");
  } else {
    Serial.println("Out of range or invalid reading.");
  }

  delay(50); // Small delay to prevent overwhelming serial output
}
```
```

--------------------------------

### VL53L0X Sensor Initialization and Configuration

Source: https://github.com/pololu/vl53l0x-arduino/blob/master/README.md

This section covers the initialization of the VL53L0X sensor and basic configuration options, including I2C bus selection, address setting, and enabling/disabling 2V8 mode.

```APIDOC
## VL53L0X Sensor Initialization and Configuration

### Description
Functions for initializing the VL53L0X sensor, setting its I2C address, and configuring I/O voltage modes.

### Methods

*   **`VL53L0X()`**
    *   **Description**: Constructor for the VL53L0X object.
    *   **Method**: Constructor

*   **`void setBus(TwoWire * bus)`**
    *   **Description**: Configures the sensor to use a specific I2C bus.
    *   **Method**: void
    *   **Parameters**: 
        *   `bus` (TwoWire*) - Required - A pointer to the `TwoWire` object to use (e.g., `&Wire` or `&Wire1`).

*   **`TwoWire * getBus()`**
    *   **Description**: Returns a pointer to the currently used I2C bus.
    *   **Method**: TwoWire*

*   **`void setAddress(uint8_t new_addr)`**
    *   **Description**: Changes the I2C slave device address of the VL53L0X.
    *   **Method**: void
    *   **Parameters**: 
        *   `new_addr` (uint8_t) - Required - The new 7-bit I2C address for the sensor.

*   **`uint8_t getAddress()`**
    *   **Description**: Returns the current I2C address of the sensor.
    *   **Method**: uint8_t

*   **`bool init(bool io_2v8 = true)`**
    *   **Description**: Initializes and configures the VL53L0X sensor. Optionally configures for 2.8V I/O mode.
    *   **Method**: bool
    *   **Parameters**: 
        *   `io_2v8` (bool) - Optional - If true (default), configures for 2.8V I/O mode. If false, leaves it in 1.8V mode.
    *   **Returns**: `true` if initialization was successful, `false` otherwise.

### Example Usage
```cpp
#include <Wire.h>
#include <VL53L0X.h>

VL53L0X sensor;

void setup() {
  Serial.begin(9600);
  Wire.begin();
  
  sensor.setAddress(0x29); // Set a custom I2C address if needed
  
  if (sensor.init()) {
    Serial.println("VL53L0X sensor initialized successfully.");
    // Optional: Configure for 1.8V mode
    // if (!sensor.init(false)) { 
    //   Serial.println("Failed to initialize in 1.8V mode.");
    // }
  } else {
    Serial.println("Failed to initialize VL53L0X sensor.");
  }
}

void loop() {
  // ... main loop code ...
}
```
```

--------------------------------

### Initialize VL53L0X Sensor with I2C Communication

Source: https://context7.com/pololu/vl53l0x-arduino/llms.txt

Initializes the VL53L0X sensor for I2C communication with a 500ms timeout. Checks if the sensor is properly connected and initialized. Requires Wire.h and VL53L0X.h libraries.

```cpp
#include <Wire.h>
#include <VL53L0X.h>

VL53L0X sensor;

void setup() {
  Serial.begin(9600);
  Wire.begin();

  // Set timeout for read operations (500ms)
  sensor.setTimeout(500);

  // Initialize sensor with 2V8 I/O mode (default)
  if (!sensor.init()) {
    Serial.println("Failed to detect and initialize sensor!");
    while (1) {}
  }

  Serial.println("VL53L0X initialized successfully!");
}

void loop() {
  // Your measurement code here
}
```

--------------------------------

### Configure Alternative I2C Bus for VL53L0X Sensor (Arduino)

Source: https://context7.com/pololu/vl53l0x-arduino/llms.txt

This snippet demonstrates how to configure the VL53L0X sensor to use an alternative I2C bus (e.g., Wire1) on Arduino boards that support multiple I2C interfaces. It initializes the sensor and verifies the bus configuration, enabling flexible sensor placement and multiple I2C devices.

```cpp
#include <Wire.h>
#include <VL53L0X.h>

VL53L0X sensor;

void setup() {
  Serial.begin(9600);

  // Use Wire1 instead of default Wire (on boards with multiple I2C buses)
  Wire1.begin();
  sensor.setBus(&Wire1);

  sensor.setTimeout(500);
  if (!sensor.init()) {
    Serial.println("Failed to initialize sensor on Wire1!");
    while (1) {}
  }

  // Verify which bus is being used
  TwoWire* currentBus = sensor.getBus();
  Serial.println("Sensor configured on Wire1");

  sensor.startContinuous();
}

void loop() {
  uint16_t distance = sensor.readRangeContinuousMillimeters();
  Serial.print("Distance (Wire1): ");
  Serial.print(distance);
  Serial.println(" mm");
}
```

--------------------------------

### Perform Single-Shot Distance Measurement

Source: https://context7.com/pololu/vl53l0x-arduino/llms.txt

Takes one-time distance measurements with configurable accuracy modes. Sets a 200ms timing budget for high accuracy measurements. Includes timeout handling for failed readings.

```cpp
#include <Wire.h>
#include <VL53L0X.h>

VL53L0X sensor;

void setup() {
  Serial.begin(9600);
  Wire.begin();

  sensor.setTimeout(500);
  if (!sensor.init()) {
    Serial.println("Failed to detect and initialize sensor!");
    while (1) {}
  }

  // Configure for high accuracy (200ms timing budget)
  sensor.setMeasurementTimingBudget(200000);

  Serial.println("Single-shot ranging mode ready");
}

void loop() {
  // Take a single range measurement
  uint16_t distance = sensor.readRangeSingleMillimeters();

  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.print(" mm");

  if (sensor.timeoutOccurred()) {
    Serial.print(" TIMEOUT");
  }

  Serial.println();
  delay(100);
}
```

--------------------------------

### Configure High Speed Distance Measurements

Source: https://context7.com/pololu/vl53l0x-arduino/llms.txt

Reduces the measurement timing budget to enable faster readings at the cost of accuracy. Configures a 20ms timing budget compared to the default ~33ms.

```cpp
#include <Wire.h>
#include <VL53L0X.h>

VL53L0X sensor;

void setup() {
  Serial.begin(9600);
  Wire.begin();

  sensor.setTimeout(500);
  if (!sensor.init()) {
    Serial.println("Failed to detect and initialize sensor!");
    while (1) {}
  }

  // Reduce timing budget to 20ms (default is ~33ms)
  if (sensor.setMeasurementTimingBudget(20000)) {
    Serial.println("High speed mode: 20ms timing budget");
  } else {
    Serial.println("Invalid timing budget!");
  }
}

void loop() {
  uint16_t distance = sensor.readRangeSingleMillimeters();
  Serial.print("Fast reading: ");
  Serial.print(distance);
  Serial.println(" mm");
  delay(50);
}
```

--------------------------------

### Adjust VL53L0X Measurement Timing Budget

Source: https://context7.com/pololu/vl53l0x-arduino/llms.txt

Illustrates how to retrieve, modify, and verify the sensor's measurement timing budget, affecting accuracy versus speed. The sketch sets a 50 ms budget, measures the time taken for a single reading, and prints both distance and elapsed time. Suitable for applications needing performance tuning.

```C++
#include <Wire.h>\n#include <VL53L0X.h>\n\nVL53L0X sensor;\n\nvoid setup() {\n  Serial.begin(9600);\n  Wire.begin();\n\n  sensor.setTimeout(500);\n  if (!sensor.init()) {\n    Serial.println(\"Failed to initialize sensor!\");\n    while (1) {}\n  }\n\n  // Get default timing budget\n  uint32_t defaultBudget = sensor.getMeasurementTimingBudget();\n  Serial.print(\"Default timing budget: \\");\n  Serial.print(defaultBudget);\n  Serial.println(\" microseconds\");\n\n  // Set timing budget (20000 to 200000 microseconds typical)\n  // Higher = more accurate but slower\n  uint32_t newBudget = 50000; // 50ms\n  if (sensor.setMeasurementTimingBudget(newBudget)) {\n    Serial.print(\"Timing budget set to \\");\n    Serial.print(newBudget / 1000);\n    Serial.println(\" ms\");\n  } else {\n    Serial.println(\"Invalid timing budget!\");\n  }\n\n  // Verify setting\n  Serial.print(\"Current timing budget: \\");\n  Serial.print(sensor.getMeasurementTimingBudget());\n  Serial.println(\" microseconds\");\n}\n\nvoid loop() {\n  unsigned long startTime = millis();\n  uint16_t distance = sensor.readRangeSingleMillimeters();\n  unsigned long elapsed = millis() - startTime;\n\n  Serial.print(\"Distance: \\");\n  Serial.print(distance);\n  Serial.print(\" mm (\");\n  Serial.print(elapsed);\n  Serial.println(\") ms)\");\n\n  delay(100);\n}\n
```

--------------------------------

### VL53L0X Ranging Configuration

Source: https://github.com/pololu/vl53l0x-arduino/blob/master/README.md

Functions for configuring the ranging parameters of the VL53L0X sensor, including signal rate limit, timing budget, and VCSEL pulse periods.

```APIDOC
## VL53L0X Ranging Configuration

### Description
Allows adjustment of key parameters that affect the ranging performance and accuracy of the VL53L0X sensor.

### Methods

*   **`bool setSignalRateLimit(float limit_Mcps)`**
    *   **Description**: Sets the return signal rate limit. This is the minimum amplitude required for a valid reading.
    *   **Method**: bool
    *   **Parameters**: 
        *   `limit_Mcps` (float) - Required - The signal rate limit in Mega Counts Per Second (MCPS). Lower values increase range but may reduce accuracy.
    *   **Returns**: `true` if the limit was valid, `false` otherwise.

*   **`float getSignalRateLimit()`**
    *   **Description**: Returns the current return signal rate limit in MCPS.
    *   **Method**: float

*   **`bool setMeasurementTimingBudget(uint32_t budget_us)`**
    *   **Description**: Sets the time allowed for a single range measurement.
    *   **Method**: bool
    *   **Parameters**: 
        *   `budget_us` (uint32_t) - Required - The timing budget in microseconds (µs). Minimum is 20ms.
    *   **Returns**: `true` if the budget was valid, `false` otherwise.

*   **`uint32_t getMeasurementTimingBudget()`**
    *   **Description**: Returns the current measurement timing budget in microseconds.
    *   **Method**: uint32_t

*   **`bool setVcselPulsePeriod(vcselPeriodType type, uint8_t period_pclks)`**
    *   **Description**: Sets the VCSEL (Vertical Cavity Surface Emitting Laser) pulse period.
    *   **Method**: bool
    *   **Parameters**: 
        *   `type` (vcselPeriodType) - Required - Specifies the period type: `VL53L0X::VcselPeriodPreRange` or `VL53L0X::VcselPeriodFinalRange`.
        *   `period_pclks` (uint8_t) - Required - The pulse period in PCLKs (Peripheral Clock Cycles). Valid ranges: Pre-range (12-18, even only), Final-range (8-14, even only).
    *   **Returns**: `true` if the period was valid, `false` otherwise.

*   **`uint8_t getVcselPulsePeriod(vcselPeriodType type)`**
    *   **Description**: Returns the current VCSEL pulse period for the specified type.
    *   **Method**: uint8_t
    *   **Parameters**: 
        *   `type` (vcselPeriodType) - Required - The period type (`VL53L0X::VcselPeriodPreRange` or `VL53L0X::VcselPeriodFinalRange`).

### Example Usage
```cpp
#include <Wire.h>
#include <VL53L0X.h>

VL53L0X sensor;

void setup() {
  Serial.begin(9600);
  Wire.begin();
  sensor.init();

  // Set a signal rate limit
  if (sensor.setSignalRateLimit(0.1)) { // 0.1 MCPS
    Serial.println("Signal rate limit set.");
  } else {
    Serial.println("Failed to set signal rate limit.");
  }

  // Set measurement timing budget
  if (sensor.setMeasurementTimingBudget(30000)) { // 30ms
    Serial.println("Measurement timing budget set.");
  } else {
    Serial.println("Failed to set measurement timing budget.");
  }

  // Set VCSEL pulse period for pre-range
  if (sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodPreRange, 16)) { // 16 PCLKs
    Serial.println("VCSEL pre-range pulse period set.");
  } else {
    Serial.println("Failed to set VCSEL pre-range pulse period.");
  }
}

void loop() {
}
```
```

--------------------------------

### Read and Write VL53L0X Registers Directly

Source: https://context7.com/pololu/vl53l0x-arduino/llms.txt

Demonstrates direct register access for advanced sensor configuration, including reading model and revision IDs and writing to an interrupt clear register. Useful for developers needing low‑level control beyond the high‑level API. Relies on the VL53L0X library's readReg, readReg16Bit, and writeReg functions.

```C++
#include <Wire.h>\n#include <VL53L0X.h>\n\nVL53L0X sensor;\n\nvoid setup() {\n  Serial.begin(9600);\n  Wire.begin();\n\n  sensor.setTimeout(500);\n  if (!sensor.init()) {\n    Serial.println(\"Failed to initialize sensor!\");\n    while (1) {}\n  }\n\n  // Read model ID (should be 0xEE for VL53L0X)\n  uint8_t modelId = sensor.readReg(VL53L0X::IDENTIFICATION_MODEL_ID);\n  Serial.print(\"Model ID: 0x\");\n  Serial.println(modelId, HEX);\n\n  // Read revision ID\n  uint8_t revisionId = sensor.readReg(VL53L0X::IDENTIFICATION_REVISION_ID);\n  Serial.print(\"Revision ID: 0x\");\n  Serial.println(revisionId, HEX);\n\n  // Write to 8-bit register\n  sensor.writeReg(VL53L0X::SYSTEM_INTERRUPT_CLEAR, 0x01);\n\n  // Read 16-bit register\n  uint16_t value16 = sensor.readReg16Bit(VL53L0X::RESULT_RANGE_STATUS);\n  Serial.print(\"Range status: 0x\");\n  Serial.println(value16, HEX);\n}\n\nvoid loop() {\n  // operation\n}\n
```

--------------------------------

### Configure VCSEL Pulse Period for VL53L0X Sensor (Arduino)

Source: https://context7.com/pololu/vl53l0x-arduino/llms.txt

This Arduino code illustrates how to adjust the VCSEL (Vertical Cavity Surface Emitting Laser) pulse periods for the VL53L0X sensor. It shows how to read default periods and set custom values for pre-range and final-range to optimize for different distance measurement scenarios.

```cpp
#include <Wire.h>
#include <VL53L0X.h>

VL53L0X sensor;

void setup() {
  Serial.begin(9600);
  Wire.begin();

  sensor.setTimeout(500);
  if (!sensor.init()) {
    Serial.println("Failed to initialize sensor!");
    while (1) {}
  }

  // Read default VCSEL pulse periods
  uint8_t preRangePeriod = sensor.getVcselPulsePeriod(VL53L0X::VcselPeriodPreRange);
  uint8_t finalRangePeriod = sensor.getVcselPulsePeriod(VL53L0X::VcselPeriodFinalRange);

  Serial.print("Default pre-range period: ");
  Serial.print(preRangePeriod);
  Serial.println(" PCLKs");

  Serial.print("Default final range period: ");
  Serial.print(finalRangePeriod);
  Serial.println(" PCLKs");

  // Set custom periods (Pre: 12-18 even, Final: 8-14 even)
  if (sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodPreRange, 16)) {
    Serial.println("Pre-range period set to 16 PCLKs");
  }

  if (sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodFinalRange, 12)) {
    Serial.println("Final range period set to 12 PCLKs");
  }

  sensor.startContinuous();
}

void loop() {
  uint16_t distance = sensor.readRangeContinuousMillimeters();
  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.println(" mm");
}
```

--------------------------------

### Configure Long Range Distance Measurement

Source: https://context7.com/pololu/vl53l0x-arduino/llms.txt

Configures the sensor for extended range measurements by adjusting signal rate limits and VCSEL pulse periods. Trades accuracy for extended range in low-light conditions.

```cpp
#include <Wire.h>
#include <VL53L0X.h>

VL53L0X sensor;

void setup() {
  Serial.begin(9600);
  Wire.begin();

  sensor.setTimeout(500);
  if (!sensor.init()) {
    Serial.println("Failed to detect and initialize sensor!");
    while (1) {}
  }

  // Long range configuration
  // Lower signal rate limit (default is 0.25 MCPS)
  sensor.setSignalRateLimit(0.1);

  // Increase laser pulse periods (defaults are 14 and 10 PCLKs)
  sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodPreRange, 18);
  sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodFinalRange, 14);

  Serial.println("Long range mode configured");
  sensor.startContinuous();
}

void loop() {
  uint16_t distance = sensor.readRangeContinuousMillimeters();
  Serial.print("Long range distance: ");
  Serial.print(distance);
  Serial.println(" mm");
}
```

--------------------------------

### VL53L0X Register Read/Write Operations

Source: https://github.com/pololu/vl53l0x-arduino/blob/master/README.md

Functions for reading and writing individual registers (8, 16, or 32 bits) and blocks of data on the VL53L0X sensor.

```APIDOC
## VL53L0X Register Read/Write Operations

### Description
Provides low-level access to the VL53L0X sensor's registers for direct control and debugging.

### Methods

*   **`void writeReg(uint8_t reg, uint8_t value)`**
    *   **Description**: Writes an 8-bit value to a specific sensor register.
    *   **Method**: void
    *   **Parameters**: 
        *   `reg` (uint8_t) - Required - The address of the register to write to. Use constants from `VL53L0X.h` (e.g., `VL53L0X::SYSRANGE_START`).
        *   `value` (uint8_t) - Required - The 8-bit value to write.

*   **`void writeReg16Bit(uint8_t reg, uint16_t value)`**
    *   **Description**: Writes a 16-bit value to a specific sensor register.
    *   **Method**: void
    *   **Parameters**: 
        *   `reg` (uint8_t) - Required - The address of the register to write to.
        *   `value` (uint16_t) - Required - The 16-bit value to write.

*   **`void writeReg32Bit(uint8_t reg, uint32_t value)`**
    *   **Description**: Writes a 32-bit value to a specific sensor register.
    *   **Method**: void
    *   **Parameters**: 
        *   `reg` (uint8_t) - Required - The address of the register to write to.
        *   `value` (uint32_t) - Required - The 32-bit value to write.

*   **`uint8_t readReg(uint8_t reg)`**
    *   **Description**: Reads an 8-bit value from a specific sensor register.
    *   **Method**: uint8_t
    *   **Parameters**: 
        *   `reg` (uint8_t) - Required - The address of the register to read from.
    *   **Returns**: The 8-bit value read from the register.

*   **`uint16_t readReg16Bit(uint8_t reg)`**
    *   **Description**: Reads a 16-bit value from a specific sensor register.
    *   **Method**: uint16_t
    *   **Parameters**: 
        *   `reg` (uint8_t) - Required - The address of the register to read from.
    *   **Returns**: The 16-bit value read from the register.

*   **`uint32_t readReg32Bit(uint8_t reg)`**
    *   **Description**: Reads a 32-bit value from a specific sensor register.
    *   **Method**: uint32_t
    *   **Parameters**: 
        *   `reg` (uint8_t) - Required - The address of the register to read from.
    *   **Returns**: The 32-bit value read from the register.

*   **`void writeMulti(uint8_t reg, uint8_t const * src, uint8_t count)`**
    *   **Description**: Writes multiple bytes from an array to the sensor starting at a given register.
    *   **Method**: void
    *   **Parameters**: 
        *   `reg` (uint8_t) - Required - The starting register address.
        *   `src` (uint8_t const *) - Required - A pointer to the byte array containing data to write.
        *   `count` (uint8_t) - Required - The number of bytes to write.

*   **`void readMulti(uint8_t reg, uint8_t * dst, uint8_t count)`**
    *   **Description**: Reads multiple bytes from the sensor into an array starting at a given register.
    *   **Method**: void
    *   **Parameters**: 
        *   `reg` (uint8_t) - Required - The starting register address.
        *   `dst` (uint8_t *) - Required - A pointer to the byte array to store the read data.
        *   `count` (uint8_t) - Required - The number of bytes to read.

### Example Usage
```cpp
#include <Wire.h>
#include <VL53L0X.h>

VL53L0X sensor;

void setup() {
  Serial.begin(9600);
  Wire.begin();
  sensor.init();

  // Example: Writing to a register
  sensor.writeReg(VL53L0X::SYSRANGE_START, 0x01);
  Serial.println("Wrote 0x01 to SYSRANGE_START register.");

  // Example: Reading from a register
  uint8_t status = sensor.readReg(VL53L0X::RESULT_INTERRUPT_STATUS);
  Serial.print("Interrupt status register: 0x");
  Serial.println(status, HEX);

  // Example: Reading multiple bytes
  uint8_t buffer[5];
  sensor.readMulti(VL53L0X::IDENTIFICATION_MODEL_ID, buffer, 5);
  Serial.println("Read 5 bytes from IDENTIFICATION_MODEL_ID:");
  for(int i=0; i<5; i++) {
    Serial.print(buffer[i], HEX);
  }
  Serial.println();
}

void loop() {
}
```
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.