Så bygger du din egen fräcka ”ljuseffekt-tv”

Ambilight, eller ambient ­lighting som det egentligen heter, är en teknik som finns i många av Philips nyare tv-apparater. Idén är att belysa väggen bakom tv:n med samma färgtoner som för tillfället visas längsmed skärmens ytterkanter – för att skapa ett slags djup i bilden och en illusion om att den sträcker sig utanför själva tv:n. Effekten är riktigt häftig och fungerar faktiskt väldigt bra.

 

Eftersom tekniken är ut-vecklad av Philips finns den i nuläget inte tillgänglig för andra tv-apparater. Spännande nog är det emellertid inte särskilt svårt att bygga en egen ambilight-klon. Allt som behövs är en led-ljusslinga, ett kontrollerkort och en ram att montera allt på bakom tv:n. Och det är precis vad vi kommer att göra i denna skola.

 

Vi kommer sedan koppla vår ljus-ram till en htpc (vanlig pc avsedd för film, men kopplad till tv:n) och få den att projicera samma färger på väggen bakom tv:n – som faktiskt visas på skärmen.
 

Val av komponenter

Vi använder oss av två huvudkomponenter för att konstruera vår bakgrundsbelysning. Den första är själva led-lamporna. Den modell vi vill åt heter WS2801 och finns vanligen att hitta i uppsättningar om 25, 50, 75 eller 100 led-lampor i en slinga. Vi valde att köpa en slinga om 50 stycken från Ebay (ebay.se) för cirka 250 kronor. För att kunna koppla ihop led-lamporna med datorn och kontrollera dem behöver vi även ett Arduino-kontrollerkort. Kortet finns i olika varianter. Vi använder Arduino Uno (Rev3) som kan köpas hos till exempel Kjell & Company för 250 kronor.

 

Utöver dessa två komponenter behöver vi två usb-kablar. En av typen a-b, för att koppla Arduino-kortet till datorn, samt en med en vanlig usb-kabel (till exempel a-micro usb), denna kommer vi att klippa av och löda ihop med vår led-slinga för att ge den ström. Vi behöver även en vanlig väggströmadapter med ett usb-uttag (minst två ampere för 50 led-lampor), en stiftlist för att fästa kablarna på Arduino-kortet samt lite krympslang för att kapsla in våra lödningar. Till sist bygger vi själva ramen av några trälister. Denna kommer vi sedan fästa bakom vår tv i skruvhålen avsedda för montering av väggfäste.
 

• Missa inte! Här kan du se det färdiga resultatet!

Delarna. Här är huvudkomponenterna till vår ljusram.
 

Del 1: Provisorisk hopkoppling

1. Vi börjar med att bryta loss tre stift från vår stiftlist. Dessa löder vi fast på hane-adaptern som följde med vår led-slinga (den större av de två kontakterna). Vi fäster sedan kontakten i led-slingan. De två överblivna kablarna från led-slingan (röd och blå) behöver vi inte, så dem innesluter vi i krympslang som vi sedan värmer upp så att de inte är i vägen.

 

2. I andra änden av vår led-slinga behöver vi ström­försörjning. Vi klipper därför av vår vanliga usb-kabel och skalar kablarna. Vi vill åt den röda (+) och den svarta kabeln (-). Vi löder sedan ihop den röda kabeln med den röda kabeln från led-slingan och den svarta med den blå kabeln från led-slingan. Övriga kablar från usb-sladden täcker vi med krympslang.

 

3. Vi placerar vårt Arduino-kort bredvid vår htpc (dator) och kopplar in de tre stiftkontakterna vi tidigare lödde fast enligt följande: blå kabel till ingången märkt GND (jord), grön kabel till ingången märkt 13 samt vit kabel till ingången märkt 11.

 

4. På bilden ovan ser du var kablarna ska fästas i Arduino-kortet. Därefter är det dags att koppla in den andra usb-kabeln i usb-porten på Arduino-kortet.  Vi pluggar även i usb-kabeln från led-slingan i vår vägg­a­dapter. Dock väntar vi ett tag med att ansluta den till datorn eller väggen.

 

