Das ist es, was wir bekommen müssen, nun, er weiß immer noch, wie man springt, geht und die bösen Kakteen schlägt, die ihn angreifen, aber wir werden Schritt für Schritt dazu kommen :)

TEIL 1 Grundlagen

Ich bestellte mir ein Arduino, "so lala Spielzeug", dachte ich, ein kleines Kit (zum Testen), das ich später bereute. Ich wollte das Potenzial freisetzen, aber aufgrund des Mangels an zusätzlichen Modulen funktionierte dies nicht. Ich musste experimentieren, das Arduino in das Sicherheitssystem zerhacken und beobachten, wie die Sensoren ihre Arbeit erledigen. Dann entschied ich mich, einen akustischen Alarm auszulösen (mit dem praktischen Quietscher aus dem Kit), also entwöhnte ich die Hunde laut oder plötzlich bellen :) und dann erreichten meine Hände das Display 1602. "Hmm ... das ist ein echtes Display", dachte ich, aber ich war enttäuscht herauszufinden, dass er fast die Hälfte aller Kontakte auf dem Arduino selbst isst. Ich kramte herum und fand ein seltsames Board im "i2C" -Kit und es war sehr verdächtig! Dass die Anzahl der Löcher mit der Anzahl der Zuhälter auf dem Display übereinstimmte. "Hmm, nicht einfach ...", dachte ich und beschloss, sie zu löten. Wenig später stellte ich fest, dass ich das Richtige getan hatte und mein Display nur noch zwei Kanäle frisst. Er begann zu studieren, was für ein Display es war und was er tun konnte. Nachdem ich genug Material studiert hatte, fand ich heraus, dass die Anzeige rein textuell ist, aber siehe da! Es kann 8 neue Zeichen mit Abmessungen von 5 x 8 Pixel verarbeiten. Dann lass uns anfangen, ein Spiel zu schreiben! Zuerst musst du herausfinden, was für ein Spiel es sein wird. Ich habe beschlossen, es wie ein Dinosaurier-Gugl-Chrom aussehen zu lassen, aber mit ein paar Chips sozusagen für den Anfang denke ich, dass es funktionieren wird :) Aber Sie müssen immer noch etwas verwalten, und Multi-Button musste nicht lange nachdenken. Ich habe die IR-Fernbedienung aus dem Kit genommen.



„Das ist der Joystick“, murmelte ich misstrauisch und dachte über die Verzögerung der Fernbedienung, die Klarheit des IR-Sensors und allgemein über die Angemessenheit dieser Idee nach, aber es gab nichts zu tun, ich konnte Arduino trainieren, mit der Tastatur für den Computer zu arbeiten, aber es war wirklich faul um es zu tun. Also begann ich, die Fernbedienungscodes aufzuschreiben, damit ich in Zukunft damit arbeiten konnte. Der Code für den Mikrocontroller ist hier am einfachsten:

"--------------------------------------------------------------------------" //   IRremote #include <IRremote.h> decode_results results; IRrecv irrecv (A0); //      void setup () { Serial.begin(9600); //   com  irrecv.enableIRIn(); //    } void loop () { if (irrecv.decode( &results )) //      ,    { Serial.println( results.value, HEX ); //          irrecv.resume(); //            } } "--------------------------------------------------------------------------" 

Der Signalcode der Fernbedienung sieht folgendermaßen aus: „FF18E7“ Ihre Codes werden natürlich anders sein, aber Sie sollten das Wesentliche verstehen. Wenn Sie diesen Code ansprechen, fügen wir am Anfang „0x“ hinzu und erhalten (0xFF18E7).

Nachdem Sie dies in Arduino gefüllt und wie gewünscht angeschlossen haben, können Sie die Aufzeichnung über den Protokollport des Tsiforka starten, nachdem Sie auf die Schaltflächen des IR-Geräts geklickt haben. Aber hier möchte ich Ihnen nur erklären, wie Sie den IR-Sensor anschließen.

Wenn wir auf den Sensor schauen, sehen wir drei Beine, links (analoges Signal), mittel (Masse), rechts (plus 5 V).



Da ich noch keine Ahnung hatte, wie das überhaupt funktionieren würde, begann ich mit Experimenten. Zuerst habe ich den Skizzencode Schritt für Schritt gemacht, durch (Verzögerung (Zeit)) zuerst habe ich nicht vermutet, dass dies eine schlechte Idee war :)
Was ist der Hauptpfosten? Dieser Mikrocontroller kann kein Multitasking ausführen. Er betrachtet den Code von oben nach unten, durchläuft alle Zweige und Funktionen und beginnt nach Abschluss erneut. Und jetzt, wenn wir viele dieser „Verzögerungen“ im Code haben, bemerken wir offensichtliche Verzögerungen. Übrigens, ja, warum brauchen wir überhaupt viel „Verzögerung“. Wenn wir ein Spiel machen, beginnt die Anzahl der Prüfungen und Interaktionen zu wachsen. Zum Beispiel bewegt sich ein Feind auf uns zu und ich möchte darüber springen, ich drücke den "Sprung" und nach Plan muss ich zum Beispiel 0,8 f Sekunden in der Luft in der Luft hängen, und dies ist das ganze Spiel und friert für diese 0,8 f Sekunden ein. "Cant" dachte ich und begann über eine Lösung nachzudenken. Die Lösung wurde schnell gefunden. Der Mikrocontroller selbst kann den Code schnell von Anfang bis Ende lesen (wenn es ihn nicht stört) und er weiß auch, wie man die Zeit vom Beginn seiner Aufnahme an zählt. Das brauchen wir. Jetzt erstellen wir nur Variablen, die die Zeit für diese oder jene Aktion speichern, und eine Variable, die den Unterschied zwischen der aktuellen Zeit und dem Zeitaufwand für die Aktivierung des Codes vergleicht. Arduino pro Sekunde dauert 1000 Millisekunden, sehr praktisch. Hier ist ein Ausschnitt, wenn es klarer wird:

 "--------------------------------------------------------------------------" //    ,  ,        //  long ClearTime = 150; // 150 = 0.15f   ~6    long ClearTimeCheck = 0; // ,       long currentMillis = 0; //   void loop () { currentMillis = millis(); //   =    } void clearscreen () //   { // if (currentMillis - ClearTimeCheck >= ClearTime) //  (  -     0.15f    { ClearTimeCheck = currentMillis; //       lcd.clear(); //   ,     } } "--------------------------------------------------------------------------" 

