LCD-animatie en gaming

Over dit project

Dit project richt zich op de basis van animatie met arduino en een 16 bij 2 lcd. Dit project kan echter ook worden uitgebreid naar lcd's met andere afmetingen.

Eerst beginnen we met de bedrading van het lcd naar de arduino, daarna met het eenvoudig printen van een bericht naar het lcd. Daarna gaan we verder met animatie.

LCD-bedrading

Dit is het circuit zoals hierboven schematisch is weergegeven.

LCD-pincode

1:VSS:naar positieve rail van breadboard (bevestig ook 5v arduino aan positieve rail)

2:VDD:naar negatieve rail van breadboard (bevestig hier ook GND van arduino)

3:VO (contrast):naar wisser van potentiometer (bevestig zijaansluitingen van potentiometer aan positieve en negatieve rails)

4:RS(register select):naar Arduino pin 12

5:R/W (lezen-schrijven):naar negatieve rail

6:E(inschakelen):naar Arduino pin 11

15:A (anode):naar positieve rail met 220 ohm weerstand

16:K(kathode):naar negatieve rail

We zullen nu geen gegevenspin toevoegen.

Schakel de stroom in en als de onderste rij oplicht, werkt je lcd. U moet dit testen voordat u iets anders gaat doen.

Als het lcd-scherm niet oplicht, controleer dan je soldeerwerk, bedrading (controleer opnieuw) en als het nog steeds niet oplicht, is het zeer waarschijnlijk dat je lcd beschadigd is, dus je moet het vervangen.

Als je lcd werkt, Bravo! je hebt het eerste deel van deze tutorial voltooid.

Verbind hierna de datapinnen:

11:D4(data pin 4):naar Arduino pin 4

12:D5:naar Arduino pin 5

13:D6:naar Arduino pin 6

14:D7:naar Arduino pin 7

Na deze upload voorbeeldcode

#include LiquidCrystal lcd(12,11,4,5,6,7);//rs,e,d4,d5,d6,d7 respectievelijkvoid setup(){lcd.begin (16,2);lcd.setCursor(0,1);lcd.print("Werkt");}void loop(){} 

