Arduino - դաշնամուրի սալիկներ. 16 քայլ (նկարներով)

2024 Հեղինակ: John Day | [email protected]. Վերջին փոփոխված: 2024-01-30 09:49

Ողջույն, ինտերնետային ցանցի մարդկանց, սա այն մասին է, թե ինչպես կարելի է անել այն, ինչ ՎԵՐԱԲԵՐՎԱԼ չի կարող լինել բջջային խաղի arduino uno r3- ում:

սկսելու համար ձեզ հարկավոր կլինեն բոլոր մասերը, որոնք հետևյալն են. 1x Arduino Uno r3 (42 դոլար)

2x LCD ստեղնաշարի վահան (յուրաքանչյուրը 19 դոլար)

5x կոճակներ

5x 220Ω ռեզիստորներ

28x լարեր

Լավ, բոլոր մասերը ձեռք բերելուց հետո ժամանակն է սկսել:

Քայլ 1: Լարերի տեղադրում

Սկսեք միացնել ձեր arduino- ին և ընկերներին, ինչպես ցույց է տրված գծապատկերում, Համոզվեք, որ կոճակները ճիշտ են միացված ՝ կոճակների ռելսերի առաջին կողմում տեղադրված A0-4 անցքերով, կամ փոխարենը arduino- ն կմտածի, որ կոճակները անընդհատ սեղմված են, այլ ոչ թե միայն սեղմիչի վրա:

Քայլ 2. Հռչակագրի հայտարարություններ

Ամբողջ կոդն այստեղ պետք է անցնի ձեր դատարկ կարգավորումից և դատարկ հանգույցից, քանի որ այս բոլոր փոփոխականներն ու օբյեկտները օգտագործվում են մի քանի գործառույթներում, որոնք մենք կստեղծենք:

Սկսեք ՝ դնելով.

#ներառում

ձեր ծածկագրի վերևում սա arduino- ին ասում է, որ օգտագործի «LiquidCrystal.h» գրադարանը և դրա մի մասի գործառույթները:

Հաջորդ քայլն այն կոճակների սահմանումն է, որոնք մենք օգտագործում ենք մեր կոճակների համար ՝ տեղադրելով այս կոդը մեր #Include- ի ներքևում:

#սահմանել btn Մուտքագրեք A0 #սահմանեք btn1 15 #սահմանեք btn2 16 #սահմանեք btn3 17 #սահմանեք btn4 18

Մենք սահմանում ենք btnEnter և btn1- ից btn 4 տերմինները, որպեսզի ծածկագիրը հեշտ լինի մեզ համար կարդալ, կամ անհրաժեշտության դեպքում փոխվի: Դա նշանակում է, որ երբ մենք մուտքագրում ենք btn1 arduino- ն կիմանա, որ մենք իրականում նկատի ունենք կոճակը 15. Չնայած մենք նավահանգիստներին անվանում ենք 15, 16, 17 և 18 նավահանգիստներ, սակայն դրանք arduino- ում պիտակավորված են որպես A1 A2 A3 և A4, դա պայմանավորված է նրանով, որ դրանք նավահանգիստներ են, որոնք հատուկ օգտագործվում են անալոգային մուտքերի համար, չնայած մենք դրանք օգտագործում ենք միայն թվային մուտքերի համար:

Հաջորդը մենք պատրաստվում ենք ստեղծել այն օբյեկտները, որոնք վերահսկելու են Liquid Crystal Displays- ը: Դա անելու համար այս ծածկագիրը դրեք մեր սահմանածներից ներքև

LiquidCrystal lcdLeft (8, 9, 12, 10, 11, 13); LiquidCrystal lcdRight (2, 3, 4, 5, 6, 7);

Այն, ինչ անում է, arduino- ին ասում է, որ երբ մենք զանգահարում ենք lcdLeft կամ lcdRight, մենք վերաբերում ենք LiquidCrystal օբյեկտին: Կցված փակագծերի թվերը arduino- ին ասում են, թե որ նավահանգիստներն են օբյեկտը պետք օգտագործել `LCD- ին հաղորդագրություններ ուղարկելու համար, երբ մենք օգտագործում ենք նրանց գործառույթները:

Այժմ մենք պետք է փոփոխականները հայտարարենք ՝ տեղադրելով հաջորդ բիտը օբյեկտի հայտարարություններից ներքև.

// այս փոփոխականները տարբերակներ են, որոնք կարող եք փոխել ՝ ավելի մեծ թվեր = խաղի ավելի արագ արագացում intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

// ստեղծել փոփոխականներ gameboolean bolPlay- ի համար; // հետքեր, եթե խաղացողը int intScore; // հետևում է խաղացողի գնահատականին int intDiff; // պարզապես էսթետիկ բան ասելու համար, թե ինչ դժվարության վրա է խաղը // փոփոխականներ ստեղծեք int intEnter մուտքագրման համար; // հետևում է, եթե օգտագործողը սեղմում է մուտքագրման կոճակը int intInput; // հետևում է, թե որ կոճակներն է օգտվողը սեղմում բուլյան bolTilePressed; // ապահովել, որ նվագարկիչը պատահաբար 5 անգամ չսեղմի և չկորցնի // փոփոխություններ ստեղծի turn int intTick- ի համար; // հաշվում է միլիոններ (մեկ հանգույցի համար) մինչև intDelay int intDelay; // ծրագիրը, որը սպասում է մինչև հաջորդ շրջադարձը millis int intGameSpeed; // վրիպազերծման ընտրանքների ընդհատում բուլյան bolSerialBoard; // երբ ճշմարիտը տպելու է տախտակը սերիական մոնիտորի վրա

Մենք փոփոխական ենք հայտարարում `նշելով տվյալների տեսակը, այնուհետև փոփոխականի անունը, օրինակ. int thisIsAnInteger

Բուլյան փոփոխականները, ինչպիսիք են bolSerialBoard- ը և bolPlay- ը, կարող են ունենալ միայն երկու արժեքներից մեկը ՝ ճշմարիտ կամ կեղծ:

Ամբողջական փոփոխական (int), ինչպիսիք են intScore- ը և intInput- ը, կարող են ամբողջ թվերը վերցնել որպես արժեքներ, օրինակ ՝ 1, 5 կամ 100:

Որոշ այլ նշանավոր տվյալների տեսակներ, որոնք մենք չենք օգտագործում այստեղ, տող է, որը տեքստի մի հատված է, և բոց, որը տասնորդական թիվ է:

Այստեղ փոփոխականներից յուրաքանչյուրն օգտագործվում է ծրագրի մի քանի վայրերում, ահա ամփոփագիրը, թե ինչ է անում յուրաքանչյուրը

bolPlay- ը ծրագրին տեղեկացնում է, թե արդյոք ցանկը պետք է ցուցադրվի, թե արդյոք իրական խաղը պետք է գործարկվի:

intScore- ը հետևում է խաղացողի գնահատականին, երբ նրանք հարվածում են սալիկներին, intDiff- ը օգտագործվում է հիմնական ընտրացանկում `ծրագրին ասելու համար, թե ինչ տեքստ պետք է տպվի LCD- ով, intEnter- ը օգտագործվում է ծրագրին հայտնելու համար, եթե սեղմված է մուտքագրման կոճակը (ամենահեռավոր ձախ կողմը), intInput- ն օգտագործվում է ծրագրին ասելու համար, թե մյուս 4 կոճակներից որն է սեղմված:

bolTilePressed- ն օգտագործվում է համոզվելու համար, որ ծրագիրը կարդում է միայն կոճակը սեղմելիս, այլ ոչ թե այն պահելիս:

intGameSpeed, intGameSpeedEasy, intGameSpeedMedium և intGameSpeedHard օգտագործվում են վերահսկելու, թե որքան արագ պետք է խաղը արագանա ՝ ելնելով այն դժվարությունից, որը ընտրված է:

intTick- ը և intDelay- ն օգտագործվում են, որպեսզի ծրագիրը ամեն անգամ այն շրջանցի, տախտակը չշարժի:

bolSerialBoard- ն օգտագործվում է ձեզ թույլ տալու համար, որպեսզի ծրագիրը փորձարկման նպատակով տախտակը ուղարկի arduino- ի սերիական մոնիտոր:

Ի վերջո, ժամանակն է հայտարարելու մեր խորհուրդը որպես զանգված ՝ օգտագործելով այս ծածկագիրը.

// set up game arrayint arrGame [16] [4] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};

Arանգվածը մատրիցա է, որի ցանկացած կետ, որի վրա կարելի է կանչել մաթեմատիկա կամ փոխել:

Ձեր կոդը այժմ պետք է ունենա այսպիսի տեսք.

// ներառել գրադարաններ#include

// այս փոփոխականները տարբերակներ են, որոնք կարող եք փոխել ՝ ավելի մեծ թվեր = խաղի ավելի արագ արագացում

int intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

// Սահմանեք կապում

#սահմանել btn Մուտքագրեք A0 #սահմանեք btn1 15 #սահմանեք btn2 16 #սահմանեք btn3 17 #սահմանեք btn4 18

// ստեղծել LCD օբյեկտներ (n, ~, n, ~, ~, n)

LiquidCrystal lcdLeft (8, 9, 12, 10, 11, 13); LiquidCrystal lcdRight (2, 3, 4, 5, 6, 7);

// ստեղծել խաղի զանգված

int arrGame [16] [4] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};

// ստեղծել փոփոխականներ խաղի համար

բուլյան bolPlay; // հետքեր, եթե խաղացողը int intScore; // հետևում է խաղացողի գնահատականին int intDiff; // պարզապես էսթետիկական բան ՝ պատմելու համար, թե ինչ դժվարության վրա է գտնվում խաղը

// մուտքագրման համար փոփոխականներ սահմանել

int intErter; // հետևում է, եթե օգտագործողը սեղմում է մուտքագրման կոճակը int intInput; // հետևում է, թե որ կոճակներն է օգտվողը սեղմում բուլյան bolTilePressed; // համոզվեք, որ նվագարկիչը պատահաբար չի սեղմում 5 անգամ կոճակը և չի պարտվում

// հերթափոխի համար փոփոխականներ սահմանել

int intTick; // հաշվում է միլիոններ (մեկ հանգույցի համար) մինչև intDelay int intDelay; // ծրագիրը, որը սպասում է մինչև հաջորդ շրջադարձը millis int intGameSpeed;

// վրիպազերծման ընտրանքների ընդհատում

բուլյան bolSerialBoard; // երբ ճշմարիտը տպելու է տախտակը սերիական մոնիտորի վրա

Քայլ 3: Կարգավորման գործառույթը

Կարգավորման օղակը գործառույթ է, որը arduino- ն կարդում է միայն մեկ անգամ, երբ այն սկզբում սկսվում է:

Կարգավորման օղակում մենք պարզապես սահմանում ենք մեր մի քանի փոփոխականների արժեքները, քանի որ դրանք հայտարարելու ժամանակ դրանք արժեք սահմանելու փոխարեն մենք դա անում ենք այստեղ:

Սկսեք ՝ այս կոդը տեղադրելով ձեր Void Setup- ում:

bolPlay = կեղծ; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium;

Յուրաքանչյուր տող պարզապես փոփոխական է դնում արժեքի վրա:

bolPlay- ը սահմանվել է կեղծ, որպեսզի խաղը չսկսի խաղալ:

intScore- ը սահմանվել է 0, քանի որ բնականաբար ձեր հաշիվը սկսվում է 0 -ից:

intTick- ը սկսվում է 0 -ից, քանի որ ծրագիրը ներկայումս ոչինչ չի հաշվում:

intDelay- ը սահմանվել է 1000, քանի որ դա այն արագությունն է, որով սկսում են սալիկները:

intDiff- ը պարզապես ասկետիկ բան է, որպեսզի ծրագիրը իմանա, թե ինչ գրել խաղի դժվարության համար:

intGameSpeed- ը դրված է այն ամենի վրա, ինչ intGameSpeedMedium- ն է, այսինքն ՝ այն դրված է միջին դժվարության վրա:

Հաջորդը տեղադրեք այս ծածկագիրը Void Setup- ում ՝ հենց նոր տեղադրված ծածկագրի ներքո:

lcdLeft.begin (16, 2); lcdRight.begin (16, 2);

Serial.begin (9600);

Սա arduino- ին ասում է, որ համակարգչի հետ սկսի հաղորդակցվել սերիական մոնիտորի միջոցով (տեսանելի է arduino IDE- ի վերևի աջ կոճակը սեղմելով):

Ձեր Void Setup- ն այժմ պետք է ունենա այսպիսի տեսք:

void setup () {Serial.begin (9600); // սկսել սերիական մոնիտորը // ստեղծել փոփոխականներ bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // սկսել lcd's lcdLeft.begin (16, 2); lcdRight.begin (16, 2); }

Քայլ 4: Օղակի գործառույթը

Օղակի գործառույթը կատարվում է arduino- ի կողմից arduino- ի յուրաքանչյուր կրկնություն:

Պատճենեք հետևյալ կոդը ձեր Void Loop- ում:

void loop () {մուտքագրում (); // ստուգեք մուտքի խաղը, եթե (bolPlay == true) {if (intTick> = intDelay) {// ստուգեք, արդյոք խաղը պետք է շրջադարձ կատարի, թե՞ շարունակի սպասել Serial.println ("~~~~~~~ print "); // տպել` նշելու համար, որ տախտակը շարժվում է // writeSerial (); // եթե տարբերակը միացված է, գրեք տախտակը սերիական կոճակների մեջ GameGame (); // ստուգել խաղացողի մուտքի համար playBoard (); // տեղափոխել տախտակը և ավելացնել նոր կղմինդր clearLcd (); // drawBoard նկարելուց առաջ մաքրեք LCD- ները (); // տախտակը գծեք lcd's bottomCheck (); intTick = 0; // վերականգնել intTick} else {buttonsGame (); // ստուգեք նվագարկչի մուտքերի համար clearLcd (); // drawBoard նկարելուց առաջ մաքրեք LCD- ները (); // տախտակը գծեք lcd- ի intTick = intTick + intGameSpeed; // ավելացնել տիզին}} else {clearLcd (); // վերնագիրը նկարելուց առաջ մաքրել LCD- ները (); // ցուցադրել վերնագրի և միավորի մասին infoMenu (); // կարդալ նվագարկիչի մուտքը clearBoard (); // ապահովել ամբողջ տախտակի = 0} ուշացում (10); // arduino- ն կարճ պահով հետաձգել}

երբ bolPlay- ը հավասար է ճշմարիտին, նշանակում է, որ խաղը խաղում է, և խաղը խաղալու ամբողջ ծածկագիրը պետք է գործարկվի, բայց մենք միայն ցանկանում ենք, որ խորհուրդը ավելացնի նոր սալիկ և շարժվի ներքև, երբ intTick- ն ավելի մեծ է, քան մեր intDelay- ը, հակառակ դեպքում մենք դեռ ցանկանում ենք թույլ տալ օգտվողին սեղմել սալիկին հարվածելու կոճակ, իսկ intTick- ը ՝ արագության բարձրացում:

Այս ծածկագրի մեծ մասն օգտագործում է գործառույթներ, որոնք մենք դեռ պետք է կատարենք, և դրանք կկատարենք հաջորդ քայլերում: Այս գործառույթների նպատակը հետևյալն է.

Մուտքը կարդում է, թե որ կոճակները սեղմել է օգտատերը:

buttonsGame- ը վերահսկում է, թե ինչ են անում կոճակները խաղի ժամանակ, և ոչ թե ընտրացանկում

playBoard- ը նոր սալիկ է ավելացնում տախտակին, այնուհետև տախտակի մեջ եղած ամեն ինչ տեղափոխում է մեկ տեղով ներքև

clearLCD- ը մաքրում է LCD- ները `համոզվելու համար, որ սալիկների հետևում ուրվականներ չեն մնացել

drawBoard- ը անցնում է arrGame- ով և տպում այն LCD- ների վրա

clearBoard- ը մաքրում է arrGame- ի ամբողջությունը, երբ խաղը չի խաղում

bottomCheck- ը ստուգում է arrGame- ի ներքևի մասը `ձախողման վիճակի համար

վերնագիրը ցուցադրում է խաղի վերնագիրը և հաշիվը, երբ ընտրացանկում է

կոճակների ընտրացանկը վերահսկում է, թե ինչ են անում օգտվողի մուտքերը ցանկում:

gameOver- ը մեկ այլ գործառույթ է, չնայած այստեղ այն չի կոչվում, ինչպես փոխարենը կոչվում է ներքևումՍեղմեք և կոճակներԽաղի գործառույթները:

Քայլ 5: ClearLCD գործառույթը

գործառույթ ստեղծելու համար մենք սկսում ենք սա ավելացնելով ծածկագրին

դատարկ գործառույթ Name () {

}

«functionName» - ը կարող է լինել ամեն ինչ, քանի դեռ այն գոյություն չունի:

Պատճենեք այս կոդը ձեր ծրագրում.

անվավեր clearLcd () {for (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 1; ii ++) {lcdLeft.setCursor (i, ii); lcdLeft.write (""); lcdRight.setCursor (i, ii); lcdRight.write (""); }}}

սա անցնում է ամբողջ զանգվածի միջոցով `օգտագործելով 2 հաշված օղակ` LCD- ների յուրաքանչյուր կետով անցնելու և բացատ գրելու համար:

Առանց ոչնչի չվերականգնվելու, LCD- երը կպահպանեն այն, ինչ նախկինում գրված էր

Քայլ 6: DrawBoard գործառույթը

պատճենեք այս կոդը ձեր ծրագրում

void drawBoard () {for (int i = 1; i <= 15; i ++) {// նկարել collums 1 և 2 ձախ LCD- ով // եթե սալիկը = 0 ոչինչ չգրել, = 1 գրել "#", = 2 գրել «@» lcdLeft.setCursor (i, 1); // սահմանել առաջին սյունակին (ամենահեռավոր ձախ կողմը), եթե (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.գրեք («@»);} lcdLeft.setCursor (i, 0); // սահմանել երկրորդ սյունակի վրա (ձախ ձախ) եթե (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.գրեք («@»);} lcdRight.setCursor (i, 1); // սահմանել երրորդ սյունակին (կենտրոնական աջ) եթե (arrGame [2] == 1) {lcdRight.write ("#");}} եթե (arrGame [2] == 2) {lcdRight.գրեք («@»);} lcdRight.setCursor (i, 0); // սահմանել չորրորդ սյունակին (ամենահեռու աջը), եթե (arrGame [3] == 1) {lcdRight.write ("#");} if (arrGame [3] == 2) {lcdRight.գրեք ("@");}}}

սա օգտագործում է մի հանգույց ՝ տախտակի յուրաքանչյուր տողից անցնելու համար, այնուհետև ստուգում է ՝ արդյոք տողում որևէ սյունակ հավասար է 1 -ի կամ 2 -ի, դրա հիման վրա այն LCD- ով տպում է կամ հեշթեգ ՝ դեռևս սալիկի համար: հարվածել, կամ հարվածել սալիկի համար @

Քայլ 7: PlayBoard գործառույթը

պատճենեք այս կոդը ձեր ծրագրում:

void playBoard () {for (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // ջնջել վերին տողը arrGame [0] [պատահական (0, 4)] = 1; // վերին տողի պատահական կետը դարձրեք սալիկ (int i = 15; i> = 1; i-) {//, որը աշխատում է տախտակի ներքևից մինչև վեր (int ii = 0;) համար: ii <= 3; ii ++) {// յուրաքանչյուր բախման համար arrGame [ii] = arrGame [i - 1] [ii]; }}}

այս ծածկագիրը սկսվում է ամբողջ վերին տողից մաքրելով 0 -ով կամ առանց սալիկի, այնուհետև մեկ պատահական սալիկը սահմանում է 1 և չհրապարակված սալիկ:

Այնուհետև այն անցնում է հակադարձ ՝ 15 -ից 1 -ը ՝ շարքը հավասարեցնելով այն, ինչին հավասար է վերևի տողը, ինչը ստիպում է տախտակը շարժվել LCD- ով ներքև

Քայլ 8: ClearBoard գործառույթը

պատճենեք այս կոդը ձեր ծրագրում:

void clearBoard () {// վերականգնել տիզերի և հետաձգման արժեքները intTick = 0; intDelay = 1000; // անցնել տախտակի միջով և ամեն ինչ սահմանել 0 -ի համար (int i = 0; i <= 15; i ++) {համար (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

Այս կոդը գործարկվում է, երբ խաղը չի խաղում, որպեսզի համոզվեք, որ ամբողջ arrGame- ը սահմանվել է 0 -ի կամ սալիկների բացակայության դեպքում `զանգվածով անցնելու համար հաշվարկված օղակների միջոցով:

Կոդը նաև վերականգնում է intDelay և intTick արժեքները:

Քայլ 9. Վերնագրի գործառույթը

պատճենեք հետևյալ ծածկագիրը ձեր ծրագրում

անվավեր վերնագիր () {// գրել վերնագիրը LCD- ի վրա և բաց թողնել միավորի համար lcdRight.setCursor (0, 0); lcdRight.write («Դաշնամուրի սալիկներ»); lcdRight.setCursor (0, 1); lcdRight.write ("Հաշիվը"); // հաշիվը վերածել լարային char strScore [3]; sprintf (strScore, "%d", intScore); // ցուցադրել հաշիվը LCD lcdRight.write- ի վրա (strScore); // ավելացնել diffictuly lcdRight.setCursor (10, 1); if (intDiff == 0) {lcdRight.write («Հեշտ»); } if (intDiff == 1) {lcdRight.write («Միջին»); } if (intDiff == 2) {lcdRight.write («Դժվար»); } // Սեղմեք մի փոքր հրահանգ lcdLeft.setCursor (0, 0); lcdLeft.write ("Սեղմեք Enter"); lcdLeft.setCursor (0, 1); lcdLeft.write («սկսել»); }

Այս ծածկագիրը գրում է խաղի անվանումը և հաշիվը LCD- ների վրա, դա անում է ՝ ասելով LCD- ին, թե որտեղից սկսել մուտքագրել LCD.setCursor- ի միջոցով, այնուհետև շարանը գրել LCD.write- ով:

Այստեղ ստեղծվում է նաև նոր փոփոխական ՝ strScore, այն օգտագործվում է spintf գործառույթի միջոցով intScore- ը տողի կամ char տվյալների տիպի վերածելու համար:

intDiff- ը նույնպես օգտագործվում է այստեղ, իր արժեքների հիման վրա տպում է տարբեր դժվարությունների ընտրանքներ:

Քայլ 10: ButtonsMenu գործառույթը

տեղադրեք հետևյալ ծածկագիրը ձեր ծրագրի մեջ

void buttonsMenu () {// երբ enter սեղմված է, սկսեք խաղը և վերակայեք միավորի արժեքը, եթե (intEnter == 1) {bolPlay = true; intScore = 0; playBoard (); drawBoard (); } // 3 -րդ կոճակը սեղմելիս միացրեք տախտակի սերիական տպման կարգաբերման տարբերակը, եթե (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("Serial Board Active"); bolSerialBoard = ճշմարիտ; } else {Serial.println ("Սերիայի տախտակն անջատված է"); bolSerialBoard = կեղծ; }} // սահմանել խաղի արագությունը հեշտ դժվարության դեպքում, եթե (intInput == 0) {Serial.print ("Game set to easy ("); Serial.print (intGameSpeedEasy); Serial.println ("ms արագացում)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // սահմանել խաղի արագությունը միջին դժվարության դեպքում, եթե (intInput == 1) {Serial.print ("Game set to medium ("); Serial.print (intGameSpeedMedium); Serial.println ("ms արագացում)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // սահմանել խաղի արագությունը ծանր դժվարության դեպքում, եթե (intInput == 2) {Serial.print ("Game set to hard ("); Serial.print (intGameSpeedHard); Serial.println ("ms արագացում)"); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

այս կոդը գործարկվում է միայն այն դեպքում, երբ bolPlay- ը դատարկ Loop- ում հավասար է false- ի

եթե intEnter- ը 1 է, նշանակում է, որ մուտքագրման կոճակը սեղմված է, եթե այն սեղմվում է, ծրագիրը bolPlay- ը սահմանում է true և խաղը սկսվում է:

Այնուհետեւ ծրագիրը կարդում է, թե ինչին է հավասար intInput- ը: եթե այն հավասար է 0 -ի, ձախից սեղմվում է առաջին կոճակը, որը բարձրանում է դեպի աջ մինչև 3. Եթե intInput- ը հավասար է 4 -ի, ոչ մի կոճակ չի սեղմվում:

եթե 0-2 կոճակները սեղմված լինեն, խաղը փոխում է դժվարությունը ՝ կարգավորելով նաև խաղի արագության արժեքը, այսինքն ՝ այն ավելի արագ կարագանա:

եթե կոճակը 3 սեղմված է, խաղը կակտիվացնի կամ կակտիվացնի վրիպազերծման ռեժիմը, որտեղ ամբողջ տախտակը տպված է սերիական մոնիտորի վրա `օգնելու ծրագրում խնդիրներ գտնելուն:

Քայլ 11: The ButtonsGame գործառույթը

պատճենեք հետևյալ ծածկագիրը ձեր ծրագրում

void buttonsGame () {if (intInput! = 4) {// եթե կոճակը սեղմվում է if (bolTilePressed == false) {// միայն այն դեպքում, երբ bolTilePressed- ը կոճակի ստուգման կեղծ հրահրող գործողություն է, սեղմել bolTilePressed = true; // այնուհետև bolTilePressed- ը դրեք true- ի վրա ՝ համոզվելու համար, որ այն կրկին պատահաբար չի գործարկվում int intLowestTile = 0; // սահմանել սալիկին ամենացածր սալիկով int intCheckedTile = 15; // հետևելու համար, թե որ սալիկներն են ստուգվել (intLowestTile == 0) {// քանի դեռ այն որևէ բանի վրա դրված չէ, ստուգեք սալիկները (int i = 0; i 100) {// այնքան ժամանակ, որքան int հետաձգումը 100 -ից ցածր չէ intDelay = intDelay - 20; // արժեք վերցնել դրանից}} else {Serial.println ("Սեղմված կոճակը սեղմված է"); խաղն ավարտված է(); // հակառակ դեպքում խաղը}}}}}

Կոդը գործարկվում է միայն այն դեպքում, երբ bolPlay- ը հավասար է true- ի դատարկ Loop- ում:

Like կոճակներըՄենյու, որը հիմնված է ներածման արժեքի վրա, այն ստուգում է ՝ խաղացողը հարվածել է սալիկին, թե բաց թողել:

Դա անում է arrGame- ով ՝ ներքևից վերև, օգտագործելով while օղակը ՝ փնտրելու համար, թե որ տողն է ամենացածրը չբացված սալիկով: Այնուհետև այն ստուգում է ՝ տեսնելու, արդյոք կոճակին սեղմված համապատասխան այդ տողի բիծը չթողնված սալիկ է, թե ոչ, եթե այն բացակայում է, այն 1 -ի փոխարեն հավասար է 2 -ի, այսինքն ՝ այն կցուցադրվի որպես @, հակառակ դեպքում այն ակտիվացնում է խաղը գործառույթ, որը մենք դեռ պետք է ստեղծենք:

Այս ֆունկցիան օգտագործում է նաև bolTilePressed փոփոխականը ՝ այն կոճակին սեղմելիս ճշմարիտ դարձնելով և ոչ մի կոճակ սեղմելիս ՝ կեղծ: Սա այն է, որպեսզի օգտվողը պատահաբար չկորցնի խաղը, քանի որ ծրագիրը կարծում էր, որ այն մի քանի անգամ սեղմել են կոճակը, երբ այն պահել են:

Քայլ 12. GameOver գործառույթը

Պատճենեք հետևյալ կոդը ձեր ծրագրում

void gameOver () {Serial.println («Խաղն ավարտված է»); Serial.print («Ձեր հաշիվն էր ՝»); Serial.println (intScore); Serial.print («Ձեր արագությունը եղել է ՝»); Serial.println (intDelay); bolPlay = կեղծ; }

Սա հրահրվում է checkBottom կամ buttonsGame գործառույթներով և խթանում խաղի ավարտը ՝ bolPlay- ը կեղծ դնելով:

Այն նաև հաղորդագրություն է տպում սերիական մոնիտորի մեջ ՝ օգտվողների գնահատականի համար, իսկ արագության սալիկներն ավելացվել են միլիվայրկյաններով:

Քայլ 13: Ներածման գործառույթը

Պատճենեք հետևյալ կոդը ձեր ծրագրում:

անվավեր մուտքագրում () {intEnter = digitalRead (btnEnter); // կարդալ մուտքագրել // կարդալ մյուս մուտքերից որևէ մեկը, կամ եթե ոչ մեկը չի սահմանել 4 եթե (digitalRead (btn1) == HIGH) {intInput = 0;} else {if (digitalRead (btn2) == HIGH) {intInput = 1;} այլ {if (digitalRead (btn3) == HIGH) {intInput = 2;} else {if (digitalRead (btn4) == HIGH) {intInput = 3;} else {intInput = 4; }}}} // սերիական տպել մուտքերը if (intEnter == 1) {Serial.println ("Մուտք սեղմված է!");} if (intInput! = 4) {Serial.print ("Button Press:"); Serial.println (intInput); } else {// եթե ոչ մի կոճակ սեղմված չէ reset bolTilePressed bolTilePressed = false; }}

Այս կոդը օգտագործվում է buttonsGame և buttonsMenu գործառույթների հետ: օգտվողի կողմից սեղմված կոճակների հիման վրա այն սահմանում է intInput- ի արժեքը, կամ եթե ոչ մի կոճակ սեղմված չէ, intInput- ը հավասար է 4 -ի:

Եթե ոչ մի կոճակ սեղմված չէ, այստեղ է, որ bolTilePressed- ը վերականգնվում է buttonsGame գործառույթի համար:

Այն նաև տպում է հաղորդագրություն սերիական մոնիտորին, որի վրա սեղմված է կոճակը:

Քայլ 14: The BottomCheck գործառույթը

պատճենեք հետևյալ ծածկագիրը ձեր ծրագրում:

void bottomCheck () {for (int i = 0; i <= 3; i ++) {// եթե 4 սյունակները (arrGame [15] == 1) {// եթե սալիկը գտնվում է ներքևում Սերիա.println («Սալիկ ներքեւում»); arrGame [15] = 2; drawBoard (); ուշացում (400); arrGame [15] = 1; drawBoard (); ուշացում (400); arrGame [15] = 2; drawBoard (); ուշացում (400); arrGame [15] = 1; drawBoard (); ուշացում (400); խաղն ավարտված է(); }}}

օգտագործելով հանգույց, այս ծածկագիրը ստուգում է arrGame- ի ստորին տողը ցանկացած unhit սալիկների համար (1 -ի հավասար սալիկներ), եթե էկրանի ներքևում կա unhit սալիկ, այն կթափի սալիկը, այնուհետև խաղը կաշխատի գործառույթի վրա:

Քայլ 15: WritSerial գործառույթը

պատճենեք հետևյալ ծածկագիրը ձեր ծրագրում

void writeSerial () {if (bolSerialBoard == true) {for (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 3; ii ++) {Serial.print (arrGame [ii]); Serial.print (","); } Serial.println (""); }}}

Սա այն գործառույթն է, որին հաջորդում է վրիպազերծման տարբերակը, որը կարելի է միացնել buttonsMenu գործառույթում: Եթե bolSerialBoard- ը այդ գործառույթում ճշմարիտ է դրված, այն կանցնի arrGame- ի միջոցով և ամբողջ զանգվածը տպելու է սերիական մոնիտորի մեջ `փորձարկման նպատակով` օգտագործելով զանգված:

Քայլ 16: Ավարտում:

Ձեր ամբողջ ծածկագիրը չպետք է ամբողջական լինի և ունենա այսպիսի տեսք:

/ * * Անուն - դաշնամուրի սալիկներ; Arduino * By - Domenic Marulli * Ամսաթիվ - 11/ *

/ ներառել գրադարանները

#ներառում

// այս փոփոխականները տարբերակներ են, որոնք կարող եք փոխել ՝ ավելի մեծ թվեր = խաղի ավելի արագ արագացում

int intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

// Սահմանեք կապում

#սահմանել btn Մուտքագրեք A0 #սահմանեք btn1 15 #սահմանեք btn2 16 #սահմանեք btn3 17 #սահմանեք btn4 18

// ստեղծել LCD օբյեկտներ (n, ~, n, ~, ~, n)

LiquidCrystal lcdLeft (8, 9, 12, 10, 11, 13); LiquidCrystal lcdRight (2, 3, 4, 5, 6, 7);

// ստեղծել խաղի զանգված

int arrGame [16] [4] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};

// ստեղծել փոփոխականներ խաղի համար

բուլյան bolPlay; // հետքեր, եթե խաղացողը int intScore; // հետևում է խաղացողի գնահատականին int intDiff; // պարզապես էսթետիկական բան ՝ պատմելու համար, թե ինչ դժվարության վրա է գտնվում խաղը

// մուտքագրման համար փոփոխականներ սահմանել

int intErter; // հետևում է, եթե օգտագործողը սեղմում է մուտքագրման կոճակը int intInput; // հետևում է, թե որ կոճակներն է օգտվողը սեղմում բուլյան bolTilePressed; // համոզվեք, որ նվագարկիչը պատահաբար չի սեղմում 5 անգամ կոճակը և չի պարտվում

// հերթափոխի համար փոփոխականներ սահմանել

int intTick; // հաշվում է միլիոններ (մեկ հանգույցի համար) մինչև intDelay int intDelay; // ծրագիրը, որը սպասում է մինչև հաջորդ շրջադարձը millis int intGameSpeed;

// վրիպազերծման ընտրանքների ընդհատում

բուլյան bolSerialBoard; // երբ ճշմարիտը տպելու է տախտակը սերիական մոնիտորի վրա

// կարգավորումը, որը գործարկվելու է մեկ անգամ

void setup () {Serial.begin (9600); // սկսել սերիական մոնիտորը // ստեղծել փոփոխականներ bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // սկսել lcd's lcdLeft.begin (16, 2); lcdRight.begin (16, 2); }

// օղակը, որը գործարկվելու է յուրաքանչյուր 10 միլիվայրկյանում

void loop () {մուտքագրում (); // ստուգեք մուտքի խաղը, եթե (bolPlay == true) {if (intTick> = intDelay) {// ստուգեք, արդյոք խաղը պետք է շրջադարձ կատարի, թե՞ շարունակի սպասել Serial.println ("~~~~~~~ print "); // տպել` նշելու համար, որ տախտակը շարժվում է // writeSerial (); // եթե տարբերակը միացված է, գրեք տախտակը սերիական կոճակների մեջ GameGame (); // ստուգել խաղացողի մուտքի համար playBoard (); // տեղափոխել տախտակը և ավելացնել նոր կղմինդր clearLcd (); // drawBoard նկարելուց առաջ մաքրեք LCD- ները (); // տախտակը գծեք lcd's bottomCheck (); intTick = 0; // վերականգնել intTick} else {buttonsGame (); // ստուգեք նվագարկչի մուտքերի համար clearLcd (); // drawBoard նկարելուց առաջ մաքրեք LCD- ները (); // տախտակը գծեք lcd- ի intTick = intTick + intGameSpeed; // ավելացնել տիզին}} else {clearLcd (); // վերնագիրը նկարելուց առաջ մաքրել LCD- ները (); // ցուցադրել վերնագրի և միավորի մասին infoMenu (); // կարդալ նվագարկիչի մուտքը clearBoard (); // ապահովել ամբողջ տախտակի = 0} ուշացում (10); // arduino- ն կարճ պահով հետաձգել}

// մաքրում է LCD- ը, այնպես որ ցանկացած չնշված բջիջ այնտեղ չի մնացել

անվավեր clearLcd () {for (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 1; ii ++) {lcdLeft.setCursor (i, ii); lcdLeft.write (""); lcdRight.setCursor (i, ii); lcdRight.write (""); }}}

// տախտակը քաշում է LCD- ների վրա

void drawBoard () {for (int i = 1; i <= 15; i ++) {// նկարել collums 1 և 2 ձախ LCD- ով // եթե սալիկը = 0 ոչինչ չգրել, = 1 գրել "#", = 2 գրել «@» lcdLeft.setCursor (i, 1); // սահմանել առաջին սյունակին (ամենահեռավոր ձախ կողմը), եթե (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.գրեք («@»);} lcdLeft.setCursor (i, 0); // սահմանել երկրորդ սյունակի վրա (ձախ ձախ) եթե (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.գրեք («@»);} lcdRight.setCursor (i, 1); // սահմանել երրորդ սյունակին (կենտրոնական աջ) եթե (arrGame [2] == 1) {lcdRight.write ("#");}} եթե (arrGame [2] == 2) {lcdRight.գրեք («@»);} lcdRight.setCursor (i, 0); // սահմանել չորրորդ սյունակին (ամենահեռու աջը), եթե (arrGame [3] == 1) {lcdRight.write ("#");} if (arrGame [3] == 2) {lcdRight.գրեք ("@");}}}

// տախտակը տեղափոխում է ներքև և պատահական արժեքը դնում սալիկ

void playBoard () {for (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // ջնջել վերին տողը arrGame [0] [պատահական (0, 4)] = 1; // վերին տողի պատահական կետը դարձրեք սալիկ (int i = 15; i> = 1; i-) {//, որը աշխատում է տախտակի ներքևից մինչև վեր (int ii = 0;) համար: ii <= 3; ii ++) {// յուրաքանչյուր բախման համար arrGame [ii] = arrGame [i - 1] [ii]; }}}

// ամբողջ տախտակը դնում է 0 -ի և փոփոխականները վերադառնում է նախախաղի

void clearBoard () {// վերականգնել տիզերի և հետաձգման արժեքները intTick = 0; intDelay = 1000; // անցնել տախտակի միջով և ամեն ինչ սահմանել 0 -ի համար (int i = 0; i <= 15; i ++) {համար (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

// ցուցադրում է հիմնական ընտրացանկը LCD- ների վրա

անվավեր վերնագիր () {// գրել վերնագիրը LCD- ի վրա և բաց թողնել միավորի համար lcdRight.setCursor (0, 0); lcdRight.write («Դաշնամուրի սալիկներ»); lcdRight.setCursor (0, 1); lcdRight.write ("Հաշիվը"); // հաշիվը վերածել լարային char strScore [3]; sprintf (strScore, "%d", intScore); // ցուցադրել հաշիվը LCD lcdRight.write- ի վրա (strScore); // ավելացնել diffictuly lcdRight.setCursor (10, 1); if (intDiff == 0) {lcdRight.write («Հեշտ»); } if (intDiff == 1) {lcdRight.write («Միջին»); } if (intDiff == 2) {lcdRight.write («Դժվար»); } // Սեղմեք մի փոքր հրահանգ lcdLeft.setCursor (0, 0); lcdLeft.write ("Սեղմեք Enter"); lcdLeft.setCursor (0, 1); lcdLeft.write («սկսել»); }

// ստուգում է կոճակները և ինչ անել նրանց համար խաղից դուրս վիճակում

void buttonsMenu () {// երբ enter սեղմված է, սկսեք խաղը և վերակայեք միավորի արժեքը, եթե (intEnter == 1) {bolPlay = true; intScore = 0; playBoard (); drawBoard (); } // 3 -րդ կոճակը սեղմելիս միացրեք տախտակի սերիական տպման կարգաբերման տարբերակը, եթե (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("Serial Board Active"); bolSerialBoard = ճշմարիտ; } else {Serial.println ("Սերիայի տախտակն անջատված է"); bolSerialBoard = կեղծ; }} // սահմանել խաղի արագությունը հեշտ դժվարության դեպքում, եթե (intInput == 0) {Serial.print ("Game set to easy ("); Serial.print (intGameSpeedEasy); Serial.println ("ms արագացում)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // սահմանել խաղի արագությունը միջին դժվարության դեպքում, եթե (intInput == 1) {Serial.print ("Game set to medium ("); Serial.print (intGameSpeedMedium); Serial.println ("ms արագացում)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // սահմանել խաղի արագությունը ծանր դժվարության դեպքում, եթե (intInput == 2) {Serial.print ("Game set to hard ("); Serial.print (intGameSpeedHard); Serial.println ("ms արագացում)"); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

// ստուգում է կոճակները և ինչ անել դրանց համար խաղի ընթացքում

void buttonsGame () {if (intInput! = 4) {// եթե կոճակը սեղմվում է if (bolTilePressed == false) {// միայն այն դեպքում, երբ bolTilePressed- ը կոճակի ստուգման կեղծ հրահրող գործողություն է, սեղմել bolTilePressed = true; // այնուհետև bolTilePressed- ը դրեք true- ի վրա ՝ համոզվելու համար, որ այն կրկին պատահաբար չի գործարկվում int intLowestTile = 0; // ամենացածր կղմինդրով սալիկին տեղադրելու համար int intCheckedTile = 15; // հետևելու համար, թե որ սալիկներն են ստուգվել (intLowestTile == 0) {// քանի դեռ այն որևէ բանի վրա դրված չէ, ստուգեք սալիկները (int i = 0; i 100) {// այնքան ժամանակ, որքան int ուշացումը 100 -ից ցածր չէ intDelay = intDelay - 20; // արժեք վերցրեք դրանից}} else {Serial.println ("Սխալ սեղմված է կոճակը"); խաղն ավարտված է(); // հակառակ դեպքում խաղը}}}}}

void gameOver () {

Serial.println («Խաղն ավարտված է»); Serial.print («Ձեր հաշիվն էր ՝»); Serial.println (intScore); Serial.print («Ձեր արագությունը եղել է ՝»); Serial.println (intDelay); bolPlay = կեղծ; }

// ստուգում է խաղացողի մուտքը

անվավեր մուտքագրում () {intEnter = digitalRead (btnEnter); // կարդալ մուտքագրել // կարդալ մյուս մուտքերից որևէ մեկը, կամ եթե ոչ մեկը չի սահմանել 4 եթե (digitalRead (btn1) == HIGH) {intInput = 0;} else {if (digitalRead (btn2) == HIGH) {intInput = 1;} այլ {if (digitalRead (btn3) == HIGH) {intInput = 2;} else {if (digitalRead (btn4) == HIGH) {intInput = 3;} else {intInput = 4; }}}} // սերիական տպել մուտքերը if (intEnter == 1) {Serial.println ("Մուտք սեղմված է!");} if (intInput! = 4) {Serial.print ("Button Press:"); Serial.println (intInput); } else {// եթե ոչ մի կոճակ սեղմված չէ reset bolTilePressed bolTilePressed = false; }}

// ստուգում է տախտակի ներքևի մասը ձախողման համար

void bottomCheck () {for (int i = 0; i <= 3; i ++) {// եթե 4 սյունակները (arrGame [15] == 1) {// եթե սալիկը գտնվում է ներքևում Սերիա.println («Սալիկ ներքեւում»); arrGame [15] = 2; drawBoard (); ուշացում (400); arrGame [15] = 1; drawBoard (); ուշացում (400); arrGame [15] = 2; drawBoard (); ուշացում (400); arrGame [15] = 1; drawBoard (); ուշացում (400); խաղն ավարտված է(); }}}

// տպում է տախտակը սերիական մոնիտորի մեջ, եթե bolSerialBoard- ը ճիշտ է

void writeSerial () {if (bolSerialBoard == true) {for (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 3; ii ++) {Serial.print (arrGame [ii]); Serial.print (","); } Serial.println (""); }}}

Երբ ամբողջ ծածկագիրը մուտքագրվի, վերբեռնեք ձեր arduino- ում և վայելեք: