Arduino- ի կողմից վերահսկվող պլատֆորմի խաղ Joystick- ով և IR ընդունիչով. 3 քայլ (նկարներով)

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

Այսօր մենք կօգտագործենք Arduino միկրոկառավարիչ ՝ C#հիմքով հարթակավոր խաղը կառավարելու համար: Ես օգտագործում եմ Arduino- ն `ջոյսթիկի մոդուլից մուտքագրելու համար և այդ մուտքն ուղարկելու C# հավելվածին, որը լսում և ապակոդավորում է մուտքագրումը սերիական կապի միջոցով: Չնայած նախագիծն ավարտելու համար տեսախաղեր կառուցելու որևէ նախկին փորձի կարիք չկա, այն կարող է որոշ ժամանակ պահանջել «խաղային օղակում» կատարվող որոշ բաների կլանման համար, որը մենք կքննարկենք ավելի ուշ:

Այս նախագիծը ավարտելու համար ձեզ հարկավոր է.

• Visual Studio համայնք
• Arduino Uno (կամ նմանատիպ)
• Joyոյստիկ վերահսկիչի մոդուլ
• Համբերություն

Եթե պատրաստ եք սկսել, շարունակեք:

Քայլ 1. Միացրեք ջոյսթիկը և IR LED- ը

Այստեղ կապը բավականին պարզ է: Ես ներառել եմ դիագրամներ, որոնք ցույց են տալիս միայն կցված ջոյսթիկը, ինչպես նաև այն կարգավորումը, որը ես օգտագործում եմ, որը ներառում է ջոյսթիկը և ինֆրակարմիր LED ՝ հեռակառավարմամբ խաղը կառավարելու համար, որն ունի բազմաթիվ Arduino հավաքածուներ: Սա ընտրովի չէ, բայց թվում էր, թե թույն գաղափար է, որ կարողանամ զբաղվել անլար խաղերով:

Կարգավորման մեջ օգտագործվող կապումներն են.

• A0 (անալոգային) <- Հորիզոնական կամ X առանցք
• A1 (անալոգային) <- Ուղղահայաց կամ Y առանցք
• Պին 2 <- Joystick Switch մուտքագրում
• Pin 2 <- ինֆրակարմիր LED մուտք
• ԵԿԿ <- 5V
• Գետնին
• Հող #2

Քայլ 2: Ստեղծեք նոր ուրվագիծ

Մենք կսկսենք ստեղծել մեր Arduino ուրվագծային ֆայլը: Սա ընտրում է փոփոխությունների ջոյսթիկը և այդ փոփոխություններն ուղարկում է C# ծրագրին մի քանի միլիվայրկյան մեկ: Իրական տեսախաղում մենք ստուգում էինք խաղային հանգույցի սերիական նավահանգիստը մուտքի համար, բայց ես խաղը սկսեցի որպես փորձ, ուստի շրջանակի արագությունը իրականում հիմնված է սերիական նավահանգստի իրադարձությունների քանակի վրա: Ես իրականում նախագիծը սկսել էի Arduino քույր նախագծում ՝ Processing, բայց պարզվում է, որ այն շատ, շատ ավելի դանդաղ էր և չկարողացավ կարգավորել էկրանի տուփերի քանակը:

Այսպիսով, նախ ստեղծեք նոր ուրվագիծ Arduino կոդի խմբագրման ծրագրում: Ես ցույց կտամ իմ ծածկագիրը, այնուհետև կբացատրեմ, թե ինչ է դա անում.

#ներառել «IRremote.h»

// IR փոփոխականներ int ընդունիչ = 3; // IR ստացողի ազդանշանային քորոց IRrecv irrecv (ընդունիչ); // ստեղծել «irrecv» decode_results արդյունքների օրինակ; // ստեղծել «decode_results» // օրինակ ՝ Joystick/game variables int xPos = 507; int yPos = 507; բայթ joyXPin = A0; բայթ joyYPin = A1; բայթ joySwitch = 2; անկայուն բայթ clickCounter = -1; int minMoveHigh = 530; int minMoveLow = 490; int ընթացիկ արագություն = 550; // Լռելյայն = միջին արագություն int speedIncrement = 25; // Գումարը արագության բարձրացման/նվազման համար Y մուտքագրմամբ անստորագիր երկար հոսանք = 0; // Պահում է ընթացիկ ժամկետային նշանը int wait = 40; // ms սպասել հաղորդագրությունների միջև [Նշում. ցածր սպասում = ավելի արագ շրջանակ] անկայուն bool buttonPressed = false; // Չափիչ, եթե կոճակը սեղմված է void setup () {Serial.begin (9600); pinMode (joySwitch, INPUT_PULLUP); attachInterrupt (0, jump, FALLING); ընթացիկ = millis (); // Կարգավորեք ընթացիկ ժամը // Կարգավորեք ինֆրակարմիր ընդունիչ ՝ irrecv.enableIRIn (); // Գործարկել ստացողը} // setup void loop () {int xMovement = analogRead (joyXPin); int yPos = analogRead (joyYPin); // Կարգավորեք Joystick X շարժումը ՝ անկախ ժամանակից. currentSpeed //… պարզապես վերադարձեք ընթացիկ արագությունը. getSpeed (yPos); // Փոփոխել yPos- ը միայն այն դեպքում, եթե joystick- ը զգալիորեն տեղափոխվել է // int distance =; Serial.print ((String) xPos + "," + (String) yPos + ',' + (String) currentSpeed + '\ n'); ընթացիկ = millis (); }} // loop int getSpeed (int yPos) {// Բացասական արժեքները ցույց են տալիս, որ Joystick- ը վեր է շարժվել, եթե (yPos 1023? 1023: currentSpeed + speedIncrement;} else if (yPos> minMoveHigh) // Մեկնաբանված է «Down» {// Պաշտպանվել անցնում է 0 -ի տակ հեռավոր, կարգավորել համապատասխան պատասխանը void translateIR (decode_results results) // քայլեր է ձեռնարկում ՝ հիմնված ստացված IR կոդի հիման վրա {switch (results.value) {case 0xFF18E7: //Serial.println("2 "); currentSpeed += speedIncrement * 2; ընդմիջում; գործ 0xFF10EF: //Serial.println("4 "); xPos = -900; ընդմիջում; գործ 0xFF38C7: //Serial.println("5"); ցատկել (); ընդմիջում; գործ 0xFF5AA5: // Սերիա: println ("6"); xPos = 900; ընդմիջում; գործ 0xFF4AB5: //Serial.println("8 "); currentSpeed -= speedIncrement * 2; ընդմիջում; կանխադրված` //Serial.println ("այլ կոճակ"); ընդմիջում;} // Ավարտի անջատիչ} // END translateIR

Ես փորձեցի ստեղծել ծածկագիրը, որը հիմնականում ինքն իրեն բացատրում է, բայց կան մի քանի բաներ, որոնք արժե նշել: Մի բան, որի մասին ես փորձում էի հաշվետու լինել, հետևյալ տողերում էր.

int minYMoveUp = 520;

int minYMoveDown = 500;

Երբ ծրագիրն աշխատում է, ջոյսթիկից անալոգային մուտքագրումը հակված է ցատկել, սովորաբար մնում է մոտ 507 -ի սահմաններում: Դրա համար մուտքը չի փոխվում, եթե այն minYMoveUp- ից ավելի մեծ չէ, կամ minYMoveDown- ից փոքր է:

pinMode (joySwitch, INPUT_PULLUP);

attachInterrupt (0, jump, FALLING);

AttachInterrupt () մեթոդը մեզ թույլ է տալիս ցանկացած ժամանակ ընդհատել նորմալ օղակը, որպեսզի մենք կարողանանք մուտքագրել, ինչպես կոճակը սեղմելիս, երբ սեղմվում է ջոյստիկի կոճակը: Այստեղ մենք ամրացրել ենք ընդհատումը դրանից առաջ տողում ՝ օգտագործելով pinMode () մեթոդը: Այստեղ կարևոր նշում է այն, որ Arduino Uno- ում ընդհատում կցելու համար պետք է օգտագործել կամ 2 -րդ կամ 3 -րդ կապերը: Այլ մոդելները օգտագործում են տարբեր ընդհատման կապակցումներ, ուստի գուցե ստիպված լինեք ստուգել, թե որ կապում է ձեր մոդելը Arduino- ի կայքում: Երկրորդ պարամետրը հետադարձ կապի մեթոդի համար է, որն այստեղ կոչվում է ISR կամ «Ընդհատման ծառայության ռեժիմ»: Այն չպետք է վերցնի որևէ պարամետր կամ վերադարձնի որևէ բան:

Serial.print (…)

Սա այն գիծն է, որը մեր տվյալները կուղարկի C# խաղին: Այստեղ մենք խաղին ուղարկում ենք X առանցքի ընթերցում, Y առանցքի ընթերցում և արագության փոփոխական: Այս ընթերցումները կարող են ընդլայնվել `ներառելով այլ մուտքեր և ընթերցումներ` խաղը ավելի հետաքրքիր դարձնելու համար, բայց այստեղ մենք կօգտագործենք միայն զույգ:

Եթե պատրաստ եք ստուգել ձեր ծածկագիրը, վերբեռնեք այն Arduino- ում և սեղմեք [Shift] + [Ctrl] + [M] ՝ սերիական մոնիտորը բացելու և տեսնելու համար, թե արդյո՞ք ելք եք ստանում: Եթե դուք ստանում եք տվյալներ Arduino- ից, մենք պատրաստ ենք շարժվել կոդի C# մասով…

Քայլ 3. Ստեղծեք C# նախագիծ

Մեր գրաֆիկան ցուցադրելու համար ես սկզբում նախագիծ սկսեցի Processing- ում, բայց հետագայում որոշեցի, որ չափազանց դանդաղ կլինի ցուցադրել բոլոր այն օբյեկտները, որոնք մենք պետք է ցուցադրենք: Այսպիսով, ես ընտրեցի օգտագործել C#, որը պարզվեց, որ շատ ավելի հարթ և արձագանքող էր մեր մուտքի հետ աշխատելիս:

#Րագրի C# մասի համար լավագույնն է պարզապես ներբեռնել.zip ֆայլը և այն հանել իր սեփական թղթապանակում, այնուհետև փոփոխել այն: ZIP ֆայլում կա երկու թղթապանակ: Visual Studio- ում նախագիծը բացելու համար մուտքագրեք RunnerGame_CSharp թղթապանակը Windows Explorer- ում: Այստեղ կրկնակի կտտացրեք.sln (լուծում) ֆայլը, և VS- ը կբեռնի նախագիծը:

Կան մի քանի տարբեր դասարաններ, որոնք ես ստեղծել եմ խաղի համար: Չեմ մանրամասնի յուրաքանչյուր դասի վերաբերյալ, բայց ես ակնարկ կտամ, թե ինչի համար են հիմնական դասերը:

Տուփի դասարան

Ես ստեղծեցի տուփի դասարան, որը թույլ է տալիս ստեղծել պարզ ուղղանկյուն օբյեկտներ, որոնք կարելի է նկարել էկրանին պատուհանների տեսքով: Գաղափարն այն է, որ ստեղծվի դաս, որը կարող է ընդլայնվել ՝ օգտագործելով այլ դասեր, որոնք գուցե ցանկանան ինչ -որ գրաֆիկա նկարել: «Վիրտուալ» հիմնաբառը օգտագործվում է այնպես, որ այլ դասարաններ կարող են դրանք չեղյալ համարել (օգտագործելով «անտեսել» հիմնաբառը): Այդ կերպ, մենք կարող ենք նույն վարքագիծը ձեռք բերել Player դասի և Հարթակի դասի համար, երբ դա անհրաժեշտ է, ինչպես նաև փոփոխել օբյեկտները, ինչպես որ անհրաժեշտ է:

Շատ մի անհանգստացեք բոլոր հատկությունների մասին և զանգեր կատարեք: Ես գրել եմ այս դասը, որպեսզի կարողանամ այն երկարաձգել ցանկացած խաղի կամ գրաֆիկական ծրագրի համար, որը գուցե ցանկանամ պատրաստել ապագայում: Եթե ձեզ հարկավոր է ուղղակի ուղղանկյուն նկարել թռիչքի ժամանակ, ապա պետք չէ այսպիսի մեծ դասարան գրել: C# փաստաթղթերում կան լավ օրինակներ, թե ինչպես դա անել:

Այնուամենայնիվ, ես կներկայացնեմ իմ «Տուփ» դասի որոշ տրամաբանություն.

հանրային վիրտուալ բուլ IsCollidedX (Box otherObject) {…}

Այստեղ մենք ստուգում ենք X- ուղղությամբ օբյեկտների հետ բախումների առկայությունը, քանի որ խաղացողը պետք է միայն Y ուղղությամբ (վերև և ներքև) բախումների առկայությունը ստուգի, եթե դրանով շարված է էկրանին:

հանրային վիրտուալ տխրություն IsCollidedY (Box otherObject) {…}

Երբ մենք գտնվում ենք մեկ այլ խաղային օբյեկտի վրա կամ դրա տակ, մենք ստուգում ենք Y- ի բախումները:

հանրային վիրտուալ տխրություն IsCollided (Box otherObject) {…}

Սա համատեղում է X և Y բախումները ՝ վերադառնալով, արդյոք որևէ առարկա բախվել է այս մեկին:

հանրային վիրտուալ դատարկություն OnPaint (գրաֆիկական գրաֆիկա) {…}

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

Բնավորության դաս

Նիշերի դասը ընդլայնում է իմ Box դասը, այնպես որ մենք ունենք որոշակի ֆիզիկա: Ես ստեղծեցի «CheckForCollisions» մեթոդը ՝ արագորեն ստուգելու բախման համար մեր ստեղծած բոլոր հարթակները: «Անցնել» մեթոդը խաղացողի վերընթաց արագությունը դնում է JumpSpeed փոփոխականի վրա, որն այնուհետև շրջանակ առ շրջանակ փոփոխվում է MainWindow դասում:

Բախումներն այստեղ մի փոքր այլ կերպ են վարվում, քան Box դասում: Այս խաղում ես որոշեցի, որ եթե վեր ցատկենք, մենք կարող ենք ցատկել հարթակով, բայց այն բախվելու դեպքում մեր խաղացողին կբռնի ներքև ընկած ճանապարհին:

Հարթակի դաս

Այս խաղում ես օգտագործում եմ միայն այս դասի կոնստրուկտորը, որը որպես մուտքագրում վերցնում է X- կոորդինատ ՝ հաշվարկելով MainWindow դասի բոլոր հարթակների X տեղերը: Յուրաքանչյուր հարթակ ստեղծվում է պատահական Y- կոորդինատից `էկրանի 1/2-ից մինչև էկրանի բարձրության 3/4: Բարձրությունը, լայնությունը և գույնը նույնպես ստեղծվում են պատահականորեն:

MainWindow դասը

Սա այն է, որտեղ մենք դնում ենք ամբողջ տրամաբանությունը, որը պետք է օգտագործվի խաղի ընթացքում: Նախ, կոնստրուկտորում մենք տպում ենք ծրագրին հասանելի բոլոր COM նավահանգիստները:

foreach (լարային նավահանգիստ SerialPort. GetPortNames- ում)

Console. WriteLine («Մատչելի նավահանգիստներ.» + Նավահանգիստ);

Մենք ընտրում ենք, թե որ տարբերակի վրա ենք ընդունում հաղորդակցությունները, ըստ որի ձեր Arduino- ն արդեն որ նավահանգիստն է օգտագործում.

SerialPort = նոր SerialPort (SerialPort. GetPortNames () [2], 9600, Parity. None, 8, StopBits. One);

Ուշադիր ուշադրություն դարձրեք հրամանին ՝ SerialPort. GetPortNames () [2]: [2] նշանակում է, թե որ սերիալային պորտն օգտագործել: Օրինակ, եթե ծրագիրը տպագրեր «COM1, COM2, COM3», մենք կլսեինք COM3- ին, քանի որ համարակալումը զանգվածում սկսվում է 0 -ից:

Նաև կոնստրուկտորում մենք ստեղծում ենք բոլոր հարթակները `կիս պատահական տարածությամբ և էկրանին Y ուղղությամբ տեղադրված: Բոլոր հարթակները ավելացված են objectանկի օբյեկտին, որը C #- ում պարզապես օգտագործողի համար հարմար և արդյունավետ միջոց է զանգվածների նման տվյալների կառուցվածքը կառավարելու համար: Այնուհետեւ մենք ստեղծում ենք Player- ը, որը մեր Նիշերի օբյեկտն է, հաշիվը սահմանում ենք 0, իսկ GameOver- ը ՝ false:

մասնավոր ստատիկ դատարկ DataReceived (օբյեկտ ուղարկող, SerialDataReceivedEventArgs ե)

Սա այն մեթոդն է, որը կոչվում է, երբ տվյալները ստացվում են Սերիական նավահանգստում: Այստեղ մենք կիրառում ենք մեր ամբողջ ֆիզիկան, որոշում ՝ ցուցադրել խաղը, տեղափոխել հարթակները և այլն: թարմացնում է Այս խաղում DataReceived մեթոդը հանդես է գալիս որպես խաղային օղակ ՝ շահարկելով միայն ֆիզիկան, քանի որ տվյալները ստացվում են վերահսկիչից: Կարող էր ավելի լավ աշխատել հիմնական պատուհանում erամաչափ տեղադրել և օբյեկտները թարմացնել ստացված տվյալների հիման վրա, բայց քանի որ սա Arduino- ի նախագիծ է, ես ուզում էի խաղ պատրաստել, որը իրականում գործելու էր դրանից բխող տվյալների հիման վրա:.

Եզրափակելով, այս կարգավորումը լավ հիմք է տալիս խաղը օգտագործելիի վերածելու համար: Չնայած ֆիզիկան այնքան էլ կատարյալ չէ, այն բավական լավ է աշխատում մեր նպատակների համար, այն է ՝ օգտագործել Arduino- ն այն ամենի համար, ինչ բոլորին դուր է գալիս. Խաղեր խաղալ: