### Initialize and Start Basic Ranging - Arduino C++

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

Initialize the VL53L1X sensor with default settings and begin continuous distance measurements. Sets up I2C communication at 400kHz, configures timeout handling, initializes the sensor, and starts continuous ranging mode with 50ms interval for ongoing distance monitoring.

```C++
#include <Wire.h>
#include <VL53L1X.h>

VL53L1X sensor;

void setup() {
  Serial.begin(115200);
  Wire.begin();
  Wire.setClock(400000); // 400 kHz I2C

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

  // Configure for long distance mode with 50ms timing budget
  sensor.setDistanceMode(VL53L1X::Long);
  sensor.setMeasurementTimingBudget(50000);

  // Start continuous readings every 50ms
  sensor.startContinuous(50);
}

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

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

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

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

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

Demonstrates how to use an alternative I2C bus (e.g., Wire1) with the VL53L1X sensor. This is useful for boards with multiple I2C interfaces. It initializes the sensor, sets communication parameters, and reads distance measurements. Dependencies include the Wire library and the VL53L1X library.

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

VL53L1X sensor;

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

  // Use default Wire bus
  Wire.begin();
  Wire.setClock(400000);

  // Or use alternative bus (e.g., Wire1 on Arduino Due, ESP32)
  // Wire1.begin();
  // Wire1.setClock(400000);
  // sensor.setBus(&Wire1);

  sensor.setTimeout(500);
  if (!sensor.init()) {
    Serial.println("Init failed!");
    while (1);
  }

  // Get current bus
  TwoWire* currentBus = sensor.getBus();
  Serial.print("Using I2C bus: ");
  Serial.println(currentBus == &Wire ? "Wire" : "Wire1");

  sensor.setDistanceMode(VL53L1X::Long);
  sensor.setMeasurementTimingBudget(50000);
  sensor.startContinuous(50);
}

void loop() {
  Serial.print("Distance: ");
  Serial.print(sensor.read());
  Serial.println(" mm");
}
```

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

### Configure Distance Modes and Timing Budgets - Arduino C++

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

Adjust sensor performance characteristics by selecting distance modes and measurement timing budgets. Shows configuration options for Short, Medium, and Long distance modes with their respective minimum timing budgets (20ms, 33ms, 33ms) and performance trade-offs regarding ambient light sensitivity and maximum range.

```C++
#include <Wire.h>
#include <VL53L1X.h>

VL53L1X sensor;

void setup() {
  Serial.begin(115200);
  Wire.begin();
  Wire.setClock(400000);

  sensor.setTimeout(500);
  if (!sensor.init()) {
    Serial.println("Init failed!");
    while (1);
  }

  // Short mode: less affected by ambient light, lower max range
  // Minimum timing budget: 20ms
  sensor.setDistanceMode(VL53L1X::Short);
  sensor.setMeasurementTimingBudget(20000);

  // Medium mode: balanced performance
  // Minimum timing budget: 33ms
  // sensor.setDistanceMode(VL53L1X::Medium);
  // sensor.setMeasurementTimingBudget(33000);

  // Long mode: maximum range, more affected by ambient light
  // Minimum timing budget: 33ms
  // sensor.setDistanceMode(VL53L1X::Long);
  // sensor.setMeasurementTimingBudget(50000);

  sensor.startContinuous(50);
}

void loop() {
  Serial.print("Distance: ");
  Serial.print(sensor.read());
  Serial.println(" mm");
}
```

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

### Direct Register Access for VL53L1X Arduino

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

Demonstrates how to read and write to the VL53L1X sensor's registers directly for advanced configuration. This method provides fine-grained control over sensor parameters. Requires Wire and VL53L1X libraries.

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

VL53L1X sensor;

void setup() {
  Serial.begin(115200);
  Wire.begin();
  Wire.setClock(400000);

  sensor.setTimeout(500);
  if (!sensor.init()) {
    Serial.println("Init failed!");
    while (1);
  }

  // Read 8-bit register
  uint8_t modelId = sensor.readReg(VL53L1X::IDENTIFICATION__MODEL_ID);
  Serial.print("Model ID: 0x");
  Serial.println(modelId, HEX);

  // Read 16-bit register
  uint16_t timingBudget = sensor.readReg16Bit(VL53L1X::RANGE_CONFIG__TIMEOUT_MACROP_A);
  Serial.print("Timing Budget Register: ");
  Serial.println(timingBudget);

  // Read 32-bit register
  uint32_t intermeasurement = sensor.readReg32Bit(VL53L1X::SYSTEM__INTERMEASUREMENT_PERIOD);
  Serial.print("Intermeasurement Period: ");
  Serial.println(intermeasurement);

  // Write 8-bit register
  // sensor.writeReg(VL53L1X::SYSTEM__INTERRUPT_CLEAR, 0x01);

  // Write 16-bit register
  // sensor.writeReg16Bit(VL53L1X::RANGE_CONFIG__TIMEOUT_MACROP_A, value);

  // Write 32-bit register
  // sensor.writeReg32Bit(VL53L1X::SYSTEM__INTERMEASUREMENT_PERIOD, value);

  sensor.setDistanceMode(VL53L1X::Long);
  sensor.setMeasurementTimingBudget(50000);
  sensor.startContinuous(50);
}

void loop() {
  Serial.print("Distance: ");
  Serial.print(sensor.read());
  Serial.println(" mm");
}

```

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

### Configure Region of Interest (ROI) for VL53L1X Arduino

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

Customizes the sensor's field of view by setting the ROI size and center position. This allows focusing on a specific area. Requires the Wire and VL53L1X libraries. Outputs the configured ROI parameters.

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

VL53L1X sensor;

void setup() {
  Serial.begin(115200);
  Wire.begin();
  Wire.setClock(400000);

  sensor.setTimeout(500);
  if (!sensor.init()) {
    Serial.println("Init failed!");
    while (1);
  }

  // Default ROI is 16x16 (full sensor array)
  // Set smaller ROI for narrower field of view
  // Minimum ROI is 4x4
  sensor.setROISize(8, 8);

  // Center SPAD 199 is default (centered FoV)
  // Adjust to shift the field of view
  sensor.setROICenter(199);

  // Read back current ROI configuration
  uint8_t width, height;
  sensor.getROISize(&width, &height);
  uint8_t center = sensor.getROICenter();

  Serial.print("ROI: ");
  Serial.print(width);
  Serial.print("x");
  Serial.print(height);
  Serial.print(" Center SPAD: ");
  Serial.println(center);

  sensor.setDistanceMode(VL53L1X::Long);
  sensor.setMeasurementTimingBudget(50000);
  sensor.startContinuous(50);
}

void loop() {
  Serial.print("Distance: ");
  Serial.print(sensor.read());
  Serial.println(" mm");
}

```

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

### Error Handling and Status Checking for VL53L1X Sensor (Arduino)

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

Implements robust error handling for the VL53L1X sensor, including timeout detection and I2C status checking. This code snippet initializes the sensor, performs distance readings, and checks for ranging validity and I2C communication errors. Dependencies include the Wire library and the VL53L1X library.

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

VL53L1X sensor;

void setup() {
  Serial.begin(115200);
  Wire.begin();
  Wire.setClock(400000);

  sensor.setTimeout(500);
  if (!sensor.init()) {
    Serial.println("Init failed!");
    Serial.print("I2C Status: ");
    Serial.println(sensor.last_status);
    while (1);
  }

  // Check initialization success
  uint8_t address = sensor.getAddress();
  Serial.print("Sensor address: 0x");
  Serial.println(address, HEX);

  sensor.setDistanceMode(VL53L1X::Long);
  sensor.setMeasurementTimingBudget(50000);
  sensor.startContinuous(50);
}

void loop() {
  sensor.read();

  // Check for timeout
  if (sensor.timeoutOccurred()) {
    Serial.println("ERROR: Read timeout occurred");
    return;
  }

  // Check range status
  if (sensor.ranging_data.range_status == VL53L1X::RangeValid) {
    Serial.print("Valid range: ");
    Serial.print(sensor.ranging_data.range_mm);
    Serial.println(" mm");
  } else {
    Serial.print("Invalid range - Status: ");
    Serial.println(VL53L1X::rangeStatusToString(sensor.ranging_data.range_status));
  }

  // Check I2C communication status
  if (sensor.last_status != 0) {
    Serial.print("I2C Error: ");
    Serial.println(sensor.last_status);
  }
}
```

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

### Multiple VL53L1X Sensors on Same I2C Bus Arduino

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

Configures and reads data from multiple VL53L1X sensors connected to the same I2C bus by assigning each a unique I2C address. Utilizes XSHUT pins for individual sensor initialization. Requires Wire and VL53L1X libraries.

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

const uint8_t sensorCount = 3;
const uint8_t xshutPins[sensorCount] = { 4, 5, 6 };
VL53L1X sensors[sensorCount];

void setup() {
  Serial.begin(115200);
  Wire.begin();
  Wire.setClock(400000);

  // Disable all sensors via XSHUT pins
  for (uint8_t i = 0; i < sensorCount; i++) {
    pinMode(xshutPins[i], OUTPUT);
    digitalWrite(xshutPins[i], LOW);
  }

  // Enable and configure each sensor with unique address
  for (uint8_t i = 0; i < sensorCount; i++) {
    // Release XSHUT to enable sensor
    pinMode(xshutPins[i], INPUT);
    delay(10);

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

    // Assign unique I2C address (default is 0x29)
    sensors[i].setAddress(0x2A + i);
    sensors[i].startContinuous(50);
  }

  Serial.println("All sensors initialized");
}

void loop() {
  for (uint8_t i = 0; i < sensorCount; i++) {
    Serial.print("Sensor ");
    Serial.print(i);
    Serial.print(": ");
    Serial.print(sensors[i].read());
    Serial.print(" mm");

    if (sensors[i].timeoutOccurred()) {
      Serial.print(" TIMEOUT");
    }
    Serial.print("\t");
  }
  Serial.println();
}

```

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