När allt nu är hopkopplat går vi vidare till nästa del (del 2) och installerar de program vi behöver.

Del 2: Dags att installera programmen

1. Vi kommer att använda två program för att styra vårt Arduino-kort. Vi surfar till arduino.cc och väljer fliken Download. Där hämtar vi hem den senaste versionen (i skrivande stund 1.0.5) av Arduino IDE-programmet (zip-versionen). Vi extraherar sedan innehållet till valfri mapp. Därefter går vi till processing.org/download och laddar ned senaste versionen av kodutvecklingsverktyget Processing. Vi väljer 32-bit versionen trots att vi använder ett 64-bit operativsystem, då 64-bit versionen verkar ha problem med de uppgifter vi kommer att ge den. Vi extraherar programmet till samma mapp vi placerade Arduino-mappen i.

 

Mappar. Här är de program vi kommer använda oss av.

 

2. Nu behöver vi hämta lite kod för att få våra lampor att göra som vi vill framöver. Givetvis kan du ge dig på att skriva koden själv, men vi kommer här att låna en av de färdigskrivna ­gratisvarianter som finns att använda sig av. Koden är skriven av företaget Adafruit och är fri för alla att använda sig av. Vår guide härstammar också från Adafruits egen genomgång av sitt program, skriven av Phillip Burgess, till­sammans med våra egna förändringar av kod och tillvägagångssätt. Vi går in på github.com/adafruit/adalight och klickar på Download ZIP (nere i högra hörnet). Vi öppnar zip-filen och extraherar mappen Arduino samt Processing till vår dators dokument-mapp (C:Användare(din användare)Mina dokument). De övriga filerna i zip-filen kommer vi inte använda.

 

3. Nu ansluter vi Arduino-kortet till datorn samt vår led-slinga till ett närliggande vägguttag. Datorn kommer att försöka installera drivrutinerna men misslyckas. I stället höger­klickar vi på Den här datorn, väljer Egenskaper och klickar på Enhetshanteraren (högst upp). Under Portar (COM och LPT) hittar vi nu Arduino UNO COMxx (xx skall vara ett nummer, till exempel 03). Vi högerklickar på Arduino och väljer Uppdatera drivrutin varpå vi bläddrar till mappen vi extraherade Arduino IDE till. Vi markerar sedan mappen Drivers och väljer Installera.

 

Arduino-kortet kan även dyka upp som en Okänd enhet under Andra enheter (högst upp i listan). Då är det bara att genomföra ovanstående steg men i stället högerklicka på Okänd enhet.

 

Klart. Här är Arduino-kortet installerat.
 

Del 3: Vi testar kopplingen

Nu startar vi Arduino IDE-programmet genom att klicka på Arduino.exe i mappen Arduino. I menyn väljer vi sedan File, Sketchbook, LEDstream. Efter detta klickar vi på Tools i menyn, följt av Serial Port. Vi markerar den com-port som motsvarar siffrorna från enhetshanteraren (i vårt fall COM3). Sedan väljer vi File, Upload för att ladda upp koden till vårt Arduino-kort.

 

Efter att koden laddats in på kortet lyser alla våra lampor upp i en kort sekvens för att indikera att kopplingen till datorn fungerar korrekt. Skulle det inte fungera bör du dubbelkolla att alla kablar är inkopplade till rätt portar på Arduino-kortet. Stäng sedan Arduino IDE-programmet.

Serial port. Här väljer vi rätt com-port för vårt kort.

 

Del 4: Ge Arduino instruktioner

Nu startar vi Processing IDE (från Processing-mappen). Programmet är till utseendet väldigt likt Arduino IDE. Vi väljer File, Sketchbook, Colorswirl. Innan vi kan testa koden behöver vi ändra en liten del av den. Vi rullar ned tills vi ser kodbiten myPort = new Serial(this, Serial.list()[0], 115200); på rad 44. Vad den här koden gör är att anta att Arduino-kortet är den första och enda inkopplade seriella enheten till datorn (vilket oftast inte är fallet). Vi vill därför berätta för programmet att Arduino faktiskt är inkopplad på com-port 3. Vi ändrar således koden till myPort = new Serial(this, ”COM3”, 115200);. Därefter klickar vi på Run (play-knappen längst upp till vänster) och vips börjar våra led-lampor lysa.

 

