### Initialize LSM6DSV16X Sensor with SPI

Source: https://context7.com/stm32duino/lsm6dsv16x/llms.txt

Initializes the LSM6DSV16X sensor for use with SPI communication, specifying the chip select (CS) pin. This setup requires the `LSM6DSV16XSensor.h` library and enables both accelerometer and gyroscope functionalities. Initialization failures are reported via the serial monitor.

```cpp
#include <LSM6DSV16XSensor.h>

#define CS_PIN 10

SPIClass dev_spi(SPI_MOSI, SPI_MISO, SPI_SCK);
LSM6DSV16XSensor AccGyr(&dev_spi, CS_PIN);

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

  // Initialize sensor with SPI
  if (AccGyr.begin() != LSM6DSV16X_OK) {
    Serial.println("Sensor initialization failed!");
    while(1);
  }

  // Enable accelerometer and gyroscope
  AccGyr.Enable_X();
  AccGyr.Enable_G();

  Serial.println("LSM6DSV16X initialized via SPI");
}

void loop() {
  // Ready to read sensor data
}
```

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

### Initialize LSM6DSV16X with I2C Arduino

Source: https://github.com/stm32duino/lsm6dsv16x/blob/main/README.md

Explains how to create and enable an LSM6DSV16XSensor instance using an I2C interface. This involves initializing the sensor and enabling both the accelerometer and gyroscope functionalities. Assumes the TwoWire interface has already been set up.

```cpp
LSM6DSV16XSensor AccGyr(&dev_i2c);
AccGyr.begin();
AccGyr.Enable_X();
AccGyr.Enable_G();
```

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

### Initialize I2C Interface for LSM6DSV16X Arduino

Source: https://github.com/stm32duino/lsm6dsv16x/blob/main/README.md

Demonstrates how to set up a TwoWire interface for I2C communication with the LSM6DSV16X sensor. This is a prerequisite for using the sensor over I2C. Ensure the correct SDA and SCL pins are defined.

```cpp
TwoWire dev_i2c(I2C_SDA, I2C_SCL);
dev_i2c.begin();
```

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

### Initialize LSM6DSV16X with SPI Arduino

Source: https://github.com/stm32duino/lsm6dsv16x/blob/main/README.md

Demonstrates how to create and enable an LSM6DSV16XSensor instance using an SPI interface and a Chip Select (CS) pin. This involves initializing the sensor and enabling both the accelerometer and gyroscope. Assumes the SPIClass interface has already been set up.

```cpp
LSM6DSV16XSensor AccGyr(&dev_spi, CS_PIN);
AccGyr.begin();
AccGyr.Enable_X();
AccGyr.Enable_G();
```

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

### Initialize SPI Interface for LSM6DSV16X Arduino

Source: https://github.com/stm32duino/lsm6dsv16x/blob/main/README.md

Shows how to set up a SPIClass interface for SPI communication with the LSM6DSV16X sensor. This is necessary when using the sensor over SPI. Ensure the correct MOSI, MISO, and SCK pins are defined.

```cpp
SPIClass dev_spi(SPI_MOSI, SPI_MISO, SPI_SCK);
dev_spi.begin();
```

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

### Initialize LSM6DSV16X Sensor with I2C

Source: https://context7.com/stm32duino/lsm6dsv16x/llms.txt

Initializes the LSM6DSV16X sensor for use with I2C communication. It requires the `LSM6DSV16XSensor.h` library and configures the sensor for accelerometer and gyroscope data acquisition. Errors during initialization will be reported to the serial monitor.

```cpp
#include <LSM6DSV16XSensor.h>

TwoWire dev_i2c(I2C_SDA, I2C_SCL);
LSM6DSV16XSensor AccGyr(&dev_i2c);

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

  // Initialize sensor
  if (AccGyr.begin() != LSM6DSV16X_OK) {
    Serial.println("Sensor initialization failed!");
    while(1);
  }

  // Enable accelerometer and gyroscope
  AccGyr.Enable_X();  // Enable accelerometer
  AccGyr.Enable_G();  // Enable gyroscope

  Serial.println("LSM6DSV16X initialized successfully");
}

void loop() {
  // Sensor is ready for data acquisition
}
```

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

### Enable Sensor Fusion and Read Quaternions with Arduino

Source: https://context7.com/stm32duino/lsm6dsv16x/llms.txt

