Podstawy interfejsu Arduino TFT: 10 kroków (ze zdjęciami)

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:30

Ekrany dotykowe TFT to niesamowity interfejs graficzny, który może być używany z mikrokontrolerami, takimi jak Atmel, PIC, STM, ponieważ ma szeroką gamę kolorów, dobre możliwości graficzne i dobre odwzorowanie pikseli.

Dzisiaj idziemy do interfejsu 2,4 cala TFT LCD Shield z Arduino.

Ta osłona jest przeznaczona dla Arduino UNO, ale nauczę go używać z Arduino Mega z bardzo logicznego powodu, „Pamięć programu”.

Używając tej kolorowej osłony TFT LCD możemy wyświetlać znaki, ciągi znaków, interfejsy przycisków, obrazy bitmapowe itp. na kolorowym wyświetlaczu TFT LCD.

Krok 1: Wymagania sprzętowe i programowe

Aby stworzyć interfejs tarczy z Arduino mega, potrzebujemy następujących elementów.

SPRZĘT:

• Arduino mega

• Wyświetlacz LCD TFT 2,4/2,8/3,2 cala

• Kabel USB

OPROGRAMOWANIE

• Arduino IDE

• Biblioteka UTFT / Biblioteka spfd5408

Tarcza jest oryginalnie wykonana dla płyt Arduino UNO, które mogą być używane z Arduino mega.

Istnieją dwa główne problemy podczas używania go z Arduino UNO: "pamięć pamięci" i użycie pinów.

Trudno jest wykorzystać nieużywane piny, które są dostępne w UNO, natomiast lepiej jest z Arduino MEGA, ponieważ pozostało nam więcej pinów I/O.

W następnym kroku pokażę, jak edytować bibliotekę UTFT, aby korzystać z osłony TFT

Krok 2: Poprawienie Lib UTFT

Ta biblioteka jest kontynuacją moich bibliotek ITDB02_Graph, ITDB02_Graph16 i RGB_GLCD dla Arduino i chipKit. Ponieważ liczba obsługiwanych modułów wyświetlaczy i kontrolerów zaczęła rosnąć, uznałem, że nadszedł czas na stworzenie jednej, uniwersalnej biblioteki, ponieważ w przyszłości będzie znacznie łatwiejsza w utrzymaniu.

Arduino MEGA posiada 256kb pamięci programu. Dodatkowo są 54 piny.

Większość z nich jest darmowa, a tylko 5 analogów pochodzi z 16.

Ta biblioteka obsługuje wiele 8-bitowych, 16-bitowych i szeregowych wyświetlaczy graficznych i będzie działać zarówno z Arduino, płytami chipKit, jak i wybranymi padami TI LaunchPad.

UWAGA: Ze względu na rozmiar biblioteki nie polecam jej używać na ATmega328 (Arduino Uno) i ATmega32U4 (Arduino Leonardo), ponieważ mają tylko 32KB pamięci flash. To zadziała, ale będziesz mieć poważne ograniczenia w dostępnej pamięci flash dla twojej aplikacji

Kroki

• Pobierz bibliotekę UTFT
• Rozpakuj bibliotekę
• Otwórz UTFT\hardware\avr w przypadku Arduino lub w zależności od używanego mikrokontrolera
• Otwórz HW_AVR_defines za pomocą Notatnika
• Odkomentuj wiersz 7, aby włączyć osłonę UNO dla MEGA
• Zapisz plik i dodaj tę bibliotekę do Arduino IDE

Teraz skończyliśmy z tym krokiem! W następnym kroku pokażę, jak korzystać z biblioteki i zdefiniować piny dla Arduino Mega.

Krok 3: Inicjalizacja TFT Shield

Po edycji biblioteki dodaj ją do katalogu Arduino.

Następnie pokażę Ci, jak zdefiniować właściwy moduł TFT, który posiadasz

powinniśmy znaleźć jego nazwę modułu w bibliotece.

• otwórz plik biblioteki
• przejdź do dokumentacji

Możesz zobaczyć te pliki w dokumentacji

• UTFT:

Ten plik pokazuje wszystkie funkcje i polecenia zawarte w tej bibliotece.

• UTFT_Wymaganie

Ten plik zawiera informacje o modułach i ich związku z biblioteką, np. konfiguracje pinów

•UTFT_Obsługiwane_moduły_wyświetlania_i_kontroler

