Wszystkie fazy projektu: Mój AmbientLight

Faza 2

W tej fazie planuję uniezależnić się od kupnego sterownika LED i przeprowadzić pierwsze eksperymenty z podświetleniem ekranu. Pomysł polega na podłączeniu taśmy LED do niezależnego kontrolera. Opcji jest kilka:

Bezpośrednio do Raspberry: kuszące, ale może będzie inna opcja…
Do Arduino a potem 'jakoś’ do Raspberry – tanie, choć nie wiem czy Arduino się wyrobi, no i trzeba je jakoś podłączyć do Raspberry…
Do ESP8266… hmm – WiFi za darmo…

Podświetlenie telewizora ma być jednym z komponentów projektowanego przeze mnie systemu multimedialnego. Jego centralnym elementem ma być Raspberry Pi z OSMC. W tej roli Raspberry będzie miało co robić. Postanowiłem więc wyizolować zarządzanie diodami do zewnętrznego układu.

ESP jest bardzo atrakcyjne, ale po ostatnich doświadczeniach z NodeMCU i LUA – zrezygnowałem z niego. Jego główną zaletą jest wbudowane WiFi. Ta opcja nie będzie mi jednak przydatna. Zdecydowałem się na Arduino UNO. To chyba najtańsza opcja:)

Pomysł przedstawia się następująco:

Połączę Raspberry z Arduino kablem USB;
Raspberry (OSMC + Hyperion) generuje instrukcje sterowania w standardzie pi-blaster i wysyła ja na port szeregowy (przez USB);
Szkic na Arduino odbierze dane z Raspberry i wygeneruje sygnał PWM dla poszczególnych kanałów diod.

Jest kilka sposobów na połączenie Raspberry z Arduino. USB jest najbezpieczniejszy. Nie musicie martwić się o poziomy napięć (RPi to 3,3v a Arduino 5v). Jedynym minusem jest 'kapryśność’ połączenia szeregowego.

Schemat blokowy takiego rozwiązania wygląda więc tak:

Zwróćcie uwagę, że nie mogę podłączyć Arduino bezpośrednio do taśmy LED. Nie będzie ono w stanie przenieść wymaganej mocy. Zastosuję więc zestaw tranzystorów, które będzie przełączać Arduino.
Do wykonania takiego układu wystarczy dosłownie kilka elementów:

Arduino UNO R3 lub klon;
Płytka rozwojowa dla Arduino;
3xTranzystor IRLZ34N (lub inny N-MOSFET o podobnych parametrach);
3xRezystory 1kΩ;
Kabel USB;
Raspberry Pi:)

Schemat (na podstawie blogu popoklopsi i dyskusji na electronics-exchange):

Jeżeli chodzi o konfigurację OSMC pod Hyperiona: wszystko opisano dokładnie na tym blogu. Jedyna różnica polega na tym, że dane zamiast na /dev/pi-blaster wysyłane będą na /dev/ttyACM0 – czyli Arduino podłączone do Raspberry za pomocą USB .

Pozostało skleić płytkę:

Płytka do sterowania taśmą LED przez Arduino

Następnie Arduino wylądował na płytce z LED’ami:

I w końcu z tyłu telewizora:

Cóż – wieczorem testy!

Testy

Pierwszy błąd w projekcie znalazłem… przypadkiem. Zaczęło się od całkiem innego tematu nie związanego bezpośrednio z taśmami LED, ale generowaniem sygnału PWM. Bawiłem się z pewnym doświadczonym przez użytkownika Leonardo, który generował dość dziwne przebiegi PWM:

Potem zacząłem porównywać przebiegi generowane na różnych portach różnych Arduino. Co ciekawe… okazało się, że mogą mieć różną częstotliwość…Powyższy wykres pokazuje przebieg PWM ustawiony na pinie 3 (żółty) i 5 (niebieski) za pomocą instrukcji analogWrite(). Okazuje się, że o ile na pinie 3 ma on częstotliwość 460Hz – na pinie 5 była ona 2 razy większa!

Gdy doczytałem, okazało się, że jest to zachowanie całkowicie normalne:

The frequency of the PWM signal on most pins is approximately 490 Hz. On the Uno and similar boards, pins 5 and 6 have a frequency of approximately 980 Hz. Pins 3 and 11 on the Leonardo also run at 980 Hz.

Oczywiście (jak na złość) użyłem pinów 3, 6, 9. Czyli mam je do przelutowania:)

Rozszerzenia…

Pierwszą z modyfikacji, którą wykonałem, było dodanie przekaźnika. Masa z zasilacza LED (12v) idzie jak poprzednio – do Arduino. Plus idzie na wejście przekaźnika i dalej – przez normalnie otwarte (NO) wyjście przekaźnika do płytki Arduino.

Sam przekaźnik zasilony jest z 5v Arduino. Jego pin sterujący (IN) podłączyłem do pinu D12 Arduino. W ten sposób wystawiając sygnał wysoki na pin D12 – włączam zasilanie diod; stan niski – wyłącza diody.

Format danych pi-blaster

W tym projekcie będę się posługiwał formatem danych jak dla oprogramowania pi-blaster. Pi-blaster to narzędzie dla Raspberry, które umożliwia generowanie sygnału PWM (na dowolnym z pinów). Składnia jest bardzo prosta:

Podajemy numer GPIO, na który ma być wysłana informacja;
Znak „=”;
Podajemy jasność z zakresu 0..1, gdzie 1 to maksymalne świecenie a 0 to wygaszenie.

Stąd np. „17=1.0” wygeneruje na pinie 17 (BCM) sygnał o stopniu wypełnienia 100%.

Specyficzne…

Jednym z ostatnich dodatków w projekcie było rozszerzenie płytki na telewizorze o przekaźnik. Przekaźnik sterowany jest z Arduino i umożliwia odłączenie oświetlenia, gdy nie jest potrzebne.

W związku z tym zmodyfikowałem trochę protokół rozszerzając go o możliwość „nadpisania” rozkazów przychodzących z hyperiona. Zamiast wiadomości jak powyżej, wystarczy wysłać: „ov=komenda.wartość”. „wartość” jest podawana dla spójności z oryginalnymi ramkami pi-blastera; nie używam jej.

Wtedy:

ov=1.0: włączenie przekaźnika (świeci),
ov=0.0: wyłączenie przekaźnika (nie świeci),
ov=17.0: pełny czerwony (w konfiguracji hyperiona kolor czerwony podłączyłem do GPIO17),
ov=22.0: pełny zielony (w konfiguracji hyperiona kolor zielony podłączyłem do GPIO22),
ov=24.0: pełny czerwony (w konfiguracji hyperiona kolor zielony podłączyłem do GPIO24),
ov=255.0: wyłączenie trybu nadpisywania (wyświetlanie przejmuje z powrotem hyperion).

Oprogramowanie na Arduino

Oprogramowanie na Arduino ma za zadanie:

Odebrać dane po USB z Raspberry,
Sparsować jasności dla poszczególnych kanałów kolorów,
Wysterować odpowiednie wyjścia, do których podłączone są tranzystory.

Kod pi_blaster_parser dla Arduino znajdziecie na githubie.

Oprogramowanie dla Raspberry

Arduino połączyłem z Raspberry kablem USB. Arduino pojawiła się w linuxie jako nowe urządzenie typu port szeregowy „/dev/ttyAMA0”. Postanowiłem sprawdzić działanie programu na Arduino za pomocą prostego skryptu w Pythonie.

W tym celu pobrałem na Raspberry pakiet pyserial.

$ tar -xzf pyserial-2.6.tar.gz 
$ cd pyserial-3.0.1
$ sudo python setup.py install

$ tar -xzf pyserial-2.6.tar.gz

$ cd pyserial-3.0.1

$ sudo python setup.py install

Prosty (i brzydki) program w Pythonie powinien zapalić nam podświetlenie:

import serial

ser = serial.Serial("/dev/ttyACM0")
ser.baudrate = 9600
ser.bytesize = serial.EIGHTBITS
ser.parity = serial.PARITY_NONE
ser.stopbits = serial.STOPBITS_ONE

while 1:
  ser.write("22=1.0\r\n")
  ser.write("17=1.0\r\n")

import serial

ser = serial.Serial("/dev/ttyACM0")

ser.baudrate = 9600

ser.bytesize = serial.EIGHTBITS

ser.parity = serial.PARITY_NONE

ser.stopbits = serial.STOPBITS_ONE

while 1:

ser.write("22=1.0\r\n")

ser.write("17=1.0\r\n")

Teraz zacząłem instalację oprogramowania Hyperion. Oprogramowanie to jest dedykowane do rozwiązań typu ambientlight. Analizuje to, co jest wysyłane na ekran i w zależności od sceny – dobiera jasności i kolory diod podświetlenia.

Do instalacji hyperiona będziecie potrzebowali praw root’a. Dla nowo zainstalowanego linuxa może być nie ustawione. Ustawcie je komendą:

$ sudo passwd root

1	$ sudo passwd root

