Arduino- კონტროლირებადი პლატფორმერი თამაში ჯოისტიკით და IR მიმღებით: 3 ნაბიჯი (სურათებით)

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:20

დღეს, ჩვენ ვაპირებთ გამოვიყენოთ Arduino მიკროკონტროლი, რომ გავაკონტროლოთ მარტივი C#დაფუძნებული პლატფორმერული თამაში. მე ვიყენებ Arduino– ს ჯოისტიკის მოდულიდან შესასვლელად და ამ შეყვანის გასაგზავნად C# პროგრამაში, რომელიც უსმენს და გაშიფრავს შეყვანას სერიული კავშირის საშუალებით. მიუხედავად იმისა, რომ თქვენ არ გჭირდებათ რაიმე გამოცდილება ვიდეო თამაშების მშენებლობაში პროექტის დასასრულებლად, შეიძლება გარკვეული დრო დასჭირდეს იმისთვის, რომ შეითვისოს ზოგიერთი რამ, რაც ხდება "თამაშის მარყუჟში", რომელსაც მოგვიანებით განვიხილავთ.

ამ პროექტის დასასრულებლად დაგჭირდებათ:

• ვიზუალური სტუდიის საზოგადოება
• Arduino Uno (ან მსგავსი)
• ჯოისტიკი კონტროლერის მოდული
• მოთმინება

თუ მზად ხართ დასაწყებად, განაგრძეთ!

ნაბიჯი 1: შეაერთეთ ჯოისტიკი და IR LED

აქ, დაკავშირება საკმაოდ მარტივია. მე ჩავრთე დიაგრამები, სადაც ნაჩვენებია მხოლოდ ჯოისტიკი, რომელიც არის ჩართული, ისევე როგორც მე ვიყენებ, რომელიც მოიცავს ჯოისტიკს პლუს ინფრაწითელი LED დისტანციური მართვის თამაშის გასაკონტროლებლად, რომელსაც გააჩნია მრავალი Arduino ნაკრები. ეს არჩევითია, მაგრამ როგორც ჩანს, მაგარი იდეაა, რომ შეძლოთ უკაბელო თამაშების გაკეთება.

კონფიგურაციაში გამოყენებული ქინძისთავებია:

• A0 (ანალოგი) <- ჰორიზონტალური ან X ღერძი
• A1 (ანალოგი) <- ვერტიკალური ან Y ღერძი
• ჩამაგრება 2 <- ჯოისტიკი გადამრთველის შეყვანა
• პინი 2 <- ინფრაწითელი LED შეყვანა
• VCC <- 5V
• გრუნტი
• მიწა #2

ნაბიჯი 2: შექმენით ახალი ესკიზი

ჩვენ დავიწყებთ ჩვენი Arduino ესკიზის ფაილის შექმნას. ეს ასახავს ცვლილებების ჯოისტიკას და აგზავნის ამ ცვლილებებს C# პროგრამაში ყოველ რამდენიმე მილიწამში. რეალურ ვიდეო თამაშში, ჩვენ შევამოწმებდით სერიულ პორტს თამაშის მარყუჟში შესასვლელად, მაგრამ მე დავიწყე თამაში ექსპერიმენტის სახით, ამიტომ ჩარჩოს სიჩქარე ფაქტობრივად ემყარება სერიულ პორტში მოვლენების რაოდენობას. მე რეალურად დავიწყე პროექტი არდუინოს დის პროექტში, დამუშავება, მაგრამ აღმოჩნდა, რომ ის იყო ბევრად უფრო ნელი და ვერ უმკლავდებოდა ეკრანზე არსებული ყუთების რაოდენობას.

ასე რომ, ჯერ შექმენით ახალი ესკიზი Arduino კოდის რედაქტორის პროგრამაში. მე ვაჩვენებ ჩემს კოდს და შემდეგ ავხსნი რას აკეთებს:

#მოიცავს "IRremote.h"

