logo elektroda
logo elektroda
X
logo elektroda
Adblock/uBlockOrigin/AdGuard mogą powodować znikanie niektórych postów z powodu nowej reguły.

Pilot uniwersalny z funkcją uczenia jako zamiennik uszkodzonego pilota

Gelip 01 Lis 2021 14:29 3831 8
REKLAMA
MediaMarkt Black Week
  • Co zrobić kiedy popsuł nam się oryginalny pilot tak, że nie działa część przycisków i nie pomaga czyszczenie i/lub wymiana gumek, nie chcemy kupować oryginału ani zamiennika tylko kupić od razu pilot uniwersalny, którym możemy zastąpić kilka pilotów?

    Kupując zamiennik nie ma 100% pewności iż będą działać wszystkie fukcje z oryginalnego pilota a uniwersalny - zwłaszcza starszy, tańszy może nie mieć w bazie naszego urządzenia lub mogą nie działać wszystkie przyciski, co właśnie mi się przydarzyło. Kupiłem pilot uniwersalny z funkcją uczenia. Niestety okazało się, iż nie ma on w bazie kodów do mojego urządzenia ale udało mi się go nauczyć działających przycisków z uszkodzonego pilota. No ale w tym momencie wyszło na to iż "Zamienił stryjek siekierkę na kijek" bo mam już drugi pilot w którym działa tylko ta sama część przycisków :| :|

    Pomyślałem iż nie będę znowu kupował innego pilota, nie mając 100% pewności czy zadziała z moim urządzeniem. Zastanawiałem się jakby tu nauczyć pilot brakujących przycisków - kody przycisków musimy skądś wziąć i czymś wysłać.

    I tu z pomocą przychodzi mój projekt: Arduino, dioda IR, dosłownie jeden rezystor 100om i kilka kabelków + płytka stykowa bo wybrałem wersję Arduino Nano (zlutowane goldpiny). Nie trzeba nawet żadnego mikroprzełącznika czy ATtiny a kody wysyłamy z poziomu konsoli szeregowej. Dodatkowo wykorzystałem jeszcze odbiornik IR TSOP 1736 aby odczytać wartości i protokół w jakim nadaje pilot oryginalny i wyszło mi iż to protokół NEC. Uważam iż schematu nie ma co zamieszczać bo zrobiłem wyraźne zdjęcie na którym wszystko widać:
    Prototyp na płytce stykowej z Arduino Nano i czujnikiem IR. Pilot uniwersalny z funkcją uczenia jako zamiennik uszkodzonego pilota Pilot uniwersalny z funkcją uczenia jako zamiennik uszkodzonego pilota

    No dobra ale skąd wziąć kody brakujących przycisków?

    Arduino jest na tyle popularne iż wielu użytkowników nagrało już takie kody i udostępnia je w Internecie w formacie HEX 32-bit unsigned integer np. 0x807F08F7 - a to za sprawą tego iż Arduino IDE zawiera przykładowe szkice do odbioru i wysyłania kodów w takim formacie.
    Wystarczy skopiować dany kod - nawet jak jest od innego przycisku, wysłać go przez Arduino do urządzenia, sprawdzić za jaką funkcję odpowiada w naszym urządzeniu a następnie nagrać sygnał pilotem uczącym.

    Niektórzy producenci udostępniają takie dane (format NEC) w tabelce np. w instrukcji serwisowej ale jako adres urządzenia i polecenie - ADDR, CMD np. 04 08
    W Internecie można też znaleźć dane przycisków wielu urządzeń w formacie LIRC, Pronto czy innym.

    Jest bardzo dobry konwerter sygnałów IR działający pod Javą - IR Scrutinizer. Potrafi on także wygenerować kod Pronto po podaniu danych ADDR, CMD a także eksportować go do innego formatu np. ICT który z kolei odczyta program IR Scope 2.01 w którym odczytamy wartość 32-bit unsigned int - patrz A=$xxxxxxxx w IRP Form:
    Pilot uniwersalny z funkcją uczenia jako zamiennik uszkodzonego pilota Pilot uniwersalny z funkcją uczenia jako zamiennik uszkodzonego pilota Pilot uniwersalny z funkcją uczenia jako zamiennik uszkodzonego pilota

    Dodano po 25 [minuty]:

    Na upartego znając parametr NEC ADDR wartość CMD przycisku można zgadnąć w ciemno:
    • w IrScrutinizer w menu Options -> Output Text Format wybieramy Pronto Hex ("CCF")
    • na zakładce Generate wybieramy Protocol: nec1, podajemy wartości D (ADDR) oraz F (CMD)
    • klikamy Generate i "To Scrutinize signal" po czym przechodzimy na zakładkę Scrutinize signal
    • klikamy Scrutinize, usuwamy 4 ostatnie wartości word xxxx xxxx xxxx xxxx na końcu i ponownie klikamy Scrutinize
    • zamieniamy czwartą wartość 0002 na 0000 i jeszcze raz na Scrutinize
    • eksportujemy kod do pliku ICT, otwieramy w IR Scope 2.01 i odczytujemy wartość A=$xxxxxxxx
    • za pomocą Arduino testujemy kod

    Fajne? Ranking DIY
    O autorze
    Gelip
    Poziom 35  
    Offline 
    Gelip napisał 4666 postów o ocenie 483, pomógł 288 razy. Jest z nami od 2003 roku.
  • REKLAMA
    MediaMarkt Black Week
  • #2 19690634
    mpier
    Poziom 29  
    Witam,
    bardzo przekombinowałeś z tymi kodami i konwerterami. Przecież cały ten kod składa się jedynie z adresu i polecenia (ADDR, CMD). U Ciebie na pierwszym zdjęciu odpowiednio 128 i 08 (Hex: 80 i 08). Tu masz "generator poleceń": 0, 1, 2, ..., 255.

    Pozdrawiam.

    Dodano po 2 [godziny] 11 [minuty]:

    Raczej 1 i 16 (Hex: 01 i 10), jeśli dany kod to gotowy ciąg do wysłania. Na jedno wychodzi.
  • REKLAMA
    MediaMarkt Black Week
  • #3 19691039
    Gelip
    Poziom 35  
    @mpier
    Nic nie przekombinowałem. To są tylko zdjęcia poglądowe IR Scrutinizer aby pokazać co potrafi. Ten program nie był mi w zasadzie do niczego potrzebny bo kody w formacie 32-bit unsigned int 0x807Fxxxx dla Arduino znalazłem w Internecie.

    Przy okazji bardzo dużo nauczyłem się o IR. Kod IR może być w wielu formatach - to zależy od oprogramowania - ADDR + CMD, RAW, Pronto czy 32-bit unsigned int w którym Arduino ma szkice w bibliotece IRRemote.
    mpier napisał:
    Tu masz "generator poleceń": 0, 1, 2, ..., 255.
    Jaki generator, gdzie???

    A czym miałbym niby wysłać ten kod do urządzenia czy mojego pilota uniwersalnego z funkcją uczenia ??? Są zapewne jakieś nadajniki na RS-232 czy na USB ale ja wybrałem Arduino + płytka stykowa.

    Oczywiście na Arduino też znalazłem generator kodu w postaci ADDR + CMD ale na ATtiny (pierwszy link do YT - TinyRemote):
    Czy do tych projektów ATTiny wystarczy kupić Arduino Nano?
    Pilot uniwersalny z funkcją uczenia jako zamiennik uszkodzonego pilota

    ale to dodatkowa robota bo trzeba kupić ATtiny, sklecić 4-ro przyciskowy nadajnik i programować od nowa dla 4 przycisków - nie praktyczne w moim przypadku bo musiałbym kilka razy programować kolejne 4 przyciski a tak to napisałem sobie szkic, który działa z samym Arduino i wystarczy podać kod w konsoli i nie trzeba wgrywać za każdym razem innego szkicu dla innego przycisku:
    Pilot uniwersalny z funkcją uczenia jako zamiennik uszkodzonego pilota

    Dodano po 10 [minuty]:

    Priorytetem w tym artykule jest szybka nauka pilota uniwersalnego - kładę pilot na przeciwko diody IR w Arduino w odleglości 1 cm, w notatniku mam spisane wszystkie kody przycisków i po kolei kopiuje, wklejam w Serial Monitor w Arduino IDE i nagrywam je w pilocie - raptem 5 minut roboty.

    Dodano po 7 [minuty]:

    W tabelce kody w formacie Arduino HEX oraz ADDR CMD.

    Spoiler:
    ADDR = adres urządzenia 01

    Arduino HEXData (CMD)Name
    807F807F01STANDBY
    807F40BF02MUTE
    807FC03F03FAVOURITE albo 807F0EF1 (IRDA z Remocon)
    807FA05F05AUDIO
    807F609F06TTX
    807FE01F07SUBTITLE
    807F10EF08EPG
    807F906F09TV/RADIO
    807F08F710CH+ (Up)
    807F887711CH- (Down)
    807F48B712VOL+ (Right)
    807FC83713VOL- (Left)
    807F28D714PLAY
    807FA85715REPEAT
    807F689716BLUE (Planowane nagrywanie)
    807FE81717PAUSE (Time Shift Play/Pause lub Play/Pause odtwarzacz)
    807F18E718STOP
    807F38C71cREV
    807FB8471dFWD
    807F78871ePREV
    807FF8071fNEXT
    807F50AF0aMENU
    807FD02F0bEXIT
    807F30CF0cINFO
    807FB04F0dRECALL (Back)
    807FF00F0fOK (Lista kanałów)
    807F02FD400
    807F827D411
    807F42BD422
    807FC23D433
    807F22DD444
    807FA25D455
    807F629D466
    807FE21D477
    807F12ED488
    807F926D499
    807F52AD4aGOTO
    807F8A7551RED
    807F4AB552GREEN (Przełącza rozdzielczość ekranu)
    807FCA3553YELLOW (Przełącza format obrazu)
    807FAA5555PAGE+
    807F6A9556PAGE-
    807FEA1557PVR
    807F1AE558REC
    807F867961Muzyka z USB
    807F46B962Restart
    807FC63963Pokazuje CVBS (format dźwięku)
    807F26D964Pokazuje RGB (format obrazu)
    807FA65965Pokazuje 16:9 (rozdzielczość obrazu)
    807F6699664:3 Full
    807F0EF170Przewodnik instalacji (domyślne ustawienia - kasuje listę programów)
    807FFF00ffChyba znak zapytania TXT i PVR USB
  • #4 19691626
    mpier
    Poziom 29  
    Chodziło mi tylko o sposób generowania "w formacie HEX 32-bit unsigned integer np. 0x807F08F7". Kod NEC u Ciebie to cztery bajty: (ADDR),(~ADDR),(CMD),(~CMD). Symbol ~ to negacja bitowa. Dla "ułatwienia" bity w powyższych bajtach zapisane są w odwrotnej kolejności.
    Przykład dla ADDR = 0x01, CMD = 0x10, czyli u Ciebie CH+:
    0x01, 0xFE, 0x10, 0xEF.
    Bity w bajtach w odwrotnej kolejności:
    0x80, 0x7F, 0x08, 0xF7.
    Kod w całości:
    0x807F08F7.
    Teraz generujesz wszystkie możliwe kody dla danego adresu: 0, 1, 2, ..., 255, wysyłasz i jeśli któryś Ci pasuje zapisujesz do pilota. Może być tak: ENTER wysyła kolejny kod a SPACJA wysyła jeszcze raz ten sam, tym razem do pilota. Dziwne, że biblioteka sama tego nie robi.
  • #5 19692091
    Gelip
    Poziom 35  
    mpier napisał:
    Teraz generujesz wszystkie możliwe kody dla danego adresu: 0, 1, 2, ..., 255, wysyłasz i jeśli któryś Ci pasuje zapisujesz do pilota.

    Ale czym mam to wygenerować i czym wysłać? Ja wiem, że są protokoły NEC, Panasonic, Sony i inne ale po co mi to jak Arduino ma gotowy szkic bazujący na danych 32-bit integer.
  • #6 19693471
    mpier
    Poziom 29  
    Nie znam Arduino, ale wysyłasz tak samo jak teraz:
    Kod: C / C++
    Zaloguj się, aby zobaczyć kod
    Efekt:
    Pilot uniwersalny z funkcją uczenia jako zamiennik uszkodzonego pilota
  • #7 19693609
    Gelip
    Poziom 35  
    @mpier
    mpier napisał:
    Nie znam Arduino, ale wysyłasz tak samo jak teraz:

    Błąd kompilacji:
    'cp' was not declared in this scope


    Dodano po 27 [minuty]:

    Dobra chyba wiem o co chodzi. To o czym piszesz faktycznie jest możliwe ale wymaga biblioteki IRRemote w wersji 3.x a ja używam 2.0.1 ze względu na to: Arduino Nano i błąd kompilacji

    Dodano po 3 [minuty]:

    https://github.com/Arduino-IRremote/Arduino-IRremote

    Features of the 3.x version

    No more need to use 32 bit hex values in your code. Instead a (8 bit) command value is provided for decoding (as well as an 16 bit address and a protocol number).

    Dodano po 1 [godziny] 20 [minuty]:

    To rozumiem:
    mpier napisał:
    Przykład dla ADDR = 0x01, CMD = 0x10, czyli u Ciebie CH+:
    0x01, 0xFE, 0x10, 0xEF.

    ale skąd z powyższego wyszło Ci to ???:
    mpier napisał:
    Bity w bajtach w odwrotnej kolejności:
    0x80, 0x7F, 0x08, 0xF7.
    Kod w całości:
    0x807F08F7.

    Przecież ADDR dla całego pilota jest ten sam 01 a tylko inne CMD dla przycisków. Coś chyba mieszasz i ten adres 32-bit integer to nie jest żadna odwrotność ADDR,CMD

    Dodano po 7 [minuty]:

    Kod 32 int np. przycisku REC 807F1AE5 to negacja liczb ale nie ADDR, CMD bo ADDR=01, CMD=58. Negacja to by było 01FE58A7
  • #8 21186025
    Gelip
    Poziom 35  
    Jak przerobić kod aby wspierał inny protokół IR a mianowicie NIKAI ? Dostałem stary TV THOMSON bez pilota. Próbowałem użyć dwóch pilotów uniwersalnych ale nie znajdują kodu. W necie znalazłem ogromną bazę danych kodów pilotów do Arduino - ponad 500 pilotów, którą można użyć w projekcie IResp - pilot IoT na ESP-01s i są tam kody do pilota THOMSON w formacie NIKAI - strona 444 w bazie danych IR_DATABASE_TV(STB).pdf
    Zdjęcie pilota do telewizora Thomson z kodami protokołu NIKAI.
    W artykule jest sketch dla Arduino, który chyba trzeba wgrać do modułu ESP-01s.
    Znalazlem w necie taki plik:
    https://github.com/crankyoldgit/IRremoteESP8266/blob/master/src/ir_Nikai.cpp
    // Copyright 2009 Ken Shirriff
    // Copyright 2017 David Conran
    
    /// @file
    /// @brief Nikai
    /// @see https://github.com/crankyoldgit/IRremoteESP8266/issues/309
    
    // Supports:
    //   Brand: Nikai,  Model: Unknown LCD TV
    
    #include <algorithm>
    #include "IRrecv.h"
    #include "IRsend.h"
    #include "IRutils.h"
    
    // Constants
    const uint16_t kNikaiTick = 500;
    const uint16_t kNikaiHdrMarkTicks = 8;
    const uint16_t kNikaiHdrMark = kNikaiHdrMarkTicks * kNikaiTick;
    const uint16_t kNikaiHdrSpaceTicks = 8;
    const uint16_t kNikaiHdrSpace = kNikaiHdrSpaceTicks * kNikaiTick;
    const uint16_t kNikaiBitMarkTicks = 1;
    const uint16_t kNikaiBitMark = kNikaiBitMarkTicks * kNikaiTick;
    const uint16_t kNikaiOneSpaceTicks = 2;
    const uint16_t kNikaiOneSpace = kNikaiOneSpaceTicks * kNikaiTick;
    const uint16_t kNikaiZeroSpaceTicks = 4;
    const uint16_t kNikaiZeroSpace = kNikaiZeroSpaceTicks * kNikaiTick;
    const uint16_t kNikaiMinGapTicks = 17;
    const uint16_t kNikaiMinGap = kNikaiMinGapTicks * kNikaiTick;
    
    #if SEND_NIKAI
    /// Send a Nikai formatted message.
    /// Status: STABLE / Working.
    /// @param[in] data The message to be sent.
    /// @param[in] nbits The number of bits of message to be sent.
    /// @param[in] repeat The number of times the command is to be repeated.
    void IRsend::sendNikai(uint64_t data, uint16_t nbits, uint16_t repeat) {
      sendGeneric(kNikaiHdrMark, kNikaiHdrSpace, kNikaiBitMark, kNikaiOneSpace,
                  kNikaiBitMark, kNikaiZeroSpace, kNikaiBitMark, kNikaiMinGap, data,
                  nbits, 38, true, repeat, 33);
    }
    #endif  // SEND_NIKAI
    
    #if DECODE_NIKAI
    /// Decode the supplied Nikai message.
    /// Status: STABLE / Working.
    /// @param[in,out] results Ptr to the data to decode & where to store the result
    /// @param[in] offset The starting index to use when attempting to decode the
    ///   raw data. Typically/Defaults to kStartOffset.
    /// @param[in] nbits The number of data bits to expect.
    /// @param[in] strict Flag indicating if we should perform strict matching.
    bool IRrecv::decodeNikai(decode_results *results, uint16_t offset,
                             const uint16_t nbits, const bool strict) {
      if (strict && nbits != kNikaiBits)
        return false;  // We expect Nikai to be a certain sized message.
    
      uint64_t data = 0;
    
      // Match Header + Data + Footer
      if (!matchGeneric(results->rawbuf + offset, &data,
                        results->rawlen - offset, nbits,
                        kNikaiHdrMark, kNikaiHdrSpace,
                        kNikaiBitMark, kNikaiOneSpace,
                        kNikaiBitMark, kNikaiZeroSpace,
                        kNikaiBitMark, kNikaiMinGap, true)) return false;
      // Success
      results->bits = nbits;
      results->value = data;
      results->decode_type = NIKAI;
      results->command = 0;
      results->address = 0;
      return true;
    }
    #endif  // DECODE_NIKAI
    


    Czy da się tego użyć w Arduino bez modułu ESP - na moim pilocie na płytce stykowej gdzie jest nadajnik IR którego teraz używam do wysyłania kodów NEC używając takiego sketcha:
    #include <IRremote.h>
    
    IRsend irsend;
    
    void setup() {
      // put your setup code here, to run once:
      Serial.begin(9600);
      Serial.print("Enter code: ");
    }
    
    void loop() {
      // put your main code here, to run repeatedly:
    String code = Serial.readString();
      const char* string1 = code.c_str();
      unsigned long int w = strtoul(string1, NULL, 16);
      if(code != ""){
        irsend.sendNEC(w, 32);
        Serial.println(code + " code sent");
        Serial.print("Enter code: ");
        delay(500);
      }
      delay(50);
    }
    


    bo chyba nie wystaczy zmienić irsend.sendNEC na irsend.sendNikai
    Prototyp na płytce stykowej z Arduino Nano i czujnikiem IR.

    Z bazy danych i kodu można skorzystać też wchodząc na stronę: http://conture.by/iresp - wpisujemy nazwę pilota np. THOMSON i klikamy link i mamy wirtualnego pilota gdzie możemy kliknąć przycisk i pokazuje kod np. POWER D5F2A:
    Wirtualny pilot z czerwonym przyciskiem zasilania i klawiaturą numeryczną dla TV THOMSON.

    Chciałbym wejść w menu serwisowe TV a tam się da chyba tylko pilotem MENU-PICTURE-CONTRAST-9-7-3-5 a nie chce mi się kupować specjalnie do tego pilota.

    Dodano po 6 [godziny] 26 [minuty]:

    Pewien postęp. Zainstalowałem bibliotekę IRremoteESP8266 2.2.1 bo dopiero od tej wersji jest obsługa protokołu NIKAI. Po instalacji w katalogu %userprofile%\My Documents\Arduino\libraries\IRremoteESP8266\test\ jest plik ir_Nikai_test.cpp a w nim dane RAW sygnału IR Volume UP:
      // Nikai TV Volume Up from Issue #309
      uint16_t rawdata_volup[52] = {3972, 4002,
          504, 1982, 526, 2010, 502, 2010, 502, 2010, 500, 1056, 502, 1056,
          502, 2010, 500, 1056, 502, 2010, 502, 2010, 500, 2010, 502, 2010,
          502, 1056, 502, 1056, 502, 1056, 500, 1056, 502, 2010, 502, 2010,
          500, 1056, 502, 2008, 502, 1054, 504, 1054, 504, 1054, 500, 1056,
          450};

    Zainstalowałem też bibliotekę IRremote 2.0.1 i w niej mam sketcha IrSendRawDemo w którym podmieniłem dane RAW na te z pliku ir_Nikai_test.cpp no i działa tylko zamiast Volume Up robi Volume Down (zmieniłem delay z 5000 na 1000ms aby wysyłało co sekundę):
    /*
     * IRremote: IRsendRawDemo - demonstrates sending IR codes with sendRaw
     * An IR LED must be connected to Arduino PWM pin 3.
     * Version 0.1 July, 2009
     * Copyright 2009 Ken Shirriff
     * http://arcfn.com
     *
     * IRsendRawDemo - added by AnalysIR (via www.AnalysIR.com), 24 August 2015
     *
     * This example shows how to send a RAW signal using the IRremote library.
     * The example signal is actually a 32 bit NEC signal.
     * Remote Control button: LGTV Power On/Off. 
     * Hex Value: 0x20DF10EF, 32 bits
     * 
     * It is more efficient to use the sendNEC function to send NEC signals. 
     * Use of sendRaw here, serves only as an example of using the function.
     * 
     */
    
    
    #include <IRremote.h>
    
    IRsend irsend;
    
    void setup()
    {
    
    }
    
    void loop() {
      int khz = 38; // 38kHz carrier frequency for the NEC protocol
      unsigned int irSignal[] = {3972, 4002,
          504, 1982, 526, 2010, 502, 2010, 502, 2010, 500, 1056, 502, 1056,
          502, 2010, 500, 1056, 502, 2010, 502, 2010, 500, 2010, 502, 2010,
          502, 1056, 502, 1056, 502, 1056, 500, 1056, 502, 2010, 502, 2010,
          500, 1056, 502, 2008, 502, 1054, 504, 1054, 504, 1054, 500, 1056,
          450}; //AnalysIR Batch Export (IRremote) - RAW
      
      irsend.sendRaw(irSignal, sizeof(irSignal) / sizeof(irSignal[0]), khz); //Note the approach used to automatically calculate the size of the array.
    
      delay(1000); //In this example, the signal will be repeated every 5 seconds, approximately.
    }

    Udało mi się nawet nagrać sygnał z Arduino w pilocie uniwersalnym i teraz mam już przycisk Volume Down :-)

    Jak konwertować kod NIKAI na RAW? Jakbym miał te kody NIKAI z tej bazy co podałem w formacie RAW to jestem w domu.

    Dodano po 9 [godziny] 4 [minuty]:

    Już mam kody - za pomocą czujnika IR-COM i programu RCExplorer sprawdziłem iż ten kod Volume Down jest rozpoznawany jako protokół RCA i ma adres F (15). W Arduino też są szkice do rozpoznawania protokołu ale sęk w tym iż mam tylko jedno Arduino, które nadaje kody i nie może równocześnie odbierać więc dlatego potrzebuję inny dekoder sygnału.

    Program IrScrutinizer potrafi generować kod RAW po wprowadzeniu takich danych jak adres (D) i cmd (F). Trochę klikania ale działa - można skopiować wygenerowany kod RAW do szkicu IRsendRawDemo.ino z biblioteki IRremote. Mało tego - w programie można wygenerować wszystkie kody cmd dla danego protokołu np. RCA-38 od 0 do 255, zapisać każdy kod w tabeli w programie i exportować jako szkic Arduino który po wgraniu do pilota na stykówce pyta o numer kodu jaki chcemy wysłać - dzięki temu nie trzeba wgrywać oddzielnego szkicu dla każdego kodu cmd. Ja podzieliłem na pół zakres 0-140.ino i 141-255.ino bo Arduino Nano ma mało pamięci i szkic z wszystkimi kodami chyba by się nie zmieścił.

    Oj siedziałem przy tym długo - ale jaka satysfakcja i wiem o co chodzi na przyszłość :-)
    Zrzut ekranu programu RCExplorer z protokołem RCA Zrzut ekranu z programu IrScrutinizer pokazujący proces konwersji kodów IR. Zrzut ekranu programu IrScrutinizer w wersji 2.4.1 z zakładką eksportu sygnałów IR Interfejs programu IrScrutinizer z widocznymi kodami IR Zrzut ekranu z programu Arduino z kodem i konsolą COM Samodzielnie zbudowany pilot IR z płytką Arduino Nano skierowany na telewizor
REKLAMA