Tänt var det här! Vi ändrar koden och våra lampor börjar lysa och skifta färg.

 

Hur mysig regnbågsanimationen än må vara är det dock inte det vi vill åstadkomma med våra lampor. Vi väljer därför File, Sketchbook, Adalight i stället. Detta är koden vi kommer använda för att styra våra lampor. Det första vi gör är att upprepa samma ändringar vi gjorde i Colorswirl-exemplet tidigare. Vi rullar ned tills vi kommer till rad 156 och koden port = new Serial(this, Serial.list()[0], 115200); och ändrar denna rad till port = new Serial(this, ”COM3”, 115200); där COM3 alltså är vår port till vilken Arduino-kortet är kopplat.

 

 

Styrning. Vi väljer nu Adalight i stället och gör samma ändring i koden som tidigare.

 

När vi nu klickar på Run igen lyser hälften av våra lampor upp i olika färger. Gör vi nu något på skärmen kan vi se hur lamporna skiftar färg beroende på vad som visas. Dock vill vi givetvis att alla våra lampor ska lysa och inte endast 25. Varför endast de 25 första lyser är för att koden är skriven med just det antalet lampor i åtanke. Har du därför en slinga med just 25 lampor kan du i princip hoppa över nästa del, (del 5).
 

Del 5: Så kodar vi om antalet lampor

1. Koden som hanterar antalet lampor börjar under stycket PER-DISPLAY INFORMATION. Det första vi behöver ändra är under static final int displays…. Från början 0, 9, 6. Det vill säga skärm nummer 0 (första skärmen och den enda vi kommer använda oss av), 9 rader med led-lampor horisontellt och 6 rader vertikalt. ­Tillsammans blir det 9 plus 9 lampor horisontellt och 4 plus 4 vertikalt, totalt 26 stycken lampor. Koden (som vi kommer till snart) lämnar dock en rad tom längst ned i mitten för att tv:ns fot ska få plats, vilket gör att vi får 25 faktiska lampor. Vi har dock 50 lampor och ändrar därför koden till 0, 16, 13.

16×2 + 11×2 = 54. I och med att vi har så pass många lampor horisontellt kan vi utesluta fyra stycken vid tv:ns fot vilket gör att vi hamnar på 50 lampor totalt (hörnlamporna räknas bara en gång).

 

 

2. Nästa del kräver lite tankekraft men är samtidigt väldigt logisk. Vi vill ändra samtliga lampor under nästföljande stycke PER-LED INFORMATION. Alla lampor består av tre siffror där den första är numret på skärmen (alltid 0 i vårt fall eftersom vi bara har en skärm), den andra är lampans x-koordinat (horisontellt) och den tredje är lampans y-koordinat (vertikalt). Enklast är att börja med lamporna överst på skärmen (tredje raden). Lampan längst upp till vänster är alltså (0, 0, 0) medan nästa lampa får koden (0, 1, 0) och så vidare till lampan längst upp till höger med koden (0, 15, 0). Efter att vi skrivit om samtliga koordinater för vårt specificerade ”rutnät” av lampor har vi tillslut fått koden ovan.

Ny kod. Överst är koden för 25 lampor. Nederst är vår egen för 50 lampor.

3. Avslutningsvis går vi till rad 39 och ändrar ­texten static final short ­minBrightness till 0 i stället för 120. Detta gör att våra lampor slocknar helt när bilden är svart. I stället för att ständigt ha ett litet ljussken. Detta steg är givetvis valfritt.
 

4. När vi nu trycker på Play-knappen lyser våra lampor upp. Ett fönster öppnas där du i realtid ser vilken färg programmet registrerar för varje lampa och var lamporna befinner sig i förhållande till varandra.

