W świetle dnia, a potem we śnie wpadłem na pomysł stworzenia własnego, regulowanego dekodera. Właściwie to wtedy otworzył się przede mną bogaty i bogaty świat inżynierii radiowej. Ponieważ nie zajmowałem się wcześniej poważnym rozwojem elektroniki, mój wybór padł na prostszą opcję - Arduino i jest to najpopularniejszy model ONZ.
Plan pracy
1. Zajmij się biblioteką
2. Przylutuj kartę wyjścia wideo
3. Napisz kod
4. Wytnij ciało
Końcowy komponent zewnętrzny nie jest w przypadku takich projektów szczególnie istotny.
Krok 1. Zastanówmy się, co jest co
Po kilkudziesięciu minutach desperackiego googlowania doszedłem do wniosku, że nie byłbym w stanie stworzyć konsoli nawet takiej jak Dandy. Cóż mogę zrobić, skoro wziąłem to na siebie, doprowadzę to do końca.
Na stronie poświęconej projektom Arduino i ogólnie elektronice radiowej (nie reklamowej) znalazłem artykuł o podobnym pomyśle. Zdecydowano się skorzystać z biblioteki Wyjście telewizyjne, ponieważ dekoder jest dekoderem telewizyjnym. Aby go zainstalować i uruchomić, trzeba było się trochę nagimnastykować.
Wymagane funkcje biblioteczne
Funkcje ustawiania trybu
Funkcjonować zaczynać() inicjuje wyjście wideo (domyślna rozdzielczość ekranu 128x96).
Składnia:
TVOut.begin(tryb);
TVOut.begin(tryb, x, y);
Opcje:
tryb – standard sygnału wideo:
_PAL – tryb PAL;
_NTSC – tryb NTSC.
Wartość zwracana:
0 – w przypadku udanego połączenia, 4 – w przypadku niepowodzenia (za mało pamięci dla bufora wyjściowego).
Funkcje opóźnienia
Funkcjonować opóźnienie() opóźnia obraz wyjściowy.
Składnia:
Opóźnienie wyjścia TV(ms);
Opcje:
ms – opóźnienie w ms z dokładnością: 20 ms dla PAL i 16 ms dla NTSC.
Funkcja opóźnienia_frame() opóźnia wyświetlany obraz.
Składnia:
TVOut.delay_frame(ramki);
Opcje:
ramki – liczba ramek dla opóźnienia...
Ta funkcja jest przydatna do minimalizowania lub eliminowania migotania ekranu spowodowanego odświeżaniem ekranu.
Funkcje pobierające parametry
Funkcjonować godz() zwraca poziomą rozdzielczość ekranu.
Składnia:
TVOut.godz.();
Opcje:
NIE.
Wartość zwracana:
unsigned char – pozioma rozdzielczość ekranu.
Funkcja vres() zwraca pionową rozdzielczość ekranu.
Składnia:
TVOut.vres();
Opcje:
NIE.
Wartość zwracana:
unsigned char – pionowa rozdzielczość ekranu.
Funkcjonować char_line() zwraca maksymalną możliwą liczbę znaków w jednej linii podczas wyświetlania informacji tekstowych.
Składnia:
Wyjście TV. char_line();
Opcje:
NIE.
Wartość zwracana:
unsigned char – liczba znaków.
Podstawowe funkcje graficzne
Funkcjonować set_pixel() ustawia kolor piksela ekranu w punkcie o podanych współrzędnych.
Składnia:
TVOut.set_pixel(x,y,kolor);
Opcje:
x,y – współrzędne pikseli;
kolor – kolor piksela:
0 – czarny;
1 – biały;
2 – odwróć kolor.
Funkcjonować get_pixel() pobiera kolor piksela ekranu z punktu o podanych współrzędnych.
Składnia:
TVOut.get_pixel(x,y);
Opcje:
x,y – współrzędne pikseli.
Wartość zwracana:
kolor – kolor piksela:
0 – czarny;
1 – biały;
2 – odwróć kolor.
Funkcja fill() wypełnia ekran określonym kolorem.
Składnia:
TVOut.fill(kolor);
Opcje:
kolor – kolor wypełnienia:
0 – czarny;
1 – biały;
2 – odwróć kolor.
Funkcjonować czysty ekran() czyści ekran wypełniając go określonym kolorem.
Składnia:
TVOut.clear_screen(kolor);
Opcje:
kolor – kolor wypełnienia:
0 – czarny;
1 – biały;
2 – odwróć kolor.
Funkcjonować odwracać() odwraca zawartość ekranu.
Składnia:
TVOut.invert();
Opcje:
NIE.
Funkcja shift_direction() przesuwa zawartość ekranu.
Składnia:
TVOut.shift_direction(odległość, kierunek);
Opcje:
odległość – odległość do przesunięcia zawartości ekranu.
kierunek – zmiana kierunku:
UP=0 – w górę;
DÓŁ=1 – dół;
LEWY=2 – lewy;
PRAWY=3 – w prawo.
Funkcjonować rysować linię()łączy dwa punkty na ekranie linią.
Składnia:
TVOut.draw_line(x0,y0,x1,y1,kolor);
Opcje:
x0,y0 – współrzędne pierwszego punktu;
x1,y1 – współrzędne drugiego punktu;
kolor – kolor wypełnienia:
0 – czarny;
1 – biały;
2 – odwróć kolor.
Funkcjonować rysuj_row() Wypełnia linię określonym kolorem pomiędzy dwoma punktami na linii.
Składnia:
TVOut.draw_row(wiersz,x0,x1,kolor);
Opcje:
rząd – pionowa współrzędna rzędu;
x1,x2 – współrzędne poziome punktów linii;
kolor – kolor wypełnienia:
0 – czarny;
1 – biały;
2 – odwróć kolor.
Funkcja Draw_column() wypełnia wiersz określonym kolorem pomiędzy dwoma punktami w kolumnie.
Składnia:
TVOut.draw_column(kolumna,y0,y1,kolor);
Opcje:
słup – współrzędna pozioma słupa;
y1,y2 – współrzędne pionowe punktów słupów;
kolor – kolor wypełnienia:
0 – czarny;
1 – biały;
2 – odwróć kolor.
Funkcjonować remis_rect() rysuje prostokąt na ekranie.
Składnia:
TVOut.draw_rect(x,y,w,h,kolor);
TVOut.draw_rect(x,y,w,h,kolor,kolor wypełnienia);
Opcje:
x,y – współrzędne lewego górnego punktu;
w,h – szerokość i wysokość rysowanego prostokąta;
kolor – kolor krawędzi prostokąta:
0 – czarny;
1 – biały;
2 – odwróć kolor.
fillcolor – kolor wypełnienia prostokąta:
0 – czarny;
1 – biały;
2 – odwróć kolor.
Funkcjonować rysuj_koło() rysuje okrąg na ekranie.
Składnia:
TVOut.draw_circle(x,y,r,kolor);
TVOut.draw_circle(x,y,r,kolor,kolor wypełnienia);
Opcje:
x,y – współrzędne środka okręgu;
r – promień okręgu;
kolor – kolor granic okręgu:
0 – czarny;
1 – biały;
2 – odwróć kolor.
fillcolor – kolor wypełnienia okręgu:
0 – czarny;
1 – biały;
2 – odwróć kolor.
Funkcjonować bitmapa() Wyświetla obraz rastrowy na ekranie.
Składnia:
TVOut.bitmap(x,y,bmp,w,h);
Opcje:
x,y – współrzędne lewego górnego rogu punktu wyjściowego;
bmp – wskaźnik do tablicy pamięci, w której przechowywany jest obraz;
w,h – szerokość, wysokość wyświetlanego obrazu;
Poniżej przyjrzymy się procesowi tworzenia kodu wyjściowych obrazów rastrowych.
Funkcje wyjściowe informacji tekstowych
Aby skorzystać z funkcji wyprowadzania informacji tekstowych, należy połączyć pliki z czcionkami zawartymi w bibliotece lub niestandardowymi. Aby połączyć niestandardowy zestaw czcionek, musisz dołączyć plik nagłówkowy do szkicu:
#włączać
Biblioteka zawiera następujące zestawy czcionek:
czcionka 4x6;
czcionka6x8;
czcionka 8x8;
czcionka8x8ext.
Funkcjonować wybierz_czcionka() wybiera czcionkę do wyświetlania informacji tekstowych.
Składnia:
TVOut.select_font(czcionka);
Opcje:
czcionka – czcionka zawarta w szkicu.
Funkcja print_char() wypisuje znak na ekranie.
Składnia:
TVOut.print_char(x,y,char);
Opcje:
x,y – pozycja na ekranie, w której wyświetlany jest symbol;
char – znak z aktualnej czcionki.
Funkcjonować set_cursor() ustawia pozycję kursora do wyświetlania informacji tekstowych na ekranie.
Składnia:
TVOut.set_cursor(x,y);
Opcje:
x,y – współrzędne kursora.
Funkcjonować wydrukować() wyświetla ciąg, znak lub liczbę.
Składnia:
TVOut.print(x,y,string);
TVOut.print(x,y,char,base);
TVOut.print(x,y,int,base).
Opcje:
x,y – współrzędne kursora.
baza – format wyjściowy:
BAJT = 0;
GRUDZIEŃ = 10 (domyślnie);
szesnastkowy = 16.
Funkcjonować println() wyświetla ciąg, znak lub liczbę, po których następuje znak nowej linii:
Składnia:
TVOut.println(x,y,string);
TVOut.println(x,y,char,base);
TVOut.println(x,y,int,base).
Opcje:
x,y – współrzędne kursora.
baza – format wyjściowy:
BAJT = 0;
GRUDZIEŃ = 10 (domyślnie);
szesnastkowy = 16.
Funkcje wyjścia audio
Funkcje wyjścia audio umożliwiają wysyłanie sygnału o określonej częstotliwości do telewizora za pośrednictwem wyjścia audio.
Funkcjonować ton() wytwarza sygnał dźwiękowy o określonej częstotliwości.
Składnia:
TVOut.tone(częstotliwość, czas trwania);
Ton wyjściowy TV (częstotliwość).
Opcje:
częstotliwość – częstotliwość sygnału audio;
czas trwania – czas trwania sygnału.
Funkcjonować niejeden() zatrzymuje wyjście audio.
Składnia:
TVOut.noTone().
Krok 2. Przylutuj wyjście wideo
Przede wszystkim musimy przylutować określoną płytkę, aby wyprowadzić sygnał wideo przez kompozytowe wyjście AV (RCA). Lutujemy według następującego schematu:
Umieścimy równolegle do siebie dwa rezystory o wartości nominalnej 470 omów i 1 kΩ i przylutujemy do nich „plus” kabla tulipana. Następnie przeprowadzimy przewód od rezystora 470 omów do siódmego pinu Arduino, ponieważ jest odpowiedzialny za wyjście wideo ( wideo), a z rezystora 1 kΩ przeniesiemy przewód do dziewiątego pinu, ponieważ jest on odpowiedzialny za synchronizację ( synchronizacja). I „minus” od kabla tulipanowego do „masy” w Arduino. Więcej szczegółów ( język angielski)
Krok 3. Napisz kod (gra)
Nie będę wyjaśniał co i jak podłączyć, bo potrzebne informacje jak zawsze można znaleźć w internecie. Opisuję coś, co bardzo trudno znaleźć lub w ogóle nie istnieje.
Zacznijmy ekran powitalny Gdzie byśmy byli bez niego? Ale tutaj pojawia się ważne pytanie: jak nazwać ten cud? Myślałem o tym i wymyśliłem - Shimo. Brzmi nieźle, nawet technologicznie zaawansowanie, oczywiście po chińsku, ale to nie ma znaczenia.
Zaczynać. Narysuj linię przez środek ekranu za pomocą TV.draw_line(60,0,60,96,1);. Kula pojawia się dokładnie na środku ekranu. Zapiszmy funkcję jego ruchu void ballmove(int vel, int kąt). Zainstaluj za pomocą TV.set_pixel(x,y,1);, tak nazwałem zmienne.
Następnie przed manipulacją piłką określamy aktualizację ekranu, a raczej tak, aby piłka nie „dziedziczyła” po ekranie, więc przechodząc do kolejnej pozycji, trzeba zamalować poprzednią na czarno. Aby to zrobić, musimy pisać przed wszystkim innym TV.set_pixel(x,y,0);. Po wszystkich zmianach zmiennych współrzędnych należy określić ustawienie pozycji i krótkie opóźnienie - opóźnienie TV(50);. Powinno to wyglądać mniej więcej tak:
Void ballmove(int vel, int angle) ( TV.set_pixel(x,y,0); //Manipulacja współrzędnymi TV.set_pixel(x,y,1); )
Teraz o samych zmianach współrzędnych. W sumie osiem kierunków (1-8), zmienne kąt int. A potem po prostu, w zależności od rotacji, odejmujemy lub dodajemy do zmiennych dowolną część prędkość int. Ja to zrobiłem:
If(kąt == 1) ( y -= poziom; ) if(kąt == 3) ( x += poziom; ) if(kąt == 5) ( y += poziom; ) if(kąt == 7) ( x -= poziom; ) if(kąt == 2) ( x += okrągły(vel/2); y -= okrągły(vel/2); ) if(kąt == 4) ( x += okrągły(vel/ 2); y += okrągły(vel/2); ) if(kąt == 6) ( x -= okrągły(vel/2); y += okrągły(vel/2); ) if(kąt == 8) ( x -= okrągły(vel/2); y -= okrągły(vel/2); )
Teraz ruchy rakietą. Tutaj ważne wyjaśnienie - użyłem tylko współrzędnych wg y, ponieważ pozycje rakiet wg X nie zmieniaj. Piszemy następującą funkcję unieważnij ruch rakiet(). Następnie rysujemy rakiety, zmienne int yb1, int yb2, TV.draw_line(10, yb1+8, 10, yb1-8, 1); I TV.draw_line(110, yb2+8, 110, yb2-8, 1);. Aktualizacja ekranu, czyli „bez śladu”, przebiega podobnie jak w przypadku piłki.
Sterowanie rakietami odbywa się za pomocą przycisków. Łączenie przycisków i pinów 2 I 3 - pierwsza rakieta, 4 I 5 - druga rakieta. Sprawdzamy naciśnięcia przycisków i zmieniamy współrzędne.
Oto funkcja:
Void racketsmove() ( TV.draw_line(10, yb1+8, 10, yb1-8, 0); TV.draw_line(110, yb2+8, 110, yb2-8, 0); if((yb1 - 8) > 1) ( if(digitalRead(2) == WYSOKI) ( yb1 -= 2;) ) if((yb1 + 8)< 95) { if(digitalRead(3) == HIGH) {yb1 += 2;} } if((yb2 - 8) >1) ( if(digitalRead(4) == WYSOKI) (yb2 -= 2; ) ) if((yb2 + 8)< 95) { if(digitalRead(5) == HIGH) {yb2 += 2;} } TV.draw_line(10, yb1+8, 10, yb1-8, 1); TV.draw_line(110, yb2+8, 110, yb2-8, 1); }
Teraz wróćmy do piłka. Zapiszmy teraz jego zderzenie i odpychanie od ścian i rakiet. Funkcja - pusty ballcol(). Aby to zrobić, po prostu sprawdzamy jego położenie względem obiektów, a następnie kąt. Następnie zmieniamy ten kąt na inny. Kąt jest łatwy do odgadnięcia.
Kąt odbicia jest równy kątowi padania
Można wprowadzić pewne wyjątki fizyczne dla niektórych obszarów rakiet.
Void ballcol() ( if(x == 1 || x == 119 || (x == 10 && y< (yb1 + 3) && y > < (yb2 + 3) && y > < (yb1 - 3) && y >(yb1 - 8)) ( a = 2; ) if(x == 10 && y > (yb1 + 3) && y< (yb1 + 8)) { a = 4; } if(x == 110 && y < (yb2 - 3) && y >(yb2 - 8)) ( a = 8; ) if(x == 110 && y > (yb2 + 3) && y< (yb2 + 8)) { a = 6; } if(y == 95 || y == 1) { if(a==1){a=5;}else if(a==2){a=4;}else if(a==3){a=7;}else if(a==4){a=2;}else if(a==5){a=1;}else if(a==6){a=8;}else if(a==7){a=3;}else if(a==8){a=6;} } }
Najtrudniejsza część już za nami, możesz z powodzeniem oddychać.
W tej chwili jedyne, co musimy zrobić, to stworzyć system punktacji, licznik czasu i restart.
Zacznijmy od timera. Istnieje zmienna sekundowa pływać ts(jest przechowywany absolutnie przez cały czas), zmienna int.tm(liczba minut, z których otrzymamy ts). Ustaw wartość tm operacja tm = ts/60;. I wyświetl wartości na ekranie, TV.print(81,1,tm); TV.print(97,1,."); TV.print(100,1,int(ts-(tm*60)));.
Kontynuujmy. Wywołujemy funkcję restartu unieważnij ponowne uruchomienie(). Tutaj zwracamy oryginalne wartości zmiennych.
Unieważnij restart() ( TV.clear_screen(); x = 60; y = 48; yb1 = 48; yb2 = 48; a = 8; ts = 900,0; c1 = 0; c2 = 0; )
Finał, system punktacji, to zbyt proste. Otwórz Google i wpisz „Zasady tenisa stołowego”. Szukamy za co przyznawane są punkty. Znajdujemy część dotyczącą kar, a następnie z powodzeniem znajdujemy następującą informację: „Punkt uważa się za zdobyty, jeśli przeciwnik nie ma czasu na prawidłowe odbicie piłki wysłanej do niego po pierwszym odbiciu”. Powstaje pytanie, jak liczyć ciosy i tak dalej?.. Ale ciosów nawet nie trzeba liczyć, bo nasz ping-pong ma dwuwymiarową grafikę.
Spokojnie znajdujemy wyjście z sytuacji i jak zawsze po prostu sprawdzamy współrzędne względem bocznych ścian. W przypadku kolizji przyznajemy punkt zawodnikowi po przeciwnej stronie boiska. Funkcja - unieważnij liczbę piłek(). Kiedy upłynie czas, porównujemy wyniki pierwszego gracza (zmienna int c1) i drugiego gracza (zmienna intc2), ogłaszamy zwycięzcę, opóźniamy i ogłaszamy restart.
Nieważna liczba kul() ( if(x == 1) ( c2++; ) if(x == 119) ( c1++; ) if(c1 >< c2 && ts == 0) { TV.println(10, 45, "Player 2 won!"); delay(10000); restart(); } else if(c1 == c2 && ts == 0) { TV.println(10, 45, "You are equal"); delay(10000); restart(); }
To wszystko, przyjaciele, całkowicie napisaliśmy kod gry. Okazało się całkiem zabawne i można grać.
Dla leniwych po prostu napiszę cały kod.
Pełny scenariusz
W sumie jest 218 linii. #włączać
Krok 4. Wytnij ciało
Postanowiłem wyciąć korpus za pomocą wycinarki laserowej (lub frezarki, nie jestem pewien) ze sklejki o grubości 4 mm. Narysowałem go w InkScape, trochę pokombinowałem i przekonwertowałem do formatu frezarki.
Do gamepadów wyciąłem małe tabliczki i wywierciłem w nich otwory na przyciski. Wyszło dobrze, ale niestety zgubiłem zdjęcie.
Wniosek
W trakcie prac powstała na Arduino prosta konsola do gier telewizyjnych, zawierająca standardową grę Ping Pong, z dwoma gamepadami, w które możemy grać, a nawet w których możemy się utknąć.
Słowo od tłumacza: Dawno, dawno temu, gdy kraj i drzewa były duże, a moja wyobraźnia była po prostu nieograniczona, miałem marzenie - możliwość wyświetlania obrazów z mojego programowalnego mikrokalkulatora Electronics MK-61 (no cóż, są różne wykresy, krzywe , zdjęcia) na ekranie telewizora. To były szalone, późnoradzieckie czasy i nie tylko konsola do gier i bardzo osobisty MICROkomputer („Pravets 8D”, „Specialist” czy „Siknkler”), ale także magnetowidy były nowością. W ogóle ludzie domagali się spektaklu i zrozumieją mnie ci, którzy pamiętają cykl publikacji edukacyjno-rozrywkowych dotyczących kalkulatorów programowalnych pod ogólnym tytułem „Ścieżka do Ziemi” (magazyn „Technologia – Młodzież”).
Krótko mówiąc, w formie powieści science fiction z dobrą fabułą została opisana podróż dwóch idiotycznych, przypadkowych znajomych – zawodowego astronauty i głównego cybernetyka z Księżyca na Ziemię. Tym, co nadało całej fabule szczególnego uroku, był fakt, że podróżowali tzw. „Lunolet”, czyli mały statek kosmiczny z silnikiem chemicznym, przeznaczony do poruszania się w warunkach bezpośredniej widoczności nad księżycami i innymi ciałami niebieskimi podobny do kuli bilardowej z prostą ulgą. Każdy numer cyklu zawierał uproszczony, prawdziwy, ale uzasadniony matematyczny opis każdego manewru zarówno w warunkach silnej (stosunkowo) grawitacji pobliskiego ciała niebieskiego, jak i wtedy, gdy na pocisk niebieski wpływali bohaterowie grawitacji Ziemia i Księżyc, a także program do obliczania kolejnego etapu lotu. Generalnie samo patrzenie na liczby na ekranie kalkulatora nie wystarczyło, ale zależało mi na pięknych krzywiznach na ekranie (jak w MCC).
Z drugiej strony nie zapominajmy, że nawet prymitywne mikrokontrolery z rodziny Arduino są o rząd wielkości lepsze wydajnością nie tylko od mikroprocesorów ówczesnych flagowców – MK-52 i MK-61, ale także od możliwości obliczeniowych niektórych 8-bitowe konsole do gier z późniejszych czasów (Atary 2600 i inne Rambos Tak, proszę pana).
Ogólnie wprowadzenie okazało się trochę przydługie, więc przejdźmy do tematu dzisiejszej lekcji – wyprowadzenia obrazu wideo z Arduino na ekran telewizora.
Niestety, cechy konstrukcyjne Arduino pozwalają na generowanie wyłącznie obrazów monochromatycznych (czarno-białych), chociaż może to być przydatne w niektórych projektach, a plik CSV z pewnością uszczęśliwi noobów...
Krok pierwszy. Części i oprogramowanie
Będziesz potrzebować:
Części i jednostki:
- Mikrokontroler Arduino
- Telewizor (bez niego nie można się nigdzie ruszyć)
- Płytka rozwojowa lub nakładka dla Arduino
- 2 rezystory o wartości nominalnej 470 omów i 1 Kom
- 2 dwupinowe adaptery montażowe męski na męski
- Ekranowany kabel telewizyjny z tulipanem na końcu
Oprogramowanie:
- Środowisko programistyczne/oprogramowania sprzętowego Arduino. Oficjalne łącze
Krok drugi. Montaż
W imieniu autora przepraszam za obrzydliwie niską jakość obrazu gotowego adaptera TV. Wyjaśnia to fakt, że pisząc instrukcje, najpierw trzeba je napisać, a następnie przystąpić do montażu, starannie rejestrując fotograficznie wszystkie etapy. W naszym przypadku wszystko potoczyło się dokładnie odwrotnie, więc po prostu nie da się niczego zrozumieć z mętnego obrazu gotowego adaptera.
Dużo lepiej jest wytłumaczyć co, gdzie i jak lutować jest schemat obwodu, który również składa się tylko z kilku części.
Pinout:
Synchronizacja - cyfrowy pin 9 mikrokontrolera
Wideo - wyjście cyfrowe 8 mikrokontrolera
GND - pin GND mikrokontrolera
Krok trzeci. Programowanie
Najfajniejszą częścią jest programowanie.
W zasadzie wydano już nową wersję biblioteki TV, jednak jest ona jeszcze bardziej błędna i niestabilna niż R5.91, z której korzysta autor, dlatego lepiej pobrać bibliotekę z linku powyżej.
Program Tex dla leniwych, którym nie chce się przepisywać kodu z kopii ekranu:
#włączać
Zakłada się, że znasz podstawowe zasady działania i programowania Arduino – podobnych mikrokontrolerów, dlatego autor postanowił nie błąkać się po drzewie, zalecając zapoznanie się z poniższymi poleceniami biblioteki:
- Begin(mode) Rozpoczyna wyświetlanie informacji na ekranie. Standardowa rozdzielczość - 128x96
- Begin(mode,x,y) Rozpoczyna wyświetlanie informacji na ekranie. Rozdzielczość jest określana przez użytkownika za pomocą argumentów x,y
- end() Wyczyść bufor wideo
- force_vscale(sfactor) Wymuś liczbę wyświetleń każdej linii.
- force_outstart(time) Wymusza czas rozpoczęcia wysyłania na aktywnej linii.
- force_linestart(line) Wymusza rozpoczęcie wysyłania danych na linię.
- set_vbi_hook(func) Ustawia funkcję wywoływaną raz na okres wygaszania pionowego.
- set_hbi_hook(func) Ustawia funkcję wywoływaną raz na okres wygaszania poziomego.
- hres() Polecenie zwraca wartość rozdzielczości poziomej,
- vres() Polecenie zwraca wartość rozdzielczości pionowej,
- char_line() Polecenie zwraca liczbę znaków mieszczących się w linii.
- set_pixel(x,y,color) Ustawia kolor piksela w określonych współrzędnych
- get_pixel(x,y) Ustawia piksel o podanych współrzędnych jako punkt odniesienia.
- fill(color) Wypełnia ekran określonym kolorem.
- clear_screen() Czyści ekran.
- invert() Odwraca obraz na ekranie.
- shift(odległość,kierunek) Przewija ekran o określoną odległość w dowolnym z 6 kierunków.
- Draw_line(x0,y0,x1,y1,color) Utwórz linię od współrzędnych (x0,y0) do współrzędnych (x1,y1).
- Draw_row(row,x0,x1,color) Wypełnia wiersz współrzędnymi od x0 do x1 o podanym kolorze.
- remis_column(kolumna,y0,y1,kolor) Wypełnia kolumnę współrzędnymi od y0 do y1 określonym kolorem.
- remis_rect(x,y,w,h,color,fillcolor) Rysuje prostokąt o początku we współrzędnych (x,y) i wymiarach (h,w) i wypełnia podanym kolorem.
- remis_rect(x,y,w,h,color) Rysuje prostokąt, którego początek ma współrzędne (x,y) i wymiary (h,w).
- remis_circle(x,y,radius,color,fillcolor) Rysuje okrąg o środku (x,y) i promieniu (RADIUS) i wypełnia go danym kolorem
- remis_circle(x,y,promień,kolor) Rysuje okrąg o środku we współrzędnych (x,y) i promieniu (RADIUS).
- bitmap(x,y,bmp,i,width,height) Wyświetla określony obraz we współrzędnych..
- print_char(x,y,c) Drukuje znak we współrzędnych (x,y).
- set_cursor(x,y) Ustawia pozycję wyświetlania następnego znaku.
- select_font(font) Ustawia czcionkę dla tekstu wyjściowego.
- print() Drukuje tekst.
- println() Drukuje pojedynczą linię.
- printPGM() Drukuje linię tekstu z pamięci programu.
- tone(frequency) Ton o określonej częstotliwości.
- tone(częstotliwość, czas trwania) Sygnał tonowy o określonej częstotliwości i czasie trwania.
- noTone() Zatrzymuje generowanie tonu.
Krok czwarty. Ukończenie
Jak wykorzystać płytkę Arduino do wyświetlenia dowolnych informacji na telewizorze? Okazuje się, że istnieje taka biblioteka TVOut (artykuł na stronie), która umożliwia wyświetlanie informacji w telewizji za pomocą kabla niskiej częstotliwości (tulipan). To prawda, że obraz będzie czarno-biały, ale to wystarczy w przypadku większości projektów.
Oto konsola do gier, w której używana jest ta biblioteka
Strona projektu http://nootropicdesign.com/hackvision/index.html
Cena tablicy wynosi 43,95 dolarów.
Stwórzmy własny dekoder telewizyjny, składający się z płytki Arduino i joysticka x-y i napiszmy prostą grę.
Oto widok naszej konsoli
Zapoznajmy się z możliwościami biblioteki i napiszmy grę.
Strona biblioteki - http://code.google.com/p/arduino-tvout
Tutaj możesz pobrać bibliotekę i zobaczyć opis funkcji.
Biblioteka wykorzystuje następujące piny Arduino
Płyta SYNC VIDEO AUDIO Decimilia, Uno, Nano 9 7 11 Mega 11 A7(D29) 10
Przyjrzyjmy się głównym funkcjom biblioteki.
Funkcje ustawiania trybu
Funkcja Begin() inicjuje wyjście wideo (domyślna rozdzielczość ekranu 128x96)
Składnia:
- TVOut.begin(tryb);
- TVOut.begin(tryb, x, y);
Opcje:
- tryb – standard sygnału wideo:
- _PAL – tryb PAL;
- _NTSC – tryb NTSC.
Wartość zwracana:
- 0 – w przypadku udanego połączenia, 4 – w przypadku niepowodzenia (za mało pamięci dla bufora wyjściowego).
Funkcje opóźnienia
Funkcja opóźnienia() opóźnia obraz wyjściowy.
Składnia:
- Opóźnienie wyjścia TV(ms);
Opcje:
- ms – opóźnienie w ms z dokładnością: 20 ms dla PAL i 16 ms dla NTSC.
Funkcja opóźnienia_frame() opóźnia wyświetlany obraz.
Składnia:
- TVOut.delay_frame(ramki);
Opcje:
- ramki – liczba ramek dla opóźnienia..
Ta funkcja jest przydatna do minimalizowania lub eliminowania migotania ekranu spowodowanego odświeżaniem ekranu.
Funkcje pobierające parametry
Funkcja hres() zwraca poziomą rozdzielczość ekranu.
Składnia:
- TVOut.godz.();
Opcje:
Wartość zwracana:
- unsigned char – pozioma rozdzielczość ekranu.
Funkcja vres() zwraca pionową rozdzielczość ekranu.
Składnia:
- TVOut.vres();
Opcje:
Wartość zwracana:
- unsigned char – pionowa rozdzielczość ekranu.
Funkcja char_line() zwraca maksymalną możliwą liczbę znaków w jednym wierszu podczas wyświetlania informacji tekstowych.
Składnia:
- Wyjście TV. char_line();
Opcje:
Wartość zwracana:
- unsigned char – liczba znaków.
Podstawowe funkcje graficzne
Funkcja set_pixel() ustawia kolor piksela ekranu w punkcie o podanych współrzędnych.
Składnia:
- TVOut.set_pixel(x,y,kolor);
Opcje:
- x,y – współrzędne pikseli;
- kolor – kolor piksela:
- 0 – czarny;
- 1 – biały;
- 2 – odwróć kolor.
Funkcja get_pixel() pobiera kolor pikseli ekranu z punktu o podanych współrzędnych.
Składnia:
- TVOut.get_pixel(x,y);
Opcje:
- x,y – współrzędne pikseli.
Wartość zwracana:
- kolor – kolor piksela:
- 0 – czarny;
- 1 – biały;
- 2 – odwróć kolor.
Funkcja fill() wypełnia ekran określonym kolorem.
Składnia:
- TVOut.fill(kolor);
Opcje:
- kolor – kolor wypełnienia:
- 0 – czarny;
- 1 – biały;
- 2 – odwróć kolor.
Funkcja clear_screen() czyści ekran, wypełniając go określonym kolorem.
Składnia:
- TVOut.clear_screen(kolor);
Opcje:
- kolor – kolor wypełnienia:
- 0 – czarny;
- 1 – biały;
- 2 – odwróć kolor.
Funkcja invert() odwraca zawartość ekranu.
Składnia:
- TVOut.invert();
Opcje:
Funkcja shift_direction() przesuwa zawartość ekranu.
Składnia:
- TVOut.shift_direction(odległość, kierunek);
Opcje:
- odległość – odległość do przesunięcia zawartości ekranu.
- kierunek – zmiana kierunku:
- UP=0 – w górę;
- DÓŁ=1 – dół;
- LEWY=2 – lewy;
- PRAWY=3 – w prawo.
Funkcja Draw_line() łączy dwa punkty na ekranie linią.
Składnia:
- TVOut.draw_line(x0,y0,x1,y1,kolor);
Opcje:
- x0,y0 – współrzędne pierwszego punktu;
- x1,y1 – współrzędne drugiego punktu;
- kolor – kolor wypełnienia:
- 0 – czarny;
- 1 – biały;
- 2 – odwróć kolor.
Funkcja Draw_row() wypełnia wiersz określonym kolorem pomiędzy dwoma punktami w wierszu.
Składnia:
- TVOut.draw_row(wiersz,x0,x1,kolor);
Opcje:
- rząd – pionowa współrzędna rzędu;
- x1,x2 – współrzędne poziome punktów linii;
- kolor – kolor wypełnienia:
- 0 – czarny;
- 1 – biały;
- 2 – odwróć kolor.
Funkcja Draw_column() wypełnia wiersz określonym kolorem pomiędzy dwoma punktami w kolumnie.
Składnia:
- TVOut.draw_column(kolumna,y0,y1,kolor);
Opcje:
- słup – współrzędna pozioma słupa;
- y1,y2 – współrzędne pionowe punktów słupów;
- kolor – kolor wypełnienia:
- 0 – czarny;
- 1 – biały;
- 2 – odwróć kolor.
Funkcja Draw_rect() rysuje prostokąt na ekranie.
Składnia:
- TVOut.draw_rect(x,y,w,h,kolor);
- TVOut.draw_rect(x,y,w,h,kolor,kolor wypełnienia);
Opcje:
- x,y – współrzędne lewego górnego punktu;
- w,h – szerokość i wysokość rysowanego prostokąta;
- kolor – kolor krawędzi prostokąta:
- 0 – czarny;
- 1 – biały;
- 2 – odwróć kolor.
- fillcolor – kolor wypełnienia prostokąta:
- 0 – czarny;
- 1 – biały;
- 2 – odwróć kolor.
Funkcja Draw_circle() rysuje okrąg na ekranie.
Składnia:
- TVOut.draw_circle(x,y,r,kolor);
- TVOut.draw_circle(x,y,r,kolor,kolor wypełnienia);
Opcje:
- x,y – współrzędne środka okręgu;
- r – promień okręgu;
- kolor – kolor granic okręgu:
- 0 – czarny;
- 1 – biały;
- 2 – odwróć kolor.
- fillcolor – kolor wypełnienia okręgu:
- 0 – czarny;
- 1 – biały;
- 2 – odwróć kolor.
Funkcja bitmap() wyświetla obraz bitmapowy na ekranie.
Składnia:
- TVOut.bitmap(x,y,bmp,w,h);
Opcje:
- x,y – współrzędne lewego górnego rogu punktu wyjściowego;
- bmp – wskaźnik do tablicy pamięci, w której przechowywany jest obraz;
- w,h – szerokość, wysokość wyświetlanego obrazu;
Poniżej przyjrzymy się procesowi tworzenia kodu wyjściowych obrazów rastrowych.
Funkcje wyjściowe informacji tekstowych
Aby skorzystać z funkcji wyprowadzania informacji tekstowych, należy połączyć pliki z czcionkami zawartymi w bibliotece lub niestandardowymi. Aby połączyć niestandardowy zestaw czcionek, musisz dołączyć plik nagłówkowy do szkicu:
#włączać
Biblioteka zawiera następujące zestawy czcionek:
- czcionka 4x6;
- czcionka6x8;
- czcionka 8x8;
- czcionka8x8ext.
Funkcjaselect_font() wybiera czcionkę do wyświetlania informacji tekstowych.
Składnia:
- TVOut.select_font(czcionka);
Opcje:
- czcionka – czcionka zawarta w szkicu.
Funkcja print_char() wypisuje znak na ekranie.
Składnia:
- TVOut.print_char(x,y,char);
Opcje:
- x,y – pozycja na ekranie, w której wyświetlany jest symbol;
- char – znak z aktualnej czcionki.
Funkcja set_cursor() ustawia położenie kursora przy wyświetlaniu informacji tekstowych na ekranie.
Składnia:
- TVOut.set_cursor(x,y);
Opcje:
- x,y – współrzędne kursora.
Funkcja print() wypisuje na ekranie ciąg znaków, znak lub liczbę.
Składnia:
- TVOut.print(x,y,string);
- TVOut.print(x,y,char,base);
- TVOut.print(x,y,int,base).
Opcje:
- x,y – współrzędne kursora.
- baza – format wyjściowy:
- BAJT = 0;
- GRUDZIEŃ = 10 (domyślnie);
- szesnastkowy = 16.
Funkcja println() wypisuje ciąg znaków, znak lub liczbę, po których następuje znak nowej linii:
Składnia:
- TVOut.println(x,y,string);
- TVOut.println(x,y,char,base);
- TVOut.println(x,y,int,base).
Opcje:
- x,y – współrzędne kursora.
- baza – format wyjściowy:
- BAJT = 0;
- GRUDZIEŃ = 10 (domyślnie);
- szesnastkowy = 16.
Funkcje wyjścia audio
Funkcje wyjścia audio umożliwiają wysyłanie sygnału o określonej częstotliwości do telewizora za pośrednictwem wyjścia audio.
Funkcja tone() generuje sygnał audio o określonej częstotliwości.
Składnia:
- TVOut.tone(częstotliwość, czas trwania);
- Ton wyjściowy TV (częstotliwość).
Opcje:
- częstotliwość – częstotliwość sygnału audio;
- czas trwania – czas trwania sygnału.
Funkcja noTone() przestaje generować dźwięk.
Składnia:
- TVOut.noTone().
Tworzenie własnych czcionek
Przyjrzyjmy się procesowi tworzenia niestandardowych czcionek dla biblioteki TVOut.
Biblioteka umożliwia tworzenie własnych czcionek.
Istnieją dwa rodzaje czcionek - stała i zmienna szerokość. W przypadku czcionek o stałej szerokości pierwsze trzy bajty tablicy zawierają szerokość znaku (4), wysokość znaku (6) i pierwszy znak drukowalny (32). Potem przychodzą dane dla każdego kolejnego znaku.
#include "myfont1.h" PROGMEM const unsigned char myfont1 = ( 4,6,32, // 0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000, // 0b01000000, 0 b01 000000, 0b01000000, 0b00000000, 0b01000000, 0b00000000, … …);
W przypadku czcionek o zmiennej szerokości pierwszy bajt w opisie każdego znaku określa szerokość tego znaku.
#include "myfont1.h" PROGMEM const unsigned char myfont1 = ( 4,6,32, // 2, 0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000, // 3, 0b01000 000, 0b01000000, 0b01000000, 0b00000000, 0b01000000, 0b00000000, … … );
Stwórzmy niestandardową czcionkę myfont1. Dla niestandardowej czcionki myfont1 utwórz 2 pliki w folderze TVOutfonts: myfont1.h i myfont1.cpp.
Oto zawartość pliku myfont1.h
#ifndef MYFONT1_h #define MYFONT1_h #include extern const unsigned char myfont1; #endif
Teraz, aby biblioteka TVOut mogła używać w szkicu naszej niestandardowej czcionki myfont1, musisz dołączyć plik
#include „myfont1.h”
Tworzenie prymitywów graficznych.
Biblioteka TVOut umożliwia ładowanie obrazów bitmapowych na ekran. Przyjrzyjmy się tworzeniu kodu ładującego bitmapę za pomocą funkcji bitmap() biblioteki TVOut.
Najpierw musisz utworzyć obraz 1-bitowy (dwukolorowy), na przykład w edytorze graficznym Paint .
Następnie potrzebujemy programu Image2Code, który przekonwertuje kod z naszego obrazu. Program można pobrać pod adresem. To jest wersja dla systemu operacyjnego Windows. Pobierz i uruchom.
Kliknij przycisk Konwertuj i uzyskaj tablicę.
# include # ifndef MYBITMAP1_H # zdefiniuj MYBITMAP1_H extern const unsigned char MyBitmap1; #endif
Następnie utwórz plik MyBitmap1.cpp, skopiuj do niego dane konwersji (w pole danych tablicy unsigned char MyBitmap1), usuwając symbole „(” i „)” oraz podając szerokość i wysokość obrazu w pikselach na początku.
#include „Mybitmap1.h” Progmem Stały znak bez znaku Mybitmap1 = (16.16, 0x73,0x8e, 0x8C, 0x71, 0x00.0x00, 0x00.0x00, 0x00.0x00, 0x97.0x63, 0x94,0x55, 0xb4.0x5, 0x b4. 0x5, 0xb 5, 0xD4,0x67, 0x94,0x45, 0x00,0x00, 0x00,0x00, 0x00,0x00, 0xAA,0xAA, 0x55,0x55, 0x00,0x00 );
Zapisujemy pliki MyBitmap1.h i myBitmap.cpp w katalogu naszego szkicu. Aby wyświetlić nasz obraz na ekranie telewizora należy wywołać funkcję TVOut.bitmap():
#include "MojaBitmap1.h" TVOut.bitmap(x,y,MojaBitmapa);
Zapoznaliśmy się z biblioteką, konsola do gier została złożona – teraz możemy przystąpić do pisania gry.
Konsola do gier na Arduino? Prawda, prawda. Z ekranem, przyciskami i grami. I to nie jest fantazja. Było (i nadal jest) kilka projektów, które próbowały to zrobić, a my spróbujemy sami wdrożyć jeden z nich (Gamebuino).
Ponieważ projekt jest otwarty, wszystkie schematy są dostępne na WIKI, a także linki do oprogramowania, gier i innych przydatnych informacji.
Do stworzenia własnej konsoli do gier potrzebne będą nam niedrogie podzespoły – ekran Nokii 5110, sześć przycisków i głośnik piezoelektryczny. Wszystko to można łatwo znaleźć na Aliexpress czy innych stronach chińskich sklepów (głównie problemem jest znalezienie ekranu), a nawet w Rosji. Ekran można nazwać „masywnym” i jest dobrze opisany, więc podłączenie go jest równie proste, jak wyjęcie.
Ponieważ Gamebuino wykorzystuje układ wygodny do umieszczania elementów na płytce, próbując połączyć elementy za pomocą standardowych pinów Arduino, otrzymujemy następujący obraz:
Tak naprawdę niektóre elementy zostały już „pominięte”, gdyż Gamebuino wykorzystuje piny mikroprocesora, które nie są poprowadzone w Arduino lub po prostu nie są potrzebne. Zezłomowano czujnik ładowania akumulatora, przycisk C i kartę SD (są ze sobą połączone) oraz czujnik oświetlenia otoczenia. Zdecydowano się także na usunięcie rezystorów – nie będziemy korzystać z wyświetlacza 24 godziny na dobę, 7 dni w tygodniu i bez tego zabezpieczenia możemy się obejść.
Można by to zrobić „pięknie”, ale wtedy musielibyśmy poprawić kod wszystkich bibliotek i „zmapować” kontakty według nowego schematu. Postanowiłem ograniczyć się wyłącznie do kosmetyków – czyli zastosować „standardowe” styki i wprowadzić jedynie drobne zmiany w kodzie, jeśli zajdzie taka potrzeba.
A więc - po złożeniu obwodu należy zainstalować Arduino IDE i pobrać to archiwum. Musisz rozpakować go do katalogu Documents/Arduino, a następnie uruchomić Arduino IDE. Wprowadzono już zmiany w kodzie biblioteki w tym archiwum i będzie on działać „od razu po wyjęciu z pudełka” z tym schematem.
Powinieneś teraz mieć przykłady Gamebuino, które pozwolą ci przetestować wyświetlacz, przyciski itp. a nawet uruchom Ponga. Do płytki „użyj” standardowego Arduino UNO lub Leonardo (nie testowałem tego jeszcze na innych).
Kiedy wszystko działa, porusza się, wydaje sygnały dźwiękowe itp. Powstaje naturalne pytanie – gdzie są igrzyska? Gamebuino używa własnego bootloadera do pracy z kartami SD, więc ładowanie HEX przez ich moduł ładujący nie będzie działać bez flashowania samego Arduino. Ale nawet jeśli to zrobisz, z powodu braku sygnału z akumulatora nie będziesz mógł niczego uruchomić, ponieważ oprogramowanie układowe przeklnie i wyłączy się. Prekompilowanego HEX-a z grami również nie da się uruchomić ze względu na problemy z czujnikiem naładowania baterii.
Ale nie wszystko stracone - możesz pobrać kody źródłowe, otworzyć je w Arduino IDE i wgrać na naszą konsolę.
Sprawdziłem niektóre gry i... DZIAŁAJĄ! Stąd możesz pobrać archiwum z kodami źródłowymi gier, otworzyć je w Arduino IDE i samodzielnie skompilować i pobrać. Pozostałe gry możesz wypróbować samodzielnie, pobierając kody źródłowe z Wiki Gamebuino.
Zatem - misja wykonana! Otrzymaliśmy miniaturową konsolę do gier. Teraz naszym zadaniem jest uczynić go mobilnym :) I postaramy się to zrobić w kolejnych artykułach.
I tak, drodzy Państwo, jeżeli posiadacie już zestaw konstrukcyjny Arduino UNO R3 (zestaw startowy) lub nudzicie się, to z technicznego punktu widzenia zapraszamy. Mamy dla Arduino cały szereg „lekcji”. Przypominam, że z tego zestawu można zrobić jeśli nie wszystko, to prawie wszystko, co będzie działać lub coś kontrolować. Konsola do gier, cóż, rozważ joystick do gry w ping-ponga i to wszystko. Ktoś nadal ma stary komputer ze starym, niedziałającym joystickiem, teraz to wszystko jest kontrolowane przez logikę Zestaw Arduino(http://arduinokit.ru/).
Od czego zacząć projekt?
Stworzyłem prostą konsolę do gier, na której można grać w ping-ponga i inne gry, pamiętajcie, jak na starym komputerze Atari 2600, który teraz można łatwo emulować za pomocą Arduino R3. Arduino przypominałoby ten stary komputer, czytając wejścia i wyjścia z joysticka podłączonego do telewizora za pośrednictwem standardowej biblioteki TVout (dla Arduino). Stworzyłem ten projekt tylko po to, aby pokazać, że każdy (bez specjalnych umiejętności) może stworzyć własną miniaturową konsolę i grać. Chciałbym też, aby każdy, kto przeczyta ten artykuł, mógł skorzystać z tej porady całkowicie bezpłatnie.
Czego potrzebujesz do konsoli do gier Arduino?
5. Teraz do gry w ping-ponga potrzebujemy tylko 4-pinowego złącza: Do przodu (1), Do tyłu (2), Przycisk (6) i Masa (8). A do drugiego joysticka potrzebujemy tylko pinów 1, 2 i 8 (Przycisk „główny” służy tylko do „uruchamiania gry” w imieniu Administratora, dlatego tylko 1 gracz powinien mieć ten przycisk - sterowanie).
6. Jeśli spojrzysz na piny z boku, połączyłem te 4 luty prostymi przewodami, które idą do Arduino (Forward do pinu 2, Back do pinu 3 i Control do pinu 4). Zrobiłem to samo dla pozostałych 3 pinów dla gracza 2 (na drugim joysticku): „Naprzód” do styku 7 i „Wstecz” do styku 10). Nie zapomnij podłączyć obu joysticków Pin 8 do masy (przewód ekranowy)!
7. Teraz załaduj grę Ping-pong i sprawdź wejścia joysticka. Włóż Arduino UNO R3 i wszystkie przewody do wymaganych złączy (użyłem uszkodzonej obudowy zewnętrznej starego dysku twardego).
Kiedy po raz pierwszy próbowałem sam wykonać to zadanie, bardzo się denerwowałem, rozpoczynając pracę nad tym projektem. Fuj, nie było łatwo, chciałem jak najszybciej ukończyć ten projekt. Początkowo moim głównym problemem było to, że próbowałem zaimplementować stare joysticki z Atari do Arduino. Z tego powodu niektórzy blogerzy internetowi błędnie pisali na swoich forach, że mówią, że wejść nie da się odczytać ani wlutować od środka joysticka, ale patrząc na to fajnie było używać ich standardowych kontrolerów podłączając się do nich od zewnątrz, podrapałem się rzepę i wysłuchałem wielu wypowiedzi kierowanych do mnie, w których mówiono, że „od tego ręce mi nie rosną” albo nie wiem, jak trzymać lutownicę w dłoniach. Niemniej jednak mój projekt działa! Czy jesteś słaby?
PS: Myślę, że jedyną rzeczą, którą teraz oglądałbym inaczej, jest hmm. No ja bym wziął np. kartridż od Segi albo Dandy'ego i zrobił jakiś czytnik kart. Oto konsola do gier telewizyjnych DIY. Najważniejsze, że mój projekt jest skalowany, możesz zrobić, jeśli nie latające roboty, to konsole do gier własnymi rękami. Nawiasem mówiąc, nasi przyjaciele mają różne komponenty do Arduino UNO R3 (Arduino Designers). Jeśli naprawdę chcesz, możesz zrobić wszystko własnymi rękami. I to działa!