// IR ცვლადები int მიმღები = 3; // IR მიმღების სიგნალის პინი IRrecv irrecv (მიმღები); // შექმენით 'irrecv' decode_results results; // შექმენით 'decode_results' // ჯოისტიკი/თამაშის ცვლადები int xPos = 507; int yPos = 507; ბაიტი joyXPin = A0; ბაიტი joyYPin = A1; ბაიტი joySwitch = 2; არასტაბილური ბაიტი clickCounter = -1; int minMoveHigh = 530; int minMoveLow = 490; int currentSpeed = 550; // ნაგულისხმევი = საშუალო სიჩქარე int speedIncrement = 25; // თანხის გაზრდის/შემცირების სიჩქარე Y შეყვანის გარეშე ხელმოუწერელი გრძელი დენი = 0; // ინახავს მიმდინარე დროის ნიშნულს int ლოდინი = 40; // ms ელოდება შეტყობინებებს შორის [შენიშვნა: ქვედა ლოდინი = ჩარჩოს უფრო სწრაფი სიჩქარე] არასტაბილური bool buttonPressed = false; // გაზომეთ თუ ღილაკზე დაჭერილია void setup () {Serial.begin (9600); pinMode (joySwitch, INPUT_PULLUP); attachIntruptrupt (0, jump, FALLING); მიმდინარე = მილი (); // დააყენეთ მიმდინარე დრო // დააყენეთ ინფრაწითელი მიმღები: irrecv.enableIRIn (); // დაწყება მიმღები} // setup void loop () {int xMovement = analogRead (joyXPin); int yPos = analogRead (joyYPin); // დაამუშავეთ ჯოისტიკ X მოძრაობა დროის მიუხედავად: თუ (xMovement> minMoveHigh || xMovement current + wait) {currentSpeed = yPos> minMoveLow && yPos <minMoveHigh // თუ ცოტათი მაინც გადაადგილდით…? currentSpeed //… უბრალოდ დააბრუნე მიმდინარე სიჩქარე: getSpeed (yPos); // შეცვალეთ yPos მხოლოდ იმ შემთხვევაში, თუ ჯოისტიკი მნიშვნელოვნად გადაადგილდა // int მანძილი =; Serial.print ((სიმებიანი) xPos + "," + (სიმებიანი) yPos + ',' + (სიმებიანი) currentSpeed + '\ n'); მიმდინარე = მილი (); }} // loop int getSpeed (int yPos) {// უარყოფითი მნიშვნელობები მიუთითებს, რომ ჯოისტიკი გადავიდა თუ (yPos 1023? 1023: currentSpeed + speedIncrement;} else if (yPos> minMoveHigh) // ინტერპრეტირებული "ქვემოთ" {// დაიცავით 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"); jump (); შესვენება; საქმე 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);

attachIntruptrupt (0, jump, FALLING);

AttachInterrupt () მეთოდი საშუალებას გვაძლევს შევაჩეროთ ნორმალური მარყუჟი ნებისმიერ დროს, ისე რომ მივიღოთ შეყვანა, ისევე როგორც ღილაკის დაჭერა ჯოისტიკის ღილაკზე დაჭერისას. აქ ჩვენ დავამატეთ შეწყვეტა მის წინ არსებულ ხაზში, pinMode () მეთოდის გამოყენებით. აქ მნიშვნელოვანი შენიშვნა ის არის, რომ Arduino Uno– ზე შეწყვეტის დასაყენებლად თქვენ უნდა გამოიყენოთ პინი 2 ან 3. სხვა მოდელები იყენებენ სხვადასხვა შეწყვეტის ქინძისთავებს, ასე რომ თქვენ შეიძლება მოგიწიოთ იმის შემოწმება, თუ რომელ პინებს იყენებს თქვენი მოდელი Arduino ვებსაიტზე. მეორე პარამეტრი არის გამოძახების მეთოდისთვის, რომელსაც აქ ეწოდება ISR ან "სერვისის შეწყვეტის რუტინა". მან არ უნდა მიიღოს რაიმე პარამეტრი ან დააბრუნოს არაფერი.

სერიული. ბეჭდვა (…)

ეს არის ხაზი, რომელიც გამოაგზავნის ჩვენს მონაცემებს C# თამაშზე. აქ ჩვენ თამაშს ვუგზავნით X ღერძის კითხვას, Y ღერძის კითხვას და სიჩქარის ცვლადს. ეს კითხვები შეიძლება გაფართოვდეს, რათა შეიცავდეს სხვა საშუალებებს და კითხვებს, რათა თამაში უფრო საინტერესო გახდეს, მაგრამ აქ ჩვენ მხოლოდ წყვილს გამოვიყენებთ.

თუ მზად ხართ თქვენი კოდის შესამოწმებლად, ატვირთეთ იგი Arduino– ზე და დააჭირეთ [Shift] + [Ctrl] + [M] სერიული მონიტორის გასახსნელად და ნახავთ თუ არა რაიმე გამომუშავებას. თუ თქვენ იღებთ მონაცემებს Arduino– დან, ჩვენ მზად ვართ გადავიდეთ კოდის C# ნაწილზე…

ნაბიჯი 3: შექმენით C# პროექტი

ჩვენი გრაფიკის საჩვენებლად, მე დავიწყე პროექტი დამუშავების პროცესში, მაგრამ მოგვიანებით გადავწყვიტე, რომ ძალიან ნელი იქნებოდა ყველა იმ ობიექტის ჩვენება, რაც ჩვენ გვჭირდება. ამრიგად, მე შევარჩიე გამოვიყენო C#, რომელიც აღმოჩნდა ბევრად უფრო რბილი და უფრო მგრძნობიარე ჩვენი შეყვანის დამუშავებისას.

პროექტის C# ნაწილისთვის უმჯობესია უბრალოდ ჩამოტვირთოთ.zip ფაილი და ამოიღოთ იგი საკუთარ საქაღალდეში, შემდეგ შეცვალოთ იგი. Zip ფაილში არის ორი საქაღალდე. Visual Studio– ში პროექტის გასახსნელად, შეიყვანეთ RunnerGame_CSharp საქაღალდე Windows Explorer– ში. აქ, ორჯერ დააწკაპუნეთ.sln (გადაწყვეტა) ფაილზე და VS ატვირთავს პროექტს.

არსებობს რამდენიმე განსხვავებული კლასი, რომელიც მე შევქმენი თამაშისთვის. მე არ შევალ ყველა დეტალზე თითოეული კლასის შესახებ, მაგრამ მე მიმოვიხილავ რა არის ძირითადი კლასები.

ყუთის კლასი

მე შევქმენი ყუთის კლასი, რომელიც საშუალებას მოგცემთ შექმნათ მარტივი მართკუთხედის ობიექტები, რომელთა დახატვა შესაძლებელია ეკრანზე ფანჯრების სახით. იდეა არის კლასის შექმნა, რომელიც შეიძლება გაფართოვდეს სხვა კლასების გამოყენებით, რომლებსაც შეიძლება სურთ რაიმე სახის გრაფიკის დახატვა. "ვირტუალური" საკვანძო სიტყვა გამოიყენება ისე, რომ სხვა კლასებმა შეძლონ მათი გადაფარვა (საკვანძო სიტყვის "გადაფარვის" გამოყენებით). ამრიგად, ჩვენ შეგვიძლია მივიღოთ იგივე ქცევა მოთამაშეთა კლასისთვის და პლატფორმის კლასისთვის, როდესაც გვჭირდება და ასევე შევცვალოთ ობიექტები, როგორც გვჭირდება.

ძალიან ნუ ინერვიულებთ ყველა თვისებაზე და დარეკეთ ზარებზე. მე დავწერე ეს კლასი ისე, რომ გამეგრძელებინა იგი ნებისმიერი თამაშისთვის ან გრაფიკული პროგრამისთვის, რისი გაკეთებაც მსურს მომავალში. თუ თქვენ გჭირდებათ უბრალოდ მართკუთხედის დახატვა ფრენის დროს, თქვენ არ გჭირდებათ ასეთი დიდი კლასის გამოწერა. C# დოკუმენტაციას აქვს კარგი მაგალითები, თუ როგორ უნდა გავაკეთოთ ეს.

თუმცა, მე გამოვყოფ ჩემი "ყუთის" კლასის ლოგიკას:

საჯარო ვირტუალური ბოული IsCollidedX (Box otherObject) {…}

აქ ჩვენ ვამოწმებთ ობიექტების შეჯახებას X- მიმართულებით, რადგან მოთამაშეს მხოლოდ Y მიმართულებით (ზევით და ქვევით) შეჯახების შემოწმება სჭირდება, თუ ის ეკრანზეა გაფორმებული.

საჯარო ვირტუალური ბოული IsCollidedY (Box otherObject) {…}

როდესაც ჩვენ ვართ თამაშის ობიექტის თავზე ან მის ქვეშ, ჩვენ ვამოწმებთ Y შეჯახებებს.

საჯარო ვირტუალური ბოული IsCollided (Box otherObject) {…}

ეს აერთიანებს X და Y შეჯახებებს, აბრუნებს თუ არა რაიმე ობიექტი შეჯახებულს მას.

საჯარო ვირტუალური სიცარიელე OnPaint (გრაფიკული გრაფიკა) {…}

ზემოაღნიშნული მეთოდის გამოყენებით, ჩვენ ჩავაბარებთ ნებისმიერ გრაფიკულ ობიექტს და ვიყენებთ მას პროგრამის გაშვებისას. ჩვენ ვქმნით ნებისმიერ მართკუთხედს, რომლის დახაზვაც შეიძლება დაგჭირდეთ. ეს შეიძლება გამოყენებულ იქნას სხვადასხვა ანიმაციისთვის. ჩვენი მიზნებისათვის, მართკუთხედები კარგად იქცევიან როგორც პლატფორმებისთვის, ასევე მოთამაშისთვის.

პერსონაჟების კლასი

პერსონაჟების კლასი აფართოებს ჩემს ყუთის კლასს, ამიტომ ჩვენ გვაქვს გარკვეული ფიზიკა ყუთის გარეთ. მე შევქმენი "CheckForCollisions" მეთოდი, რათა სწრაფად შევამოწმო ყველა პლატფორმა, რომელიც ჩვენ შევქმენით შეჯახებისთვის. "Jump" მეთოდი ადგენს მოთამაშის აღმავალ სიჩქარეს JumpSpeed ცვლადზე, რომელიც შემდეგ შეიცვლება ჩარჩო-ჩარჩო MainWindow კლასში.

შეჯახება ხდება ოდნავ განსხვავებულად აქ, ვიდრე Box კლასში. მე ამ თამაშში გადავწყვიტე, რომ თუ ზემოთ ვხტებით, ჩვენ შეგვიძლია გადახვიდეთ პლატფორმაზე, მაგრამ ის დაეჯახება ჩვენს მოთამაშეს ქვევით გზაზე, თუ მას შეეჯახებით.

პლატფორმის კლასი

ამ თამაშში მე ვიყენებ მხოლოდ ამ კლასის კონსტრუქტორს, რომელიც იღებს X კოორდინატს, როგორც შეყვანისას, ვიანგარიშებ ყველა პლატფორმის X ადგილს MainWindow კლასში. თითოეული პლატფორმა იქმნება შემთხვევითი Y- კოორდინატით ეკრანის 1/2-დან ეკრანის სიმაღლის 3/4-მდე. სიმაღლე, სიგანე და ფერი ასევე შემთხვევით წარმოიქმნება.

MainWindow კლასი

ეს არის ის, სადაც ჩვენ ვაყენებთ ყველა ლოგიკას, რომელიც გამოიყენება თამაშის დროს. პირველ რიგში, კონსტრუქტორში, ჩვენ ვბეჭდავთ პროგრამისთვის ხელმისაწვდომი ყველა COM პორტს.

foreach (სიმებიანი პორტი SerialPort. GetPortNames- ში)

Console. WriteLine ("AVAILABLE PORTS:" + პორტი);

ჩვენ ვირჩევთ რომელზე ვიღებთ კომუნიკაციებს, რომლის პორტის მიხედვით იყენებს თქვენი Arduino უკვე:

SerialPort = ახალი SerialPort (SerialPort. GetPortNames () [2], 9600, პარიტეტი. არცერთი, 8, StopBits. One);

დიდი ყურადღება მიაქციეთ ბრძანებას: SerialPort. GetPortNames () [2]. [2] ნიშნავს რომელი სერიული პორტის გამოყენება. მაგალითად, თუ პროგრამა დაბეჭდავს "COM1, COM2, COM3", ჩვენ მოვუსმენთ COM3- ს, რადგან ნუმერაცია იწყება მასივის 0 -დან.

ასევე კონსტრუქტორში, ჩვენ ვქმნით ყველა პლატფორმას ნახევრად შემთხვევითი ინტერვალით და ეკრანზე Y მიმართულებით განთავსებით. ყველა პლატფორმა ემატება List ობიექტს, რომელიც C#-ში არის ძალიან მოსახერხებელი და ეფექტური საშუალება მასივის მსგავსი მონაცემების სტრუქტურის მართვისთვის. შემდეგ ჩვენ ვქმნით მოთამაშეს, რომელიც არის ჩვენი პერსონაჟის ობიექტი, ვაყენებთ ანგარიშს 0 -ზე და ვაყენებთ GameOver- ს ყალბს.

პირადი სტატიკური სიცარიელე DataReceived (ობიექტის გამგზავნი, SerialDataReceivedEventArgs e)

ეს არის მეთოდი, რომელსაც უწოდებენ, როდესაც მონაცემები მიიღება სერიულ პორტზე. ეს არის ის, სადაც ჩვენ ვიყენებთ მთელ ფიზიკას, ვწყვეტთ თამაშის დასრულებას, პლატფორმების გადატანას და ა.შ. ახალისებს ამ თამაშში DataReceived მეთოდი მოქმედებს როგორც თამაშის მარყუჟი, მხოლოდ ფიზიკის მანიპულირებით ხდება მონაცემების მიღება კონტროლერისგან. შესაძლოა უკეთესად იმუშაოს მთავარ ფანჯარაში ტაიმერის დაყენება და ობიექტების განახლება მიღებული მონაცემების საფუძველზე, მაგრამ რადგან ეს არის არდუინოს პროექტი, მინდოდა გამეკეთებინა თამაში, რომელიც რეალურად მუშაობდა მისგან შემოსული მონაცემების საფუძველზე რა

დასასრულს, ეს კონფიგურაცია იძლევა კარგ საფუძველს თამაშის გაფართოების მიზნით. მიუხედავად იმისა, რომ ფიზიკა არ არის სრულყოფილი, ის საკმაოდ კარგად მუშაობს ჩვენი მიზნებისათვის, ანუ არდუინოს გამოსაყენებლად ის, რაც ყველას მოსწონს: თამაშობენ თამაშებს!