IR Blaster - prosty, uniwersalny pilot na podczerwień integrowany z Internetem Rzeczy

Poniedziałek, 01 Sierpień 2022

Kiedy oglądamy telewizję, szczególnie w grupie kilku osób, bardzo często zdarza się, że pilot od telewizora staje się... niewidzialny. To małe urządzenie potrafi zniknąć gdzieś w czeluściach kanapy, pod poduszką, za meblem i potrafi się bardzo skutecznie ukrywać. Zaprezentowany w artykule projekt jest bardzo ciekawym rozwiązaniem tego problemu i w dodatku korzysta z technologii IoT – za pomocą prostej aplikacji integruje się z domowym asystentem, takim jak Google Home czy Amazon Alexa.

Celem opisanego projektu było skonstruowanie urządzenia, które może zmieniać kanały telewizyjne i będzie sterowane za pomocą poleceń głosowych wydawanych domowemu asystentowi, takiemu jak Google Home lub Alexa. W ten sposób powstał IR Blaster – urządzenie z dziedziny IoT, którym można sterować za pomocą aplikacji Blynk i poleceń głosowych z całego świata.

Opracowana aplikacja została dostosowana do konkretnego dekodera, jakiego używa autor konstrukcji, jednak nic nie stoi na przeszkodzie, aby przygotować uniwersalne urządzenie, które będzie sterowało wszystkimi urządzeniami korzystającymi z pilota na podczerwień za pomocą poleceń głosowych.

Potrzebne elementy

Zaprezentowany system od strony sprzętowej jest dosyć prosty. Do zbudowania IR Blastera potrzebne będą trzy moduły:

płytka z ESP8266 lub ESP32, wspierana w ekosystemie Arduino IDE,
dioda podczerwona o maksimum emisji przypadającym na ok. 940 nm, aby była wykrywana przez czujniki w telewizorach itp.,
odbiornik podczerwieni TSOP1738.

Oprócz powyższych modułów potrzebne będzie jeszcze źródło zasilania dla modułu z mikrokontrolerem ESP, przewody do podłączenia diody i odbiornika oraz przewód mikroUSB do podłączenia mikrokontrolera do komputera, aby go zaprogramować.

Zasada działania pilota

Zasada działania systemu jest bardzo prosta. Zasadniczo system omawiany w tym artykule składa się z dwóch elementów – systemu komunikacji w podczerwieni, który jest odpowiedzialny za komunikację z telewizorem oraz systemu, który komunikuje się z usługami w sieci. Ich integrację zapewnia mikrokontroler ESP32, obsługujący oba systemy.

Każdy przycisk w pilocie ma inny kod. Kod wysyłany z pilota jest dekodowany przez odbiornik, który w odpowiedzi realizuje odpowiednią komendę. Generalnie każde urządzenie używa innego zestawu komend, więc w pierwszej kolejności konieczne jest zebranie komunikatów, jakie wysyła nasz pilot, aby móc je następnie skopiować i używać wraz z mikrokontrolerem.

Autor konstrukcji do tworzenia oprogramowania dla modułu z ESP używa edytora Arduino on-line, który jest dostępny pod adresem: https://create.arduino.cc/editor. Aby z niego skorzystać, wystarczy założyć w portalu konto, pobrać specjalnego agenta, który zainstalowany na komputerze pozwoli na komunikację z płytką mikrokontrolera. Teraz wystarczy dodać tylko w menedżerze bibliotek IRREMOTEESP8266 do ulubionych i już mamy dostęp do wszystkich potrzebnych elementów. Programy te są również dostępne w repozytorium na GitHubie.

Zbieranie komunikatów

W pierwszej kolejności musimy zarejestrować komendy wysyłane przez naszego pilota w podczerwieni. W tym celu zastosujemy odbiornik podczerwieni typu TSOP1738, podłączony do naszego mikrokontrolera w sposób pokazany na rysunku 1.

Rysunek 1. Schemat układu do odbierania kodów z pilota

Do sterowania tym prostym układem wystarczy skrypt z listingu 1.

Listing 1. Szkic Arduino, który odbiera kody z pilota i prezentuje je w konsoli szeregowej

#include <Arduino.h>
#include <IRremoteESP8266.h>
#include <IRrecv.h>
#include <IRutils.h>

#ifdef ARDUINO_ESP32C3_DEV
// Wykorzystanie pinu 14 na ESP32-C3 uniemożliwia boot
const uint16_t kRecvPin = 10;
#else // ARDUINO_ESP32C3_DEV
const uint16_t kRecvPin = 14;
#endif // ARDUINO_ESP32C3_DEV

