ATNEL tech-forum

Re: Budujemy uniwersalny odbiornik IR do Kodi cz. 1

2019-07-10T19:28:15+01:00

ooo super, ten kod sie kompiluje, wielkie dzięki!

tak, tak, teraz bawiłem się ze zmianą na ATMEGA 328P i stąd te 12 MHz

Statystyki: Napisane przez yalbi — 10 lip 2019, o 19:28

Re: Budujemy uniwersalny odbiornik IR do Kodi cz. 1

2019-07-10T19:18:28+01:00

Hmm ciekawe nie mam u siebie takich funkcji
Może wrzuciłem jakiś stary kod...
Daję do załącznika to co mi się kompiluje, zaimportuj nowy projekt do workspace i zobacz.
Tak w ogóle to nadal masz 12 MHz (-DF_CPU=12000000UL), ma być 16,5 MHz dla Attiny.

Statystyki: Napisane przez Zealota — 10 lip 2019, o 19:18

Re: Budujemy uniwersalny odbiornik IR do Kodi cz. 1

2019-07-10T18:44:33+01:00

ok, ok, dzięki za odpowiedź

używałem marsa, ale z ciekawości odpaliłem na photonie i dalej ta sama sytuacja :/

ustawiłem autokalibrację i przerwania PCINT, ale dalej wywala błędy
co masz na myśli pisząc o zmniejszeniu obsługiwanych protokołów?

edit. aaa, już wiem które protokoły miałeś na myśli SAMSG NEC RC5 itd. ograniczyłem do jednego i dalej to samo

[syntax=c]'Building file: ../lib/sw_ir_manage.c'
'Invoking: AVR Compiler'
avr-gcc -Wall -Os -fpack-struct -fshort-enums -ffunction-sections -fdata-sections -std=gnu99 -funsigned-char -funsigned-bitfields -mmcu=attiny85 -DF_CPU=12000000UL -MMD -MP -MF"lib/sw_ir_manage.d" -MT"lib/sw_ir_manage.o" -c -o "lib/sw_ir_manage.o" "../lib/sw_ir_manage.c"
In file included from ../lib/V-USB/../../usbdrv/usbportability.h:124:0,
from ../lib/V-USB/../../usbdrv/usbdrv.h:13,
from ../lib/V-USB/usb_sw_layer.h:4,
from ../lib/sw_ir_manage.h:14,
from ../lib/sw_ir_manage.c:9:
../lib/sw_ir_manage.c: In function 'sw_settings_strings_to_usb':
../lib/sw_ir_manage.c:326:39: error: 'settings' undeclared (first use in this function)
unsigned char *ptr = pgm_read_word( settings+i ); // Pobieramy z FLASH kolejny wskaĹşnik do nazwy kodu[/syntax]

Statystyki: Napisane przez yalbi — 10 lip 2019, o 18:44

Re: Budujemy uniwersalny odbiornik IR do Kodi cz. 1

2019-07-10T17:25:54+01:00

Skompilowałem u siebie i nie było błędów w Eclipse Photon.
Najlepiej ręcznie usunąć zawartość katalogu Release, żeby stare pliki oboektowe nie mieszały.
Na początek w ustawieniach projektu zmienić na ATtiny85 i ustawić zegar na 16500000 oraz włączyć przerwania od PCINT:
[syntax=c]#define USB_PCINT_ON1//Ustalamy czy korzystamy z przerwania PCINT[/syntax]
Niestety dla 8 KB flash trzeba ograniczyć ilość obsługiwanych protokołów IR. Dla 2 powinno zadziałać.
Trzeba koniecznie pamiętać, że przy wgrywaniu wsadu zasilanie musi być brane z USB - taki oto niezamierzony "ficzer"

------------------------ [ Dodano po: 53 minutyach ]

A i jeszcze jedna opcja dla ATtiny:
[syntax=c]#define ATTINY_AUTO_CALIBRATE1[/syntax]

Statystyki: Napisane przez Zealota — 10 lip 2019, o 17:25

Re: Budujemy uniwersalny odbiornik IR do Kodi cz. 1

2019-07-10T17:03:57+01:00

@Zealota, dziękuję

a podpowiesz czy cos trzeba zmienić w kodzie jeśli chce sie używać digispark? Kiedy kompiluje na ATMEGA328P wszystko ładnie działa, a jeśli ten kod ustawie na attiny85 to już nie działa, tylko sypie błędami

Statystyki: Napisane przez yalbi — 10 lip 2019, o 17:03

Re: Budujemy uniwersalny odbiornik IR do Kodi cz. 1

2019-07-06T20:04:43+01:00

Kod znajdziesz na moim blogu:
http://zealota74.blogspot.com/2017/10/u ... ni-do.html
Na samym dole.

Statystyki: Napisane przez Zealota — 6 lip 2019, o 20:04

Re: Budujemy uniwersalny odbiornik IR do Kodi cz. 1

2019-07-06T14:15:49+01:00

bardzo zaciekawił mnie ten projekt, ale nigdzie nie mogę pobrać pełnego kodu, stąd moja prośba do autora tematu o udostępnienie
Z góry dzięki

Statystyki: Napisane przez yalbi — 6 lip 2019, o 14:15

Re: Budujemy uniwersalny odbiornik IR do Kodi cz. 1

2017-06-12T07:55:01+01:00

Bardzo fajny projekt i realizacja - miałem okazję to zobaczyć na własne oczy i ponieważ znam Kodi to tym bardziej doceniam

Sent from my Mi-4c using Tapatalk

Statystyki: Napisane przez micky — 12 cze 2017, o 07:55

Re: Budujemy uniwersalny odbiornik IR do Kodi cz. 1

2017-06-11T22:14:14+01:00

Chciałbym jeszcze dodać, że tym razem oprócz "tych Kodi", jest pewne nawiązanie do tematyki ostatnich poradników Mirka, chodzi o kalibrację zegara:

Zealota napisał(a):