This code enables the Sensor Fusion Low Power (SFLP) mode on the LSM6DSV16X sensor to compute rotation quaternions for 3D orientation tracking. It configures the accelerometer, gyroscope, and SFLP output data rates, then reads quaternion data from the FIFO buffer. Ensure the Wire library is included for I2C communication.

```cpp
#include <LSM6DSV16XSensor.h>

#define ALGO_FREQ 120U
#define ALGO_PERIOD (1000U / ALGO_FREQ)

LSM6DSV16XSensor AccGyr(&Wire);
uint8_t status = 0;
uint8_t tag = 0;
float quaternions[4] = {0};
unsigned long startTime, elapsedTime;

void setup() {
  Serial.begin(115200);
  while (!Serial) {
    yield();
  }

  Wire.begin();
  AccGyr.begin();
  AccGyr.Enable_X();
  AccGyr.Enable_G();

  // Enable Sensor Fusion
  status |= AccGyr.Set_X_FS(4);
  status |= AccGyr.Set_G_FS(2000);
  status |= AccGyr.Set_X_ODR(120.0f);
  status |= AccGyr.Set_G_ODR(120.0f);
  status |= AccGyr.Set_SFLP_ODR(120.0f);
  status |= AccGyr.Enable_Rotation_Vector();
  status |= AccGyr.FIFO_Set_Mode(LSM6DSV16X_STREAM_MODE);

  if (status != LSM6DSV16X_OK) {
    Serial.println("LSM6DSV16X Sensor failed to init/configure");
    while (1);
  }

  Serial.println("LSM6DSV16X SFLP Demo");
  Serial.println("Display quaternions at: https://adafruit.github.io/Adafruit_WebSerial_3DModelViewer/");
}

void loop() {
  uint16_t fifo_samples;
  startTime = millis();

  // Check the number of samples inside FIFO
  if (AccGyr.FIFO_Get_Num_Samples(&fifo_samples) != LSM6DSV16X_OK) {
    Serial.println("Failed to get FIFO samples");
    while (1);
  }

  // Read the FIFO if there is one stored sample
  if (fifo_samples > 0) {
    for (int i = 0; i < fifo_samples; i++) {
      AccGyr.FIFO_Get_Tag(&tag);

      // Tag 0x13 indicates rotation vector data
      if (tag == 0x13u) {
        AccGyr.FIFO_Get_Rotation_Vector(&quaternions[0]);

        // Print Quaternion data (w, x, y, z)
        Serial.print("Quaternion: ");
        Serial.print(quaternions[3], 4);
        Serial.print(", ");
        Serial.print(quaternions[0], 4);
        Serial.print(", ");
        Serial.print(quaternions[1], 4);
        Serial.print(", ");
        Serial.println(quaternions[2], 4);

        // Maintain algorithm period timing
        elapsedTime = millis() - startTime;
        if ((long)(ALGO_PERIOD - elapsedTime) > 0) {
          delay(ALGO_PERIOD - elapsedTime);
        }
      }
    }
  }
}

```

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

### Read QVAR Data with Arduino for Electrostatic Sensing

Source: https://context7.com/stm32duino/lsm6dsv16x/llms.txt

This code demonstrates how to enable and read QVAR (charge variation) measurements from the LSM6DSV16X sensor for electrostatic sensing applications. It initializes the sensor, enables the accelerometer, gyroscope, and QVAR, and then continuously reads and prints the QVAR data. The Wire library is required for I2C communication.

```cpp
#include <LSM6DSV16XSensor.h>

LSM6DSV16XSensor AccGyr(&Wire);

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

  // Initialize sensor
  AccGyr.begin();

  // Enable accelerometer and gyroscope
  AccGyr.Enable_X();
  AccGyr.Enable_G();

  // Enable QVAR
  if (AccGyr.QVAR_Enable() != LSM6DSV16X_OK) {
    Serial.println("Error during initialization of QVAR");
    while (1);
  }

  Serial.println("LSM6DSV16X QVAR Demo");
  Serial.println("Reading charge variation measurements...");
}

void loop() {
  uint8_t qvar_status;
  float qvar_data;

  // Check if QVAR data is ready
  if (AccGyr.QVAR_GetStatus(&qvar_status) == LSM6DSV16X_OK) {
    if (qvar_status) {
      // Get QVAR data
      if (AccGyr.QVAR_GetData(&qvar_data) == LSM6DSV16X_OK) {
        Serial.print("QVAR: ");
        Serial.println(qvar_data);
      }
    }
  }

  delay(10); // Small delay for stability
}

```

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