### Read Detailed Measurement Data - Arduino C++

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

Access comprehensive ranging data including measurement status, signal rates, and ambient light information. Demonstrates how to retrieve extended measurement data from the sensor including range status string conversion, peak signal count rate in MCPS, and ambient light count rate for advanced diagnostics.

```C++
#include <Wire.h>
#include <VL53L1X.h>

VL53L1X sensor;

void setup() {
  Serial.begin(115200);
  Wire.begin();
  Wire.setClock(400000);

  sensor.setTimeout(500);
  if (!sensor.init()) {
    Serial.println("Initialization failed!");
    while (1);
  }

  sensor.setDistanceMode(VL53L1X::Long);
  sensor.setMeasurementTimingBudget(50000);
  sensor.startContinuous(50);
}

void loop() {
  sensor.read();

  // Access detailed ranging data from the ranging_data struct
  Serial.print("Range: ");
  Serial.print(sensor.ranging_data.range_mm);
  Serial.print(" mm\tStatus: ");
  Serial.print(VL53L1X::rangeStatusToString(sensor.ranging_data.range_status));
  Serial.print("\tPeak Signal: ");
  Serial.print(sensor.ranging_data.peak_signal_count_rate_MCPS);
  Serial.print(" MCPS\tAmbient: ");
  Serial.print(sensor.ranging_data.ambient_count_rate_MCPS);
  Serial.println(" MCPS");

  delay(50);
}
```

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

### Non-Blocking Single-Shot Measurements with VL53L1X Arduino

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

Initiates a distance measurement and checks for its completion without blocking the main loop. This allows other tasks to run while the sensor is acquiring data. Requires the Wire and VL53L1X libraries.

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

VL53L1X sensor;
bool measurementStarted = false;

void setup() {
  Serial.begin(115200);
  Wire.begin();
  Wire.setClock(400000);

  sensor.setTimeout(500);
  if (!sensor.init()) {
    Serial.println("Init failed!");
    while (1);
  }

  sensor.setDistanceMode(VL53L1X::Long);
  sensor.setMeasurementTimingBudget(50000);
}

void loop() {
  if (!measurementStarted) {
    // Start non-blocking measurement
    sensor.readSingle(false);
    measurementStarted = true;
    Serial.println("Measurement started...");
  }

  // Check if data is ready
  if (sensor.dataReady()) {
    uint16_t distance = sensor.read(false);
    Serial.print("Distance: ");
    Serial.print(distance);
    Serial.println(" mm");

    measurementStarted = false;
    delay(1000); // Wait before starting next measurement
  }

  // Do other tasks while waiting for measurement
}

```

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

### Single-Shot Measurements - Arduino C++

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

Perform on-demand distance measurements instead of continuous polling. Uses the blocking readSingle() method to perform individual distance measurements on demand, with a 1-second delay between measurements to reduce power consumption and avoid sensor overheating during intermittent readings.

```C++
#include <Wire.h>
#include <VL53L1X.h>

VL53L1X sensor;

void setup() {
  Serial.begin(115200);
  Wire.begin();
  Wire.setClock(400000);

  sensor.setTimeout(500);
  if (!sensor.init()) {
    Serial.println("Init failed!");
    while (1);
  }

  sensor.setDistanceMode(VL53L1X::Long);
  sensor.setMeasurementTimingBudget(50000);
}

void loop() {
  // Blocking single-shot measurement
  uint16_t distance = sensor.readSingle();
  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.println(" mm");

  delay(1000); // Wait before next measurement
}
```

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