პროქტი№7 – შუქდიოდის ცვალებადი სიკაშკაშე, პულსირება.

September 16, 2012

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

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

შუქდიოდი, (იყოს მწვანე)  

150-200Ω წინაღობა              

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

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

სურ. 3-3.  სქემა, პულსირებადი შუქდიოდი

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

აკრიფეთ ქვემოთ მოყვანილი კოდი, შეამოწმეთ და ჩატვირთეთ არდუინოში.
// int ტიპის ცვლადი სახელად ledPin 
// (კონტაქტის № რომელზეც მიერთებულა შუქდიოდი)
int ledPin = 11; 
// float ტიპის ცვლადი სახელად 
// sinVal (შინაარსი: სინუსის მნიშვნელობა)
float sinVal; 
// int ტიპის ცვლადი სახელად ledVal 
// (შინაარსი: შუქდიოდის კაშკაშის მნიშვნელობა)
int ledVal; 

void setup() { 
 pinMode(ledPin, OUTPUT);//ledPin=11 კონტაქტი არის გამომსვლელი
}
void loop() {
 for (int x=0; x<180; x++) { // კუთხის ზრდა 10 ბიჯით
       /*შემდეგ სტრიქონში ხდება კუთხის გრადუსული 
       ზომის გადაყვანა რადიანებში და შესაბამისი სინუსის გამოთვლა */
       sinVal = (sin(x*(3.1412/180)));
   ledVal = int(sinVal*255);//მიღებული სინუსის გადაეცემა ledVal-ს
       // ledVal-ის გადაცემა გამომსვლელ კონტაქტზე
       analogWrite(ledPin, ledVal);
   delay(25); // დაყოვნება 25 მილიწამით
   }
}

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

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

ზემოთ მოყვანილი პროგრამული კოდი მარტივია, მაგრამ აუცილებელია ზოგიერთი განმარტების გაკეთება. გამოსასვლელი კონტაქტისთვის შემოვიღეთ int ტიპის ცავლადი ledPin. სინუსის გამოსათვლელად float ტიპის ცვლადი. ხოლო  №11 PWM გამომსვლელ კონტაქტზე გადასაცემად კი int ტიპის ცვლადი ledVal.

იდეა მდგომარეობს იმაში, რომ სიკაშკაშის ცვლილებისათვის გამოვიყენოთ სინუსის ფუნქციის თვისება მიიღოს მნიშვნელობები (0; 1; 0) შუალედში, როდესაც არგუმენტი იცვლება 00 გრადუსიდან 1800 გრადუსამდე (1800-3600 არ გვჭირდება რადგან ამ შუალედში სინუსი უარყოფითია).

სინუსის გამოსათვლელად საჭიროა გრადუსული ზომის გადაყვანა რადიანებში x*(3.1412/180).

(ერთი შეხედვით რა საჭიროა ჯერ გრადუსული ზომის აღება და მერე მისი გადაყვანა რადიანებში, არ ჯობდა პირდაპირ რადიანები აგვეღო? არ ჯობდა იმიტომ, რომ გრადუსული ზომისთვის ინკრემენტი for (int x=0; x<180; x++) მარტივია). მიღებულ sinVal მნიშვნელობას ვამრავლებთ 255-ზე და ვღებულობთ ledVal-ს მნიშვნელობებს 0 დან 255 მაქსიმუმამდე. თან float ტიპის sinVal გარდაიქმნება int ტიპად შემდეგ გამოცხადებით:int()

ledVal = int(sinVal*255);

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

ამის შემდეგ, მიღებული მნიშვნელობები გადაეცემა №11 ციფრულ PWM კონტაქტს.

analogWrite(ledPin, ledVal);