### Enable Pedometer and Count Steps with LSM6DSV16X

Source: https://context7.com/stm32duino/lsm6dsv16x/llms.txt

This snippet configures the LSM6DSV16X sensor to act as a pedometer, detecting steps using interrupt-driven methods and also provides periodic status polling. It requires the LSM6DSV16XSensor library and uses the INT1 pin for interrupt notifications. The output includes the current step count.

```cpp
#include <LSM6DSV16XSensor.h>

#define INT1_pin PA4

LSM6DSV16XSensor LSM6DSV16X(&Wire);

volatile int mems_event = 0;
uint16_t step_count = 0;
uint32_t previous_tick;
char report[256];

void INT1Event_cb() {
  mems_event = 1;
}

void setup() {
  Serial.begin(115200);
  delay(1000);
  pinMode(LED_BUILTIN, OUTPUT);
  Wire.begin();

  // Enable INT1 pin for interrupts
  attachInterrupt(INT1_pin, INT1Event_cb, RISING);

  // Initialize sensor
  LSM6DSV16X.begin();
  LSM6DSV16X.Enable_X();

  // Enable Pedometer with INT1 pin
  if (LSM6DSV16X.Enable_Pedometer(LSM6DSV16X_INT1_PIN) != LSM6DSV16X_OK) {
    Serial.println("Failed to enable pedometer");
    while(1);
  }

  previous_tick = millis();
  Serial.println("Pedometer enabled - start walking!");
}

void loop() {
  // Handle interrupt-driven step detection
  if (mems_event) {
    mems_event = 0;
    LSM6DSV16X_Event_Status_t status;
    LSM6DSV16X.Get_X_Event_Status(&status);

    if (status.StepStatus) {
      digitalWrite(LED_BUILTIN, HIGH);
      delay(100);
      digitalWrite(LED_BUILTIN, LOW);

      LSM6DSV16X.Get_Step_Count(&step_count);
      snprintf(report, sizeof(report), "Step counter: %d", step_count);
      Serial.println(report);
    }
  }

  // Print step counter every 3 seconds
  uint32_t current_tick = millis();
  if ((current_tick - previous_tick) >= 3000) {
    LSM6DSV16X.Get_Step_Count(&step_count);
    snprintf(report, sizeof(report), "Step counter: %d", step_count);
    Serial.println(report);
    previous_tick = millis();
  }
}

```

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

### Enable LSM6DSV16X Event Detection (Arduino C++)

Source: https://context7.com/stm32duino/lsm6dsv16x/llms.txt

This C++ code configures the LSM6DSV16X sensor to detect free fall, wake up, tilt, and 6D orientation events. It utilizes interrupts attached to specific pins to trigger callback functions when an event occurs. The code initializes the sensor, enables the desired features with specific thresholds and durations, and then processes these events in the main loop, printing status messages to the serial monitor. Dependencies include the LSM6DSV16XSensor library and Arduino's Wire library for I2C communication.

