პროექტი №14 – სინათლის სენსორი.

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

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

პიეზო დინამიკი  (ან პიეზო დისკი)

ორკონტაქტიანი ტერმინალი            

ფოტო წინაღობა (1kΩ–10kΩ)            

10kΩ წინაღობა                  

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

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

სურ. 4-4. სქემა მე-14-ე პროექტისთვის – სინათლის სენსორი

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

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

// Project 14 - სინათლის სენსორი
// პიეზო ელემენტი მიერთებულია მერვე გამომყვანზე (Pin 8)
int piezoPin = 8;
// ფრ მიერთებული №0 ანალოგურ გამომყვანზე (Aalog Pin 0)
int ldrPin = 0; 
int ldrValue = 0; // ფრ–დან მიღებული საწყისი სიდიდე
void setup() {
 // ცარიელია
}
void loop() {
  // ფრ–დან რაღაც მნიშვნელობის მიღება 
  ldrValue = analogRead(ldrPin); 
  // პიეზო ელემენტი გამოსცემს 1000ჰც სიხშირის ტონს
  tone(piezoPin,1000); 
  delay(25); // დალოდება 25 მილიწამით
  noTone(piezoPin); // ტონის შეწყვეტა
  delay(ldrValue); //ldrValue–ს ტოლი მილიწამით დაყოვნება
} 

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

ამ გაკვეთლის პროგრამული კოდი საკმაოდ მარტივია და ადვილად გასარჩევი. ამიტომ პრდაპირ

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

სქემის განხილვა.

ფოტო რეზიტორებს ამზადებენ კადმიუმ–სულფატის ფოტომგძნობიარე შენაერთისაგან ( CdS: Cadmium-Sulfide) და მათ აქვთ სხვადასხვა წინაღობა.

სხვა და სხვა კონსტრუქციისის ფოტო რეზიტორები.

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

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

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

ამ გაკვეთილში გამოყენებულია მუდმივი 10kΩ სიდიდის წინაღობა და ცვლადი წინაღობა ფრ–ის სახით. ძაბვის დამყოფის სტანდარტული სქემა მოცემული ქვემოთ.

როგორც ნახაზიდან ჩანს, შემავალი ძაბვა(Vin) მოდებულია ორივე წინაღობაზე. ერთ რომელიმე წინაღობაზე მოსული, ანუ დაყოფილი ძაბვა კი იქნება ნაკლები და მას პირობითად დავარქვათ გამომავალი ძაბვა (Vout). ამ გამომავალი ძაბვის გამოსათვლელი ფორმულა ასეთია:
Vout = (R2/(R2+R1))x Vin

მაგ. თუ R1=R2=100Ω (ანუ =0.1kΩ) და შემავალი ძაბვა Vin=5ვ, მაშინ გამომავალი ძაბვა იქნება:

Vout= (0.1/(0.1+0.1))X5 = 2.5ვ

თუ R1=R2=470Ω მაშინ:

 

Vout= (0.47/(0.47+0.47))X5 = 2.5ვ

იმ შემთხვევაში თუ R1=1kΩ და R2=500Ω მაშინ:

Vout= (0.5/(0.5+1))X5 = 1.66ვ

თუ R1=1kΩ და R2=2kΩ მაშინ

Vout= (2/(2+1))X5 = 3.33ვ

ძაბვის გამყოფისათვის მნიშვნელოვანია წინაღობების სიდიდე, მაგრამ გაცილებით მნიშვნელოვანია მათ შორის თანაფარდობა.

რადგან ჩვენს სქემაში გამოყენებულია მუდმივი 10kΩ წინაღობა და ფრ რომლის წინაღობა იცვლება 10kΩ–დან (სრული დაბნელება) 1kΩ–მდე (მაქსიმალური განათება), მაშინ გამომავალი ძაბვა და მისი შესაბამისი განათებულობის მნიშვნელობები მოცემულია ქვემოთ მოყვანილ ცხრილში.

R1	R2 (ფრ)	გამომავალი ძაბვა Vout	განათებულობა
10kΩ	100kΩ	4.54ვ	სიბნელე
10kΩ	73kΩ	4.39ვ	25%
10kΩ	45kΩ	4.09ვ	50%
10kΩ	28kΩ	3.68ვ	75%
10kΩ	10kΩ	2.5ვ	მაქს. სიკაშკაშე

პროექტი № 13 – კაკუნის პეზო სენსორი

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

დაგვჭირდება

პიეზო დინამიკი    

ორკონტაქტიანი ტერმინალი 

შუქდიოდი 

1MΩ წინაღობა  

* შეგიძლიათ პიეზო ელემენტის გამომყვანებს მიარჩილოთ 22 awg მავთული(იხ. გაკვეთლი 1, სურ. 2-8.) და ჩართოთ დაფაში, ან არდუინოში.

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

სურ. 4-3. სქემა მე-13-ე პროექტისთვის – კანუნის პიეზო სენსორი

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

// Project 13 - კაკუნის პიეზო სენსორი
int ledPin = 9; // შუქდიოდი მე-9 გამომყვანზე
int piezoPin = 5; // პიეზო მიერთებულია მე-5 ანალოგურ გამომყვანზე
int threshold = 120; 
// სესორის საწყისი მინიშვნელობა 120 მის გააქტიურებამდე
int sensorValue = 0; // ცვლადი რომელიც ინახავს სენსსორიდან 
// მიღებული სიგნალის სიდიდეს 
float ledValue = 0; // შუქდიოდის ნათების სიდიდე.

void setup() {
   // ledPin განსაზღვრულია როგორ გამომავალი კონტაქტი
   pinMode(ledPin, OUTPUT);
   //პროგრამის გაშვებისას შუქდიოდი აინთება ორჯერ   
   digitalWrite(ledPin, HIGH); 
   delay(150); 
   digitalWrite(ledPin, LOW); 
   delay(150);
   digitalWrite(ledPin, HIGH); 
   delay(150); 
   digitalWrite(ledPin, LOW); 
   delay(150);
}

void loop() {
   sensorValue = analogRead(piezoPin);//სესორის მიშვნელობის მიღება
   if (sensorValue >= threshold) { 
      // თუ კაკუნია რეგისტრირებული, შუქდიოდი აინთოს მაქსიმუმადე
      ledValue = 255;
   }
   // ნათების სიდიდის გადაცემა შუქდიოზე
   analogWrite(ledPin, int(ledValue) );
   ledValue = ledValue - 0.05; // შუქდიოდი ჩაქრეს ნელა
   if (ledValue <= 0) { ledValue = 0;} 
   //ledValue ნულზე ნაკლები არ უნდა იყოს 
}

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

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

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

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

ზემოთ მოყვანილ კოდში ახალი არაფერია.

აქ გამოცხადებულია ცვლადები და მოცემულია კომენტარები:

int ledPin = 9; // შუქდიოდი მე-9 გამომყვანზე 
// პიეზო მიერთებულია მე-5 ანალოგურ გამომყვანზე
int piezoPin = 5; 
// სესორის საწყისი მინიშვნელობა მის გააქტიურებამდე
int threshold = 120; 
// ცვლადი რომელიც ინახავს სენსსორიდან მიღებული
// სიგნალის სიდიდეს
int sensorValue = 0; 
float ledValue = 0; //შუქდიოდის ნათების სიდიდე. 

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

void setup() {
   pinMode(ledPin, OUTPUT);
   digitalWrite(ledPin, HIGH); 
   delay(150); 
   digitalWrite(ledPin, LOW); 
   delay(150);
   digitalWrite(ledPin, HIGH); 
   delay(150); 
   digitalWrite(ledPin, LOW); 
   delay(150);
}

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

sensorValue = analogRead(piezoPin);

შემდეგ, პროგრამული კოდი ამოწმებს არის თუა არა მიღებული სიგნალის სიდიდე მეტი ან ტოლი (>=) ვიდრე threshold-თვის მინიჭებული საწყისი მნიშვნელობა.და თუ მეტი ან ტოლი მაშინ ledValue-ს მიენიჭება 255, რას არის PWM ტიპის №9(Pin 9) ციფრული კონტაქტზე გამომავალი ძაბვის მაქსიმალური სიდიდე.

if (sensorValue >= threshold) {
    ledValue = 255;
}

და ეს სიდიდე გადაეცემა PWM Pin 9-ს. რადგან ledValue არის float ტიპის, საჭიროა მისი გარდაქნა integer ტიპად, რადგან analogWrite ფუნქციისათვის დასაშვებია მხოლოდ integer ტიპის ცვლადები:

analogWrite(ledPin, int(ledValue) );

შემდეგ ledValue ცვლადი მნიშვნელობა მცირდება, მას თანდათან აკლდება 0,05

ledValue = ledValue – 0.05;

და შუქდიოდი ნელა ჩაქრება თუ არ დაფიქსირდა ახალი კაკუნი.

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

პროექტი №12 – პიეზო პლეერი.

ამ გაკვეთილში გავაკეთოთ პიეზო პლეიერი. გამოვიყენოთ მე-11 გაკვეთილის სქემა.

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

ქვემოთ მოყვანილი კოდი გადაიტანეთ ID-ში.

// Project 12 - პიეზო პლეერი. 
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define WHOLE 1
#define HALF 0.5
#define QUARTER 0.25
#define EIGHTH 0.125
#define SIXTEENTH 0.0625


int tune[] = { NOTE_C4, NOTE_C4, NOTE_C4, NOTE_C4, 
NOTE_C4, NOTE_B3, NOTE_G3, NOTE_A3, NOTE_C4, 
NOTE_C4, NOTE_G3, NOTE_G3, NOTE_F3, NOTE_F3, 
NOTE_G3, NOTE_F3, NOTE_E3, NOTE_G3, NOTE_C4, 
NOTE_C4, NOTE_C4, NOTE_C4, NOTE_A3, NOTE_B3, 
NOTE_C4, NOTE_D4};

float duration[] = { EIGHTH, QUARTER+EIGHTH, SIXTEENTH,
QUARTER, QUARTER, HALF, HALF, HALF, QUARTER, QUARTER, 
HALF+QUARTER, QUARTER, QUARTER, QUARTER, QUARTER+EIGHTH, 
EIGHTH, QUARTER, QUARTER, QUARTER, EIGHTH, EIGHTH, 
QUARTER, QUARTER, QUARTER, QUARTER, HALF+QUARTER};

int length;
void setup() {
    pinMode(8, OUTPUT);
    length = sizeof(tune) / sizeof(tune[0]);
}
void loop() {
     for (int x=0; x<length; x++) {
         tone(8, tune[x]);
         delay(1500 * duration[x]);
         noTone(8);
     }
     delay(5000);
}

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

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

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

#define PI 3.14159265358979323846264338327950288419716939937510

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

მეორე მაგალითი:

#define TRUE 1
#define FALSE 0

პროგრამაში TRUE ან FALSE ჩაწერა ყველსასათვის უფრო გასაგებია თუ რას ნიჩნავს, ვიდრე მხოლოდ 1ან 0. პროგრამის მსვლელობის დროს კი, ყველა TRUE ან FALSE შეიცვლება შესაბამისად 1–ითან 0–ით.

კიდევ ერთი მაგალითი: დავუშვათ დაგვჭირდა რაღაც ტაბლოს გარჩევის უნარიანობის განსაღვრა სიდიდით 8 x 32. მოსახერხებელი ტაბლოს, გნებავთ დიპლეის სიმაღლის (height) და სიგანის (width) განმსაზღვრელი დირექტივები ჩავწეროთ ასე:

#define DISPLAY_HEIGHT 8
#define DISPLAY_WIDTH 32

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

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

ამ პროექტში ჩვენ შევქმენით define directive-ების სია ნოტების დასახელებებით და შესაბამისი სიხშირეების მითითებით. სიაში პირველი ნოტი არის C3 და მისის სიხშირეა 131ჰც.

ნოტების შემდგომი ხუთი define directive არის ნოტების ხანგრძლივობა შესაბამისი მნიშვნელობები: მთელი ნოტა, ნახევარი, მეოთხედი. მერვედი და მეთექვსმეტედი. ეს მნიშვნელობები გამოიყენება თითოეული ნოტის ჟღერადობის ხანგრძლივოდის გამოსათვლელად მილიწამებში. მაგ მეოთხედი ნოტისთვის:

1500 x QUARTER = 375 milliseconds

ამ ორი define directive შემდეგ მოდის int ტიპის tune[] მასივი,რომელშიც ჩაწერილია მელოდია ანუ ნოტების თანმიმდევრობა:

int tune[] = { NOTE_C4, NOTE_C4, NOTE_C4, NOTE_C4,
NOTE_C4, NOTE_B3, NOTE_G3, NOTE_A3, NOTE_C4, NOTE_C4, 
NOTE_G3, NOTE_G3, NOTE_F3, NOTE_F3, NOTE_G3, NOTE_F3,
NOTE_E3, NOTE_G3, NOTE_C4, NOTE_C4, NOTE_C4, NOTE_C4, 
NOTE_A3, NOTE_B3, NOTE_C4, NOTE_D4};

შემდეგია float ტიპის duration[ ] მასივი. ამ მასივში მოცემულია მელოდიის თითოეული ნოტის ხანგრძლივობა:

float duration[] = { EIGHTH, QUARTER+EIGHTH, 
SIXTEENTH, QUARTER, QUARTER, HALF, HALF, 
HALF, QUARTER, QUARTER, HALF+QUARTER, QUARTER,
QUARTER, QUARTER, QUARTER+EIGHTH, EIGHTH, 
QUARTER, QUARTER, QUARTER, EIGHTH, EIGHTH,
QUARTER, QUARTER, QUARTER, QUARTER, 
HALF+QUARTER};

როგორც ხედავთ ციფრებით შევსებულთან შედარებით, define directive–ის გამოყენებით შედგენილი მასივის წაკითხვა და გაგება გაცილებით ადვილია.

შემდეგია int ტიპის ცვლადი სახელად length

int length;

რომელიც გამოიყენება მასივის სიგრძის(ანუ თითოეული ნოტის ”სიგრძის”) გამოსათვლელად და შესანახად.

setup()–ში მოცემული სტრიქონით მე-8 კონტაქტი არის გამომავალი:

pinMode(8, OUTPUT);

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

length = sizeof(tune) / sizeof(tune[0]);

sizeof ფუნქცია აბრუნებს მისთვის გადაცემული(ფრჩხილებში მოთავსებული) პარამეტრის ბაიტების რაოდენობას. (არდუინოში integer ტიპს გამოყოფილი აქვს 2 ბაიტი, ბაიტი კი შედგება 8 ბიტისაგან). ჩვენი მელოდია შედგება 26 ნოტისაგან, ანუ tunes[]მასივი შეიცავს26 ელემენტს. მთელი მასივის ზომა ბაიტებში იქნება:

sizeof(tune)

გავყოფთ ამ მიღებულ სიდიდეს ერთი ელემენტის ზომაზე ბაიტებში:

sizeof(tune[0])

მივიღებთ length–ის სიდიდეს:

26 / 2 = 13

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

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

მთავარ ციკლში მოცემულია for ციკლი, რომელიც შესრულდება იმდენჯერ რამდენი ნოტიც დავთვალეთ length–ის საშუალებით

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

მე-8 გამომავალ კონტაქტს გადაეცემა tune[] მასივში მოცემულინოტები .

tone(8, tune[x]);

თითიეული ნოტის გაიჟღერებს

delay(1500 * duration[x]);

მილიწამის განმავლობაში.

საბაზისო 1500 მილიწამი გამრავლებულია ნოტის ხანგრძლივობაზე (მაგ 1500*0,25 მეოთხედი ნოტისთვის და 0,125-ზე მერვედი ნოტისთვის)

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

noTone(8);

გასაგებია, რომ ეს ნიშნავს სიგნალის შეწყვეტას.

ეს ბრძანება საჭიროა იმისათვის, რომ ყოველი ნოტი გაჟღერდეს ინდივიდუალურად არ მივიღოთ რაღაც ერთი გრძელი გადაბმული მელოდია.

ბოლოს, for ციკლის დასრულების შემდეგ, მელოდიის შემდგომ გამეორებამდე დგას 5 წამიანი დაყოვნება:

delay(5000);

შემდეგ გაკვეთილში გავარჩევთ კაკუნის, ვიბრაციის სენსორს (Knock Sensor).

პროექტი № 11 – პიეზო სირენა.

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

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

პიეზო დისკი

კონტაქტები*

*ამ პროექტისთვის აუცილებელი არ არის. შეგიძლიათ პიეზო ელემენტის გამომყვანებს მიარჩილოთ 22 awg მავთული(იხ. გაკვეთლი 1, სურ. 2-8.) და ჩართოთ დაფაში, ან არდუინოში.

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

სქემა მარტივია, განმარტებები საჭირო არ არის.

მხოლოდ ერთი: არდუინო უნდა იყოს გამორთული

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

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

// Project 11 – პიეზო სირენა

float sinVal;
int toneVal;
void setup() {
     pinMode(8, OUTPUT); 
}
void loop() {
     for (int x=0; x<180; x++) {
                   // გრადუსის გადაყვანა რადიანებში
         sinVal = (sin(x*(3.1412/180)));
                   // სინუსის მნიშვნელობიდან სიხშირის მიღება
         toneVal = 2000+(int(sinVal*1000));
         tone(8, toneVal);
         delay(2);
     }
}

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

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

ვაცხადებთ ორ ცვლადს:

 
float sinVal;
int toneVal;

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

setup ფუნქციაში მე-8 კონტაქტი გამოცხადებულია როგორც გამომავალი.

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

მთავარ ციკლში, ჩასმულია for ციკლი 0 დან 179 ჩათვლით იმისათვის, რომ გამოვრიცხოთ სინუსის უარყოფითი მნიშვნელობები (იხ. გაკვეთილი 7):

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

გადავიყვანოთ x -ის გრადუსული ზომა რადიანებში (იხ. გაკვეთილი 7):

sinVal = (sin(x*(3.1412/180)));

მიღებული მნიშვნელობები გადავიყვანოთ სიხშირულ დიაპაზონად.

toneVal = 2000+(int(sinVal*1000));

2000-ს ემატება sinVal გამრავლებული 1000-ზე და ვღებულობთ 2000-3000ჰც დიაპაზონს

შემდეგ სტრიქონში გამოყენებულია tone() ბრძანება რომელიც გენერირებს და აგზავნის სიხშირეს პიეზო დინამიკზე:

tone(8, toneVal);

tone() ბრძანებას გადაეცემა ორი ან სამი პარამეტრი

tone(pin, frequency) – (კონტაქტი, სიხშირე)

tone(pin, frequency, duration) – (კონტაქტი, სიხშირე, ხანგრძლივობა)

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

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

პიეზო ელემენტი.

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

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

პროექტი № 9 – ღია ცეცხლის ეფექტი

დაგვჭირდება:
წითელი შუქდიოდი                       
2 ცალი ყვითელი შუქდიოდი       
3 ცალი რეზისტორი                         

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

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

სურ. 3-6.

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

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

// პროექტი № 9 – ღია ცეცხლის ეფექტი

int ledPin1 = 9;
int ledPin2 = 10;
int ledPin3 = 11; 
void setup()
{
    pinMode(ledPin1, OUTPUT);
    pinMode(ledPin2, OUTPUT);
    pinMode(ledPin3, OUTPUT);
} 
void loop()
{
    analogWrite(ledPin1, random(120)+135);
    analogWrite(ledPin2, random(120)+135);
    analogWrite(ledPin3, random(120)+135);
    delay(random(100));
}

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

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

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

int ledPin1 = 9;
int ledPin2 = 10;
int ledPin3 = 11;

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

pinMode(ledPin1, OUTPUT);
pinMode(ledPin2, OUTPUT);
pinMode(ledPin3, OUTPUT);

პროგრამის მთავარი ციკლი აგზავნის შემთხვევით მნიშვნელობებს [0;120]; და დამატებული 130(მაქსიმალური ნათების მისაღებად) PWM ტიპის კონტაქტებზე 9, 10, and 11:

analogWrite(ledPin1, random(120)+135);
analogWrite(ledPin2, random(120)+135);
analogWrite(ledPin3, random(120)+135);

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

delay(random(100));

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

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

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

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

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

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) შუალედში, როდესაც არგუმენტი იცვლება 0⁰ გრადუსიდან 180⁰ გრადუსამდე (180⁰-360⁰ არ გვჭირდება რადგან ამ შუალედში სინუსი უარყოფითია).

სინუსის გამოსათვლელად საჭიროა გრადუსული ზომის გადაყვანა რადიანებში 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-ს.