Light of the World: Light-Emitting Diode

				
					#include <math.h>

// Define RGB pins
const int redPin = 9;    // Red pin connected to PWM9
const int greenPin = 10; // Green pin connected to PWM10
const int bluePin = 11;  // Blue pin connected to PWM11

// Light effect parameters
const int baseSpeed = 20;      // Base animation speed
const int maxBrightness = 255; // Maximum brightness (0-255)
const int minBrightness = 20;  // Minimum brightness
const int beatDuration = 300;  // Beat duration in milliseconds (controls overall speed)

// Current color state
float currentHue = 0.0;        // Current hue in HSV color space (0.0-1.0)
int currentR = 0;              // Current red value
int currentG = 0;              // Current green value
int currentB = 0;              // Current blue value

// Rhythm pattern configuration
const int patternCount = 8;    // Number of light effect patterns
const int patterns[patternCount][4] = {
  // Rainbow, Strobe, Brightness, Speed factor
  {1, 0, 255, 1},   // Rainbow gradient
  {0, 1, 255, 1},   // White strobe
  {1, 0, 180, 1},   // Medium brightness rainbow
  {0, 1, 255, 1},   // Random color strobe
  {1, 0, 220, 2},   // Slow rainbow
  {0, 1, 255, 1},   // Triple strobe
  {1, 0, 150, 1},   // Deep color rainbow
  {0, 1, 255, 0}    // Climax strobe
};

unsigned long lastBeat = 0;    // Timestamp of last beat
int patternIndex = 0;          // Current pattern index

void setup() {
  // Set RGB pins as outputs
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
  
  // Initialize random number generator
  randomSeed(analogRead(0));
  
  // Start with LEDs off
  setColor(0, 0, 0);
  
  // Initialize timer
  lastBeat = millis();
  
  // Smooth startup sequence
  fadeIn();
}

void loop() {
  unsigned long currentTime = millis();
  
  // Check if it's time to switch to next pattern
  if (currentTime - lastBeat >= beatDuration) {
    lastBeat = currentTime;
    
    // Execute the current pattern
    executePattern();
    
    // Move to next pattern (loop back to start)
    patternIndex = (patternIndex + 1) % patternCount;
  }
  
  // Continuously update color in rainbow mode
  if (patterns[patternIndex][0] == 1) {
    updateRainbow(patterns[patternIndex][3]);
  }
  
  // Add random micro-flashes for dynamic effect
  if (random(100) < 5) {
    microFlash();
  }
}

// Smooth fade-in startup sequence
void fadeIn() {
  // Fade in red
  for (int i = 0; i <= 255; i += 5) {
    setColor(i, 0, 0);
    delay(30);
  }
  
  // Fade in green
  for (int i = 0; i <= 255; i += 5) {
    setColor(255, i, 0);
    delay(30);
  }
  
  // Fade in blue
  for (int i = 0; i <= 255; i += 5) {
    setColor(255, 255, i);
    delay(30);
  }
  
  // Turn off and pause before main sequence
  setColor(0, 0, 0);
  delay(200);
}

// Execute the current pattern effect
void executePattern() {
  int patternType = patterns[patternIndex][0];
  int flashType = patterns[patternIndex][1];
  int brightness = patterns[patternIndex][2];
  
  if (patternType == 1) { 
    // Rainbow mode - handled in main loop
  } 
  else if (flashType == 1) { 
    // Strobe mode - execute specific strobe effect
    switch (patternIndex) {
      case 1: // White strobe
        whiteFlash(2, 80); 
        break;
      case 3: // Random color strobe
        randomColorFlash(4, 60); 
        break;
      case 5: // Triple strobe
        tripleFlash();
        break;
      case 7: // Climax strobe
        climaxFlash();
        break;
    }
  }
}

// Update rainbow color progression
void updateRainbow(int speedFactor) {
  // Increment hue value (controls color change speed)
  currentHue += 0.003 * speedFactor;
  if (currentHue >= 1.0) currentHue = 0.0;
  
  // Convert HSV to RGB
  hsvToRgb(currentHue, 1.0, patterns[patternIndex][2]/255.0);
  
  // Apply new color
  setColor(currentR, currentG, currentB);
}

// Convert HSV color space to RGB
void hsvToRgb(float h, float s, float v) {
  int i = int(h * 6);
  float f = h * 6 - i;
  float p = v * (1 - s);
  float q = v * (1 - f * s);
  float t = v * (1 - (1 - f) * s);
  
  switch (i % 6) {
    case 0: 
      currentR = v * 255; 
      currentG = t * 255; 
      currentB = p * 255; 
      break;
    case 1: 
      currentR = q * 255; 
      currentG = v * 255; 
      currentB = p * 255; 
      break;
    case 2: 
      currentR = p * 255; 
      currentG = v * 255; 
      currentB = t * 255; 
      break;
    case 3: 
      currentR = p * 255; 
      currentG = q * 255; 
      currentB = v * 255; 
      break;
    case 4: 
      currentR = t * 255; 
      currentG = p * 255; 
      currentB = v * 255; 
      break;
    case 5: 
      currentR = v * 255; 
      currentG = p * 255; 
      currentB = q * 255; 
      break;
  }
}

// Set LED color using PWM values
void setColor(int r, int g, int b) {
  analogWrite(redPin, r);
  analogWrite(greenPin, g);
  analogWrite(bluePin, b);
}

// White strobe effect
void whiteFlash(int count, int delayTime) {
  for (int i = 0; i < count; i++) {
    setColor(255, 255, 255);  // White
    delay(delayTime);
    setColor(0, 0, 0);        // Off
    delay(delayTime/2);
    
    // Restore current rainbow color
    setColor(currentR, currentG, currentB);
    delay(delayTime/2);
  }
}

// Random color strobe effect
void randomColorFlash(int count, int delayTime) {
  for (int i = 0; i < count; i++) {
    // Generate random bright color
    int r = random(50, 255);
    int g = random(50, 255);
    int b = random(50, 255);
    
    setColor(r, g, b);
    delay(delayTime);
    setColor(0, 0, 0);
    delay(delayTime/2);
  }
  
  // Restore current rainbow color
  setColor(currentR, currentG, currentB);
}

// Triple color strobe effect
void tripleFlash() {
  for (int i = 0; i < 3; i++) {
    // Red flash
    setColor(255, 0, 0);
    delay(50);
    setColor(0, 0, 0);
    delay(30);
    
    // Green flash
    setColor(0, 255, 0);
    delay(50);
    setColor(0, 0, 0);
    delay(30);
    
    // Blue flash
    setColor(0, 0, 255);
    delay(50);
    setColor(0, 0, 0);
    delay(50);
  }
  
  // Restore current rainbow color
  setColor(currentR, currentG, currentB);
}

// Climax strobe sequence
void climaxFlash() {
  // Fast color sequence through rainbow colors
  int colors[][3] = {
    {255, 0, 0},    // Red
    {255, 255, 0},  // Yellow
    {0, 255, 0},    // Green
    {0, 255, 255},  // Cyan
    {0, 0, 255},    // Blue
    {255, 0, 255},  // Magenta
    {255, 255, 255} // White
  };
  
  // Flash through all colors
  for (int i = 0; i < 7; i++) {
    setColor(colors[i][0], colors[i][1], colors[i][2]);
    delay(50);
    setColor(0, 0, 0);
    delay(30);
  }
  
  // Final triple white flash
  for (int i = 0; i < 3; i++) {
    setColor(255, 255, 255);
    delay(40);
    setColor(0, 0, 0);
    delay(30);
  }
  
  // Restore current rainbow color
  setColor(currentR, currentG, currentB);
}

// Random micro-flash effect for added dynamics
void microFlash() {
  int originalR = currentR;
  int originalG = currentG;
  int originalB = currentB;
  
  // Temporarily increase brightness
  setColor(
    constrain(originalR + 60, 0, 255),
    constrain(originalG + 60, 0, 255),
    constrain(originalB + 60, 0, 255)
  );
  
  // Short delay for visible effect
  delay(20);
  
  // Restore original brightness
  setColor(originalR, originalG, originalB);
}