არდუინო - საფორტეპიანო ფილები: 16 ნაბიჯი (სურათებით)

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

გამარჯობა ინტერნეტ ხალხო, ეს იქნება იმის შესახებ, თუ როგორ უნდა გააკეთოთ ის, რაც ნამდვილად არ არის მობილური თამაშების გაფუჭება arduino uno r3– ზე.

დასაწყებად, თქვენ დაგჭირდებათ ყველა ნაწილი, რომელიც არის შემდეგი! 1x Arduino Uno r3 ($ 42)

2x LCD კლავიატურის ფარი (თითოეული $ 19)

5x ღილაკი

5x 220Ω რეზისტორები

28x მავთული

კარგი, მას შემდეგ რაც თქვენ მიიღებთ ყველა ნაწილს, დროა დაიწყოთ!

ნაბიჯი 1: გაყვანილობა

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

ნაბიჯი 2: დეკლარაციის განცხადებები

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

დაიწყეთ დაყენებით:

#ჩართეთ

თქვენი კოდის თავში, ეს ეუბნება არდუინოს გამოიყენოს ბიბლიოთეკა "LiquidCrystal.h" და მისი ნაწილი მისი ფუნქციები.

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

#განსაზღვრეთ btnEnter A0 #განსაზღვრეთ btn1 15 #განსაზღვრეთ btn2 16 #განსაზღვრეთ btn3 17 #განსაზღვრეთ btn4 18

ჩვენ განვსაზღვრავთ ტერმინებს btnEnter და btn1 to btn 4, რათა კოდის კითხვა გაგვიადვილდეს ან საჭიროების შემთხვევაში შევცვალოთ. ეს ნიშნავს, რომ როდესაც ჩვენ ვწერთ btn1 არდუინოს ეცოდინება, რომ ჩვენ რეალურად ვგულისხმობთ ღილაკს 15. მიუხედავად იმისა, რომ ჩვენ ვუწოდებთ პორტებს პორტს 15, 16, 17 და 18, ისინი არდუინოზე იწერება როგორც A1 A2 A3 და A4, ეს იმიტომ ხდება ეს არის პორტები, რომლებიც სპეციალურად გამოიყენება ანალოგური შეყვანისთვის, თუმცა ჩვენ მათ ვიყენებთ მხოლოდ ციფრული შეყვანისთვის.

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

LiquidCrystal lcd მარცხენა (8, 9, 12, 10, 11, 13); LiquidCrystal lcdRight (2, 3, 4, 5, 6, 7);

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

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

// ეს ცვლადები არის პარამეტრები, რომელთა შეცვლაც შეგიძლიათ - უფრო მაღალი რიცხვები = თამაშის უფრო სწრაფი სიჩქარე intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

// დააყენეთ ცვლადები gameboolean bolPlay– სთვის; // აკონტროლებს თუ არა მოთამაშე int intScore; // აკონტროლებს მოთამაშეს ქულა int intDiff; // უბრალოდ ესთეტიკური რამ იმის სათქმელად, თუ რა სირთულეზეა თამაში // დააყენეთ ცვლადები int intEnter შესასვლელად; // აკონტროლებს თუ მომხმარებელი დააჭერს enter ღილაკს int intInput; // აკონტროლებს რომელ ღილაკებს აჭერს მომხმარებელი ლოგიკურ bolTilePressed; // დარწმუნდით, რომ მოთამაშე შემთხვევით არ აჭერს ღილაკს 5x და არ კარგავს // ცვლის ცვლადებს int intTick– ისთვის; // ითვლის მილიონებს (თითო მარყუჟში) intDelay int intDelay; // დრო, როდესაც პროგრამა ელოდება მომდევნო შემობრუნებას millis int intGameSpeed– ში; // გამართვის პარამეტრების აცილება boolean bolSerialBoard; // როდესაც ჭეშმარიტი დაბეჭდავს დაფას სერიულ მონიტორში

ჩვენ ვაცხადებთ ცვლადს მონაცემთა ტიპის და შემდეგ ცვლადის სახელის მითითებით, მაგ. int thisIsAnInteger

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

მთელი ცვლადი (int), როგორიცაა intScore და intInput, შეუძლია მიიღოს მთელი რიცხვები მნიშვნელობებად, მაგალითად 1, 5 ან 100.

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

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

bolPlay ეუბნება პროგრამას, უნდა გამოჩნდეს თუ არა მენიუ თუ უნდა გაშვებულიყო რეალური თამაში.

intScore აკონტროლებს მოთამაშის ქულას ფილების დარტყმისას, intDiff გამოიყენება მთავარ მენიუში, რომ უთხრას პროგრამას რა ტექსტი უნდა დაბეჭდოს LCD– ზე, intEnter გამოიყენება პროგრამის გასაგებად, თუ დააჭირეთ ღილაკს (მარცხნივ მარცხნივ), intInput გამოიყენება პროგრამის სათქმელად, დანარჩენი 4 ღილაკიდან რომელია დაჭერილი.

bolTilePressed გამოიყენება იმის უზრუნველსაყოფად, რომ პროგრამა იკითხება მხოლოდ ღილაკზე დაჭერისას და არა მისი დაკავებისას.

intGameSpeed, intGameSpeedEasy, intGameSpeedMedium და intGameSpeedHard გამოიყენება იმის გასაკონტროლებლად, თუ რამდენად სწრაფად უნდა აჩქარდეს თამაში, რომელი სირთულის მიხედვით არის შერჩეული.

intTick და intDelay გამოიყენება პროგრამის გადასატანად დაფის გადაადგილებისას ყოველ ჯერზე, როდესაც ის მარყუჟდება.

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

საბოლოოდ დროა გამოვაცხადოთ ჩვენი დაფა მასივად ამ კოდის გამოყენებით:

// თამაშის 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}};

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

თქვენი კოდი ახლა ასე უნდა გამოიყურებოდეს;

// მოიცავს ბიბლიოთეკებს#მოიცავს

// ეს ცვლადები არის პარამეტრები, რომელთა შეცვლაც შეგიძლიათ - უფრო მაღალი რიცხვები = თამაშის უფრო დაჩქარება

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

// ქინძისთავების განსაზღვრა

#განსაზღვრეთ btnEnter A0 #განსაზღვრეთ btn1 15 #განსაზღვრეთ btn2 16 #განსაზღვრეთ btn3 17 #განსაზღვრეთ btn4 18

// LCD ობიექტების შექმნა (n, ~, n, ~, ~, n)

LiquidCrystal lcd მარცხენა (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 intEnter; // აკონტროლებს თუ მომხმარებელი დააჭერს enter ღილაკს int intInput; // აკონტროლებს რომელ ღილაკებს აჭერს მომხმარებელი ლოგიკურ bolTilePressed; // დარწმუნდით, რომ მოთამაშე შემთხვევით არ აჭერს ღილაკს 5x და არ წააგებს

// ცვლადების დაყენება თავის მხრივ

int intTick; // ითვლის მილიონებს (თითო მარყუჟში) intDelay int intDelay; // დრო, როდესაც პროგრამა ელოდება მომდევნო შემობრუნებას millis int intGameSpeed– ში;

// გამართვის პარამეტრების შეწყვეტა

ლოგიკური bolSerialBoard; // როდესაც true დაბეჭდავს დაფას სერიულ მონიტორში

ნაბიჯი 3: დაყენების ფუნქცია

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

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

დაიწყეთ ამ კოდის ჩასვით თქვენს 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);

სერიული.დაწყება (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. დასაწყისი (16, 2); }

ნაბიჯი 4: მარყუჟის ფუნქცია

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

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

void loop () {input (); // შეამოწმეთ შეყვანის თამაშის მნიშვნელობა თუ (bolPlay == ჭეშმარიტი) {if (intTick> = intDelay) {// შეამოწმეთ თამაშმა უნდა შეასრულოს თუ არა მორიგი ლოდინი Serial.println ("~~~~~~~ print "); // ამობეჭდვა ნიშნავს დაფის მოძრაობას // writeSerial (); // თუ ვარიანტი ჩართულია ჩაწერეთ დაფა სერიულ ღილაკებში GameGame (); // შეამოწმეთ მოთამაშის შეყვანა playBoard (); // გადაიტანეთ დაფა და დაამატეთ ახალი ფილა clearLcd (); // გაწმინდეთ LCD– ები drawBoard– ის დახატვამდე (); // დაფის დახატვა lcd's bottomCheck (); intTick = 0; // გადატვირთეთ intTick} else {buttonsGame (); // მოთამაშის შეყვანის შემოწმება clearLcd (); // გაწმინდეთ LCD– ები drawBoard– ის დახატვამდე (); // დაფის დახატვა lcd's intTick = intTick + intGameSpeed; // დამატება მონიშვნაზე}} else {clearLcd (); // გაწმინდეთ LCD- ები სათაურის დახატვამდე (); // სათაურის და ქულის ინფორმაციის ჩვენება buttonsMenu (); // მოთამაშის შესვლის წაკითხვა clearBoard (); // უზრუნველყოს მთლიანი დაფა = 0} შეფერხება (10); // არდუინოს მოკლე დროით გადადება}

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

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

შეყვანისას იკითხება რომელი ღილაკები დააჭირა მომხმარებელმა.

buttonsGame აკონტროლებს რას აკეთებენ ღილაკები თამაშში და არა მენიუში

playBoard დასძენს ახალ კრამიტს დაფაზე და შემდეგ გადააქვს ყველაფერი დაფაზე ერთ სივრცეში

clearLCD ასუფთავებს LCD– ებს, რათა დარწმუნდეს, რომ მოჩვენებები არ დარჩენილა ფილების უკან

drawBoard გადის arrGame– ში და ბეჭდავს მას LCD– ებზე

clearBoard ასუფთავებს arrGame– ს მთელ თამაშს, როდესაც თამაში არ თამაშობს

bottomCheck ამოწმებს arrGame- ს ფსკერზე წარუმატებლობის მდგომარეობისთვის

title აჩვენებს თამაშის სათაურს და ანგარიშის ინფორმაციას მენიუში ყოფნისას

ღილაკების მენიუ აკონტროლებს რას აკეთებს მომხმარებლის შეყვანა მენიუში ყოფნისას.

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

ნაბიჯი 5: ClearLCD ფუნქცია

ფუნქციის შესაქმნელად ვიწყებთ ამას კოდში დამატებით

void 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 ++) {// დახაზეთ კოლუმები 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); // დააყენეთ მესამე სვეტზე (ცენტრში მარჯვნივ) if (arrGame [2] == 1) {lcdRight.write ("#");} if (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 და unhit ფილა.

შემდეგ ის გადის დათვლილ მარყუჟს საპირისპიროდ, 15 -დან 1 -მდე, რიგის ტოლი გახდება რისი ტოლიც მის ზემოთ არის, რის გამოც დაფა გადადის LCD– ის ქვემოთ

ნაბიჯი 8: ClearBoard ფუნქცია

დააკოპირეთ ეს კოდი თქვენს პროგრამაში.

void clearBoard () {// გადატვირთეთ tick და დაგვიანებული მნიშვნელობები intTick = 0; intDelay = 1000; // გაიარე დაფა და ყველაფერი დააყენე 0 -ზე (int i = 0; i <= 15; i ++) {for (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– ში. დაწერა.

აქ ასევე იქმნება ახალი ცვლადი, strScore, იგი გამოიყენება intScore სტრიქონად ან char მონაცემების ტიპად გადასაყვანად sprintf ფუნქციის გამოყენებით.

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

ნაბიჯი 10: ღილაკების მენიუს ფუნქცია

შეიყვანეთ შემდეგი კოდი თქვენს პროგრამაში

void buttonsMenu () {// როდესაც enter დაჭერილია დაიწყეთ თამაში და გადააყენეთ ქულის მნიშვნელობა თუ (intEnter == 1) {bolPlay = true; intScore = 0; playBoard (); drawBoard (); } // ღილაკზე 3 დაჭერისას ჩართეთ დაფის სერიული დაბეჭდვის გამართვის ვარიანტი if (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("Serial Board Active"); bolSerialBoard = ჭეშმარიტი; } else {Serial.println ("სერიული დაფა გამორთულია"); bolSerialBoard = ყალბი; }} // დააყენეთ თამაშის სიჩქარე მარტივ სირთულედ, თუ (intInput == 0) {Serial.print ("Game set on easy ("); Serial.print (intGameSpeedEasy); Serial.println ("ms აჩქარება)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // დააყენეთ თამაშის სიჩქარე საშუალო სირთულისთვის თუ (intInput == 1) {Serial.print ("თამაში დაყენებულია საშუალოზე" ()); Serial.print (intGameSpeedMedium); Serial.println ("ms აჩქარება)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // დააყენეთ თამაშის სიჩქარე რთულ სირთულედ, თუ (intInput == 2) {Serial.print ("Game set on hard ("); Serial.print (intGameSpeedHard); Serial.println ("ms აჩქარება)"); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

ეს კოდი მუშაობს მხოლოდ მაშინ, როდესაც bolPlay უდრის ბათილ მარყუჟში false- ს

თუ intEnter დაყენებულია 1 -ზე, ეს ნიშნავს, რომ შესვლის ღილაკი დაჭერილია, თუ მასზე დაჭერით პროგრამა ადგენს bolPlay- ს true- ს და თამაში იწყება.

პროგრამა შემდეგ კითხულობს თუ რას უდრის intInput. თუ ის უდრის 0 -ს მარცხენა მხრიდან პირველი ღილაკი იჭრება, მარჯვნივ მარჯვნივ მაღლა იწევს 3 -მდე. თუ intInput არის 4 -ის ტოლი არ იჭერს ღილაკს.

თუ ღილაკებს 0-2 დააჭერთ თამაში ცვლის სირთულეს, ასევე თამაშის სიჩქარის მნიშვნელობის მორგებას, რაც იმას ნიშნავს რომ ის უფრო სწრაფად დაჩქარდება.

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

ნაბიჯი 11: ButtonsGame ფუნქცია

დააკოპირეთ შემდეგი კოდი თქვენს პროგრამაში

void buttonsGame () {if (intInput! = 4) {// თუ ღილაკზე დაჭერილია თუ (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 ("არასწორად დაჭერილი ღილაკი"); gameOver (); // სხვაგვარად თამაში დასრულდა}}}}}

კოდი გაშვებულია მხოლოდ მაშინ, როდესაც bolPlay ტოლია ჭეშმარიტი ბათილ მარყუჟში.

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

ამას აკეთებს arrGame ქვემოდან ზემოდან, ხოლო მარყუჟის გამოყენებით, რომ ნახოთ რომელი რიგია ყველაზე დაბალი unhit კრამიტით. ამის შემდეგ ის ამოწმებს, რომ იმ რიგის ადგილი, რომელიც შეესაბამება ღილაკს, არის unhit ფილა თუ არა, თუ unhit არის ის უტოლდება 2 -ს 1 -ის ნაცვლად, რაც იმას ნიშნავს, რომ ის გამოჩნდება @, წინააღმდეგ შემთხვევაში ის ააქტიურებს თამაშს ფუნქცია, რომელიც ჩვენ ჯერ უნდა შევქმნათ.

ეს ფუნქცია ასევე იყენებს bolTilePressed ცვლადს და აყენებს მას true ღილაკზე დაჭერისას და false როდესაც ღილაკს არ დააჭერთ. ეს არის იმის უზრუნველსაყოფად, რომ მომხმარებელი შემთხვევით არ წააგებს თამაშს, რადგან პროგრამას ეგონა, რომ რამდენჯერმე დააჭირა ღილაკს დაკვრისას.

ნაბიჯი 12: GameOver ფუნქცია

დააკოპირეთ შემდეგი კოდი თქვენს პროგრამაში

void gameOver () {Serial.println ("თამაში დასრულდა!"); Serial.print ("შენი ქულა იყო:"); Serial.println (intScore); Serial.print ("შენი სიჩქარე იყო:"); Serial.println (intDelay); bolPlay = ყალბი; }

ამას იწვევს checkBottom ან buttonsGame ფუნქციები და იწვევს თამაშის დასრულებას bolPlay– ის ყალბი დაყენებით.

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

ნაბიჯი 13: შეყვანის ფუნქცია

დააკოპირეთ შემდეგი კოდი თქვენს პროგრამაში.

void input () {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 ("Enter pressed!");} if (intInput! = 4) {Serial.print ("Button Press:"); Serial.println (intInput); } else {// თუ ღილაკი არ არის დაჭერილი გადატვირთეთ bolTilePressed bolTilePressed = false; }}

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

თუ არცერთი ღილაკი არ არის დაჭერილი, ეს არის ის ადგილი, სადაც bolTilePressed გადატვირთულია ღილაკების თამაშის ფუნქციისთვის.

ის ასევე ბეჭდავს შეტყობინებას სერიულ მონიტორზე, რომელზედაც დაჭერილია ღილაკი.

ნაბიჯი 14: BottomCheck ფუნქცია

დააკოპირეთ შემდეგი კოდი თქვენს პროგრამაში.

void bottomCheck () {for (int i = 0; i <= 3; i ++) {// for the 4 columns if (arrGame [15] == 1) {// თუ კრამიტი ბოლოშია სერიული.println ("კრამიტი ბოლოში"); arrGame [15] = 2; drawBoard (); დაგვიანება (400); arrGame [15] = 1; drawBoard (); დაგვიანება (400); arrGame [15] = 2; drawBoard (); დაგვიანება (400); arrGame [15] = 1; drawBoard (); დაგვიანება (400); gameOver (); }}}

მარყუჟის გამოყენებით, ეს კოდი ამოწმებს arrGame– ის ქვედა რიგს ნებისმიერი unhit ფილებისთვის (ფილები 1 – ის ტოლია), თუ ეკრანის ბოლოში არის unhit tile, ის აანთებს კრამიტს და შემდეგ გამოიწვევს თამაშს ფუნქციონირებაზე.

ნაბიჯი 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 (""); }}}

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

ნაბიჯი 16: დასრულება

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

/ * * სახელი - საფორტეპიანო ფილები; არდუინო * ავტორი - დომენიკ მარული * თარიღი - 11/ *

/ მოიცავს ბიბლიოთეკებს

#ჩართეთ

// ეს ცვლადები არის პარამეტრები, რომელთა შეცვლაც შეგიძლიათ - უფრო მაღალი რიცხვები = თამაშის უფრო დაჩქარება

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

// ქინძისთავების განსაზღვრა

#განსაზღვრეთ btnEnter A0 #განსაზღვრეთ btn1 15 #განსაზღვრეთ btn2 16 #განსაზღვრეთ btn3 17 #განსაზღვრეთ btn4 18

// LCD ობიექტების შექმნა (n, ~, n, ~, ~, n)

LiquidCrystal lcd მარცხენა (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 intEnter; // აკონტროლებს თუ მომხმარებელი დააჭერს enter ღილაკს int intInput; // აკონტროლებს რომელ ღილაკებს აჭერს მომხმარებელი ლოგიკურ bolTilePressed; // დარწმუნდით, რომ მოთამაშე შემთხვევით არ აჭერს ღილაკს 5x და არ წააგებს

// ცვლადების დაყენება თავის მხრივ

int intTick; // ითვლის მილიონებს (თითო მარყუჟში) intDelay int intDelay; // დრო, როდესაც პროგრამა ელოდება მომდევნო შემობრუნებას millis int intGameSpeed– ში;

// გამართვის პარამეტრების შეწყვეტა

ლოგიკური bolSerialBoard; // როდესაც true დაბეჭდავს დაფას სერიულ მონიტორში

// კონფიგურაცია, რომელიც გაშვებული იქნება ერთხელ

void setup () {Serial.begin (9600); // სერიული მონიტორის დაწყება // ცვლადების დაყენება bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // დაიწყოს lcd's lcdLeft.begin (16, 2); lcdRight. დასაწყისი (16, 2); }

// მარყუჟი, რომელიც გადის ყოველ 10 მილიწამში

void loop () {input (); // შეამოწმეთ შეყვანის თამაშის მნიშვნელობა თუ (bolPlay == ჭეშმარიტი) {if (intTick> = intDelay) {// შეამოწმეთ თამაშმა უნდა შეასრულოს თუ არა მორიგი ლოდინი Serial.println ("~~~~~~~ print "); // ამობეჭდვა ნიშნავს დაფის მოძრაობას // writeSerial (); // თუ ვარიანტი ჩართულია ჩაწერეთ დაფა სერიულ ღილაკებში GameGame (); // შეამოწმეთ მოთამაშის შეყვანა playBoard (); // გადაიტანეთ დაფა და დაამატეთ ახალი ფილა clearLcd (); // გაწმინდეთ LCD– ები drawBoard– ის დახატვამდე (); // დაფის დახატვა lcd's bottomCheck (); intTick = 0; // გადატვირთეთ intTick} else {buttonsGame (); // მოთამაშის შეყვანის შემოწმება clearLcd (); // გაწმინდეთ LCD– ები drawBoard– ის დახატვამდე (); // დაფის დახატვა lcd's intTick = intTick + intGameSpeed; // დამატება მონიშვნაზე}} else {clearLcd (); // გაწმინდეთ LCD- ები სათაურის დახატვამდე (); // სათაურის და ქულის ინფორმაციის ჩვენება buttonsMenu (); // მოთამაშის შესვლის წაკითხვა clearBoard (); // უზრუნველყოს მთლიანი დაფა = 0} შეფერხება (10); // არდუინოს მოკლე დროით გადადება}

// ასუფთავებს 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 ++) {// დახაზეთ კოლუმები 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); // დააყენეთ მესამე სვეტზე (ცენტრში მარჯვნივ) if (arrGame [2] == 1) {lcdRight.write ("#");} if (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 () {// გადატვირთეთ tick და დაგვიანებული მნიშვნელობები intTick = 0; intDelay = 1000; // გაიარე დაფა და ყველაფერი დააყენე 0 -ზე (int i = 0; i <= 15; i ++) {for (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 დაჭერისას ჩართეთ დაფის სერიული დაბეჭდვის გამართვის ვარიანტი if (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("Serial Board Active"); bolSerialBoard = ჭეშმარიტი; } else {Serial.println ("სერიული დაფა გამორთულია"); bolSerialBoard = ყალბი; }} // დააყენეთ თამაშის სიჩქარე მარტივ სირთულედ, თუ (intInput == 0) {Serial.print ("Game set on easy ("); Serial.print (intGameSpeedEasy); Serial.println ("ms აჩქარება)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // დააყენეთ თამაშის სიჩქარე საშუალო სირთულისთვის თუ (intInput == 1) {Serial.print ("თამაში დაყენებულია საშუალოზე" ()); Serial.print (intGameSpeedMedium); Serial.println ("ms აჩქარება)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // დააყენეთ თამაშის სიჩქარე რთულ სირთულედ, თუ (intInput == 2) {Serial.print ("Game set on hard ("); Serial.print (intGameSpeedHard); Serial.println ("ms აჩქარება)"); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

// ამოწმებს ღილაკებს და რა უნდა გააკეთოს მათთვის თამაშის დროს

void buttonsGame () {if (intInput! = 4) {// თუ ღილაკზე დაჭერილია თუ (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 ("არასწორად დაჭერილი ღილაკი"); gameOver (); // სხვაგვარად თამაში დასრულდა}}}}}

void gameOver () {

Serial.println ("თამაში დასრულდა!"); Serial.print ("შენი ქულა იყო:"); Serial.println (intScore); Serial.print ("შენი სიჩქარე იყო:"); Serial.println (intDelay); bolPlay = ყალბი; }

// ამოწმებს მოთამაშეთა შეყვანას

void input () {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 ("Enter pressed!");} if (intInput! = 4) {Serial.print ("Button Press:"); Serial.println (intInput); } else {// თუ ღილაკი არ არის დაჭერილი გადატვირთეთ bolTilePressed bolTilePressed = false; }}

// ამოწმებს დაფის ძირს წარუმატებლობისთვის

void bottomCheck () {for (int i = 0; i <= 3; i ++) {// for the 4 columns if (arrGame [15] == 1) {// თუ კრამიტი არის ქვედა სერიული.println ("კრამიტი ბოლოში"); arrGame [15] = 2; drawBoard (); დაგვიანება (400); arrGame [15] = 1; drawBoard (); დაგვიანება (400); arrGame [15] = 2; drawBoard (); დაგვიანება (400); arrGame [15] = 1; drawBoard (); დაგვიანება (400); gameOver (); }}}

// ბეჭდავს დაფას სერიულ მონიტორში, თუ 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 (""); }}}

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