Arduino თამაშის კონტროლერი შუქებით, რომელიც პასუხობს თქვენს ერთობის თამაშს :: 24 ნაბიჯი

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

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

ამ პროექტში მე ვიყენებ 2 arduino– ს კოდის 2 ცალკეული ბიტის გასაშვებად, ვინაიდან გამიჭირდა მისი მუშაობა მხოლოდ ერთთან

ესენი არიან უნიო და ლეონარდო

საერთო ჯამში, ეს არის ის, რაც დაგჭირდებათ პროექტის გასაუმჯობესებლად.

· 7 ღილაკი

· 23 მხტუნავი მავთული

· 1 arduino ლეონარდო + USB კაბელი

· 4 რეზისტორი · 4 led

· 1 arduino uno + USB კაბელი

· 2 დაფა

ნაბიჯი 1: კონტროლის ღილაკების მიერთება არდუინოსთან

რაც დაგჭირდებათ ამ ნაწილის დასაკავშირებლად:

· 7 ღილაკი

· 14 მხტუნავი მავთული

· 1 arduino ლეონარდო + USB კაბელი

· პურის დაფა

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

· პირველ რიგში თქვენ განათავსეთ ღილაკები იმ პოზიციებში, რომლებიც მე მონიშნული მაქვს ზემოთ მოცემულ სურათზე.

· მეორეც, თქვენ გინდათ არუმუ ლეონარდოზე ჯუმპერი მიამაგროთ დაფაზე მინუს მწკრივში.

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

· შემდეგ თქვენ გინდათ დააკავშიროთ ჯუმბერის მავთული ზედიზედ, რომელიც შეესაბამება თქვენი ღილაკის მარცხენა პინთან ლეონარდოს ციფრული შეყვანის სლოტებს. ღილაკებისთვის აქ გამოვიყენე სლოტი 2 - 3 - 4 - 5 - 6 - 7- 8

მე მხოლოდ აჩვენე მავთული, რომელიც აპირებს სურათზე 8 შეყვანას, რადგან ის ხდება ძალიან ბინძური სურათი, რომ გაჩვენოთ ყველა მავთული ერთმანეთზე.

ნაბიჯი 2: კოდირება Arduino Leonardo:

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

ახლა მე ვაპირებ სიარულს თქვენ ფიქრობდით კოდი ეტაპობრივად.

უპირველეს ყოვლისა, ზედა ნაწილში ჩვენ მოიცავს Keyboard.h. ეს საშუალებას მოგვცემს გამოვიყენოთ კლავიატურის ფუნქციები, რომლებსაც ჩვენ ვიყენებთ ჩვენს კოდში.

ნაბიჯი 3:

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

ლეონარდო თითოეული ღილაკისთვის.

მე ასევე დავარქვი თითოეულ მათგანს იმ გასაღების სახელით, რომლის მიბაძვასაც ვაპირებ.

ნაბიჯი 4:

იქიდან ჩვენ შევდივართ კონფიგურაციის ფუნქციაში. ეს ეუბნება იმას

arduino რას აკეთებს გაშვებისას.

პირველ რიგში ჩვენ ვწერთ Serial.begin რომელიც გახსნის სერიულ პორტს და ადგენს მონაცემთა სიჩქარეს 9600 bps

და ჩვენ განვსაზღვრავთ ყველა დასახელებულ ქინძისთავებს შეყვანისთვის.

ნაბიჯი 5:

და ბოლოს ჩვენ ვწერთ ჩვენს მარყუჟის ფუნქციას, რომელიც შეამოწმებს თუ არა

ღილაკებს აჭერენ და უთხარი არდუინოს როგორ უპასუხოს ამას.

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

ნაბიჯი 6:

შემდეგ ყველა ღილაკზე ჩვენ ვწერთ if/else განცხადებას, რომელიც ასე გამოიყურება

ასე რომ, რაც მე ვუთხარი arduino– ს არის: თუ ჩემი მარცხენა ღილაკი იკუმშება კონტროლერზე, აფიქრებინეთ კომპიუტერი, რომ ჩვენ ვაჭერთ ღილაკს „a“და თუ ეს ასე არ არის, იფიქრეთ, რომ ჩვენ გავუშვით გასაღები.

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

ნაბიჯი 7:

კლავიშები, რომლებიც ჩვენ ვუთხარით კომპიუტერს, რომ მოარტყა აქ არის W - A - S - D, რომელიც

საკმაოდ სტანდარტულია კომპიუტერულ თამაშებში და E-Q– ში გადაადგილებისთვის და spacebar, რომელიც ამ კოდში არის აღიარებული, როგორც არის ღილაკები, რომლითაც მე ვიღებ ამოღებას-გათავისუფლებას და თამაშს ჩემს თამაშში. მოგერიდებათ შეცვალოთ ეს ის კლავიშები, რომლებიც თქვენი აზრით უკეთესად მუშაობს თქვენს თამაშზე/კონტროლერზე.

შემდეგ ბოლოს ჩვენ ვეუბნებით arduino– ს, რომ შეწყვიტოს შემოწმება რომელი კლავიატურა. დასასრული

ნაბიჯი 8: კოდირების მოძრაობა ერთობაში:

უპირველეს ყოვლისა, მინდა გითხრათ, რომ მე ამას ვაკეთებ 2d თამაშისთვის

მაგალითები, რომელთა ნახვასაც აპირებთ, ამისთვის არის აგებული. ძირითადად ნიშნავს იმას, თუ სად ვიყენებ vector2– ს, თუ თქვენ მუშაობთ 3D– ში, თქვენ გამოიყენებთ vector3– ს. რადგან თქვენ უნდა ინერვიულოთ მოძრაობის დამატებით განზომილებაზე 3D- ში.

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

თუ თქვენ გახსნით თქვენს პროექტს ერთიანად, გადადით რედაქტირება -> პროექტის პარამეტრები -> შეყვანა. თქვენ შეგიძლიათ ნახოთ თქვენს ინსპექტორში, რომ ის იტვირთება შეყვანის მენეჯერი. სადაც, თუ დააწკაპუნებთ ღერძებზე, ხედავთ, რომ იხსნება მთელი რიგი შეყვანის სახელები, რომლებიც ჩვეულებრივ გამოიყენება კომპიუტერის კონტროლერებისთვის, როგორიც ჩვენ ახლა ვაკეთებთ. 2 შეყვანის ჩვენ ვაპირებთ გამოვიყენოთ არის ჰორიზონტალური და ვერტიკალური რომელიც შეამოწმეთ თქვენ მიხვდა W-A-S-D.

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

ნაბიჯი 9:

თქვენ გსურთ მისცეთ ამ მოთამაშეს 2 რამ. ყუთის კოლაიდერი 2d და

Rigidbody 2d და შეცვალეთ ისინი ისე, როგორც ზემოთ გამოსახულია.

ნაბიჯი 10:

შემდეგ გსურთ შეხვიდეთ თქვენი პროექტების საქაღალდეში და შექმნათ

C# სკრიპტი. რომელსაც მე დავარქვი PlayerMovement.

ამ სკრიპტში თქვენ აპირებთ განსაზღვროთ 2 ცვლადი. საზოგადოებრივი მოძრავი, რომელსაც მე ვუწოდებ moveSpeed. რაც განსაზღვრავს რამდენად სწრაფად მიდიხარ. და კერძო Rigidbody2D რომელსაც მე ვუწოდებ RigidPlayer. რომელიც ეძებს თქვენს მოთამაშეებს rigidbody.

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

ნაბიჯი 11:

ახლა თქვენს დაწყებისას () გსურთ ერთი რამის გაკეთება და ეს არის

დარწმუნდით, რომ თქვენს RigidPlayer- ს შეუძლია იპოვოს თქვენი გადამხდელი rigidbody 2d. თქვენ ამას აკეთებთ კოდის შემდეგი ხაზით:

ნაბიჯი 12:

შემდეგ ჩვენ გადავდივართ განახლებაზე (). აი, სად მივდივართ

რათა მოთამაშე გადავიდეს.

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

ნაბიჯი 13:

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

თქვენ არაფერს აჭერთ ეს მოგწონს ასე:

ახლა თუ გსურთ გამოიყენოთ თქვენი 3 სხვა ღილაკი ყველაფრისთვის, რასაც აკეთებთ ამ if განცხადებით: if (Input. GetKeyDown (Keycode. Space))

ამისთვის spacebar და სივრცის ნაცვლად განათავსეთ სხვა კლავიშების ასო, რომელიც თქვენ აირჩიეთ სხვა კლავიშებისთვის.

ნაბიჯი 14: შეუერთეთ შუქები არდუინოს

·

რაც დაგჭირდებათ ამ ნაწილის დასაკავშირებლად:

· 9 ჯუმბერის მავთული

· 4 რეზისტორი

· 4 led

· 1 arduino uno + USB კაბელი

· პურის დაფა

განათების დაკავშირება მოხდება Uno– ს საშუალებით.

საბოლოოდ გამოიყურება როგორც ეს სურათი ზემოთ:

თქვენ რეზისტორებს აერთებთ LED- ების გრძელ მხარეს. შემდეგ კი აერთებთ jumper ციფრული პინ ნომრიდან uno- ზე რეზისტორებს. ამ შემთხვევაში მე გამოვიყენე ციფრული პინის სლოტები 9 -10 -11 -12 ეს რიცხვები აქტუალური იქნება, როდესაც მივიღებთ ნათურების კოდს.

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

შემდეგ გსურთ გქონდეთ 4 მხტუნავები, რომლებიც ყველა წამყვანია თითოეული LED- ის მოკლე ბოლოში

ნაბიჯი 15: Arduino Uno- ს კოდირება

კარგი, ჯერ ჩვენ ვაპირებთ კვლავ განვსაზღვროთ ჩვენი ცვლადები

ასე რომ, პირველ რიგში, რომელი ციფრული საშუალებები ვიყენებთ ჩვენს განათებისთვის. ჩვენ ვაპირებთ გავაკეთოთ ნახშირი სახელწოდებით myCol [20]

ნაბიჯი 16:

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

ნაბიჯი 17:

დაბოლოს, თქვენ გსურთ დაწეროთ თქვენი მარყუჟის ფუნქცია.

ეს გამოიწვევს Arduino– ს წაკითხვას სერიული საშუალებით შემოსული ნებისმიერი მონაცემი, სანამ ერთი ორი მოვლენა არ მოხდება. გამოვლენილია ხაზის არხის სიმბოლო; ეს არის განსაზღვრული lf– ით, რომელიც არის 10 და არის პირველი არგუმენტი ან წაკითხულია გარკვეული რაოდენობის ბაიტი. ეს არის მესამე არგუმენტი და ამ მაგალითისთვის მითითებულია მხოლოდ ერთი ბაიტი. მონაცემები ინახება ცვლადი myCol- ში, რომელიც მითითებულია char- ზე და ლიმიტი 20 -მდე. ReadBytesUntil ეს არის მეორე არგუმენტი. ან მისი ახსნის სხვა გზა არის Serial.readBytesUntil (terminatorCharacter, buffer, byteLimit);

და თუ განცხადებები დარწმუნდება, რომ გარკვეული შუქები ირთვება, როდესაც ერთიანობა იძლევა სიგნალს. ამ შემთხვევაში მე მივიღე 4 სხვადასხვა ფერის შუქი, ასე რომ მე ვაგზავნი g- ს მწვანე LED- ს ჩართვისთვის, b ლურჯი LED- ის ჩართვისთვის, r წითელი LED- ის ჩართვისთვის და y ყვითელი LED- ის ჩართვისთვის.

ნაბიჯი 18: კოდირების განათება ერთიანობის მხარე:

კარგია 2 რამ, სანამ ამას შევუდგებით.

1. თქვენს arduino კოდირების პროგრამაში გადადით Tool -> Port -> და შეამოწმეთ რომელი COM არის თქვენი uno. ჩემს შემთხვევაში მისი COM3 (ეს მნიშვნელოვანი იქნება კოდში)

2. ერთობაში გადადით რედაქტირებაზე -> პროექტის პარამეტრები -> მოთამაშე შემდეგ ინსპექტორში დააწკაპუნეთ სხვა პარამეტრებზე გადადით Api თავსებადობის დონეზე და გადართეთ. NET 2.0 ქვექსელიდან მხოლოდ. NET 2.0

ოკ ეს დასრულდა. შევეშვათ მას.

მარჯვენა ღილაკით დააწკაპუნეთ თქვენს იერარქიაზე და დააწკაპუნეთ ცარიელის შექმნაზე.

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

ნაბიჯი 19:

შემდეგ გადადით თქვენი პროექტების ჩანართზე და შექმენით ახალი C# სკრიპტი

და დაარქვით მას გაგზავნა.

პირველი რაც თქვენ უნდა გააკეთოთ არის ჩაწეროთ ეს სტრიქონები თქვენი კოდის სექციების გამოყენებით:

System. IO. Ports- ის გამოყენებით;

System. Threading– ის გამოყენებით;

ამით ჩვენ შეგვიძლია გამოვიყენოთ SerialPort ცვლადი

ნაბიჯი 20:

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

ნაბიჯი 21:

დასაწყისში ჩვენ ვეუბნებით სკრიპტს გამოიყენოს OpenConnection

ფუნქცია, რომელსაც ჩვენ ცოტათი დავწერთ

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

ნაბიჯი 22:

კარგი ახლა ამ OpenConnection ფუნქციისთვის. ეს მხოლოდ დიდია

if/else განცხადება, რომელიც ინახავს კავშირს ღია, უბრალოდ დააკოპირეთ როგორც დაწერილია და თქვენ კარგად იქნებით.

ნაბიჯი 23:

ახლა დაიმახსოვრე arduino კოდიდან, რომლის შესამოწმებლად გავაკეთე

სიგნალები იმისა, რომ ერთიანობა მას გაუგზავნის.

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

ნაბიჯი 24:

თქვენ ალბათ გაინტერესებთ როგორ უნდა დავარქვა ამას

ფუნქცია? თქვენ ამას აკეთებთ ერთი მარტივი ხაზით, თქვენს სხვა c# სკრიპტებში, რომელსაც იყენებთ თქვენი თამაშისთვის. Sending. NameFunctionhere ();. მაგალითად ჩემს თამაშში მოთამაშეს ევალება შეაგროვოს 4 ფერის ორბი. ასე რომ, მე დავწერე პატარა სცენარი, რომელიც დარწმუნებულია, რომ როდესაც ის ერთს მიუახლოვდება და მარჯვენა ღილაკს დააჭერს, ის ამოიღებს მას და აგზავნის სიგნალს არდუინოს, რომ ამ შემთხვევაში ყვითელი ორბი აიყვანეს. რომ იცოდეს, ოკ, ყვითელი LED უნდა ჩავრთო:

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