Nicht schwer, oder?

Nachdem ich den gesamten Code neu geschrieben hatte, begann das Spiel schnell und klar zu funktionieren, um Multitasking-Aktionen zu simulieren :) Ich habe einen langen Weg zurückgelegt. Schließlich müssen wir noch einen Charakter, eine Art Schnittstelle und Animation erstellen. Da wir nur acht neue Charaktere erstellen können, müssen wir alles irgendwie durcheinander bringen. Ich habe bisher nicht vor, viele Objekte auf dem Display zu bearbeiten. Daher kann dies so erfolgen, dass in einer Codeverarbeitung nur acht aktive Objekte auf dem Bildschirm angezeigt werden. Was wird es sein? Nun, natürlich die Hauptfigur, ein Schlag, ein Bösewicht, ein Herz und ein Indikator für Gesundheit. Für den Anfang ist dies genug. Ja, und ich habe drei weitere einzigartige Objekte auf Lager.

Die Hauptfigur wird so aussehen:



Den Vorgang der Eingabe eines neuen Zeichens produziere ich im Binärcode (ich fühle mich so wohl)
es wird so aussehen:

01110
01110
00100
01110
10101
00100
01110
01010

Wenn Sie genau hinschauen, werden wir von einem aus unseren Charakter sehen, aber damit er nicht untätig bleibt, machen wir ihn zu einer Animation.



Nun wird unserem Code ein weiterer Satz von Binärzahlen hinzugefügt, nämlich dieser:

00000
01110
01110
00100
11111
00100
01110
01010

Wie man eine Animation auf diesem Display erstellt, habe ich die obige Logik angegeben. Lassen Sie uns nun üben, sie in der Mitte des Bildschirms zu platzieren und sie einfach stillstehen zu lassen. Denken Sie daran, dass unsere Aufgabe darin besteht, nur eine Speicherzelle für zwei Animations-Sprites zu verwenden. Das ist einfacher als es sich anhört:

 "--------------------------------------------------------------------------" #include <Wire.h> #include <LiquidCrystal_I2C.h> LiquidCrystal_I2C lcd(0x3F,16,2); //   long AnimatedTime = 300; //     long AnimatedTimeCheck = 0; //   (    ) int AnimPlayer = 1; //    int GGpozX = 8; //   int GGpozY = 1; //   1  2   0    long currentMillis = 0; //   //   ,     ,    :) enum { SYMBOL_HEIGHT = 8 }; byte Player_1[SYMBOL_HEIGHT] = {B01110,B01110,B00100,B01110,B10101,B00100,B01110,B01010,}; //  1 byte Player_2[SYMBOL_HEIGHT] = {B00000,B01110,B01110,B00100,B11111,B00100,B01110,B01010,}; //  2 void setup() { lcd.init(); lcd.backlight();//    loop(); PlAn(); } void loop() { if (AnimPlayer != 50) { //    ,       :) // --------------------------- Animated -> // -------------------- Player -> if (AnimPlayer == 1){lcd.createChar(0, Player_1);} //  1   1 //(lcd.createChar(    0  7,   )) if (AnimPlayer == 2){lcd.createChar(0, Player_2);} //  2   2 } // --------------------------- <- Animated currentMillis = millis(); //   =    PlAn(); } void PlAn () { if (AnimPlayer == 1) //   1  { lcd.setCursor(GGpozX, GGpozY); //  ""      lcd.write(0); //          "" } if (AnimPlayer == 2) //  №1 { lcd.setCursor(GGpozX, GGpozY); lcd.write(0); } if (currentMillis - AnimatedTimeCheck >= AnimatedTime) //       { AnimatedTimeCheck = currentMillis; //     if (AnimPlayer == 2){AnimPlayer = 1; return;} //  2   1      if (AnimPlayer == 1){AnimPlayer = 2;} // 1  2           ,         } } "--------------------------------------------------------------------------" 

Nach dem Start sehen wir den kleinen Mann, der sich in der Mitte des Bildschirms befindet, in der 2. Zeile und schwankt sozusagen.

Fazit: Heute habe ich darüber gesprochen, wie man Daten über den Infrarotanschluss herausfindet, wie man die Verzögerung des Mikrocontroller-Codes umgeht und wie man die erste Animation erstellt.

Der Rest kommt bald :) Ich habe noch viel zu schreiben, also werde ich mir ansehen, wie interessant es für dich überhaupt sein wird, und wenn ja, werde ich morgen anfangen, eine Fortsetzung zu schreiben.

Vielen Dank für Ihre Aufmerksamkeit, Ciao Kakao!

Der zweite Teil des Artikels -> habr.com/post/425367