Arduino სენსორული კალკულატორი: 7 ნაბიჯი

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

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

მარაგები

- არდუინო უნო

-2.4 TFT LCD ფარი (აქ ვიყიდე:

USB A to B კაბელი (კაბელი Arduino– ს კომპიუტერთან დასაკავშირებლად)

- დაინსტალირებული კომპიუტერი Arduino IDE– ით

- თქვენ ასევე უნდა გადმოწეროთ ორი ბიბლიოთეკა: MCUFRIEND_kbv და Touchscreen. პირველი შეგიძლიათ იხილოთ github– ზე (ბმული: https://github.com/prenticedavid/MCUFRIEND_kbv) ან შეგიძლიათ გამოიყენოთ ბიბლიოთეკის zip ფაილი, რომელიც ქვემოთ შევიტანე. მეორე არის Arduino ბიბლიოთეკის მენეჯერში ინსტალაციისთვის.

ნაბიჯი 1: აპარატურის კავშირები

სენსორული ეკრანის ფარი Arduino Uno– სთან არის მარტივი და სწრაფი. თქვენ მხოლოდ უნდა დაალაგოთ ყველაზე დაბალი ქინძისთავები ფარზე ყველაზე დაბალი ქინძისთავებით არდუინოზე და გადააგდოთ ფარი ქინძისთავებში. ზედა 5V პინსა და დენის მხარეს დაუნიშნავ პინზე არ უნდა იყოს ფარიდან ქინძისთავები, დაფის მეორე მხარეს იგივე პარამეტრები გამოიყენება ქინძისთავებისთვის SCL და SDA. ახლა, ჩვენ მზად ვართ კოდირებისთვის!

ნაბიჯი 2: კოდი: გლობალური განსაზღვრებები და დაყენება

#ჩართეთ

MCUFRIEND_kbv tft; // გაეროს ფარისათვის მაინცდამაინც მყარი

#ჩართეთ

#განსაზღვრეთ YP A3

#განსაზღვრეთ XM A2

#განსაზღვრეთ YM 9

#განსაზღვრეთ XP 8

TouchScreen ts = TouchScreen (XP, YP, XM, YM, 300);

#განსაზღვრეთ MINPRESSURE 10

ეს არის კოდის დასაწყისი, სადაც ჩვენ ვიყენებთ ბიბლიოთეკებს (MCUFRIEND_kbv & Touchscreen), განვსაზღვრავთ X და Y ქინძისთავებს, ვქმნით სენსორული ეკრანის პარამეტრებს და განვსაზღვრავთ მინიმალურ წნევას Arduino– სთვის მომხმარებლის პრესის რეგისტრაციისათვის.

int ID;

int user_selection;

float save_number = 0;

float term1;

int op_num;

float შედეგი;

int cursorLocX = 5;

int cursorLocY = 20;

დაყენების დაწყებამდე, ჩვენ გვჭირდება გლობალური ცვლადების დაყენება. ID ხელს უწყობს სენსორული ეკრანის ამოქმედებას. user_selection ინახავს ნომერს, რომელიც შეესაბამება იმ ღილაკს, რომელსაც მომხმარებელი ირჩევს სენსორულ ეკრანზე დაჭერისას. save_number არის ცვლადი, რომელსაც ჩვენ ვბეჭდავთ ეკრანზე მომხმარებლის შეყვანის შემდეგ (ამის შესახებ უფრო მეტი მარყუჟში). ეს არის მცურავი, ასე რომ მას შეუძლია დაიჭიროს ათობითი რიცხვები და მთელი რიცხვები. term1 არის ცვლადი, რომელშიც ტოლობის პირველი რიცხვი ინახება ოპერანდის არჩევის შემდეგ. op_num ინახავს ოპერანდს რიცხვის სახით (1 დამატებისთვის, 2 გამოკლებისთვის, 3 გამრავლებისთვის და 4 გაყოფისათვის). შედეგი არის ცვლადი, რომელიც იბეჭდება ეკრანზე მას შემდეგ, რაც მომხმარებელი დააწკაპუნებს ტოლობის ნიშანზე. ის ასევე მცურავია. cursorLocX და cursorLocY არის შეხების წერტილები სენსორულ ეკრანზე, სადაც კურსორი მრავალჯერ არის მითითებული (ის მდებარეობს ნაცრისფერ ზოლში, სხვაგვარად ცნობილია როგორც შედეგების ველი).

void setup () {

tft.reset ();

ID = tft.readID ();

tft.begin (ID);

tft.setRotation (0);

tft.fillScreen (TFT_DARKGREY);

კვადრატები ();

რიცხვები ();

tft.setTextSize (3);

tft.setTextColor (TFT_BLUE, TFT_DARKGREY);

}

ჩვენი დაყენების ფუნქცია პირველ რიგში შეიცავს სენსორული ფარის ინიციალიზაციას (სტრიქონი 1-3). ფარის ორიენტაცია დაყენებულია tft.setRotation () ბრძანების გამოყენებით, 0 კი სწორია. მთელი ეკრანი შეფერილია მუქი ნაცრისფერში tft.fillScreen () ბრძანებით, რომელსაც ჩვენ დავწერთ თავზე (გარდა შედეგების ველისა). კვადრატების () და რიცხვების () ფუნქციები ხატავს კალკულატორის კვადრატებს, შავ -თეთრ ფერს კვადრატულ შაბლონში და წერს რიცხვებს/ოპერანდებს კვადრატებზე ლურჯ ფერში. ჩვენ მივდივართ მათ შემდეგ ეტაპზე. Tft.setTextSize () ბრძანება ადგენს შედეგების ველის ტექსტის ზომას 3 -მდე, რაც საშუალო შრიფტია. Tft.setTextColor () ბრძანება ადგენს შედეგების ველის ტექსტის ფერს ლურჯად, რომელიც ჩაწერილია მუქი ნაცრისფერ ველზე.

ნაბიჯი 3: კოდი: მარყუჟი

void loop () {numberSelect ();

დაგვიანება (100);

თუ (user_selection == 16) {

;

} სხვა {

თუ (მომხმარებლის_სარჩევი <10) {

შენახული_ნომერი = შენახული_ნომერი * 10 + მომხმარებლის_სელექცია;

tft.setCursor (cursorLocX, cursorLocY);

tft.print (შენახული_ნომერი);

} else if (user_selection> 10) {

გადართვა (მომხმარებლის_სელექცია) {

შემთხვევა 11:

op_num = 1;

tft.setCursor (cursorLocX, cursorLocY);

tft.print ("+");

ვადა 1 = შენახული_ რიცხვი;

შენახული_ნომერი = 0;

შესვენება;

შემთხვევა 12:

op_num = 2;

tft.setCursor (cursorLocX, cursorLocY);

tft.print ("-");

ვადა 1 = შენახული_ რიცხვი;

შენახული_ნომერი = 0;

შესვენება;

საქმე 13:

op_num = 3;

tft.setCursor (cursorLocX, cursorLocY);

tft.print ("X");

ვადა 1 = შენახული_ რიცხვი;

შენახული_ნომერი = 0;

შესვენება;

შემთხვევა 14:

op_num = 4;

tft.setCursor (cursorLocX, cursorLocY);

tft.print ("/");

ვადა 1 = შენახული_ რიცხვი;

შენახული_ნომერი = 0;

შესვენება;

შემთხვევა 15:

შენახული_ნომერი = 0;

ტერმინი 1 = 0;

op_num = 0;

tft.setCursor (cursorLocX, cursorLocY);

tft.print ("");

შესვენება;

}

tft.setCursor (cursorLocX, cursorLocY);

ეს ბევრია საღეჭი, ამიტომ აგიხსნით რა არის ზემოთ. ჩვენ ვიწყებთ numberSelect () ფუნქციის გამოძახებით, რომელიც სენსორულ ეკრანზე თითოეულ კვადრატს ანიჭებს რიცხვს. როდესაც მომხმარებელი დააჭერს ერთ – ერთ იმ კვადრატს, ფუნქცია ადგენს user_selection ცვლადს კვადრატის რიცხვზე. პირველი if განცხადება არის მხოლოდ მარყუჟის გავლით, თუ გაკეთებულია მომხმარებლის სწორი არჩევანი. თუ ეს ასეა, მომდევნო if განცხადება ითხოვს, აქვს თუ არა user_selection 10-ზე ნაკლები რიცხვი (რიცხვები 0-9). თუ ასეა, შენახული_ რიცხვი მრავლდება 10 -ით და მომხმარებლის_სარჩევი რიცხვი ემატება შენახულ_ რიცხვს, რომელიც იბეჭდება სენსორულ ეკრანზე შედეგების ველში. თუ ეს ასე არ არის, მომდევნო if განცხადება ითხოვს, აქვს თუ არა user_selection 10 -ზე მეტი რიცხვი შენახული (ოპერანდის ნომრები: 11 + +, 12 for -, 13 X, 14 for /და 15 წმინდა ეკრანის კვადრატისთვის). გადართვის ფუნქცია ზრუნავს თითოეულ შემთხვევაზე (განსაზღვრულია მომხმარებლის_სელექციით). ცვლადი op_num მოცემულია რიცხვით, რომელიც შეესაბამება ოპერანდს, რომელიც არჩეულია (1 + -ისთვის, 2 - -, 3 X- ისთვის და 4 / / -ისთვის). შენახული_ რიცხვის მნიშვნელობა ინახება ცვლადი ტერმინი 1 ისე, რომ შენახული_ რიცხვითი ცვლადი შეიძლება გამოყენებულ იქნას განტოლების მეორე ნახევარში. ოპერანდის სიმბოლო იბეჭდება ეკრანზე, შედეგების ველში ნებისმიერი რიცხვის გასუფთავებასთან ერთად. ერთადერთი გამონაკლისი არის ეკრანის მკაფიო კვადრატი, რომელიც აღადგენს გაანგარიშების ყველა ცვლადს და ასუფთავებს შედეგების ველს მასზე.

} სხვა {

გადართვა (op_num) {

შემთხვევა 1:

შედეგი = ტერმინი 1 + შენახული_ნომერი;

tft.setCursor (cursorLocX, cursorLocY);

tft.print (ორმაგი (შედეგი));

შესვენება;

შემთხვევა 2:

შედეგი = ტერმინი 1 - შენახული_ნომერი;

tft.setCursor (cursorLocX, cursorLocY);

tft.print (ორმაგი (შედეგი));

შესვენება;

შემთხვევა 3:

შედეგი = ტერმინი 1 * შენახული_ნომერი;

tft.setCursor (cursorLocX, cursorLocY);

tft.print (ორმაგი (შედეგი));

შესვენება;

შემთხვევა 4:

შედეგი = float (term1) / float (შენახული_ნომერი);

tft.setCursor (cursorLocX, cursorLocY);

tft.print (შედეგი);

შესვენება;

}

tft.setCursor (cursorLocX, cursorLocY);

შენახული_ნომერი = შედეგი;

ტერმინი 1 = 0;

op_num = 0;

დაგვიანება (1000);

}

}

}

მარყუჟის ბოლო ნაწილი ეხება მომხმარებლის მიერ ტოლობის ნიშნის არჩევის მოვლენას (user_selection == 10). სხვა გადართვის ფუნქცია მუშაობს ოთხი მათემატიკური ფუნქციის საშუალებით (განისაზღვრება op_num). დამატების შემთხვევა (შემთხვევა 1) ამატებს ტერმინ 1 -ს და შენახულ_ რიცხვს ერთად და ინახავს რიცხვს შედეგის ცვლადში. შედეგი იბეჭდება შედეგების ველში ორმაგი. გამოკლების შემთხვევა (შემთხვევა 2) გამოაკლებს შენახულ_ რიცხვს term1- დან და ინახავს რიცხვს შედეგის ცვლადში. შედეგი იბეჭდება შედეგების ველში ორმაგი სახით. გამრავლების შემთხვევა (შემთხვევა 3) ამრავლებს ტერმინს 1 შენახული_ რიცხვით და ინახავს რიცხვს შედეგის ცვლადში. შედეგი იბეჭდება შედეგების ველში ორმაგი. გაყოფის შემთხვევა (შემთხვევა 4) ყოფს ტერმინს 1 შენახული_ რიცხვით და ინახავს რიცხვს შედეგის ცვლადში. შედეგი იბეჭდება შედეგების ველში, როგორც float (რადგან გაყოფის პასუხები შეიძლება იყოს ათობითი რიცხვები). მას შემდეგ, რაც ეკრანზე დაიბეჭდება რიცხვი, ოპერანდი ან შედეგი, კურსორი გადატვირთულია, შენახული_ რიცხვი დაყენებულია წინა შედეგზე, ხოლო term1 & op_num გადატვირთულია.

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

ნაბიჯი 4: კოდი: კვადრატების ფუნქცია

ბათილი კვადრატები () {

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

tft.fillRect (0, 60, 60, 65, TFT_BLACK); // იწყება კვადრატების პირველი რიგი, შავიდან თეთრამდე tft.fillRect (60, 60, 60, 65, TFT_WHITE);

tft.fillRect (120, 60, 60, 65, TFT_BLACK);

tft.fillRect (180, 60, 60, 65, TFT_WHITE); // მთავრდება კვადრატების პირველი რიგი

tft.fillRect (0, 125, 60, 65, TFT_WHITE); // იწყება კვადრატების მეორე რიგი, თეთრიდან შავამდე tft.fillRect (60, 125, 60, 65, TFT_BLACK);

tft.fillRect (120, 125, 60, 65, TFT_WHITE);

tft.fillRect (180, 125, 60, 65, TFT_BLACK); // მთავრდება კვადრატების მეორე რიგი

tft.fillRect (0, 190, 60, 65, TFT_BLACK); // იწყება კვადრატების მესამე რიგი, შავიდან თეთრამდე tft.fillRect (60, 190, 60, 65, TFT_WHITE);

tft.fillRect (120, 190, 60, 65, TFT_BLACK);

tft.fillRect (180, 190, 60, 65, TFT_WHITE); // მთავრდება კვადრატების მესამე რიგი

tft.fillRect (0, 255, 60, 65, TFT_WHITE); // იწყება კვადრატების მეოთხე რიგი, თეთრიდან შავამდე tft.fillRect (60, 255, 60, 65, TFT_BLACK);

tft.fillRect (120, 255, 60, 65, TFT_WHITE);

tft.fillRect (180, 255, 60, 65, TFT_BLACK); // მთავრდება კვადრატების მეოთხე რიგი

}

კვადრატების () ფუნქცია საკმაოდ მარტივია. Tft.fillRect (X1, Y1, X2, Y2, TFT_COLOR) ბრძანება ხატავს ოთხკუთხედს მასში გადატანილი პარამეტრების მიხედვით, რომლებიც არის x და y პირველი პოზიციები, x და y მეორე პოზიციები და ფერი, რომლითაც ივსება მართკუთხედი რა ეს ფუნქცია ხატავს კვადრატების ოთხივე რიგს (ტექნიკურად ოთხკუთხედებს) და ავსებს თითოეულ კვადრატს მისთვის გადაცემული ფერით.

ნაბიჯი 5: კოდი: რიცხვების ფუნქცია

ბათილი რიცხვები () {

tft.setTextColor (TFT_BLUE); // ადგენს რიცხვს/სიმბოლოს ფერს ლურჯად

tft.setTextSize (5); // ადგენს რიცხვს/სიმბოლოს ზომას 5 -მდე

tft.setCursor (18, 75); // ადგენს კურსორს რიცხვების/სიმბოლოების პირველი სტრიქონისთვის

tft.print ("7 8 9 /"); // ბეჭდავს რიცხვების/სიმბოლოების პირველ სტრიქონს

tft.setCursor (18, 140); // ადგენს კურსორს რიცხვების/სიმბოლოების მეორე ხაზისთვის

tft.print ("4 5 6 X"); // ბეჭდავს რიცხვების/სიმბოლოების მეორე სტრიქონს

tft.setCursor (18, 205); // ადგენს კურსორს რიცხვების/სიმბოლოების მესამე ხაზისთვის

tft.print ("1 2 3 -"); // ბეჭდავს რიცხვების/სიმბოლოების მესამე სტრიქონს

tft.setCursor (18, 270); // ადგენს კურსორს რიცხვების/სიმბოლოების მეოთხე ხაზისთვის

tft.print ("C 0 = +"); // ბეჭდავს რიცხვების/სიმბოლოების მეოთხე სტრიქონს

}

რიცხვების () ფუნქცია ასევე პირდაპირია. პირველი ორი სტრიქონი ადგენს ტექსტის ზომას უფრო დიდს და ფერს ლურჯად. Tft.setCursor () ბრძანება კურსორს ადგენს თითოეულ სტრიქონზე იმ პოზიციიდან, საიდანაც იწყება რიცხვების წერა. შემდეგ tft.print () ბრძანება ბეჭდავს რიცხვებს/სიმბოლოებს კვადრატებზე.

ნაბიჯი 6: კოდი: NumberSelect ფუნქცია

void numberSelect () {

TSPoint p = ts.getPoint ();

pinMode (XM, OUTPUT);

pinMode (YP, OUTPUT);

თუ (p.z> MINPRESSURE) {

p.x = რუკა (p.x, 250, 845, 0, 239);

p.y = რუკა (p.y, 245, 860, 0, 319);

თუ (შედეგი! = 0) {

შედეგი = 0;

შენახული_ნომერი = 0;

tft.print ("წმინდა ღირებულებები");

დაგვიანება (500);

tft.setCursor (cursorLocX, cursorLocY);

tft.print ("");

tft.setCursor (cursorLocX, cursorLocY);

}

NumberSelect () ფუნქციის დასაწყებად, ჩვენ ვითხოვთ მომხმარებლის შეყვანას სენსორული ეკრანიდან ts.getPoint () ბრძანებით. მას შემდეგ რაც ეს მონაცემები შეგროვდება, ჩვენ ვამოწმებთ, გადააჭარბა თუ არა მინიმალური წნევა (ან, სხვა სიტყვებით რომ ვთქვათ, მომხმარებელმა დააჭირა სადმე სენსორულ ეკრანზე). თუ ასეა, x და y კოორდინატები ასახულია კარტესული კოორდინატებიდან სენსორული ეკრანის სპეციფიკურ კოორდინატებზე. (0, 0) არის სენსორული ეკრანის ზედა მარცხენა კუთხე, სადაც x ღერძი გადის და y ღერძი ქვევით. შემდეგი ნაწილი ამოწმებს, არის თუ არა ნომერი შენახული შედეგად. თუ არსებობს, შედეგი და შენახული_ რიცხვი გადატვირთულია 0 -ზე. შეტყობინება "CLEAR VALUES" იბეჭდება შედეგების ველზე და ეკრანი იწმინდება კურსორით საწყის პოზიციაზე.

თუ (გვ. 60) {// კვადრატების პირველი რიგი

თუ (p.x <60)

მომხმარებლის_სელექცია = 7;

სხვა თუ (p.x <120)

მომხმარებლის_სელექცია = 8;

სხვა თუ (p.x <180)

მომხმარებლის_სელექცია = 9;

სხვაგან user_selection = 14;

} else if (p.y 125) {// კვადრატების მეორე რიგი

თუ (p.x <60)

მომხმარებლის_სელექცია = 4;

სხვა თუ (p.x <120)

მომხმარებლის_სელექცია = 5;

სხვა თუ (p.x <180)

მომხმარებლის_სელექცია = 6;

სხვაგან user_selection = 13;

} else if (p.y 190) {// კვადრატების მესამე რიგი

თუ (p.x <60)

მომხმარებლის_სელექცია = 1;

სხვა თუ (p.x <120)

მომხმარებლის_სელექცია = 2;

სხვა თუ (p.x <180)

მომხმარებლის_სელექცია = 3;

სხვაგან user_selection = 12;

} else if (p.y> 255) {// კვადრატების მეოთხე რიგი

თუ (p.x <60)

მომხმარებლის_სელექცია = 15;

სხვა თუ (p.x <120)

მომხმარებლის_სელექცია = 0;

სხვა თუ (p.x <180)

მომხმარებლის_სელექცია = 10;

სხვაგან user_selection = 11;

}

} სხვა {

მომხმარებლის_სელექცია = 16; // user_selection არის 16 (ცვლადი არაფერი)

}

}

ეს არის ნაწილი, რომელიც განსაზღვრავს რომელი ღილაკია არჩეული. დაწყებული კვადრატების ზედა რიგიდან და დამთავრებული ქვედა რიგით, არდუინო ეძებს იქ, სადაც რეალურად იყო დაჭერილი ეკრანი. შემდეგ ის ანიჭებს კვადრატს რიცხვს და ინახავს ამ რიცხვს მომხმარებლის_სელექციაში. რიცხვები 0-9 შეესაბამება რიცხვის კვადრატებს, რიცხვები 11-15 შეესაბამება ოპერანდის კვადრატებს და გამჭვირვალე კვადრატს, ხოლო რიცხვი 10 შეესაბამება ტოლობის ნიშნის კვადრატს. თუ კვადრატი არ არის არჩეული, მაშინ user_selection არის 16 -ზე, რაც მარყუჟს თავიდან დაიწყებს (იხ. მარყუჟის ფუნქცია).

ნაბიჯი 7: ისიამოვნეთ თქვენი დასრულებული პროექტით

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

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