To jest nasz cel, ten plik zawiera nazwy modułów i osłon, które są obsługiwane przez tę bibliotekę, możesz zobaczyć w nim listę nazw modułów i nazw modułów dla UTFT, których powinieneś użyć do zdefiniowania swojego modułu.

Kroki do zdefiniowania TFT:

Otwórz plik UTFT_Supported_display_modules_&_controller z biblioteki

• Otwórz plik UTFT_Supported_display_modules_&_controller z biblioteki
• Znajdź modele dla UTFT dla modułów (osłony), które posiadasz.
• Teraz, aby zdefiniować funkcję UTFT w Arduino IDE, używamy polecenia:

Nazwa UTFT (moduł, Rs, Wr, Cs, Rst);

Otwórz plik UTFT_Requirement z biblioteki

Z dokumentu wiemy, że piny znajdują się na pinach A5, A4, A3 i A2.

używamy polecenia:

UTFT mójGLCD(ITDB28, 19, 18, 17, 16); # zauważ, że piny 19, 18, 17, 16 w Arduino Mega

UTFT mójGLCD (ITDB28, A5, A4, A3, A2); # zauważ, że piny A5, A4, A3, A2 w Arduino UNO

I zrobione! Teraz możesz użyć przykładów bibliotek na Arduino IDE z następującymi zmianami.

Krok 4: Podstawowe Hello World

#include // Zadeklaruj, jakich czcionek będziemy używać

extern uint8_t BigFont; extern uint8_t SevenSegNumFont; // Pamiętaj, aby zmienić parametr modelu, aby pasował do Twojego modułu wyświetlacza! UTFT mójGLCD (ITDB28, A5, A4, A3, A2); void setup() { myGLCD. InitLCD(); mójGLCD.clrScr(); mójGLCD.setFont(BigFont); } void loop() { myGLCD.setColor(0, 255, 0); //zielony myGLCD.print("HELLO WORLD", 45, 100); podczas (prawda) {}; }

Krok 5: Czcionki UTFT

#include // Zadeklaruj, jakich czcionek będziemy używać

extern uint8_t SmallFont; extern uint8_t BigFont; extern uint8_t SevenSegNumFont; // Ustaw piny na prawidłowe dla twojej tarczy rozwojowej // ------------------------------------ ------------------------- // Arduino Uno / 2009: // ---------------- --- // Standardowa osłona Arduino Uno/2009:, A5, A4, A3, A2 // DisplayModule Arduino Uno osłona TFT:, A5, A4, A3, A2 // // Arduino Mega: // ----- -------------- // Standardowa osłona Arduino Mega/Due:, 38, 39, 40, 41 // CTE TFT LCD/SD Shield dla Arduino Mega:, 38, 39, 40, 41 // // Pamiętaj, aby zmienić parametr modelu, aby pasował do Twojego modułu wyświetlacza! UTFT mójGLCD(ITDB32S, 38, 39, 40, 41); void setup() { myGLCD. InitLCD() myGLCD.clrScr(); } void loop() { myGLCD.setColor(0, 255, 0); mójGLCD.setBackColor(0, 0, 0); mójGLCD.setFont(BigFont); myGLCD.print(" !\"#$%&'()*+, -./", CENTER, 0); myGLCD.print("0123456789:;?", CENTER, 16); myGLCD.print("@ ABCDEFGHIJKLMNO", CENTRUM, 32); myGLCD.print("PQRSTUVWXYZ^_", CENTRUM, 48); myGLCD.print("`abcdefghijklmno", CENTRUM, 64); myGLCD.print("pqrstuvwxyz{|} ~ ", CENTER, 80); myGLCD.setFont(SmallFont); myGLCD.print(" !\"#$%&'()*+, -./0123456789:;?", CENTER, 120); mójGLCD.print("@ABCDEFGHIJKLMNOPQRSTUVWXYZ^_", CENTRUM, 132); myGLCD.print("`abcdefghijklmnopqrstuvwxyz{|}~ ", CENTRUM, 144); mójGLCD.setFont(SevenSegNumFont); myGLCD.print("0123456789", CENTRUM, 190); podczas (1) {}; }

Krok 6: Kształty, linie i wzór UTFT