მაგრამ, როგორ გადაეცემა ანალოგური სიგნალი ციფრულ კონტაქტს? თუ დავაკვირდებით არდუინოს დაფას, ვნახავთ, რომ №3, 5, 6, 9, 10 და 11 კონტაქტებს აწერია PWM. ეს კონტაქტები იმით განსხვავდება სხვა, მხოლოდ ციფრული კონტაქტებისაგან, რომ მათ დამატებით შეუძლიათ გამოიყვანონ PWM ტიპის სიგნალი.

ახლა განვიხილოთ თუ რას წარმოადგენს PWM (Pulse Width Modulation). ეს მეთოდი გულისხმობს ანალოგური სიგნალის მოქმედების მსგავსი ეფექტის მიღებას ციფრული სიგნალით. ამ დროს მართკუთხა ციფრული სიგალის ხანგრძლივობის ცვლილებით (სურათი ქვემოთ) ხდება ანალოგური სიგნალის კოდირება-იმიტაცია. არდუინო თავის PWM კონტაქტებზე აგზავნის 0 და 5ვ სიდიდის იმპულსებს 500ჰც სიხშირით. ამ იმპულსების, ანუ ჩართვა-გამორთვის კომბინაციები ახდენენ ანალოგური სიგალის 0-დან 5ვ-მდე ცვლილების იმიტაციას. კომბინაციები კი ნიშნავს თუ როგორია თანაფარდობა ჩართული მდგომარების ჯამურ ხანგრძლივობასა და გამორთული მდგომარების ჯამურ ხანგრძლივობას შორის.

მაგალითად: №11 ციფრულ PWM კონტაქტზე analogWrite()-ის საშუალებით 0-გადაცემის შემთხვევაში, ჩართული მდგომარეობის ანუ ძაბვის მიწოდების ხანგრძლივობა იქნება ნული, ანუ სამუშაო ციკლის 0%. იმავე კონტაქტზე 64-ის გადაცემის შემთხვევაში (რაც შეადგენს 255-ის ≈25%(25,1)) №11 ციფრულ PWM კონტაქტზე 5ვ ძაბვა მიწოდებული იქნება დროის 25% განმავლობაში და გამორთული 75% განმავლობაში. 191-ის გადაცემის დროს კი დროის ≈75% (74,9) ჩართული და გამორთული ≈25%. ხოლო 255-ის გადაცემის დროს სრული 100% ჩართული. საბოლოოდ იქმნება ილუზია, რომ შეგვიძლია ციფრული გამომსველელი კონტაქტზე მოვახდინოთ ანალოგური სიგნალის სიმულირება

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

Advertisements

პროექტი №6 – ინტერაქტიული ”მორბენალი” ნათება

September 11, 2012

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

მე-5 პროექტზე დასამატებლად დაგვჭირდება :

4,7KΩ ან ცოტათი მეტი წინაღობის პოტენციომეტრი (მაგ. 5,1)

 

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

სურ. 3-2. მე-6 პროექტის სქემა.

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

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

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

byte ledPin[] = {4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
int ledDelay;
int direction = 1;
int currentLED = 0;
unsigned long changeTime;
int potPin = 2; // პონტენციომეტრისთვის შემავალი კონტაქტის დანიშვნა

void setup() {
  for (int x=0; x<10; x++) { 
      pinMode(ledPin[x], OUTPUT); 
  }
  changeTime = millis();
}

void loop() {
 ledDelay = analogRead(potPin); // პოტენციომეტრის მნიშვნელობის წაკითხვა
 if ((millis() - changeTime) > ledDelay) {
    changeLED(); changeTime = millis();
 }
}
void changeLED() {
  for (int x=0; x<10; x++) { 
      digitalWrite(ledPin[x], LOW);
  }
  digitalWrite(ledPin[currentLED], HIGH);
  currentLED += direction;
  if (currentLED == 9) {
     direction = -1;
  }
  if (currentLED == 0) {
     direction = 1;
  }
}

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

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

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

int potPin = 2; ამ სტრიქონს განსაკუთრებული ახსნა არ უნდა, პოტერციომეტრი მიერთებულია №2 ანალოგურ კონტაქტთან. ledDelay = analogRead(potPin); // პოტენციომეტრის მნიშვნელობის წაკითხვა ამ სტრიქონის საშუალებით ვკითხულობთ ანუ ვღებულობთწინაღობის მნიშვნელობებს №2 კონტაქტიდან analogRead ბრძანების გამოყენებით. არდუინოს აქვს ექვსი (დამოკიდებულია არდუინოს მოდელზე) ანალოგური შემავალ/გამომავალი კონტაქტი ანალოგურიდან ციფრულში 10ბიტიანი გადამყვანით(analog to digital convertor). რაც ნიშნავს, რომ ანალოგურ კონტაქტს შეუძლია წაიკითხოს შემავალი 0-დან 5 ვოლტამდე ძაბვა როგორც integer ტიპის მნიშვნელობები 0დან(ანუ 0 ვოლტიდან) 1023მდე(ანუ 5 ვოლტამდე). რაც გვაძლევს შემდეგ გარჩევისუნარობას: 5ვოლტი / 1024 ერთეულზე (რადგან 0-იც შედის სათვალავში)ანუ 0,0049 ვოლტი (4,9მილივოლტი)ერთ ერთეულზე. (5/1024=0,00488281250.0049 პრაქტიკული თვალსაზრისით თამამად შეგვიძლია ვთქვათ = 0,0049) პოტენციომეტრიდან მიღებული ანუ წაკითხული მნიშვნელობები პირდაპირ მიენიჭება ledDelay ცვლადს და საბოლოოდ ვღებულობთ დაყოვნებას 0-დან 1023 მილიწამამდე. ledDelay = analogRead(potPin); ციფრული კონტაქტებისაგან განსხვავებით, ანალოგურ კონტაქს არ ჭირდება წინასწარ გასაზღრვრა შემავალია ის თუ გამომავალი. ledDelay = analogRead(potPin); რადგან, ამ სტრიქონს მუდმივად აკონტროლებს მთავარი ციკლი void loop(), ჩვენ მხოლოდ ისღა დაგვრჩენია ვატრიალოთ პოტენციომეტრის სახელური.

პოტენციომეტრის მიკლე აღწერა

 განვიხილოთ პოტენციომეტრი. მაგ. 4K7 (4700Ω) რომელიც გამოყენებულია ჩვენ პროექტში.   ჩვენ უკვე ვიცით თუ რა არის რეზისტორი. პოტენციომეტრი კი უბრალოდ არის რეგულირებადი ანუ ცვლადი რეზისტორი 0-დან მის მაქსიმალურ მნიშვნელობამდე, რომლიც ქარხნული წესით დატანილი რეზისტორის კორპუსზე. ჩვენ შემთხვევაში რეზისტორის კორპუსზე ნახავთ წარწერას 4K7 ან 4700Ω, რაც ნიშნავს 04700ომი დიაპაზონს . პოტენციომეტრს აქვს სამი კონტაქტი. რომელიმე კიდურა და შუა კონტაქტის (ცოცია) გამოყენებით ვღებულოთ ცვლად რეზისტორს, ხოლო სამივე კონტაქტის ჩართვით კი ძაბვის დამყოფს.


პროექტი №5 – ”მორბენალი” ნათება

September 10, 2012

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

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

1) 10 ცალი შუქდიოდი

2) 10 ცალი 150-200Ω  რესისტორი

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

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

სურ. 3-1.

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

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

// პროექტი №5 - ”მორბენალი” შუქდიოდები
// byte ტიპის მასივი სახელად ledPin რომლის
byte ledPin[] = {4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
//შემადგენელი ელემენტებია იმ კონტაქტების
//ნომრები რომლებზეც შუქდიოდებია მიერთებული 
// int ტიპის ცვლადი სახელად ledDelay, შეცვლის დაყოვნება მლწმ-ში
int ledDelay(65); 
int direction = 1;//int ტიპის ცვლადი სახელად direction
int currentLED = 0;// int ტიპის ცვლადი სახელად currentLED
//unsigned long ტიპის ცვლადი სახელად changeTime
unsigned long changeTime;
void setup() {
// კონტაქტების გადაყვანა გამოსვლის რეჟიმში
  for (int x=0; x<10; x++) { 
      pinMode(ledPin[x], OUTPUT); 
  }
  changeTime = millis();
}

void loop() {
//თუ ბოლო შეცვლიდან გასულია ledDelay მლწმ   
   if ((millis() - changeTime) > ledDelay) { 
      changeLED();
      changeTime = millis();
   }
}
void changeLED() {
  for (int x=0; x<10; x++) { // ყველ შუქდიოდის გამორთვა
      digitalWrite(ledPin[x], LOW);
  }
  // მიმდინარე შუქდიოდის ჩართვა
  digitalWrite(ledPin[currentLED], HIGH); 
  currentLED += direction; // direction-ით მატება
  // შეიცვალოს მიმართულება direction თუ გავედით ბოლოში
  if (currentLED == 9) {
      direction = -1;
  }
  if (currentLED == 0) {
      direction = 1;
  }
}

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

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

პირველი სტრიქონი

byte ledPin[] = {4, 5, 6, 7, 8, 9, 10, 11, 12, 13};

არის მონაცემთა მასივი, გამოცხადებული byte ტიპის ცვლადის საშუალებით, სახელად ledPinმასივი არის ცვლადების (გნებავთ მნიშვნელობების) ერთობლიობა, ნაკრები, ჯგუფი, სიმრავლე. მასივის შემადგენელი ელემენტების გამოძახება, გამოყენება, წვდომა ხდება მათი ინდექსის ანუ რიგითი ნომრის საშუალებით. ჩვენი მასივი შედგემა 10 ელემეტისაგან, მნიშვნელობისაგან, წევრისაგან (კონტაქტების ნომრები 4-დან 13-ის ჩათვლით). მიუხედავად იმისა, რომ ჩვენ ინტუიციურად მიჩვეული ვართ თვლა დავიყოთ 1-დან, მასივის გამოყენების შემთხვევაში კი საქმე სხაგვარად არის, ამიტომ დაიმახსოვრეთ : მასივის ელემენტების ნუმერაცია იწყება 0-დან. რაც იმას ნიშნავს, რომ პირველი ელემენტის ინდექსი არის 0, მეორე ელემენტის ინდექსი არის 1, მესამე ელემენტის ინდექსი 2 და ა.შ. ამიტომ ჩვენი მასივის ელემენტების ინდექსებია: 0, 1, 2, 3, 4, 5, 6 ,7, 8 და 9. მაგალითად: არდუინოს მე-6 კონტაქტის ანუ მასივის მე-3 ელემენტის გამოძახება ჩაიწერება ასე: ledPin[2]. მე-10 კონტაქტის ანუ მასივის მე-7 ელემენის გამოძახება კი ასე ledPin[6].

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

byte ledPin[10];

ხოლო ელემენტები მიგვენიჭებინა მოგვიანებით.

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

void changeLED() {
// ყველ შუქდიოდის გამორთვა
for (int x=0; x<10; x++) { 
    digitalWrite(ledPin[x], LOW);
}

digitalWrite(ledPin[currentLED], HIGH); // მიმდინარე შუქდიოდის ჩართვა

currentLED += direction; // direction-ის ტოლი სიდიდით მატება

// შეიცვალს მიმართულება direction თუ გავედით ბოლოში

if (currentLED == 9) {direction = -1;}

if (currentLED == 0) {direction = 1;}

}

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

შემდეგ ამ ცვლადს ემატება direction. რადგან direction-ის მნიშვნელობა შეიძლება იყოს ან1, ცვლადის მნიშვნელობა გაიზრდება (+1) ან შემცირდება (currentLED +(-1)) ერთით.

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

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

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


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


პროექტი №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. წინაღობების ფერადი მარკირების ცხრილი