```cpp
#include <LSM6DSV16XSensor.h>

#define INT1_pin PA4
#define INT2_pin PA5

LSM6DSV16XSensor sensor(&Wire);
volatile int int1_event = 0;
volatile int int2_event = 0;

void INT1Event_cb() {
  int1_event = 1;
}

void INT2Event_cb() {
  int2_event = 1;
}

void setup() {
  Serial.begin(115200);
  Wire.begin();
  pinMode(LED_BUILTIN, OUTPUT);

  // Configure interrupts
  attachInterrupt(INT1_pin, INT1Event_cb, RISING);
  attachInterrupt(INT2_pin, INT2Event_cb, RISING);

  // Initialize sensor
  sensor.begin();
  sensor.Enable_X();

  // Enable Free Fall Detection on INT1
  sensor.Enable_Free_Fall_Detection(LSM6DSV16X_INT1_PIN);
  sensor.Set_Free_Fall_Threshold(3);  // Set threshold
  sensor.Set_Free_Fall_Duration(3);   // Set duration

  // Enable Wake Up Detection on INT2
  sensor.Enable_Wake_Up_Detection(LSM6DSV16X_INT2_PIN);
  sensor.Set_Wake_Up_Threshold(63);   // Set threshold
  sensor.Set_Wake_Up_Duration(0);     // Set duration

  // Enable Tilt Detection on INT1
  sensor.Enable_Tilt_Detection(LSM6DSV16X_INT1_PIN);

  // Enable 6D Orientation Detection on INT1
  sensor.Enable_6D_Orientation(LSM6DSV16X_INT1_PIN);
  sensor.Set_6D_Orientation_Threshold(2);

  Serial.println("Event detection enabled:");
  Serial.println("- Free Fall (INT1)");
  Serial.println("- Wake Up (INT2)");
  Serial.println("- Tilt (INT1)");
  Serial.println("- 6D Orientation (INT1)");
}

void loop() {
  LSM6DSV16X_Event_Status_t status;

  // Handle INT1 events
  if (int1_event) {
    int1_event = 0;
    sensor.Get_X_Event_Status(&status);

    if (status.FreeFallStatus) {
      Serial.println("FREE FALL DETECTED!");
      digitalWrite(LED_BUILTIN, HIGH);
      delay(100);
      digitalWrite(LED_BUILTIN, LOW);
    }

    if (status.TiltStatus) {
      Serial.println("TILT DETECTED!");
    }

    if (status.D6DOrientationStatus) {
      uint8_t xl, xh, yl, yh, zl, zh;
      sensor.Get_6D_Orientation_XL(&xl);
      sensor.Get_6D_Orientation_XH(&xh);
      sensor.Get_6D_Orientation_YL(&yl);
      sensor.Get_6D_Orientation_YH(&yh);
      sensor.Get_6D_Orientation_ZL(&zl);
      sensor.Get_6D_Orientation_ZH(&zh);

      Serial.print("6D Orientation: ");
      if (xl) Serial.print("XL ");
      if (xh) Serial.print("XH ");
      if (yl) Serial.print("YL ");
      if (yh) Serial.print("YH ");
      if (zl) Serial.print("ZL ");
      if (zh) Serial.print("ZH ");
      Serial.println();
    }
  }

  // Handle INT2 events
  if (int2_event) {
    int2_event = 0;
    sensor.Get_X_Event_Status(&status);

    if (status.WakeUpStatus) {
      Serial.println("WAKE UP DETECTED!");
    }
  }
}

```

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

### Configure LSM6DSV16X Output Data Rate and Full Scale

Source: https://context7.com/stm32duino/lsm6dsv16x/llms.txt

Sets custom output data rates (ODR) and full-scale ranges (FS) for the accelerometer and gyroscope. It also verifies and prints the configured settings to the serial monitor. This function requires the sensor to be initialized and enabled.

```cpp
#include <LSM6DSV16XSensor.h>

LSM6DSV16XSensor sensor(&Wire);

void setup() {
  Serial.begin(115200);
  Wire.begin();
  sensor.begin();
  sensor.Enable_X();
  sensor.Enable_G();

  // Set accelerometer ODR to 104 Hz and full scale to 2g
  if (sensor.Set_X_ODR(104.0f) != LSM6DSV16X_OK) {
    Serial.println("Failed to set accelerometer ODR");
  }
  if (sensor.Set_X_FS(2) != LSM6DSV16X_OK) {
    Serial.println("Failed to set accelerometer full scale");
  }

  // Set gyroscope ODR to 104 Hz and full scale to 2000 dps
  if (sensor.Set_G_ODR(104.0f) != LSM6DSV16X_OK) {
    Serial.println("Failed to set gyroscope ODR");
  }
  if (sensor.Set_G_FS(2000) != LSM6DSV16X_OK) {
    Serial.println("Failed to set gyroscope full scale");
  }

  // Verify settings
  float acc_odr, gyro_odr;
  int32_t acc_fs, gyro_fs;
  sensor.Get_X_ODR(&acc_odr);
  sensor.Get_X_FS(&acc_fs);
  sensor.Get_G_ODR(&gyro_odr);
  sensor.Get_G_FS(&gyro_fs);

  Serial.print("Accelerometer - ODR: ");
  Serial.print(acc_odr);
  Serial.print(" Hz, FS: ");
  Serial.print(acc_fs);
  Serial.println(" g");
  Serial.print("Gyroscope - ODR: ");
  Serial.print(gyro_odr);
  Serial.print(" Hz, FS: ");
  Serial.print(gyro_fs);
  Serial.println(" dps");
}

void loop() {
  // Sensor configured and ready
}
```

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

### Read Accelerometer and Gyroscope Data

Source: https://context7.com/stm32duino/lsm6dsv16x/llms.txt

Continuously reads and prints accelerometer data in milligravity (mg) and gyroscope data in milli-degrees per second (mdps). This function assumes the sensor is already initialized and enabled. It uses the built-in LED to indicate activity.

```cpp
#include <LSM6DSV16XSensor.h>

LSM6DSV16XSensor sensor(&Wire);
int32_t accel[3], angrate[3];

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  Serial.begin(115200);
  Wire.begin();
  sensor.begin();
  sensor.Enable_X();
  sensor.Enable_G();
}

void loop() {
  // Read accelerometer data (output in mg - milligravity)
  sensor.Get_X_Axes(accel);

  // Read gyroscope data (output in mdps - milli-degrees per second)
  sensor.Get_G_Axes(angrate);

  // Print accelerometer data
  Serial.print("Accel-X[mg]:");
  Serial.print(accel[0]);
  Serial.print(",Accel-Y[mg]:");
  Serial.print(accel[1]);
  Serial.print(",Accel-Z[mg]:");
  Serial.println(accel[2]);

  // Print gyroscope data
  Serial.print("AngRate-X[mdps]:");
  Serial.print(angrate[0]);
  Serial.print(",AngRate-Y[mdps]:");
  Serial.print(angrate[1]);
  Serial.print(",AngRate-Z[mdps]:");
  Serial.println(angrate[2]);

  digitalWrite(LED_BUILTIN, HIGH);
  delay(25);
  digitalWrite(LED_BUILTIN, LOW);
  delay(975);
}
```

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

### Read LSM6DSV16X Accel/Gyro Data from FIFO (C++)

Source: https://context7.com/stm32duino/lsm6dsv16x/llms.txt

This C++ code snippet configures the LSM6DSV16X sensor to use its FIFO buffer in streaming mode. It sets up accelerometer and gyroscope data rate and full-scale ranges, then continuously checks the FIFO for data. When a threshold is met, it reads and parses accelerometer and gyroscope data, storing it with timestamps. Dependencies include the LSM6DSV16XSensor library and Wire for I2C communication.

```cpp
#include <LSM6DSV16XSensor.h>

#define SENSOR_ODR 104.0f
#define ACC_FS 2
#define GYR_FS 2000
#define MEASUREMENT_TIME_INTERVAL (1000.0f/SENSOR_ODR)
#define FIFO_SAMPLE_THRESHOLD 199
#define FLASH_BUFF_LEN 8192

LSM6DSV16XSensor AccGyr(&Wire);
uint8_t status = 0;
unsigned long timestamp_count = 0;
bool acc_available = false;
bool gyr_available = false;
int32_t acc_value[3];
int32_t gyr_value[3];
char buff[FLASH_BUFF_LEN];
uint32_t pos = 0;

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

  // Initialize sensor
  AccGyr.begin();
  status |= AccGyr.Enable_X();
  status |= AccGyr.Enable_G();

  // Configure ODR and FS
  status |= AccGyr.Set_X_ODR(SENSOR_ODR);
  status |= AccGyr.Set_X_FS(ACC_FS);
  status |= AccGyr.Set_G_ODR(SENSOR_ODR);
  status |= AccGyr.Set_G_FS(GYR_FS);

  // Configure FIFO BDR
  status |= AccGyr.FIFO_Set_X_BDR(SENSOR_ODR);
  status |= AccGyr.FIFO_Set_G_BDR(SENSOR_ODR);

  // Set FIFO in Continuous mode
  status |= AccGyr.FIFO_Set_Mode(LSM6DSV16X_STREAM_MODE);

  if (status != LSM6DSV16X_OK) {
    Serial.println("LSM6DSV16X Sensor failed to init/configure");
    while (1);
  }
  Serial.println("LSM6DSV16X FIFO Demo");
}

void loop() {
  uint16_t fifo_samples;

  // Check the number of samples inside FIFO
  if (AccGyr.FIFO_Get_Num_Samples(&fifo_samples) != LSM6DSV16X_OK) {
    Serial.println("Failed to get FIFO samples");
    while (1);
  }

  // If we reach the threshold, empty the FIFO
  if (fifo_samples > FIFO_SAMPLE_THRESHOLD) {
    Read_FIFO_Data();
    Serial.print(buff);
  }
}

void Read_FIFO_Data() {
  uint16_t samples_to_read;

  if (AccGyr.FIFO_Get_Num_Samples(&samples_to_read) != LSM6DSV16X_OK) {
    Serial.println("Failed to get FIFO samples");
    while (1);
  }

  for (uint16_t i = 0; i < samples_to_read; i++) {
    uint8_t tag;

    // Check the FIFO tag
    if (AccGyr.FIFO_Get_Tag(&tag) != LSM6DSV16X_OK) {
      Serial.println("Failed to get tag");
      while (1);
    }

    switch (tag) {
      case 1: // Gyro tag
        if (AccGyr.FIFO_Get_G_Axes(gyr_value) != LSM6DSV16X_OK) {
          Serial.println("Failed to get gyroscope data");
          while (1);
        }
        gyr_available = true;
        break;

      case 2: // Acc tag
        if (AccGyr.FIFO_Get_X_Axes(acc_value) != LSM6DSV16X_OK) {
          Serial.println("Failed to get accelerometer data");
          while (1);
        }
        acc_available = true;
        break;

      default:
        break;
    }

    // Store measurements with timestamp when both are available
    if (acc_available && gyr_available) {
      int num_bytes = snprintf(&buff[pos], (FLASH_BUFF_LEN - pos), 
                               "%lu %d %d %d %d %d %d\r\n", 
                               (unsigned long)((float)timestamp_count * MEASUREMENT_TIME_INTERVAL),
                               (int)acc_value[0], (int)acc_value[1], (int)acc_value[2],
                               (int)gyr_value[0], (int)gyr_value[1], (int)gyr_value[2]);
      pos += num_bytes;
      timestamp_count++;
      acc_available = false;
      gyr_available = false;
    }
  }

  // Add termination character
  buff[pos] = '\0';
  pos = 0;
}

```

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

### Read Accelerometer and Gyroscope Data LSM6DSV16X Arduino

Source: https://github.com/stm32duino/lsm6dsv16x/blob/main/README.md

Shows how to retrieve accelerometer and gyroscope readings from the LSM6DSV16X sensor. This code snippet assumes the sensor has been initialized and enabled for both axes. The data is stored in integer arrays.

```cpp
int32_t accelerometer[3];
int32_t gyroscope[3];
AccGyr.Get_X_Axes(accelerometer);
AccGyr.Get_G_Axes(gyroscope);
```

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

### Detect Double Tap Events with LSM6DSV16X

Source: https://context7.com/stm32duino/lsm6dsv16x/llms.txt

This code demonstrates how to enable and detect double tap gestures using the LSM6DSV16X sensor. It configures the sensor to trigger an interrupt on the INT1 pin when a double tap is detected. The output includes serial messages and LED blinking to indicate detection. It requires the LSM6DSV16XSensor library.

```cpp
#include <LSM6DSV16XSensor.h>

#define INT1_pin PA4

LSM6DSV16XSensor LSM6DSV16X(&Wire);

volatile int mems_event = 0;

void INT1Event_cb() {
  mems_event = 1;
}

void setup() {
  Serial.begin(115200);
  delay(1000);
  pinMode(LED_BUILTIN, OUTPUT);
  Wire.begin();

  // Enable interrupt pin
  attachInterrupt(INT1_pin, INT1Event_cb, RISING);

  // Initialize components
  LSM6DSV16X.begin();
  LSM6DSV16X.Enable_X();

  // Enable Double Tap Detection
  if (LSM6DSV16X.Enable_Double_Tap_Detection(LSM6DSV16X_INT1_PIN) != LSM6DSV16X_OK) {
    Serial.println("Failed to enable double tap detection");
    while(1);
  }

  Serial.println("Double tap detection enabled");
}

void loop() {
  if (mems_event) {
    mems_event = 0;
    LSM6DSV16X_Event_Status_t status;
    LSM6DSV16X.Get_X_Event_Status(&status);

    if (status.DoubleTapStatus) {
      // Visual and serial notification
      digitalWrite(LED_BUILTIN, HIGH);
      delay(100);
      digitalWrite(LED_BUILTIN, LOW);
      Serial.println("Double Tap Detected!");
    }
  }
}

```

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