პროექტი №4 – ინტერაქტიული შუქნიშანი

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

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

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

დაგვჭირდება:

1) 2 წითელი შუქდიოდი

2) ყვითელი შუქდიოდი

3) 2 მწვანე შუქდიოდი

4) 5 ცალი 150Ω და 1 ცალი 10-20კომ. წინაღობა*

5) ღილაკი **

 

* წინაღობის ზუსტი მნიშვნელობა დამოკიდებულია გამოყენებულ შუქდიოდზე. ერთი 150Ω წინაღობა კი მიერთებულია ღილაკზე და მუშაობს როგორც „მინუს“ წინაღობა (pull down resistor) ახსნილია ქვემოთ.
**ღილაკის ოთხი გამომყვანიდან ორ–ორი საერთოა. ზედა სურათზე მოყვანილ მდგომარეობაში მარცხენა ზედა და ქვედა, ასევე მარჯვენა ზედა და ქვედა.

სქემის აწყობა

ყურადღებით დააკვირდით და გამორთულ არდუინოზე ააწყვეთ სურ. 2-8-ზე მოყვანილი წრედი.
შენიშვნა: (ღილაკის წრედში მე ჩემს სქემაში გამოვიყენე 10კომ. წინაღობა.)

სურ. 2-8. ინტერაქტიული შუქნიშნის მართვის სისტემა

პროგრამული კოდი

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

ღილაკზე დაჭერის დროს, პროგრამა შეამოწმებს, გავიდა თუ არა მინიმუმ 5 წამი შუქნიშნის ბოლო ცვლილებიდან. (იმისათვის, რომ ტრანსპორტს ჰქონდეს ნორმალურად მოძრაობის საშუალება). თუ გასულია 5 წამზე მეტი, მაშინ გამოიძახება ახლად შექმნილი ფუნქცია changeLights(). ეს ფუნქცია შეცვლის შუქნიშნის ფერს შემდეგი თანმიმდევრობით: მწვანე-ყვითელი-წითელი. crossTime ცვლადში მითითებული დროის გავლის შემდეგ (რაც არის სავალი ნაწილის გადაკვეთისათვის საკმარისი დრო), ქვეითთა მწვანე შუქი დაიწყებს ციმციმს და შემდეგ ჩაქრება, რაც ნიშანია იმისა რომ ქვეითად მოსიარეულეებმა უნდა იჩქარონ რადგან მალე აინთება ამკრძალავი წითელი შუქი. ქვეითების წითელი შუქის ანთების შემდეგ, ავტოტრანპორტისათვის ანთებული შუქი შეიცვლება შემდეგი თანმიმდევრობით: წითელი-ყვითელი-მაწვანე და ტრასპორტის მოძრაობა განახლდება.

// პროექტი №4 – ინტერაქტიული შუქნიშანი
int carRed = 12;//ავტოტრანსპორტის წითელი შუქნიშნის კონტაქტი
int carYellow = 11;//ავტოტრანსპორტის ყვითელი შუქნიშნის კონტაქტი
int carGreen = 10;//ავტოტრანსპორტის მწვანე შუქნიშნის კონტაქტი 
// ქვეითად მოსიარულეთა წითელი შუქნიშნის კონტაქტი
int pedRed = 9;//ქვეითად მოსიარულეთა ყვითელი შუქნიშნის კონტაქტი
int pedGreen = 8;
int button = 2; // ღილაკის მიერთების კონტაქტის ნომერი
// გადასავლელის გადაკვეთისათვის განსაზღვრული დრო
int crossTime = 5000; // ღილაკის ბოლო დაჭერიდან გასული დრო
unsigned long changeTime; void setup() {
     pinMode(carRed, OUTPUT);
     pinMode(carYellow, OUTPUT);
     pinMode(carGreen, OUTPUT);
     pinMode(pedRed, OUTPUT);
     pinMode(pedGreen, OUTPUT);
     pinMode(button, INPUT); // ღილაკი მიეთებული 2 კონტაქტთან
     // ავტოტრანსპორტის მწვანე შუქნიშნიშნის ჩართვა     
     digitalWrite(carGreen, HIGH);     
     // ქვეითთა წითელი შუქნიშნიშნის ჩართვა
     digitalWrite(pedRed, HIGH);
}
void loop() {
     int state = digitalRead(button);
     // ღილაკზე დაჭერის შემოწმება და გასულია თუ არა
           // მინიმუმ 5 წამი ღილაკზე ბოლო დაჭერიდან
     if (state == HIGH && (millis() - changeTime) > 5000) {
         // ფუნქციის გამოძახება შუქნიშნის ფერის შესაცვლელეად
         changeLights();
     }
}

void changeLights() {
     digitalWrite(carGreen, LOW); // ტრანსპ. მწვანე გამოირთო
     digitalWrite(carYellow, HIGH); // ტრანსპ. ყვითელი ჩაირთო
     delay(2000); // დაყოვნება 2 წამი
     digitalWrite(carYellow, LOW); // ტრანსპ. ყვითელი გამოირთო
     digitalWrite(carRed, HIGH); // ტრანსპ. წითელი ჩაირთო     
     delay(1000); // 1 წმ დაყოვნება უსაფრთხოებისათვის
     // ქვეითთა წითელი შუქნიშანი გამოირთო 
     digitalWrite(pedRed, LOW); 
     digitalWrite(pedGreen, HIGH); // ქვეითთა მწვანე აინთო
     // დაყოვნება გასაზღვრული crossTime-ით დროით
     delay(crossTime); 
     // ქვეითთა მწვანე შუქის ციმციმი 10ჯერ     
     for (int x=0; x<10; x++){
           digitalWrite(pedGreen, HIGH); // ქვეითთა მწვანე აინთო
           delay(250);//2,5 წმ დაყოვნება
           digitalWrite(pedGreen, LOW); // ქვეითთა მწვანე ჩაქრა
           delay(250); // 0,25წმ დაყოვნება
      }    digitalWrite(pedRed, HIGH); // ქვეითთა წითელი ჩაირთო    
    delay(500); // 0,5წმ დაყოვნება
     digitalWrite(carYellow, HIGH); // ტრანსპ. ყვითელი ჩაირთო
     digitalWrite(carRed, LOW); // ტრანსპ. წითელი გამოირთო    
    delay(1000);//1წმ დაყოვნება
     digitalWrite(carGreen, HIGH);//ტრანსპ. მწვანე აინთო    
    digitalWrite(carYellow, LOW); // ტრანსპ. ყვითელი გამოირთო
   //შუქნიშნის ბოლო ცვლელების შემდეგ გასული დროის დამახსოვრება
    changeTime = millis();
    // პროგრამის მთავარ ცილში დაბრუნება

}

კოდის განხილვა

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

unsigned long changeTime;

ეს არის ცვლადის ახალი ტიპი. წინა პროექტებში ჩვენ შევხვდით მთელი ტიპის (integer) ცვლადს, რომელსაც შეუძლია მიიღოს მნიშვნელობები [-32768, 32767] არეში. ახალი ცვლადის ტიპი კი არის longდიდი, რომელიც გასაღვრულია შემდეგ არეში: [-2147483648, 2147483647]. მაგრამ მას ახლავს კიდევ ერთი გასაზღვრება unsigned long არაუარყოფითი დიდი, (ქართული ტერმინების სიწორეზე თავს ვერ დავდებ, მაგრამ შინაარსი გასაგები უნდა იყოს) რომლის მნიშვნელობების არეა [0, 4294967295]. ამ პროქტში შუქნიშნიშნის ბოლო შეცვლიდან გასული დროის შესანახად რომ გამოგვეყენებინა integer ტიპის ცვლადი, მაშინ ამ ტიპის ცვლადი შეინახავდა მაქსიმუმ 32წამს.

ცხადია, რომ ქვეითად მოსიარულენი 32წამის პერიდულობით არ კვეთენ გზის სავალ ნაწილს, და ისიც ცხადია, რომ არ გვინდა ჩვენი პროგრამა ”ჩამოეკიდოს” ცვლადისთვის გამოყოფილი მახსოვრობის ”შევსების” გამო. რაც მოხდება მაშინ როდესაც პროგრამა შეეცდება შეინახოს დასაშვებზე (integer) დიდი მნიშვნელობა. ამიტომ ღილაკის ორ დაჭერას შორის გასული დროის დასამახსოვრებლად უნდა გამოვიყენოთ unsigned long ტიპის ცვლადი:

4294967295 x 1მლწმ ≈ 4294967 წმ

4294967წმ ≈ 71582წთ

71582წთ ≈ 1193სთ

1193სთ ≈ 49დღე

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

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

Atmega168 აქვს მხოლოდ 1Kb (1000 ბაიტი) და Atmega328 2Kb (2000 ბაიტი) (SRAM, static random access memory) მახსოვრობა, რას არ ისე დიდია. დიდ პროგრამებში სადაც გამოყენებულია უამრავი ცვლადი, თუ ცვალდების გვარობა წინასწარ არ არის ოპტიმიზირებული ადვილად შეიძლება მახსოვრობის მთლიანად შევსება. მაგალითად შეგვილია განვიხილოთ ისევ ჩვენი პროექტები. ჩვენ ყველგან ვიყენებთ int(2 ბაიტი, ზედა ზღვარი 32767) კონტაქტის ნომრის აღმნიშვნელი ცვლადის შესანახად. Arduino Uno–ს შემთხვაში კონტაქტების რაოდენობა არის 13, ხოლო Arduino Mega–ს შემთხვევაში კი 54. ე.ი. ჩვენ ვიყენებთ იმაზე მეტ მახსოვრობას ვიდრე ეს სინამდვილეში არსი საჭირო.უკეთესია დავზოგოთ მახსოვრობა და ამ ცვლადებისთვის გამოვიყენოთ byte ტიპი(1ბაიტი, ზედა ზღვარი 255), თუმცა ეს მაინც მეტია ვიდრე I/O (შემავალი/გამომავალი) კონტაქტების (pin) რაოდენობა.

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

ცხრილი 2-2. ცვლადების ტიპები.

დავუბრუნდეთ ისევ კოდს და განვიხილოთ:

pinMode(button, INPUT);

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

int state = digitalRead(button);

აქ განსაზღვრულია integer ტიპის ცვლადი (როგორც ზემოთ ავღნიშნეთ, მახსოვრობის დაზოგვის მიზნით უმჯობესი იქნებოდა გამოგვეყენებინა  byte ტიპის ცვლადი) სახელად state და მას მინიჭება მე–2 ციფრული კონტაქტის მდგომარეობის შესაბამისი მნიშვნელობა. ხოლო digitalRead განსაზღვრება კითხულობს ფრჩხილებში ჩაწერილი ღილაკის მდგომარეობას და უკან გვიბრუნებს ამ მნიშნელობას state ცვლადის სახით. ამის შემდეგ if-ის საშუალებით ვამოწმებთთ stateისმნიშვნელობას იმისათვის, რომ გავიგოთ დააჭირა ღილაკს ვინმემ თუ არა.

if (state == HIGH && (millis() – changeTime) > 5000)
{
// ფუნქციის გამოძახება შუქნიშნის ფერის შესაცვლელეად
changeLights();

}

if დანიშნულებაა შეამოწმოს რაღაც პირობის შესრულება. თუ პირობის შედეგი ჭეშმარიტია მაშინ შეასრულოს {……} ბლოკში მოთავსებული კოდი. მაგალითად თუ გვინდა რომ შუქდიოდი აინთოს მაშინ როდესაც x გახდება 500–ზე მეტი, შეგვიძლია დავწეროთ შემდეგი:

