Lesson 12: 3-Axis Accelerometer (LSM6DS3TR)

/*
  Vumbua Synapse Kit - I2C Scanner
  Scan I2C bus for connected devices
  Should detect LSM6DS3TR at address 0x6B
*/

#include 

void setup() {
  Wire.begin();
  Serial.begin(9600);
  
  Serial.println("\nI2C Scanner for Vumbua Synapse Kit");
  Serial.println("=================================");
  Serial.println("Scanning I2C bus for devices...");
  Serial.println();
}

void loop() {
  byte error, address;
  int nDevices = 0;
  
  Serial.println("Scanning...");
  
  for (address = 1; address < 127; address++) {
    // The i2c_scanner uses the return value of
    // the Write.endTransmission to see if
    // a device acknowledged the address.
    Wire.beginTransmission(address);
    error = Wire.endTransmission();
    
    if (error == 0) {
      Serial.print("I2C device found at address 0x");
      if (address < 16) {
        Serial.print("0");
      }
      Serial.print(address, HEX);
      Serial.print(" (");
      Serial.print(address);
      Serial.println(" decimal)");
      
      // Check for LSM6DS3TR
      if (address == 0x6B || address == 0x6A) {
        Serial.println("  → This is likely the LSM6DS3TR accelerometer/gyroscope!");
      }
      
      nDevices++;
    }
  }
  
  if (nDevices == 0) {
    Serial.println("No I2C devices found\n");
  } else {
    Serial.println("Scan complete\n");
  }
  
  delay(5000);  // Wait 5 seconds before next scan
}

/*
  Vumbua Synapse Kit - Lesson 12: Basic Accelerometer Reading
  Read raw acceleration data from LSM6DS3TR sensor
  I2C Address: 0x6B
*/

#include 
#include "LSM6DS3TR.h"

// Create sensor object with I2C address 0x6B
LSM6DS3TR myIMU(I2C_MODE, 0x6B);

void setup() {
  Serial.begin(9600);
  
  Serial.println("Vumbua Synapse Kit - LSM6DS3TR Accelerometer");
  Serial.println("=============================================");
  
  // Initialize the sensor
  if (myIMU.begin() != 0) {
    Serial.println("ERROR: LSM6DS3TR not detected!");
    Serial.println("Please check:");
    Serial.println("1. I2C connections (SDA=A4, SCL=A5)");
    Serial.println("2. I2C address (try 0x6A if 0x6B fails)");
    Serial.println("3. Power supply (3.3V)");
    while (1);  // Stop program
  } else {
    Serial.println("LSM6DS3TR initialized successfully!");
    Serial.println("Move the Vumbua Kit to see acceleration values change");
    Serial.println();
  }
  
  // Configure sensor settings
  myIMU.settings.gyroEnabled = 1;      // Enable gyroscope
  myIMU.settings.accelEnabled = 1;     // Enable accelerometer
  myIMU.settings.accelRange = 4;       // ±4g range
  myIMU.settings.gyroRange = 500;      // ±500 dps
  myIMU.settings.accelSampleRate = 416;  // 416 Hz
  myIMU.settings.gyroSampleRate = 416;   // 416 Hz
}

void loop() {
  // Read acceleration data (in g units)
  float ax = myIMU.readFloatAccelX();
  float ay = myIMU.readFloatAccelY();
  float az = myIMU.readFloatAccelZ();
  
  // Read gyroscope data (in dps units)
  float gx = myIMU.readFloatGyroX();
  float gy = myIMU.readFloatGyroY();
  float gz = myIMU.readFloatGyroZ();
  
  // Read temperature
  float temperature = myIMU.readTempC();
  
  // Display acceleration values
  Serial.print("Accel X: ");
  Serial.print(ax, 2);
  Serial.print("g | Y: ");
  Serial.print(ay, 2);
  Serial.print("g | Z: ");
  Serial.print(az, 2);
  Serial.println("g");
  
  // Display gyroscope values
  Serial.print("Gyro  X: ");
  Serial.print(gx, 1);
  Serial.print(" dps | Y: ");
  Serial.print(gy, 1);
  Serial.print(" dps | Z: ");
  Serial.print(gz, 1);
  Serial.println(" dps");
  
  // Display temperature
  Serial.print("Temperature: ");
  Serial.print(temperature, 1);
  Serial.println("°C");
  
  Serial.println("----------------------------------------");
  
  delay(200);  // Update 5 times per second
}