IRrecv irrecv(kRecvPin);
decode_results results;

void setup() {
Serial.begin(115200);
// Start the receiver
irrecv.enableIRIn();
// Wait for the serial connection to be establised.
while (!Serial)
   delay(50);
Serial.println();
Serial.print(“IRrecvDemo is now running and waiting for IR message”);
Serial.println(kRecvPin);
}

void loop() {
if (irrecv.decode(&results)) {
   serialPrintUint64(results.value, HEX);
   Serial.println(“”);
   irrecv.resume(); // Receive the next value
}
delay(100);
}

Po zbudowaniu układu i załadowaniu szkicu z listingu 1 do pamięci mikrokontrolera wystarczy uruchomić monitor portu szeregowego, aby odbierać komunikaty, które nadaje nasz pilot. Zapiszmy te wartości, gdyż potrzebne one nam będą w drugiej części projektu – systemu do wysyłania komunikatów.

Obsługa przez smartfona – integracja z innymi usługami

Zanim możliwe będzie wysyłanie komunikatów IR, konieczne jest skonfigurowanie usług w sieci, aby mogły one komunikować się z urządzeniem. Do tego posłuży aplikacja Blynk. Możemy zainstalować ją na naszym smartfonie i skonfigurować do przesyłania odpowiednich komend. Na rysunku 2 pokazano poszczególne elementy konfiguracji aplikacji w smartfonie.

Rysunek 2. Aplikacja Blynk na smartfona – konfiguracja

Po pobraniu i zainstalowaniu aplikacji Blynk możemy zalogować się do niej i utworzyć nowy projekt. W nim ustawiamy poszczególne elementy (za pomocą ikonki ze znakiem plusa). Dodajemy elementy STEP H oraz STEP V (patrz rysunek 2), dodajemy przyciski do wyciszania i inne. Następnie w każdym elemencie sterującym musimy wybrać pin V0 jako sterujący. Jest to wirtualny pin, który widoczny będzie w skrypcie Arduino (listing 2 w dalszej części artykułu). Konfigurujemy także kody, jakie przekazywane są do aplikacji na Arduino, które identyfikują, jaka wiadomość ma być wysłana poprzez podczerwień.

Listing 2. Skrypt sterujący pracą nadajnika (fragment)

#if defined(ESP8266)
#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>
#else
#include <WiFi.h>
#endif // ESP8266
#if defined(ESP32)
#include <BlynkSimpleEsp32.h>
#endif // ESP32
#include <IRremoteESP8266.h>
#include <IRsend.h>

// Pin GPIO ESP8266 używany do sterowania diodą.
const uint16_t kIrLed = 4;
// Konfiguracja pinu sterującego diodą IR
IRsend irsend(kIrLed);

char auth[] = "";     // Token autoryzacji Blynk.
char ssid[] = "";     // SSID sieci Wi-Fi.
// Hasło sieci Wi-Fi. Zostaw puste, jeśli sieć jest otwarta.
char pass[] = "";

void setup() {
irsend.begin();
#if ESP8266
   Serial.begin(115200, SERIAL_8N1, SERIAL_TX_ONLY);
#else // ESP8266
   Serial.begin(115200, SERIAL_8N1);
#endif // ESP8266
Blynk.begin(auth, ssid, pass);
}

BLYNK_WRITE(V0) {
   if (param.asInt() == 1) {
     Serial.println("starplus");
     irsend.sendNEC(0x80BF49B6);
     delay(1000);
     irsend.sendNEC(0x80BFE11E);
     delay(1000);
     irsend.sendNEC(0x80BF49B6);
     delay(1000);
   }
   else if (param.asInt()==19) {
     Serial.println("VOLUME-");
     irsend.sendNEC(0x80BF31CE);
   }
   else if (param.asInt()==20) {
     Serial.println("VOLUME+");
     irsend.sendNEC(0x80BFBB44);
   }
   else if (param.asInt()==21) {
     Serial.println("MUTE");
     irsend.sendNEC(0x80BF39C6);
   }
}

void loop() {
Blynk.run();
}

W aplikacji generujemy także tzw. token autoryzacji, jaki będzie nam potrzebny, aby aplikacja na Arduino mogła połączyć się z serwerem Blynk w chmurze. Token ten musimy zapisać i następnie przekopiować do skryptu (listing 2).

Wysyłanie komunikatów

Do sterowania telewizorem używane jest proste urządzenie, którego schemat został pokazany na rysunku 3. Do modułu z mikrokontrolerem podłączona jest dioda LED, pracująca jako nadajnik podczerwieni. Generowanie samych sygnałów jest realizowane programowo, co upraszcza cały układ.

Rysunek 3. Schemat nadajnika podczerwieni

Na listingu 2 pokazany jest skrypt, który steruje pracą nadajnika. Szkic Arduino należy uzupełnić danymi do logowania do lokalnej sieci Wi-Fi (SSID oraz hasło) oraz tokenem autoryzacji, zapisanym w zmiennej auth.

Jak każdy program Arduino, ten także zawiera sekcję setup() oraz loop(). Pierwsza z nich konfiguruje dwa elementy:

uruchamia nadajnik podczerwieni – irsend.begin()
oraz konfiguruje połączenie z Blynk – Blynk.begin(auth, ssid, pass).

Z kolei sekcja nieskończonej pętli uruchamia tylko aplikację Blynk – Blynk.run().

Kluczowa część aplikacji, opisująca logikę sterowania, znajduje się w funkcji BLYNK_WRITE(V0), gdzie V0 to skonfigurowany przez nas wcześniej wirtualny pin, który sterowany jest za pomocą Blynk. Dla uproszczenia pominięto w funkcji na listingu 2 większą część definicji funkcji, a pozostawiono tylko trzy przykładowe wpisy. Metoda param.asInt() zwraca parametr ustawiony w Blynk, który definiuje, jaki komunikat ma być uruchomiony, dlatego też to ona decyduje, jaki komunikat zostanie wysłany za pomocą metody irsend.sendNEC(x), gdzie x to wartość wysyłanego komunikatu w postaci liczby 32-bitowej, zapisanej heksadecymalnie.

Integracja asystenta Google

Finalnym krokiem jest zintegrowanie systemu z asystentem Google, aby w ten sposób możliwe było sterowanie naszym urządzeniem. Jedną z metod jest usługa IFTTT – If This Then That, która pozwala łączyć ze sobą różne wydarzenia i budować proste mechanizmy automatyki, pracujące w chmurze.

Rysunek 4. Konfiguracja aplikacji IFTTT

Na rysunku 4 pokazano, w jaki sposób skonfigurować to, aby asystent Google, po wychwyceniu słowa kluczowego/polecenia, uruchamiał poprzez REST-owe API Blynka nasz wirtualny pin V0.

Automatykę w IFTTT możemy skonfigurować w aplikacji IFTTT na smartfona. Po pobraniu i zainstalowaniu aplikacji możemy zarejestrować się w IFTTT i utworzyć pierwsze z poleceń. Wybieramy polecenie, jakiego chcemy użyć – jest to if, a następnie wyszukujemy asystenta Google. Wybieramy zdanie, jakie ma być wypowiedziane i tworzymy (jako then) tzw. webhook. Webhook jest to wywołanie, korzystające z interfejsu REST. W tym przypadku korzystamy z API Blynka, dlatego też musimy wpisać związane z nim dane:

adres: http://188.166.206.43/TWÓJ TOKEN UWIERZYTELNIANIA BLYNK/update/V0,

metoda: PUT,

typ treści > application/json,

treść > ["Dodaj wartość swojego kanału"].

W ten sposób skonfigurowaliśmy jedno polecenie, analogicznie postępujemy dla pozostałych, konfigurując poszczególne połączenia. Dzięki IFTTT możliwe jest ich zintegrowanie nie tylko z asystentem Google, ale także szeregu innych usług, między innymi Amazon Alexa itp.

Podsumowanie

Teraz można już przetestować swój zdalny nadajnik podczerwieni, korzystający z usług IoT, sterując nim za pomocą aplikacji Google Assistant/Blynk. Autor pracuje obecnie nad bardziej uniwersalną konstrukcją, ale nic nie stoi na przeszkodzie, aby konstrukcja ta była inspiracją dla któregoś z czytelników. Zaprezentowane w artykule urządzenie pokazuje ogromne możliwości współczesnych systemów Internetu Rzeczy – wystarczy proste urządzenie z połączeniem z Internetem, aby realizować nawet bardzo złożone funkcje. Można zintegrować układ z jeszcze bardziej zaawansowaną automatyzacją i przełączać kanały automatycznie, wyłączać i włączać telewizor o zadanych godzinach itp. Z pewnością da się wymyślić jeszcze bardziej złożone algorytmy sterowania, które komuś się przydadzą.

Nikodem Czechowski, EP

Źródła: