Arduino კონტროლერები: 10 ნაბიჯი (სურათებით)

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

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

ეს პროექტი ასევე შექმნილია p5.js JavaScript ბიბლიოთეკის გამოყენებასთან ერთად p5.play ბიბლიოთეკისთვის, რომელიც განკუთვნილია p5.js. ეს ბიბლიოთეკები საშუალებას გვაძლევს მარტივად დავპროგრამოთ ჩვენი თამაშები. P5.play ვებსაიტს აქვს რამოდენიმე გაკვეთილი და მაგალითი მომხმარებლებისთვის, რომ შექმნან თამაშები მისთვის. ეს პროექტი მომხმარებლებს საშუალებას აძლევს გამოიყენონ თავიანთი ტექნიკური და პროგრამული უზრუნველყოფის განვითარების უნარ -ჩვევები.

ნაბიჯი 1: რაც დაგჭირდებათ

ინსტრუმენტები:

• გასაყიდი რკინა
• Solder
• მავთულის სტრიპტიზორები
• გვერდითი საჭრელები
• ფანქარი

აპარატურა:

• Arduino თავსებადი დაფა (მე გამოვიყენე Sparkfun დაფა, ასევე Arduino Uno და ლეონარდო)

• სრულყოფილი დაფა:

  • 8 სმ x 6 სმ მწვანე პერფის დაფები
  • Aduino Uno ფარი პერფ დაფა

• სხვადასხვა სენსორები

  • ჯოისტიკები
  • ღილაკები (რეზისტენტებით, 10k ohms, მათთან ერთად)
  • პოტენომეტრები
  • Flex სენსორები
  • წნევის სენსორები
  • და სხვა…

• მავთული:

  • ერთი მავთული (მე გამოვიყენე 26 AWG მყარი)
  • ლენტი მავთულები და დამჭერები
• დაარღვიე თავი (აქედან მინიმუმ 20)

• სურვილისამებრ აპარატურა (შეგიძლიათ გამოიყენოთ მუყაო და ცხელი წებო/zip სამაგრები):

  • Breadboard და jumper კაბელები პროტოტიპისთვის
  • 3D ნაბეჭდი კორპუსები
  • აპარატურის შესაკრავები (მე გამოვიყენე M2.5 ხრახნები)

პროგრამული უზრუნველყოფა:

• Arduino IDE

• p5.js ბიბლიოთეკა

  P5. ასევე ითამაშეთ ბიბლიოთეკა

• p5. სერიული კონტროლი
• კვანძი. Js

ნაბიჯი 2: მშენებლობა: კონსოლის კერა, ფარის დაყენება

ჩასვით თავები Arduino Uno ფარის პერფის დაფაზე.

• დავიწყე ფარის სათაურებით (ძალა, ანალოგი და ციფრული)
• შემდეგი არის 2x5 სათაურის ქინძისთავები. თქვენ შეგიძლიათ გამოიყენოთ 2x5 სათაურები, ან მხოლოდ 2 სტრიქონი 5 შესვენებაზე. ვერტიკალურად დავდე ეს A3 და A4 და მათ შორის დავტოვე 2 სივრცე.

ნაბიჯი 3: შენობა: კონსოლის კერა, ფარის გაყვანილობა

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

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

ამ ფარის დიზაინის იდეა არის თითოეული კონტროლერიდან 3 ანალოგური და 5 ციფრული შეყვანის დაშვება. ეს სრულად იყენებს Arduino Uno– ს ყველა ანალოგურ შეყვანას, ასევე ჩვენს ფირზე დარჩენილ მავთულს.

ნაბიჯი 4: მშენებლობა: კონტროლერები, თქვენი ნაწილების დაყენება

პირველი ნაბიჯი თქვენი კონტროლერის შესაქმნელად არის დაგეგმოთ რომელი სენსორების გამოყენება. ჩემს მაგალითებში მე მაქვს საკმაოდ სტანდარტული კონტროლერი ჯოისტიკით და რამდენიმე ღილაკით. მე ასევე მაქვს კონტროლერი ორი სლაიდერი პოტენომეტრით.

თუ გსურთ ამის გამეორება, შეგიძლიათ ნახოთ ჩემი სურათები განთავსებისთვის.

შემდეგი ნაბიჯი არის თქვენი ლენტის კაბელის შედუღება პერფის დაფაზე.

1. გადააფარეთ და კალის ლენტი კაბელი
2. შეაერთეთ ლენტი კაბელი თქვენი პერფის დაფის ზედა ცენტრში.

შემდეგი ნაბიჯი არის თქვენი მავთულის მარშრუტირება. დავიწყე დენის (5 ვ/წითელი მავთულის) და მიწის (ყავისფერი მავთულის) მიერთება სენსორებთან. შემდეგ შევაერთე ანალოგური შეყვანა. მე ადვილად გამოვიყენე ნარინჯისფერი კაბელი (ანალოგი A0 ან A3) ჰორიზონტალური მოძრაობისთვის და ყვითელი კაბელი (ანალოგი A1 ან A4) ვერტიკალური მოძრაობისთვის.

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

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

ნაბიჯი 5: სურვილისამებრ: დანართები

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

თქვენ შეგიძლიათ ნახოთ ჩემი 3D მოდელები, რომლებიც ერთვის ამ ნაბიჯს. მე შევქმენი ჩარჩოები Arduino Uno/Leonardo და Sparkfun RedBoard– ისთვის (ეს დაფა ცოტა უფრო ფართოა და იყენებს მინი USB– ს).

კონტროლერებისთვის, შეგიძლიათ მიამაგროთ ისინი M2.5 ხრახნით. მე ვინახავდი თხილს PCB- ის მხარეს და ვიყენებ გამრეცხი და ხრახნი ბოლოში.

მე ასევე ჩავრთე 3D მოდელი სახელურის სლაიდერებისთვის, რომელიც მე გამოვიყენე.

თქვენ შეგიძლიათ იპოვოთ ყველა 3D ფაილი GitHub– ზე.

ნაბიჯი 6: პროგრამირება: არდუინო

დავიწყოთ შესამოწმებლად მარტივი ესკიზის დაყენებით. მე გირჩევთ გამოიყენოთ ITU– ს მიერ შექმნილი NYU– ში აქ ნაპოვნი სახელმძღვანელო. ამ გაკვეთილის გასაკეთებლად დაგჭირდებათ p5.serialcontroll და node.js დაინსტალირებული. ამ სახელმძღვანელოში თქვენ გაეცნობით Arduino– ს დაყენებას სერიული მონაცემების გასაგზავნად, რომელიც გამოსაყენებელია ჩვენი javascript ბიბლიოთეკისთვის, p5.js. თქვენ შეგიძლიათ გამოიყენოთ ჰაბ და კონტროლერი, რომელიც ჩვენ შევქმენით წინა ნაბიჯებში, ან შეგიძლიათ გაიმეოროთ სქემები, რომლებიც ნაჩვენებია სახელმძღვანელოში. ეს სამეურვეო იყენებს A0 ანალოგურ შეყვანის პინს Arduino Uno– ზე, რომელიც ასახულია თქვენი პირველი კონტროლერის ნარინჯისფერ მავთულზე.

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

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

// კონტროლერი 1const int dig2 = 2; // ლურჯი const int dig3 = 3; // მეწამული const int dig4 = 4; // ნაცრისფერი const int dig5 = 5; // თეთრი const int dig6 = 6; // შავი // კონტროლერი 2 const int dig7 = 7; // blue const int dig8 = 8; // მეწამული const int dig9 = 9; // ნაცრისფერი const int dig10 = 10; // თეთრი კონსტ int dig11 = 11; // შავი

void setup () {

სერიული.დაწყება (9600); ხოლო (Serial.available () <= 0) {Serial.println ("გამარჯობა"); // გაგზავნის საწყისი შეტყობინების დაგვიანებას (300); // დაელოდეთ 1/3 წამს} pinMode (dig2, INPUT); pinMode (dig3, INPUT); pinMode (dig4, INPUT); pinMode (dig5, INPUT); pinMode (dig6, INPUT); pinMode (dig7, INPUT); pinMode (dig8, INPUT); pinMode (dig9, INPUT); pinMode (dig10, INPUT); pinMode (dig11, INPUT); }

ბათილი მარყუჟი () {

if (Serial.available ()> 0) {// წაიკითხეთ შემომავალი ბაიტი: int inByte = Serial.read (); // წაიკითხეთ სენსორი:

// ANALOG კონტროლერი 1

int analog0 = analogRead (A0); int analog1 = analogRead (A1); int analog2 = analogRead (A2); // ANALOG Controller 2 int analog3 = analogRead (A3); int analog4 = analogRead (A4); int analog5 = analogRead (A5); // DIGITAL Controller 1 int digital2 = digitalRead (dig2); int digital3 = digitalRead (dig3); int digital4 = digitalRead (dig4);

int digital5 = digitalRead (dig5);

int digital6 = digitalRead (dig6); // DIGITAL Controller 2 int digital7 = digitalRead (dig7); int digital8 = digitalRead (dig8); int digital9 = digitalRead (dig9); int digital10 = digitalRead (dig10); int digital11 = digitalRead (dig11); // შედეგების ამობეჭდვა: Serial.print (analog0); // [0] Serial.print (","); Serial.print (ანალოგი 1); // [1] Serial.print (","); Serial.print (ანალოგი 2); // [2] Serial.print (","); // დაიწყე კონტროლერი 2 მონაცემები Serial.print (analog3); // [3] Serial.print (","); Serial.print (ანალოგი 4); // [4] Serial.print (","); Serial.print (ანალოგი 5); // [5] Serial.print (","); Serial.print (digital2); // [6] Serial.print (","); Serial.print (digital3); // [7] Serial.print (","); Serial.print (digital4); // [8] Serial.print (","); Serial.print (digital5); // [9] Serial.print (","); Serial.print (digital6); // [10] Serial.print (","); // კონტროლერის დაწყება 2 მონაცემები Serial.print (digital7); // [11] Serial.print (","); Serial.print (digital8); // [12] Serial.print (","); Serial.print (digital9); // [13] Serial.print (","); Serial.println (digital10); // [14] Serial.print (","); Serial.println (ციფრული 11); // [15]}}

ეს კოდი აგზავნის სერიული მონაცემებს ჩვენი ორივე კონტროლერისგან 16 ნომრის მასივის სახით. ამ რიცხვების პირველი 6 არის ჩვენი ანალოგური შეყვანა (0-1023-დან) და დარჩენილი 10 მნიშვნელობა არის ჩვენი ციფრული მნიშვნელობები (0 ან 1).

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

ნაბიჯი 7: პროგრამირება: HTML

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

სხეული {შევსება: 0; ზღვარი: 0;}

Html კოდი უბრალოდ აკავშირებს ჩვენს javascript ფაილებს. ჩვენი კოდის უმეტესობა რეალურად მოხდება ესკიზის.js ფაილში.

ნაბიჯი 8: პროგრამირება: P5.js და Javascript

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

• p5.js
• გვ 5. თამაში

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

// სერიული ცვლადი სერიული სერიალი; // ცვლადი სერიული პორტის ბიბლიოთეკის მაგალითზე var portName = 'COM4'; // შეავსეთ თქვენი სერიული პორტის სახელი აქ // გლობალური თამაშის ცვლადები ---------------

// დაყენების ფუნქცია ----------------------

ფუნქციის დაყენება () {createCanvas (640, 480); სერიული = ახალი p5. SerialPort (); // სერიული პორტის ბიბლიოთეკის ახალი მაგალითის შექმნა serial.on ('list', printList); // დააყენეთ გამოძახების ფუნქცია სერიული პორტის სიის მოვლენისთვის serial.on ('დაკავშირებულია', serverConnected); // სერვერზე serial.on ('გახსნილი', portOpen) დასაკავშირებლად გამოძახება; // პორტის გახსნის serial.on ('data', serialEvent) გამოძახება; // გამოძახება, როდესაც ახალი მონაცემები ჩამოდის serial.on ('error', serialError); // შეცდომების გამოძახება serial.on ('დახურვა', portClose); // პორტის დახურვის სერიული სია. () // ჩამოთვალეთ სერიული პორტები serial.open (portName); // სერიული პორტის გახსნა} // Draw ფუნქცია ----------------------- ფუნქცია draw () {background (0); // შავი ფონი} // სერიული მონაცემების ინტერპრეტაცია აქ ---------- ფუნქცია serialEvent () {// წაიკითხეთ სტრიქონი სერიული პორტიდან // სანამ არ მიიღებთ ვაგონის დაბრუნებას და ახალ ხაზს: var inString = სერიული. readStringUntil ('\ r / n'); // შეამოწმეთ, რომ იქ ნამდვილად არის ssetring: if (inString.length> 0) {if (inString! == 'hello') {// თუ გამარჯობა, იგნორირება გაუკეთეთ var sensors = split (inString, ', '); // გაყავით სტრიქონი მძიმით თუ (სენსორები. სიგრძე> 16) {// თუ არის თექვსმეტი ელემენტი (6 ანალოგიური, 10 ციფრული) // გამოიყენეთ სენსორის მონაცემები აქ:

}

} serial.write ('x'); // გაგზავნეთ ბაიტი მეტი სერიული მონაცემების მოთხოვნით}} // მიიღეთ პორტების სია: ფუნქცია printList (portList) {// portList არის სერიული პორტის სახელების მასივი (var i = 0; i <portList.length; i ++) {// სიის ჩვენება კონსოლი: print (i + "" + portList ); }} ფუნქცია serverConnected () {print ('დაკავშირებულია სერვერთან.'); } function portOpen () {print ('სერიული პორტი გაიხსნა.')} ფუნქცია serialError (err) {print ('სერიულ პორტთან მოხდა რაღაც შეცდომა.' + err); } ფუნქცია portClose () {print ('სერიული პორტი დაიხურა.'); } ფუნქცია დახურვის კოდი () {serial.close (portName); დაბრუნება null; } window.onbeforeunload = დახურვის კოდი;

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

// სერიული მონაცემების ინტერპრეტაცია აქ ----------

ფუნქცია serialEvent () {// წაიკითხეთ სტრიქონი სერიული პორტიდან // სანამ არ მიიღებთ ვაგონის დაბრუნებას და ახალ ხაზს: var inString = serial.readStringUntil ('\ r / n'); // შეამოწმეთ, რომ იქ ნამდვილად არის ssetring: if (inString.length> 0) {if (inString! == 'hello') {// თუ მიესალმები, იგნორირება გაუკეთე var sensors = split (inString, ', '); // გაყავით სტრიქონი მძიმით if (sensors.length> 16) {// თუ არის თექვსმეტი ელემენტი (6 ანალოგური, 10 ციფრული) // გამოიყენეთ სენსორის მონაცემები აქ:}} serial.write ('x'); // გაგზავნეთ ბაიტი მეტი სერიული მონაცემების მოთხოვნით}}

ჩვენ ახლა შეგვიძლია გავუშვათ ჩვენი პროგრამა, რომ ნახოთ მუშაობს თუ არა!

ნაბიჯი 9: გაუშვით თქვენი პროგრამა

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

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

• შეაერთეთ Arduino იმ კონტროლერთან, რომლის გამოყენებასაც აპირებთ.
• გახსენით p5. სერიული კონტროლი
• შეცვალეთ თქვენი p5 ესკიზის პორტი, რომელსაც იყენებთ (თუ იყენებთ ჩონჩხს, ეს არის ხაზზე 3)
• გახსენით HTML ფაილი, რომელიც აკავშირებს თქვენს p5 ესკიზს

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

ნაბიჯი 10: წინსვლა

უფრო შორს წასასვლელად და მეტი თამაშების შესაქმნელად, შეგიძლიათ მიჰყევით p5– ის სხვადასხვა მაგალითს. ითამაშეთ აქ. ქვემოთ მოცემულია უფრო რთული თამაშის მაგალითი, რომელიც მე შევქმენი. ეს არის 1 vs 1 სატანკო მსროლელი თამაში. თქვენ შეგიძლიათ იპოვოთ ყველა რესურსი ამისთვის GitHub– ზე.