DIY Ambilight System for TV with WS2812B LEDs

[Power Supply] --> [Capacitor] --> [ESP32 5V]
                              |
                              V
                        [Ground]
                              |
[ESP32 Data Pin (GPIO 23)] --> [WS2812B Strip]
                              |
                              V
                        [Ground] <-- [Power Supply GND]

#include <Adafruit_NeoPixel.h>
#include <ArduinoJson.h>
#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoOTA.h>

#define LED_PIN 23
#define LED_COUNT 300 // 5M strip with 60 LEDs/m
#define BUTTON_PIN 0

Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);

// TV-related variables
const char* ssid = "YourWiFiSSID";
const char* password = "YourWiFiPassword";
const char* server_url = "http://your-server-url.com/get_colors";

// Color smoothing variables
long last_update = 0;
int smooth_factor = 5; // Lower = more responsive, higher = smoother
int current_r = 0, current_g = 0, current_b = 0;
int target_r = 0, target_g = 0, target_b = 0;

void setup() {
  Serial.begin(115200);
  
  // Initialize NeoPixel strip
  strip.begin();
  strip.setBrightness(50); // Adjust brightness as needed
  strip.show();
  
  // Initialize button
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  
  // Setup WiFi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWiFi connected!");
  
  // Setup OTA updates
  ArduinoOTA.setHostname("Ambilight-ESP32");
  ArduinoOTA.setPassword("yourpassword");
  ArduinoOTA.begin();
  
  // Initial display
  setColor(0, 0, 0);
}

void loop() {
  ArduinoOTA.handle();
  
  // Handle button press
  if (digitalRead(BUTTON_PIN) == LOW) {
    delay(50); // Debounce
    setColor(0, 0, 0); // Turn off on button press
    while (digitalRead(BUTTON_PIN) == LOW); // Wait for release
  }
  
  // Capture colors from TV every 50ms
  unsigned long current_time = millis();
  if (current_time - last_update > 50) {
    last_update = current_time;
    captureColorsFromTV();
  }
  
  // Smooth transition
  smoothColors();
  displayColors();
}

void captureColorsFromTV() {
  if (WiFi.status() == WL_CONNECTED) {
    HTTPClient http;
    http.begin(server_url);
    
    int httpCode = http.GET();
    if (httpCode > 0) {
      String payload = http.getString();
      
      // Parse JSON response
      DynamicJsonDocument doc(1024);
      deserializeJson(doc, payload);
      
      target_r = doc["r"] | 0;
      target_g = doc["g"] | 0;
      target_b = doc["b"] | 0;
      
      Serial.printf("Captured - RGB: %d, %d, %d\n", target_r, target_g, target_b);
    }
    
    http.end();
  }
}

void smoothColors() {
  // Smooth transitions for less flickering
  current_r += (target_r - current_r) / smooth_factor;
  current_g += (target_g - current_g) / smooth_factor;
  current_b += (target_b - current_b) / smooth_factor;
}

void setColor(int r, int g, int b) {
  target_r = r;
  target_g = g;
  target_b = b;
}

void displayColors() {
  for (int i = 0; i < LED_COUNT; i++) {
    // Create gradient effect
    int pixel_r = current_r;
    int pixel_g = current_g;
    int pixel_b = current_b;
    
    // Add some variation for more interesting effects
    if (i > 0) {
      pixel_r = constrain(pixel_r + random(-20, 20), 0, 255);
      pixel_g = constrain(pixel_g + random(-20, 20), 0, 255);
      pixel_b = constrain(pixel_b + random(-20, 20), 0, 255);
    }
    
    strip.setPixelColor(i, strip.Color(pixel_r, pixel_g, pixel_b));
  }
  
  strip.show();
}

import cv2
import numpy as np
import json
from http.server import BaseHTTPRequestHandler
from socketserver import HTTPServer
import threading

class ColorCaptureServer(BaseHTTPRequestHandler):
    def do_GET(self):
        # Capture frame from webcam
        ret, frame = cap.read()
        
        if ret:
            # Convert to HSV for better color detection
            hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
            
            # Define range for white/gray
            lower_white = np.array([0, 0, 200])
            upper_white = np.array([180, 30, 255])
            mask = cv2.inRange(hsv, lower_white, upper_white)
            
            # Find largest white area (assumed to be TV screen)
            contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
            largest_contour = max(contours, key=cv2.contourArea)
            
            # Get average color in the largest white area
            x, y, w, h = cv2.boundingRect(largest_contour)
            tv_region = frame[y:y+h, x:x+w]
            avg_color = np.mean(tv_region, axis=(0, 1))
            
            # Convert RGB to 0-255 range
            rgb = [int(avg_color[2]), int(avg_color[1]), int(avg_color[0])]
            
            # Send response
            self.send_response(200)
            self.send_header('Content-type', 'application/json')
            self.end_headers()
            response = json.dumps({"r": rgb[0], "g": rgb[1], "b": rgb[2]})
            self.wfile.write(response.encode())
        else:
            self.send_response(400)
            self.end_headers()

def run_server():
    server = HTTPServer(('0.0.0.0', 8080), ColorCaptureServer)
    print("Server running on port 8080...")
    server.serve_forever()

# Initialize webcam
cap = cv2.VideoCapture(0)
if not cap.isOpened():
    print("Error: Could not open webcam")
    exit()

# Run server in separate thread
threading.Thread(target=run_server).start()

# Keep main thread alive
try:
    while True:
        pass
except KeyboardInterrupt:
    cap.release()
    cv2.destroyAllWindows()

void musicVisualizer() {
  for (int i = 0; i < LED_COUNT; i++) {
    int pixel = (i * 100) % 100;
    int brightness = abs(pixel - musicData) % 100;
    strip.setPixelColor(i, strip.Color(brightness, brightness/2, brightness/4));
  }
}

void breathingEffect(int r, int g, int b) {
  static int phase = 0;
  phase += 2;
  
  if (phase > 180) phase = 0;
  
  int intensity = map(phase, 0, 180, 0, 255);
  strip.setPixelColor(0, strip.Color(r*intensity/255, g*intensity/255, b*intensity/255));
}

void applyMovieNightPalette() {
  setColor(80, 60, 100);
}

void applyGamingPalette() {
  setColor(120, 60, 180);
}

void applyRelaxingPalette() {
  setColor(100, 150, 1