# Lab: Tetris Light Symphony - Classic Game Music Meets LED Magic ## **Objective** Create a synchronized light and music show using TK33 WS2812 LED strip and TK37 Passive Buzzer playing the iconic Tetris theme (Korobeiniki). The LED strip will change colors and patterns based on the musical notes, creating an immersive audio-visual experience that captures the classic Tetris gaming atmosphere. ## **Required Components**  1. **Lonely Binary UNO R3** - Main Arduino board 2. **TinkerBlock UNO R3 Shield** - Expansion shield that plugs onto the UNO R3 3. **TinkerBlock TK33** - WS2812 LED Strip Module 4. **TinkerBlock TK37** - Passive Buzzer Module ## **Theory** ### **Tetris Theme (Korobeiniki) Analysis** - **Origin**: Russian folk song "Korobeiniki" (The Peddlers) - **Tempo**: 144 BPM (beats per minute) - faster than typical songs - **Key**: E minor - **Structure**: A-B-A-B format with repeating motifs - **Character**: Upbeat, energetic, perfect for gaming ### **Musical Characteristics** - **Fast-paced**: 144 BPM creates energetic feel - **Repetitive motifs**: Perfect for loop-based light patterns - **Clear melody**: Distinctive Russian folk melody - **Strong rhythm**: Driving beat ideal for visual synchronization ### **WS2812 LED Strip** - **Addressable RGB LEDs**: Each LED can be individually controlled - **24-bit Color**: 8 bits each for Red, Green, and Blue (16.7 million colors) - **Serial Protocol**: Single-wire communication protocol - **Cascading Control**: Control multiple LEDs with one data line ### **Musical Synchronization** - **Note Timing**: Each musical note has specific duration - **Color Mapping**: Different colors for different note types and sections - **Pattern Effects**: Visual patterns that match musical rhythm - **Beat Detection**: Synchronize light changes with musical beats ## **Wiring Instructions** ### **TK33 WS2812 LED Strip Pinout** - **GND** → Arduino GND - **VCC** → Arduino 5V - **NC** → No Connection - **Signal** → Arduino Digital Pin D5 ### **TK37 Passive Buzzer Pinout** - **GND** → Arduino GND - **VCC** → Arduino 5V - **NC** → No Connection - **Signal** → Arduino Digital Pin D7 ### **Connection Diagram**  ``` UNO R3 + Shield ├── Digital Pin D5 ──→ TK33 Signal (WS2812 Data) └── Digital Pin D7 ──→ TK37 Signal (Buzzer) ``` ## **Basic Tetris Musical Light Show** ```cpp // Tetris Musical Light Show // Based on the classic Tetris theme (Korobeiniki) // Requires FastLED library: https://github.com/FastLED/FastLED #include <FastLED.h> // Pin definitions #define LED_PIN 5 // TK33 WS2812 LED Strip on D5 #define BUZZER_PIN 7 // TK37 Passive Buzzer on D7 #define NUM_LEDS 5 // TK33 has 5 WS2812 LEDs // LED array CRGB leds[NUM_LEDS]; // Tetris theme note definitions #define NOTE_B0 31 #define NOTE_C1 33 #define NOTE_CS1 35 #define NOTE_D1 37 #define NOTE_DS1 39 #define NOTE_E1 41 #define NOTE_F1 44 #define NOTE_FS1 46 #define NOTE_G1 49 #define NOTE_GS1 52 #define NOTE_A1 55 #define NOTE_AS1 58 #define NOTE_B1 62 #define NOTE_C2 65 #define NOTE_CS2 69 #define NOTE_D2 73 #define NOTE_DS2 78 #define NOTE_E2 82 #define NOTE_F2 87 #define NOTE_FS2 93 #define NOTE_G2 98 #define NOTE_GS2 104 #define NOTE_A2 110 #define NOTE_AS2 117 #define NOTE_B2 123 #define NOTE_C3 131 #define NOTE_CS3 139 #define NOTE_D3 147 #define NOTE_DS3 156 #define NOTE_E3 165 #define NOTE_F3 175 #define NOTE_FS3 185 #define NOTE_G3 196 #define NOTE_GS3 208 #define NOTE_A3 220 #define NOTE_AS3 233 #define NOTE_B3 247 #define NOTE_C4 262 #define NOTE_CS4 277 #define NOTE_D4 294 #define NOTE_DS4 311 #define NOTE_E4 330 #define NOTE_F4 349 #define NOTE_FS4 370 #define NOTE_G4 392 #define NOTE_GS4 415 #define NOTE_A4 440 #define NOTE_AS4 466 #define NOTE_B4 494 #define NOTE_C5 523 #define NOTE_CS5 554 #define NOTE_D5 587 #define NOTE_DS5 622 #define NOTE_E5 659 #define NOTE_F5 698 #define NOTE_FS5 740 #define NOTE_G5 784 #define NOTE_GS5 831 #define NOTE_A5 880 #define NOTE_AS5 932 #define NOTE_B5 988 #define NOTE_C6 1047 #define NOTE_CS6 1109 #define NOTE_D6 1175 #define NOTE_DS6 1245 #define NOTE_E6 1319 #define NOTE_F6 1397 #define NOTE_FS6 1480 #define NOTE_G6 1568 #define NOTE_GS6 1661 #define NOTE_A6 1760 #define NOTE_AS6 1865 #define NOTE_B6 1976 #define NOTE_C7 2093 #define NOTE_CS7 2217 #define NOTE_D7 2349 #define NOTE_DS7 2489 #define NOTE_E7 2637 #define NOTE_F7 2794 #define NOTE_FS7 2960 #define NOTE_G7 3136 #define NOTE_GS7 3322 #define NOTE_A7 3520 #define NOTE_AS7 3729 #define NOTE_B7 3951 #define NOTE_C8 4186 #define NOTE_CS8 4435 #define NOTE_D8 4699 #define NOTE_DS8 4978 #define REST 0 // Tetris theme tempo and timing int tempo = 144; // Beats per minute int wholenote = (60000 * 4) / tempo; // Duration of a whole note in ms // Tetris theme melody and durations int melody[] = { // Based on the arrangement at https://www.flutetunes.com/tunes.php?id=192 NOTE_E5, 4, NOTE_B4,8, NOTE_C5,8, NOTE_D5,4, NOTE_C5,8, NOTE_B4,8, NOTE_A4, 4, NOTE_A4,8, NOTE_C5,8, NOTE_E5,4, NOTE_D5,8, NOTE_C5,8, NOTE_B4, -4, NOTE_C5,8, NOTE_D5,4, NOTE_E5,4, NOTE_C5, 4, NOTE_A4,4, NOTE_A4,4, REST,4, REST,8, NOTE_D5, 4, NOTE_F5,8, NOTE_A5,4, NOTE_G5,8, NOTE_F5,8, NOTE_E5, -4, NOTE_C5,8, NOTE_E5,4, NOTE_D5,8, NOTE_C5,8, NOTE_B4, 4, NOTE_B4,8, NOTE_C5,8, NOTE_D5,4, NOTE_E5,4, NOTE_C5, 4, NOTE_A4,4, NOTE_A4,4, REST, 4, NOTE_E5,2, NOTE_C5,2, NOTE_D5,2, NOTE_B4,2, NOTE_C5,2, NOTE_A4,2, NOTE_B4,1, NOTE_E5,2, NOTE_C5,2, NOTE_D5,2, NOTE_B4,2, NOTE_C5,4, NOTE_E5,4, NOTE_A5,2, NOTE_GS5,1, NOTE_E5, 4, NOTE_B4,8, NOTE_C5,8, NOTE_D5,4, NOTE_C5,8, NOTE_B4,8, NOTE_A4, 4, NOTE_A4,8, NOTE_C5,8, NOTE_E5,4, NOTE_D5,8, NOTE_C5,8, NOTE_B4, -4, NOTE_C5,8, NOTE_D5,4, NOTE_E5,4, NOTE_C5, 4, NOTE_A4,4, NOTE_A4,4, REST,4, REST,8, NOTE_D5, 4, NOTE_F5,8, NOTE_A5,4, NOTE_G5,8, NOTE_F5,8, REST,8, NOTE_E5, 4, NOTE_C5,8, NOTE_E5,4, NOTE_D5,8, NOTE_C5,8, REST,8, NOTE_B4, 4, NOTE_C5,8, NOTE_D5,4, NOTE_E5,4, REST,8, NOTE_C5, 4, NOTE_A4,8, NOTE_A4,4, REST, 4, }; // Color definitions for Tetris theme #define COLOR_TETRIS_BLUE CRGB(0, 100, 255) // Classic Tetris blue #define COLOR_TETRIS_CYAN CRGB(0, 255, 255) // I-piece color #define COLOR_TETRIS_YELLOW CRGB(255, 255, 0) // O-piece color #define COLOR_TETRIS_GREEN CRGB(0, 255, 0) // S-piece color #define COLOR_TETRIS_RED CRGB(255, 0, 0) // Z-piece color #define COLOR_TETRIS_ORANGE CRGB(255, 165, 0) // L-piece color #define COLOR_TETRIS_PURPLE CRGB(128, 0, 128) // T-piece color #define COLOR_TETRIS_PINK CRGB(255, 20, 147) // Accent color #define COLOR_TETRIS_WHITE CRGB(255, 255, 255) // Bright accent #define COLOR_TETRIS_GOLD CRGB(255, 215, 0) // Special effect // Calculate number of notes int notes = sizeof(melody) / sizeof(melody[0]) / 2; void setup() { // Initialize serial communication Serial.begin(9600); Serial.println("Tetris Musical Light Show"); Serial.println("========================="); // Initialize WS2812 LED strip FastLED.addLeds<WS2812, LED_PIN, GRB>(leds, NUM_LEDS); FastLED.setBrightness(50); // Set brightness (0-255) // Initialize buzzer pin pinMode(BUZZER_PIN, OUTPUT); // Clear all LEDs FastLED.clear(); FastLED.show(); delay(1000); Serial.println("Hardware initialized!"); Serial.println("TK33 WS2812 LED Strip: D5"); Serial.println("TK37 Passive Buzzer: D7"); Serial.println(); Serial.println("Tetris Theme (Korobeiniki) - 144 BPM"); Serial.println("Starting musical light show..."); Serial.println(); } void loop() { // Play Tetris theme with synchronized lights playTetrisTheme(); // Wait before repeating delay(3000); Serial.println("Tetris theme finished. Repeating in 3 seconds..."); Serial.println(); } void playTetrisTheme() { Serial.println("🎮 Playing: Tetris Theme (Korobeiniki) 🎮"); Serial.println(); // Play the melody with synchronized lights for (int thisNote = 0; thisNote < notes * 2; thisNote = thisNote + 2) { // Get note and duration int note = melody[thisNote]; int duration = melody[thisNote + 1]; // Calculate note duration int noteDuration = calculateNoteDuration(duration); // Play note with synchronized light effect playNoteWithLight(note, noteDuration, thisNote); } // Final fade out fadeOut(); Serial.println("Tetris theme complete!"); Serial.println(); } int calculateNoteDuration(int duration) { int noteDuration; if (duration > 0) { // Regular note noteDuration = wholenote / duration; } else if (duration < 0) { // Dotted note noteDuration = wholenote / abs(duration); noteDuration *= 1.5; // Increase duration by half } else { // Rest noteDuration = wholenote / 4; } return noteDuration; } void playNoteWithLight(int note, int duration, int noteIndex) { // Skip if it's a rest if (note == REST) { Serial.println("Rest"); delay(duration); return; } // Choose color based on note and position CRGB color = chooseColorForNote(note, noteIndex); // Set LED color setAllLEDs(color); FastLED.show(); // Play note tone(BUZZER_PIN, note, duration * 0.9); // Display note info Serial.print("Note "); Serial.print(noteIndex / 2 + 1); Serial.print(": "); Serial.print(note); Serial.print("Hz ("); Serial.print(duration); Serial.print("ms) - "); printColorName(color); Serial.println(); // Wait for note duration delay(duration); // Turn off buzzer noTone(BUZZER_PIN); // Clear LEDs FastLED.clear(); FastLED.show(); // Small pause between notes delay(20); } CRGB chooseColorForNote(int note, int noteIndex) { // Color mapping based on note frequency ranges if (note >= NOTE_E5 && note <= NOTE_E6) { // High E notes - Tetris blue return COLOR_TETRIS_BLUE; } else if (note >= NOTE_C5 && note <= NOTE_D5) { // C and D notes - Cyan (I-piece) return COLOR_TETRIS_CYAN; } else if (note >= NOTE_A4 && note <= NOTE_B4) { // A and B notes - Yellow (O-piece) return COLOR_TETRIS_YELLOW; } else if (note >= NOTE_F5 && note <= NOTE_G5) { // F and G notes - Green (S-piece) return COLOR_TETRIS_GREEN; } else if (note >= NOTE_A5 && note <= NOTE_B5) { // High A and B notes - Red (Z-piece) return COLOR_TETRIS_RED; } else if (note >= NOTE_GS5) { // Very high notes - Orange (L-piece) return COLOR_TETRIS_ORANGE; } else if (note >= NOTE_D4 && note <= NOTE_E4) { // Middle D and E notes - Purple (T-piece) return COLOR_TETRIS_PURPLE; } else if (note >= NOTE_A4 && note <= NOTE_C5) { // A to C range - Pink accent return COLOR_TETRIS_PINK; } else { // Default - Gold return COLOR_TETRIS_GOLD; } } void setAllLEDs(CRGB color) { for (int i = 0; i < NUM_LEDS; i++) { leds[i] = color; } } void fadeOut() { Serial.println("Fading out..."); // Gradually reduce brightness for (int brightness = 50; brightness >= 0; brightness--) { FastLED.setBrightness(brightness); FastLED.show(); delay(20); } // Clear all LEDs FastLED.clear(); FastLED.show(); } void printColorName(CRGB color) { if (color == COLOR_TETRIS_BLUE) Serial.print("Tetris Blue"); else if (color == COLOR_TETRIS_CYAN) Serial.print("Cyan (I-piece)"); else if (color == COLOR_TETRIS_YELLOW) Serial.print("Yellow (O-piece)"); else if (color == COLOR_TETRIS_GREEN) Serial.print("Green (S-piece)"); else if (color == COLOR_TETRIS_RED) Serial.print("Red (Z-piece)"); else if (color == COLOR_TETRIS_ORANGE) Serial.print("Orange (L-piece)"); else if (color == COLOR_TETRIS_PURPLE) Serial.print("Purple (T-piece)"); else if (color == COLOR_TETRIS_PINK) Serial.print("Pink Accent"); else if (color == COLOR_TETRIS_GOLD) Serial.print("Gold"); else Serial.print("Custom"); } ``` ## **Code Explanation** ### **Hardware Integration** ```cpp #define LED_PIN 5 // TK33 WS2812 LED Strip on D5 #define BUZZER_PIN 7 // TK37 Passive Buzzer on D7 #define NUM_LEDS 5 // TK33 has 5 WS2812 LEDs ``` - **Dual Hardware**: Combines LED strip and buzzer for audio-visual experience - **Pin Management**: Separate pins for LED data and buzzer control - **LED Count**: TK33 module has 5 addressable RGB LEDs - **Synchronization**: Coordinated control of both audio and visual elements ### **FastLED Library Integration** ```cpp #include <FastLED.h> FastLED.addLeds<WS2812, LED_PIN, GRB>(leds, NUM_LEDS); FastLED.setBrightness(50); ``` - **Library Requirement**: FastLED library for WS2812 control - **LED Configuration**: WS2812 protocol with GRB color order - **Brightness Control**: 50/255 brightness for comfortable viewing - **Memory Management**: Efficient LED array handling ### **Tetris Theme Implementation** ```cpp int melody[] = { NOTE_E5, 4, NOTE_B4,8, NOTE_C5,8, NOTE_D5,4, NOTE_C5,8, NOTE_B4,8, // ... complete melody array }; ``` - **Authentic Melody**: Based on original Korobeiniki arrangement - **Note-Duration Pairs**: Each note followed by its duration value - **Musical Accuracy**: Preserves original timing and rhythm - **Memory Efficiency**: Compact array representation ### **Tempo and Timing System** ```cpp int tempo = 144; // Beats per minute int wholenote = (60000 * 4) / tempo; // Duration of a whole note in ms int calculateNoteDuration(int duration) { int noteDuration; if (duration > 0) { noteDuration = wholenote / duration; } else if (duration < 0) { noteDuration = wholenote / abs(duration); noteDuration *= 1.5; // Dotted note } else { noteDuration = wholenote / 4; // Rest } return noteDuration; } ``` - **BPM Calculation**: 144 BPM for authentic Tetris tempo - **Duration Conversion**: Converts musical notation to milliseconds - **Dotted Notes**: Handles dotted note timing (1.5x duration) - **Rest Support**: Proper silence timing for musical accuracy ### **Audio-Visual Synchronization** ```cpp void playNoteWithLight(int note, int duration, int noteIndex) { if (note == REST) { Serial.println("Rest"); delay(duration); return; } CRGB color = chooseColorForNote(note, noteIndex); setAllLEDs(color); FastLED.show(); tone(BUZZER_PIN, note, duration * 0.9); delay(duration); noTone(BUZZER_PIN); FastLED.clear(); FastLED.show(); delay(20); } ``` - **Perfect Timing**: LED changes exactly with note playback - **Color Selection**: Each note triggers specific color - **Clean Transitions**: Clear LEDs between notes - **Rest Handling**: Proper silence with no visual output ### **Color Mapping System** ```cpp CRGB chooseColorForNote(int note, int noteIndex) { if (note >= NOTE_E5 && note <= NOTE_E6) { return COLOR_TETRIS_BLUE; } else if (note >= NOTE_C5 && note <= NOTE_D5) { return COLOR_TETRIS_CYAN; } // ... more color mappings } ``` - **Frequency-Based Mapping**: Different frequency ranges get different colors - **Tetris Theme Colors**: Uses classic Tetris piece colors - **Visual Consistency**: Same notes always get same colors - **Gaming Aesthetic**: Authentic Tetris visual experience ### **Tetris Color Palette** ```cpp #define COLOR_TETRIS_BLUE CRGB(0, 100, 255) // Classic Tetris blue #define COLOR_TETRIS_CYAN CRGB(0, 255, 255) // I-piece color #define COLOR_TETRIS_YELLOW CRGB(255, 255, 0) // O-piece color #define COLOR_TETRIS_GREEN CRGB(0, 255, 0) // S-piece color #define COLOR_TETRIS_RED CRGB(255, 0, 0) // Z-piece color #define COLOR_TETRIS_ORANGE CRGB(255, 165, 0) // L-piece color #define COLOR_TETRIS_PURPLE CRGB(128, 0, 128) // T-piece color ``` - **Authentic Colors**: Matches classic Tetris piece colors - **High Contrast**: Bright, vibrant colors for visual impact - **Color Variety**: Seven distinct colors for musical variety - **Gaming Nostalgia**: Evokes classic Tetris gaming experience ### **LED Control Functions** ```cpp void setAllLEDs(CRGB color) { for (int i = 0; i < NUM_LEDS; i++) { leds[i] = color; } } void fadeOut() { for (int brightness = 50; brightness >= 0; brightness--) { FastLED.setBrightness(brightness); FastLED.show(); delay(20); } FastLED.clear(); FastLED.show(); } ``` - **Unified Control**: All LEDs show same color simultaneously - **Smooth Transitions**: Gradual brightness changes - **Clean Shutdown**: Proper LED clearing and reset - **Visual Polish**: Professional fade-out effect ### **Debug and Feedback System** ```cpp Serial.print("Note "); Serial.print(noteIndex / 2 + 1); Serial.print(": "); Serial.print(note); Serial.print("Hz ("); Serial.print(duration); Serial.print("ms) - "); printColorName(color); Serial.println(); ``` - **Real-time Feedback**: Shows each note as it plays - **Technical Information**: Frequency, duration, and color data - **Progress Tracking**: Note number and timing information - **Debug Support**: Helps troubleshoot synchronization issues ### **Key Programming Concepts** #### **Audio-Visual Synchronization** - **Perfect Timing**: LED changes exactly with musical notes - **Color Coordination**: Each note type gets specific color - **Rhythm Matching**: Visual patterns follow musical rhythm - **Rest Handling**: Proper silence periods with no visual output #### **Memory Management** - **Efficient Arrays**: Compact melody and duration storage - **LED Buffer**: FastLED library handles LED memory efficiently - **Color Definitions**: Pre-defined colors save memory - **Optimized Loops**: Minimal memory usage in main loop #### **Musical Accuracy** - **Authentic Tempo**: 144 BPM matches original Tetris theme - **Note Timing**: Precise duration calculations for each note - **Dotted Notes**: Proper handling of musical notation - **Rest Support**: Accurate silence timing ## **Expected Output** ### **Serial Monitor Output** ``` Tetris Musical Light Show ========================= Hardware initialized! TK33 WS2812 LED Strip: D5 TK37 Passive Buzzer: D7 Tetris Theme (Korobeiniki) - 144 BPM Starting musical light show... 🎮 Playing: Tetris Theme (Korobeiniki) 🎮 Note 1: 659Hz (417ms) - Tetris Blue Note 2: 494Hz (208ms) - Yellow (O-piece) Note 3: 523Hz (208ms) - Cyan (I-piece) Note 4: 587Hz (417ms) - Tetris Blue Note 5: 523Hz (208ms) - Cyan (I-piece) Note 6: 494Hz (208ms) - Yellow (O-piece) Note 7: 440Hz (417ms) - Yellow (O-piece) Note 8: 440Hz (208ms) - Yellow (O-piece) Note 9: 523Hz (208ms) - Cyan (I-piece) Note 10: 659Hz (417ms) - Tetris Blue ... Rest ... Fading out... Tetris theme complete! Tetris theme finished. Repeating in 3 seconds... ``` ### **Audio Output** - **Tetris Theme**: Authentic Korobeiniki melody at 144 BPM - **Note Clarity**: Clear, distinct musical notes - **Rhythm Accuracy**: Proper timing and musical flow - **Loop Playback**: Continuous theme repetition - **Professional Quality**: High-quality musical output ### **Visual Output** - **Color Synchronization**: LED colors change with each note - **Tetris Colors**: Classic Tetris piece colors (blue, cyan, yellow, green, red, orange, purple) - **Smooth Transitions**: Clean color changes between notes - **Fade Effects**: Gradual brightness changes and fade-out - **Gaming Aesthetic**: Authentic Tetris visual experience ### **Synchronization Quality** - **Perfect Timing**: LED changes exactly with musical notes - **Color Consistency**: Same notes always get same colors - **Rest Handling**: No visual output during silence - **Rhythm Matching**: Visual patterns follow musical rhythm ## **Troubleshooting** ### **LED Strip Issues:** - **No Lights**: Check TK33 wiring (D5 pin) and power supply - **Wrong Colors**: Verify GRB color order in FastLED configuration - **Flickering**: Ensure stable 5V power supply with sufficient current - **Library Issues**: Install FastLED library from Arduino Library Manager ### **Buzzer Problems:** - **No Sound**: Check TK37 wiring (D7 pin) and power connections - **Distorted Audio**: Verify stable 5V power supply - **Wrong Notes**: Check note frequency definitions and tone() function - **Timing Issues**: Verify tempo calculations and duration values ### **Synchronization Issues:** - **LED/Audio Mismatch**: Check note timing and LED update timing - **Color Errors**: Verify color mapping function and note frequency ranges - **Timing Drift**: Ensure consistent delay() timing throughout - **Memory Problems**: Check for memory overflow with large melody arrays ### **Performance Issues:** - **Slow Response**: Optimize LED update frequency and timing - **Memory Full**: Reduce melody length or optimize array usage - **Power Issues**: Ensure adequate power supply for both LED strip and buzzer - **Library Conflicts**: Check for conflicts with other libraries ### **Visual Quality Problems:** - **Dim Lights**: Increase FastLED.setBrightness() value - **Color Bleeding**: Check LED strip quality and power supply - **Inconsistent Colors**: Verify color definitions and mapping logic - **Flickering**: Ensure stable power and proper grounding ## **Applications** ### **Entertainment** - **Gaming Events**: Tetris-themed parties and competitions - **Retro Gaming**: Nostalgic gaming atmosphere creation - **Music Visualization**: Visual representation of classic game music - **Party Lighting**: Dynamic light shows for gaming events ### **Educational** - **Music Theory**: Learn about timing and rhythm in gaming music - **Color Theory**: Understand RGB color mixing with game themes - **Programming**: Practice timing and synchronization - **Gaming History**: Learn about classic game music ### **Commercial** - **Arcade Lighting**: Retro arcade atmosphere creation - **Gaming Cafes**: Immersive gaming environment - **Event Venues**: Gaming-themed events and parties - **Retail Displays**: Gaming product demonstrations ### **Artistic** - **Performance Art**: Audio-visual installations - **Interactive Art**: User-controlled light and music experiences - **Digital Art**: Programming-based artistic expression - **Installation Art**: Large-scale audio-visual displays ## **Customization Ideas** ### **Add More Game Themes:** - **Super Mario**: Classic Mario theme with green/red colors - **Pac-Man**: Pac-Man theme with yellow/blue colors - **Space Invaders**: Space theme with green/white colors - **Donkey Kong**: Jungle theme with brown/orange colors ### **Enhance Visual Effects:** - **Pattern Effects**: Different LED patterns for different sections - **Brightness Variation**: Dynamic brightness based on note intensity - **Color Transitions**: Smooth color blending between notes - **Animation Effects**: Moving light patterns and sequences ### **Add Interactive Elements:** - **Button Control**: Use buttons to trigger different themes - **Potentiometer Control**: Adjust tempo or brightness with analog input - **Motion Sensor**: Trigger effects with movement - **Sound Sensor**: React to external audio input ### **Advanced Features:** - **Multiple LED Strips**: Larger displays with more LEDs - **3D Effects**: Create depth with multiple LED layers - **Network Control**: Remote control via WiFi/Bluetooth - **Recording Mode**: Record and playback custom light shows ## **Next Steps** - **Learn More Game Themes**: Study other classic game music - **Explore Advanced LED Effects**: Complex patterns and animations - **Study Audio Processing**: Digital signal processing for music - **Build Larger Displays**: Multiple LED strips and complex arrangements - **Investigate MIDI**: Professional music control and synchronization ## **Resources** - **FastLED Library**: https://github.com/FastLED/FastLED - **Tetris Theme**: Original Korobeiniki arrangement and history - **Musical Notes**: Standard musical note frequencies and timing - **Color Theory**: RGB color mixing and visual design principles - **Gaming Music**: History and analysis of classic video game music