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

August 18, 2012

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

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

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

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

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–ში, პლუს წინაღობები დარჩებიან გააქტიურებულები.

Advertisements

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

August 18, 2012

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

ამ გაკვეთილისთვის საჭიროა:

 1) სამაკეტო დაფა

 

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

 

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

 

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

5) 3 ცალი 150Ω წინაღობა*

6) სამონტაჟო მავთულები

*წინაღობის ზუსტი მნიშვნელობა დამოკიდებულია გამოყენებულ შუქდიოდზე.

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

ყურადღებით დააკვირდით და ააწყვეთ სურ. 2-6-ზე მოყვანილი წრედი. ამ წრედში შუქდიოდების ანოდები მიერთებულია არდუინოს შესაბამის ციფრულ კონტაქტებთან 8, 9 და 10.ხოლო კათოდები კი 150Ωწინაღობების გავლით მიწაზე, კორპუსზე, მინუსზე.

სურ. 2-6.შუქნიშნიშნის წრედი

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

კოდის შეყვანა.

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

// პროექტი №3 -შუქნიშანი.
int ledDelay = 10000; // 10 წმ შეყოვნება გადართვებს შორის
int redPin = 10;
int yellowPin = 9;
int greenPin = 8;
void setup() {
     pinMode(redPin, OUTPUT); 
     pinMode(yellowPin, OUTPUT); 
     pinMode(greenPin, OUTPUT);
}
void loop() {
     digitalWrite(redPin, HIGH); // წითელი შუქდიოდის ჩართვა 
     delay(ledDelay); // 10წმ დაყოვნება
          digitalWrite(yelloWPin, HIGH); // ყვითელი შუქდიოდის ჩართვა
          delay(2000); // 2წმ დაყოვნება
          digitalWrite(greenPin, HIGH); // მწვანე შუქდიოდის ჩართვა
     digitalWrite(redPin, LOW); // წითელი შუქდიოდის გამორთვა
     digitalWrite(yellowPin, LOW); // ყვითელი შუქდიოდის გამორთვა
     delay(ledDelay); // დაყოვნება ledDelay მლწმ-ით (იხ. კოდის დასაწყისი)
          digitalWrite(yellowPin, HIGH); // ყვითელი შუქდიოდის ჩართვა
     digitalWrite(greenPin, LOW); // მწვანე შუქდიოდის გამორთვა
          delay(2000); // 2წმ დაყოვნება
          digitalWrite(yellowPin, LOW); // ყვითელი შუქდიოდის გამორთვა
          // ამის შემდეგ ციკლი იყწება თავიდან
}

სურ. 2-7.დიდ ბრიტანეში მიღებული შუქნიშნის მუშაობის თანმიმდევრობა.


პროექტი №2 – მორზეს S.O.S. სიგნალის ციმციმა.

August 18, 2012

ამ პროექტისთვის გამოიყენება პირველ გაკვეთილში აღწერილი სქემა, ამიტომ მას ხელმეორედ აღარ განვიხილავთ. დისკრეტული ელექტრონიკისგან გასხვავებით მიკროპროცესორის გამოყენებისას ხშირად საკმარისია მხოლოდ პროგრამული კოდის შეცვლა და არ არის საჭირო ახალი სქემის აწყობა. რაც მიკროპროცესორების ერთ–ერთი ძლიერი და საინტერესო უპირატესობაა. ეს პროექტიც ამის ნათელი დადასტურებაა. მაგრამ დისკრეტული ელექტრონიკის, გნებავთ კლასიკური ელექტრონიკის, საფუძვლების შესაწავლა აუცილებელია და დიდად მომგებიანია შემდგომი მუშაობისათვის. აღარ დავიწყებ იმის ახსნას თუ რას წარმოადგენს მორზეს კოდი. ვიტყვი მხოლოდ ერთს, რომ S.O.S. სიგნალი შედგება სამი მოკლე, სამი გრძელი და ისევ სამი მოკლეს იმპულსისაგან: (… – – – …).

გახსენით არდუინოს IDE და აკრიფეთ ქვემოთ მოყვანილი კოდი:

//შუქდიოდი შეერთებულია მე–10 კონტაქტთან
int ledPin = 10;
//გაეშვება ერთჯერ, sketch–ის სტარტისას
void setup(){
      //განსაზღვრავს გამომავალ კონტაქტს
     pinMode(ledPin, OUTPUT);
}
// მუშაობს ციკლი 
void loop(){
     // 3 წერტილი
     for (int x=0; x<3; x++) {
         digitalWrite(ledPin, HIGH); // ჩართავს შუქდიოდს         delay(150); //იცდის 0,15წმ
         digitalWrite(ledPin, LOW); //გამორთავს შუქდიოდს
         delay(100); //იცდის 0,1წმ
     }
     // 0,1წმ დაყოვნება წერტილებს და ტირეებს შორის
     delay(100);
     // 3 ტირე 
     for (int x=0; x<3; x++) {
         digitalWrite(ledPin, HIGH); // ჩართავს შუქდიოდს
          delay(400); // იცდის 0,4წმ
                  digitalWrite(ledPin, LOW); // გამორთავს შუქდიოდს 
         delay(100); // იცდის0,1წმ
     }
     // 0,1წმ დაყოვნება ტირეებს და წერტილებს შორის
     delay(100);
      // ისევ 3 წერტილი
     for (int x=0; x<3; x++) {
         digitalWrite(ledPin, HIGH); //ჩართავს შუქდიოდს
         delay(150); //იცდის 0,15წმ
         digitalWrite(ledPin, LOW); //გამორთავს შუქდიოდს
         delay(100); // იცდის 0,1წმ
     }
     // 5 წამიანი დაყოვნება SOS სინალის განმეორებამდე, 
     //ამ სიგნალების ერთმანეთისაგან უკეთ გარჩევისათვის
     delay(5000);
}

შეამოწმეთ კოდი და ჩატვირთეთ არდუინოში (იხ. შესავალში). შუქდიოდი დაიწყებს SOS სიგალის შესაბამისად ციმციმს.                 ამ (… – – – …) ერთი ციკლის დამთავრების შემდეგ გააკეთებს 5 წამიან პაუზას და ისევ გაუშვებს ციკლს უსასრულოდ მანამ, სანამ არდუინოს მიეწოდება დენი. კოდის ჩატვირთვის შემდეგ შეგიძლიათ მოხსნათ USB კაბელი და არდუინოს მიაწოდოთ გარეთა კვება ან 9ვ ბატარიდან ან დამატებითი 9ვ კვების ბლოკიდან. არდუინოს სამუშაო ძაბვაა 5–12 ვ, ოპტიმალურია 9ვ.

სურ. არდუინოს გარეთა კვების წყაროს ვარიანტები. შტეკერის შიდა დიამეტი 2,1მმ. ადაპტერიდან გამომავალი ძაბვა 9, დენი 1ა. ხოლო ცენტრალური კონტაქტი ”+”. პირველ რიგში მოცემული შეგიძლიათ შეუკვეთოთ ebay.com-ზე. ხოლო მეორე რიგში მოცემული მაღაზია DAC-ში.

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

კოდის გარჩევა

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

პირველ ბლოკი იძლევა სინათლის სამ მოკლე იმპულს.

for (int x=0; x<3; x++) {
    digitalWrite(ledPin, HIGH); 
    delay(150);
    digitalWrite(ledPin, LOW); 
    delay(100);
}

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

ამას აკეთებს for ციკლი:

for (int x=0; x<3; x++) {

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

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

int x=0;

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

x<3;

ჩვენს ჩემთხვევაში for ციკლი შესრულდება მანამ სანამ x ნაკლებია (<) 3–ზე.

ამ სიმბოლოს < ზოგადად ეწოდება შედარების ოპერატორი. შედარების ოპერატორებია:

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

!= (არ უდრის)

< (ნაკლებია)

> (მეტია)

<= (ნაკლებია ან ტოლი)

>= (მეტია ან ტოლი)

ბოლო განსაღვრება არის ზრდა, ინკრემენტი:

x++

რაც ნიშნავს, რომ x უნდა გაიზარდოს ბიჯით 1. ეს შეიძლeბა ასეც დაიწეროს x = x + 1, რაც ნიშნაცს, რომ x–ს მიენიჭოს მის უკვე არსებულ მნიშვნელობას მიმატებული 1. for ციკლის შემდეგ წერტილ-მძიმეს დასმა საჭირო არ არის.

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

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


პროექტი №1 მოციმციმე შუქდიოდი (LED Flasher)

August 16, 2012

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

პროექტი  №1 – მოციმციმე შუქდიოდი (LED Flasher)

ამ პროექტში გამეორებულია იგივე ეფექტი რაც იყო მოცემული შესავალ ნაწილში არდუინოს შემოწმების დროს. მაგრამ იმ განსხვავებით, რომ არდუინოზე დამონტაჟებული №13 შუქდიოდის ნაცვლად გამოყენებულია არდუინოს ერთ-ერთი ციფრულ კონტაქტზე მიერთებული გარეთა შუქდიოდი.გავეცნობით სამოტაჟო დაფაზე სქემის აწყობას, ელექტრონიკის და კოდირების ანუ პროგრამირების(C-ს ვარიანტი) საწყისებს.

ამ გაკვეთილისთვის დაგჭირდება შემდეგი: (იხ. აგრეთვე დამატებითი ინფორმაცია გაკვეთილის ბოლოს)

სამონტაჟო-სამაკეტო დაფა:

შუქდიოდი 5მმ დიამეტრი.

წინაღობა*100Ω r.

სამონტაჟო მავთულები.

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

განხილული პროექტების უმრავლესობისათვის გამოყენებულია 840 ნახვრეტიანი სამონტაჟო-სამაკეტო დაფა(სურ.2-6.), ზომით 16,5×5,5 სმ. ამ დაფას გვერდებზე აქვს ბუდეები და ნაწიბურები, რომლებიც გამოიყენება რამდენიმე დაფის ერთმანეთზე შესაერთებლად, ხოლო დაფას ქვემოდან მიმაგრებული აქვს წებოვანი ლენტი, რაიმე ზედაპირზე მისამაგრებლად. სამონტაჟო დაფა ასევე შეგიძლიათ გამოიყენოთ სხვა სქემების აწყობა-მოდელირებისათვის. შუქდიოდი სასურველია იყოს პატარა, 5მმ დიამეტრის(რადგან არ მოიხმარს დიდ დენს) ნებისმიერი ფერის. აუცილებლად დაგჭირდებათ გამოყენებული შუქდიოდის შემდეგი მახასიათებლები ”პირდაპირი დენი” და ”ძაბვის ვარდნა”, რომელთა საშუალებით გამოითვლება(მოცემულია ქვემოთ) დენის შემზღუდავი, ”ბალასტური” წინაღობის სიდიდე. (ნებისმიერი ელექტრო დეტალის მახასიათებლების(datasheet) მოძიება შეიძლება ინტერნეტში). სამონტაჟო მავთულებად შეგიძლიათ გამოიყენოთ სხვადასხვა სიგრძის უკვე გამზადებული ფერადი გამტარები სპეციალური ბოლოებით(სურ.2-7) ან მის გარეშე(სურ.2-9). ხოლო ყველაზე იაფი და მარტივი გამოსავალია შეიძინოთ ორი-სამი ფერის 22awg (ცხრილი.2-2) სამონტაჟო მავთულის(სურ.2-8) გორგალი, გადაჭრათ საჭირო ზომაზე და მოაცილოთ იზოლაცია 6მმ-ზე, სპეციალური ინსტრუმენტით (სურ.2-10 და 2-11).

საჭირო ინსტრუმენტების ოპტიმალური ნაკრები შეგიძლიათ იხილოთ ამ საიტზე: http://www.ladyada.net/library/equipt/kits.html#basic

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

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

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

შეამოწმეთ, რომ შუქდიოდის ანოდი, მისი გრძელი ფეხი მიერთებულია №10 ციფრულ კონტაქტთან(Digital Pin 10). შუქდიოდის გრძელი ფეხი არის ანოდი და ყოველთვის უნდა მიუერთდეს +5ვოლტს. მოკლე ფეხი არის კათოდი და ყოველთვის უნდა შეუერთდეს ”მიწას” Gnd. სადმე +5ვოლტს, შუქ დიოდსა და მიწას შორის აუცილებლად მიდევრებით უნდა ჩაირთოს დენის შემზღუდავი, ”ბალასტი” წინაღობა. კათოდთან კორპუსის ქვედა ნაწილი არის ბრტყელი. სურ. 2-5.

თუ დარწმუნებული ხართ, რომ ყველა შეერთებები სწორია შეაერთეთ USB კაბელი.

 

სურ. 2-1. პირველი პროექტის შეერთების ესკიზი.

კოდის შეყვანა

გახსენით არდუინოს IDE აკრიფეთ ქვემოთ მოცემული კოდი(Listing 2-1.)

Listing 2-1. Code for Project 1

// Project 1 – LED Flasher
int ledPin = 10;
void setup() {
             pinMode(ledPin, OUTPUT);
}
void loop() {
            digitalWrite(ledPin, HIGH); delay(1000);
            digitalWrite(ledPin, LOW); delay(1000);
}

დააჭირეთ IDE ზედა ნაწილში განლაგებულ Verify/Compile ღილაკს აკრეფილი კოდის შესამოწმებლად. თუ კოდი სწორია, მაშინ დააჭირეთ Upload ღილაკს და კოდი ჩაიტვირთება არდუინოში. თუ ყველაფერი უშეცდომოდ გააკეთეთ მაშინ შუქდიოდი დაიწებს ერთ წამიან ნათებას ერთი წამიანი ინტერვალით.

პროექტი №1-მოციმციმე შუქდიოდი – კოდის განხილვა

კოდის პირველი სტრიქონია:
// Project 1 - LED Flasher int

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

/* ყველაფერი დახრილიხაზის და ფიფქის შემდეგ არის კომენტარი და იგნორირებული იქნება კომპილატორის მიერ, შემდეგი ფიფქსა და დახრილი ხაზის გამოჩენამდე */

IDE ავტომატურად გადაიყვანს კომენტარის ტექსტს ნაცრისფერში.

შემდეგი სტრიქონის არის

int ledPin = 10;

ეს არის ცვლადი (variable). მისი დანიშნულებაა მონაცემის შენახვა. აქ ცვლადის ტიპი არის მთელი int (integer). მთელს შიძლება მიენიჭოს მნიშვნელობები -32768 დან 32767 მდე. შემდეგ, მთელი ტიპის ცვლადს მინიჭებული აქვს სახელი ledPin და მისი მნიშვნელობა არის 10. ცვლადისთვის სახელის შერჩევაში არ ვართ შეზღუდული და არ არის აუცილებელი, რომ გამოვიყენოთ სახელი ledPin. მაგრამ მოსახერხებელია როდესაც ცვლადის სახელი ასახავს იმ დანიშნულებას რისთვისაც ის შემოგვყავს პროგრამაში. ჩვენს შემთხვევაში გამოყენებული ledPin ნიშნავს, რომ საქმე გვაქვს შუქდიოდთან (led), რომელიც შეერთებული კონტაქტთან (Pin) და გამოყენებული ციფრული კონტაქტის ნომერია 10. სტრიქონის ბოლოში დგას წერტილ-მძიმე. რაც მიუთითებს კომპილატორს, რომ ჩვენს მიერ შედგენილი განსაზღვრება დასრულებულია.

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

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

საბოლოოდ, მას იმიტომაც დაერქვა ცვლადი, რომ შეიძლება მისი მნიშვნელობის შეცვლა.

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

შემდეგ სტრიქონში არის setup() ფუნქცია:

void setup() {
         pinMode(ledPin, OUTPUT);
}

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

void setup()

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

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

int myFunc(int x, int y)

პირობითად მისი სახელია: myFunc. მას გადაეცა ორი მთელი ტიპის პარამეტრი(არგუმენტი, სიდიდე) სახელად x და y. შემდგომ ფუნქციამ იმუშავა, იმუშავა და საბოლოოდ დაგვიბრუნა პასუხი, მნიშვნელობა მთელი ტიპის. თანაც ჩასვა იმ ადგილზე საიდანაც იყო გამოძახებული. ამ შემთხვევაში int-ის შემდეგ.

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

void setup() {
     pinMode(ledPin, OUTPUT);
}

ეს setup ფუნქცია იძლევა მხოლოდ ერთ მითითებას. ეს მითითება არის pinMode, რაც ეუბნება არდუინოს, რომ ჩვენ გვინდა კონტაქტმა (pin) რომლის სახელია ledPin იმუშაოს სიგნალის გამოყვანის ანუ გამოსვლის(OUTPUT) რეჟიმში(mode). როგორც ვიცით ფუნქცია setupმდე ledPin-ს მივანიჭეთ 10.საბოლოოდ ზემოთ მოყვანილი გამარტება მიუთითებს არდუინოს, რომ ციფრულმა კონტაქტმა №10 უნდა იმუშაოს სიგნალის გამოსვლის რეჟიმში.რადგან setup() ფუნქცია გაეშვება ერთხელ, შემდეგ არდუინო იწყებს მთავარი ციკლის, loop ფუნქციის შესრულებას:

void loop() {
     digitalWrite(ledPin, HIGH);
     delay(1000);
     digitalWrite(ledPin, LOW);
     delay(1000);
}

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

ამ პროგრამის შესრულებისას შუქდიოდი ჩაირთვება ერთი წამით, შემდეგ გამოირთვება ერთი წამით და ეს ჩართვა-გამორთვა განმეორდება თავიდან.
განვიხილოთ
loop() ფუნქციაში მოთავსებული ბრძანებები. პირველი ბრძანებაა:

digitalWrite(ledPin, HIGH);

ამ ბრძანებით ledPin რომლის ნომერი არის 10 მიენიჭება მნიშვნელობა HIGH(ან გნებავთ გადადის მდგომარება HIGH-ში), რაც ნიშნავს +5ვოლტის მიწოდებას. შუქდიოდი აინთება. შემდეგი ბრძანებაა:

delay(1000);

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

digitalWrite(ledPin, LOW);

ამ ბრძანებით ledPinმიენიჭება მნიშვნელობა LOW, რაც ნიშნავს მე-10 ციფრული კონტაქტიდან ძაბვის გამორთვას და შესაბამისად შუქდიოდიც ჩაქრება. შემდეგ ისევ იქნება 1 წამიანი დაყოვნება და შუქდიოდი ამ 1 წამის განმავლობაში ჩამქრალია. მაგრამ რადგან loop() არის ციკლური ფუნქცია ყველაფერი ისევ დაიწყება თავიდან.

ახლა უკვე შეგვიძლია ისევ გადავხედოთ ჩვენს პროგრამას, სტრიქონ-სტრიქონ გავიაროთ ზემოდან ქვემოთ და თვალნათლივ წარმოვიდგინოთ მისი მოქმედება და შესაბამისად არდუინოს მუშაობა:

// Project 1 - LED Flasher 
int ledPin = 10;
void setup() {
     pinMode(ledPin, OUTPUT);
}
void loop() {
     digitalWrite(ledPin, HIGH); 
     delay(1000);
     digitalWrite(ledPin, LOW); 
     delay(1000);
}

შემოგვაქვს მთელი ცვლადი და ვარქმევთ მას ledPin, ვანიჭებთ მნიშვნელობას 10. შემდეგ გადავდივართ setup() ფუნქციაში, სადაც მე-10 ციფრულ კონტაქტს ვაყენებთ გამოსვლის რეჟიმში. პროგრამის მთავარ ციკლში მე-10 კონტაქტზე ვაგზავნით +5ვ. შემდეგ ველოდებით 1 წამს და გამოვრთავთ +5ვოლტს. ისევ ვიცდით 1 წამს. შემდეგ კი ციკლი გადადის საწყის მდგომარეობაში და ყველაფერი მეორდება თავიდან. და როგორც ზემოთ აღვნიშნეთ ასე განმეორდება მანამ, სანამ არდუინოს მიეწოდება დენი.

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

მაგალითად: შუქდიოდი ანთია 2 წამის განმავლობაში, ხოლო ჩამქრალია ნახევარი წამის ხანგრძლივობით. შესაბამისი კოდი:

void loop() {
     digitalWrite(ledPin, HIGH); delay(2000);
     digitalWrite(ledPin, LOW); delay(500);
}

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

void loop() {
     digitalWrite(ledPin, HIGH);
     delay(250);
     digitalWrite(ledPin, LOW); 
     delay(5000);
}

ამ კოდის შესაბამისად კი შუქდიოდი სწრაფად ციმციმებს:

void loop() {
     digitalWrite(ledPin, HIGH);
     delay(50);
     digitalWrite(ledPin, LOW);
     delay(50);
}

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

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

სურ. 2-2. სამაკეტო-სამონტაჟო დაფაში გამტარების განლაგება.

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

სურ. 2-3. მიკროსქემის გამომყვანების განლაგებაა სამონტაჟო დაფის ნახვრეტებში.

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

ჩვენს შემთხვევაში არდუინოს №10 ციფრული კონტაქტი იძლევა მუდმივ +5ვოლტს, გამომავალი დენის მაქსიმალური მნიშვნელობა კი შეიძლება იყოს 40მა(mA) (მილიამპერი). ამ პროექტში გამოყენებული შუქდიოდისთვის კი საჭიროა 2და მაქსიმუმ 35მა (ამიტომ იყო არჩეული პროექტის დასაწყისში, მცირე ზომის შუქ დიოდი). ამისთვის საჭიროა 5ვ ჩამოყვანა 2ვ-მდე და დენის ძალის შემცირება 40მა-დან 35მა-მდე. თუ გვინდა, რომ შუქ დიოდმა სრულად არ იკაშკაშოს მაშინ დენის ძალა კიდევ უფრო უნდა შემცირდეს. მაგრამ მოდით გათვლები გავაკეთოთ შუქდიოდის მაქსიმალურად დასაშვები დენისთვის.

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

წინაღობის საჭირო სიდიდე ასე გამოითვლება:

R = (VS-VL)/ I

სადაცVS არის არდუინოს კონტაქტზე მოდებული ძაბვა, VL არის შუქდიოდზე ძაბვის ვარდნა და I შუქდიოდში გამავალი (მაქსიმალურად დასაშვები)* დენი. ჩვენს პირობებში VS=5ვ, VL=2ვ და I =35მა=0,035ა მივიღებთ:

R = (5 – 2) / 0.035=85,71(ომი)

ამ სიდიდის ქარხნული წესით დამზადებული წინაღობა კი არ არსებობს. წინაღობები მზადდება სტანდარტულად განსაზღვრული გრადაციით. უახლოესი სტანდარტული მნიშვნელობა კი არის 100Ω. წინაღობის არჩევისას ყოველთვის აიღეთ გამოთვლილი სიდიდეზე მეტი უახლოესი სტანდარტული მნიშვნელობის წინაღობა მხოლოდ. ამით თავიდან აიცილებთ სქემის გადატვირთვა-დაზიანებას.

*მაქსიმალურად დასაშვები დენი არის ისეთი სიდიდის დენი რომლის დროს შუქ დიოდი გარანტირებულად არ გამოვა მწყობრიდან (არ გადაიწვება) პასპორტით განსაზღვრული დროის გასვლამდე.

საჭირო წინაღობის არჩევა ხდება მასზე დატანილი 4 ფერადი რგოლის საშუალებით. იხ. ცხრილი 2-1 და სურ. 2-14.

ფერი

1-ლი რგოლი

მე-2 რგოლი

მე-3 რგოლი, მამრავლი

მე-4 რგოლი ცდომილება

შავი

0

0

x100

ყავისფერი

1

1

x101

+1%

წითელი

2

2

x102

+2%

ნარინჯისფერი

3

3

x103

ყვითელი

4

4

x104

მწვანე

5

5

x105

+0,5%

ცისფერი

6

6

x106

+0,25%

იისფერი

7

7

x107

+0,1%

ნაცრისფერი

8

8

x108

+0,05%

თეთრი

9

9

x109

ოქროსფერი

x10-1

+5%

ვერსხლისფერი

x10-2

+10%

უფერული

+20%

ცხრილი 2-1. წინაღობების ფერადი კოდირება.

ცხრილი 2-1 ან სურ. 2-14 გამოყენებით ვნახოთ რა ფერის რგოლები აქვს 100Ω წინაღობას. პირველი ციფრი უნდა იყოს 1 რასაც შეესაბამება ყავისფერი. მეორე ციფრი კი უნდა იყოს 0, რასაც შეესაბამება შავი. მესამე უნდა იყოს მამრავლი x101 რასაც შეესაბამება ყავისფერი, ანუ მივიღებთ 10x101 =100. თუ ბოლო რგოლი არის ოქროსფერი მაშინ ცდომილება შეადგენს +5%, რაც ნიშნავს, რომ წინაღობის ფაქტიური მნიშვნელობა შეიძლება მერყეობდეს 95Ω-105Ωფარგლებში.

10K წინაღობისთვის(რაც იგივეა 10კომ, 10kΩ) საჭიროა, რომ წინაღობაზე დატანებული იყოს ყავისფერი, შავი და ნარინჯისფერი რგოლები (1, 0, x103 ანუ 1, 0, და კიდევ სამი 0). 570K წინაღობისთვის საჭიროა მწვანე, იისფერი და ყვითელი რგოლები.

სურ. 2-4. 10kΩ წინაღობა 5% ცდომილებით.იხ. ცხრილი 2-1 და სურ. 2-14.

იგივეა უცნობი წინაღობის სიდიდის დადგენის პროცედურა.

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

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

სურ. 2-5. შუქ დიოდი.

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

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

არსებობს ორ ფერიანი (bi-color) და სამ ფერიანი (tri-color) შუქდიოდები შესაბამისად სამი და ოთხი გამომყვანებით. ასეთი შუქდიოდები შეიძლება იყოს საერთო ანოდიანი ან საერთო კათოდიანი. სამფერიანი შუდიოდს ასევე ჰქვია RGB შუდიოდი (Red, Green, Blue). შესაბამისი გამომყვანების გავლით შუქდიოდში სხვადასხვა სიდიდი დენის გატარებით შეიძლება შეიცვალოს თითოეული ფერის სიკაშკაშე, რითაც მიიღება მრავალი შეფერილობის სინათლის ნაკადი.

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

დამატებითი ინფორმაცია:

სურ. 2-6. სამოტაჟო-სამაკეტო დაფა (Breadboard)

ფასი ebay.com-ზე $3,87დან. DAC-ში 25 ლარი.

სურ.2-7. სამონტაჟო-სამაკეტო დაფის მავთული კონტაქტებით 65 ცალი (Breadboard Jumper Cable)

ფასი ebay.com-ზე $3,12 დან.

სურ. 2-8. სამონტაჟო მოკალული ცალგულა (უკეთესი ტერმინიც შეიძლება მოიფიქროთ) სპილენძის მავთული დამეტრი22 awg. (Solid Tinned Copper 22 awg) ფასი ebay.com-ზე $9,0 15მეტრი.

სურ. 2-9. სამონტაჟოდ გამზადებული მავთულები, არის DAC-ში 140 ცალი ფასი 14ლარი, 350 ცალი 28 ლარი. Solderless Breadboard Jumper Wire cable, 140ცალი, ფასი ebay.com-ზე $6 დან.

სურ. 2-10. იზოლაციის მოსაცილებელი, Automatic Wire Stripper Cutter light and handy 0.2-3mm². ფასი ebay.com-ზე $3,80.

სურ. 2-11. იზოლაციის მოსაცილებელი დიამეტრი 0,2-0,8მმ (20-30 awg), Multifunctional Plier 20-30 AWG Wire Cutter Stripper. ფასი ebay.com-ზე $8,63.(გირჩევთ).

სურ. 2-12. ტესტერი. 15-25 ლარიანი ტესტერი სავსებით საკმარისია. (ebay.com-ზე შეგიძლიათ იპოვოთ დაწყებული $4დან)

სურ. 2-13. გამადიდებული, შეიძლება გადიდების 4 ვარიანტის არჩევა. ფასი ebay.com-ზე $12, New Multi-function Head Band VISOR Magnifier Light Lamp 2 LED. DAC-ში 36ლარი, .

ცხრილი 2-2. awg-ს მილიმეტრებში გადასაყვანად.

სურ. 2-14. წინაღობების ფერადი მარკირების ცხრილი


Arduino (დასაწყისი)

August 15, 2012

წინამდებარე გაკვეთილები აღებულია წიგნიდან “Beginning Arduino 2010 by Michael McRoberts, 459გვ.”

გამოტოვებულია წინასიყვაობა, ინფორმაცია ავტორებზე და სხვა.

შესავალი

ამ ნაწილში ნაჩვენებია თუ როგორ დავაყენოთ არდუინოს დაპროგრამების პაკეტი(შეგიძლიათ გადმოწეროთ: http://arduino.cc/en/Main/Software) ვინდოუსისათვის. აქ და შემდგომშიც, ყველა გაკვეთლში მოხსენებულია Arduino Uno(სხვა მოდელის გამოყენება სპეციალურად იქნება მითითებული), თუმცა ჩვენი მიზნებისათვის არდუინოს ტიპს პრაქტიკულად დიდი მნიშვნელონა არ აქვს. რა თქმა უნდა სწავლების პროცესში დამატებით შეგიძლიათ და აუცილებელიც არის ინტერნეტში ინფორმაციის მოძიება. მეც თქენთან ერთად ვიწყებ ამ გაკვეთილების გარჩევას და თუ უზუსტობებს ან შეცდომებს აღმოაჩენთ, დიდი ყურადღებით მოგისმენთ და ყველ შენიშვნას მადლიერებით მივიღებ. არდუინოს გარდა აუცილებლად დაგჭირდებათ USB კაბელი (A დან B-ზე გადამყვანიშესაეთებლით), ისეთი როგორიც გამოიყებენა პრიტერის კომიუტერთან შესაერთებლად. მაგრამ ჯერ არაფერი არ ჩართოთ.

სურ. 1-4.Arduino Duemilanove

*სურათების ნუმერაცია არის ისეთივე როგორც ეს მოყვანილია ორიგინალ წიგნში.

დაყენება WindowsXP-თვის

ზემოთ მოყვანილი საიტიდან ჩამოტვირთვის შემდეგ გახსენით არქივი და ამიღეთ ფაილები რომელიმე დირექტორიაში. შემდეგ შეაერთეთ თქვენი არდუინო კაბელის საშუალებით კომპიუტერთან, არდუინოზე აინთება კვების მწვანე შუქდიოდი (მარკირებულია როგორც PWR, თუ რას ნიშნავს PWR ახსნილია შემდგომ გაკვეთლებში) . ეკრანზე გამოვა შეტყობინება “Found new hardware: Arduino Uno(ან ის მოდელი რომელიც მიერთებულია კომპიუტერთან)და ეკრანზე გამოვა ახალი მოწობილობის დასაყენებელი დამხმარე შემდეგი შეტყობინებით: ”Found New Hardware Wizard. დააწკაპუნეთnext”.ამის შემდეგა Windows-იშეეცდება დააყენოს შესაბამისი დრაივერები. ეს პროცესი როგორც წესი ჩაიშლება, რაც ნორმალურია და არ ინერვიულოთ.

მარჯვენა ღილაკით დაუწკაპუნეთ My Computer და აირჩიეთ Manage.

გაიხსნება Computer Management, შედით System Tools-ში,

გადადით-დააწკაპუნეთ Event Manager. მარჯვენა მხარეს გამოჩნდება თქვენს სისტემაში არსებული მოწყობილობების სია. ხოლო Arduino Uno-ზე იქნება დასმული ყვითელი ძახილის ნიშანი, რაც ნიშნავს, რომ Arduino Uno არ არის დაყენებული ისე როგორც საჭიროა.

დაუწკაპუნეთ მარჯვენა ღილაკით და აირჩიეთ დრაივერების განახლება Update Driver.

გამოსულ პირველ გვერდზეაირჩიეთ “No, not this time” და დაუწკაპუნეთ next.

ამის შემდგომ აირჩიეთ “Install from a list or specific location (Advanced)”და ისევ დაუწკაპუნეთ next.

დაუწკაპუნეთ “Include this location in the search” და დააჭირეთ Browse.

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

ვინდოუსი დააყენებს დრაივერებს და საბოლოოდ დაუწკაპუნეთ ღილაკს Finish.

Arduino Uno გამოჩნდება მოწობილობების სიაში, სადაც მოცემულია ”პორტები” Ports და მითითებული ექნება პორტის ნომერი (COM6). დირქტორიაში სადაც არდუინოს ფაილებია აქივიდან ამოღებული ორჯერ დაწკაპუნეთ არდუინოს საფირმო ნიშანზე და პროგრამირების მოდულიც გაიხსნება.

სურ 1-6.არდუინოს პროგრამირების მოდული (IDE) —- #1#

(Windows 7 & Vista -თვის შესაბამისი მანიპულაციის გაკეთება ზემოთ მოყვანილი პროცედურების შემდეგ არ უნდა გაგიჭირდეთ.

შენიშვნა (სურ. 1-5 )ამოღებულია, სადაც მოცემული ინსტალაცია ლინუქსისთვის)

შედით menu-შიდუწკაპუნეთჯერ Tools,შემდეგ Board (See სურ. 1-7).

სურ. 1-7. Tools მენიუ

გამოვა ფანჯარა boards (სურ. 1-8). აირჩიეთ არდუინოს ის მოდელი რომელიც თქვენ გაქვთ

სურ. 1-8. არდუინოს მოდელები

ისევ შედით მენიუში Tools, დაუწკაპუნეთ Serial Port, ამოირჩიეთ შესაბამისი პორტი მოცემული სიიდან (სურ. 1-9). ახლა ყველაფერი მზად არის პროგრამული კოდის, რომელსაც ეწოდება sketch ასაკრეფად და არდუინოში გადასატანად..

სურ. 1-9. Serial Port სია

პირველი Skatch-ის ჩატვირთვა

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

დაუწკაპუნეთ File menu (სურ. 1-10) ხოლო შემდეგ Examples.

სურ. 1-10. File menu

გაიშლება კოდი-ნიმუშების გრძელი ჩამონათვალი. ავარჩიოთ ყველაზე მარტივი. რისთვისაც დაუწკაპუნეთ Basics, ხოლო შემდეგ Blink (სურ. 1-11). Blink-ის sketch ანუ კოდი ჩაიტვირთება პროგრამირების მოდულში IDE (შემდგომში გამოვიყენოთ ტერნიმი IDE).

სურ. 1-11. ნიმუშების სია

დააჭირეთ ღილაკს Upload (ზედა რიგში მარცხნიდან მეექვსე) და დააკვირდით თქვენს არდუინოს. (თუ თქვენ გაქვთ არდუინოMini, NG, ან სვა მოდელი, შესაძლებელია IDEში Upload-ის დაჭერამდე საჭირო იყოს reset ღილაკის დაჭერა უშუალოდ არდუინოზე, დააკვირდით და ადვილად მიაგნებთ). არდუინოზე RX(მიღება) და TX(გადაცემა) შუქდიოდებმა უნდა დაიწყოს ციმციმი, რაც იმის მანიშნებელია, რომ მონაცემები გადაეცემა არდუინოს. როგორც კი კოდი წარმატებით ჩაიტვირთება არდუინოში, IDEstatusbar-ში გამოჩდება წარწერა Doneuploadingდა RX/TX შუქდიოდები ჩაქრება.

სურ. 1-12. LED13 -ის ციმციმი

რამოდენიმე წამში # 13 კონტაქტის შუქდიოდი დაიყებს ციმციმს ერთ წამიანი ინტერვალით, რაც იმის მანიშნებელია, რომ არდუინო სწორად არის ჩართული, დრაივერები დაყენებულია და კოდი არდუინოში წარმატებით ჩატვირთა. სურ. 1-12-ზე ნაჩვენები ანთებული შუქდიოდი შიდა წინაღობის გავლით მიერთებულია #13 ციფრულ კონტაქტზე. მიუხედავად ამისა #13 კონტაქტი თავისუფალია შემდგომი გამოყენებისათვის

ახლა გავეცნოთ IDE-ს ინტერფეისს.

არდუინოს IDE

IDEგაშვების შემდეგ მისი ინტერფეისი გამოიყურება ისე როგორც ეს მოცემულია სურ. 1-13. შეიძლება ცოტა განსვავებული იერი ჰქონდეს IDE-ს. მაგრამ ძირითადი ინტერფეისი მოყვანილია ქვემოთ. IDE გაყოფილია სამ ნაწილად: Toolbar ზემოთ, კოდებისანუ Sketch-ის ფანჯარა შუაში დაშეტყობინების ფანჯარა ქვემოთ. Toolbar წარმოდგენილია შვიდი ღილაკით. Toolbar-ის ქვემოთ მოთავსებულია პატარა იარლიყის ადგილი სადაც კოდის ანუ sketch-ის სახელი გამოისახება

სურ. 1-13. IDE-ს ინტერფეისი

 

სურ. 1-14

ღილაკებს განმარტბა:

Verify/Compile — ამოწმებს პროგრამული კოდების სისწორეს არდუინოში ჩატვირთვამდე.

Stop ————- აჩერებს serial monitor-ისმუშაობას.

New ————- ხსნის ახალ ”ფურცელს”ახალი sketch-ის შესაყვანად. IDE შეგეკითხებათ რა უნდა დაერქვას ახალ sketch-ს და სად იქნება ის შენახული.

Open ———— გახსნის შენახულ sketches-ს.

Save ————- შეინახავს sketch-ის ფანჯარაში შეყვანილ კოდს sketch ფაილში. შენახვის დამთავრების შემდეგ კოდების ფანჯარაში გამოვა შეტყობინება ”Done Saving.

Upload ———– ჩატვირთავს sketch-ის ფანჯარაში არსებულ კოდს არდუინოში. შემდგომი გაუგებრობების თავიდან აცილების მიზნით ჩატვირთვამდე დარწმუნდით, რომ არდუინოს ტიპი სწორად გაქვთ შერჩეული.

ასევე წესად შემოიღეთ, რომ ყოველი sketch შემოწმდეს შენახვის წინ და შენახული იქნეს არდუინოში ჩატვირთვამდე.

Serial Monitor — საჭირო ინსრტუმენტია კოდებზე სამუშაოდ და შეცდომების გასაწორებლად. მისი საშუალებით შესაძლებელია არდუინოდან გამოზავნილი მონაცემების კონტროლი. ასევევ მისი საშუალებით შესაძლებელია ინფორმაციის გაგზავნა არდუინოზე. Serial Monitor მუშაობის მაგალითი იხ.სურ. 1-15.

ქვედა მარჯვენ კუთხეში მოცემულია არდუინოსა და კომპიუტერს შორის გადაცემა/მიღების სიჩქარე ბიტი წამში (ბიტი/წმ). სტანდარტული სიჩქარეა 9600baud ანუ 9600ბიტი/წმ. რადგან ერთ სიმბოლო იკავებს 8 ბიტს ამიტომ 9600ბიტი/წმ ტოლია 1200სიმბოლო/წმ ანდ 1200ბაიტი/წმ.

 

სურ. 1-15. serial window მუშაობის დროს

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

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

 IDE-ს ზედა მხარეს ასევევ გალაგებულია მენიუ (სურ. 1-16).

სურ. 1-16. IDE მენიუ

პირველი მენიუში (სურ. 1-17). მოცემულია ინფორმაცია არდუინოს IDE-ს შესახებ: ვერსიის ნომერი, ავტორები და ა.შ.

სურ. 1-17. მენიუ Arduino

Preferences ნიშნავს ინტერფეისის ვიზუალური ეფექტის არჩევას. ხოლო Quit ნიშნავს პროგრამიდან გასვლას.

სურ.1-18. მენიუ File

New – ახალი sketch, open – შენახული sketch გახნა, Sketchbook sketch-ების შესანახი დირექტორია, Examples – ნიმუშები, Close – დახურვა, Save – შენახვა, Save As – შენახვა როგორც, Upload I/O Board – კოდის გაგზავნა არდუინოზე, Page Setup – გვერდის მახასიათებლების დაყენება, Print – ბეჭდვა.

სურ. 1-19. მენიუ Edit

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

სურ.1-20. მენიუ Sketch

მენიუ Sketch (სურ. 1-20) შეიცავს Verify/Compile-(შედარება/კომპილაცია) და სხვა სასარგებლო პუნქტებს. Show Sketch folderSketch დირექტორიის ჩვენება, Library -ბიბლიოთეკა , რომელიც გამოჩენს ხელმისაწვდომ ბიბლიოთეკებს.

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

Sketch Folder გამოჩენს იმ დირექტორიას სადაც შენახული გაქვთ sketch-ები. Add File-ის საშუალებით შესაძლებელიადაუმატოთ თქვენს sketch-ს სხვა ფაილები,რითაც დიდი sketch შეიძლება დაიყოს პატარა ნაწილებად და შემდეგ უკვე პატარა ზომის sketch-ების სახით დაემატოს მთავარe sketch-ს.

სურ. 1-21. Tools მენიუ

მენიუ Tools ( სურ. 1-21) გაერთიანებულია რამოდენიმე სერვისი. შეგიძლიათ აირჩიოთ არდუინოს ტიპი და Serial Port, ისევე როგორც პირველი დაყენების(ინსტალაციის)დროს. Auto Format დააფორმატებს კოდს უფრო ადვილად აღსაქმელ ფორმატში.Archive Sketch შეკუმშავს sketch-ს ZIP ფორმატში და მონიტორზე გამოსული შეტყობინებით

სურ. 1-22. Atmel ATmega მიკროკონტროლერი (ჩიპი)

შეგეკითხებათ თუ სად გსურთ მისი შენახვა, Burn Bootloader შექმნის არდუინოს Bootloader-ს მისი ჩიპისთვის. ეს სერვისი გამოიყენება თუ გაქვთ AVR პროგრამატორი და თუ შეცვალეთ არდუინოს ჩიპი (Atmel-ის მიკროკონტროლერი), ან შეიძინეთ ახალი ჩიპი თქვენი პროექტისათვის. თუ არა აპირებთ ბევრი ჩიპის დაპროგრამებას, მაშინ უკეთესია და თანაც იაფი, შეიძინოთ უკვე დაპროგრამებული Atmegaჩიპი (სურ. 1 -22). ბევრი ინტერნეტ მაღაზია სთავაზობს კლიენეტებს უკვე დაპროგრამებულ იაფ პროცესორებს.

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

Arduino IDE საკმაოდ მარტივი, ადვილად გასაგები და ასათვისებელია. შემდგომში რაც უფრო მეტ გამოცდილებას შეიძენთ არდუინოს გამოყენებასა და C-ზე პროგრამირებაში (არდუინოსათვის გამოყენებული პროგრამირების ენა), მოგინდებათ და აუცილებლად მოგინდებათ ფრთების გაშლა, შეგიძლიათ გადახვიდეთ რაიმე უფრო უკეთეს, მეტი ფუნქციის მქონე და პროფესიონალურ IDE პროგრამატორებზემაგ. Eclipse, ArduIDE, GNU/Emacs, AVR-GCC, AVR Studio, Apple’s XCode და სხვა.

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


RC car Robot

August 9, 2012

რობოტი  დაბრკოლაბათა გარშემოვლის უნარით არის ერთერთი მარტივი ასაწყობათ და ასევე შეჯიბრებებშიც გამოდგება. ასეთი რობოტის ასაწყობათ საჭირო იქნება:
1)შასი სერვო ძრავებით
2)აკუმულატორი
3)მიკროკონტროლერი ან მარტივი ალგორითმის შემთხვევაში ლოგიკური მიკროსქემები და ტაიმერი
(მაგალითად კარგათ ცნობილი 555 თაიმერი).
4)ძრავის დრაივერი მიკროსქემა
5)მიახლოვების სენსორები. ძირითადათ გამოიყენება ინფრაწითელი ან აკუსტიკური.