Als je na het uploaden willekeurige tekens of helemaal niets ziet, controleer dan je contrast (draai de potentiometerknop omhoog en omlaag), controleer je pinsoldeer (datapinnen mogen NIET een beetje met elkaar zijn verbonden), en tot slot je circuit en lijn 2 in de voorbeeldcode (zorg ervoor dat de pincodes die aan LiquidCrystal zijn verstrekt overeenkomen met die in uw circuit.

Als er nog steeds niets gebeurt, verlies dan de hoop niet, als je de onderste rij in het eerste deel hebt zien oplichten, betekent dit dat je lcd-scherm in orde is. speel wat met het circuit en het solderen totdat het werkt.

Als je het bericht "Working" ziet, heb je je lcd met succes aangesloten en heb je het tweede deel van deze tutorial voltooid. Laat je circuit zoals het is, we zullen er niet meer mee rotzooien, het enige wat we nu moeten doen is in de software.

Verklaring van code in deel2

LiquidCrystallcd(12,11,4,5,6,7);

Deze regel declareert een lcd-object met interface-pinnen zoals aangegeven in de argumenten. Nu zal al uw lcd-interface via dit 'lcd'-object worden gedaan. (merk op dat u dit alles kunt noemen wat u maar wilt, maar die naam overal behoudt).

lcd.begin(16,2);

Deze regel geeft aan dat ons lcd-scherm 16 kolommen en 2 rijen heeft, houd er rekening mee dat uw lcd mogelijk niet 16 bij 2 is, pas de cijfers dienovereenkomstig aan.

lcd.setCursor(0,1);

Deze regel plaatst de cursor op de eerste kolom en de tweede rij (aangezien het tellen in C++ begint met 0 en niet met 1!). Merk op dat je de cursor niet kunt zien, maar de cursor is er altijd, het bepaalt de plek waar het volgende teken zal verschijnen.

lcd.print("Welkom");

Deze regel drukt het bericht Welkom af op de plaats waar de cursor naar wijst, dat wil zeggen 0 kolommen 1 rijen.

Scrollende tekst

Nou, we hebben een bericht op het scherm afgedrukt, maar het is niet erg aantrekkelijk om naar datzelfde bericht te staren, bovendien heeft het geen enkel nut. Daarom zullen we in deze sectie een bericht afdrukken dat van rechts naar links zal scrollen zoals in de reclameborden. Alleen de setup() en loop() functies zullen verschillen, dus ik laat alleen die functies zien, de rest blijft hetzelfde.

void setup(){lcd.begin(16,2);}void loop(){int n;char message[]="scrollende tekst!";n=15;char* ptr=bericht; while(n!=-14){lcd.clear(); lcd.setCursor(n,1); if(n<0){ ptr++; } lcd.print(ptr); n--;delay(250);}} 

Merk op dat om deze code te begrijpen, je een redelijk goede kennis van pointers in C en C++ nodig hebt, aangezien Arduino-taal eigenlijk gewoon AVR-C++ is, maar lichtjes verwerkt.

In de loop-functie definiëren we je bericht als een constante string.

lcd.clear() wordt gebruikt om het scherm voor elke iteratie te wissen.

Vervolgens stellen we een pointer ptr in om het adres van het bericht vast te houden. Deze aanwijzerwaarde wordt verhoogd om het bericht in het lcd-venster te laten passen, zelfs nadat de tekens naar links uit het zicht zijn verdwenen. We doen dit voor het linkeruiteinde en niet voor het rechteruiteinde, aangezien de LiquidCrystal-bibliotheek dit aankan voor het rechteruiteinde (tekst scrollt eruit) maar kan geen negatieve kolomadressen aan zoals vereist is voor ons programma.

Dan hebben we een while-lus die het bericht op verschillende locaties van links naar rechts weergeeft, waardoor de illusie wordt gewekt dat de tekst beweegt. Merk op dat de vertraging () aan het einde is om ervoor te zorgen dat we de tekst kunnen lezen en niet van rechts naar links suizen met onleesbare snelheden. Als de animatie te langzaam of te snel lijkt, kun je de vertragingswaarde wijzigen.

Aangepaste tekens

Ondanks alle toepassingen van de lcd.print()-functie, kunnen we bijvoorbeeld geen dinosaurus op het lcd-scherm weergeven. We kunnen dit echter doen met behulp van een functie van de LiquidCrystal-bibliotheek genaamd Custom Characters.

Hiervoor definiëren we een databyte, die 1s bevat voor alle pixels aan en 0s voor alle pixels uit, zoals dit:

byte dino[]={B01110, B01110, B01100, B01111, B11101, B01010, B01010, B01010} 

Dit is een aangepast personage dat een dinosaurus op het LCD-scherm zal weergeven. Je kunt hier je eigen personages maken:https://maxpromer.github.io/LCD-Character-Creator/

Hierna moeten we ze weergeven. Deze tekens kunnen echter niet worden weergegeven met de normale lcd.print-methode; we moeten dit gebruiken:

void setup(){lcd.createChar(0,dino);lcd.begin(16,2);lcd.setCursor(0,1);lcd.write(byte(0));} 

Met deze code maken we een aangepast adresseerbaar teken uit onze eerder gedefinieerde dino[]-byte. Het adres van ons aangepaste karakter wordt gegeven door lcd.createChar() methode die karakter 0 definieert als dino[]. We zullen dan naar dit teken verwijzen als byte(0), dat het adres van ons aangepaste teken retourneert, en het uiteindelijk op het scherm afdrukken met de lcd.Write()-methode.

Pijlen schieten

Dit programma leert je eindelijk hoe je kunt animeren met behulp van lcd-schermen, lees dit aandachtig door.

#include LiquidCrystal lcd(12,11,4,5,6,7);byte pijlpunt[]={B00001, B00011, B00111, B01111, B00111, B00011, B00001, B00000 }byte arrowbody[]={B00000, B00000, B00000, B11111, B11111, B00000, B00000, B0000}byteB00011, B00111, B01111, B11111, B11111, B01111, B00111, B00011}voidlcd.createChar(0,pijlpunt);lcd. createChar(1,arrowbody);lcd.createChar(2,arrowtail);lcd.begin(16,2);}voidintwhile(n!=-1){lcd.clear();lcd.setCursor(0,1); lcd.write(byte(0));lcd.write(byte(1));lcd.write(byte(2));n--;delay(50);}} 

Hier gebruiken we drie aangepaste tekens om een ​​pijl te simuleren. De rest is je bekend. Terwijl u dit op uw lcd-scherm uitvoert, ziet u mogelijk een spoor achter de pijlstaart waardoor het langer lijkt dan het is, maak u geen zorgen, het is slechts het residu van de eerdere pijlpositie.

Dat is het! Je bent klaar met je eerste animatie met Arduino en LCD's! Speel wat met de code en combineer dit met knopinvoer om dit om te toveren tot een volwaardig spel!

LCD-spel

Eindelijk kunnen we een spel maken! Tijdens deze tutorial ga ik echter niet beginnen met een heel ingewikkeld spel, maar een heel eenvoudig spel dat veel lijkt op de vroege arcade-spellen.

Doel van dit spel

Voordat we de game starten, moeten we een doel voor de gameplay bedenken.

In dit spel is het doel als volgt:

Er is de held, een persoon op rij 1 (merk op dat de eerste rij rij 0 is) (normaal gesproken) op wie een reeks pijlen wordt afgevuurd. Als de held wordt geraakt, is het spel afgelopen. De held gaat de pijlen ontwijken door naar rij 0 te springen, die we met een knop gaan manipuleren. (knop indrukken=rij 0 niet=rij1). De score wordt per loop verhoogd en weergegeven in de rechterhoek.

Dit is eigenlijk een uitbreiding van de animatie van de eariler-pijlen, dus ik ga alleen de delen opnemen die zijn gewijzigd.

byte man[] ={ B01110, B01110, B00100, B01110, B10101, B00100, B01010, B10001};void setup() { // stel het aantal kolommen en rijen van het LCD-scherm in:lcd.createChar( 0, pijlpunt); lcd.createChar (1, pijllichaam); lcd.createChar (2, pijlstaart); lcd.createChar(3,man); lcd.begin (16, 2); attachInterrupt(0,buttonin,CHANGE); randomSeed (analogRead (A0)); // Druk een bericht af op het LCD-scherm. //lcd.print("hallo, wereld!");} int n;void loop() { // zet de cursor op kolom 0, regel 1 // (let op:regel 1 is de tweede rij, aangezien het tellen begint met 0)://lcd.setCursor (0, 1); // print het aantal seconden sinds reset://lcd.print(millis() / 1000); n=15; int.; rnd=willekeurig (15,25); while(n!=-1){ lcd.clear(); vertraging(10); tekenman(); lcd.setCursor(n,1); if(n==1){ if(level==1){ stopgame(); doorgaan; } } lcd.write(byte(0)); lcd.schrijven(byte(1)); lcd.schrijven(byte(2)); lcd.setCursor(10,0); lcd.print(score); vertraging (100-rnd); N--; scoren++; if(niveau==0) score--; }}void drawman(){ lcd.setCursor(1,level); lcd.write(byte(3));}void buttonin(){ if(digitalRead(2)==LOW){ level=0; } anders{ niveau=1; }}void stopgame(){ lcd.clear(); lcd.setCursor(0,0); lcd.print("Game over"); lcd.setCursor(10,0); lcd.print(score); niveau=1; score=0; n=15; vertraging (3000); terug;} 

Niet al deze code gaat over het lcd-scherm, maar ALLES is belangrijk voor game-ontwikkelaars.

We beginnen met de karakterdefinitie van man[] die de byte voor man karakter (onze held) zal opslaan. Dan hebben we de setup-functie, waar slechts twee regels zijn gewijzigd. Beide lijnen zijn representatief voor slechts een deel van de grote groep waaronder ze vallen, namelijk interrupts en willekeurige getallen. Beide zijn zeer nuttige voorzieningen, waarover u meer informatie kunt vinden op de arduino.cc-website.

Eerst hebben we de functie attachInterrupt. Merk op dat de definitie die ik ga geven niet erg uitgebreid is, maar een korte is nodig om te begrijpen wat hier aan de hand is.

Interrupts zijn functies die kunnen worden opgeroepen bij het optreden van een gebeurtenis, ONGEACHT WAAR DE UITVOERING plaatsvindt. Dit is een belangrijk feit dat nuttig is voor het implementeren van realtime invoerfuncties. Hier gebruiken we het om ervoor te zorgen dat ongeacht op welk punt van de uitvoering de knop wordt ingedrukt, we de juiste actie zullen ondernemen (tenminste het programma zal).

Syntaxis voor attachInterrupt:

attachInterrupt(pin_number-2,function_to_call_without_parenthesis,condition_for_calling);

CHANGE is een #define-waarde die wordt gebruikt om aan te geven dat voor elke statuswijziging in de pin_number-invoer de bijgevoegde functie wordt aangeroepen.

Dan hebben we een willekeurig getal. Een uitstekende eigenschap die fysieke processors zoals de Arduino hebben en normale processors niet, is dat een willekeurig getal dat door de Arduino wordt gegenereerd, echt is. willekeurig als de analoge ruis aanwezig op pin A0 if pin A0 zweeft (d.w.z. niet verbonden) is willekeurig zoals voorspeld door de kwantumfysica (min of meer).

randomSeed wordt gebruikt om het zaad voor het willekeurige proces in te stellen. random() is een functie met parameters MIN,MAX of MAX alleen om het volgende willekeurige getal in de reeks te krijgen.

Dan hebben we de Interrupt-functie buttonin() die controleert of de knop wordt ingedrukt (LOW) of niet (HIGH) en verandert het niveau (rij) van onze held dienovereenkomstig.

Dat is het, we hebben een volledig functioneel spel!!

Code

• code voor animatie
• code voor spel

code voor animatieArduino

// voeg de bibliotheekcode toe:#include // initialiseer de bibliotheek door de benodigde LCD-interface-pin// te koppelen aan het arduino-pinnummer waarmee deze is verbondenconst int rs =12, en =11, d4 =4, d5 =5, d6 =6, d7 =7;LiquidCrystal lcd(rs, en, d4, d5, d6, d7);byte pijlpunt[]={ B00001, B00011, B00111, B01111, B00111, B00011, B00001 , B00000};byte arrowbody[]={ B00000, B00000, B00000, B11111, B11111, B00000, B00000, B00000};byte arrowtail[]={ B00011, B00111, B11111, B11111, B11111, B00111, B00011, B00000}; byte man [] ={B01110, B01110, B00100, B01110, B10101, B00100, B01010, B10001};void setup() { // stel het aantal kolommen en rijen van het LCD-scherm in:lcd.createChar(0,pijlpunt); lcd.createChar (1, pijllichaam); lcd.createChar (2, pijlstaart); lcd.createChar(3,man); lcd.begin (16, 2); // Druk een bericht af op het LCD-scherm. //lcd.print("hallo, wereld!");}void loop() { // zet de cursor op kolom 0, regel 1 // (let op:regel 1 is de tweede rij, aangezien het tellen begint met 0)://lcd.setCursor (0, 1); // print het aantal seconden sinds reset://lcd.print(millis() / 1000); int n; n=15; while(n!=-1){ lcd.clear(); vertraging(10); lcd.setCursor(0,0); lcd.print("door Debanshu Das"); /* lcd.setCursor(1,1); lcd.schrijven (byte (3)); lcd.setCursor(n,1); lcd.schrijven(byte(0)); lcd.schrijven(byte(1)); lcd.write(byte(2));*/vertraging(65); N--; }}

code voor spelArduino

// voeg de bibliotheekcode toe:#include // initialiseer de bibliotheek door de benodigde LCD-interface-pin// te koppelen aan het arduino-pinnummer waarmee deze is verbondenconst int rs =12, en =11, d4 =4, d5 =5, d6 =6, d7 =7;LiquidCrystal lcd(rs, en, d4, d5, d6, d7);int level=1;int score=0;byte pijlpunt[]={ B00001, B00011 , B00111, B01111, B00111, B00011, B00001, B00000};byte arrowbody[]={ B00000, B00000, B00000, B11111, B11111, B00000, B00000, B00000};byte arrowtail[]={ B00011, B00111, B11111, B11111 , B11111, B00111, B00011, B00000};byte man[] ={B01110, B01110, B00100, B01110, B10101, B00100, B01010, B10001};void setup() { // stel het aantal kolommen en rijen van het LCD-scherm in:lcd.createChar(0,pijlpunt); lcd.createChar (1, pijllichaam); lcd.createChar (2, pijlstaart); lcd.createChar(3,man); lcd.begin (16, 2); attachInterrupt(0,buttonin,CHANGE); randomSeed (analogRead (A0)); // Druk een bericht af op het LCD-scherm. //lcd.print("hallo, wereld!");} int n;void loop() { // zet de cursor op kolom 0, regel 1 // (let op:regel 1 is de tweede rij, aangezien het tellen begint met 0)://lcd.setCursor (0, 1); // print het aantal seconden sinds reset://lcd.print(millis() / 1000); n=15; int.; rnd=willekeurig (15,25); while(n!=-1){ lcd.clear(); vertraging(10); tekenman(); lcd.setCursor(n,1); if(n==1){ if(level==1){ stopgame(); doorgaan; } } lcd.write(byte(0)); lcd.schrijven(byte(1)); lcd.schrijven(byte(2)); lcd.setCursor(10,0); lcd.print(score); vertraging (100-rnd); N--; scoren++; if(niveau==0) score--; }}void drawman(){ lcd.setCursor(1,level); lcd.write(byte(3));}void buttonin(){ if(digitalRead(2)==LOW){ level=0; } anders{ niveau=1; }}void stopgame(){ lcd.clear(); lcd.setCursor(0,0); lcd.print("Game over"); lcd.setCursor(10,0); lcd.print(score); niveau=1; score=0; n=15; vertraging (3000); terug;}

Schema's