W niniejszym rozwiązaniu nie zastosowano rezonatora kwarcowego, w zamian, w programie głównym, zaimplementowano automatyczną kalibrację urządzenia, która dzięki wewnętrznej pętli PLL mikrokontrolera pozwala ustalić częstotliwość zegara, na zgodną z V-USB wartość, tzn. 16,5 MHz. Takie rozwiązanie pozwoliło zaoszczędzić 2 porty mikrokontrolera potrzebne do obsługi USB i dzięki temu powstała możliwość uruchomienia odbiornika na tym module, korzystając ze sprzętowej obsługi przerwań AVR w trybie PCINT. Sposób obsługi kalibracji zaczerpnięto z:
http://vusb.wikidot.com/examples

Prace nad opisem zintensyfikowałem właśnie po "owych poradnikach", tak by trochę się przy nich "ogrzać"

Ważne jest też to, że łatwiej się programuje to, co się rozumie oraz jest potrzebne

Statystyki: Napisane przez Zealota — 11 cze 2017, o 22:14

Re: Budujemy uniwersalny odbiornik IR do Kodi cz. 1

2017-06-11T21:59:57+01:00

Ja może się nie znam aż na tyle na tym KODI, ale zapewniam was, że z tego projektu już sam widok "terminala" w notatniku windows - po prostu powala na kolana!

To co kolega autor wyprawia tu z tymi KODI itp to normalnie jakiś pogrom ! ... czytając to wszystko wyżej aż chciałoby się rzucić gdzieś w kąt wszystko czym się teraz zajmuję i .... i oddać się rozkoszy zajęcia tą właśnie tematyką ...

Statystyki: Napisane przez mirekk36 — 11 cze 2017, o 21:59

Budujemy uniwersalny odbiornik IR do Kodi cz. 1

2017-06-11T21:54:33+01:00

W tym tygodniu kontynuuję prezentację projektów związanych z Kodi (Xbmc).
Jak wiecie z mojego poprzedniego opisu: topic18562.html
sprzęt multimedialny klasy HTPC to jest mój konik
Jeśli jeszcze o tym nie wiecie, to zapraszam do powyższego opisu, w którym skoncentrowałem się na aspektach sprzętowych.
Dzisiaj, natomiast, poświęcę nieco więcej czasu aspektom dotyczącym samego programowania.
Zanim jednak dojdziemy do kodu, to trzeba liznąć nieco teorii

I.Wstęp.
Odbiornik przeznaczony jest do sterowania odtwarzaczem multimedialnym Kodi (dawniej XBMC).
Jako medium transmisyjne wykorzystano podczerwień. Zastosowano popularne w sprzęcie konsumenckim odbiorniki IR pracujące na fali nośnej o częstotliwości 38kHz. Parametr ten nie jest krytyczny i można z powodzeniem zastosować odbiorniki o innej częstotliwości np. 36kHz lub 40kHz.
Żeby móc skorzystać z mocy drzemiącej w odbiorniku należy użyć, odpowiedniego do tego celu, pilota na podczerwień. Dzięki zastosowaniu w projekcie zaawansowanej biblioteki do obsługi podczerwieni (IRMP) można skorzystać z bardzo dużej gamy dostępnych na rynku urządzeń nadawczych.
Wyboru pilota można dokonać na etapie kompilacji programu, ustalając tablicę kodów IR oraz podczas użytkowania odbiornika, dzięki "zaszytej" w kodzie funkcji uczenia kodów. Oprócz powyższej funkcji, odbiornik może pracować jeszcze w dwóch kolejnych trybach, podstawowym, jako klawiatura IR i dodatkowym, logowania IR. W pamięci flash odbiornika umieszczono również plik konfiguracyjny keyboard.xml, który jest częścią integralną programu Kodi. W ten sposób, niejako „pod ręką”, mamy możliwość rozszerzenia możliwości odbiornika o dodatkowe funkcje, przydatne m.in. w trybie LiveTV odtwarzacz Kodi.

Część sprzętową odbiornika oparto na popularnej rodziny mikrokontrolerów AVR firmy Atmel. Podstawowe schematy elektryczne odbiornika można znaleźć w dalszej części dokumentu. Kod źródłowy przygotowano dla kilku tanich i ogólnie dostępnych przedstawicieli rodziny AVR.
Ilość niezbędnych komponentów elektronicznych zredukowano do niezbędnego minimum tak, by nawet początkujący elektronik mógł wykonać urządzenie we własnym zakresie. W dalszej części przedstawiono kilka praktycznych przykładów wykonania.
Minimalne wymagania, co do ilości pamięci programu, ustalono na 8K bajtów. Taka wielkość pamięci programu gwarantuje już dużą uniwersalność urządzenia, szczególnie co do możliwości obsługi jak największej ilości pilotów. Dzięki elastyczności biblioteki IRMP zajętość pamięci programu można łatwo modyfikować, wyłączając obsługę niektórych standardów kodowania. Warto zauważyć, że biblioteka ta wspiera także inne platformy jak PIC czy STM32.
W dalszej części dokumentu opisano jeszcze inne sposoby, modyfikacji kodu źródłowego programu, służące do ograniczania zajętości pamięci flash. Pełna funkcjonalność urządzenia wymaga zastosowania mikrokontrolera, z co najmniej 16K bajtów.
Drugą, również niezbędną biblioteką, jest V-USB. Dzięki niej możliwa była komunikacja odbiornika z komputerem w różnych systemach operacyjnych, na różnych platformach sprzętowych, dzięki emulacji urządzeń typu HID. Wspierane i przetestowane platformy zostaną krótko opisane w dalszej części dokumentu. Wspomniana wyżej biblioteka umożliwiła stworzenie pseudo-terminala, dzięki któremu urządzenie nie potrzebuje do komunikacji z użytkownikiem dodatkowego interfejsu jak wyświetlacz LED, LCD, czy dedykowanej aplikacji. Rolę interfejsu tutaj będzie pełnić dowolny edytor tekstowy. Idea tego rozwiązania została zaczerpnięta stąd:
https://www.mikrocontroller.net/article ... e_Receiver.

Podsumowując pracując nad urządzenie postawiono na:
- uniwersalność,
- prostotę użytkowania,
- łatwość wykonania modułu odbiornika.

II.Koncepcja obsługi odtwarzacza Kodi.
Odtwarzacz Kodi jest programem o bardzo dużych możliwościach, praktycznie w każdym aspekcie jego działania. Nie inaczej jest również od strony interfejsu wejściowego użytkownika.
Kodi współpracuje z klawiaturami, myszkami, dżojstikami, odbiornikami podczerwieni różnego rodzaju. Nie każde z tych rozwiązań cechuje się jednakową uniwersalnością. W mojej ocenie najlepiej na tym polu sprawdza się współpraca ze standardowymi klawiaturami PC, zarówno przewodowymi jak i bezprzewodowymi. Stąd właśnie wybór pracy odbiornika IR właśnie w tym trybie. Takie rozwiązanie daje bardzo dużą przenośność między różnymi platformami sprzętowymi i systemowymi. Poprawna praca interfejsu HID pozwoli użytkować odbiornik pod systemem Windows, Linux, Android czy nawet iOS.
Takie rozwiązanie ma znaczną przewagę w stosunku do obsługi realizowanej dzięki Lirc czy Eventlirc, bowiem zapewnia dużą przenośność między urządzeniami i właściwie pracuje w trybie Plug&Play.
Zaletę tę szczególnie docenią użytkownicy próbujący przystosować odtwarzacz Kodi do zdalnej obsługi w systemie Windows, na przykład za pomocą EventGhost.
Praca ze standardowymi pilotami ma właściwie tylko dwie wady, trudność z przekazywaniem danych tekstowych, druga to konieczność "celowania w odbiornik". Obie te wady zwykle tracą na znaczeniu przy codziennym, standardowym użytkowaniu.
Odtwarzacz Kodi do podstawowego swojego działania wymaga tylko kilku komend sterujących, tych zgrupowanych wokół poruszania się po menu odtwarzacza.
Są to: Menu Up, Menu Down, Menu Left, Menu Right, Menu OK, Previous Menu, Back. Pilot podczerwieni powinien być wyposażony, w co najmniej 7 przycisków, co zaprezentowano na obraku:

Takie minimalistyczne podejście mocno ograniczy ergonomię użytkowania, zatem projektując odbiornik do Kodi przyjąłem inne założenie.
Do podstawowych kodów dołożono kod Power i opierając się na wymogach wygodnego użytkowania odtwarzacza w trybie LiveTV przyjęto ilość przycisków na 46. Ilość klawiszy wynika wprost z konstrukcji jednego z popularniejszych pilotów uniwersalnych tzn. Logitech i300. Taka ich ilość, oraz pewna wprawa w użytkowaniu, zostawia w tyle, co do sprawności i szybkości, inne rozwiązania, choćby te oparte na smartfonach.
Zaproponowaną przeze mnie ilość przycisków można łatwo zmodyfikować na etapie kompilacji źródeł programu. Zmniejszając ilość obsługiwanych przycisków można zaoszczędzić nieco na pamięci flash.
Z minimalnej ilości niezbędnych komend wynika również zachowanie odbiornika w trybie uczenia kodów IR, gdzie po zapamiętaniu sekwencji pierwszych 8 kodów możliwe jest wyjście z trybu uczenia (komenda Previous Menu) oraz można pominąć niepożądane komendy (zarejestrowana komenda Menu Down).
Podsumowując, pierwszych 8 komend, aż do Previous Menu, należy zaprogramować, żeby ułatwić proces uczenia kodów i również zachować minimalną ergonomię użytkowania.
Takie zachowanie oprogramowania inspirowane było trybem uczenia skrótów klawiaturowych zastosowane w VDR (Video Disk Recorder).

III.Tryby pracy odbiornika.
1.Tryb klawiatury IR.
Taki tryb pracy jest podstawowy dla całego urządzenia. W trybie tym następuje przekazywanie kodów IR z pilota podczerwieni do odbiornika, następnie dekodowanie na odpowiadające im kody HID i przesyłane poprzez interfejs USB do urządzenia głównego. W obecnej wersji oprogramowania możliwe jest przekazywanie pojedynczych kodów (klawiszy) – brak możliwości tworzenia skrótów klawiaturowych. Nie powinno być problemu z modyfikacją kodu, by można było przesyłać kombinacje klawiszy z Ctrl, Alt itp.

2.Tryb logowania kodów IR.
Jest to dodatkowy tryb pozwalający przeanalizować kody dowolnego pilota i określić wartości kodów IR, adresu IR oraz nazwę zastosowanego systemu kodowania. Dzięki tak zebranym danym można przygotować własną tablicę kodów IR i użyć na etapie kompilacji programu, czy wręcz w innych projektach wykorzystujących sterowanie podczerwienią.
Żeby skorzystać z tego trybu należy odbiornik przełączyć w tryb logowania IR (patrz punkt IV.2). W oknie edytora tekstowego będzie można podglądnąć, aktualnie wykryte, kody z pilota.

3.Tryb uczenia kodów pilota.
Dzięki temu trybowi pracy można przystosować odbiornik do współpracy z każdym pilotem obsługiwanym przez bibliotekę IRMP. W trybie tym następuje przypisanie, zdefiniowanym w programie funkcjom sterowania programem Kodi, odpowiednich kodów pilota, a następnie zapisanie tych wartości do pamięci eeprom.
Żeby zaprogramować odbiornik do obsługi konkretnego pilota należy przełączyć odbiornik w tryb uczenia (patrz punkt IV.2). Wcześniej, w systemie operacyjnym, należy uruchomić dowolny edytor tekstowy, żeby można było odczytać komendy odbiornika. W niniejszym opisie użyto standardowo dostępnego w systemie Windows 8.1 Notatnika (notepad.exe).

Oprócz powyższych trybów ważnym aspektem działania odbiornika jest sterowanie transoptorem, który pozwala w wersjach V.3 oraz V.5 sterować sygnałem Power On dowolnej płyty głównej klasy PC.

4.Tryb generowania pliku keyboard.xml.
W pamięci flash mikrokontrolera zaszyto kod tekstowy pliku keyboard.xml, który jest częścią programu Kodi. Dzięki temu każdy użytkownik odbiornika IR będzie miał „pod ręką” stosowny plik konfiguracyjny, który uzupełni możliwości konfiguracyjne odbiornika.

Konkretny sposób działania przedstawiono na poniższym filmie.

iframe

IV.Inne, ważne funkcje odbiornika.

1.Funkcja pseudo-terminala.
Do interakcji odbiornika z użytkownikiem, jak napisano we wstępie, zastosowałem prosty sposób wykorzystujący dane czysto tekstowe, zatem do otrzymania stosownych informacji należy użyć dowolnego edytora tekstowego. Takie rozwiązanie ma jeszcze tę zaletę, że zaraz po interakcji z odbiornikiem, uzyskane dane można zapisać do pliku tekstowego, pod dowolną nazwą.
Pseudo-terminal wykorzystywany jest w trybach 2, 3 oraz 4 (patrz punkt III).
W powyższych trybach należy koniecznie przełączyć się na aktywny edytor tekstowy, żeby otrzymać wszystkie przekazywane dane oraz uniknąć pewnego bałaganu w systemie operacyjnym, "bombardowanym" przekazywanym tekstem.

2.Przełączanie między trybami pracy odbiornika.
W zależności od wykonania sprzętowego oraz zaimplementowanej obsługi programowej odbiornika zmiany trybów pracy można wykonać:
- za pomocą zamontowanego w odbiorniku przycisku,
- za pomocą podłączonej do komputera klawiatury (klawisz Capslock).

Żeby zmienić tryb działania odbiornika, wyposażonego w obsługę przycisku (może być też jumper lub zwora), należy po włączeniu zasilania (włożeniu wtyczki USB do gniazda) nacisnąć przycisk i przytrzymać w takiej pozycji, obserwując zarazem zamontowaną w odbiorniku diodę LED. Powinna zacząć migać, przez kilka sekund, po czym włączyć się na stałe, następnie znowu migać, ale szybciej. Zwolnienie przycisku w trakcie wolnego migania diody przełączy odbiornik w tryb logowania IR, zwolnienie przycisku, gdy dioda będzie świecić światłem ciągłym, w tryb uczenia kodów IR, zwolnienie przycisku w trakcie szybkiego migania przełączy odbiornik w tryb generowania tekstu do pliku keyboard.xml.

Jeżeli do oprogramowania modułu zaszyto obsługę klawisza Capslock, podłączonej do PC klawiatury, to należy wykonać sekwencję od kilku do kilkunastu zapaleń i zgaszeń diody od Capslock’a, pamiętając, że każda sekwencja musi zakończyć się zgaszeniem diody. Nie zastosowanie się do tego sposobu spowoduje, że po 1s świecenia diody próbę trzeba będzie powtórzyć.
Podczas naciskania przycisku Capslock należy obserwować diodę zamontowaną w odbiorniku. W jaki tryb odbiornik zostanie przełączony zależy od ilości sekwencji:
- 1 sekwencja – odbiornik wraca do trybu nr 1 (III.1),
- od 2 do 5 sekwencji – odbiornik wchodzi do trybu nr 2 (III.2),
- od 6 do 10 sekwencji – odbiornik wchodzi do trybu nr 3 (III.3),
- więcej niż 10 sekwencji – wchodzi do trybu nr 4 (III.4)

Sposób zmiany trybów za pomocą Capslock'a (a jest to tryb preferowany) przedstawiono również na powyższym filmie.

V.Praktyczne przykłady realizacji odbiornika podczerwieni.

Dzięki dużej uniwersalności mikrokontrolerów z rodziny AVR, ilość gotowych rozwiązań sprzętowych, realizujących ideę odbiornika IR USB, jest wręcz nieograniczona. Poniżej przedstawiono kilka prostych rozwiązań.

1.Gotowy moduł z procesorem ATtimy85 (Digispark ATtiny85).
Wygląd odbiornika wraz z modyfikacjami prezentują zdjęcia:

Zmontowany moduł Digispark ATtiny85 Mini USB znakomicie nadaje się na tego typu urządzenie. Zawiera w sobie mikrokontroler o wystarczającej pamięci programu jak i danych.
Moduł zawiera 5 dostępnych portów (nie licząc pinu reset), co jest wystarczające w użyciu modułu jako odbiornika IR. Porty pełnią następujące funkcje:
- PB0 - port wejściowy współpracujący z odbiornikiem podczerwieni
- PB1 - port wyjściowy przeznaczony do sterowania diodą LED,
- PB2 - port wejściowy przygotowany do obsługi pojedynczego klawisza (zworki),
- PB3, PB4 - porty, do których podłączono interfejs USB, odpowiednio D- i D+.
W niniejszym rozwiązaniu nie zastosowano rezonatora kwarcowego, w zamian, w programie głównym, zaimplementowano automatyczną kalibrację urządzenia, która dzięki wewnętrznej pętli PLL mikrokontrolera pozwala ustalić częstotliwość zegara, na zgodną z V-USB wartość, tzn. 16,5 MHz. Takie rozwiązanie pozwoliło zaoszczędzić 2 porty mikrokontrolera potrzebne do obsługi USB i dzięki temu powstała możliwość uruchomienia odbiornika na tym module, korzystając ze sprzętowej obsługi przerwań AVR w trybie PCINT. Sposób obsługi kalibracji zaczerpnięto z:
http://vusb.wikidot.com/examples