/*
  Vumbua Synapse Kit - Acceleration Visualizer
  Calculate and display total acceleration and vector components
*/

#include 
#include "LSM6DS3TR.h"
#include 

LSM6DS3TR myIMU(I2C_MODE, 0x6B);

void setup() {
  Serial.begin(115200);  // Higher baud rate for more data
  
  if (myIMU.begin() != 0) {
    Serial.println("Sensor initialization failed!");
    while (1);
  }
  
  Serial.println("Acceleration Visualizer Ready");
  Serial.println("AX,AY,AZ,TOTAL");  // Header for Serial Plotter
}

void loop() {
  // Read acceleration
  float ax = myIMU.readFloatAccelX();
  float ay = myIMU.readFloatAccelY();
  float az = myIMU.readFloatAccelZ();
  
  // Calculate total acceleration
  float total = sqrt(ax * ax + ay * ay + az * az);
  
  // For Serial Monitor display
  Serial.print("X:"); Serial.print(ax, 3);
  Serial.print("g Y:"); Serial.print(ay, 3);
  Serial.print("g Z:"); Serial.print(az, 3);
  Serial.print("g Total:"); Serial.print(total, 3); Serial.println("g");
  
  // For Serial Plotter (Tools → Serial Plotter)
  // Uncomment for graphing:
  // Serial.print(ax); Serial.print(",");
  // Serial.print(ay); Serial.print(",");
  // Serial.print(az); Serial.print(",");
  // Serial.println(total);
  
  delay(50);  // 20 Hz update rate
}

/*
  Vumbua Synapse Kit - Tilt Detector
  Calculate pitch and roll angles from accelerometer data
*/

#include 
#include "LSM6DS3TR.h"
#include 

LSM6DS3TR myIMU(I2C_MODE, 0x6B);

// Function to convert radians to degrees
float radToDeg(float radians) {
  return radians * 180.0 / PI;
}

void setup() {
  Serial.begin(9600);
  
  if (myIMU.begin() != 0) {
    Serial.println("Sensor initialization failed!");
    while (1);
  }
  
  Serial.println("Vumbua Tilt Detector");
  Serial.println("====================");
  Serial.println("Tilt the board to see pitch and roll angles change");
  Serial.println();
}

void loop() {
  // Read acceleration
  float ax = myIMU.readFloatAccelX();
  float ay = myIMU.readFloatAccelY();
  float az = myIMU.readFloatAccelZ();
  
  // Calculate pitch (rotation around X-axis)
  // Pitch: forward/backward tilt
  float pitch = atan2(-ax, sqrt(ay * ay + az * az));
  
  // Calculate roll (rotation around Y-axis)
  // Roll: left/right tilt
  float roll = atan2(ay, az);
  
  // Convert to degrees
  pitch = radToDeg(pitch);
  roll = radToDeg(roll);
  
  // Determine orientation
  String orientation = "Unknown";
  
  if (abs(pitch) < 15 && abs(roll) < 15) {
    if (az > 0.8) {
      orientation = "Flat (face up)";
    } else if (az < -0.8) {
      orientation = "Flat (face down)";
    }
  } else if (pitch > 45) {
    orientation = "Tilted Forward";
  } else if (pitch < -45) {
    orientation = "Tilted Backward";
  } else if (roll > 45) {
    orientation = "Tilted Right";
  } else if (roll < -45) {
    orientation = "Tilted Left";
  }
  
  // Display results
  Serial.print("Pitch: ");
  Serial.print(pitch, 1);
  Serial.print("° | Roll: ");
  Serial.print(roll, 1);
  Serial.print("° | Orientation: ");
  Serial.println(orientation);
  
  // Simple visual indicator
  int pitchBars = map(int(pitch), -90, 90, 0, 20);
  int rollBars = map(int(roll), -90, 90, 0, 20);
  
  Serial.print("Pitch: [");
  for (int i = 0; i < 20; i++) {
    Serial.print(i == pitchBars ? "|" : "-");
  }
  Serial.print("] Roll: [");
  for (int i = 0; i < 20; i++) {
    Serial.print(i == rollBars ? "|" : "-");
  }
  Serial.println("]");
  
  delay(200);
}

/*
  Vumbua Synapse Kit - Orientation Tracker
  Complementary filter combining accelerometer and gyroscope
*/

#include 
#include "LSM6DS3TR.h"
#include 

LSM6DS3TR myIMU(I2C_MODE, 0x6B);

// Variables for complementary filter
float pitch = 0, roll = 0;
float gyroAngleX = 0, gyroAngleY = 0;
unsigned long lastTime = 0;

// Complementary filter constant (0-1)
// Closer to 1 = trust accelerometer more
// Closer to 0 = trust gyroscope more
const float alpha = 0.98;

float radToDeg(float radians) {
  return radians * 180.0 / PI;
}

void setup() {
  Serial.begin(115200);
  
  if (myIMU.begin() != 0) {
    Serial.println("Sensor initialization failed!");
    while (1);
  }
  
  // Configure for high performance
  myIMU.settings.gyroEnabled = 1;
  myIMU.settings.accelEnabled = 1;
  myIMU.settings.accelRange = 4;
  myIMU.settings.gyroRange = 500;
  myIMU.settings.accelSampleRate = 104;
  myIMU.settings.gyroSampleRate = 104;
  
  lastTime = millis();
  Serial.println("Vumbua Orientation Tracker Ready");
}

void loop() {
  // Calculate time difference
  unsigned long currentTime = millis();
  float dt = (currentTime - lastTime) / 1000.0;  // in seconds
  lastTime = currentTime;
  
  // Read sensor data
  float ax = myIMU.readFloatAccelX();
  float ay = myIMU.readFloatAccelY();
  float az = myIMU.readFloatAccelZ();
  
  float gx = myIMU.readFloatGyroX();
  float gy = myIMU.readFloatGyroY();
  float gz = myIMU.readFloatGyroZ();
  
  // Calculate angles from accelerometer (in radians)
  float accelPitch = atan2(-ax, sqrt(ay * ay + az * az));
  float accelRoll = atan2(ay, az);
  
  // Convert to degrees
  accelPitch = radToDeg(accelPitch);
  accelRoll = radToDeg(accelRoll);
  
  // Calculate angles from gyroscope (integration)
  gyroAngleX += gx * dt;  // Pitch from gyro
  gyroAngleY += gy * dt;  // Roll from gyro
  
  // Complementary filter: combine accelerometer and gyroscope
  pitch = alpha * (pitch + gx * dt) + (1 - alpha) * accelPitch;
  roll = alpha * (roll + gy * dt) + (1 - alpha) * accelRoll;
  
  // Display results
  Serial.print("Accel Pitch: ");
  Serial.print(accelPitch, 1);
  Serial.print("° | Gyro Pitch: ");
  Serial.print(gyroAngleX, 1);
  Serial.print("° | Filtered: ");
  Serial.print(pitch, 1);
  Serial.println("°");
  
  // Optional: Send to Serial Plotter
  // Serial.print(accelPitch); Serial.print(",");
  // Serial.print(gyroAngleX); Serial.print(",");
  // Serial.println(pitch);
  
  // Small delay for stability
  delay(10);  // ~100 Hz update rate
}

/*
  Vumbua Synapse Kit - Tap Detection Example
  Detect single and double taps using LSM6DS3TR
*/

#include 
#include "LSM6DS3TR.h"

LSM6DS3TR myIMU(I2C_MODE, 0x6B);

unsigned long lastTapTime = 0;
int tapCount = 0;

void setup() {
  Serial.begin(9600);
  
  if (myIMU.begin() != 0) {
    Serial.println("Sensor initialization failed!");
    while (1);
  }
  
  // Configure for tap detection
  // Note: Actual tap configuration requires low-level register access
  // This example uses threshold-based software detection
  
  Serial.println("Tap Detector Ready");
  Serial.println("Tap the Vumbua Kit gently");
}

