sudo apt update
sudo apt upgrade -y
sudo reboot

# Update package lists
sudo apt update

# Install Python development tools
sudo apt install python3-pip python3-dev -y

# Install LED control libraries
sudo pip3 install rpi_ws281x adafruit-circuitpython-neopixel
sudo pip3 install adafruit-circuitpython-dotstar

# Install additional useful libraries
sudo pip3 install numpy pillow flask requests

sudo raspi-config
# Navigate to Interface Options
# Enable SPI and I2C as needed
sudo reboot

import time
import board
import neopixel

# LED strip configuration
LED_COUNT = 30        # Number of LED pixels
LED_PIN = board.D18   # GPIO pin connected to LEDs
LED_BRIGHTNESS = 0.5  # Brightness (0.0 to 1.0)

# Initialize LED strip
pixels = neopixel.NeoPixel(LED_PIN, LED_COUNT, brightness=LED_BRIGHTNESS)

def set_all_color(r, g, b):
    """Set all LEDs to specified RGB color"""
    pixels.fill((r, g, b))
    pixels.show()

def rainbow_cycle(wait):
    """Rainbow cycle effect"""
    for j in range(255):
        for i in range(LED_COUNT):
            pixel_index = (i * 256 // LED_COUNT) + j
            pixels[i] = wheel(pixel_index & 255)
        pixels.show()
        time.sleep(wait)

def wheel(pos):
    """Generate rainbow colors"""
    pos = 255 - pos
    if pos < 85:
        return (255 - pos * 3, 0, pos * 3)
    if pos < 170:
        pos -= 85
        return (0, pos * 3, 255 - pos * 3)
    pos -= 170
    return (pos * 3, 255 - pos * 3, 0)

# Main program
try:
    while True:
        set_all_color(255, 0, 0)  # Red
        time.sleep(1)
        set_all_color(0, 255, 0)  # Green
        time.sleep(1)
        set_all_color(0, 0, 255)  # Blue
        time.sleep(1)
        rainbow_cycle(0.001)       # Rainbow effect
        time.sleep(2)

except KeyboardInterrupt:
    pixels.fill((0, 0, 0))  # Turn off all LEDs
    print("LED strip turned off")

import numpy as np
import pyaudio
import board
import neopixel
from collections import deque

# Audio configuration
FORMAT = pyaudio.paInt16
CHANNELS = 1
RATE = 44100
CHUNK = 1024

# LED configuration
LED_COUNT = 60
LED_PIN = board.D18
pixels = neopixel.NeoPixel(LED_PIN, LED_COUNT, brightness=0.5)

# Audio processing
audio = pyaudio.PyAudio()
stream = audio.open(format=FORMAT, channels=CHANNELS,
                   rate=RATE, input=True, frames_per_buffer=CHUNK)

# Frequency analysis setup
freq_history = deque(maxlen=10)

def get_audio_levels():
    """Get audio frequency levels"""
    data = stream.read(CHUNK)
    data = np.frombuffer(data, dtype=np.int16)
    
    # FFT to get frequency spectrum
    fft = np.fft.fft(data)
    freqs = np.abs(fft[:len(fft)//2])
    
    # Normalize frequencies
    freqs = freqs / np.max(freqs) if np.max(freqs) > 0 else freqs
    
    return freqs

def map_frequency_to_leds(freqs):
    """Map frequency levels to LED colors"""
    # Divide frequency spectrum into LED sections
    section_size = len(freqs) // LED_COUNT
    
    for i in range(LED_COUNT):
        start_idx = i * section_size
        end_idx = start_idx + section_size
        if end_idx <= len(freqs):
            # Average frequency in this section
            avg_freq = np.mean(freqs[start_idx:end_idx])
            
            # Map to color (bass=red, mid=green, treble=blue)
            if i < LED_COUNT // 3:  # Bass frequencies
                color = (int(avg_freq * 255), 0, 0)
            elif i < 2 * LED_COUNT // 3:  # Mid frequencies
                color = (0, int(avg_freq * 255), 0)
            else:  # Treble frequencies
                color = (0, 0, int(avg_freq * 255))
            
            pixels[i] = color

try:
    print("Starting music-reactive LED display...")
    while True:
        freqs = get_audio_levels()
        map_frequency_to_leds(freqs)
        pixels.show()

except KeyboardInterrupt:
    print("Stopping music-reactive display")
    stream.stop_stream()
    stream.close()
    audio.terminate()
    pixels.fill((0, 0, 0))

from flask import Flask, render_template, request, jsonify
import board
import neopixel
import json
import threading
import time

app = Flask(__name__)

# LED configuration
LED_COUNT = 30
LED_PIN = board.D18
pixels = neopixel.NeoPixel(LED_PIN, LED_COUNT, brightness=0.5)

# Global variables for LED control
current_effect = "solid"
current_color = [255, 255, 255]
effect_running = False

def solid_color_effect():
    """Solid color effect"""
    while effect_running and current_effect == "solid":
        pixels.fill(tuple(current_color))
        pixels.show()
        time.sleep(0.1)

def rainbow_effect():
    """Rainbow effect"""
    while effect_running and current_effect == "rainbow":
        for j in range(255):
            if not effect_running or current_effect != "rainbow":
                break
            for i in range(LED_COUNT):
                pixel_index = (i * 256 // LED_COUNT) + j
                pixels[i] = wheel(pixel_index & 255)
            pixels.show()
            time.sleep(0.01)

def wheel(pos):
    """Generate rainbow colors"""
    pos = 255 - pos
    if pos < 85:
        return (255 - pos * 3, 0, pos * 3)
    if pos < 170:
        pos -= 85
        return (0, pos * 3, 255 - pos * 3)
    pos -= 170
    return (pos * 3, 255 - pos * 3, 0)

def start_effect(effect_name):
    """Start LED effect"""
    global effect_running, current_effect
    
    # Stop current effect
    effect_running = False
    time.sleep(0.2)
    
    # Start new effect
    current_effect = effect_name
    effect_running = True
    
    if effect_name == "solid":
        threading.Thread(target=solid_color_effect, daemon=True).start()
    elif effect_name == "rainbow":
        threading.Thread(target=rainbow_effect, daemon=True).start()

@app.route('/')
def index():
    """Main web page"""
    return render_template('index.html')

@app.route('/api/set_color', methods=['POST'])
def set_color():
    """Set solid color"""
    global current_color
    data = request.json
    current_color = [data['r'], data['g'], data['b']]
    start_effect("solid")
    return jsonify({"status": "success"})

@app.route('/api/set_effect', methods=['POST'])
def set_effect():
    """Set LED effect"""
    data = request.json
    effect_name = data['effect']
    start_effect(effect_name)
    return jsonify({"status": "success"})

@app.route('/api/status')
def get_status():
    """Get current LED status"""
    return jsonify({
        "effect": current_effect,
        "color": current_color,
        "running": effect_running
    })

if __name__ == '__main__':
    # Start with solid white
    start_effect("solid")
    
    # Run web server
    app.run(host='0.0.0.0', port=5000, debug=False)

<!DOCTYPE html>
<html>
<head>
    <title>Raspberry Pi LED Control</title>
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        .control-panel { max-width: 600px; margin: 0 auto; }
        .color-picker { margin: 20px 0; }
        .effect-buttons { margin: 20px 0; }
        button { padding: 10px 20px; margin: 5px; }
        input[type="color"] { width: 100px; height: 40px; }
        .status { margin: 20px 0; padding: 10px; background: #f0f0f0; }
    </style>
</head>
<body>
    <div class="control-panel">
        <h1>Raspberry Pi LED Control</h1>
        
        <div class="color-picker">
            <h3>Solid Color</h3>
            <input type="color" id="colorPicker" value="#ffffff">
            <button onclick="setColor()">Set Color</button>
        </div>
        
        <div class="effect-buttons">
            <h3>Effects</h3>
            <button onclick="setEffect('solid')">Solid</button>
            <button onclick="setEffect('rainbow')">Rainbow</button>
        </div>
        
        <div class="status" id="status">
            <h3>Status</h3>
            <p>Effect: <span id="currentEffect">solid</span></p>
            <p>Color: <span id="currentColor">#ffffff</span></p>
        </div>
    </div>

    <script>
        function setColor() {
            const color = document.getElementById('colorPicker').value;
            const r = parseInt(color.substr(1,2), 16);
            const g = parseInt(color.substr(3,2), 16);
            const b = parseInt(color.substr(5,2), 16);
            
            fetch('/api/set_color', {
                method: 'POST',
                headers: {'Content-Type': 'application/json'},
                body: JSON.stringify({r: r, g: g, b: b})
            });
        }
        
        function setEffect(effect) {
            fetch('/api/set_effect', {
                method: 'POST',
                headers: {'Content-Type': 'application/json'},
                body: JSON.stringify({effect: effect})
            });
        }
        
        function updateStatus() {
            fetch('/api/status')
                .then(response => response.json())
                .then(data => {
                    document.getElementById('currentEffect').textContent = data.effect;
                    const color = data.color;
                    const hexColor = '#' + color.map(c => c.toString(16).padStart(2, '0')).join('');
                    document.getElementById('currentColor').textContent = hexColor;
                });
        }
        
        // Update status every 2 seconds
        setInterval(updateStatus, 2000);
        updateStatus(); // Initial update
    </script>
</body>
</html>

import paho.mqtt.client as mqtt
import board
import neopixel
import json
import time

# MQTT configuration
MQTT_BROKER = "localhost"  # Change to your MQTT broker
MQTT_PORT = 1883
MQTT_TOPIC = "home/livingroom/leds"

# LED configuration
LED_COUNT = 30
LED_PIN = board.D18
pixels = neopixel.NeoPixel(LED_COUNT, LED_COUNT, brightness=0.5)

# MQTT callbacks
def on_connect(client, userdata, flags, rc):
    print(f"Connected to MQTT broker with result code {rc}")
    client.subscribe(MQTT_TOPIC)

def on_message(client, userdata, msg):
    """Handle MQTT messages"""
    try:
        payload = json.loads(msg.payload.decode())
        command = payload.get('command', 'solid')
        
        if command == 'solid':
            color = payload.get('color', [255, 255, 255])
            pixels.fill(tuple(color))
            pixels.show()
        elif command == 'off':
            pixels.fill((0, 0, 0))
            pixels.show()
        elif command == 'brightness':
            brightness = payload.get('value', 0.5)
            pixels.brightness = brightness
            pixels.show()
            
    except Exception as e:
        print(f"Error processing message: {e}")

# Setup MQTT client
client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message

# Connect and start
client.connect(MQTT_BROKER, MQTT_PORT, 60)
client.loop_start()

print("MQTT LED controller started...")
try:
    while True:
        time.sleep(1)
except KeyboardInterrupt:
    client.loop_stop()
    pixels.fill((0, 0, 0))
    print("LED controller stopped")

# Use generators for large sequences
def color_generator():
    """Generate colors efficiently"""
    colors = [(255, 0, 0), (0, 255, 0), (0, 0, 255)]
    while True:
        for color in colors:
            yield color

# Use numpy for array operations
import numpy as np
led_array = np.zeros((LED_COUNT, 3), dtype=np.uint8)

import psutil
import time

def monitor_resources():
    """Monitor system resources"""
    cpu_percent = psutil.cpu_percent()
    memory_percent = psutil.virtual_memory().percent
    
    if cpu_percent > 80:
        print("High CPU usage detected")
    if memory_percent > 80:
        print("High memory usage detected")

from flask import Flask
from werkzeug.middleware.proxy_fix import ProxyFix

app = Flask(__name__)
app.wsgi_app = ProxyFix(app.wsgi_app)

# Enable gzip compression
from flask_compress import Compress
Compress(app)

# Cache static content
@app.after_request
def add_header(response):
    response.headers['Cache-Control'] = 'public, max-age=300'
    return response

# Add user to gpio group
sudo usermod -a -G gpio $USER

# Reboot to apply changes
sudo reboot

# Clean installation
sudo pip3 uninstall rpi_ws281x adafruit-circuitpython-neopixel
sudo pip3 install --no-cache-dir rpi_ws281x adafruit-circuitpython-neopixel

import cv2
import numpy as np

def camera_led_control():
    """Control LEDs based on camera input"""
    cap = cv2.VideoCapture(0)
    
    while True:
        ret, frame = cap.read()
        if not ret:
            break
            
        # Process frame
        avg_color = np.mean(frame, axis=(0, 1))
        
        # Map to LED colors
        led_color = (int(avg_color[2]), int(avg_color[1]), int(avg_color[0]))
        pixels.fill(led_color)
        pixels.show()
        
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    
    cap.release()

import tensorflow as tf
import numpy as np

# Load TensorFlow Lite model
interpreter = tf.lite.Interpreter(model_path="led_model.tflite")
interpreter.allocate_tensors()

def ml_led_control(input_data):
    """Use ML model for LED control"""
    input_details = interpreter.get_input_details()
    output_details = interpreter.get_output_details()
    
    # Set input tensor
    interpreter.set_tensor(input_details[0]['index'], input_data)
    interpreter.invoke()
    
    # Get output
    output_data = interpreter.get_tensor(output_details[0]['index'])
    return output_data