# Christmas Lights Tutorials — Practical Step-by-Step Guides *Australian context — 240V mains, summer Christmas, prices in AUD* *Companion to: [report.md](report.md) | Shopping lists: [shopping-lists.md](shopping-lists.md)* --- ## Table of Contents 1. [Tutorial 1: Your First WLED Display (Weekend Project)](#tutorial-1-your-first-wled-display-weekend-project) 2. [Tutorial 2: Your First xLights Roofline](#tutorial-2-your-first-xlights-roofline) 3. [Tutorial 3: Building a Mega Tree](#tutorial-3-building-a-mega-tree) 4. [Tutorial 4: Adding Music Sync](#tutorial-4-adding-music-sync) 5. [Tutorial 5: Power Planning & Safety](#tutorial-5-power-planning--safety) 6. [Tutorial 6: Network & Controller Setup Deep Dive](#tutorial-6-network--controller-setup-deep-dive) --- ## Tutorial 1: Your First WLED Display (Weekend Project) **Difficulty:** ⭐ Beginner | **Time:** 2–4 hours | **Cost:** ~$150–250 AUD ### What You'll Build A string of 100 individually-controllable RGB pixels running off an ESP32 with WLED firmware. You'll control them from your phone, and they'll work standalone — no computer needed after setup. This is the cheapest possible entry point into addressable Christmas lights. ### Parts List | Item | Qty | AUD Price | Where to Buy | |------|-----|-----------|--------------| | ESP32 DevKit V1 (30-pin, CP2102 USB) | 1 | $12–18 | AliExpress / Core Electronics (coreelectronics.com.au) | | WS2811 12V Bullet Pixels, 100ct string, 10cm spacing, xConnect or Ray Wu connector | 1 | $15–25 | Ray Wu AliExpress store (store 701799) / Hanson Electronics | | Mean Well LRS-350-12 (12V 29A 350W PSU) | 1 | $65–80 | Hanson Electronics / RS Components / eBay AU | | 3-core 18AWG silicone wire (red/black/green), 3m | 1 | $8 | Jaycar / AliExpress | | 330Ω resistor (1/4W, through-hole) | 1 | $0.50 | Jaycar / any electronics store | | 1000µF 25V electrolytic capacitor | 1 | $1 | Jaycar / any electronics store | | SN74HCT125N level shifter (DIP-14) | 1 | $3 | Core Electronics / Mouser AU | | Dupont jumper wires (male-to-male, 10-pack) | 1 | $3 | AliExpress / Core Electronics | | IEC C14 power inlet with fuse holder + 10A fuse | 1 | $8 | Jaycar / eBay AU | | IP65 junction box (~200×120×75mm) | 1 | $12 | Bunnings / Jaycar | | Cable glands (PG9, 3-pack) | 1 | $5 | Bunnings / Jaycar | | Standard IEC kettle lead (240V, AU plug) | 1 | $8 | Bunnings / Jaycar / Officeworks | | USB Micro cable (for flashing ESP32) | 1 | Own | — | **Total: ~$150–200 AUD** > 💡 **Budget tip:** A 350W PSU is overkill for 100 pixels (~72W max). You can use a Mean Well LRS-100-12 (~$35) instead, but the 350W gives you room to grow to 400+ pixels later. ### Step 1: Flash WLED onto the ESP32 Do this FIRST, before wiring anything. The ESP32 connects to your computer alone. 1. Open Chrome or Edge (not Firefox — it doesn't support Web Serial) 2. Go to **https://install.wled.me 3. Plug in your ESP32 via USB Micro cable 4. Click **"Install"** → Select the serial port that appears (usually `CP2102`) 5. Check **"Erase device"** on first flash → Click **"Install"** 6. Wait ~60 seconds for the flash to complete 7. Click **"Next"** → **"Configure Wi-Fi"** 8. Enter your home WiFi SSID and password → Click **"Connect"** 9. WLED will connect to your WiFi and show its IP address 10. Open that IP address in any browser — you should see the WLED web interface **✅ Test it:** You should see the WLED colour wheel UI. The ESP32's onboard LED may blink. No pixels are connected yet — that's fine. > 📺 **Watch:** "WLED for Beginners" — https://www.youtube.com/watch?v=tXvtxwK3jRk ### Step 2: Wire It Up Here's what connects where. The ESP32 runs on 5V (via USB or the VIN pin), but the WS2811 pixels run on 12V. The data signal needs a level shifter to go from 3.3V (ESP32) to 5V (what WS2811 expects). #### Wiring Diagram ``` ┌──────────────────────────────────────────────┐ │ MEAN WELL LRS-350-12 │ 240V AC IN ────────▶│ L N ⏚ │ │ V+ V+ V- V- │ (IEC inlet │ (AC side) │ │ (DC 12V side) │ with 10A fuse) └────────────┘ └──┬───┬───┬───┬────┘ │ │ │ │ 12V+ │ │ │ │ GND │ │ │ │ ┌────────────────────────────┐│ │ │ │ │ ││ │ │ │ │ 1000µF CAP (+ to 12V) ──┘│ │ │ │ (across V+ and V-) │ │ │ │ ───┘ │ │ │ │ │ ┌───────────┼─────────────────────────────────┘ │ │ │ │ 12V+ │ GND │ │ GND │ │ │ │ ┌──────┴──────┐ │ │ │ ESP32 │ │ │ │ DevKit │ │ │ │ │ │ │ │ VIN ◄──────┼── 12V+ (Can power ESP32 │ │ │ │ via VIN if 5-12V, │ │ │ │ OR just use USB power) │ │ │ GND ◄──────┼──────────────────────────────┘ │ │ │ (common ground) │ │ GPIO16 ────┼──► 330Ω resistor ──┐ │ │ (or GPIO2) │ │ │ └─────────────┘ │ │ │ │ ┌──────────────┐ │ │ │ SN74HCT125N │ │ │ │ Level Shifter│ │ │ │ │ │ │ │ VCC ◄───────┼── 5V (from ESP32 3V3 or USB 5V) │ │ GND ◄───────┼── GND (common) │ │ 1OE ◄───────┼── GND (enable) │ │ 1A ◄───────┼── from 330Ω resistor above │ │ 1Y ────────┼──────────────────────────┐ │ └──────────────┘ │ │ │ DATA │ │ │ ┌─────────────────────────────────────────┐│ │ │ WS2811 PIXEL STRING (100 pixels) ││ │ │ ││ │ │ 12V+ (Red wire) ◄──────────────────────┘│ ◄── 12V+ │ │ GND (Blue wire) ◄──────────────────────┘ ◄── GND │ │ DATA (Green/Yellow wire) ◄──────────────── DATA from 1Y │ │ │ │ │ Pixel 1 ── Pixel 2 ── ... ── Pixel 100 │ │ └─────────────────────────────────────────┘ │ └── 12V+ to pixel string Red wire ``` #### Simplified Version (Works for ≤100 Pixels) For a quick test with just 100 12V pixels, you can skip the level shifter. Many people run the data line directly from the ESP32 GPIO through a 330Ω resistor to the pixel data input. It works at short distances because 12V WS2811 pixels are tolerant of 3.3V data signals (the threshold is ~0.7×VDD for high = ~3.5V on 5V logic, and 12V WS2811 has an internal 5V regulator for logic). **Simplified wiring (no level shifter):** ``` ESP32 WS2811 String (100px) ┌──────────┐ ┌───────────────────┐ │ GPIO16 ──┼── 330Ω ──────────▶│ DATA (green wire) │ │ GND ─────┼──────────────────▶│ GND (blue wire) │◄── PSU V- │ VIN ─────┼── (optional) ◄───▶│ 12V+ (red wire) │◄── PSU V+ └──────────┘ └───────────────────┘ 1000µF capacitor across PSU V+ and V- (right at the PSU terminals) ``` > ⚠️ **Critical:** The GND of the ESP32 MUST connect to the GND of the 12V power supply. This is the #1 mistake beginners make. Without a common ground, data won't work. ### Step 3: Wiring — Physical Steps 1. **Mount the PSU in the junction box** using its mounting holes or double-sided tape 2. **Wire the IEC inlet** to the PSU's AC terminals (L, N, Earth). If you're not confident with 240V wiring, get an electrician to do this part — it's a 15-minute job 3. **Connect the 1000µF capacitor** across V+ and V- on the PSU's DC terminals (observe polarity — the stripe side is negative) 4. **Run two wires** from the PSU's DC terminals out through a cable gland: - Red wire → 12V+ → pixel string red wire - Black wire → GND → pixel string blue wire AND ESP32 GND 5. **Connect the data line**: ESP32 GPIO16 → 330Ω resistor → pixel string green/yellow data wire 6. **Power the ESP32**: Either via USB (easiest for testing) or connect the 12V+ to the VIN pin (the ESP32's onboard regulator handles 12V→3.3V) ### Step 4: Configure WLED 1. Open the WLED web UI in your browser (use the IP from Step 1) 2. Go to **⚙️ Config** → **LED Preferences** 3. Set: - **LED Type:** WS281x - **Colour Order:** GRB (most common — if colours are wrong, try RGB, BRG etc.) - **GPIO:** 16 (or whatever pin you used) - **Length:** 100 - **Max Current:** 4000 mA (this is a safety limit — 100 pixels × 55mA = 5500mA at full white, but the limit prevents accidental overcurrent) 4. Click **Save** → The pixels should light up! 5. Install the **WLED app** on your phone: - iOS: Search "WLED" in App Store - Android: Search "WLED" in Play Store 6. Open the app → it should auto-discover your WLED device 7. Play with effects! Try: **Rainbow**, **Chase**, **Twinkle**, **Fire** **✅ Test it:** All 100 pixels should respond. Try the "Solid" effect with pure red, pure green, pure blue. If the colours are wrong (e.g., you set red but get green), change the Colour Order in LED Preferences. ### Step 5: Weatherproofing for Outdoor Use Australian Christmas = summer heat + afternoon thunderstorms. Weatherproofing is not optional. 1. **Junction box**: Mount the PSU, ESP32, and all connections inside an IP65 junction box 2. **Cable glands**: Use PG9 or PG11 cable glands for every wire entering/leaving the box 3. **Silicone sealant**: Apply around any gaps. Neutral-cure silicone (not acetic/vinegar-smelling — that corrodes electronics) 4. **Conformal coating**: Spray the ESP32 board with conformal coating (Jaycar ~$15) for moisture protection 5. **Mount vertically**: Cable glands pointing DOWN so water can't pool and enter 6. **Pixel strings**: WS2811 bullet pixels with xConnect connectors are already IP68 rated. The weak points are the pigtail connections — wrap with self-amalgamating tape 7. **Shade the box**: Direct sun can cook electronics. Mount under eaves or use a shade 8. **RCD protection**: Your outdoor power MUST be on an RCD-protected circuit (this is mandatory for outdoor power points under Australian Standards AS/NZS 3000) ### Troubleshooting | Problem | Cause | Fix | |---------|-------|-----| | No pixels light up at all | No common ground between ESP32 and PSU | Connect ESP32 GND to PSU V- | | First pixel lights, rest don't | Data pin wrong or no data connection | Check GPIO number in WLED config matches physical wiring | | Random flickering / glitching | Data signal too weak (3.3V vs 5V needed) | Add SN74HCT125 level shifter | | Wrong colours (set red, get green) | Colour order wrong | Change in WLED → Config → LED Preferences → try GRB, RGB, BRG | | First few pixels work, rest are dark | Insufficient power / voltage drop | Check PSU is 12V, check all connections are solid | | Pixels flicker when many are white | PSU can't deliver enough current | Use bigger PSU or reduce brightness in WLED (Config → LED Preferences → Max Current) | | ESP32 won't connect to WiFi | Wrong password or 5GHz network | WLED only works on 2.4GHz WiFi. Double-check password | | Pixels show random colours on power-up | Normal — WLED hasn't loaded yet | Wait 2–3 seconds for ESP32 to boot. This is normal | > 📺 **Watch:** "WLED Complete Setup Guide" — https://www.youtube.com/watch?v=tXvtxwK3jRk > 📺 **Watch:** "12V WS2811 Pixel Wiring" — https://www.youtube.com/watch?v=JE3VQCpFzQE ### Common Mistakes to Avoid 1. **Don't feed 12V into the ESP32's 3.3V pin** — use VIN (which has a regulator) or USB 2. **Don't skip the capacitor** — it prevents voltage spikes that kill the first pixel 3. **Don't run data wires longer than 1–2m** without a level shifter — signal degrades 4. **Don't use the ESP32's onboard 3.3V to power pixels** — it can only supply ~500mA 5. **Don't plug in the USB while 12V is connected to VIN** unless you know your board supports it (most do, but cheap clones may not) --- ## Tutorial 2: Your First xLights Roofline **Difficulty:** ⭐⭐ Intermediate | **Time:** 1–2 weekends | **Cost:** ~$500–900 AUD ### What You'll Build A pixel roofline for a typical Australian house (15–20m total length), controlled by xLights, run from a Raspberry Pi with Falcon Player. This is the classic "first real display" that every Christmas lighter does. ### Parts List (for ~18m roofline) | Item | Qty | AUD Price | Where to Buy | |------|-----|-----------|--------------| | WS2811 12V Bullet Pixels, 100ct string, 10cm spacing, xConnect | 2 | $25–50 ea | Ray Wu AliExpress / Hanson Electronics | | **Controller — Option A:** WLED on ESP32 (budget) | 1 | $15 | See Tutorial 1 | | **Controller — Option B:** Falcon F16V4 (pro) | 1 | $380–420 | aus.pixelcontroller.com / Hanson Electronics | | Mean Well LRS-350-12 (12V 29A) | 1 | $65–80 | Hanson Electronics / RS Components | | Raspberry Pi 4 (2GB+) with SD card (for FPP) | 1 | $90–130 | Core Electronics / PiAustralia | | Pixel mounting clips (bag of 100) | 2 | $8–12 ea | Hanson Electronics / AliExpress | | 3-core 18AWG extension cables, xConnect, 3m | 3 | $5–8 ea | Ray Wu / Hanson | | xConnect T-splitter (power injection) | 2 | $5–8 ea | Ray Wu / Hanson | | IP65 enclosure (~300×200×150mm) | 1 | $20 | Bunnings / Jaycar | | Cable glands PG9/PG11 (5-pack) | 1 | $8 | Bunnings | | Cat6 Ethernet cable (5m) | 1 | $8 | Bunnings / Officeworks | | IEC inlet + fuse holder | 1 | $8 | Jaycar | | 18AWG 3-core cable (10m) | 1 | $15 | Jaycar | | Self-amalgamating tape | 1 | $12 | Bunnings | | Cable ties (bag of 100) | 1 | $5 | Bunnings | **Total: ~$500 (WLED path) / ~$850 (Falcon path)** ### Choosing Your Controller Path | Feature | WLED on ESP32 (~$15) | Falcon F16V4 (~$400) | |---------|---------------------|---------------------| | Max pixels per output | ~800 | ~1000 per port, 16+ ports | | Outputs | 1–4 (ESP32 GPIOs) | 16 (expandable to 48) | | Protocol | DDP / E1.31 over WiFi | E1.31 / DDP / ArtNet over Ethernet | | Reliability | Good (WiFi can drop) | Rock solid (wired Ethernet) | | Setup difficulty | Easy | Medium | | Future expansion | Limited | Unlimited — add props for years | | Best for | ≤500 pixels, single prop | 500+ pixels, multiple props, music sync | **Recommendation:** Start with WLED if this is your only prop. Go Falcon if you plan to expand next year. ### Step 1: Measure Your Roofline Go outside with a tape measure and a notepad. Australian houses typically have: ``` Roofline Layout — Typical Australian House (Top View) ◄──── 6m ────► ┌────────────────────────┐ / \ / ◄── 3m rake ──► \ ◄── 3m rake / \ / \ ┌──────────────────────────────────┐ │ FRONT OF HOUSE │ │◄────────── 8m fascia ───────────►│ └──────────────────────────────────┘ Total: 3m (left rake) + 6m (ridge) + 3m (right rake) + 8m (fascia) = 20m total At 10cm pixel spacing: 200 pixels = 2 × 100ct strings ``` **Measure:** 1. Left rake (sloped edge, gutter to peak) 2. Ridge line (peak, left to right) 3. Right rake (peak down to gutter) 4. Fascia / gutterline (straight along the front) 5. Any returns or garage sections Write down each segment length. You'll need these for xLights model setup. ### Step 2: Physical Installation #### Mounting Clips Use **pixel mounting clips** (C7/C9 clips or universal pixel clips). They screw or clip onto the fascia board, gutter lip, or roof edge. ``` Cross-section of gutter/fascia mounting: ┌─── Roof ─────────────── │ ├─── Fascia board │ ┌─────┐ │ │CLIP │ ◄── Screws into fascia, or clips onto gutter lip │ │ ● │ ◄── Pixel sits in clip │ └─────┘ │ └─── Gutter ``` #### Installation Steps 1. **Start from the controller location** (usually near an outdoor power point, under eaves or in garage) 2. **Run the first extension cable** from controller to the start of your roofline 3. **Connect the first pixel string** (note: data flows in ONE direction — look for the arrow on the string or the "DI" / "DATA IN" label) 4. **Clip each pixel** into a mounting clip, spaced evenly along the fascia/gutter 5. **At the end of string 1** (~10m / 100 pixels), connect string 2 6. **At the junction between strings**, add a **power injection T-splitter**: ``` Power Injection Point (every ~5m / 50 pixels): From PSU To next pixel string ──────── xConnect T-Splitter ──────────────────── (Power only — no data) │ 12V+ and GND from PSU via 18AWG extension ``` 7. **Continue clipping** string 2 along the remainder of the roofline 8. **Secure all cables** with cable ties to the gutter or fascia — leave slack at corners for thermal expansion #### Full Roofline Wiring Diagram ``` ┌─────────────────────────────────────────────────────────┐ │ JUNCTION BOX (under eaves / in garage) │ │ │ │ ┌────────┐ ┌──────────┐ ┌────────────────┐ │ │ │ PSU │ │Controller│ │ Raspberry Pi │ │ │ │12V 29A │ │(WLED or │ │ (FPP) │ │ │ │ │ │ Falcon) │ │ │ │ │ └──┬──┬──┘ └────┬─────┘ └───────┬────────┘ │ │ │ │ │ DATA │ Ethernet │ │ V+ │ │GND GPIO│or Port 1 │(to controller) │ └─────┼──┼───────────┼─────────────────┼──────────────────┘ │ │ │ │ │ │ ┌─────┘ │ │ │ │ │ ▼ ▼ ▼ │ ══════════════════════════════════════ │ ║ ROOFLINE — 200 pixels total ║ │ ║ ║ │ ║ EXT──►PX1──PX2──...──PX50──┐ ║ │ ║ String 1 │ ║ │ ║ INJECT◄──┤ ║ │ ║ (T-split)│ ║ │ ║ │ ║ │ ║ PX51──PX52──...──PX100 ║ │ ║ │ String 1 cont. ║ │ ║ INJECT◄──┤ ║ │ ║ │ ║ │ ║ PX101──PX102──...──PX150 ║ │ ║ String 2 ║ │ ║ INJECT◄──┤ ║ │ ║ │ ║ │ ║ PX151──...──PX200 (end) ║ │ ║ String 2 cont. ║ │ ══════════════════════════════════════ │ │ Power injection runs (18AWG from PSU): │ Run 1: PSU → pixel 1 (via extension) │ Run 2: PSU → T-split at pixel 50 │ Run 3: PSU → T-split at pixel 100 │ Run 4: PSU → T-split at pixel 150 │ ``` > 💡 **Rule of thumb:** Inject power every 50 pixels (5m) for 12V WS2811. You can push to 100 pixels if you're not running full white, but 50 is safe. ### Step 3: Controller Setup #### Option A: WLED Follow Tutorial 1 for flashing and basic setup. Additional config for xLights integration: 1. In WLED Config → **Sync Interfaces**: - Enable **E1.31 (sACN)**: ✅ - Start Universe: **1** - OR enable **DDP**: ✅ (simpler — no universe management) 2. Note the IP address of the ESP32 #### Option B: Falcon F16V4 1. Connect the F16V4 to your network via Ethernet 2. Find its IP address (it displays on the OLED screen, or check your router's DHCP leases) 3. Open the web interface in a browser: `http://` 4. Go to **Network** → Set a static IP (e.g., 192.168.1.50) 5. Go to **Output Settings** → **Pixel**: - Port 1: Pixel Count = 200 (or however many you have) - Pixel Type: WS2811 6. Don't worry about universe configuration — let xLights handle it (see below) ### Step 4: xLights Setup 1. **Download xLights** from https://xlights.org — install the latest version 2. **Create a Show Directory**: e.g., `Documents/xLights/2026Show/` 3. **Controllers Tab**: - Click **"Add Controller"** - For WLED: Protocol = DDP, IP = your WLED IP - For Falcon: Protocol = DDP, IP = your Falcon IP, Vendor = Falcon, Model = F16V4 - Check **"Auto Layout Models"**, **"Auto Size"**, **"Full xLights Control"** - Click **Save** 4. **Layout Tab** — Create your roofline model: - Take a photo of your house front-on with your phone - In Layout tab → click the three dots next to "Background Image" → select your photo - Lower the brightness to ~30% - Click the **Poly Line** model icon (looks like a zigzag line) - Click to trace your roofline over the photo: click at each corner/bend, press **ESC** when done - In the model properties (left panel): - Name: `Roofline` - Nodes: 200 - Individual Segments: ✅ (then set each segment's pixel count proportionally) - Click **Save** 5. **Assign the model to a controller port**: - Go to **Controllers** tab → click your controller → click **Visualizer** - Drag `Roofline` to Port 1 - Click **Save** → **Upload Output** (sends config to controller) 6. **Create your first sequence**: - Go to **Sequencer** tab → **New Sequence** → **Animation** → **Quick Start** - Right-click the timing area → **Edit Display Elements** → add `Roofline` - Drag effects from the top bar onto the Roofline timeline: - Try: **Color Wash**, **Marquee**, **Twinkle**, **Shimmer** - Click **Render All** (the gear icon) → **Play** ▶️ - The preview window should show your effect on the roofline outline - Click **Save** **✅ Test it:** In xLights, go to **Tools** → **Test** → Select your controller → Click pixels on/off to verify each one responds and is in the right position. ### Step 5: Set Up FPP on Raspberry Pi 1. Download FPP from https://github.com/FalconChristmas/fpp/releases 2. Flash to SD card using Raspberry Pi Imager 3. Boot the Pi → connect via Ethernet to same network as controller 4. Open `http://fpp.local` in browser 5. Configure: - **Network**: Set static IP or use DHCP - **Channel Outputs**: Add E1.31 or DDP bridge output → point to controller IP 6. In xLights: **Tools** → **FPP Connect**: - Add your FPP instance → Upload sequences and configuration 7. In FPP web UI: **Scheduler** → set playlist to run at sunset **✅ Test it:** Schedule a sequence to play in 2 minutes. Walk outside and verify the roofline runs the sequence. ### Common Mistakes 1. **Pixel direction**: Data flows ONE way. If you wire backwards, nothing works. Look for arrows on the pixel string 2. **Not enough power injection**: Pixels at the far end look dim or wrong colour → add injection points 3. **WiFi vs Ethernet**: For WLED, WiFi is fine for ≤200 pixels. For Falcon and larger shows, always use Ethernet 4. **xLights version mismatch**: Always use the same xLights version as your FPP version expects. Update both together 5. **Testing during the day**: You can't see pixels in sunlight. Test at night or in the garage with lights off > 📺 **Watch:** "xLights Beginner Tutorial" — https://www.youtube.com/watch?v=K6IHEKnr0hU > 📺 **Watch:** "How to set up FPP" — https://www.youtube.com/watch?v=YWl1ouVnJHg --- ## Tutorial 3: Building a Mega Tree **Difficulty:** ⭐⭐⭐ Intermediate-Advanced | **Time:** 2–3 weekends | **Cost:** ~$600–1500 AUD ### What Is a Mega Tree? A mega tree is a cone-shaped "tree" made from strands of pixel lights radiating from a central pole. From the front, it looks like a Christmas tree. It's the centrepiece of most pixel light displays. ``` Mega Tree — How It Works (Side View) ★ ◄── Star/topper (separate pixel prop, optional) /|\ / | \ / | \ / | \ ◄── Pixel strands hang from hub at top / | \ to anchor ring at bottom / | \ / | \ / | \ ◄── Each strand is a string of pixels / | \ (e.g., 50 pixels per strand) / | \ / 3m POLE \ / (steel or ali) \ /____________|____________\ │ Ground anchor (star picket + base plate or sleeve) Top View (looking down): N │ ╱ ╱ │ ╲ ╲ ╱ ╱ │ ╲ ╲ W──────── ★ ────────E ← 16 or 32 strands radiate ╲ ╲ │ ╱ ╱ from centre to anchor ring ╲ ╲ │ ╱ ╱ (~1.5–2m diameter) │ S ``` ### Parts List (3m, 16-strand tree) | Item | Qty | AUD Price | Where to Buy | |------|-----|-----------|--------------| | WS2811 12V Bullet Pixels, 50ct string, 10cm spacing, xConnect | 16 | $15–25 ea | Ray Wu AliExpress / Hanson | | Mega tree hub/topper (for 16 strands, with bearing) | 1 | $40–80 | Boscoyo Studio / Hanson / AliExpress | | Steel pole, 3m × 40mm OD (fence post works) | 1 | $30–50 | Bunnings | | Ground sleeve or star picket + pole mount | 1 | $15–30 | Bunnings | | Anchor ring (hula hoop, PVC ring, or purpose-built) | 1 | $15–30 | Bunnings (PVC pipe bent into ring) / AliExpress | | Guy wire kit (if >3m pole) | 1 | $20 | Bunnings | | Controller (Falcon F16V4 or HE123 Mk2) | 1 | $120–420 | Hanson / aus.pixelcontroller.com | | Mean Well LRS-350-12 | 1 | $65–80 | Hanson / RS Components | | xConnect pigtails (controller to pixel string) | 16 | $2–3 ea | Ray Wu / Hanson | | Power injection T-splitters | 4 | $5–8 ea | Ray Wu / Hanson | | 18AWG 3-core wire (for power injection runs) | 20m | $20 | Jaycar | | Pixel mounting strip (optional, for even spacing at base) | 5m | $12 | Hanson | | Ground stakes / tent pegs for anchor ring | 8 | $10 | Bunnings | **Total: ~$700–1200 AUD** (depending on controller choice) ### Step 1: Pole and Base Setup 1. **Set the ground sleeve**: Drive a star picket into the ground, or embed a 50mm PVC sleeve in a bucket of concrete (pour 2 weeks before Christmas to cure) 2. **Prepare the pole**: A 3m galvanised steel fence post (40mm OD) from Bunnings works well. Slide it into the sleeve 3. **Attach the hub/topper**: The hub sits at the top of the pole. It has 16 (or 32) holes or hooks where the pixel strands attach. Many hubs have a bearing so the strands don't twist 4. **Set up the anchor ring**: At the base, create a ring ~1.5m radius from the pole. A 3m diameter circle. Use a hula hoop, bent PVC pipe, or rope pegged to the ground ### Step 2: Wiring Each strand is one 50-count pixel string. All 16 strings start at the bottom (near the controller), go UP to the hub, and the last pixel hangs near the top. **Or, for "zig-zag" wiring**: Each string goes UP one strand and comes DOWN the adjacent strand. This halves the number of controller ports needed (8 ports for 16 strands). ``` Mega Tree Wiring — 16 strands, 8 controller ports (zig-zag) Port 1: String 1 (50px) ─── UP Strand 1 ─── over hub ─── DOWN Strand 2 Port 2: String 2 (50px) ─── UP Strand 3 ─── over hub ─── DOWN Strand 4 Port 3: String 3 (50px) ─── UP Strand 5 ─── over hub ─── DOWN Strand 6 Port 4: String 4 (50px) ─── UP Strand 7 ─── over hub ─── DOWN Strand 8 Port 5: String 5 (50px) ─── UP Strand 9 ─── over hub ─── DOWN Strand 10 Port 6: String 6 (50px) ─── UP Strand 11 ─── over hub ─── DOWN Strand 12 Port 7: String 7 (50px) ─── UP Strand 13 ─── over hub ─── DOWN Strand 14 Port 8: String 8 (50px) ─── UP Strand 15 ─── over hub ─── DOWN Strand 16 Each string = 100 pixels total (50 up + 50 down) Total: 8 × 100 = 800 pixels Power injection: at bottom of each strand (near controller) + at top/hub connection point every 4 strands ``` ``` Wiring Diagram — Bottom of Mega Tree (looking down) PSU (in weatherproof box) ┌──────────┐ │ LRS-350 │ │ 12V 29A │ └──┬───┬───┘ │ │ V+ │ │ V- │ │ CONTROLLER (F16V4 / HE123) ┌──────────────────┐ │ Port 1 ──────────┼──► Strand 1↑ Strand 2↓ │ Port 2 ──────────┼──► Strand 3↑ Strand 4↓ │ Port 3 ──────────┼──► Strand 5↑ Strand 6↓ │ Port 4 ──────────┼──► Strand 7↑ Strand 8↓ │ Port 5 ──────────┼──► Strand 9↑ Strand 10↓ │ Port 6 ──────────┼──► Strand 11↑ Strand 12↓ │ Port 7 ──────────┼──► Strand 13↑ Strand 14↓ │ Port 8 ──────────┼──► Strand 15↑ Strand 16↓ │ Ethernet ◄───────┼──── FPP (Raspberry Pi) └──────────────────┘ Power injection bus (18AWG): PSU V+ ──┬──── Port 1 pigtail ──┬──── Port 3 pigtail ──┬─── ... │ │ │ PSU V- ──┴──── (same pattern) ──┴──── ──────────────────┴─── ... ``` ### Step 3: xLights Mega Tree Model 1. Open xLights → **Layout** tab 2. Click the **Tree** model icon (looks like a Christmas tree) 3. Click and drag on your layout to place the tree 4. In model properties: - **Name:** `MegaTree` - **# Strings:** 8 (if using zig-zag) or 16 (if each strand is separate) - **Nodes per String:** 100 (if zig-zag, 50 up + 50 down) or 50 - **Strands per String:** 2 (for zig-zag) or 1 - **Starting Location:** Bottom Left - **Degrees:** 360 (full tree) or 180 (flat/half tree against a wall) 5. Assign to controller ports via the **Visualizer** 6. **Save** → **Upload Output** to controller **✅ Test it:** In xLights Test mode, turn on Port 1 → verify strand 1 lights bottom-to-top, then strand 2 lights top-to-bottom. Repeat for all ports. ### Step 4: Sequencing Tips for Mega Trees Mega trees look spectacular with these effects: - **Spirals**: Use the "Spirals" effect — set wraps to 2-3, thickness 10-20% - **Fire**: The built-in fire effect looks amazing on a tree shape - **Curtain**: Sweeps across all strands — great for transitions - **Circles**: Radiating rings that expand outward - **Butterfly**: Creates swirling patterns unique to cone shapes - **Pinwheel**: Rotating wedges — classic mega tree effect - **Text/Images**: You can scroll text or display images — the tree acts like a curved screen **Pro tip:** Create a **"Model Group"** containing your mega tree and roofline together, then apply group-level effects that flow across both props. ### Common Mistakes 1. **Strands too short**: Measure the diagonal from base ring to hub, not the pole height. A 3m pole with 1.5m radius ring needs strands of √(3² + 1.5²) ≈ 3.35m 2. **Twisted strands**: Use a hub with a bearing so the pole can spin freely during setup. Number each strand position 3. **Wind damage**: Guy-wire any pole over 2.5m. Australian summer storms are brutal — budget for a 30-minute pack-down procedure for severe weather warnings 4. **Uneven spacing**: Mark the anchor ring with tape every 20cm (for 16 strands at ~1.5m radius: circumference ÷ 16 = ~59cm apart) 5. **Wrong zig-zag config**: If you set zig-zag in the controller AND in xLights, they cancel out and everything's wrong. Set it in xLights only (Strands per String = 2) > 📺 **Watch:** "Beginner's Guide to Building a Mega Tree" — https://www.youtube.com/watch?v=hb6cpS2lg4M > 📺 **Watch:** "How to Build a MEGA TREE" — https://www.youtube.com/watch?v=oKDSyJkaLgw --- ## Tutorial 4: Adding Music Sync **Difficulty:** ⭐⭐⭐ Intermediate | **Time:** 4–8 hours per song | **Cost:** ~$50–150 AUD (additional) ### How Music-Sync Works The flow is: 1. **You** choose a song and import it into xLights 2. **xLights** analyses the audio (beat detection, frequency analysis) and creates timing marks 3. **You** place effects on the timeline aligned to those timing marks 4. **xLights** renders a `.fseq` file containing per-frame pixel data 5. **FPP** plays the audio AND the `.fseq` simultaneously, perfectly synced 6. **Speakers** or an **FM transmitter** output the audio for your audience The music data is NOT sent to the controller in real-time. The sequencer pre-calculates every single frame, and FPP plays it back. This is why it's always perfectly synced. ### Parts List (Additional to Tutorials 1–3) | Item | Qty | AUD Price | Where to Buy | |------|-----|-----------|--------------| | Raspberry Pi 4 (2GB+) with SD card (if not already bought) | 1 | $90–130 | Core Electronics | | USB sound card (for headphone-out to FM transmitter) | 1 | $10 | Amazon AU / AliExpress | | Outdoor speakers (Bluetooth or wired) | 1 pair | $40–80 | JB Hi-Fi / Amazon AU | | **OR** FM transmitter (PLL type, ~0.5W) | 1 | $25–40 | AliExpress / eBay AU | | 3.5mm audio cable (male-male, 1m) | 1 | $5 | JB Hi-Fi / Officeworks | | 3.5mm audio Y-splitter (optional, for speakers + FM) | 1 | $5 | JB Hi-Fi | ### Step 1: Prepare Your Audio 1. **Choose a song**: Start with something with a clear beat — "Wizards in Winter" (TSO), "All I Want for Christmas Is You" (Mariah Carey), or "Carol of the Bells" 2. **Get a high-quality file**: MP3 at 192kbps minimum, or WAV. Don't use YouTube rips 3. **Normalize in Audacity** (free download): - Import the MP3 - Effect → Normalize → set to -1.0dB - File → Export → Export as WAV (44.1kHz, 16-bit) — xLights works best with WAV - Also export as MP3 (Constant Bit Rate, 192kbps) — for FPP playback 4. **Trim silence** from the start and end — even 0.5 seconds of silence at the start throws off your sync ### Step 2: Create a Musical Sequence in xLights 1. **New Sequence** → select **"Musical"** → browse to your WAV file 2. Set **Frame Rate: 40fps** (modern standard — 20fps is also fine for simpler shows) 3. Click **Quick Start** 4. You'll see the audio waveform at the top of the sequencer #### Add Timing Tracks Timing tracks are the backbone of music sync — they mark beats, bars, and phrases so you can snap effects to the music. 1. Right-click the timing area → **Add Timing Track** 2. Select **"Audacity Vamp – QM Bar and Beat Tracker"** (you need the QM Vamp plugins installed — download from the xLights download page) 3. This auto-detects beats and creates timing marks 4. Also add a **"Phrases"** timing track manually — mark the start of each musical phrase (verse, chorus, bridge) #### Place Effects 1. **Add your models** to the sequence (Edit Display Elements → add Roofline, MegaTree, etc.) 2. **Start simple**: For the first verse, drag a "Color Wash" onto the Roofline, snapped to a phrase boundary 3. **Build up**: For the chorus, use more intense effects (Chase, Marquee, Spirals) 4. **Match intensity to music**: Quiet verse = gentle twinkle. Loud chorus = fast chase + bright colours 5. **Use the "On" effect** for drum hits — snap a short white flash to each beat mark #### Key xLights Sequencing Shortcuts | Key | Action | |-----|--------| | **Space** | Play/Pause | | **Ctrl+R** | Render All | | **Ctrl+S** | Save | | **T** | Split effect at cursor | | **Ctrl+C/V** | Copy/Paste effects | | **Shift+Click** | Select multiple effects | ### Step 3: Set Up FPP for Audio Playback 1. In FPP web UI (`http://fpp.local`): - **Content** → **File Manager** → upload your MP3 file - OR use xLights **Tools** → **FPP Connect** to upload everything at once 2. **Audio Output**: - **Status/Control** → **FPP Settings** → Audio Output - Select HDMI, headphone jack, or USB sound card - If using USB sound card: plug it in, it should auto-detect. Select "USB Audio" as output 3. **Create a Playlist**: - **Content** → **Playlists** → **Create New** - Add your sequence + matching audio file - Set to loop or play once 4. **Schedule**: - **Scheduler** → set start time (e.g., 7:30 PM) and end time (e.g., 10:30 PM) - FPP will automatically play your show during those hours ### Step 4: FM Transmitter Setup (for Drive-By Shows) An FM transmitter lets visitors tune their car radio to hear your show. 1. **Connect**: USB sound card → 3.5mm cable → FM transmitter audio input 2. **Power the transmitter**: 5V micro-USB from a phone charger or the Pi's USB port 3. **Set frequency**: Choose an unused FM frequency (e.g., 88.1 or 107.9). Check what's used in your area at https://www.acma.gov.au/ 4. **Attach antenna**: A simple wire antenna (about 75cm of wire) connected to the FM transmitter's antenna terminal 5. **Range**: Low-power FM transmitters (~0.5W) reach about 30–50m — enough for your street 6. **Sign**: Put up a sign in the yard: "Tune to 88.1 FM 📻" > ⚠️ **Legal note (Australia):** Low-power FM transmitters under 1W are legal under ACMA's class licence for low-interference devices. Don't exceed this — high-powered transmitters require a broadcast licence. **Audio routing for FM + local speakers:** ``` Raspberry Pi (FPP) ┌──────────────┐ │ │ │ USB Sound │──► 3.5mm Y-splitter ──┬──► FM Transmitter ──► Car radios │ Card │ │ │ │ └──► Powered Speakers ──► Live audio └──────────────┘ ``` ### Step 5: Fine-Tuning Sync If audio and lights are slightly out of sync: 1. In FPP → **Settings** → **Timing**: adjust the **Offset** value. Positive = delay lights, Negative = advance lights 2. Start with ±50ms and test 3. FM transmitters add ~100–200ms of delay — adjust accordingly if using FM **✅ Test it:** Play your sequence. Stand at the street and watch. Are effects hitting on the beat? Is the FM audio matching the speaker audio? Adjust timing offset as needed. ### Common Mistakes 1. **Using MP3 in xLights**: Always use WAV for sequencing (more precise waveform). Export MP3 for FPP playback 2. **Not installing QM Vamp plugins**: Beat detection won't work without them 3. **Variable bitrate MP3**: FPP can get confused. Always export as **Constant Bit Rate** (CBR) 4. **Too many effects**: Start simple. A well-timed color wash beats a chaotic mess of random effects 5. **Sequencing at 20fps but running at 40fps**: Mismatch causes double-speed playback. Match frame rates > 📺 **Watch:** "xLights Musical Sequence for Beginners" — https://www.youtube.com/watch?v=K6IHEKnr0hU > 📺 **Watch:** "FM Transmitter with FPP" — https://www.youtube.com/watch?v=Aeyesy8UfZ0 --- ## Tutorial 5: Power Planning & Safety **Difficulty:** ⭐⭐ Important for ALL builds | **Time:** 1–2 hours of planning | **Cost:** N/A (planning exercise) ### How to Calculate Your Power Requirements Every pixel display starts with a power budget. Get this wrong and you get dim lights, flickering, or fire. #### The Formula ``` Total Watts = (Number of Pixels) × (Amps per Pixel) × (Voltage) × (Brightness %) For WS2811 12V pixels: - Max current per pixel at full white: 0.055A (55mA) - Voltage: 12V - Power per pixel at full white: 0.055 × 12 = 0.66W ``` #### Worked Examples **Example 1: 200-pixel roofline** ``` Max power = 200 × 0.055A × 12V = 132W At 80% brightness: 132 × 0.8 = 105.6W At 50% brightness: 132 × 0.5 = 66W PSU needed: 132W × 1.2 (20% headroom) = 158W minimum → Mean Well LRS-200-12 (200W) is sufficient → Mean Well LRS-350-12 (350W) gives room to grow ``` **Example 2: 800-pixel mega tree** ``` Max power = 800 × 0.055A × 12V = 528W At 80% brightness: 528 × 0.8 = 422W PSU needed: 528 × 1.2 = 634W minimum → Mean Well LRS-600-12 (600W) at 80% brightness limit → OR two Mean Well LRS-350-12 (700W total) — RECOMMENDED ``` **Example 3: Full display (roofline + mega tree + mini trees + star)** ``` Roofline: 200 pixels = 132W Mega tree: 800 pixels = 528W 2x mini trees: 200 pixels = 132W Star: 50 pixels = 33W ─────────────────────────── Total: 1,250 pixels = 825W max At 70% limit: 578W PSU: 2× LRS-350-12 = 700W ✅ OR: 1× LRS-600-12 + 1× LRS-200-12 = 800W ✅ ``` > 💡 **Reality check:** In actual shows with coloured effects (not full white), you typically draw 30–50% of max. Full white at 100% brightness is the absolute worst case. Most people run at 60–80% brightness and never see full white. But always SIZE for worst case — you don't want a fire because one sequence happens to have 2 seconds of full white. ### Power Supply Sizing Quick Reference | Pixel Count | Max Watts (12V) | Recommended PSU | AUD Price | |-------------|-----------------|-----------------|-----------| | 1–150 | 99W | LRS-100-12 (100W) | $35–45 | | 150–350 | 231W | LRS-200-12 (200W) | $45–55 | | 350–525 | 347W | LRS-350-12 (350W) | $65–80 | | 525–900 | 594W | LRS-600-12 (600W) | $90–110 | | 900+ | — | Multiple PSUs or server PSU | Varies | ### Power Injection Explained **Why:** Pixels are wired in series. Each pixel consumes a tiny bit of voltage. After 50-100 pixels (12V) or 25-50 pixels (5V), the voltage at the far end has dropped so much that pixels are dim and colours shift (white looks pink/yellow). **Solution:** Run additional power wires (V+ and GND) from the PSU directly to points along the pixel string, bypassing the tiny pixel-to-pixel wires. ``` WITHOUT Power Injection: PSU ──V+──► PX1 ── PX2 ── ... ── PX50 ── PX51 ── ... ── PX100 12V 12.0V 11.9V 11.0V 10.5V 9.2V ❌ (dim/wrong colour) WITH Power Injection every 50 pixels: PSU ──V+──► PX1 ── PX2 ── ... ── PX50 ──┬── PX51 ── ... ── PX100 12V 12.0V 11.9V 11.0V │ 12.0V 11.0V ✅ │ PSU ──V+──────────────────────────────────┘ (18AWG wire run directly from PSU to injection point) Power Injection T-Splitter Wiring: ┌─── From PSU (V+, GND) ──── 18AWG wire ────┐ │ │ │ ┌────────────────────┐ │ │ │ T-SPLITTER │ │ │ │ (xConnect type) │ │ │ │ │ │ └───▶│ POWER IN (V+,GND)│ │ │ │ │ ◄────│ DATA THRU ────────│──── to next pixels │ (passes through) │ ────▶│ PIXEL STRING IN │ │ (from previous) │ └────────────────────┘ NOTE: Use "3-3-3 T-splitter" with NO data pin connected on the power injection leg — this prevents stray data signals from injection wires acting as antennas. ``` #### Power Injection Rules of Thumb | Pixel Type | Inject Every | Wire Gauge for Injection Run | |-----------|-------------|------------------------------| | WS2811 12V bullet | 100 pixels (10m) conservative / 50 pixels (5m) safe | 18AWG for <5m, 16AWG for 5-10m | | WS2812B 5V strip | 50 pixels (1.5m at 30/m) | 18AWG for <3m, 16AWG for 3-5m | | WS2815 12V strip | 150 pixels (5m at 30/m) | 18AWG | ### 240V Safety for Australians > ⚠️ **THIS SECTION IS CRITICAL. ELECTRICITY CAN KILL YOU.** #### What You CAN Do Yourself (No Electrician Needed) - ✅ Wire 12V DC from a plug-pack or bench PSU to LED pixels - ✅ Plug in a Mean Well PSU using an existing IEC lead (kettle lead) and a pre-wired IEC inlet - ✅ Use approved outdoor power boards and extension leads - ✅ Wire everything on the 12V DC side (controllers, pixels, data cables) - ✅ Use outdoor-rated weatherproof power points that are already installed #### What You CANNOT Do Yourself (Electrician Required) - ❌ Install new outdoor power points - ❌ Run new 240V circuits from the switchboard - ❌ Hard-wire a Mean Well PSU directly to 240V mains (without an IEC inlet) - ❌ Modify an existing switchboard or add circuit breakers - ❌ Any work on the 240V side of the installation (under AS/NZS 3000 "Wiring Rules") **In Australia, all 240V electrical work must be done by a licensed electrician.** This includes installing new power points. Fines apply. #### Using a Mean Well PSU Safely The recommended approach: use a pre-made IEC inlet with a fuse holder. ``` Safe 240V Connection (No Sparky Needed): Wall power point (240V, must be RCD-protected) │ ┌──────┴──────┐ │ IEC Kettle │ ◄── Standard appliance cord, AU plug │ Lead │ ($8 from Bunnings) └──────┬──────┘ │ ┌──────┴──────┐ │ IEC C14 │ ◄── Panel-mount IEC inlet with built-in │ Inlet + │ fuse holder. Install in junction box │ Fuse Holder │ with 10A fuse │ (10A fuse) │ └──────┬──────┘ │ ┌──────┴──────┐ │ Mean Well │ ◄── L, N, Earth terminals on PSU │ LRS-350-12 │ Wire from IEC inlet to PSU terminals │ │ (this is 240V wiring in an enclosed │ 12V DC out │──► box — legal as it's "appliance └─────────────┘ construction" not "installation work") ``` > 💡 **The legal grey area:** Wiring an IEC inlet to a PSU inside a sealed enclosure is generally considered "assembling an appliance" rather than "electrical installation work." Most Christmas lighters do this. However, if you're uncomfortable, get an electrician to wire the 240V side for you (~$50-80 callout). The 12V side is all you. ### Fuse and Circuit Protection **Why fuses matter:** If a pixel string shorts (water ingress, damaged wire), without a fuse the PSU will push maximum current through the fault. With a 29A PSU, that's 348W of heat through a thin wire — fire risk. #### Fusing Strategy ``` PSU V+ ──┬── 5A fuse ── Port 1 (Roofline, 200px, max 11A) │ wait — 11A through 5A fuse? That's the idea. │ Each PORT is fused, not each PIXEL. │ 200 pixels max = 11A, but real-world = 4-6A │ Size fuse for wire capacity, not pixel max. │ ├── 5A fuse ── Port 2 (Mega tree strings 1-4) │ ├── 5A fuse ── Port 3 (Mega tree strings 5-8) │ └── 5A fuse ── Port 4 (Mini trees + star) ``` - Fuse each output run based on the wire gauge: - 18AWG: 5A fuse (max safe continuous current ~7A) - 16AWG: 7.5A fuse (max safe continuous current ~10A) - 14AWG: 10A fuse (max safe continuous current ~15A) - **Blade fuses** in inline holders work great. Get them from Jaycar or Supercheap Auto ### Grounding and RCD Requirements Under Australian Standards (AS/NZS 3000): - All outdoor power points MUST be protected by a **30mA RCD (safety switch)** — this has been mandatory since 1991 - If your outdoor power points aren't RCD-protected, get an electrician to install one (~$150-250) - Alternatively, use a **portable RCD** (plug-in type, ~$30-50 from Bunnings) between the wall socket and your display - Mean Well LRS-series PSUs have a ground/earth terminal — **connect it** to the earth conductor in your IEC lead. This ensures the metal case is earthed **✅ Test it:** Press the "Test" button on your RCD before each Christmas season. If it doesn't trip, get it replaced. ### Common Mistakes 1. **Using indoor extension leads outdoors**: Use only outdoor-rated (heavy duty) extension leads rated for the load 2. **Daisy-chaining power boards**: Creates fire risk. Run dedicated leads from different power points 3. **No fuses on DC side**: A short circuit on unfused 12V DC can cause fire. Always fuse 4. **Undersized wire for injection runs**: Use at least 18AWG for any run carrying more than 2A 5. **Assuming the PSU limits current**: Mean Well PSUs will deliver full rated current into a short. That's their job. YOUR fuses are the safety net. --- ## Tutorial 6: Network & Controller Setup Deep Dive **Difficulty:** ⭐⭐⭐ Intermediate | **Time:** 2–4 hours | **Cost:** ~$30–80 AUD (switch + cables) ### Protocols Explained Simply Your sequencing software (xLights) talks to your pixel controllers over your network. There are three main protocols: #### E1.31 (sACN) — Streaming Architecture for Control Networks - **What it is:** An entertainment industry standard for sending lighting data over Ethernet - **How it works:** Data is organised into **"universes"** of 512 channels each - **Each RGB pixel = 3 channels** (Red, Green, Blue) - So one universe holds **170 pixels** (170 × 3 = 510 channels, with 2 spare) - Supports **multicast** (one packet goes to all controllers) or **unicast** (targeted to one controller) - **Best for:** Multiple controllers, complex setups, industry-standard compatibility ``` E1.31 Universe/Channel Mapping: Universe 1 (512 channels): ┌─────────────────────────────────────────────────────┐ │ CH1 CH2 CH3 │ CH4 CH5 CH6 │ ... │ CH508 509 510│ 511 512 │ R G B │ R G B │ │ R G B │ (spare) │ Pixel 1 │ Pixel 2 │ │ Pixel 170 │ └─────────────────────────────────────────────────────┘ Universe 2 (512 channels): ┌─────────────────────────────────────────────────────┐ │ CH1 CH2 CH3 │ CH4 CH5 CH6 │ ... │ │ │ R G B │ R G B │ │ │ │ Pixel 171 │ Pixel 172 │ │ Pixel 340 │ └─────────────────────────────────────────────────────┘ 200-pixel roofline needs: ceil(200/170) = 2 universes 800-pixel mega tree needs: ceil(800/170) = 5 universes 1250-pixel full display: ceil(1250/170) = 8 universes ``` #### DDP — Distributed Display Protocol - **What it is:** A simpler protocol designed specifically for pixel controllers - **How it works:** No universes — just sends a continuous stream of pixel data addressed by absolute channel number - **Much simpler to configure** — just enter the controller IP and total pixel count - **Best for:** Single-controller setups, WLED, beginners ``` DDP Addressing (no universes): Controller at 192.168.1.50: ┌────────────────────────────────────────────────┐ │ Channel 1-600: Roofline (200 px × 3 ch) │ │ Channel 601-3000: Mega tree (800 px × 3 ch) │ │ Channel 3001-3600: Mini trees (200 px × 3 ch) │ └────────────────────────────────────────────────┘ xLights just needs: IP address + total pixel count The controller handles everything else ``` #### ArtNet - **What it is:** An older protocol, originally designed for stage lighting - **Similar to E1.31** (universe-based), but less common in Christmas lighting - **Use only if:** You have legacy equipment that requires it - **Otherwise:** Stick with DDP or E1.31 #### Which Protocol to Use? | Scenario | Recommended Protocol | |----------|---------------------| | Single WLED controller, ≤800 pixels | **DDP** (simplest) | | Single Falcon/Kulp controller, ≤2000 pixels | **DDP** (simplest) | | Multiple controllers on same network | **E1.31 multicast** (one stream, all controllers listen) | | Very large display, 5000+ pixels | **E1.31 unicast** (targeted, most efficient) | | WLED + Falcon mixed setup | **DDP for WLED**, **E1.31 for Falcon** | ### Setting Up a Dedicated Show Network **Why a separate network?** Your show sends thousands of packets per second. On your home WiFi, this competes with Netflix, phones, and IoT devices. A dedicated network prevents: - Show data being delayed by home traffic - Home devices being slowed by show data - WiFi interference affecting show reliability **The setup is simple and cheap:** ``` Network Topology — Recommended Setup ┌──────────────────────────────────────────────────────────┐ │ HOME NETWORK (192.168.1.x) │ │ │ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │ │ Router │ │ Phones │ │ Smart TV │ │ │ │192.168.1.1│ │ etc. │ │ │ │ │ └────┬──────┘ └──────────┘ └──────────┘ │ │ │ │ └───────┼──────────────────────────────────────────────────┘ │ │ (your computer connects to both networks) │ ┌───────┼──────────────────────────────────────────────────┐ │ │ │ │ SHOW NETWORK (192.168.2.x) │ │ │ │ ┌────┴─────────┐ │ │ │ Unmanaged │ ◄── Cheap gigabit switch │ │ │ Gigabit │ ($25-40, TP-Link or Netgear) │ │ │ Switch │ │ │ │ 192.168.2.x │ │ │ └┬──┬──┬──┬──┬──┘ │ │ │ │ │ │ │ │ │ │ │ │ │ └──► Raspberry Pi (FPP) — 192.168.2.10 │ │ │ │ │ │ │ │ │ │ │ └─────► Falcon F16V4 — 192.168.2.50 │ │ │ │ │ │ │ │ │ └────────► WLED ESP32 #1 — 192.168.2.51 │ │ │ │ │ │ │ └───────────► WLED ESP32 #2 — 192.168.2.52 │ │ │ │ │ └──────────────► Your PC (2nd NIC) — 192.168.2.100 │ │ (for xLights config/upload) │ │ │ └──────────────────────────────────────────────────────────┘ ``` #### Setup Steps 1. **Buy a cheap gigabit switch**: TP-Link TL-SG105 (5-port, ~$25) or TL-SG108 (8-port, ~$40) from Officeworks or Amazon AU 2. **Assign static IPs** to all show devices: - Falcon F16V4: via OLED menu or web UI → 192.168.2.50 - WLED: via Config → WiFi → Static IP → 192.168.2.51 - FPP: via web UI → Network → 192.168.2.10 3. **Connect everything** with Cat6 Ethernet cables 4. **On your PC**: If it has only one network port, use a USB-to-Ethernet adapter for the show network. Set it to a static IP (192.168.2.100, subnet 255.255.255.0, no gateway) > 💡 **Simple alternative:** If your display is small (≤2 controllers), just put everything on your home network. The dedicated show network matters more for larger displays with 4+ controllers. ### Controller IP Addressing Assign static IPs to avoid controllers getting random IPs from DHCP: | Device | IP Address | Subnet Mask | Gateway | |--------|-----------|-------------|---------| | Show switch | N/A (unmanaged) | — | — | | FPP (Raspberry Pi) | 192.168.2.10 | 255.255.255.0 | (none needed) | | Falcon F16V4 | 192.168.2.50 | 255.255.255.0 | (none needed) | | WLED #1 | 192.168.2.51 | 255.255.255.0 | (none needed) | | WLED #2 | 192.168.2.52 | 255.255.255.0 | (none needed) | | Your PC (show NIC) | 192.168.2.100 | 255.255.255.0 | (none needed) | > ⚠️ **No gateway needed** on the show network — it doesn't connect to the internet. Setting a gateway can cause routing conflicts on your PC. ### Universe and Channel Mapping If using E1.31 (not DDP), you need to map universes to controller ports: ``` Example: 1250-pixel display ┌────────────────────────────────────────────────────────┐ │ Universe 1: Channels 1-510 → Roofline px 1-170 │ │ Universe 2: Channels 1-90 → Roofline px 171-200 │ │ Channels 91-510 → Mega tree px 1-140 │ │ Universe 3: Channels 1-510 → Mega tree px 141-310 │ │ Universe 4: Channels 1-510 → Mega tree px 311-480 │ │ Universe 5: Channels 1-510 → Mega tree px 481-650 │ │ Universe 6: Channels 1-510 → Mega tree px 651-800 │ │ + Mini trees px 1-30 │ │ Universe 7: Channels 1-510 → Mini trees px 31-200 │ │ Universe 8: Channels 1-150 → Star px 1-50 │ └────────────────────────────────────────────────────────┘ ``` **This is why DDP is easier** — with DDP, you don't think about universes at all. You just assign models to controller ports in xLights, and it handles the addressing. #### xLights Controller Configuration (DDP — Recommended) 1. Go to **Controllers** tab 2. Click **Add Ethernet** 3. Set: - Name: `Falcon-F16V4` - Protocol: **DDP** - IP: `192.168.2.50` - Vendor: Falcon, Model: F16V4 - Check: Auto Layout, Auto Size, Full xLights Control 4. Save 5. Open **Visualizer** → drag models to ports 6. **Upload Output** → xLights pushes the configuration to the Falcon #### xLights Controller Configuration (E1.31) 1. Go to **Controllers** tab 2. Click **Add Ethernet** 3. Set: - Protocol: **E1.31** - IP: controller IP (unicast) or leave blank (multicast) - Starting Universe: 1 - Number of Universes: calculate based on pixels (ceil(total_pixels × 3 / 512)) 4. Save ### Testing Your Network 1. **Ping test**: From your PC, open a terminal: ``` ping 192.168.2.50 (should get replies from Falcon) ping 192.168.2.51 (should get replies from WLED) ping 192.168.2.10 (should get replies from FPP) ``` 2. **xLights test**: Go to **Tools** → **Test** → Select controller → Click individual pixels 3. **FPP test**: Open FPP web UI → **Display Testing** → select "All Channels" → "Chase" → Start 4. **Throughput test**: For large displays, check the switch's activity LEDs during playback. If the link light flickers/drops, you have a network bottleneck **✅ Test it:** Run your full show for 30 minutes. Watch for any pixel dropouts, freezes, or glitches. If you see them: - Switch WiFi controllers to Ethernet (WLED → ESP32 with Ethernet adapter, or replace with Falcon) - Check cable connections (loose RJ45 = intermittent drops) - Reduce frame rate from 40fps to 20fps (halves network traffic) ### Common Mistakes 1. **Using WiFi for everything**: WiFi is inherently unreliable for real-time lighting data. Use Ethernet where possible 2. **All devices on home network**: Works for small setups, but causes problems at scale 3. **Wrong subnet mask**: If one device is 255.255.255.0 and another is 255.255.0.0, they may not communicate 4. **Gateway conflicts**: Setting a gateway on the show network interface can cause your PC to route internet traffic there 5. **Not checking firmware versions**: Falcon and WLED firmware updates can change network behaviour. Update together with xLights 6. **Multicast flooding**: E1.31 multicast sends data to ALL ports on the switch. On a home network, this floods every device. Use unicast or a dedicated switch > 📺 **Watch:** "Lighting Protocols Explained" — https://www.youtube.com/watch?v=rxF8-rxZXq8 > 📺 **Watch:** "Setting up a Show Network" — https://www.youtube.com/watch?v=YWl1ouVnJHg --- ## Appendix: Key Resources | Resource | URL | What It Is | |----------|-----|-----------| | WLED Web Installer | https://install.wled.me | Flash WLED to ESP32 from browser | | WLED Documentation | https://kno.wled.ge | Official WLED docs including wiring guides | | xLights Download | https://xlights.org | Sequencing software | | xLights Manual | https://manual.xlights.org | Complete reference | | FPP Downloads | https://github.com/FalconChristmas/fpp/releases | Show player for Raspberry Pi | | AusChristmasLighting | https://auschristmaslighting.com | Australian community forum — THE place to ask questions | | Hanson Electronics | https://www.hansonelectronics.com.au | Australian supplier: controllers, pixels, PSUs | | Ray Wu AliExpress | https://www.aliexpress.com/store/701799 | China direct: cheapest pixels, connectors | | Light It Up LEDs | https://www.pixelprops.com.au | Australian supplier (Perth-based) | | Ink Creations | https://www.inkcreations.com.au | Australian supplier: coro props, YPS pixels | | aus.pixelcontroller.com | https://aus.pixelcontroller.com | Falcon controllers in Australia | | QuinLED | https://quinled.info | Excellent WLED + WS2811 guides | | Power Calculator | https://www.da-share.com/calculators/led-strip-string-current/ | Calculate PSU requirements | --- *Last updated: September 2026* *Questions? Join the AusChristmasLighting forum — the community is incredibly helpful for beginners.*