შასი შეიძლება გამოვიწეროთ რაიმე რობოკონსტრუქტორის, ან ჩვენთვითონ ავაწყოთ რაც არც თუ ისე მოხერხებულია მითუმეტეს თუ არ გაქვს აუცილებელი მასალები და ინსტრუმენტები. გარდა ამისა ყველაზე მარტივია იყიდო რომელიმე რადიომართვადი სათამაშო მანქანა და არსებული მიმღებისა და ძრავების მართვის სქემის ნაცვლად დააყენო საკუთარი მართვის მოდული მიკროკონტროლერზე. ქვემოთ განხილული რობოტი სწორედ რადიომართვადი მანქანის შასის ბაზაზე იქნება.  უნდა აღინიშნოს, რომ თუ გამოვიყენებთ არსებულ ძრავებს, აუცილებელია მივიღოთ დამატებითი ზემები მუდმივი დენის ძრავებისგან გამოწვეულ ელექტრო-მაგნიტურ ხელშეშლებთან საბრძოლველად (მოცემულ საკითხზე უფრო დეტალურად სქემის განხილვისას გვექნება საუბარი). ასევე იმ შემთხვევაში თუ მობრუნების სამართავად არის უბრალო მუდმივი დენის ძრავი, კარგი იქნება თუ გამოვცვლით და დავაყენებთ სერვოძრავას, ამით ერთი რომ შევამცირებთ ხელშეშლებს და მეორე შემცირდება მოხმარების დენი. მოცემულ შემთხვევაში სერვოძრავა არ არის გამოყენებული, და უბრალოთ მობრუნებისთვის თავისივე ძრავა ამოიყენება.                                                                                                                                                                                                                                                                                          აკუმულატორი შეიძლება გამოვიყენოთ არსებულივე, მაგრამ მანქანა ხშირ შემთხვევაში ან უბრალო ელემენტებზეა ან აკუმულატორის ტევადობა ძალიან მცირეა. ასეთ დროს კარგი იქნება თუ შევცვლით 4.5-6ვ და დაახლოვებით 2000Ah ის ტევადობის მცირე ზომის აკუმულატორით.
მართვისთვის გამოყენებულია ატმელის მიკროკოტროლერი კარგათ ცნობილი ATtiny2313.ძრავების დრაივერად გამოიყენება L293D მოკროსქემა, რომელიც ასრულებს ეწ. H bridge-ის როლს.

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

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

იფრაწითელი სენსორის მთავარი კომპონენტია ფოტომიმღები, რომლის მოქმედების პრინციპი ნაჩვენებია ქვემოთ,

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

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

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

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

მიკროკონტროლერის კოდი დაწერილია Atmel Studio 6.0-ში რომელიც უნდა აღინიშნოს რომ იგივე IDE-ია რაც Mocrosoft Visual Studio 2010.  პროგრამის დაწერის და დებაგირების პროცესი საკმაოდ გამარტივებულია და მოხერხებული.

განვიხილოთ პროგრამული კოდი დეტალურად, პროგრამა დაწერილია AVR GCC კომპილატორზე


#define F_CPU 1000000UL /*F_CPU მიუთითებს პროცესორის ტაქტური სიხშირეს 1Mhz */

#include <inttypes.h>
#include <avr/io.h>
#include <util/delay.h>
#include <stdbool.h>

void method(char p,char z){
  int i=0;   /*integer-ის ტიპის ცვლადის გამოცხადება || ზომა --- 16 ბიტი*/
  _Bool b=false/*დადებითი character-ის ტიპის ცვლადი || ზომა --- 8 ბიტი*/

  while (i<1000) {  /*უწყვეტი ციკლი სანამ i არ მიაღწევს 1000-ს*/
  if(!((PIND & (1<<PIND0))&&(PIND & (1<<PIND1)))){
    /*(PIND & (1<<PIND0)-ით მოწმდება თუ მიკროკონტროლერის PORTD-ს D0 პინზე არის ლოგიკური ნული
    მოცემულ შემთხვევაში გათვალისწინებულია რომ თუ ერთერთ PIND0 ან PIND1 იქნება ლოგიკური ერთი,
    მაშინ პროგრამა შევა if ოპერატორის ბლოკში და b-ს მიანიჭებს ერთს.*/
    b=true;
  }

  _delay_us(7);  /*ხდება პროგრამის დაყოვნება 7 მიკროწამით.*/

  PORTB = ~PORTB & z; /*PORTB_ზე ბიტების ინვერსია რომელიც ემთხვევა z ბაიტში არსებული ლიგიკური ერთიანების პოზიციას.*/
  PORTB |= _BV(PB6);
  /*PORTB-ს PB6-ი მიენიჭოს ლოგიკური ერთიანი. მოცემული პინიდან გამომავალი სიგნალით უზრუნველყოფილია
  ნამქანის პირდაპირ მოძრაობა*/
  i++;   /*i-ის ინკრემენტირება, ანუ ყოველი მიმართვისას i იზრდება ერთით*/
}

if(b==true){ /*იმ შემთხვევაში თუ PORTD-ს D0 ან D1 პინზე დაფიქსირდება ლოგიკური ნული მაშინ b იქნება 1 და შესრულდება შემდეგი მოქმედებები*/
PORTB=p;  /*p-ს მნიშვნელობა განაპირობებს რობოტის შესაბამის მოქმედებას*/
_delay_ms(1000); /*დაყოვნება 1 წამი*/
}
}