if (x>500) {
digitalWrite(ledPin, HIGH);

digitalRead–ის საშუალებით კონტაქტის შემოწმების დროს, კონტაქტის მდგომარეობა შეიძლება იყოს HIGH ანLOW.

დავუბრუნდეთ ისევჩვენს if ბრძანებას:

if (state == HIGH && (millis() – changeTime) > 5000)

ამ კონსტრუქციაში მოწმდება (ლოგიკური ბრძანების && ანუ AND საშუალებით)ორი პირობის შესრულება. პიველი: არის თუ არა ცვალდი სახელად state ტოლი high. თუ ღილაკი დაჭერილია მაშინ state იქნება HIGH. ხოლო მისი მნიშვნელობის აღება ხდება მე–2 ციფრული კონტაქტის მდგომარეობიდან. მეორე: მოწმდება არის თუ არა millis()changeTime სხვაობა მეტი 5000–ზე. millis() არის არდუინოში „ქარხნულად ჩაწერილი“ ერთ–ერთი ფუნქცია, რომელიც იძლევა/აბრუნებს არდუინოზე გაშვებული პროგრამის დასაწყისიდან გასულ დროს მილიწამებში. თავიდან changeTime ცვლადს არ აქვს მინიჭებულია არავითარი სიდიდე. changeLights ფუნქციის გაშვების და მისი მოქმედების დამთავრების შემდეგ, ამ millis()–ს მიენიჭება ახალი მნიშვნელობა.

changeTime ცვლადის და millis()ის მიმდინარე მნიშნელობების სხვაობით დავადგენთ გავიდა თუ არა მინიმუმ 5 წამი changeTime–ის ბოლო გამოძახებიდან. საბოლოოდ millis()changeTimeსხვაობა და state–ის მნიშვნელობა ჩაისმება if-ის ფრჩხილებში, რომ შემოწმდეს მასში მოცემული ორივე პირობის ერთდროული შესრულებ.

სიმბოლო && რომელიც მოცემულია state == HIGH ტოლობასა და სხვაობას შორის არის ბულის ერთ–ერთი ლოგიკური ოპერატორი და ნიშნავს და–ს(AND). ბულის ზოგიერთი სხვა ოპერატორებია:

&&ლოგიკური და (AND)

||ლოგიკური ან (OR)
!ლოგიკური უარყოფა, არა (NOT)

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

&& ოპერატორის მოქმედების შედეგი არის ჭეშმარიტი(True) თუ ორივე ოპერატორი არის ჭეშმარიტი. მაგ. შემდეგი if კონსრუქცია შეასრულებს {–ის შემდეგ მოთავსებულ კოდს თუ x უდრის 5 და y უდრის 10:

if (x==5 && y==10) {. . . . .

|| არის ჭეშმარიტი თუ ერთ–ერთ ოპერატორი მაინც არის ჭერშმარიტი, მაგ. შემდეგი if კონსრუქცია შეასრულებს {–ის შემდეგ მოთავსებულ კოდს თუ ან x უდრის 5 ან y უდრის 10:

if (x==5 || y==10) {. . . . .

! ანუ NOT არის შეშმარიტი თუ მისი ოპერატორი მცდარია და პირიქით. მაგ. შემდეგი if კონსრუქცია შეასრულებს {–ის შემდეგ მოთავსებულ კოდს თუ x არის მცდარი, ანუ ტოლია ნულის:

if (!x) {

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

if (x==5 && (y==10 || z==25)) {

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

ცხრილი 2–3. (x==5 && (y==10 || z==25)) პირობის ჭეშმარიტების ცხრილი.

x

y

z

True/False?

4

9

25

FALSE

5

10

24

TRUE

7

10

25

FALSE

5

10

25

TRUE

ჩვენს მიერ განხილულ if კონსტრუქციაში ბოლო განსაზღვრება არის

changeLights();

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

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

ჩვენ შემთხვევაში თუ სრულდება if–ში მოცემული პირობა მაშინ პროგრამის მსვლელობა გადერთვება ფუნქციის შესრულებაზე და მისი დამთავრების შემდეგ დაბრუნდება უკან და ისევ გააგრძელებს პროგრამული კოდის შესრულებას changeLights()–ის შემდეგ მოთავსებული სტრიქონიდან.

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

პროგრამის მთავარი ციკლი (loop) მუდმივად აკონტროლებს ჩაირთო თუ არა ღილაკი და თუ ჩაირთო არის თუ არა ჭეშმარიტი (&&) ოპერატორით განსაზღვრული პირობა, ანუ გავიდა თუ არა 5 წამზე მეტი ღილაკის ბოლო დაჭერიდან და თუ გავიდა ისევ მოხდება changeLights() ფუნქციის გამოძახება და ა.შ………

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

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

სქემის მოკლე მიმოხილვა

ახალი ელემენტი რომელიც პირველად ამ პროექტში გამოჩნდა არის ღილაკი. როგორც სქემიდა ჩანს ღილაკი პირდაპირ არ არის ჩართული კვების დადებით და შემავალ კონტაქტებს შორის, არამედ ღილაკის ერთ-ერთ კონტაქტი წინაღობის გავლით ზის მინუსზე/მიწაზე/კორპუსზე. ასეთნაირად ჩართულ წინაღობას ეწოდება (pull-down resistor, стягивающий резистор)”მინუს-წინაღობა” (პირობითად ასე ვთარგმნე რადგან შესაბამისი ქართული ტერმინი ჩემთვის უცნობია). ეს წინაღობა აუცილებელია ღილაკის გამართულად მუშაობისათვის.
თუ რატომ, ამისათვის მოკლედ განვიხილოთ წინაღობის ჩართვის ორი ვარიანტი ”პლუს წინაღობა” (
pull-up resistor, подтягивающий резистор)და ”მინუს-წინაღობა”( pull-down resistor, стягивающий резистор).

ლოგიკური მდგომარეობები

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

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

სურ. 2-9.

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

სურ. 2-10. pull-down

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

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

სურ. 2-11. pull-up

აქაც გამოიყენება მაღალი ნომინალის რეზიტორი. რომელიც ღილაკის ჩართვის დროს ამცირებს დანაკარგებს. (აუცილებელია ღინიშნოს, რომ მოცემული pull-up სქემა მეტად გავრცელებულია, ვიდრე pull-down, რადგან მიკროკონტროლერის შემავალ კონტაქტზე პირდაპირ დატვირთვის გარეშე მაქსიმალური ძაბვის მიწოდება არ არის რეკომენდირებული, როგორც ეს pull-down-ის შემთხვევაში ხდება)

არდუინოს შიდა პლუს–წინაღობები

არდუინოს აქვს საკუთარი, ციფრულ და ანალოგურ კონტაქტებთან მიერთებული შიდა პლუს–20კომ სიდიდის წინაღობები. ამ წინაღობების გააქტიურება ხდება პროგრამულად, ამისათვის საჭიროა შესაბამისი კონტაქტის pinMode–ს გადაყვიყვანოთINPUT მდგომარეობაში და შემდეგ digitalWrite ბრძანებით გადავიყვანოთ HIGH მდგომარეობაში:

pinMode(pin, INPUT); 
digitalWrite(pin, HIGH);

შიდა პლუს–წინაღობების გააქტიურების შემდეგ თუ კონტაქტის pinMode–ს გადავიყვანთ INPUT–დან OUTPUT–ში, კონტაქტებია დარჩებიან HIGH მდგომარეობაში და პირიქით. გამომავალი კონტაქტის (output pin) რომელიც იყო HIGH მდგომარეობაში და გადაყვანილი იქნა INPUT–ში, პლუს წინაღობები დარჩებიან გააქტიურებულები.

2 Responses to პროექტი №4 – ინტერაქტიული შუქნიშანი

  1. scienceasm says:

    წიგნის თარგმანი ქვეყნდება forum.ge – ზე Hinkalino-ს მიერ.
    დამატებითი შეკითხვები თემაში
    ==========================================
    “Arduino ს ინტერფეისი”
    ==========================================
    http://forum.ge/?f=48&showtopic=34393677

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

%d bloggers like this: