Arduino Basics – Exercise

const int buttonPin = 2;
const int ledPin = 13;

int buttonState = 0;

void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(buttonPin, INPUT);
}

void loop() {
  buttonState = digitalRead(buttonPin);

  if (buttonState == HIGH) {
    digitalWrite(ledPin, HIGH);
  } else {
    digitalWrite(ledPin, LOW);
  }
}

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  int potValue = analogRead(A0);      // Read potentiometer (0-1023)
  int brightness = map(potValue, 0, 1023, 0, 255);  // Map to LED brightness (0-255)
  
  analogWrite(LED_BUILTIN, brightness);  // Set LED brightness
  delay(10);
}

int lastButtonState = HIGH;
unsigned long lastPropellerTime = 0;
unsigned long propellerDelay = 50;
 
void setup() {
  pinMode(2, INPUT);
  pinMode(LED_BUILTIN, OUTPUT);
}
 
void loop() {
  int reading = digitalRead(2);
  
  if (reading != lastButtonState) {
    lastPropellerTime = millis();
  }
  
  if ((millis() - lastPropellerTime) > propellerDelay) {
    if (reading == HIGH) {
      digitalWrite(LED_BUILTIN, HIGH);
    } else {
      digitalWrite(LED_BUILTIN, LOW);
    }
  }
  
  lastButtonState = reading;
}

#include <Servo.h>

Servo myservo;  

int potpin = A0; 
int val;    

void setup() {
  myservo.attach(9); 
}

void loop() {
  val = analogRead(potpin);           
  val = map(val, 0, 1023, 180, 0);     
  myservo.write(val);                  
  delay(15);                           
}

int redPin = 9;
int greenPin = 10;
int bluePin = 11;

void setup() {
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
}

void loop() {
  // Red
  analogWrite(redPin, 255);
  analogWrite(greenPin, 0);
  analogWrite(bluePin, 0);
  delay(1000);
  
  // Green
  analogWrite(redPin, 0);
  analogWrite(greenPin, 255);
  analogWrite(bluePin, 0);
  delay(1000);
  
  // Blue
  analogWrite(redPin, 0);
  analogWrite(greenPin, 0);
  analogWrite(bluePin, 255);
  delay(1000);
}

const int trigPin = 10;
const int echoPin = 9;

void setup() {
  Serial.begin(9600);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
}

void loop() {
  // Send trigger pulse
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  
  // Read echo pulse
  long duration = pulseIn(echoPin, HIGH);
  
  // Calculate distance in cm
  int distance = duration * 0.034 / 2;
  
  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.println(" cm");
  
  delay(500);
}

#include <afstandssensor.h>

AfstandsSensor afstandssensor(13, 12);
const int outPin = 9;

int dist;

void setup() {
  pinMode(outPin, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  dist = afstandssensor.afstandCM();
  Serial.println(dist);
  analogWrite(outPin, map(dist, 0, 100, 0, 255));
  delay(50);
}

#include <FastLED.h>
FASTLED_USING_NAMESPACE

#define DATA_PIN    6
#define LED_TYPE    WS2811
#define COLOR_ORDER GRB
#define NUM_LEDS    8
CRGB leds[NUM_LEDS];

#define BRIGHTNESS          96
#define FRAMES_PER_SECOND  120

void setup() {
  delay(3000);
  FastLED.addLeds<LED_TYPE,DATA_PIN,COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalLEDStrip);
  FastLED.setBrightness(BRIGHTNESS);
}

uint8_t gHue = 0;

void loop() {
  bpm();
  FastLED.show();  
  FastLED.delay(1000/FRAMES_PER_SECOND);
  EVERY_N_MILLISECONDS( 20 ) { gHue++; }
}

void bpm() {
  uint8_t BeatsPerMinute = 62;
  CRGBPalette16 palette = PartyColors_p;
  uint8_t beat = beatsin8( BeatsPerMinute, 64, 255);
  for( int i = 0; i < NUM_LEDS; i++) {
    leds[i] = ColorFromPalette(palette, gHue+(i*2), beat-gHue+(i*10));
  }
}

#include <DHT.h>

#define DHTPIN 2
#define DHTTYPE DHT11

DHT dht(DHTPIN, DHTTYPE);

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

void loop() {
  // Wait 2 seconds between measurements
  delay(2000);
  
  // Read humidity
  float humidity = dht.readHumidity();
  
  // Read temperature in Celsius
  float temperature = dht.readTemperature();
  
  // Check if readings failed
  if (isnan(humidity) || isnan(temperature)) {
    Serial.println("Failed to read from DHT sensor!");
    return;
  }
  
  Serial.print("Humidity: ");
  Serial.print(humidity);
  Serial.print(" %  Temperature: ");
  Serial.print(temperature);
  Serial.println(" °C");
}

/*
 * Button Press Duration Measurement using Interrupts
 * 
 * Hardware Setup:
 * - Connect button between pin 2 and GND
 * - Use internal pull-up resistor (button pressed = LOW)
 * - Or use external pull-up resistor
 * 
 * How it Works:
 * - FALLING interrupt: triggered when button is pressed (HIGH to LOW)
 * - RISING interrupt: triggered when button is released (LOW to HIGH)
 * - Calculates duration = release time - press time
 * - Uses debouncing to filter out noise
 */

const int buttonPin = 2;
volatile unsigned long pressStartTime = 0;  // When button was pressed
volatile unsigned long pressDuration = 0;   // Calculated duration
volatile bool buttonPressed = false;        // Button state flag
volatile bool newMeasurement = false;       // Flag for new measurement
volatile int pressCount = 0;                // Number of presses

void setup() {
  Serial.begin(9600);
  pinMode(buttonPin, INPUT_PULLUP);  // Enable internal pull-up resistor
  
  // Use CHANGE mode to detect both press and release
  // Note: Arduino Uno can only have one interrupt per pin
  attachInterrupt(digitalPinToInterrupt(buttonPin), buttonISR, CHANGE);
  
  Serial.println("Button Press Duration Measurement");
  Serial.println("Press and hold the button...");
  Serial.println("--------------------------------");
}

void loop() {
  // Display results when button is released
  if (newMeasurement) {
    newMeasurement = false;  // Clear flag
    
    pressCount++;
    Serial.print("Press #");
    Serial.print(pressCount);
    Serial.print(": Duration = ");
    Serial.print(pressDuration);
    Serial.print(" ms (");
    Serial.print(pressDuration / 1000.0);
    Serial.println(" seconds)");
    
    pressDuration = 0;  // Reset for next measurement
  }
  
  delay(10);  // Small delay to prevent excessive CPU usage
}

/*
 * Interrupt Service Routine for button state change
 * Triggered on both press (HIGH to LOW) and release (LOW to HIGH)
 * Uses CHANGE mode to detect both edges
 */
void buttonISR() {
  static unsigned long lastInterruptTime = 0;
  unsigned long currentTime = millis();
  
  // Debouncing: ignore interrupts within 50ms of last event
  if (currentTime - lastInterruptTime < 50) {
    return;  // Ignore bounce
  }
  lastInterruptTime = currentTime;
  
  // Read current button state (LOW = pressed, HIGH = released)
  bool currentState = digitalRead(buttonPin);
  
  if (currentState == LOW) {
    // Button pressed (FALLING edge)
    if (!buttonPressed) {  // Only record if button wasn't already pressed
      pressStartTime = currentTime;
      buttonPressed = true;
      Serial.println("Button PRESSED");
    }
  } else {
    // Button released (RISING edge)
    if (buttonPressed) {  // Only calculate if button was actually pressed
      // Calculate duration
      pressDuration = currentTime - pressStartTime;
      buttonPressed = false;
      newMeasurement = true;  // Signal that new measurement is ready
      Serial.println("Button RELEASED");
    }
  }
}

// Watchdog library for AVR microcontrollers
#include <avr/wdt.h>

unsigned long lastKick = 0;  // Time of last "kick"

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  Serial.begin(9600);
  delay(500);
  
  Serial.println("=== WATCHDOG TEST ===");
  Serial.println("Press ENTER to kick the dog!");
  Serial.println("If no kick in 4 sec, Arduino resets.");
  
  // Enable watchdog with 4 second timeout
  wdt_enable(WDTO_4S);
  
  lastKick = millis();
}

void loop() {
  // Check if user pressed ENTER
  if (Serial.available()) {
    Serial.read();  // Clear buffer
    Serial.println("✓ Kicked! Timer reset.");
    lastKick = millis();
  }
  
  // Calculate time since last kick
  unsigned long timeSinceKick = millis() - lastKick;
  
  // If time remaining
  if (timeSinceKick < 4000) {
    unsigned long remaining = (4000 - timeSinceKick) / 1000;
    Serial.print("Time left: ");
    Serial.print(remaining);
    Serial.println(" sec");
    
    digitalWrite(LED_BUILTIN, HIGH);  // LED on
    
    // IMPORTANT: Tell watchdog that program is running
    wdt_reset();
  } 
  else {
    // Time's up - LED off and DON'T call wdt_reset()
    digitalWrite(LED_BUILTIN, LOW);
    Serial.println("⚠ TIME'S UP! Watchdog will reset...");
    
    // Freeze program - watchdog will reset Arduino
    while(1) { }
  }
  
  delay(1000);
}

#include <Wire.h>

void setup() {
  Wire.begin();
  Serial.begin(9600);
  Serial.println("I2C Scanner");
}

void loop() {
  byte error, address;
  int nDevices = 0;
  
  for(address = 1; address < 127; address++) {
    Wire.beginTransmission(address);
    error = Wire.endTransmission();
    
    if (error == 0) {
      Serial.print("Device at 0x");
      if (address < 16) Serial.print("0");
      Serial.println(address, HEX);
      nDevices++;
    }
  }
  
  if (nDevices == 0) Serial.println("No devices found");
  delay(5000);
}

/*
 * MPU6050 Accelerometer and Gyroscope via I2C
 * 
 * Hardware Setup:
 * - Connect MPU6050 VCC to 5V (or 3.3V)
 * - Connect MPU6050 GND to GND
 * - Connect MPU6050 SCL to Arduino A5 (SCL)
 * - Connect MPU6050 SDA to Arduino A4 (SDA)
 * - I2C address: 0x68 (default)
 * 
 * MPU6050 Features:
 * - 3-axis accelerometer (measures acceleration)
 * - 3-axis gyroscope (measures rotation rate)
 * - Temperature sensor
 * - I2C interface
 * 
 * How it Works:
 * - Reads raw sensor data from MPU6050 registers
 * - Converts raw values to physical units (g for accelerometer, °/s for gyroscope)
 * - Displays values on Serial Monitor
 * 
 * Library Required:
 * - Wire.h (included with Arduino IDE)
 * 
 * Documentation:
 * - Arduino Reference: https://www.arduino.cc/reference/
 * - Wire Library: https://www.arduino.cc/reference/en/language/functions/communication/wire/
 * - MPU6050 Datasheet: https://www.invensense.com/products/motion-tracking/6-axis/mpu-6050/
 */

#include <Wire.h>

// MPU6050 I2C address
const int MPU6050_ADDR = 0x68;

// MPU6050 register addresses
const int MPU6050_PWR_MGMT_1 = 0x6B;  // Power management register
const int MPU6050_ACCEL_XOUT_H = 0x3B; // Accelerometer data registers
const int MPU6050_GYRO_XOUT_H = 0x43;  // Gyroscope data registers
const int MPU6050_TEMP_OUT_H = 0x41;   // Temperature register

// Sensitivity settings (from datasheet)
const float ACCEL_SENSITIVITY = 16384.0;  // LSB/g for ±2g range
const float GYRO_SENSITIVITY = 131.0;     // LSB/(°/s) for ±250°/s range

void setup() {
  Serial.begin(9600);
  Wire.begin();
  
  // Initialize MPU6050
  initMPU6050();
  
  Serial.println("MPU6050 Accelerometer & Gyroscope");
  Serial.println("====================================");
  delay(1000);
}

void loop() {
  // Read and display sensor data
  readAndDisplayMPU6050();
  
  delay(500);  // Update every 500ms
}

/*
 * Initialize MPU6050 sensor
 */
void initMPU6050() {
  // Wake up MPU6050 (exit sleep mode)
  Wire.beginTransmission(MPU6050_ADDR);
  Wire.write(MPU6050_PWR_MGMT_1);
  Wire.write(0);  // Set to 0 to wake up
  Wire.endTransmission();
  
  delay(100);  // Wait for sensor to stabilize
  
  Serial.println("MPU6050 initialized");
}

/*
 * Read 16-bit value from two consecutive registers
 */
int16_t read16BitRegister(uint8_t reg) {
  Wire.beginTransmission(MPU6050_ADDR);
  Wire.write(reg);
  Wire.endTransmission(false);  // Don't release bus
  Wire.requestFrom(MPU6050_ADDR, 2, true);  // Request 2 bytes
  
  // Read high and low bytes
  uint8_t highByte = Wire.read();
  uint8_t lowByte = Wire.read();
  
  // Combine bytes (high byte first, then low byte)
  return (int16_t)((highByte << 8) | lowByte);
}

/*
 * Read and display all MPU6050 sensor data
 */
void readAndDisplayMPU6050() {
  // Read accelerometer data (X, Y, Z)
  int16_t accelX = read16BitRegister(MPU6050_ACCEL_XOUT_H);
  int16_t accelY = read16BitRegister(MPU6050_ACCEL_XOUT_H + 2);
  int16_t accelZ = read16BitRegister(MPU6050_ACCEL_XOUT_H + 4);
  
  // Read gyroscope data (X, Y, Z)
  int16_t gyroX = read16BitRegister(MPU6050_GYRO_XOUT_H);
  int16_t gyroY = read16BitRegister(MPU6050_GYRO_XOUT_H + 2);
  int16_t gyroZ = read16BitRegister(MPU6050_GYRO_XOUT_H + 4);
  
  // Read temperature
  int16_t tempRaw = read16BitRegister(MPU6050_TEMP_OUT_H);
  
  // Convert to physical units
  float accelX_g = accelX / ACCEL_SENSITIVITY;
  float accelY_g = accelY / ACCEL_SENSITIVITY;
  float accelZ_g = accelZ / ACCEL_SENSITIVITY;
  
  float gyroX_dps = gyroX / GYRO_SENSITIVITY;  // degrees per second
  float gyroY_dps = gyroY / GYRO_SENSITIVITY;
  float gyroZ_dps = gyroZ / GYRO_SENSITIVITY;
  
  // Temperature conversion: T = (TEMP_OUT / 340) + 36.53
  float temperature = (tempRaw / 340.0) + 36.53;
  
  // Display results
  Serial.println("--- MPU6050 Data ---");
  
  Serial.print("Accelerometer (g): ");
  Serial.print("X=");
  Serial.print(accelX_g, 3);
  Serial.print(" Y=");
  Serial.print(accelY_g, 3);
  Serial.print(" Z=");
  Serial.println(accelZ_g, 3);
  
  Serial.print("Gyroscope (°/s): ");
  Serial.print("X=");
  Serial.print(gyroX_dps, 2);
  Serial.print(" Y=");
  Serial.print(gyroY_dps, 2);
  Serial.print(" Z=");
  Serial.println(gyroZ_dps, 2);
  
  Serial.print("Temperature: ");
  Serial.print(temperature, 2);
  Serial.println(" °C");
  
  Serial.println();
}

/*
 * Alternative: Read single axis (example for X-axis accelerometer)
 */
float readAccelX() {
  int16_t raw = read16BitRegister(MPU6050_ACCEL_XOUT_H);
  return raw / ACCEL_SENSITIVITY;
}

/*
 * Alternative: Read single axis (example for X-axis gyroscope)
 */
float readGyroX() {
  int16_t raw = read16BitRegister(MPU6050_GYRO_XOUT_H);
  return raw / GYRO_SENSITIVITY;
}

/*
 * DS18B20 Temperature Sensor with 1-Wire Protocol
 * 
 * Hardware Setup:
 * - Connect DS18B20 data pin to digital pin 2 (or any digital pin)
 * - Connect DS18B20 VCC to 5V (or 3.3V)
 * - Connect DS18B20 GND to GND
 * 
 * IMPORTANT: Pull-up Resistor Required
 * - A 4.7kΩ pull-up resistor is needed between the data pin and VCC
 * - This resistor ensures proper signal levels for 1-Wire communication
 * - Without the pull-up resistor, the sensor may not work correctly
 * 
 * NOTE: If using an adapter board/module for DS18B20, the pull-up resistor
 * is usually already included on the board, so no external resistor is needed.
 * 
 * IMPORTANT: Compatibility with ESP8266 and Other Peripherals
 * 
 * ESP8266 Wi-Fi Interrupts:
 * - OneWire protocol uses precise timing (delayMicroseconds) for communication
 * - Wi-Fi on ESP8266 uses timer interrupts that can interfere with OneWire timing
 * - If you experience communication errors, try:
 *   1. Disable Wi-Fi during temperature reading: WiFi.mode(WIFI_OFF) before reading
 *   2. Use yield() or delay() between readings to allow Wi-Fi tasks to run
 *   3. Consider using a separate task/thread for Wi-Fi if using RTOS
 * 
 * I2C Compatibility:
 * - I2C and OneWire can be used simultaneously without hardware conflicts
 * - They use different pins: I2C uses SDA/SCL (A4/A5 on Uno, D2/D1 on ESP8266)
 * - OneWire can use any digital pin (avoid using I2C pins for OneWire)
 * - No timer conflicts: I2C uses software or hardware I2C controller, OneWire uses
 *   software timing - they don't share the same hardware timers
 * - However, if both are used in interrupt handlers, there may be timing issues
 * 
 * Libraries Required:
 * - OneWire (by Paul Stoffregen)
 * - DallasTemperature (by Miles Burton)
 * 
 * Documentation:
 * - Arduino Reference: https://www.arduino.cc/reference/
 * - OneWire Library: https://www.arduino.cc/reference/en/libraries/onewire/
 * - DallasTemperature Library: https://www.arduino.cc/reference/en/libraries/dallastemperature/
 */

#include <OneWire.h>
#include <DallasTemperature.h>

#define ONE_WIRE_BUS 2  // Data pin connected to pin 2

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

void setup() {
  Serial.begin(9600);
  sensors.begin();
  
  Serial.println("DS18B20 Temperature Sensor");
  Serial.println("---------------------------");
}

void loop() {
  sensors.requestTemperatures();
  
  float tempC = sensors.getTempCByIndex(0);
  
  if (tempC != DEVICE_DISCONNECTED_C) {
    Serial.print("Temperature: ");
    Serial.print(tempC);
    Serial.print(" °C / ");
    Serial.print((tempC * 9.0 / 5.0) + 32.0);
    Serial.println(" °F");
  } else {
    Serial.println("Error: Could not read temperature");
  }
  
  delay(1000);
}

/*
 * Analog Comparator using Arduino Uno's Built-in Comparator
 * 
 * ============================================================
 * HARDWARE SETUP (Simple - Only One Potentiometer Needed):
 * ============================================================
 * - Connect potentiometer: middle pin to AIN0 (pin D6), outer pins to GND and 5V
 * - Optional: Connect LED to pin 13 (built-in LED) to show comparison result
 * - No connection needed to AIN1 (D7) - using internal 1.1V reference
 * 
 * ============================================================
 * HOW IT WORKS:
 * ============================================================
 * - Arduino Uno has a built-in analog comparator (AC) in the ATmega328P chip
 * - AIN0 (D6) is compared against internal 1.1V bandgap reference
 * - When AIN0 > 1.1V, comparator output is HIGH
 * - When AIN0 < 1.1V, comparator output is LOW
 * - The comparator can trigger interrupts on rising/falling edges
 * 
 * ============================================================
 * CHANGING THE REFERENCE VOLTAGE:
 * ============================================================
 * 
 * Option 1: Use External Reference on AIN1 (D7)
 *   - To use a different reference voltage, connect it to AIN1 (pin D7)
 *   - Change ACBG bit to 0: ACSR = (1 << ACIE) | (0 << ACBG) | ...
 *   - Hardware: Connect second potentiometer or voltage divider to AIN1 (D7)
 *   - This allows any reference voltage from 0V to VCC (5V)
 * 
 * Option 2: Use Voltage Divider for Fixed Reference
 *   - Create a voltage divider: R1 and R2 between 5V and GND
 *   - Connect junction to AIN1 (D7)
 *   - Reference voltage = 5V * R2 / (R1 + R2)
 *   - Example: R1 = 10kΩ, R2 = 10kΩ gives 2.5V reference
 *   - Set ACBG = 0 to use external reference
 * 
 * Option 3: Use Second Potentiometer for Adjustable Reference
 *   - Connect second potentiometer: middle pin to AIN1 (D7), outer pins to GND and 5V
 *   - Set ACBG = 0 to use external reference
 *   - Now you can adjust both input and reference voltages
 * 
 * NOTE: The internal 1.1V bandgap reference (ACBG = 1) is fixed and cannot be changed.
 *       It is stable, temperature-compensated, and independent of supply voltage.
 *       To use a different reference, you must use external reference (ACBG = 0).
 * 
 * ============================================================
 * INTERNAL BANDGAP REFERENCE (Current Configuration):
 * ============================================================
 * - ACBG bit = 1: Uses internal 1.1V reference for AIN1
 * - This eliminates the need for a second potentiometer or external reference
 * - The 1.1V reference is stable and temperature-compensated
 * - Cannot be changed - it's a fixed hardware reference
 * 
 * ============================================================
 * ADVANTAGES OF BUILT-IN COMPARATOR:
 * ============================================================
 * - Faster than ADC (no conversion delay)
 * - Lower power consumption
 * - Can trigger interrupts automatically
 * - Useful for threshold detection, zero-crossing detection, etc.
 * 
 * ============================================================
 * CODE MODIFICATION TO USE EXTERNAL REFERENCE:
 * ============================================================
 * To use external reference on AIN1 (D7) instead of internal 1.1V:
 * 
 *   1. Change this line in setup():
 *      ACSR = (1 << ACIE) | (0 << ACBG) | (0 << ACIS1) | (0 << ACIS0);
 *      // Change ACBG from 1 to 0
 * 
 *   2. Connect your reference voltage to AIN1 (pin D7)
 * 
 *   3. Update Serial messages to reflect your reference voltage
 * 
 * Documentation:
 * - Arduino Reference: https://www.arduino.cc/reference/
 * - AVR Analog Comparator: https://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-7810-Automotive-Microcontrollers-ATmega328P_Datasheet.pdf
 */

// AVR register definitions for analog comparator
#include <avr/io.h>
#include <avr/interrupt.h>

#define LED_PIN 13
#define REFERENCE_VOLTAGE 1.1  // Internal bandgap reference voltage

void setup() {
  Serial.begin(9600);
  pinMode(LED_PIN, OUTPUT);
  
  // Configure analog comparator
  // 
  // Register bits explanation:
  // - ACIE = 1: Enable analog comparator interrupt
  // - ACBG = 1: Use internal 1.1V bandgap reference for AIN1 (negative input)
  //            = 0: Use external reference on AIN1 (pin D7) - connect pot/voltage divider
  // - ACIS1 = 0, ACIS0 = 0: Trigger interrupt on comparator output toggle (any change)
  //          = 0, ACIS0 = 1: Trigger on falling edge (AIN0 goes below reference)
  //          = 1, ACIS0 = 0: Trigger on rising edge (AIN0 goes above reference)
  //          = 1, ACIS0 = 1: Reserved
  //
  // To change reference voltage:
  // - For internal 1.1V: Keep ACBG = 1 (current setting)
  // - For external reference: Change ACBG to 0 and connect reference to AIN1 (D7)
  //   Example: ACSR = (1 << ACIE) | (0 << ACBG) | (0 << ACIS1) | (0 << ACIS0);
  //
  ACSR = (1 << ACIE) | (1 << ACBG) | (0 << ACIS1) | (0 << ACIS0);
  
  // Enable global interrupts
  sei();
  
  Serial.println("Analog Comparator Example");
  Serial.println("AIN0 (D6) vs Internal 1.1V Reference");
  Serial.println("------------------------------------");
  Serial.print("Reference voltage: ");
  Serial.print(REFERENCE_VOLTAGE);
  Serial.println("V");
}

// Interrupt service routine for analog comparator
ISR(ANALOG_COMP_vect) {
  // Comparator output changed
  if (ACSR & (1 << ACO)) {
    // AIN0 > 1.1V reference
    digitalWrite(LED_PIN, HIGH);
    Serial.println("AIN0 > 1.1V (LED ON)");
  } else {
    // AIN0 < 1.1V reference
    digitalWrite(LED_PIN, LOW);
    Serial.println("AIN0 < 1.1V (LED OFF)");
  }
}

void loop() {
  // Read comparator output status
  bool comparatorOutput = (ACSR & (1 << ACO)) != 0;
  
  // Read AIN0 voltage using ADC for display (optional)
  // Note: AIN0 is pin D6, but we can't read it directly with analogRead
  // Instead, we can read a similar analog pin to show the concept
  // In practice, you'd measure the actual voltage on D6 with a multimeter
  
  Serial.print("Comparator: ");
  Serial.print(comparatorOutput ? "AIN0 > 1.1V" : "AIN0 < 1.1V");
  Serial.print(" | LED: ");
  Serial.println(comparatorOutput ? "ON" : "OFF");
  Serial.println("(Adjust potentiometer to see LED toggle)");
  
  delay(500);
}

/*
 * EEPROM Storage - Password Storage and Retrieval
 * 
 * Hardware Setup:
 * - Uses built-in UART (Serial) on Arduino Uno
 * - Connect via USB or use Serial Monitor in Arduino IDE
 * 
 * How it Works:
 * - Reads stored password from EEPROM at startup
 * - Allows writing new password via UART (type password and press Enter)
 * - Displays stored password every second
 * - Password persists across power cycles
 * 
 * EEPROM Usage:
 * - Address 0: Password length (1 byte)
 * - Address 1-32: Password string (max 32 characters)
 * - Total: 33 bytes used
 * 
 * Documentation:
 * - Arduino Reference: https://www.arduino.cc/reference/
 * - EEPROM Library: https://www.arduino.cc/reference/en/libraries/eeprom/
 */

#include <EEPROM.h>

#define EEPROM_PASSWORD_LEN_ADDR 0    // Address for password length
#define EEPROM_PASSWORD_ADDR 1        // Address for password string
#define MAX_PASSWORD_LEN 32           // Maximum password length

String storedPassword = "";           // Current password in memory
unsigned long lastReadTime = 0;       // Last time we read from EEPROM
const unsigned long READ_INTERVAL = 1000;  // Read every 1 second

void setup() {
  Serial.begin(9600);
  delay(500);
  
  Serial.println("EEPROM Password Storage");
  Serial.println("========================");
  
  // Read stored password from EEPROM at startup
  readPasswordFromEEPROM();
  
  if (storedPassword.length() > 0) {
    Serial.print("Stored password: ");
    Serial.println(storedPassword);
  } else {
    Serial.println("No password stored in EEPROM");
    Serial.println("Type a password and press Enter to store it");
  }
  
  Serial.println();
  Serial.println("Commands:");
  Serial.println("- Type password and press Enter to store new password");
  Serial.println("- Password is read from EEPROM every second");
  Serial.println();
}

void loop() {
  // Check if user wants to write new password via UART
  if (Serial.available() > 0) {
    String input = Serial.readStringUntil('\n');
    input.trim();
    
    if (input.length() > 0) {
      // Write new password to EEPROM
      writePasswordToEEPROM(input);
      Serial.print("Password saved: ");
      Serial.println(input);
      Serial.println();
    }
  }
  
  // Read password from EEPROM every second
  if (millis() - lastReadTime >= READ_INTERVAL) {
    lastReadTime = millis();
    readPasswordFromEEPROM();
    
    Serial.print("Password from EEPROM: ");
    if (storedPassword.length() > 0) {
      Serial.println(storedPassword);
    } else {
      Serial.println("(empty)");
    }
  }
  
  delay(10);  // Small delay to prevent excessive CPU usage
}

/*
 * Read password from EEPROM
 */
void readPasswordFromEEPROM() {
  // Read password length
  uint8_t passwordLen = EEPROM.read(EEPROM_PASSWORD_LEN_ADDR);
  
  // Validate length
  if (passwordLen == 0 || passwordLen > MAX_PASSWORD_LEN) {
    storedPassword = "";
    return;
  }
  
  // Read password string
  storedPassword = "";
  for (uint8_t i = 0; i < passwordLen; i++) {
    char c = EEPROM.read(EEPROM_PASSWORD_ADDR + i);
    if (c == 0) break;  // Null terminator
    storedPassword += c;
  }
}

/*
 * Write password to EEPROM
 */
void writePasswordToEEPROM(String password) {
  // Limit password length
  if (password.length() > MAX_PASSWORD_LEN) {
    password = password.substring(0, MAX_PASSWORD_LEN);
  }
  
  // Write password length
  EEPROM.update(EEPROM_PASSWORD_LEN_ADDR, password.length());
  
  // Write password string
  for (uint8_t i = 0; i < password.length(); i++) {
    EEPROM.update(EEPROM_PASSWORD_ADDR + i, password.charAt(i));
  }
  
  // Write null terminator
  if (password.length() < MAX_PASSWORD_LEN) {
    EEPROM.update(EEPROM_PASSWORD_ADDR + password.length(), 0);
  }
  
  // Update in-memory copy
  storedPassword = password;
}

/*
 * Alternative: Clear password from EEPROM
 */
void clearPasswordFromEEPROM() {
  EEPROM.update(EEPROM_PASSWORD_LEN_ADDR, 0);
  storedPassword = "";
  Serial.println("Password cleared from EEPROM");
}

/*
 * UART Communication with CRC-8 Error Checking
 * 
 * Hardware Setup:
 * - Uses built-in UART (Serial) on Arduino Uno
 * - Connect via USB or use Serial Monitor in Arduino IDE
 * 
 * How it Works:
 * - Sender calculates CRC-8 checksum and appends it to data
 * - Receiver recalculates CRC and compares with received checksum
 * - If CRC matches, data is valid; if not, error is detected
 * 
 * Message Format: [DATA][CRC]
 * Example: "Hello" + CRC = "Hello" + 0x5A
 * 
 * CRC-8 Algorithm:
 * - Polynomial: x^8 + x^2 + x + 1 (0x07)
 * - Initial value: 0x00
 * 
 * Documentation:
 * - Arduino Reference: https://www.arduino.cc/reference/
 * - Serial Communication: https://www.arduino.cc/reference/en/language/functions/communication/serial/
 */

#define BUFFER_SIZE 64

// Calculate CRC-8 checksum
uint8_t calculateCRC8(uint8_t *data, uint8_t length) {
  uint8_t crc = 0x00;
  uint8_t polynomial = 0x07;  // CRC-8 polynomial
  
  for (uint8_t i = 0; i < length; i++) {
    crc ^= data[i];
    for (uint8_t j = 0; j < 8; j++) {
      if (crc & 0x80) {
        crc = (crc << 1) ^ polynomial;
      } else {
        crc <<= 1;
      }
    }
  }
  return crc;
}

// Send data with CRC
void sendWithCRC(String message) {
  uint8_t data[BUFFER_SIZE];
  uint8_t len = message.length();
  
  // Copy message to buffer
  for (uint8_t i = 0; i < len; i++) {
    data[i] = message.charAt(i);
  }
  
  // Calculate CRC
  uint8_t crc = calculateCRC8(data, len);
  
  // Send message + CRC
  Serial.print(message);
  Serial.write(crc);
  Serial.println(" [CRC sent]");
}

void setup() {
  Serial.begin(9600);
  delay(1000);
  
  Serial.println("UART with CRC Example");
  Serial.println("---------------------");
  
  // Send test messages
  sendWithCRC("Hello");
  sendWithCRC("Test123");
  sendWithCRC("Arduino");
}

void loop() {
  static uint8_t buffer[BUFFER_SIZE];
  static uint8_t index = 0;
  
  // Receive data
  while (Serial.available() > 0) {
    uint8_t byte = Serial.read();
    
    if (byte == '\n' || byte == '\r') {
      if (index > 1) {  // At least 1 data byte + 1 CRC byte
        // Last byte is CRC, rest is data
        uint8_t dataLen = index - 1;
        uint8_t receivedCRC = buffer[dataLen];
        uint8_t calculatedCRC = calculateCRC8(buffer, dataLen);
        
        // Verify CRC
        if (receivedCRC == calculatedCRC) {
          Serial.print("Valid: ");
          for (uint8_t i = 0; i < dataLen; i++) {
            Serial.write(buffer[i]);
          }
          Serial.println();
        } else {
          Serial.print("CRC Error! Received: 0x");
          Serial.print(receivedCRC, HEX);
          Serial.print(", Calculated: 0x");
          Serial.println(calculatedCRC, HEX);
        }
      }
      index = 0;
    } else if (index < BUFFER_SIZE - 1) {
      buffer[index++] = byte;
    }
  }
}

/*
 * Software UART String Parsing - Extract Numeric Value from Command
 * 
 * Hardware Setup:
 * - Uses SoftwareSerial library for software UART (no hardware UART)
 * - RX pin: 2 (connect TX from other device here)
 * - TX pin: 3 (connect RX from other device here)
 * - Built-in Serial (USB) used only for debugging output
 * - No error checking (no parity, no CRC, no flow control)
 * 
 * How it Works:
 * - SoftwareSerial emulates UART using software timing
 * - Reads complete string from software UART buffer
 * - Parses commands like "test 100" and extracts the numeric value
 * - Returns the extracted value as an integer
 * 
 * Example Commands (send via software UART on pins 2/3):
 * - "test 100" -> extracts 100
 * - "test 42" -> extracts 42
 * - "test -5" -> extracts -5
 * 
 * Note: SoftwareSerial is slower and less reliable than hardware UART
 *       Maximum reliable baud rate is typically 9600 or lower
 * 
 * Library Required:
 * - SoftwareSerial (included with Arduino IDE)
 * 
 * Documentation:
 * - Arduino Reference: https://www.arduino.cc/reference/
 * - SoftwareSerial Library: https://www.arduino.cc/reference/en/libraries/softwareserial/
 */

#include <SoftwareSerial.h>

// Create software UART instance
// RX pin = 2, TX pin = 3
SoftwareSerial softSerial(2, 3);  // RX, TX

String inputString = "";  // String to hold incoming data

void setup() {
  // Initialize built-in Serial for debugging (USB)
  Serial.begin(9600);
  
  // Initialize software UART
  softSerial.begin(9600);
  
  inputString.reserve(64);  // Reserve 64 bytes for the string
  
  Serial.println("Software UART String Parsing Example");
  Serial.println("Send commands via software UART (pins 2/3)");
  Serial.println("Example: test 100");
  Serial.println("----------------------------------------");
}

void loop() {
  // Check if data is available on software UART
  if (softSerial.available() > 0) {
    // Read the entire string until newline
    inputString = softSerial.readStringUntil('\n');
    inputString.trim();  // Remove whitespace
    
    if (inputString.length() > 0) {
      // Parse the command and extract value
      int value = parseCommand(inputString);
      
      if (value != -9999) {  // -9999 indicates parsing error
        // Echo back via software UART
        softSerial.print("Command: ");
        softSerial.println(inputString);
        softSerial.print("Value: ");
        softSerial.println(value);
        
        // Also print to Serial Monitor for debugging
        Serial.print("Software UART received: ");
        Serial.println(inputString);
        Serial.print("Extracted value: ");
        Serial.println(value);
        Serial.println("---");
      } else {
        // Send error via software UART
        softSerial.print("Error parsing: ");
        softSerial.println(inputString);
        
        // Also print to Serial Monitor
        Serial.print("Error: Could not parse value from: ");
        Serial.println(inputString);
      }
    }
  }
}

/*
 * Parse command string and extract numeric value
 * Format: "test 100" or "test -42" etc.
 * Returns: extracted integer value, or -9999 if error
 */
int parseCommand(String command) {
  // Find the position of the last space
  int lastSpaceIndex = command.lastIndexOf(' ');
  
  if (lastSpaceIndex == -1) {
    // No space found, try to parse entire string as number
    return command.toInt();
  }
  
  // Extract substring after last space
  String valueString = command.substring(lastSpaceIndex + 1);
  
  // Convert to integer
  int value = valueString.toInt();
  
  // Check if conversion was successful
  // toInt() returns 0 if conversion fails, so we need additional check
  if (value == 0 && valueString != "0" && valueString != "-0") {
    // Conversion likely failed
    return -9999;
  }
  
  return value;
}

/*
 * Alternative parsing function for more complex commands
 * Example: "test value=100" or "test:100"
 */
int parseCommandAdvanced(String command) {
  // Try to find '=' separator
  int equalsIndex = command.indexOf('=');
  if (equalsIndex != -1) {
    String valueString = command.substring(equalsIndex + 1);
    return valueString.toInt();
  }
  
  // Try to find ':' separator
  int colonIndex = command.indexOf(':');
  if (colonIndex != -1) {
    String valueString = command.substring(colonIndex + 1);
    return valueString.toInt();
  }
  
  // Try to find last space (original method)
  int lastSpaceIndex = command.lastIndexOf(' ');
  if (lastSpaceIndex != -1) {
    String valueString = command.substring(lastSpaceIndex + 1);
    return valueString.toInt();
  }
  
  return -9999;  // Error
}

/*
 * Char vs ASCII - Understanding the Difference
 * 
 * IMPORTANT CONCEPT:
 * - char is NOT the same as ASCII
 * - char is a data type (8-bit integer) that can store ASCII values
 * - ASCII is an encoding standard that maps characters to numbers
 * - char variables store numeric values (0-255), not characters themselves
 * 
 * Key Points:
 * - char c = 'A';  // Stores the ASCII value 65, not the letter 'A'
 * - char is actually a signed 8-bit integer (-128 to 127)
 * - unsigned char is an unsigned 8-bit integer (0 to 255)
 * - When you print a char, it's converted to the corresponding ASCII character
 * - You can do arithmetic with char values
 * 
 * Hardware Setup:
 * - Uses built-in UART (Serial) on Arduino Uno
 * - Connect via USB or use Serial Monitor in Arduino IDE
 * 
 * Documentation:
 * - Arduino Reference: https://www.arduino.cc/reference/
 * - Data Types: https://www.arduino.cc/reference/en/language/variables/data-types/
 */

void setup() {
  Serial.begin(9600);
  delay(1000);
  
  Serial.println("Char vs ASCII Example");
  Serial.println("=====================");
  Serial.println();
  
  demonstrateCharVsASCII();
  demonstrateCharArithmetic();
  demonstrateCharComparison();
}

void loop() {
  // Empty - demonstration runs once in setup()
}

/*
 * Demonstrate that char stores numeric values, not characters
 */
void demonstrateCharVsASCII() {
  Serial.println("1. Char stores numeric ASCII values:");
  Serial.println("-----------------------------------");
  
  char c1 = 'A';        // ASCII value 65
  char c2 = 'B';        // ASCII value 66
  char c3 = 65;         // Same as 'A' - stores number 65
  char c4 = 0x41;       // Hexadecimal 0x41 = 65 = 'A'
  
  Serial.print("char c1 = 'A';  // c1 = ");
  Serial.print((int)c1);  // Cast to int to show numeric value
  Serial.print(" (ASCII code for 'A')");
  Serial.println();
  
  Serial.print("char c2 = 'B';  // c2 = ");
  Serial.print((int)c2);
  Serial.print(" (ASCII code for 'B')");
  Serial.println();
  
  Serial.print("char c3 = 65;   // c3 = ");
  Serial.print((int)c3);
  Serial.print(" (same as 'A')");
  Serial.println();
  
  Serial.print("char c4 = 0x41; // c4 = ");
  Serial.print((int)c4);
  Serial.print(" (hex 0x41 = 65 = 'A')");
  Serial.println();
  Serial.println();
  
  // Print as character vs as number
  Serial.println("Printing as character vs as number:");
  Serial.print("c1 as char: '");
  Serial.print(c1);
  Serial.print("' | c1 as int: ");
  Serial.println((int)c1);
  Serial.println();
}

/*
 * Demonstrate arithmetic operations with char
 */
void demonstrateCharArithmetic() {
  Serial.println("2. Char arithmetic (char is a number):");
  Serial.println("--------------------------------------");
  
  char letter = 'A';
  Serial.print("char letter = 'A';  // letter = ");
  Serial.println((int)letter);
  
  // Add 1 to get next letter
  char nextLetter = letter + 1;
  Serial.print("letter + 1 = ");
  Serial.print((int)nextLetter);
  Serial.print(" which is '");
  Serial.print(nextLetter);
  Serial.println("'");
  
  // Subtract to get previous letter
  char prevLetter = letter - 1;
  Serial.print("letter - 1 = ");
  Serial.print((int)prevLetter);
  Serial.print(" which is '");
  Serial.print(prevLetter);
  Serial.println("'");
  
  // Convert lowercase to uppercase
  char lowercase = 'a';  // ASCII 97
  char uppercase = lowercase - 32;  // 'A' is 65, 'a' is 97, difference is 32
  Serial.print("'");
  Serial.print(lowercase);
  Serial.print("' - 32 = '");
  Serial.print(uppercase);
  Serial.println("'");
  Serial.println();
}

/*
 * Demonstrate comparison and type behavior
 */
void demonstrateCharComparison() {
  Serial.println("3. Char comparison and type behavior:");
  Serial.println("-------------------------------------");
  
  char c = '5';  // ASCII value 53, NOT the number 5!
  int num = 5;   // Actual number 5
  
  Serial.print("char c = '5';  // c = ");
  Serial.print((int)c);
  Serial.print(" (ASCII code, NOT the number 5!)");
  Serial.println();
  
  Serial.print("int num = 5;   // num = ");
  Serial.println(num);
  Serial.println();
  
  Serial.println("Common mistake - comparing char '5' with int 5:");
  Serial.print("c == 5? ");
  Serial.println(c == 5 ? "true" : "false");  // false! 53 != 5
  Serial.print("c == 53? ");
  Serial.println(c == 53 ? "true" : "false");  // true! 53 == 53
  Serial.println();
  
  Serial.println("To convert char '5' to int 5:");
  Serial.print("c - '0' = ");
  Serial.print(c - '0');
  Serial.print(" (subtract ASCII '0' which is 48)");
  Serial.println();
  Serial.print("c - 48 = ");
  Serial.println(c - 48);  // Same thing
  Serial.println();
  
  Serial.println("ASCII table snippet:");
  Serial.println("'0' = 48, '1' = 49, '2' = 50, ..., '9' = 57");
  Serial.println("'A' = 65, 'B' = 66, ..., 'Z' = 90");
  Serial.println("'a' = 97, 'b' = 98, ..., 'z' = 122");
  Serial.println();
}

/*
 * Practical example: Convert char digit to integer
 */
int charToInt(char c) {
  // Check if char is a digit (ASCII '0' to '9' = 48 to 57)
  if (c >= '0' && c <= '9') {
    return c - '0';  // Subtract ASCII '0' (48) to get actual number
  }
  return -1;  // Not a digit
}

/*
 * Practical example: Check if char is uppercase letter
 */
bool isUpperCase(char c) {
  // Uppercase letters: 'A' to 'Z' = ASCII 65 to 90
  return (c >= 'A' && c <= 'Z');
}

/*
 * Practical example: Check if char is lowercase letter
 */
bool isLowerCase(char c) {
  // Lowercase letters: 'a' to 'z' = ASCII 97 to 122
  return (c >= 'a' && c <= 'z');
}

/*
 * Event-Driven: Voltage Drop Detection with Filtering
 * 
 * Hardware Setup:
 * - Connect voltage source to analog pin A0 (via voltage divider if > 5V)
 * - Connect LED to pin 13 (built-in LED) to indicate voltage drop
 * - Optional: Connect potentiometer to A0 for testing
 * 
 * How it Works:
 * - Monitors voltage on analog pin
 * - Detects when voltage drops below threshold
 * - Uses filtering to avoid false triggers from noise/bouncing
 * - Triggers event handler when voltage drop is confirmed
 * 
 * Filtering Method:
 * - Takes multiple samples and requires consistent low reading
 * - Prevents false triggers from electrical noise
 * - Debouncing delay ensures stable reading
 * 
 * Documentation:
 * - Arduino Reference: https://www.arduino.cc/reference/
 * - analogRead(): https://www.arduino.cc/reference/en/language/functions/analog-io/analogread/
 */

#define VOLTAGE_PIN A0
#define LED_PIN 13
#define THRESHOLD 512        // 2.5V (512 out of 1024 = 2.5V/5V)
#define FILTER_SAMPLES 5    // Number of samples for filtering
#define FILTER_DELAY 10      // Delay between samples (ms)

int voltageDropCount = 0;
bool voltageDropDetected = false;

void setup() {
  Serial.begin(9600);
  pinMode(LED_PIN, OUTPUT);
  pinMode(VOLTAGE_PIN, INPUT);
  
  Serial.println("Voltage Drop Detection with Filtering");
  Serial.println("------------------------------------");
  Serial.print("Threshold: ");
  Serial.print((THRESHOLD * 5.0) / 1024.0);
  Serial.println("V");
}

void loop() {
  // Check for voltage drop event
  if (checkVoltageDrop()) {
    handleVoltageDropEvent();
  }
  
  // Other tasks can run here
  delay(50);
}

/*
 * Check if voltage has dropped below threshold
 * Uses filtering to avoid false triggers
 */
bool checkVoltageDrop() {
  int lowReadings = 0;
  
  // Take multiple samples
  for (int i = 0; i < FILTER_SAMPLES; i++) {
    int reading = analogRead(VOLTAGE_PIN);
    
    if (reading < THRESHOLD) {
      lowReadings++;
    }
    
    delay(FILTER_DELAY);
  }
  
  // Require majority of samples to be low (filtering)
  if (lowReadings >= (FILTER_SAMPLES / 2 + 1)) {
    if (!voltageDropDetected) {
      voltageDropDetected = true;
      return true;  // New event detected
    }
  } else {
    voltageDropDetected = false;  // Reset if voltage recovers
  }
  
  return false;
}

/*
 * Event handler for voltage drop
 */
void handleVoltageDropEvent() {
  voltageDropCount++;
  
  int voltage = analogRead(VOLTAGE_PIN);
  float voltageVolts = (voltage * 5.0) / 1024.0;
  
  // Turn on LED
  digitalWrite(LED_PIN, HIGH);
  
  // Log event
  Serial.print("Event #");
  Serial.print(voltageDropCount);
  Serial.print(": Voltage drop detected! Voltage = ");
  Serial.print(voltageVolts);
  Serial.println("V");
  
  // You can add more actions here:
  // - Save to EEPROM
  // - Send alert via UART
  // - Trigger other devices
  // - etc.
}

/*
 * Event-Driven: Low Voltage Indicator
 * 
 * Hardware Setup:
 * - Connect battery/voltage source to analog pin A0 (via voltage divider)
 * - Connect LED to pin 13 (built-in LED) for warning
 * - Connect buzzer to pin 9 (optional) for audio alert
 * 
 * How it Works:
 * - Continuously monitors battery voltage
 * - Triggers event when voltage drops below critical level
 * - Uses filtering to prevent false alarms from noise
 * - Provides visual and optional audio warning
 * 
 * Voltage Divider Calculation:
 * - For 12V battery: R1 = 10kΩ, R2 = 10kΩ gives 6V max to A0
 * - For 9V battery: R1 = 4.7kΩ, R2 = 10kΩ gives ~6.5V max to A0
 * - Adjust divider ratio based on your battery voltage
 * 
 * Documentation:
 * - Arduino Reference: https://www.arduino.cc/reference/
 * - analogRead(): https://www.arduino.cc/reference/en/language/functions/analog-io/analogread/
 * - tone(): https://www.arduino.cc/reference/en/language/functions/advanced-io/tone/
 */

#define VOLTAGE_PIN A0
#define LED_PIN 13
#define BUZZER_PIN 9
#define LOW_VOLTAGE_THRESHOLD 3.0   // Critical voltage in volts
#define WARNING_VOLTAGE_THRESHOLD 3.5 // Warning voltage in volts
#define FILTER_SAMPLES 10            // Samples for filtering
#define CHECK_INTERVAL 1000          // Check every 1 second

// Voltage divider ratio (if using divider)
// Actual battery voltage = measured voltage * divider_ratio
// Example: If divider gives 1/2, then ratio = 2.0
#define DIVIDER_RATIO 2.0

bool lowVoltageEvent = false;
bool warningVoltageEvent = false;
unsigned long lastCheck = 0;

void setup() {
  Serial.begin(9600);
  pinMode(LED_PIN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);
  pinMode(VOLTAGE_PIN, INPUT);
  
  Serial.println("Low Voltage Indicator");
  Serial.println("--------------------");
  Serial.print("Critical threshold: ");
  Serial.print(LOW_VOLTAGE_THRESHOLD);
  Serial.println("V");
  Serial.print("Warning threshold: ");
  Serial.print(WARNING_VOLTAGE_THRESHOLD);
  Serial.println("V");
}

void loop() {
  // Check voltage periodically (event-driven, not continuous polling)
  if (millis() - lastCheck >= CHECK_INTERVAL) {
    lastCheck = millis();
    
    float voltage = readFilteredVoltage();
    
    // Check for low voltage event
    if (voltage < LOW_VOLTAGE_THRESHOLD && !lowVoltageEvent) {
      handleLowVoltageEvent(voltage);
    } else if (voltage >= LOW_VOLTAGE_THRESHOLD) {
      lowVoltageEvent = false;
      digitalWrite(LED_PIN, LOW);
      noTone(BUZZER_PIN);
    }
    
    // Check for warning voltage event
    if (voltage < WARNING_VOLTAGE_THRESHOLD && voltage >= LOW_VOLTAGE_THRESHOLD) {
      if (!warningVoltageEvent) {
        handleWarningVoltageEvent(voltage);
      }
    } else if (voltage >= WARNING_VOLTAGE_THRESHOLD) {
      warningVoltageEvent = false;
    }
    
    // Display current voltage
    Serial.print("Battery voltage: ");
    Serial.print(voltage);
    Serial.println("V");
  }
  
  // Other tasks can run here
}

/*
 * Read voltage with filtering to avoid noise
 */
float readFilteredVoltage() {
  long sum = 0;
  
  // Take multiple samples
  for (int i = 0; i < FILTER_SAMPLES; i++) {
    sum += analogRead(VOLTAGE_PIN);
    delay(5);
  }
  
  // Calculate average
  int average = sum / FILTER_SAMPLES;
  
  // Convert to voltage
  float voltage = (average * 5.0) / 1024.0;
  
  // Apply divider ratio if using voltage divider
  voltage = voltage * DIVIDER_RATIO;
  
  return voltage;
}

/*
 * Event handler for critical low voltage
 */
void handleLowVoltageEvent(float voltage) {
  lowVoltageEvent = true;
  
  Serial.println("!!! CRITICAL: Low Voltage Event !!!");
  Serial.print("Voltage: ");
  Serial.print(voltage);
  Serial.println("V");
  
  // Visual warning - fast blink
  for (int i = 0; i < 5; i++) {
    digitalWrite(LED_PIN, HIGH);
    delay(100);
    digitalWrite(LED_PIN, LOW);
    delay(100);
  }
  digitalWrite(LED_PIN, HIGH);  // Keep LED on
  
  // Audio warning (optional)
  tone(BUZZER_PIN, 1000, 500);  // 1kHz tone for 500ms
  
  // Additional actions:
  // - Save critical state to EEPROM
  // - Send alert via UART/WiFi
  // - Enter low-power mode
  // - Shutdown non-essential systems
}

/*
 * Event handler for warning voltage level
 */
void handleWarningVoltageEvent(float voltage) {
  warningVoltageEvent = true;
  
  Serial.println("WARNING: Battery voltage low");
  Serial.print("Voltage: ");
  Serial.print(voltage);
  Serial.println("V");
  
  // Visual warning - slow blink
  digitalWrite(LED_PIN, HIGH);
  delay(200);
  digitalWrite(LED_PIN, LOW);
}

/*
 * Event-Driven: Motion Detection with Debouncing
 * 
 * Hardware Setup:
 * - Connect PIR motion sensor to digital pin 2
 * - PIR sensor: VCC to 5V, GND to GND, OUT to pin 2
 * - Connect LED to pin 13 (built-in LED) for indication
 * - Optional: Connect buzzer to pin 9 for audio alert
 * 
 * How it Works:
 * - Uses interrupt to detect motion (event-driven)
 * - Implements debouncing to filter false triggers
 * - Triggers event handler when motion is detected
 * - Can be used for security, lighting control, etc.
 * 
 * Debouncing:
 * - Prevents multiple triggers from single motion
 * - Uses time-based filtering
 * - Ignores triggers within debounce period
 * 
 * Documentation:
 * - Arduino Reference: https://www.arduino.cc/reference/
 * - attachInterrupt(): https://www.arduino.cc/reference/en/language/functions/external-interrupts/attachinterrupt/
 */

#define PIR_PIN 2
#define LED_PIN 13
#define BUZZER_PIN 9
#define DEBOUNCE_TIME 2000  // 2 seconds debounce (ms)

volatile bool motionDetected = false;
volatile unsigned long lastMotionTime = 0;
int motionCount = 0;

void setup() {
  Serial.begin(9600);
  pinMode(PIR_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);
  
  // Attach interrupt for motion detection (event-driven)
  // RISING: triggers when pin goes from LOW to HIGH
  attachInterrupt(digitalPinToInterrupt(PIR_PIN), motionISR, RISING);
  
  Serial.println("Motion Detection with Debouncing");
  Serial.println("--------------------------------");
  Serial.println("Waiting for motion...");
}

void loop() {
  // Check if motion event occurred
  if (motionDetected) {
    handleMotionEvent();
    motionDetected = false;  // Reset flag
  }
  
  // Other tasks can run here
  // The system is event-driven, not polling continuously
  delay(100);
}

/*
 * Interrupt Service Routine (ISR) for motion detection
 * This is called automatically when motion is detected
 */
void motionISR() {
  unsigned long currentTime = millis();
  
  // Debouncing: ignore triggers within debounce period
  if (currentTime - lastMotionTime > DEBOUNCE_TIME) {
    motionDetected = true;
    lastMotionTime = currentTime;
  }
}

/*
 * Event handler for motion detection
 */
void handleMotionEvent() {
  motionCount++;
  
  Serial.print("Motion detected! Event #");
  Serial.println(motionCount);
  Serial.print("Time: ");
  Serial.print(millis() / 1000);
  Serial.println(" seconds");
  
  // Visual indication
  digitalWrite(LED_PIN, HIGH);
  delay(500);
  digitalWrite(LED_PIN, LOW);
  
  // Audio indication (optional)
  tone(BUZZER_PIN, 2000, 200);  // 2kHz tone for 200ms
  
  // Additional actions:
  // - Turn on lights
  // - Send notification via UART/WiFi
  // - Log to EEPROM
  // - Trigger camera
  // - etc.
}

/*
 * Alternative: Non-interrupt version with polling and filtering
 * Use this if interrupts are not available or you prefer polling
 */
bool checkMotionPolling() {
  static unsigned long lastCheck = 0;
  static int consecutiveHigh = 0;
  const int REQUIRED_HIGH = 3;  // Require 3 consecutive HIGH readings
  
  // Check periodically
  if (millis() - lastCheck < 50) {
    return false;  // Too soon to check again
  }
  lastCheck = millis();
  
  // Read sensor
  if (digitalRead(PIR_PIN) == HIGH) {
    consecutiveHigh++;
    
    // Require multiple consecutive readings (filtering)
    if (consecutiveHigh >= REQUIRED_HIGH) {
      consecutiveHigh = 0;
      return true;  // Motion confirmed
    }
  } else {
    consecutiveHigh = 0;  // Reset counter
  }
  
  return false;
}

/*
 * PWM Signal Control via UART - Arduino Uno
 * 
 * Hardware Setup:
 * - Connect LED to pin 9 (PWM-capable pin) via 220Ω resistor
 * - Or connect motor/servo to pin 9
 * - Connect via USB for Serial communication
 * 
 * How it Works:
 * - Asks user for PWM percentage (0-100%) via Serial Monitor
 * - Converts percentage to Arduino PWM value (0-255)
 * - Outputs PWM signal on specified pin
 * - Arduino Uno uses 8-bit PWM (0-255 range)
 * 
 * PWM Resolution:
 * - Arduino Uno: 8-bit PWM = 256 levels (0-255)
 * - Frequency: ~490 Hz (pins 5,6) or ~980 Hz (pins 3,9,10,11)
 * 
 * For Future - Analog Low-Pass Filter:
 * - To convert PWM to smooth analog voltage, use RC low-pass filter
 * - Connect: PWM pin → Resistor (1kΩ) → Capacitor (10µF) → GND
 * - Cutoff frequency: f = 1/(2πRC)
 * - Example: R=1kΩ, C=10µF → f ≈ 16 Hz (smooth DC output)
 * - The capacitor charges/discharges, averaging the PWM signal
 * 
 * Documentation:
 * - Arduino Reference: https://www.arduino.cc/reference/
 * - analogWrite(): https://www.arduino.cc/reference/en/language/functions/analog-io/analogwrite/
 */

#define PWM_PIN 9        // PWM-capable pin (3, 5, 6, 9, 10, 11 on Uno)
#define PWM_MAX 255      // Maximum PWM value for Arduino Uno (8-bit)

void setup() {
  Serial.begin(9600);
  pinMode(PWM_PIN, OUTPUT);
  
  // Initialize PWM to 0%
  analogWrite(PWM_PIN, 0);
  
  Serial.println("PWM Control via UART - Arduino Uno");
  Serial.println("===================================");
  Serial.println("Enter PWM percentage (0-100):");
  Serial.println("Example: 50 (for 50%)");
  Serial.println();
}

void loop() {
  // Check if data is available from Serial
  if (Serial.available() > 0) {
    // Read the input string
    String input = Serial.readStringUntil('\n');
    input.trim();
    
    // Parse percentage value
    int percentage = input.toInt();
    
    // Validate input (0-100%)
    if (percentage >= 0 && percentage <= 100) {
      // Convert percentage to PWM value
      // Arduino Uno: 0-100% maps to 0-255
      int pwmValue = map(percentage, 0, 100, 0, PWM_MAX);
      
      // Alternative calculation:
      // int pwmValue = (percentage * PWM_MAX) / 100;
      
      // Set PWM output
      analogWrite(PWM_PIN, pwmValue);
      
      // Calculate actual voltage (assuming 5V system)
      float voltage = (pwmValue * 5.0) / PWM_MAX;
      
      // Display result
      Serial.print("PWM set to: ");
      Serial.print(percentage);
      Serial.print("% (PWM value: ");
      Serial.print(pwmValue);
      Serial.print("/255, Voltage: ");
      Serial.print(voltage);
      Serial.println("V)");
      Serial.println();
      Serial.println("Enter new percentage (0-100):");
    } else {
      Serial.println("Error: Please enter a value between 0 and 100");
      Serial.println("Enter PWM percentage (0-100):");
    }
  }
  
  // Small delay to prevent excessive CPU usage
  delay(10);
}

/*
 * Function to set PWM with percentage (helper function)
 */
void setPWMPercent(int percentage) {
  // Clamp value to valid range
  if (percentage < 0) percentage = 0;
  if (percentage > 100) percentage = 100;
  
  // Convert to PWM value
  int pwmValue = map(percentage, 0, 100, 0, PWM_MAX);
  
  // Set PWM
  analogWrite(PWM_PIN, pwmValue);
}

/*
 * For Future: Analog Low-Pass Filter Design
 * 
 * To smooth PWM into analog voltage:
 * 
 * 1. Calculate cutoff frequency needed:
 *    - For smooth DC: cutoff should be much lower than PWM frequency
 *    - Arduino PWM: ~490-980 Hz
 *    - Recommended cutoff: 10-50 Hz (10x lower than PWM frequency)
 * 
 * 2. Choose resistor and capacitor:
 *    - Cutoff frequency: fc = 1 / (2π × R × C)
 *    - Example: fc = 16 Hz → R = 1kΩ, C = 10µF
 *    - Example: fc = 32 Hz → R = 1kΩ, C = 5µF
 * 
 * 3. Circuit connection:
 *    - PWM pin → Resistor → Output (to load) → Capacitor → GND
 *    - The capacitor acts as a voltage reservoir
 *    - Resistor limits charging current
 * 
 * 4. Output voltage:
 *    - Vout = Vpwm × (duty_cycle / 100)
 *    - Example: 5V PWM at 50% duty → 2.5V output (after filter)
 * 
 * 5. Load considerations:
 *    - Filter output impedance = R (resistor value)
 *    - Load should be much higher than R (10x or more)
 *    - Otherwise voltage will drop under load
 */

/*
 * PWM Signal Control via UART - ESP8266
 * 
 * Hardware Setup:
 * - Connect LED to GPIO pin 4 (D2) via 220Ω resistor
 * - Or connect motor/servo to GPIO pin 4
 * - Connect via USB for Serial communication
 * 
 * How it Works:
 * - Asks user for PWM percentage (0-100%) via Serial Monitor
 * - Converts percentage to ESP8266 PWM value (0-1023)
 * - Outputs PWM signal on specified pin
 * - ESP8266 uses 10-bit PWM (0-1023 range)
 * 
 * PWM Resolution:
 * - ESP8266: 10-bit PWM = 1024 levels (0-1023)
 * - Frequency: Default 1 kHz (can be adjusted)
 * - More resolution than Arduino Uno (1024 vs 256 levels)
 * 
 * Important Differences from Arduino Uno:
 * - analogWrite() range: 0-1023 (not 0-255)
 * - Must call analogWriteRange() to set range (default 1023)
 * - Must call analogWriteFreq() to set frequency (default 1000 Hz)
 * 
 * For Future - Analog Low-Pass Filter:
 * - Same RC filter design as Arduino Uno
 * - ESP8266 PWM frequency: 1 kHz (default)
 * - Recommended cutoff: 50-100 Hz for smooth output
 * - Example: R=1kΩ, C=2.2µF → f ≈ 72 Hz
 */

#define PWM_PIN 4        // GPIO 4 (D2) - PWM-capable pin
#define PWM_MAX 1023     // Maximum PWM value for ESP8266 (10-bit)

void setup() {
  Serial.begin(115200);  // ESP8266 typically uses 115200 baud
  delay(100);
  
  // Configure PWM pin
  pinMode(PWM_PIN, OUTPUT);
  
  // Set PWM range (0-1023 is default, but explicit is good practice)
  analogWriteRange(PWM_MAX);
  
  // Set PWM frequency (default is 1000 Hz, can be adjusted)
  // Range: 100 Hz to 1000 Hz
  analogWriteFreq(1000);  // 1 kHz
  
  // Initialize PWM to 0%
  analogWrite(PWM_PIN, 0);
  
  Serial.println();
  Serial.println("PWM Control via UART - ESP8266");
  Serial.println("=================================");
  Serial.print("PWM Resolution: 10-bit (0-");
  Serial.print(PWM_MAX);
  Serial.println(")");
  Serial.print("PWM Frequency: ");
  Serial.print(1000);
  Serial.println(" Hz");
  Serial.println("Enter PWM percentage (0-100):");
  Serial.println("Example: 50 (for 50%)");
  Serial.println();
}

void loop() {
  // Check if data is available from Serial
  if (Serial.available() > 0) {
    // Read the input string
    String input = Serial.readStringUntil('\n');
    input.trim();
    
    // Parse percentage value
    int percentage = input.toInt();
    
    // Validate input (0-100%)
    if (percentage >= 0 && percentage <= 100) {
      // Convert percentage to PWM value
      // ESP8266: 0-100% maps to 0-1023
      int pwmValue = map(percentage, 0, 100, 0, PWM_MAX);
      
      // Alternative calculation:
      // int pwmValue = (percentage * PWM_MAX) / 100;
      
      // Set PWM output
      analogWrite(PWM_PIN, pwmValue);
      
      // Calculate actual voltage (assuming 3.3V system for ESP8266)
      float voltage = (pwmValue * 3.3) / PWM_MAX;
      
      // Display result
      Serial.print("PWM set to: ");
      Serial.print(percentage);
      Serial.print("% (PWM value: ");
      Serial.print(pwmValue);
      Serial.print("/1023, Voltage: ");
      Serial.print(voltage);
      Serial.println("V)");
      Serial.println();
      Serial.println("Enter new percentage (0-100):");
    } else {
      Serial.println("Error: Please enter a value between 0 and 100");
      Serial.println("Enter PWM percentage (0-100):");
    }
  }
  
  // Small delay to prevent excessive CPU usage
  delay(10);
}

/*
 * Function to set PWM with percentage (helper function)
 */
void setPWMPercent(int percentage) {
  // Clamp value to valid range
  if (percentage < 0) percentage = 0;
  if (percentage > 100) percentage = 100;
  
  // Convert to PWM value
  int pwmValue = map(percentage, 0, 100, 0, PWM_MAX);
  
  // Set PWM
  analogWrite(PWM_PIN, pwmValue);
}

/*
 * Function to change PWM frequency (ESP8266 specific)
 */
void setPWMFrequency(uint32_t frequency) {
  // Frequency range: 100 Hz to 1000 Hz
  if (frequency < 100) frequency = 100;
  if (frequency > 1000) frequency = 1000;
  
  analogWriteFreq(frequency);
  
  Serial.print("PWM frequency set to: ");
  Serial.print(frequency);
  Serial.println(" Hz");
}

/*
 * For Future: Analog Low-Pass Filter Design for ESP8266
 * 
 * To smooth PWM into analog voltage:
 * 
 * 1. ESP8266 PWM characteristics:
 *    - Frequency: 1 kHz (default, can be 100-1000 Hz)
 *    - Resolution: 10-bit (1024 levels)
 *    - Voltage: 3.3V (not 5V like Arduino Uno)
 * 
 * 2. Calculate cutoff frequency:
 *    - PWM frequency: 1000 Hz
 *    - Recommended cutoff: 50-100 Hz (10-20x lower)
 *    - Formula: fc = 1 / (2π × R × C)
 * 
 * 3. Component selection examples:
 *    - R = 1kΩ, C = 2.2µF → fc ≈ 72 Hz (good for 1 kHz PWM)
 *    - R = 1kΩ, C = 1µF → fc ≈ 159 Hz (faster response)
 *    - R = 2.2kΩ, C = 1µF → fc ≈ 72 Hz (higher impedance)
 * 
 * 4. Circuit connection:
 *    - GPIO pin → Resistor → Output (to load) → Capacitor → GND
 *    - Same as Arduino Uno, but note 3.3V system voltage
 * 
 * 5. Output voltage calculation:
 *    - Vout = 3.3V × (duty_cycle / 100)
 *    - Example: 50% duty → 1.65V output (after filter)
 *    - Maximum: 100% duty → 3.3V output
 * 
 * 6. Advantages of 10-bit PWM:
 *    - 1024 levels vs 256 levels (Arduino Uno)
 *    - Finer control resolution
 *    - Smoother transitions
 *    - Better for precision applications
 * 
 * 7. Load considerations:
 *    - Output impedance = R (resistor value)
 *    - Load should be >> R (10x or more recommended)
 *    - Higher R = less current draw, but higher output impedance
 *    - Lower R = more current draw, but lower output impedance
 * 
 * Documentation:
 * - Arduino Reference: https://www.arduino.cc/reference/
 * - ESP8266 Arduino Core: https://arduino-esp8266.readthedocs.io/
 * - analogWrite() for ESP8266: https://arduino-esp8266.readthedocs.io/en/latest/reference.html#analog-output
 */

/*
 * Obstacle-Avoiding Robot with Servo Motors
 * Uses distance sensor and continuous rotation servos
 * Includes Serial debugging for monitoring behavior
 */

#include <Servo.h>
#include <afstandssensor.h>

AfstandsSensor distanceSensor(13, 12);  // Trigger pin 13, echo pin 12
Servo servoLeft;
Servo servoRight;

int speedRight = 90;  // 90 = stopped for continuous rotation servo
int speedLeft = 90;   // 90 = stopped for continuous rotation servo

void setup() {
  servoLeft.attach(9);    // Attach left servo to pin 9
  servoRight.attach(10);  // Attach right servo to pin 10
  Serial.begin(9600);     // Initialize serial communication
  
  Serial.println("Robot initialized!");
  Serial.println("Starting in 2 seconds...");
  delay(2000);
}

void loop() {
  // Read distance in cm from the sensor
  float distance = distanceSensor.afstandCM();
  
  // If sensor reading failed, set a high dummy value
  if (distance == -1) {
    distance = 1000;
    Serial.println("Sensor error - assuming clear path");
  }
  
  // Debug: print current distance
  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.print(" cm - ");
  
  // Take action based on distance
  if (distance < 20) {
    Serial.println("OBSTACLE! Reversing and turning...");
    reverse();         // Too close — reverse and turn
  }
  
  if (distance >= 20) {
    Serial.println("Path clear - moving forward");
    driveForward();    // Path is clear — go forward
  }
  
  delay(150);  // Wait before next sensor reading
}

void reverse() {
  Serial.println("  -> Reversing...");
  setMotorSpeeds(70, 70);  // Move backward
  delay(1000);             // Reverse for 1 second
  
  // Random turn: add variation to direction
  int r = random(-30, 30);
  int l = random(-30, 30);
  speedRight = 70 - r;
  speedLeft = 70 - l;
  
  Serial.print("  -> Turning (L:");
  Serial.print(speedLeft);
  Serial.print(", R:");
  Serial.print(speedRight);
  Serial.println(")");
  
  setMotorSpeeds(speedLeft, speedRight);
  delay(1000);             // Turn for 1 second
}

void driveForward() {
  setMotorSpeeds(100, 100);  // Move forward
}

void setMotorSpeeds(int leftSpeed, int rightSpeed) {
  // Convert values to servo-compatible angles
  servoLeft.write(rightSpeed);       // Left motor
  servoRight.write(180 - leftSpeed); // Right motor reversed
}