Teraz podajcie nowe hasło.

Do instalacji Hyperion’a na Raspberry wystarczy wpisać:

$ su
$ wget -N https://raw.github.com/tvdzwan/hyperion/master/bin/install_hyperion.sh
$ chmod +x /home/osmc/install_hyperion.sh
$ sudo sh ./install_hyperion.sh

$ su

$ wget -N https://raw.github.com/tvdzwan/hyperion/master/bin/install_hyperion.sh

$ chmod +x /home/osmc/install_hyperion.sh

$ sudo sh ./install_hyperion.sh

Kluczową sprawą jest odpowiedni plik konfiguracyjny: /opt/hyperion/config/hyperion.config.json. Jego zawartość w moim przypadku wygląda tak:

{
  "device" :
  {
    "name"  : "MyPi",
    "rate":"9600",
    "type"  : "piblaster",
    "output"  : "/dev/ttyACM0",   // This is the pi-blaster fifo to write to
    "gpiomap"  :
    [
      { "gpio" : 17, "ledindex" : 0, "ledcolor" : "r" },   // GPIO 4 gets the red component of hyperion led 0
      { "gpio" : 22, "ledindex" : 0, "ledcolor" : "g" },   // GPIO17 gets the green component of hyperion led 0
      { "gpio" : 24, "ledindex" : 0, "ledcolor" : "b" }   // GPIO18 gets the blue component of hyperion led 0
    ]
 },

  "color" :
  {
    "smoothing" :
    {
      "type"            : "linear", 
      "time_ms"         : 200,
      "updateFrequency" : 20.0000,
      "updateDelay"     : 0
    }

  },

   "framegrabber" :
   {
     "width" : 64,
     "height" : 64,
     "frequency_Hz" : 10.0,
     "priority" : 890
   },

   "jsonServer" :
   {
      "port" : 19444
   },

   "leds" :
   [
     {
       "index" : 0,
       "hscan" : { "minimum" : 0.5000, "maximum" : 0.5625 },
       "vscan" : { "minimum" : 0.9200, "maximum" : 1.0000 }
      }
   ],

   "endOfJson" : "endOfJson"
}

{

"device" :

{

"name" : "MyPi",

"rate":"9600",

"type" : "piblaster",

"output" : "/dev/ttyACM0", // This is the pi-blaster fifo to write to

"gpiomap" :

[

{ "gpio" : 17, "ledindex" : 0, "ledcolor" : "r" }, // GPIO 4 gets the red component of hyperion led 0

{ "gpio" : 22, "ledindex" : 0, "ledcolor" : "g" }, // GPIO17 gets the green component of hyperion led 0

{ "gpio" : 24, "ledindex" : 0, "ledcolor" : "b" } // GPIO18 gets the blue component of hyperion led 0

]

"color" :

{

"smoothing" :

{

"type" : "linear",

"time_ms" : 200,

"updateFrequency" : 20.0000,

"updateDelay" : 0

}

"framegrabber" :

{

"width" : 64,

"height" : 64,

"frequency_Hz" : 10.0,

"priority" : 890

"jsonServer" :

{

"port" : 19444

"leds" :

[

{

"index" : 0,

"hscan" : { "minimum" : 0.5000, "maximum" : 0.5625 },

"vscan" : { "minimum" : 0.9200, "maximum" : 1.0000 }

}

"endOfJson" : "endOfJson"

}

Więcej o konfiguracji piBlaster dowiecie się tutaj: https://hyperion-project.org/wiki/pi-blaster

Już wkrótce: ciąg dalszy!

Koszty fazy 2

Materiały:

Arduino UNO R3 lub klon: 30 PLN (tutaj z 328 DIP)
Płytka rozwojowa dla Arduino: 15 PLN (aliexpress)
3xTranzystor IRLZ34N (lub inny N-MOSFET o podobnych parametrach): 7.5
3xRezystory 1kΩ: grosze
Śrubki fi2/16mm i dystanse 6mm: 6PLN
Kabelki połączeniowe: 2 PLN
Kabel USB: 8 PLN
Raspberry Pi: cóż – komplet ok. 250 PLN

Razem: niecałe 70 PLN (bez Raspberry)

Uzupełnienie

Instalacja pi-blaster:

$ sudo apt-get install build-essential
$ sudo apt-get install usbutils
$ sudo apt-get install automake
$ sudo apt-get install autoconf
$ sudo apt-get install git
$ git clone https://github.com/sarfata/pi-blaster.git
$ cd pi-blaster
$ ./autogen.sh
$ ./configure
$ make
$ sudo make install