Log In
Home
February 17, 2012
Offline
Det går att styra allt och lite till över lokalt nätverk idag, smidigt inte minst om man gillar att använda telefonen som fjärrkontroll. Det var tanken när jag köpte min hemmabioförstärkare (Yamaha RX-V775) för tre år sedan, och när jag köpte mina Philips Hue-lampor för två år sedan. Båda två har appar och webbgränssnitt för att styras från dator och telefon, och i båda fallen fungerar det “bra nog” till vardags. Men, kort sagt, bra nog räcker inte alltid till.
Ett vanligt användarscenario är att jag sitter med laptopen i soffan eller vid den stationära burken vid skrivbordet och vill sätta igång en låt att strömma till förstärkaren. Sistnämnda år såklart avstängd, fjärrkontrollen tycks ha tunnlat till ett parallellt universum och telefonen ligger på andra sidan rummet. Det enda sättet att starta förstärkaren eller släcka lamporna direkt från någon av datorerna är att öppna webbläsaren och använda klumpiga webbappar.
Ett I-landsproblem? Utan tvekan. Men det är ett lösbart I-landsproblem! 🙂
(Webbappen till förstärkaren är både opraktisk och osexig)
En kombination av nyfikenhet, uttråkning och önskan efter en mer skräddarsydd lösning har därför drivit mig till att ta lite mer kontroll över prylarna och se om jag kan väva in dem lite mer i mitt användarmönster. Jag har intresserat mig för hemautomation sedan ett tag tillbaka, så jag har helt enkelt bestämt mig för att ta fram lite egna lösningar för hur lamporna och förstärkaren samarbetar, och hur jag smidigast kan styra mina prylar utan att gräva fram halvdana appar eller rota efter fjärrkontrollen. Jag gör det dels för att lägga till lite egna funktioner jag saknar, såsom att kontrollera båda systemen från samma kontrollpanel, och dels för att jag helt enkelt tycker det är kul att lära mig mer om hur de fungerar under huven.
Någonting som dock är viktigt att påpeka är att jag inte är programmerare. Jag har lite praktisk erfarenhet av scriptspråk till Windows, Mac och Linux och är van vid att använda Bash som kommandorad, men det mesta lär jag mig efterhand som det behöver göras. Den största anledningen att jag ens pysslar med det här projektet är för att öva på mina script- och programmeringskunskaper. Därför kommer det förekomma klumpigheter i koden jag använder - den kommer optimeras i längden, men i första hand är det viktigaste att scripten gör det jag vill att de ska göra. Metoderna kommer bli lite som de blir, så det hoppas jag att mer erfarna kodknackare i läsarskaran har överseende med 🙂
Med det ur vägen, här är några av sakerna jag vill kunna göra:
- Kunna styra både lampor och förstärkare via kommandoraden på med korta, enkla kommandon. Inget av systemen har färdiga, skräddarsydda terminalanrop i nuläget.
- Bygga enkla grafiska verktyg för att styra både förstärkare och lampor från samma ställe på datorn, utan att behöva använda en webbapp
- Kunna aktivera gemensamma profiler för lampor och förstärkare. Ett särskilt HTPC-filmläge ska exempelvis byta ingång på förstärkaren till HTPC, lägga volymen på lämplig nivå och släcka ner lamporna i rummet, med ett enda knapptryck eller terminalkommando.
- Smartare användning av förstärkaren - jag kan manuellt ställa in volym och ingång på förstärkaren som det är, men flera funktioner går att automatisera och göra smartare. Exempelvis vill jag ha en lättåtkomlig timerfunktion som stänger av eller startar förstärkaren efter en viss stund eller vid ett visst klockslag.
Inledelsevis kommer jag i första hand göra de här grejerna via terminalen på laptopen, men i längden planerar jag att gå vidare med lite mer avancerade steg och skriva ett mer regelrätt program för att styra prylarna.
Det finns flera sätt att åstadkomma resultatet jag är ute efter, men primärt kommer jag använda mig av tre språk/verktyg. Till Mac och Linux kommer jag använda Bash-terminalen och tillhörande scriptspråk, och därefter Swift i Xcode för att skriva appar till MacOS och iOS. Till Windows kommer jag istället använda mig av scriptspråket Autoit.
Det här har blivit en lite långdragen introduktion, men jag räknar med att göra den första uppdateringen under morgondagen med de första stegen för att styra själva förstärkaren.
February 17, 2012
Offline
Dags att få pli på förstärkaren
Innan det går att göra någonting mer avancerat behöver jag analysera vilken information som skickas till förstärkaren, hur det skickas, och hur jag kan skapa egna kommandon baserade på samma princip. För att ta reda på det använder jag utvecklarverktygen i Chrome:
Nätverksfliken i Chrome håller koll på vilken information som webbläsaren skickar till och tar emot från förstärkaren. När en knapp i gränssnittet aktiveras dyker två nya kommandon upp i listan, båda två i form av HTML-strängar. Här syns det snabbt att ett knapptryck skickar två olika kommandon: ett "PUT"-kommando och ett "GET"-kommando.
PUT och GET innebär att förstärkaren fjärrstyrs via HTTP-poster, och smidigt nog går det att direkt från webbläsaren skapa ett kommando som går att köras via en terminal. På så sätt kan jag också se formatet på strängen som används.
Kommandot som genereras använder cURL, ett standardverktyg som finns på de flesta Posix-kompatibla operativsystem, till exempel Linux och Mac. Det finns inte som standardverktyg till Windows, utan där kommer jag behöva använda andra verktyg för att skicka samma information.
Det följer med en hel del onödig information i kommandot som Chrome spottar ur sig, så det går att korta ner en hel del till en mer begriplig form:
curl 'http://192.168.2.105/YamahaRemoteControl/ctrl' --data-binary '<YAMAHA_AV cmd="PUT"><Main_Zone><Power_Control><Power>On</Power></Power_Control></Main_Zone></YAMAHA_AV>' --compressed
Kommandot visar helt enkelt att cURL ska skicka en enkel, binär textsträng med HTML-kod till en lyssnande server på förstärkaren. Innehållet i strängen berättar sedan om förstärkaren ska ändra någonting eller bara svara med information om någonting.
Jag upprepar samma steg med alla de kommandon jag kan tänkas behöva när jag ska skriva script längre fram. Det innebär att jag skriver ner både PUT- och GET-strängar för bland annat:
- Att starta eller stänga av förstärkaren från viloläge, samt fråga den i vilket läge den är just nu
- Att byta ingång på förstärkaren till en specifik port (HDMI, analog video, frontpanelsljud etc) samt fråga förstärkaren vilken ingång som är aktiv just nu
- Att aktivera eller deaktivera mute, samt fråga om förstärkaren är i mute-läge just nu
- Att höja eller sänka volymen med ett visst antal steg
- Att ställa volymen direkt till en specifik nivå samt fråga vad volymen är just nu
- Motsvarande ovanstående för bas och diskant
Med de strängarna nedskrivna har jag sedan allt som behövs för att bygga enkla script och program för allt jag annars brukar använda fjärrkontroll, mobiltelefon eller webbläsare till. Till att börja med kan jag skriva korta script som går att anropa i terminalen på Mac eller Linux, och det görs med ett script i stil med det jag skriver här nedanför:
#!/bin/bash
source /Users/curl/Scripts/AVR/receiverConfig.sh
state=$(curl -s 'http://'$avrip'/YamahaRemoteControl/ctrl' --data-binary '<YAMAHA_AV cmd="GET"><Main_Zone><Power_Control><Power>GetParam</Power></Power_Control></Main_Zone></YAMAHA_AV>' --compressed | grep -o "On\|Standby")
if [ $state = "Standby" ] ; then
curl -s 'http://'$avrip'/YamahaRemoteControl/ctrl' --data-binary '<YAMAHA_AV cmd="PUT"><Main_Zone><Power_Control><Power>On</Power></Power_Control></Main_Zone></YAMAHA_AV>' --compressed > /dev/null
elif [ $state = "On" ]; then
curl -s 'http://'$avrip'/YamahaRemoteControl/ctrl' --data-binary '<YAMAHA_AV cmd="PUT"><Main_Zone><Power_Control><Power>Standby</Power></Power_Control></Main_Zone></YAMAHA_AV>' --compressed > /dev/null
else
echo "Hittar ej status"
fi
I scriptet ovanför läser det först in en separat fil (receiverConfig.sh) där jag har sparat IP-adressen till förstärkaren - detta för att jag inte manuellt ska behöva gå in och byta IP-adress manuellt i alla script om jag skulle få för mig att byta IP på förstärkaren senare. Därefter skickas ett GET-kommando till förstärkaren och frågar om standby-status, och scriptet söker i svaret efter nyckelorden "On" eller "Standby", och sparar det som en variabel. Om svaret är "On" så skickas sedan ett kommando för att stänga av förstärkaren, och vice versa.
Scriptet sparas som en textfil och görs körbart med "chmod +x", och kopieras till mappen med terminalprogram. Nu räcker det med att skriva namnet på scriptet i ett terminalfönster så kommer det motsvara att trycka på strömknappen på förstärkaren eller fjärrkontrollen - är den avstängd sätts den igång, är den igång så stängs den av 🙂
Motsvarande script går att skriva för alla förstärkarens funktioner, så att det snabbt går att styra den med några tangentbordstryckningar från laptopen. Vid det här laget är det dock inte mycket smidigare än att starta webbappen och trycka på knappen där, så nästa steg är att bygga någonting mer grafiskt som fjärrkontroll till både den stationära och den bärbara datorn. Men det får bli i nästa uppdatering!
February 17, 2012
Offline
Varde ljus!
Nu när jag har de mest grundläggande byggklossarna för att fjärrstyra förstärkaren ska jag istället ta en titt på att reglera belysningen. Jag använder första generationens Philips Hue-kit med tre RGB-lampor som är anslutna trådlöst till en ethernet-ansluten basstation, och det finns redan en hel del bra verktyg för att styra lamporna med både telefon och dator. Det går exempelvis att schemalägga olika ljusprofiler med hjälp av mobilappen, bland annat för att tända ljuset på morgonen eller släcka automatiskt när jag inte är hemma.
Vad jag vill åstadkomma nu är att kunna styra lamporna från datorn med samma gränssnitt som förstärkaren - på mobilen är profilerna och widgetfunktionerna redan bra nog för det mesta jag vill göra. Och för att bygga in mina egna lampkontroller på datorn behöver jag först leta rätt på exakt vilka kommandon som används.
Fördelen med Hue är att Philips tillhändahåller en ganska djupgående dokumentation på sin hemsida, så jag behöver inte rota fram några kommandon på egen hand som jag behövde med förstärkaren. Den grundläggande tekniken är dessutom densamma som för förstärkaren: lamporna lyssnar efter HTTP-kommandon (POST eller GET) och utför olika operationer eller svarar med olika värden beroende på vad som efterfrågas. I Hues fall används en teknik som kallas RESTful.
En stor skillnad är däremot att Hue har ett extra säkerhetslager, medan förstärkaren bara lyssnar passivt efter kommandon. För att styra Hue behöver man först skapa ett "användarnamn", och ge det åtkomst genom att trycka på parkopplingsknappen på basstationen.
Både kontoskapandet och fjärrstyrningen kan testas med ett webbgränssnitt, där det både går att läsa och skriva information. På så sätt kan jag testa mig fram och hitta vilka lampor som har vilket ID, skapa grupper av lampor som kan styra samtidigt, ändra färg, ljusstyrka och mycket annat.
För mina ändamål vill jag i första hand kunna tända och släcka alla lampor (även om jag kommer vilja lägga till mer avancerade funktioner längre fram). Precis som med förstärkaren kan jag använda cURL för att styra lamporna, men formatet är lite annorlunda:
source /Users/curl/Scripts/Hue/hue_creds.sh
curl -s -X PUT -d "{\"on\":false}" http://$hueip/api/$username/gr.....s/4/action > /dev/null
Variabeln $hueip är Hue-basstationens IP-adress på nätverket, och $username är det användarnamn som skapades för att ge läs- och skrivrättigheter. Dessa ligger lagrade i en separat fil, hue_creds.sh, för att enkelt kunna ändras utan att behöva skriva om alla sparade script.
Scriptet i exemplet ovanför skickar en sträng som sätter värdet "on" till "false" för en av lampgrupperna. Grupp nummer 4 är helt enkelt en grupp med alla lampor, och att sätta "on" till "false" innebär helt enkelt att släcka alla lampor i lägenheten. Skriver jag "true" istället för "false" så tänds alla lampor, med den senast aktiva ljusstyrkan och färgen.
Biten "> /dev/null" innebär att returdatan från operationen dumpas och inte skrivs ut i terminalen, främst för att inte fylla terminalfönstret med text för sådana här förhållandevis små kommandon.
Som kuriosa är det värt att notera att när Hue ska styras med cURL så skrivs "PUT" ut som en del av cURL-kommandot vilket det inte gör när jag ska styra förstärkaren, även om både förstärkaren och Hue använder just PUT. Anledningen tycks vara att Yamaha använt en lite mer udda metod, där både PUT- och GET-kommandon skickas som POST, och innehållet i strängen som skickas sedan berättar om det är PUT eller GET.
Efter att ha testat så att scriptet fungerar har jag nu de pusselbitar som behövs för att bygga ett mer grafiskt gränssnitt. I nästa inlägg tänkte jag börja med att bygga ett till Windows, så att jag smidigare kan flytta om ljudet till förstärkaren när jag sitter vid den stationära datorn.
February 17, 2012
Offline
En fjärrkontroll till Windows
Efter någon veckas uppehåll vill jag mest ge en uppdatering om hur pysslandet fortskridit, bland annat med ett program till Windows jag kan använda för att styra både lampor och förstärkare. I samband med det arbetet kan jag också konstatera att projektet har spårat ur en gnutta från hur planerna såg ut från början, men mer om det i slutet av inlägget.
I mitt mina två förra inlägg visade jag hur det går att styra prylarna med hjälp av kommandoraden, via enkla cURL-kommandon. Det är någorlunda smidigt på en Mac eller dator med Linux, men cURL är ett Unix- och Linux-verktyg som inte finns inbyggt i Windows. Därför fungerar inte heller de scripten i sitt grundutförande på min stationära dator.
Min första, lata metod var att använda ett verktygsfält i menyfältet på skrivbordet, det vill säga att bara lägga några script i en mapp och sedan visa den mappen som en utfällbar meny (exempel ovan). Det skulle vara en någorlunda smidig lösning, men hjälper inte mot problemet att jag fortfarande behöver script som fungerar till Windows som jag sedan kan länka in.
Valet stod därför antingen mellan att försöka köra scripten på Windows med hjälp av ett kompatibilitetsverktyg, till exempel Cygwin, eller att strunta i cURL helt och hållet och bygga någonting nytt för just Windows. I och med att jag ändå ville passa på och bygga någonting lite snyggare än bara ett verktygsfält så föll valet på det senare.
Ut med Bash, in med Autoit
För ändamålet använder jag Autoit, ett scriptspråk till Windows som även kan användas för att bygga lite mer avancerade program. Fördelen med Autoit i det här fallet är att det är relativt enkel syntax, jämförbar med exempelvis Bash till Linux eller Mac, men med fullt stöd för att bygga funktioner, arrayer och kompletta användargränssnitt med fönster och menyer, utan att behöva ett fullstort utvecklarkit som Visual Studio. Visual Studio är ett par GB stort och kräver betydligt större bakgrundskunskaper för att bygga ens enkla program, medan Autoit bara tar ett par MB, och skrivs med en vanlig texteditor.
Mitt fjärrkontrollsprogram är än så länge förhållandevis kort, strax över 200 rader inklusive formatering, men det är fortfarande lite väl långt för att jag ska lägga in all kod här i forumet. Jag kommer dock ge några exempel på hur det fungerar, och skulle någon av någon anledning vilja se all kod så är det bara att fråga så kan jag skicka filen.
Först och främst har det ett par fördefinierade funktioner som var och en skickar ett kommando till förstärkaren eller lamporna. Som jag nämnde tidigare så fungerar inte cURL till Windows, utan istället har jag använt Autoits egen metod för att skicka HTTP-kommandon (tack till Tjalve för lite hjälp på vägen för hur dessa fungerar). Här är ett exempel som byter ingång på förstärkaren:
$data_to_send = StringToBinary('' & $input & '')
$oHTTP = ObjCreate("winhttp.winhttprequest.5.1")
$oHTTP.Open("POST", "http://" & $ip & "/YamahaRemoteControl/ctrl", False)
$oHTTP.Send($data_to_send)
EndFunc
_SetInput är namnet på funktionen, och när jag kallar på den någonstans i koden så behöver jag lägga till ett värde för variabeln $input, till exempel "HDMI1" eller "V-AUX". Funktionen skapar sedan en sträng med ett kommando som säger åt förstärkaren att byta ingång till värdet i $input. $oHTTP är ett objekt av typen winhttprequest som skapas för att kunna skicka kommandot, motsvarande hur jag använder cURL i kommandoraden på Mac. Objektet har ett antal metoder (inbyggda funktioner), till exempel .Open som öppnar kommunikationen med förstärkaren och .Send som skickar strängen som sparades i början av funktionen.
Exakt samma princip används för allt ifrån att öka eller sänka volymen till att stänga av eller starta förstärkaren.
Här är motsvarande exempel för att stänga av eller starta Philips Hue-lamporna:
$sendState = ""
If $state = "On" Then
$sendState = "true"
ElseIf $state = "Off" Then
$sendState = "false"
Else
MsgBox(0,"Error","Incorrect Hue response.")
EndIf
$data_to_send = StringToBinary('{"on":' & $sendState &'}')
$oHTTP = ObjCreate("winhttp.winhttprequest.5.1")
$oHTTP.Open("PUT", "http://" & $HueIP & "/api/" & $username & "/groups/4/action", False)
$oHTTP.Send($data_to_send)
EndFunc
Här är ett annat exempel som frågar om status hos förstärkaren istället för att be den ändra någonting:
$data_to_send = StringToBinary('GetParam')
$oHTTP = ObjCreate("winhttp.winhttprequest.5.1")
$oHTTP.Open("POST", "http://" & $ip & "/YamahaRemoteControl/ctrl", False)
$oHTTP.Send($data_to_send)
$AVR_response = $oHTTP.ResponseText
Global $aArray = 0
Global $iOffset = 1
$AVR_powerState = StringRegExp($AVR_response, '(?i)(.*?)', $STR_REGEXPARRAYMATCH, $iOffset)[0]
Return $AVR_powerState
EndFunc
Funktionen fungerar egentligen på precis samma sätt som funktionen för att byta ingång, men här innehåller strängen en förfrågan (GET) istället för en ändring (PUT). Förstärkaren skickar sedan ett svar, i det här fallet med svaret på frågan "är förstärkaren på eller av?". Svaret sparas som $oHTTP.ResponseText, som jag sedan sparar i en egen variabel, $AVR_response.
Svaret har dock ett långt format i form av en HTML-sträng som påminner om den långa sträng som skickas till förstärkaren. För att göra det lite mer lätthanterligt använder jag en Regular Expression för att klippa ut bara den biten jag vill ha - antingen "On" eller "Standby". Den biten av svaret skickas sedan som funktionens svar.
Med funktioner för att fråga om status eller ändra värden kan jag sedan pussla ihop funktioner som frågar om en status och skickar ett kommando beroende på vad programmet får som svar. Här nedanför är ett exempel motsvarar att trycka på strömknappen på förstärkaren - är den av så startas den, är den på så stängs den av:
If _CheckPower() = "Standby" Then
_SetPowerState("On")
ElseIf _CheckPower() = "On" Then
_SetPowerState("Standby")
Else
MsgBox(0,"Error","Invalid AVR response!")
EndIf
EndFunc
Gränssnitt
Med alla de nödvändigaste funktionerna på plats följer sedan den roliga biten - hur programmet ska se ut och fungera på datorn. Jag skulle kunna göra ett enkelt fönster med knappar som utför de olika funktionerna, men då är det bara marginellt smidigare än att öppna förstärkarens eller lampornas webb-app. Istället vill jag ha någonting som ligger i menyfältet och alltid är lättåtkomligt.
Gränssnitten i Autoit startas som funktioner, och saker som fönster och knappar skapas genom att lägga till variabler som anropar andra funktioner som ritar upp gränssnitten. I det här fallet vill jag ha en liten app i aktivitetsfältet, så jag använder Tray-funktionerna, exempelvis TrayCreateMenu (själva menyn) och TrayCreateIten (för knapparna).
Här är ett exempel på hur knapparna och menyerna är definierade:
Local $iMute = TrayCreateItem("Mute")
Local $HueToggle = TrayCreateItem("Lights")
TrayCreateItem("")
Local $iInputMenu = TrayCreateMenu("Input")
Local $iHDMI1 = TrayCreateItem(_optAlias($HDMI1), $iInputMenu)
Local $iHDMI2 = TrayCreateItem(_optAlias($HDMI2), $iInputMenu)
Local $iHDMI3 = TrayCreateItem(_optAlias($HDMI3), $iInputMenu)
Local $iHDMI4 = TrayCreateItem(_optAlias($HDMI4), $iInputMenu)
Local $iHDMI5 = TrayCreateItem(_optAlias($HDMI5), $iInputMenu)
TrayCreateItem("",$iInputMenu)
Local $iAV1 = TrayCreateItem(_optAlias($AV1), $iInputMenu)
Local $iAV2 = TrayCreateItem(_optAlias($AV2), $iInputMenu)
Local $iAV3 = TrayCreateItem(_optAlias($AV3), $iInputMenu)
Local $iAV4 = TrayCreateItem(_optAlias($AV4), $iInputMenu)
Local $iAV5 = TrayCreateItem(_optAlias($AV5), $iInputMenu)
Local $iAV6 = TrayCreateItem(_optAlias($AV6), $iInputMenu)
TrayCreateItem("",$iInputMenu)
Local $iVAUX = TrayCreateItem(_optAlias($VAUX), $iInputMenu)
Local $iAUDIO1 = TrayCreateItem(_optAlias($AUDIO1), $iInputMenu)
Local $iAUDIO2 = TrayCreateItem(_optAlias($AUDIO1), $iInputMenu)
Local $idQuit = TrayCreateItem("Quit")
Vilket ser ut så här när programmet sedan körs:
I koden lite längre upp finns en funktion som heter _optAlias. Anledningen att jag använder den är för att jag inte alltid kommer ihåg vilken pryl som är kopplad till vilken port på förstärkaren. Därför vill jag såklart att det ska stå vilken enhet (till exempel Apple TV eller Xbox) det är jag byter till, inte bara vilken port. Samtidigt så vill jag kunna byta port för en pryl utan att behöva ändra varje referens till prylen i koden. Så _optAlias är helt enkelt ett litet fulhack jag lade in för att göra det lite enklare att byta namn eller plats på en pryl utan att behöva skriva om för mycket av programmet.
Högst upp i programmet har varje ingång en egen array med två värden. Exempelvis heter HDMI2-porten $HDMI2 och har två värden: strängen "HDMI2" och en annan sträng, i det här fallet "Chromecast". När en enhet är kopplad till en port skriver jag vilken enhet det är i det andra värdet, som ett "alias". Har jag inget alias för enheten, eller om det inte finns någonting kopplat till porten, så lämnar jag det andra värdet blankt.
(Av någon anledning vill inte forumet formatera koden korrekt i exemplet ovanför, så alla variabler hamnar i princip på samma rad.)
If $input[1] = "" Then
Return $input[0] Else
Return $input[1] EndIf
EndFunc
_optAlias är sedan en funktion som kontrollerar om det finns ett alias sparat för den ingången. Finns det ett alias så svarar _optAlias med namnet på prylen, och om det inte finns ett alias sparat så svarar funktionen istället med namnet på porten. Byter jag port på någonting behöver jag alltså bara ändra det på ett ställe i koden, så uppdateras menynamnet automatiskt.
Så här ser det sedan ut i praktiken:
Att bara skapa menyerna räcker dock inte, utan det behövs även en metod för att programmet ska veta vad det ska göra när jag klickar på en knapp. Det gör jag genom att lägga till en switch-sats i samma funktion som gränssnittet:
Switch TrayGetMsg()
Case $YamahaIPower
_TogglePower()
Case $iMute
_ToggleMute()
Case $HueToggle
_ToggleHue()
Case $iHDMI1
_SetInput("HDMI1")
Case $iHDMI2
_SetInput("HDMI2")
Case $iHDMI3
_SetInput("HDMI3")
Case $iHDMI4
_SetInput("HDMI4")
Case $iHDMI5
_SetInput("HDMI5")
Case $iAV1
_SetInput("AV1")
Case $iAV2
_SetInput("AV2")
Case $iAV3
_SetInput("AV3")
Case $iAV4
_SetInput("AV4")
Case $iAV5
_SetInput("AV5")
Case $iAV6
_SetInput("AV6")
Case $iVAUX
_SetInput("V-AUX")
Case $iAUDIO1
_SetInput("AUDIO1")
Case $iAUDIO2
_SetInput("AUDIO2")
Case $idQuit
ExitLoop
EndSwitch
WEnd
Koden berättar helt enkelt vad som ska hända när en knapp aktiveras, och koden loopar tills dess att man trycker på Quit-knappen, vilket går ur loopen så att programmet körs till sin botten och avslutas.
Nu kan jag kompilera programmet till en körbar .exe-fil som sedan startas automatiskt varje gång jag loggar in i Windows, och som alltid ligger lättåtkomligt i aktivitetsfältet 🙂
Next up: Apple-prylarna
Nu känner jag mig förhållandevis nöjd med programmet till Windows, och det gör merparten av det jag velat från början. Det som fortfarande ska läggas till är olika profiler för lamporna - i nuläget kan jag bara tända och släcka - och en inställningspanel så att jag kan lägga till nya alias på prylarna utan att behöva gå in i koden över huvud taget. Men det är någonting som får vänta till ett lite senare skede. Nu har jag fått blodad tand, och vill testa någonting lite mer djupgående.
I början av inlägget nämnde jag att projektet spårat ur en aning, vilket det gjort i den bemärkelsen att programbyggandet gått en bra bit bortom att bara styra förstärkaren via terminalen och automatiska script. Nästa utmaning är att göra ett eget fjärrkontrollsprogram även till Macen, så att jag inte behöver använda terminalen alls, och att därefter göra en widget till telefonen så att jag inte behöver öppna Yamahas egen fjärrkontrollsapp varje gång jag ska starta eller stänga av förstärkaren.
För att bygga gränssnitt till MacOS och iOS kommer jag därför behöva använda mig av mer djupgående språk som Swift snarare än scriptspråk som Bash eller Autoit. Det kommer jag gå in närmare på i nästa uppdatering.
1 Guest(s)