void loop() {
  static float lastAccel = 0;
  static bool tapDetected = false;
  
  float ax = myIMU.readFloatAccelX();
  float ay = myIMU.readFloatAccelY();
  float az = myIMU.readFloatAccelZ();
  
  // Calculate total acceleration change
  float totalAccel = sqrt(ax * ax + ay * ay + az * az);
  float accelChange = abs(totalAccel - lastAccel);
  lastAccel = totalAccel;
  
  // Simple tap detection based on acceleration change
  if (accelChange > 0.5 && !tapDetected) {  // Threshold for tap
    tapDetected = true;
    
    unsigned long currentTime = millis();
    
    if (currentTime - lastTapTime < 500) {  // 500ms window for double tap
      tapCount++;
      if (tapCount == 2) {
        Serial.println("DOUBLE TAP DETECTED!");
        tapCount = 0;
      }
    } else {
      tapCount = 1;
      Serial.println("Single tap detected");
    }
    
    lastTapTime = currentTime;
    
    // Debounce: ignore new taps for 100ms
    delay(100);
    tapDetected = false;
  }
  
  delay(10);
}

/*
  Vumbua Synapse Kit - Motion-Activated Security System
  Detects unauthorized movement and triggers alarm
*/

#include 
#include "LSM6DS3TR.h"

LSM6DS3TR myIMU(I2C_MODE, 0x6B);

const int buzzerPin = 3;
const int ledPin = 9;
const int buttonPin = 2;

bool systemArmed = false;
bool alarmTriggered = false;
float baseAccel = 0;

void setup() {
  Serial.begin(9600);
  
  pinMode(buzzerPin, OUTPUT);
  pinMode(ledPin, OUTPUT);
  pinMode(buttonPin, INPUT_PULLUP);
  
  if (myIMU.begin() != 0) {
    Serial.println("Sensor initialization failed!");
    while (1);
  }
  
  Serial.println("Motion Security System");
  Serial.println("Press button to arm/disarm");
  
  // Calibrate baseline acceleration
  calibrateSensor();
}

void calibrateSensor() {
  Serial.println("Calibrating... Do not move the device.");
  
  float sum = 0;
  for (int i = 0; i < 100; i++) {
    float ax = myIMU.readFloatAccelX();
    float ay = myIMU.readFloatAccelY();
    float az = myIMU.readFloatAccelZ();
    sum += sqrt(ax * ax + ay * ay + az * az);
    delay(10);
  }
  baseAccel = sum / 100;
  
  Serial.print("Baseline acceleration: ");
  Serial.print(baseAccel, 3);
  Serial.println("g");
}

void loop() {
  // Check arm/disarm button
  if (digitalRead(buttonPin) == LOW) {
    delay(50);  // Debounce
    if (digitalRead(buttonPin) == LOW) {
      systemArmed = !systemArmed;
      if (systemArmed) {
        Serial.println("System ARMED");
        digitalWrite(ledPin, HIGH);
        calibrateSensor();  // Recalibrate when arming
      } else {
        Serial.println("System DISARMED");
        digitalWrite(ledPin, LOW);
        alarmTriggered = false;
        noTone(buzzerPin);
      }
      while (digitalRead(buttonPin) == LOW);  // Wait for release
    }
  }
  
  // If system is armed, monitor for motion
  if (systemArmed && !alarmTriggered) {
    float ax = myIMU.readFloatAccelX();
    float ay = myIMU.readFloatAccelY();
    float az = myIMU.readFloatAccelZ();
    
    float currentAccel = sqrt(ax * ax + ay * ay + az * az);
    float deviation = abs(currentAccel - baseAccel);
    
    if (deviation > 0.1) {  // Motion threshold
      Serial.println("MOTION DETECTED! ALARM!");
      alarmTriggered = true;
    }
  }
  
  // Trigger alarm if motion detected
  if (alarmTriggered) {
    tone(buzzerPin, 1000);
    delay(100);
    tone(buzzerPin, 1500);
    delay(100);
  }
  
  delay(50);
}