#include <FastLED.h>
// Pin Configuration
#define RING1_PIN 6 // Inner ring (1 LED)
#define RING2_PIN 7 // Second ring (7 LEDs)
#define RING3_PIN 8 // Third ring (11 LEDs)
#define RING4_PIN 9 // Outer ring (16 LEDs)
#define MODE_PIN 2 // Optional: Connect to button for mode switching
#define DEBUG_PIN 3 // Optional: Connect to button to toggle debug mode
// LED Ring Configuration
#define RING1_LEDS 1
#define RING2_LEDS 7
#define RING3_LEDS 11
#define RING4_LEDS 16
// Define separate arrays for each ring
CRGB ring1[RING1_LEDS];
CRGB ring2[RING2_LEDS];
CRGB ring3[RING3_LEDS];
CRGB ring4[RING4_LEDS];
// Serial monitoring configuration
const unsigned long SERIAL_UPDATE_INTERVAL = 1000; // Update every second
unsigned long lastSerialUpdate = 0;
bool serialMonitoringEnabled = true; // Set to false to disable if needed
// Debug configuration
bool debugMode = false;
unsigned long lastDebugUpdate = 0;
const unsigned long DEBUG_INTERVAL = 1000; // Update debug info every second
// Mode configuration
enum SystemMode {
MODE_STANDARD = 0, // Standard sunrise/sunset
MODE_DRAMATIC = 1, // More vibrant colors
MODE_ASTRONOMY = 2, // Realistic astronomical timing
MODE_TROPICAL = 3, // Vibrant tropical sunrise/sunset
MODE_ARCTIC = 4, // Long sunset/sunrise, short day/night
MODE_FAST_DEMO = 5, // Quick demo cycle
MODE_COUNT
};
SystemMode currentMode = MODE_STANDARD;
unsigned long lastModeCheck = 0;
const unsigned long MODE_CHECK_INTERVAL = 100; // Check mode button every 100ms
/////// TIMING CONFIGURATION ///////
// Timing presets for different modes (all in milliseconds)
struct TimingPreset {
unsigned long fadeTime; // Time for full fade cycle
unsigned long holdTimeDark; // Time to hold in darkness
unsigned long daylightDuration; // Time to hold at full daylight
unsigned long moonlightDuration; // Time to hold at full moonlight
};
// Timing presets for each mode - adjust these as desired
// Simulation mode values (1/100 of real values)
TimingPreset timingPresets[MODE_COUNT] = {
// Standard mode
{ 6000, 300, 1500, 1200 },
// Dramatic mode - faster transitions
{ 3000, 200, 1000, 800 },
// Astronomy mode - realistic daylight-to-night ratio
{ 4500, 200, 3000, 2000 },
// Tropical mode - short transitions, long daylight
{ 2000, 300, 3000, 800 },
// Arctic mode - long transitions, short daylight
{ 10000, 500, 500, 1500 },
// Fast demo mode - ultra quick for demonstration
{ 1000, 100, 300, 200 }
};
// Current timing configuration based on selected mode
unsigned long FADE_TIME = 6000;
unsigned long HOLD_TIME_DARK = 300;
unsigned long DAYLIGHT_DURATION = 1500;
unsigned long MOONLIGHT_DURATION = 1200;
unsigned long RING_DELAY = 10;
// Animation percentages - these control the animation phases
const uint8_t DAWN_START = 0; // Dawn begins
const uint8_t DAWN_END = 15; // Dawn ends, sunrise begins
const uint8_t SUNRISE_END = 40; // Sunrise ends, full daylight begins
const uint8_t SUNSET_START = 60; // Sunset begins
const uint8_t SUNSET_PEAK = 85; // Deep sunset colors
const uint8_t SUNSET_END = 100; // Complete darkness
const uint8_t MOONRISE_START = 0; // Moonrise begins
const uint8_t MOONRISE_END = 20; // Full moonlight begins
const uint8_t MOONSET_START = 80; // Moonset begins
const uint8_t MOONSET_END = 100; // Complete darkness
/////// COLOR CONFIGURATION ///////
// Define color palettes for different modes
struct ColorPalette {
CRGB dawnColor;
CRGB sunriseColor;
CRGB daylight;
CRGB sunsetColor;
CRGB moonlight;
};
// Color presets for each mode
ColorPalette colorPresets[MODE_COUNT] = {
// Standard mode
{
CRGB(255, 30, 0), // Dawn: Deep orange
CRGB(255, 160, 60), // Sunrise: Bright orange-yellow
CRGB(255, 255, 220), // Daylight: Warm white
CRGB(255, 40, 0), // Sunset: Deep red-orange
CRGB(180, 220, 255) // Moonlight: Cool blue-white
},
// Dramatic mode
{
CRGB(255, 0, 0), // Dawn: Pure red
CRGB(255, 100, 0), // Sunrise: Vibrant orange
CRGB(255, 255, 255), // Daylight: Pure white
CRGB(255, 0, 80), // Sunset: Red-purple
CRGB(80, 120, 255) // Moonlight: Rich blue
},
// Astronomy mode
{
CRGB(200, 40, 10), // Dawn: Subtle red-orange
CRGB(230, 150, 80), // Sunrise: Soft gold
CRGB(245, 245, 235), // Daylight: Natural white
CRGB(240, 80, 20), // Sunset: Realistic orange sunset
CRGB(160, 200, 255) // Moonlight: Pale blue-white
},
// Tropical mode
{
CRGB(255,50, 20), // Dawn: Vivid red
CRGB(255, 170, 0), // Sunrise: Golden yellow
CRGB(255, 240, 200), // Daylight: Warm tropical sun
CRGB(255, 50, 20), // Sunset: Deep orange-red
CRGB(100, 160, 255) // Moonlight: Tropical night blue
},
// Arctic mode
{
CRGB(160, 120, 170), // Dawn: Purple-blue
CRGB(200, 180, 255), // Sunrise: Lavender-blue
CRGB(230, 240, 255), // Daylight: Cool arctic white
CRGB(220, 130, 170), // Sunset: Pink-purple
CRGB(100, 140, 230) // Moonlight: Deep blue
},
// Fast demo mode
{
CRGB(255, 0, 0), // Dawn: Red
CRGB(255, 255, 0), // Sunrise: Yellow
CRGB(255, 255, 255), // Daylight: White
CRGB(255, 0, 255), // Sunset: Magenta
CRGB(0, 0, 255) // Moonlight: Blue
}
};
// Current color palette based on selected mode
CRGB DAWN_COLOR;
CRGB SUNRISE_COLOR;
CRGB DAYLIGHT;
CRGB SUNSET_COLOR;
CRGB MOONLIGHT;
// State tracking
enum RingStateType {
STATE_SUNRISE = 0,
STATE_DAYLIGHT = 1,
STATE_SUNSET = 2,
STATE_DARK1 = 3,
STATE_MOONRISE = 4,
STATE_MOONLIGHT = 5,
STATE_MOONSET = 6,
STATE_DARK2 = 7
};
const char* stateNames[] = {
"SUNRISE", "DAYLIGHT", "SUNSET", "DARK1",
"MOONRISE", "MOONLIGHT", "MOONSET", "DARK2"
};
const char* modeNames[] = {
"STANDARD", "DRAMATIC", "ASTRONOMY", "TROPICAL", "ARCTIC", "FAST_DEMO"
};
struct RingState {
float fadeProgress;
unsigned long startTime;
bool active;
RingStateType state;
};
RingState ringStates[4];
void setup() {
// Initialize serial communication
Serial.begin(115200);
Serial.println(F("Multi-Ring Sunrise/Sunset System"));
Serial.println(F("Serial monitoring active"));
// Display initial configuration
Serial.println(F("\n--- System Configuration ---"));
Serial.print(F("Mode: "));
Serial.println(modeNames[currentMode]);
Serial.print(F("Fade Time: "));
Serial.print(FADE_TIME);
Serial.println(F(" ms"));
Serial.print(F("Daylight Duration: "));
Serial.print(DAYLIGHT_DURATION);
Serial.println(F(" ms"));
Serial.print(F("Moonlight Duration: "));
Serial.print(MOONLIGHT_DURATION);
Serial.println(F(" ms"));
Serial.print(F("Dark Hold Time: "));
Serial.print(HOLD_TIME_DARK);
Serial.println(F(" ms"));
Serial.println(F("---------------------------\n"));
// Initialize button pins if using hardware buttons
pinMode(MODE_PIN, INPUT_PULLUP);
pinMode(DEBUG_PIN, INPUT_PULLUP);
// Initialize each ring separately
FastLED.addLeds<WS2812B, RING1_PIN, GRB>(ring1, RING1_LEDS);
FastLED.addLeds<WS2812B, RING2_PIN, GRB>(ring2, RING2_LEDS);
FastLED.addLeds<WS2812B, RING3_PIN, GRB>(ring3, RING3_LEDS);
FastLED.addLeds<WS2812B, RING4_PIN, GRB>(ring4, RING4_LEDS);
FastLED.setBrightness(255);
// Initialize ring states
for(int i = 0; i < 4; i++) {
ringStates[i].fadeProgress = 0;
ringStates[i].startTime = 0;
ringStates[i].active = false;
ringStates[i].state = STATE_SUNRISE;
}
// Apply initial mode settings
applyModeSettings();
// Start first ring
ringStates[0].active = true;
ringStates[0].startTime = millis();
Serial.println(F("System initialized"));
Serial.print(F("Current mode: "));
Serial.println(modeNames[currentMode]);
}
// Apply settings based on current mode
void applyModeSettings() {
// Apply timing settings from preset
FADE_TIME = timingPresets[currentMode].fadeTime;
HOLD_TIME_DARK = timingPresets[currentMode].holdTimeDark;
DAYLIGHT_DURATION = timingPresets[currentMode].daylightDuration;
MOONLIGHT_DURATION = timingPresets[currentMode].moonlightDuration;
// Apply color settings from preset
DAWN_COLOR = colorPresets[currentMode].dawnColor;
SUNRISE_COLOR = colorPresets[currentMode].sunriseColor;
DAYLIGHT = colorPresets[currentMode].daylight;
SUNSET_COLOR = colorPresets[currentMode].sunsetColor;
MOONLIGHT = colorPresets[currentMode].moonlight;
// Mode-specific adjustments
if(currentMode == MODE_ASTRONOMY) {
// 12-hour day/night cycle with appropriate ratios
RING_DELAY = 20; // More delay between rings
} else if(currentMode == MODE_ARCTIC) {
// Long transitions
RING_DELAY = 30; // Longest delay between rings
} else {
RING_DELAY = 10; // Standard delay
}
}
void setRingColor(CRGB* ring, int numLeds, CRGB color, uint8_t brightness) {
for(int i = 0; i < numLeds; i++) {
ring[i] = color;
ring[i].nscale8(brightness); // Apply brightness
}
}
// Enhanced color transitions with special effects based on current mode
void setRingColorEnhanced(CRGB* ring, int numLeds, CRGB color, uint8_t brightness, int ringIndex) {
if(currentMode == MODE_DRAMATIC) {
// Dramatic mode: Add sparkling effect
for(int i = 0; i < numLeds; i++) {
ring[i] = color;
  // Random sparkle effect during transitions  
  if((ringStates[ringIndex].state == STATE_SUNRISE ||   
      ringStates[ringIndex].state == STATE_SUNSET) &&   
     random8() < 20) {  
    ring[i] = CRGB::White;  
  }  
  
  // Apply brightness  
  ring[i].nscale8(brightness);  
}  
}
else if(currentMode == MODE_TROPICAL) {
// Tropical mode: Slight red and orange variations
for(int i = 0; i < numLeds; i++) {
ring[i] = color;
  // Add color variations for tropical sunrise/sunset  
  if(ringStates[ringIndex].state == STATE_SUNRISE ||   
     ringStates[ringIndex].state == STATE_SUNSET) {  
    ring[i].r = qadd8(ring[i].r, random8(0, 30));  
    ring[i].g = qsub8(ring[i].g, random8(0, 20));  
  }  
  
  // Apply brightness  
  ring[i].nscale8(brightness);  
}  
}
else if(currentMode == MODE_ARCTIC) {
// Arctic mode: Add pulsing blue/purple aurora effect during night
for(int i = 0; i < numLeds; i++) {
ring[i] = color;
  // Aurora effect during moonlight  
  if(ringStates[ringIndex].state == STATE_MOONLIGHT) {  
    uint8_t wave = sin8(millis() / 200 + i * 20);  
    ring[i].b = qadd8(ring[i].b, wave / 5);  
    ring[i].g = qadd8(ring[i].g, wave / 8);  
  }  
  
  // Apply brightness  
  ring[i].nscale8(brightness);  
}  
}
else {
// Standard color setting for other modes
for(int i = 0; i < numLeds; i++) {
ring[i] = color;
ring[i].nscale8(brightness);
}
}
}
void handleRing(int ringIndex, unsigned long currentMillis) {
RingState* state = &ringStates[ringIndex];
CRGB* ring;
int numLeds;
// Select ring parameters
switch(ringIndex) {
case 0: ring = ring1; numLeds = RING1_LEDS; break;
case 1: ring = ring2; numLeds = RING2_LEDS; break;
case 2: ring = ring3; numLeds = RING3_LEDS; break;
case 3: ring = ring4; numLeds = RING4_LEDS; break;
}
// Activate next ring after delay when this ring reaches dawn end
if(ringIndex < 3 && state->active && state->state == STATE_SUNRISE &&
state->fadeProgress >= DAWN_END && !ringStates[ringIndex + 1].active) {
ringStates[ringIndex + 1].active = true;
ringStates[ringIndex + 1].startTime = currentMillis;
// Log ring activation  
if(serialMonitoringEnabled) {  
  Serial.print(F("Ring "));  
  Serial.print(ringIndex + 2);  
  Serial.println(F(" activated"));  
}  
}
if(!state->active) {
// Ring not active yet, keep it dark
setRingColor(ring, numLeds, CRGB::Black, 0);
return;
}
switch(state->state) {
case STATE_SUNRISE:
// Sunrise animation sequence
if(currentMillis - state->startTime >= (FADE_TIME / 100)) {
state->startTime = currentMillis;
state->fadeProgress += 1;
    if(state->fadeProgress <= DAWN_END) {  
      // Dawn  
      uint8_t brightness = map(state->fadeProgress, DAWN_START, DAWN_END, 0, 100);  
      setRingColorEnhanced(ring, numLeds, DAWN_COLOR, brightness, ringIndex);  
    }  
    else if(state->fadeProgress <= SUNRISE_END) {  
      // Sunrise  
      uint8_t brightness = map(state->fadeProgress, DAWN_END, SUNRISE_END, 100, 255);  
      
      // Blend between dawn and sunrise colors  
      float blendFactor = (float)(state->fadeProgress - DAWN_END) / (SUNRISE_END - DAWN_END);  
      CRGB blendedColor = blend(DAWN_COLOR, SUNRISE_COLOR, blendFactor * 255);  
      
      setRingColorEnhanced(ring, numLeds, blendedColor, brightness, ringIndex);  
    }  
    else if(state->fadeProgress <= SUNSET_START) {  
      // Full daylight  
      setRingColorEnhanced(ring, numLeds, DAYLIGHT, 255, ringIndex);  
      
      // Transition to full daylight state  
      if(state->fadeProgress == SUNRISE_END + 1) {  
        // Log state change  
        if(serialMonitoringEnabled) {  
          Serial.print(F("Ring "));  
          Serial.print(ringIndex + 1);  
          Serial.print(F(": State change "));  
          Serial.print(stateNames[STATE_SUNRISE]);  
          Serial.print(F(" → "));  
          Serial.println(stateNames[STATE_DAYLIGHT]);  
        }  
        
        state->state = STATE_DAYLIGHT;  
        state->startTime = currentMillis;  
      }  
    }  
  }  
  break;  

case STATE_DAYLIGHT:  
  // Hold full daylight for specified duration  
  setRingColorEnhanced(ring, numLeds, DAYLIGHT, 255, ringIndex);  
  if(currentMillis - state->startTime >= DAYLIGHT_DURATION) {  
    // Log state change  
    if(serialMonitoringEnabled) {  
      Serial.print(F("Ring "));  
      Serial.print(ringIndex + 1);  
      Serial.print(F(": State change "));  
      Serial.print(stateNames[STATE_DAYLIGHT]);  
      Serial.print(F(" → "));  
      Serial.println(stateNames[STATE_SUNSET]);  
    }  
    
    state->state = STATE_SUNSET;  
    state->fadeProgress = SUNSET_START;  
    state->startTime = currentMillis;  
  }  
  break;  

case STATE_SUNSET:  
  // Continue the sunset sequence  
  if(currentMillis - state->startTime >= (FADE_TIME / 100)) {  
    state->startTime = currentMillis;  
    state->fadeProgress += 1;  
    
    if(state->fadeProgress <= SUNSET_PEAK) {  
      // Sunset transition - blend from daylight to sunset  
      uint8_t brightness = map(state->fadeProgress, SUNSET_START, SUNSET_PEAK, 255, 180);  
      
      // Blend between daylight and sunset colors  
      float blendFactor = (float)(state->fadeProgress - SUNSET_START) / (SUNSET_PEAK - SUNSET_START);  
      CRGB blendedColor = blend(DAYLIGHT, SUNSET_COLOR, blendFactor * 255);  
      
      setRingColorEnhanced(ring, numLeds, blendedColor, brightness, ringIndex);  
    }  
    else if(state->fadeProgress <= SUNSET_END) {  
      // Final sunset  
      uint8_t brightness = map(state->fadeProgress, SUNSET_PEAK, SUNSET_END, 180, 20);  
      setRingColorEnhanced(ring, numLeds, SUNSET_COLOR, brightness, ringIndex);  
    }  
    
    if(state->fadeProgress >= SUNSET_END) {  
      // Log state change  
      if(serialMonitoringEnabled) {  
        Serial.print(F("Ring "));  
        Serial.print(ringIndex + 1);  
        Serial.print(F(": State change "));  
        Serial.print(stateNames[STATE_SUNSET]);  
        Serial.print(F(" → "));  
        Serial.println(stateNames[STATE_DARK1]);  
      }  
      
      state->state = STATE_DARK1;  
      state->fadeProgress = 0;  
      state->startTime = currentMillis;  
      setRingColor(ring, numLeds, CRGB::Black, 0); // Turn off  
    }  
  }  
  break;  
  
case STATE_DARK1:  
  // Hold dark for specified duration  
  if(currentMillis - state->startTime >= HOLD_TIME_DARK) {  
    // Log state change  
    if(serialMonitoringEnabled) {  
      Serial.print(F("Ring "));  
      Serial.print(ringIndex + 1);  
      Serial.print(F(": State change "));  
      Serial.print(stateNames[STATE_DARK1]);  
      Serial.print(F(" → "));  
      Serial.println(stateNames[STATE_MOONRISE]);  
    }  
    
    state->state = STATE_MOONRISE;  
    state->fadeProgress = 0;  
    state->startTime = currentMillis;  
  } else {  
    setRingColor(ring, numLeds, CRGB::Black, 0); // Ensure it's off during hold  
  }  
  break;  
  
case STATE_MOONRISE:  
  // Moonlight animation sequence  
  if(currentMillis - state->startTime >= (FADE_TIME / 100)) {  
    state->startTime = currentMillis;  
    state->fadeProgress += 1;  
    
    if(state->fadeProgress <= MOONRISE_END) {  
      // Moonrise  
      uint8_t brightness = map(state->fadeProgress, MOONRISE_START, MOONRISE_END, 0, 180);  
      setRingColorEnhanced(ring, numLeds, MOONLIGHT, brightness, ringIndex);  
    }  
    else if(state->fadeProgress <= MOONSET_START) {  
      // Full moonlight  
      setRingColorEnhanced(ring, numLeds, MOONLIGHT, 180, ringIndex);  
      
      // Transition to full moonlight hold state  
      if(state->fadeProgress == MOONRISE_END + 1) {  
        // Log state change  
        if(serialMonitoringEnabled) {  
          Serial.print(F("Ring "));  
          Serial.print(ringIndex + 1);  
          Serial.print(F(": State change "));  
          Serial.print(stateNames[STATE_MOONRISE]);  
          Serial.print(F(" → "));  
          Serial.println(stateNames[STATE_MOONLIGHT]);  
        }  
        
        state->state = STATE_MOONLIGHT;  
        state->startTime = currentMillis;  
      }  
    }  
  }  
  break;  
  
case STATE_MOONLIGHT:  
  // Hold full moonlight for specified duration  
  setRingColorEnhanced(ring, numLeds, MOONLIGHT, 180, ringIndex);  
  if(currentMillis - state->startTime >= MOONLIGHT_DURATION) {  
    // Log state change  
    if(serialMonitoringEnabled) {  
      Serial.print(F("Ring "));  
      Serial.print(ringIndex + 1);  
      Serial.print(F(": State change "));  
      Serial.print(stateNames[STATE_MOONLIGHT]);  
      Serial.print(F(" → "));  
      Serial.println(stateNames[STATE_MOONSET]);  
    }  
    
    state->state = STATE_MOONSET;  
    state->fadeProgress = MOONSET_START;  
    state->startTime = currentMillis;  
  }  
  break;  
  
case STATE_MOONSET:  
  // Continue the moonset sequence  
  if(currentMillis - state->startTime >= (FADE_TIME / 100)) {  
    state->startTime = currentMillis;  
    state->fadeProgress += 1;  
    
    if(state->fadeProgress <= MOONSET_END) {  
      // Moonset  
      uint8_t brightness = map(state->fadeProgress, MOONSET_START, MOONSET_END, 180, 0);  
      setRingColorEnhanced(ring, numLeds, MOONLIGHT, brightness, ringIndex);  
    }  
    
    if(state->fadeProgress >= MOONSET_END) {  
      // Log state change  
      if(serialMonitoringEnabled) {  
        Serial.print(F("Ring "));  
        Serial.print(ringIndex + 1);  
        Serial.print(F(": State change "));  
        Serial.print(stateNames[STATE_MOONSET]);  
        Serial.print(F(" → "));  
        Serial.println(stateNames[STATE_DARK2]);  
      }  
      
      state->state = STATE_DARK2;  
      state->fadeProgress = 0;  
      state->startTime = currentMillis;  
      setRingColor(ring, numLeds, CRGB::Black, 0); // Turn off  
    }  
  }  
  break;  
  
case STATE_DARK2:  
  // Hold dark before restart  
  if(currentMillis - state->startTime >= HOLD_TIME_DARK) {  
    // Log state change  
    if(serialMonitoringEnabled) {  
      Serial.print(F("Ring "));  
      Serial.print(ringIndex + 1);  
      Serial.print(F(": State change "));  
      Serial.print(stateNames[STATE_DARK2]);  
      Serial.print(F(" → "));  
      Serial.println(stateNames[STATE_SUNRISE]);  
    }  
    
    state->state = STATE_SUNRISE;  
    state->fadeProgress = 0;  
    state->startTime = currentMillis;  
  } else {  
    setRingColor(ring, numLeds, CRGB::Black, 0); // Ensure it's off during hold  
  }  
  break;  
}
}
// Check for button presses to change modes
void checkButtons(unsigned long currentMillis) {
// Only check periodically to avoid excessive reads
if(currentMillis - lastModeCheck >= MODE_CHECK_INTERVAL) {
lastModeCheck = currentMillis;
// Mode button - cycle through modes  
if(digitalRead(MODE_PIN) == LOW) {  
  delay(50); // Debounce  
  if(digitalRead(MODE_PIN) == LOW) {  
    // Change mode and apply settings  
    currentMode = (SystemMode)((currentMode + 1) % MODE_COUNT);  
    applyModeSettings();  
    
    // Reset all rings to start a fresh cycle with new settings  
    for(int i = 0; i < 4; i++) {  
      ringStates[i].fadeProgress = 0;  
      ringStates[i].startTime = currentMillis;  
      ringStates[i].state = STATE_SUNRISE;  
      ringStates[i].active = (i == 0); // Only first ring active  
    }  
    
    Serial.print(F("Mode changed to: "));  
    Serial.println(modeNames[currentMode]);  
    
    // Wait for button release  
    while(digitalRead(MODE_PIN) == LOW) {  
      delay(10);  
    }  
  }  
}  

// Debug button - toggle debug mode  
if(digitalRead(DEBUG_PIN) == LOW) {  
  delay(50); // Debounce  
  if(digitalRead(DEBUG_PIN) == LOW) {  
    debugMode = !debugMode;  
    Serial.print(F("Debug mode: "));  
    Serial.println(debugMode ? F("ON") : F("OFF"));  
    
    // Wait for button release  
    while(digitalRead(DEBUG_PIN) == LOW) {  
      delay(10);  
    }  
  }  
}  
}
}
// Update serial monitor with current status
void updateSerialMonitor(unsigned long currentMillis) {
if (!serialMonitoringEnabled) return;
if (currentMillis - lastSerialUpdate >= SERIAL_UPDATE_INTERVAL) {
lastSerialUpdate = currentMillis;
// Print header  
Serial.println(F("\n--- SYSTEM STATUS ---"));  

// Current mode  
Serial.print(F("Mode: "));  
Serial.println(modeNames[currentMode]);  

// Ring status  
for (int i = 0; i < 4; i++) {  
  Serial.print(F("Ring "));  
  Serial.print(i + 1);  
  Serial.print(F(" ("));  
  
  // Ring LED count  
  switch(i) {  
    case 0: Serial.print(F("1 LED")); break;  
    case 1: Serial.print(F("7 LEDs")); break;  
    case 2: Serial.print(F("11 LEDs")); break;  
    case 3: Serial.print(F("16 LEDs")); break;  
  }  
  
  Serial.print(F("): "));  
  
  // Active status  
  if (!ringStates[i].active) {  
    Serial.println(F("INACTIVE"));  
    continue;  
  }  
  
  // Current state  
  Serial.print(F("State="));  
  Serial.print(stateNames[ringStates[i].state]);  
  
  // Progress percentage  
  Serial.print(F(", Progress="));  
  Serial.print(ringStates[i].fadeProgress);  
  Serial.print(F("%"));  
  
  // Time in current state  
  Serial.print(F(", Time in state="));  
  Serial.print((currentMillis - ringStates[i].startTime) / 1000.0);  
  Serial.print(F("s"));  
  
  // Current effect description  
  Serial.print(F(", Effect="));  
  switch(ringStates[i].state) {  
    case STATE_SUNRISE:  
      if (ringStates[i].fadeProgress <= DAWN_END) {  
        Serial.print(F("Dawn ("));  
        Serial.print(map(ringStates[i].fadeProgress, DAWN_START, DAWN_END, 0, 100));  
        Serial.print(F("% brightness)"));  
      } else if (ringStates[i].fadeProgress <= SUNRISE_END) {  
        Serial.print(F("Sunrise ("));  
        Serial.print(map(ringStates[i].fadeProgress, DAWN_END, SUNRISE_END, 0, 100));  
        Serial.print(F("% complete)"));  
      } else {  
        Serial.print(F("Approaching daylight"));  
      }  
      break;  
      
    case STATE_DAYLIGHT:  
      Serial.print(F("Full daylight ("));  
      Serial.print((currentMillis - ringStates[i].startTime) * 100 / DAYLIGHT_DURATION);  
      Serial.print(F("% elapsed)"));  
      break;  
      
    case STATE_SUNSET:  
      if (ringStates[i].fadeProgress <= SUNSET_PEAK) {  
        Serial.print(F("Early sunset ("));  
        Serial.print(map(ringStates[i].fadeProgress, SUNSET_START, SUNSET_PEAK, 0, 100));  
        Serial.print(F("% complete)"));  
      } else {  
        Serial.print(F("Final sunset ("));  
        Serial.print(map(ringStates[i].fadeProgress, SUNSET_PEAK, SUNSET_END, 0, 100));  
        Serial.print(F("% complete)"));  
      }  
      break;  
      
    case STATE_DARK1:  
      Serial.print(F("Post-sunset darkness ("));  
      Serial.print((currentMillis - ringStates[i].startTime) *100 / HOLD_TIME_DARK);  
      Serial.print(F("% elapsed)"));  
      break;  
      
    case STATE_MOONRISE:  
      Serial.print(F("Moonrise ("));  
      Serial.print(map(ringStates[i].fadeProgress, MOONRISE_START, MOONRISE_END, 0, 100));  
      Serial.print(F("% complete)"));  
      break;  
      
    case STATE_MOONLIGHT:  
      Serial.print(F("Full moonlight ("));  
      Serial.print((currentMillis - ringStates[i].startTime) * 100 / MOONLIGHT_DURATION);  
      Serial.print(F("% elapsed)"));  
      break;  
      
    case STATE_MOONSET:  
      Serial.print(F("Moonset ("));  
      Serial.print(map(ringStates[i].fadeProgress, MOONSET_START, MOONSET_END, 0, 100));  
      Serial.print(F("% complete)"));  
      break;  
      
    case STATE_DARK2:  
      Serial.print(F("Post-moonset darkness ("));  
      Serial.print((currentMillis - ringStates[i].startTime) * 100 / HOLD_TIME_DARK);  
      Serial.print(F("% elapsed)"));  
      break;  
  }  
  
  Serial.println();  
}  

// System information  
Serial.print(F("System uptime: "));  
Serial.print(currentMillis / 1000);  
Serial.println(F(" seconds"));  

Serial.print(F("Free memory: "));  
Serial.print(freeRam());  
Serial.println(F(" bytes"));  

Serial.println(F("--------------------"));  
}
}
// Display debug information
void displayDebugInfo(unsigned long currentMillis) {
if(!debugMode) return;
if(currentMillis - lastDebugUpdate >= DEBUG_INTERVAL) {
lastDebugUpdate = currentMillis;
Serial.println(F("\n--- DEBUG INFO ---"));  
Serial.print(F("Mode: "));  
Serial.println(modeNames[currentMode]);  
Serial.print(F("FADE_TIME: "));  
Serial.println(FADE_TIME);  
Serial.print(F("DAYLIGHT_DURATION: "));  
Serial.println(DAYLIGHT_DURATION);  
Serial.print(F("MOONLIGHT_DURATION: "));  
Serial.println(MOONLIGHT_DURATION);  

for(int i = 0; i < 4; i++) {  
  Serial.print(F("Ring "));  
  Serial.print(i+1);  
  Serial.print(F(": State="));  
  Serial.print(stateNames[ringStates[i].state]);  
  Serial.print(F(", Progress="));  
  Serial.print(ringStates[i].fadeProgress);  
  Serial.print(F(", Active="));  
  Serial.println(ringStates[i].active ? F("Yes") : F("No"));  
}  

// Memory usage  
Serial.print(F("Free RAM: "));  
Serial.println(freeRam());  
Serial.println(F("----------------"));  
}
}
// Helper function to check available RAM
int freeRam() {
extern int __heap_start, *__brkval;
int v;
return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
}
void loop() {
unsigned long currentMillis = millis();
// Check for mode changes
checkButtons(currentMillis);
// Handle each ring
for(int i = 0; i < 4; i++) {
handleRing(i, currentMillis);
}
// Display debug info if enabled
displayDebugInfo(currentMillis);
// Update serial monitor with status
updateSerialMonitor(currentMillis);
  // Update all rings  
  FastLED.show();  
}