Del 6: Dags att bygga en ram till lamporna

När vi slutligen fått samtliga lampor att lysa är det dags att bygga en ram åt dem. Vi bygger en ram av vanliga träreglar från en gammal tavelram. Vi gör ramen något mindre än vår tv och mäter sedan ut var alla lampor ska sitta enligt vårt tidigare schema (alltså 16 i överkant, 11 på respektive kortsida samt 6 på varje sida i underkant). Lamporna fäster vi med hjälp av resårband och häftpistol. För att få fast ramen på tv:n skruvar vi fast reglar tvärs över.

 

Lampor på plats. Vår ram efter montering av led-lamporna.

 

I reglarna borrar vi sedan hål med samma avstånd som tv:ns hål för väggfäste har.

 

Arduino-kortet fäster vi längst ned på ramen med ett par skruvar. Givetvis bör kortet skyddas med någon typ av hölje, dock hoppar vi över detta i nuläget så vi kan se att allt fungerar som det ska först. När ramen sedan är klar skruvar vi fast den bak på vår tv (i skruvhålen avsedda för väggfäste) och kopplar in alla kablar precis som tidigare.

 

Kort på plats. Lampor och Arduino-kortet monterade.

 

För att undvika överhettning, tänk på att inte täcka för några ventilationshål eller placera ramen där du vet att tv:n blir väldigt varm.

 

Färdigmonterat. Alltsammans monterat bakom tv:n.
 

Del 7: Vi tar hjälp av XBMC

När vi nu startar programmet Processing blinkar våra lampor till i en kort färgsekvens för att sedan mycket riktigt börja visa i princip exakt samma färger som visas på skärmen där de sitter monterade bakom (se bild nedan). För att testa så att allt är korrekt monterat använder vi oss av en testfilm från Youtube som vi spelar upp i fullskärmsläge (youtube.com/watch?v= sr_vL2anfXA). Skulle det vara så att någon lampa visar fel färg är det förmodligen något fel i koden, till exempel att två lampor har samma koordinater.

Färgglatt. Alla våra lampor lyser och visar korrekt färg för sin ­placering.

 

Eftersom huvudtanken är att använda vår ljusram att förstärka upplevelsen vid film­visning laddar vi ned och installerar XBMC från xbmc.org/download.

 

XBMC är ett mycket kompetent program för att spela upp filmfiler och har mängder med inställningar. Vi fokuserar dock på den inställning som är viktig för att vår bakgrundsbelysning ska fungera korrekt. Eftersom programmet nu skannar av skärmen hela tiden vill vi inte låta XBMC köras i fullskärmsläge utan i stället endast låtsas köra i fullskärm. (Om XBMC körs i fullskärmsläge känner inte Processing av vad som faktiskt sker på skärmen utan hamnar i bakgrunden och då blir belysningen inte korrekt.)

Vi löser detta genom att starta XBMC från startmenyn och välja Settings, System, Video Output. Sedan kryssar vi för rutan Use a fullscreen window rather than true full­screen. Vi startar ett videoklipp och mycket riktigt lyser våra led-lampor i samma färger som visas på skärmen.

 

• Missa inte! Gratis tv från play-kanalerna

Del 8: Vi har ett resultat!

Så här läckert blev till slut resultatet. Våra lampor följer skärmens minsta vink och visar efter bästa förmåga en så korrekt färg som möjligt beroende på vad som sker på skärmen.

 

Här är en film som visar resultatet:

 

Så slipper du starta Processing IDE varje gång

I stället för att behöva starta Processing IDE och ladda Adalight varje gång vi vill använda vår ljusram väljer vi att klicka på File, Export application i Processing.

 

Här kryssar vi ur Full screen och väljer Windows.

Vi högerklickar sedan på filen Adalight.pde och väljer Skapa genväg. Genvägen sparar vi i datorns autostart-mapp (Start-menyn, Alla program, Autostart). Detta gör att vår kod startar automatiskt varje gång vi startar vår htpc.