int main(){    /* მთავარი main ფუნქციის დასაწყისი*/

DDRB = 0b11111111;   /* PORTB იყოს გამომავალი პორტი*/
DDRD = 0x00;   /* PORTD იყოს შემავალი პორტი*/

while(1){ //უწყვეტი ციკლი

/*თანმიმდევრულად ამოიძახება method ფუნქცია სხვადასხვა მნიშვნელობის პარამეტრებით.*/
//.................................................................
method(0b10010000,0b00000001);
//0b00000001 --- ციმციმებს წინა სენსორის მარჯვენა შუქდიოდი                                                        
//0b10010000 --- თვლების მარჯვნივ მოტრიალება და მოძრაობა უკან
//.................................................................
method(0b10100000,0b00000010);
//0b00000010 --- ცომციმებს წინა სენსორის მარცხენა შუქდიოდი
//0b10100000 --- თვლების მარცხნივ მოტრიალება და მოძრაობა უკან
//.................................................................
method(0b01010000,0b00000100);
//0b00000100 --- ციმციმებს უკანა სენსორის მარჯვენა შუქდიოდი
//0b01010000 --- თვლების მარჯვნივ მოტრიალება და მოძრაობა პირდაპირ
//.................................................................
method(0b01100000,0b00001000);
//0b00001000 --- ციმციმებს უკანა სენსორის მარცხენა შუქდიოდი
//0b01100000 --- თვლების მარცხნივ მოტრიალება და მოძრაობა პირდაპირ
}

}

* This source code was highlighted with Source Code Highlighter.

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

როგორც უკვე ავღნიშნეთ სენსორებისთვის გამოიყენება ინფრაწითელი ფოტომიმღებები ჩვენს შემთხვევაში ეს არის TSOP1738 აქ 38 მიუთითებს რომ მომღებს სიგნალის გაძლიერების მაქსიმალური მნიშვნელობა აქვს 38kHz სიხშირეზე. C1,R2 და C2,R1 წრედი ასრულებს დაბალი სიხშირის ფილტრის როლს და ამცირებს ძრავებიდან წამოსულ ხელშეშლებს. ნახაზზე მოცემული Front ფოტომიმღები და D3,D4 ინფრაწითელი შუქდიოდები შეადგენენ წინამდებარე სენსორს, როლო Back  ფოტომიმღები და D3,D4  შუქდიოდებისგან სედგენილი სენსორი დამაგრებულია მანქანის უკანა მხარეს. სენსორი მუშაობს შემდეგნაირად: შუქდიოდები ციმციმებენ მონაცვლეობით 38kHz ის მახლობელი სიხშირით ( შუქდიოდების ციმციმის სიხშირე დამდენადმე განსხვავდება 38kHz სიხშირისგან, რადგან ზუსტად 38kHz სიხშირეზე  ფოტომიმღების მგრძნობიარობა საკმაოდ მაღალია და რამოდენიმე მეტრის მანძილიდან არეკვლილი სხივებიც ახდენენ ფოტომიმღებზე ზემოქმედებას, ასეთ რეჟიმში მუშობა არ მოგვცემს არანაის შედეგს, გარდა იმ შემთხვევისა თუ შუქდიოდები გვექნება გაცილებით მიმართული მოქმედების და ასევე შევამცირებთ იმპულსების ხანგძლივობას რაც თავისთავად გამოიწვევს შუქდიოდების განათებულობის შემცირებას) შუქდიოდების თანმიმდევრული მუშაობით განისაზღვრება თუ რომელი მიმართულებიდან მოხდა სხივის არეკვლა. დრიოს ყოველ მომენტში მუშაობს მხოლოდ ერთი შუქდიოდი, და სიგნალის მიღების შემთხვევაში შესრულდება მისი შესაბმისი ბრძანება.
ძრავების დრაივერად გამოყენებულია L239D მიკროსქემა რომლის მართვის შესასვლელები ლოგიკურია და  პირდაპირ არის მიერთებიული მიკროკონტროლერის B პორტის გამომყვანებთან.