Żeby nie komplikować zanadto dodatkowej elektroniki, w postaci odbiornika IR i jego peryferiów, zrezygnowano, z zalecanej przez producenta modułu IR, prawidłowej filtracji napięcia zasilania, w zamian zastosowano tylko kondensator filtrujący SMD, widoczny na zdjęciach. Wielokrotne próby wykazały, że przy zastosowanym scalonym odbiorniku podczerwieni, nie zaobserwowano niepokojących objawów podczas działania przy takiej, niepełnej filtracji. Pewna hermetyczność rozwiązania, w postaci gotowego modułu jako bazy, skomplikowała nieco proces programowania mikrokontrolera (potrzebna jest dedykowana "przejściówka" – brak gniazda w standardzie Kanda) oraz utrudniła również proces zmiany trybu pracy odbiornika, dzięki brakowi mikro przełącznika na module. Dodatkowo sam scalony odbiornik IR musi być tak dołączony do modułu Digispark by, na czas programowania kodów, można go było zdemontować. Zamiast przełącznika należy użyć dowolnej zworki (przewodu) i zewrzeć pin PB2 do masy i postępować wg punktu IV.2.
Na zdjęciach zmodyfikowanego modułu, widać wszystkie potrzebne elementy do złożenia odbiornika IR.
Wymienione trudności są niewielkie zważywszy, że trybu uczenia, czy logowania IR nie wykonuje się zbyt często podczas normalnego użytkowania odbiornika.

UWAGI:
oW tym rozwiązaniu próby implementacji użycia Capslocka, jako „wyzwalacza” zmiany trybów odbiornika, nie powiodły się. Ten moduł należy programować z obsługą zworki.
oŻeby auto-kalibracja, do żądanej częstotliwości 16.5 MHz udała się, należy wiedzieć, że podczas programowania pamięci flash za pomocą programatora, zasilanie musi być podane poprzez złącze USB, nie poprzez programator.

2.Gotowy moduł z mikrokontrolerem ATmega328P wraz z modyfikacjami.
Do wykonania odbiornika użyto popularnego moduł Arduino Pro Mini z rezonatorem kwarcowym 16 MHz i zasilaniem 5V. Żeby moduł zrealizował funkcję odbiornika dla Kodi użytkownik, we własnym zakresie, powinien wykonać drobną modyfikację w postaci układu wejściowego USB wraz z obwodem zasilania dla układu odbiorczego IR. Całość zmian przedstawiono zdjęciach:

3.Projekt PCB z wykorzystaniem ATmega328P.
Jest to właściwie gotowy do produkcji projekt, wyposażony w otwory montażowe.
Odbiornik zaprezentowano na zdjęciach:

4.Gotowy moduł Arduino Pro Micro z procesorem ATmega32U4.
Na zakończenie propozycja innego podejścia do odbiornika IR.
Tym razem zamiast programowej obsługi USB można skorzystać z czysto sprzętowej, dostępnej m.in. w mikrokontrolerze ATmega32U4, dzięki projektowi LUFA:
http://www.fourwalledcubicle.com/LUFA.php
Taki podejście do projektu mocno uprości urządzenie, po zakupie np. Arduino Pro Micro wystarczy tylko dołączyć odbiornik IR i gotowe.
Projekt takiego rozwiązania jest jeszcze we wczesnej fazie, ale pierwsze próby wypadły obiecująco.

5.Przykład gotowego urządzenia klasy mini PC.
W tym przypadku mamy już konkretny sposób wykorzystania odbiornika. Został, bowiem zaszyty w panelu sterującym wykorzystanym w odtwarzaczu multimedialnym przeznaczonym "do salonu". Cała konstrukcja to elektryczna i mechaniczna przeróbka uszkodzonego magnetofonu i stanowi część większego projektu, oprócz odbiornika urządzenie obsługuje klawisze na panelu czołowym oraz wyświetlacz VFD. Całość urządzenia oczywiście współpracuje z Kodi na kilka sposobów, poprzez odbiornik IR, klawiaturę oraz enkoder.
Pełny opis można znaleźć tutaj:
topic18562.html

VII.Trochę słów o kodzie.
Pełen kod, wraz z krótkim opisem przedstawię w następnej części publikacji.
W pisanym kodzie starałem się mocno skoncentrować na podziale aplikacji wg warstw, a szczególnie zależało mi na oddzieleniu tzw. warstwy sprzętowej. Nie mam niestety jeszcze dużej wprawy w programowaniu, ale już teraz czuję podskórnie, że to dobra droga. Myślenie o warstwach pozwoliło mi wstępnie na zamianę programowej obsługi USB na sprzętową, o czym pisałem w punkcie V.3

Na zakończenie tej części dodaję jeszcze zrzut struktury programu w postaci drzewa projektu Eclipse.

oraz plik główny projektu:
[syntax=c]#include
#include
#include
#include

#include "usbdrv/usbdrv.h"
#include "kodi_ir_config.h"
#include "lib/IRMP/irmp.h"
#include "lib/sw_ir_manage.h"
#include "lib/SW_AVR_PERIPHS/timers.h"
#include "macros.h"

uint8_tledState = 0;// Domyslny tryb miganie diody, jedno mignięcie
uint8_t tmp = 0;
/* ====================================================== MAIN ==========================================================*/
int main( void ) {

uint8_t mode = IR_SEND_MODE;// Domyślny tryb pracy odbiornika
uint8_tusbCheckActivity = 0;// Flaga działania transmisji USB

/*************************************************** Sekcja INIT *******************************************/
#if USB_SEND_MODE
#ifdef TRANS_POWER
sw_transoptor_init();
#endif
#endif
#if __AVR_ATtiny85__ && USB_PCINT_ON
sw_keyboard_init();
#endif
sw_led_init();
sw_led_off();

sw_data_init();// Inicjalizujemy tablicę kodów i obsługę IR
timer1_init();// inicjalizacja timer1 do irmp

#if IRMP_USE_CALLBACK
irmp_set_callback_ptr( led_callback );// Miganie diodą wbudowane w IRMP
#endif

#if SOFT_TIMERS
#if defined (__AVR_ATmega328P__) || defined (__AVR_ATtiny85__)
timer0_init();// inicjalizacja timer0 do timerów programowych
#else
timer2_init();
#endif
#endif
/**********************************************************************************************************/
PORTB &= ~(1<
sei();// Włączenie przerwań
/*************************** USB routines **************************/
usbInit();
clearReport();// Czyscimy raport USB na wstepie
usbDeviceReconnect();
/*******************************************************************/

#if defined (__AVR_ATtiny85__)
/************** Kalibrujemy zegar dla ATtiny85 *********************/
#ifATTINY_AUTO_CALIBRATE
atTiny_calibrate();
#else
OSCCAL = 102;
#endif

/*******************************************************************/
#endif

while ( !sw_usb_check_activity(usbSofCount) ) {// Czekamy aż ruszy transmisja USB
usbPoll();
}

/* ========================================== GLÓWNA PĘTLA ===================================================== */
wdt_enable(WDTO_1S);// Włączenie watchdoga na 1s
while(1) {
wdt_reset();// Reset watchdoga
usbPoll();

#if __AVR_ATtiny85__ && USB_PCINT_ON && !USB_CFG_IMPLEMENT_FN_WRITE
mode = sw_get_mode( &keyboard, &ledState, mode );// Ustalamy tryb pracy urządzenia
#else
mode = sw_get_mode( &softTimer5, &ledState, mode );
#endif
sw_led_blink( &softTimer1, &ledState);
usbCheckActivity = sw_usb_check_activity( usbSofCount );// Sprawdzamy czy jest transmisja USB

#ifdef TRANS_POWER// Obsługa transoptora
mode = sw_switch_mode( mode, &ledState, usbCheckActivity, &tmp );// Przełączamy tryb pracy
if ( tmp == TRANS_POWER ){
sw_power_manage( tmp );// Wyłączenie jest z poziomu Kodi
} else
sw_power_manage( 0 );// Wyłączenie jest z poziomu Kodi

#else
mode = sw_switch_mode( mode, &ledState, usbCheckActivity, &tmp );
#endif

}// End of main loop while()
/* ============================================================================================================= */
return 0;
}// End of main()[/syntax]

Jeszcze zajrzyjmy do pliku konfiguracyjnego:
[syntax=c]/*
* kodi_ir_config.h
*
* Created on: 8 paź 2016
* Author: simon
*/

#ifndef KODI_IR_CONFIG_H_
#define KODI_IR_CONFIG_H_

/*********************** Zmniejszamy zajętość pamięci FLASH **********************/
#define LOW_MEMORY 0
/*********************************************************************************/

/*********************** Włączamy obsługę logowania kodów IR *********************/
#define USB_LOG_MODE1
/*********************************************************************************/

/*********************** Włączamy obsługę uczenia kodów IR ***********************/
#define USB_LEARN_MODE1
/*********************************************************************************/

/*********************** Włączamy obsługę uczenia kodów IR ***********************/
#define USB_SEND_MODE1
/*********************************************************************************/

/********** Czas między kolejnymi repetycjaminaciśnięcia klawisza ****************/
#define AUTOREPEAT_MS100
/*********************************************************************************/

/*********************** Włączamy autokalibrację zegara da ATtiny85 **************/
#define ATTINY_AUTO_CALIBRATE0
/*********************************************************************************/

/*************************** Konfiguracja diody LED ******************************/
#if defined __AVR_ATtiny85__
#define LED_PORTPORTB
#define LED_PIN1
#else
#if defined (__AVR_ATmega8__) || defined (__AVR_ATmega328P__) || defined (__AVR_ATmega32__)
#define LED_PORT PORTB
#define LED_PIN 1
#endif
#endif
/***************** Definiujemy gaszenie i zapalenie LED **************************/
#define sw_led_off()LED_PORT |= (1<#define sw_led_on()LED_PORT &= ~(1<#define sw_led_xor()LED_PORT ^= (1</*********************************************************************************/

/*************************** Konfiguracja Transoptora ****************************/
#define TRANS_POWERHID_KEY_S// Ustalamy kod HID, który będzie sterował transoptorem,
#ifdef TRANS_POWER// zarazem definiujemy czy mamy transoptor
#define TRANS_PORTPORTB
#define TRANS_PIN2
#define transoptor_on()TRANS_PORT |= (1<#define transoptor_off()TRANS_PORT &= ~(1<#define TRANS_TIMEtime_base_ms(100)// Ustawiamy timer na odliczanie 400 ms
#endif
/*********************************************************************************/

/*********************************** Sekcja dotycząca V-USB ********************************/
#define USB_CFG_IMPLEMENT_FN_WRITE 1// Potrzebne do sterowania Capslockiem
/* Set this to 1 if you want usbFunctionWrite() to be called for control-out
* transfers. Set it to 0 if you don't need it and want to save a couple of
* bytes.
*/
#define USB_PCINT_ON0//Ustalamy czy korzystamy z przerwania PCINT

/****************************** Definiujemy porty dla V-USB ********************************/
#if defined __AVR_ATmega32__
#define USB_CFG_IOPORTNAME D
#define USB_CFG_DMINUS_BIT 2
#define USB_CFG_DPLUS_BIT 0
#endif
#if defined __AVR_ATmega8__
#define USB_CFG_IOPORTNAME D
#define USB_CFG_DMINUS_BIT 2
#define USB_CFG_DPLUS_BIT 0
#endif
#if defined __AVR_ATtiny85__
#define USB_CFG_IOPORTNAME B

#if USB_PCINT_ON
#define USB_CFG_DMINUS_BIT 3// 3
#define USB_CFG_DPLUS_BIT 4// 4
#else
#define USB_CFG_DMINUS_BIT 2
#define USB_CFG_DPLUS_BIT 1
#endif
#endif
#if defined __AVR_ATmega328P__
#define USB_CFG_IOPORTNAME D
#if USB_PCINT_ON
#define USB_CFG_DMINUS_BIT 0
#define USB_CFG_DPLUS_BIT 1
#else
#define USB_CFG_DMINUS_BIT 2
#define USB_CFG_DPLUS_BIT 1
#endif
#endif

/****************** Konfiguracja przerwania dla V-USB ****************/
// Dane domyślne dla INT0 dla różnych procesorów
/* #define USB_INTR_CFG MCUCR */
/* #define USB_INTR_CFG_SET ((1 << ISC00) | (1 << ISC01)) */
/* #define USB_INTR_CFG_CLR 0 */
/* #define USB_INTR_ENABLE GIMSK */
/* #define USB_INTR_ENABLE_BIT INT0 */
/* #define USB_INTR_PENDING GIFR */
/* #define USB_INTR_PENDING_BIT INTF0 */
/* #define USB_INTR_VECTOR INT0_vect */

/**/
#if (defined __AVR_ATtiny85__) && USB_PCINT_ON //PCINT3 default
#define USB_INTR_CFG PCMSK
#define USB_INTR_CFG_SET (1 << PCINT3)
#define USB_INTR_CFG_CLR 0
#define USB_INTR_ENABLE GIMSK
#define USB_INTR_ENABLE_BIT PCIE
#define USB_INTR_PENDING GIFR
#define USB_INTR_PENDING_BIT PCIF
#define USB_INTR_VECTOR PCINT0_vect
#endif
/**/
/**/
#if (defined __AVR_ATmega328P__) && USB_PCINT_ON
#define USB_INTR_CFG PCMSK2
#define USB_INTR_CFG_SET (1 << PCINT16)
#define USB_INTR_CFG_CLR 0
#define USB_INTR_ENABLE PCICR
#define USB_INTR_ENABLE_BIT PCIE2
#define USB_INTR_PENDING PCIFR
#define USB_INTR_PENDING_BIT PCIF2
#define USB_INTR_VECTOR PCINT2_vect
#endif
/**/
/**/// ATMEGA32 INT2 działa!!
#if defined __AVR_ATmega32__
#define USB_INTR_CFG MCUCSR
#define USB_INTR_CFG_SET (1 << ISC2) //rising edge
#define USB_INTR_CFG_CLR 0
#define USB_INTR_ENABLE GICR
#define USB_INTR_ENABLE_BIT INT2
#define USB_INTR_PENDING GIFR
#define USB_INTR_PENDING_BIT INTF2
#define USB_INTR_VECTOR INT2_vect
#endif
/*******************************************************************************************************/
\
/************** Fragment biblioteki IRMP ****************************************
* Zaznaczamy, które z protokołów mają być obsługiwane.
*/
/*---------------------------------------------------------------------------------------------------------------------------------------------------
* Change F_INTERRUPTS if you change the number of interrupts per second,
* Normally, F_INTERRUPTS should be in the range from 10000 to 15000, typical is 15000
* A value above 15000 costs additional program space, absolute maximum value is 20000.
* On PIC with XC8/C18 Compiler, use 15151 as the correct value.
*---------------------------------------------------------------------------------------------------------------------------------------------------
*/
#ifndef F_INTERRUPTS
# define F_INTERRUPTS 15000 // interrupts per second, min: 10000, max: 20000, typ: 15000
#endif

/*---------------------------------------------------------------------------------------------------------------------------------------------------
* Change settings from 1 to 0 if you want to disable one or more decoders.
* This saves program space.
*
* 1 enable decoder
* 0 disable decoder
*
* The standard decoders are enabled per default.
* Less common protocols are disabled here, you need to enable them manually.
*
* If you want to use FDC or RCCAR simultaneous with RC5 protocol, additional program space is required.
* If you don't need RC5 when using FDC/RCCAR, you should disable RC5.
* You cannot enable both DENON and RUWIDO, only enable one of them.
*---------------------------------------------------------------------------------------------------------------------------------------------------
*/

// typical protocols, disable here! Enable Remarks F_INTERRUPTS Program Space
#define IRMP_SUPPORT_SIRCS_PROTOCOL 1 // Sony SIRCS >= 10000 ~150 bytes //
#define IRMP_SUPPORT_NEC_PROTOCOL 1 // NEC + APPLE >= 10000 ~300 bytes //
#define IRMP_SUPPORT_SAMSUNG_PROTOCOL 1 // Samsung + Samsg32 >= 10000 ~300 bytes //
#define IRMP_SUPPORT_RC5_PROTOCOL 1 // RC5 >= 10000 ~250 bytes //

// more protocols, enable here! Enable Remarks F_INTERRUPTS Program Space
#define IRMP_SUPPORT_KASEIKYO_PROTOCOL 1 // Kaseikyo >= 10000 ~250 bytes //
#define IRMP_SUPPORT_JVC_PROTOCOL 1 // JVC >= 10000 ~150 bytes //
#define IRMP_SUPPORT_NEC16_PROTOCOL 1 // NEC16 >= 10000 ~100 bytes //
#define IRMP_SUPPORT_NEC42_PROTOCOL 1 // NEC42 >= 10000 ~300 bytes //
#define IRMP_SUPPORT_MATSUSHITA_PROTOCOL 1 // Matsushita >= 10000 ~50 bytes //
#define IRMP_SUPPORT_DENON_PROTOCOL 1 // DENON, Sharp >= 10000 ~250 bytes //
#define IRMP_SUPPORT_RC6_PROTOCOL 1 // RC6 & RC6A >= 10000 ~250 bytes //
#define IRMP_SUPPORT_IR60_PROTOCOL 0 // IR60 (SDA2008) >= 10000 ~300 bytes //
#define IRMP_SUPPORT_GRUNDIG_PROTOCOL 0 // Grundig >= 10000 ~300 bytes //
#define IRMP_SUPPORT_SIEMENS_PROTOCOL 0 // Siemens Gigaset >= 15000 ~550 bytes
#define IRMP_SUPPORT_NOKIA_PROTOCOL 0 // Nokia >= 10000 ~300 bytes //

// exotic protocols, enable here! Enable Remarks F_INTERRUPTS Program Space
#define IRMP_SUPPORT_BOSE_PROTOCOL 0 // BOSE >= 10000 ~150 bytes //
#define IRMP_SUPPORT_KATHREIN_PROTOCOL 0 // Kathrein >= 10000 ~200 bytes //
#define IRMP_SUPPORT_NUBERT_PROTOCOL 0 // NUBERT >= 10000 ~50 bytes
#define IRMP_SUPPORT_FAN_PROTOCOL 0 // FAN (ventilator) >= 10000 ~50 bytes //
#define IRMP_SUPPORT_SPEAKER_PROTOCOL 0 // SPEAKER (~NUBERT) >= 10000 ~50 bytes //
#define IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL 0 // Bang & Olufsen >= 10000 ~200 bytes //
#define IRMP_SUPPORT_RECS80_PROTOCOL 0 // RECS80 (SAA3004) >= 15000 ~50 bytes //
#define IRMP_SUPPORT_RECS80EXT_PROTOCOL 0 // RECS80EXT (SAA3008) >= 15000 ~50 bytes //
#define IRMP_SUPPORT_THOMSON_PROTOCOL 0 // Thomson >= 10000 ~250 bytes //
#define IRMP_SUPPORT_NIKON_PROTOCOL 0 // NIKON camera >= 10000 ~250 bytes //
#define IRMP_SUPPORT_NETBOX_PROTOCOL 0 // Netbox keyboard >= 10000 ~400 bytes (PROTOTYPE!)
#define IRMP_SUPPORT_ORTEK_PROTOCOL 0 // ORTEK (Hama) >= 10000 ~150 bytes
#define IRMP_SUPPORT_TELEFUNKEN_PROTOCOL 0 // Telefunken 1560 >= 10000 ~150 bytes //
#define IRMP_SUPPORT_FDC_PROTOCOL 0 // FDC3402 keyboard >= 10000 (better 15000) ~150 bytes (~400 in combination with RC5)
#define IRMP_SUPPORT_RCCAR_PROTOCOL 0 // RC Car >= 10000 (better 15000) ~150 bytes (~500 in combination with RC5)
#define IRMP_SUPPORT_ROOMBA_PROTOCOL 0 // iRobot Roomba >= 10000 ~150 bytes
#define IRMP_SUPPORT_RUWIDO_PROTOCOL 0 // RUWIDO, T-Home >= 15000 ~550 bytes
#define IRMP_SUPPORT_A1TVBOX_PROTOCOL 0 // A1 TV BOX >= 15000 (better 20000) ~300 bytes //
#define IRMP_SUPPORT_LEGO_PROTOCOL 0 // LEGO Power RC >= 20000 ~150 bytes
#define IRMP_SUPPORT_RCMM_PROTOCOL 0 // RCMM 12,24, or 32 >= 20000 ~150 bytes
#define IRMP_SUPPORT_LGAIR_PROTOCOL 0 // LG Air Condition >= 10000 ~300 bytes //
#define IRMP_SUPPORT_SAMSUNG48_PROTOCOL 0 // Samsung48 >= 10000 ~100 bytes // (SAMSUNG must be enabled!)
#define IRMP_SUPPORT_MERLIN_PROTOCOL 0 // Merlin >= 15000 (better 20000) ~300 bytes
#define IRMP_SUPPORT_PENTAX_PROTOCOL 0 // Pentax >= 10000 ~150 bytes //
#define IRMP_SUPPORT_S100_PROTOCOL 0 // S100 >= 10000 ~250 bytes
#define IRMP_SUPPORT_ACP24_PROTOCOL 0 // ACP24 >= 10000 ~250 bytes
#define IRMP_SUPPORT_TECHNICS_PROTOCOL 0 // TECHNICS >= 10000 ~250 bytes //
#define IRMP_SUPPORT_PANASONIC_PROTOCOL 0 // PANASONIC Beamer >= 10000 ~250 bytes
#define IRMP_SUPPORT_RADIO1_PROTOCOL 0 // RADIO, e.g. TEVION >= 10000 ~250 bytes (experimental)

#endif /* KODI_IR_CONFIG_H_ */[/syntax]

VIII.Podsumowanie:
No cóż, po raz kolejny udało się zrealizować wstępne założenia projektu
Dostaliśmy odbiornik niewielki, sprytny, łatwy w obsłudze (aczkolwiek zdaję sobie sprawę, że na pewno dla twórcy, dla użytkowników pewnie się okaże ) i z kilkoma ciekawymi "ficzerami"

Co należy jeszcze poprawić?
1. Na pewno należy powalczyć jeszcze z kodem. Odbiornik powstał ok. roku temu, kiedy to jeszcze nie potrafiłem stosować callbacków ani zdarzeń. Warto te techniki programowania zastosować do obsługi biblioteki IRMP, tak by jeszcze uprościć kod.

2. Warto zastanowić się nad poprawą implementacji V-USB. Obsługę, którą zastosowałem robiłem trochę po omacku. Dopiero liznąłem tę tematykę i trochę działałem metodą prób i błędów, po omacku

3. Odbiornik właściwie nadaje się tylko do Kodi, a można by pomyśleć o bardziej zaawansowanej obsłudze np. można stworzyć dedykowaną aplikację na PC, która będzie zarządzała skrótami klawiaturowymi i przyporządkowywała je kodom IR, następnie "wgrywała" do odbiornika, tak by dopasować działanie nawet do innych aplikacji.

To by było na razie wszystko
Mam nadzieję, że miłośników Kodi, na forum Atnel, jeszcze przybędzie

VIII.Źródła:

IRMP: http://www.mikrocontroller.net/articles ... nglish#top

V-USB: https://www.obdev.at/products/vusb/index.html
http://eleccelerator.com/tutorial-about ... scriptors/
http://code.birkler.se/usb-ir-hid/
http://codeandlife.com/2012/06/18/usb-h ... ith-v-usb/

KODI: http://kodi.wiki/view/keymap
http://wiki.openelec.tv/index.php/Main_Page

HID: http://www.usb.org/developers/hidpage/Hut1_12v2.pdf

VDR: https://www.linuxtv.org/vdrwiki/index.php/Main_Page

Statystyki: Napisane przez Zealota — 11 cze 2017, o 21:54