#include "UTFT.h"// Zadeklaruj, jakich czcionek będziemy używaćextern uint8_t SmallFont;// Ustaw piny na odpowiednie dla twojej tarczy rozwojowej // -------------- ---------------------------------------------- // Arduino Uno / 2009: // ------------------- // Standardowa nakładka Arduino Uno/2009:, A5, A4, A3, A2 // DisplayModule Arduino Uno nakładka TFT:, A5, A4, A3, A2 // // Arduino Mega: // ------------------- // Standardowa osłona Arduino Mega/Due:, 38, 39, 40, 41 // CTE TFT LCD/SD Shield dla Arduino Mega:, 38, 39, 40, 41 // // Pamiętaj, aby zmienić parametr modelu, aby dopasować go do modułu wyświetlacza! UTFT myGLCD(ITDB32S, 38, 39, 40, 41);unieważnij setup() { randomSeed(analogRead(0)); // Konfiguracja wyświetlacza LCD myGLCD. InitLCD(); mójGLCD.setFont(MałaCzcionka); }

pusta pętla()

{ int.buf[318]; int x, x2; int y, y2; int r;// Wyczyść ekran i narysuj ramkę myGLCD.clrScr(); mójGLCD.setColor(255, 0, 0); mójGLCD.fillRect(0, 0, 319, 13); mójGLCD.setColor(64, 64, 64); mójGLCD.fillRect(0, 226, 319, 239); mójGLCD.setColor(255, 255, 255); mójGLCD.setBackColor(255, 0, 0); myGLCD.print("* Uniwersalna biblioteka kolorowych wyświetlaczy TFT *", CENTRUM, 1); mójGLCD.setBackColor(64, 64, 64); mójGLCD.setColor(255, 255, 0); myGLCD.print("", CENTRUM, 227); mójGLCD.setColor(0, 0, 255); myGLCD.drawRect(0, 14, 319, 225);// Rysuj krzyżyk myGLCD.setColor(0, 0, 255); mójGLCD.setBackColor(0, 0, 0); myGLCD.drawLine(159, 15, 159, 224); myGLCD.drawLine(1, 119, 318, 119); for (int i=9; i<310; i+=10) myGLCD.drawLine(i, 117, i, 121); for (int i=19; i<220; i+=10) myGLCD.drawLine(157, i, 161, i);// Rysuj linie sin-, cos- i tan-myGLCD.setColor(0, 255, 255); myGLCD.print("Grzech", 5, 15); for (int i=1; i<318; i++) { myGLCD.drawPixel(i, 119+(sin(((i*1.13)*3.14)/180)*95)); } myGLCD.setColor(255, 0, 0); myGLCD.print("Cos", 5, 27); for (int i=1; i<318; i++) { myGLCD.drawPixel(i, 119+(cos(((i*1.13)*3.14)/180)*95)); } myGLCD.setColor(255, 255, 0); myGLCD.print("Tan", 5, 39); for (int i=1; i<318; i++) { myGLCD.drawPixel(i, 119+(tan(((i*1.13)*3.14)/180))); } opóźnienie(2000); mójGLCD.setColor(0, 0, 0); mójGLCD.fillRect(1, 15, 318, 224); mójGLCD.setColor(0, 0, 255); mójGLCD.setBackColor(0, 0, 0); myGLCD.drawLine(159, 15, 159, 224); myGLCD.drawLine(1, 119, 318, 119);// Narysuj ruchomą falę sinusoidalną x=1; for (int i=1; i319) { if ((x==159)||(buf[x-1]==119)) myGLCD.setColor(0, 0, 255); w przeciwnym razie myGLCD.setColor(0, 0, 0); myGLCD.drawPixel(x, buf[x-1]); } myGLCD.setColor(0, 255, 255); y=119+(sin(((i*1,1)*3,14/180)*(90-(i/100))); myGLCD.drawPixel(x, y); buf[x-1]=y; } opóźnienie(2000); mójGLCD.setColor(0, 0, 0); myGLCD.fillRect(1, 15, 318, 224);// Narysuj kilka wypełnionych prostokątów for (int i=1; i<6; i++) { switch (i) { case 1: myGLCD.setColor(255, 0, 255); przerwa; przypadek 2: myGLCD.setColor(255, 0, 0); przerwa; przypadek 3: myGLCD.setColor(0, 255, 0); przerwa; przypadek 4: myGLCD.setColor(0, 0, 255); przerwa; przypadek 5: myGLCD.setColor(255, 255, 0); przerwa; } myGLCD.fillRect(70+(i*20), 30+(i*20), 130+(i*20), 90+(i*20)); } opóźnienie(2000); mójGLCD.setColor(0, 0, 0); myGLCD.fillRect(1, 15, 318, 224);// Narysuj kilka wypełnionych, zaokrąglonych prostokątów for (int i=1; i<6; i++) { switch (i) { case 1: myGLCD.setColor(255, 0, 255); przerwa; przypadek 2: myGLCD.setColor(255, 0, 0); przerwa; przypadek 3: myGLCD.setColor(0, 255, 0); przerwa; przypadek 4: myGLCD.setColor(0, 0, 255); przerwa; przypadek 5: myGLCD.setColor(255, 255, 0); przerwa; } myGLCD.fillRoundRect(190-(i*20), 30+(i*20), 250-(i*20), 90+(i*20)); } opóźnienie(2000); mójGLCD.setColor(0, 0, 0); myGLCD.fillRect(1, 15, 318, 224);// Narysuj kilka wypełnionych kółek for (int i=1; i<6; i++) { switch (i) { case 1: myGLCD.setColor(255, 0, 255); przerwa; przypadek 2: myGLCD.setColor(255, 0, 0); przerwa; przypadek 3: myGLCD.setColor(0, 255, 0); przerwa; przypadek 4: myGLCD.setColor(0, 0, 255); przerwa; przypadek 5: myGLCD.setColor(255, 255, 0); przerwa; } myGLCD.fillCircle(100+(i*20), 60+(i*20), 30); } opóźnienie(2000); mójGLCD.setColor(0, 0, 0); myGLCD.fillRect(1, 15, 318, 224);// Narysuj kilka linii we wzorcu myGLCD.setColor (255, 0, 0); for (int i=15; i<224; i+=5) { myGLCD.drawLine(1, i, (i*1.44)-10, 224); } myGLCD.setColor (255, 0, 0); for (int i=224; i>15; i-=5) { myGLCD.drawLine(318, i, (i*1.44)-11, 15); } myGLCD.setColor (0, 255, 255); for (int i=224; i>15; i-=5) { myGLCD.drawLine(1, i, 331-(i*1,44), 15); } myGLCD.setColor (0, 255, 255); for (int i=15; i<224; i+=5) { myGLCD.drawLine(318, i, 330-(i*1,44), 224); } opóźnienie(2000); mójGLCD.setColor(0, 0, 0); myGLCD.fillRect(1, 15, 318, 224);// Narysuj losowe kółka for (int i=0; i<100; i++) { myGLCD.setColor(random(255), random(255), random(255)); x=32+losowy(256); y=45+losowy(146); r=losowy(30); myGLCD.drawCircle(x, y, r); } opóźnienie(2000); mójGLCD.setColor(0, 0, 0); myGLCD.fillRect(1, 15, 318, 224);// Narysuj kilka losowych prostokątów for (int i=0; i<100; i++) { myGLCD.setColor(random(255), random(255), random(255)); x=2+losowy(316); y=16+losowy(207); x2=2+losowy(316); y2=16+losowy(207); mójGLCD.drawRect(x, y, x2, y2); } opóźnienie(2000); mójGLCD.setColor(0, 0, 0); myGLCD.fillRect(1, 15, 318, 224);// Narysuj losowo zaokrąglone prostokąty for (int i=0; i<100; i++) { myGLCD.setColor(random(255), random(255), random(255)); x=2+losowy(316); y=16+losowy(207); x2=2+losowy(316); y2=16+losowy(207); mójGLCD.drawRoundRect(x, y, x2, y2); } opóźnienie(2000); mójGLCD.setColor(0, 0, 0); mójGLCD.fillRect(1, 15, 318, 224); for (int i=0; i<100; i++) { myGLCD.setColor(random(255), random(255), random(255)); x=2+losowy(316); y=16+losowy(209); x2=2+losowy(316); y2=16+losowy(209); myGLCD.drawLine(x, y, x2, y2); } opóźnienie(2000); mójGLCD.setColor(0, 0, 0); mójGLCD.fillRect(1, 15, 318, 224); for (int i=0; i<10000; i++) { myGLCD.setColor(random(255), random(255), random(255)); myGLCD.drawPixel(2+losowe(316), 16+losowe(209)); } opóźnienie(2000); mójGLCD.fillScr(0, 0, 255); mójGLCD.setColor(255, 0, 0); mójGLCD.fillRoundRect(80, 70, 239, 169); mójGLCD.setColor(255, 255, 255); mójGLCD.setBackColor(255, 0, 0); myGLCD.print("To jest to!", CENTRUM, 93); myGLCD.print("Ponowne uruchamianie za", CENTRUM, 119); myGLCD.print("kilka sekund…", CENTRUM, 132); mójGLCD.setColor(0, 255, 0); mójGLCD.setBackColor(0, 0, 255); myGLCD.print("Czas wykonania: (msek)", CENTRUM, 210); mójGLCD.printNumI(millis(), CENTRUM, 225); opóźnienie (10000); }

Krok 7: Bitmapa UTFT

#włączać

#include // Zadeklaruj, jakich czcionek będziemy używać extern uint8_t SmallFont;// Ustaw piny na prawidłowe dla twojej tarczy rozwojowej // ------------------ ------------------------------------------ // Arduino Uno / 2009: / / ------------------- // Standardowa osłona Arduino Uno/2009:, A5, A4, A3, A2 // DisplayModule Arduino Uno osłona TFT:, A5, A4, A3, A2 // // Arduino Mega: // ------------------- // Standardowa osłona Arduino Mega/Due:, 38, 39, 40, 41 // CTE TFT LCD/SD Shield dla Arduino Mega:, 38, 39, 40, 41 // // Pamiętaj, aby zmienić parametr modelu, aby pasował do Twojego modułu wyświetlacza! UTFT myGLCD(ITDB32S, A5, A4, A3, A2);extern unsigned int info[0x400]; extern unsigned int icon[0x400]; extern unsigned int tux[0x400];unieważnij setup() { myGLCD. InitLCD(); mójGLCD.setFont(MałaCzcionka); } void loop() { myGLCD.fillScr(255, 255, 255); mójGLCD.setColor(255, 255, 255); myGLCD.print(" *** Siatka 10 na 7 ikony 32x32 *** ", CENTER, 228); for (int x=0; x<10; x++) for (int y=0; y<7; y++) myGLCD.drawBitmap (x*32, y*32, 32, 32, info); opóźnienie(5000); mójGLCD.fillScr(255, 255, 255); mójGLCD.setColor(255, 255, 255); myGLCD.print("Dwie różne ikony w skali od 1 do 4", CENTER, 228); int x=0; for (int s=0; s0; s--) { myGLCD.drawBitmap (x, 224-(s*32), 32, 32, icon, s); x+=(s*32); } opóźnienie(5000); }

Krok 8: Interfejs przycisków

#include #include // Zainicjuj wyświetlanie// ------------------ // Ustaw piny na prawidłowe dla swojej płytki rozwojowej // ------- -------------------------------------------------- -- // Standardowa osłona Arduino Uno/2009:, 19, 18, 17, 16 // Standardowa osłona Arduino Mega/Due:, 38, 39, 40, 41 // CTE TFT LCD/SD Shield dla Arduino Due:, 25, 26, 27, 28 // Teensy 3.x TFT Test Board:, 23, 22, 3, 4 // ElecHouse TFT LCD/SD Shield dla Arduino Due:, 22, 23, 31, 33 // // Pamiętaj, aby zmień parametr modelu, aby pasował do Twojego modułu wyświetlacza! UTFT myGLCD(ITDB32S, 38, 39, 40, 41);// Zainicjuj ekran dotykowy // ---------------------- // Ustaw prawidłowe piny te dla twojej tablicy rozwojowej // -------------------------------------------- ---------------- // Standardowa osłona Arduino Uno/2009: 15, 10, 14, 9, 8 // Standardowa osłona Arduino Mega/Due: 6, 5, 4, 3, 2 // CTE TFT LCD/SD Shield dla Arduino Due: 6, 5, 4, 3, 2 // Teensy 3.x TFT Test Board: 26, 31, 27, 28, 29 // ElecHouse TFT LCD/SD Shield dla Arduino Due: 25, 26, 27, 29, 30 // URTouch myTouch(6, 5, 4, 3, 2);// Zadeklaruj, jakich czcionek będziemy używać extern uint8_t BigFont;int x, y; char stCurrent[20]=""; int stCurrentLen=0; char stLast[20]="";/************************* ** Funkcje niestandardowe ** ********** ****************/void drawButtons() { // Narysuj górny rząd przycisków for (x=0; x<5; x++) { myGLCD.setColor(0, 0, 255); mójGLCD.fillRoundRect (10+(x*60), 10, 60+(x*60), 60); mójGLCD.setColor(255, 255, 255); myGLCD.drawRoundRect (10+(x*60), 10, 60+(x*60), 60); mójGLCD.printNumI(x+1, 27+(x*60), 27); } // Narysuj środkowy rząd przycisków for (x=0; x<5; x++) { myGLCD.setColor(0, 0, 255); mójGLCD.fillRoundRect (10+(x*60), 70, 60+(x*60), 120); mójGLCD.setColor(255, 255, 255); myGLCD.drawRoundRect (10+(x*60), 70, 60+(x*60), 120); if (x<4) myGLCD.printNumI(x+6, 27+(x*60), 87); } mójGLCD.print("0", 267, 87); // Narysuj dolny rząd przycisków myGLCD.setColor(0, 0, 255); mójGLCD.fillRoundRect (10, 130, 150, 180); mójGLCD.setColor(255, 255, 255); mójGLCD.drawRoundRect (10, 130, 150, 180); myGLCD.print("Wyczyść", 40, 147); mójGLCD.setColor(0, 0, 255); mójGLCD.fillRoundRect (160, 130, 300, 180); mójGLCD.setColor(255, 255, 255); mójGLCD.drawRoundRect (160, 130, 300, 180); myGLCD.print("Enter", 190, 147); mójGLCD.setBackColor (0, 0, 0); } void updateStr(int val) { if (stCurrentLen=10) && (y=10) && (x=70) && (x=130) && (x=190) && (x=250) && (x=70) && (y=10) && (x=70) && (x=130) && (x=190) && (x=250) && (x=130) && (y=10) && (x=160) && (x0) { dla (x=0; x

Krok 9: Flappy ptak

#include #include #include //==== Tworzenie obiektów UTFT myGLCD(SSD1289, 38, 39, 40, 41); //Parametry powinny być dostosowane do Twojego modelu Display/Schield UTouch myTouch(6, 5, 4, 3, 2);//==== Definiowanie czcionek extern uint8_t SmallFont; extern uint8_t BigFont; extern uint8_t SevenSegNumFont;extern unsigned int bird01[0x41A]; // Bitmapa ptaka x, y; // Zmienne dla współrzędnych, w których naciśnięto ekran// Floppy Bird int xP = 319; int yP = 100; int yB = 50; intruchomość = 3; int fallRateInt = 0; współczynnik opadania pływaka = 0; wynik wewnętrzny = 0; int lastSpeedUpScore = 0; int najwyższy wynik; boolean screenPressed = false; boolean gameStarted = false;unieważnij setup() { // Rozpocznij wyświetlanie myGLCD. InitLCD(); mójGLCD.clrScr(); myTouch. InitTouch(); myTouch.setPrecision(PREC_MEDIUM); najwyższy Wynik = EEPROM.read(0); // Odczytaj najwyższy wynik z EEPROM initialGame(); // Rozpocznij grę }void loop() { xP=xP-movingRate; // xP - współrzędna x filarów; zakres: 319 - (-51) drawPilars(xP, yP); // Rysuje filary // yB - współrzędna y ptaka, która zależy od wartości zmiennej fallRate yB+=fallRateInt; FallRate=fallRate+0,4; // Z każdym inetracją szybkość opadania wzrasta tak, że możemy uzyskać efekt przyspieszenia/ grawitacji fallRateInt= int(fallRate); // Sprawdza kolizje if(yB>=180 || yB<=0){ // góra i dół gameOver(); } if((xP=5) && (yB<=yP-2){ // górny filar gameOver(); } if((xP=5) && (yB>=yP+60)){ // dolny filar gameOver(); } // Rysuje ptaka drawBird(yB); // Po przejściu słupka przez ekran if (xPRESET=250) && (x=0) && (y=0) && (x=30) && (y=270){ myGLCD.setColor(0, 200, 20); mójGLCD.fillRect(318, 0, x, y-1); mójGLCD.setColor(0, 0, 0); mójGLCD.drawRect(319, 0, x-1, y); mójGLCD.setColor(0, 200, 20); mójGLCD.fillRect(318, y+81, x, 203); mójGLCD.setColor(0, 0, 0); mójGLCD.drawRect(319, y+80, x-1, 204); } else if(x najwyższyWynik) { najwyższyWynik = wynik; EEPROM.write(0, najwyższy wynik); } // Resetuje zmienne do wartości pozycji początkowej xP=319; yB=50; wskaźnik upadku=0; wynik = 0; lastSpeedUpScore = 0; szybkość ruchu = 3; gameStarted = fałsz; // Zrestartuj grę initialGame(); }

Krok 10: Praca nad projektem

Kod źródłowy można znaleźć w moim repozytorium Github.

Link:

Daj kciuki, jeśli naprawdę ci to pomogło i śledź mój kanał, aby znaleźć ciekawe projekty:)

Udostępnij ten film, jeśli chcesz.

Cieszę się, że subskrybujesz:

Dziękuje za przeczytanie!