პროექტი №10 – Serial Monitor-ით მართული RGB ნათურა.

მერვე გაკვეთილის გარძელება.

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

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

აკრიფეთ ქვემოთ მოყვანილი კოდი, შეამოწმეთ და ჩატვირთეთ არდუინოში. (თქვენ რათქმაუნდა კოდს არ კრეფთ, არამედ copy, paste და პირდაპირ IDE-ში).

// Project 10 – Serial Monitor-ით მართული RGB ნათურა.

char buffer[18];
int red, green, blue;
int RedPin = 11;
int GreenPin = 10;
int BluePin = 9;
void setup()
{
   Serial.begin(9600);
   Serial.flush();
   pinMode(RedPin, OUTPUT);
   pinMode(GreenPin, OUTPUT);
   pinMode(BluePin, OUTPUT);
}

void loop()
{
   if (Serial.available() > 0) {
      int index=0;
      delay(100); // დაყოვნება, ბუფერმა რომ შეძლოს შევსება
      int numChar = Serial.available();

      if (numChar>15) {
         numChar=15;
      }

      while (numChar--) {
         buffer[index++] = Serial.read();
      }
      splitString(buffer);
   }
}

void splitString(char* data) {
   Serial.print("Data entered: ");
   Serial.println(data);
   char* parameter;
   parameter = strtok (data, " ,");
   while (parameter != NULL) {
      setLED(parameter);
      parameter = strtok (NULL, " ,");
   }
   // ტექსტის წაშლა და ბუფერის გაწმენდა
   for (int x=0; x<16; x++) {
      buffer[x]='';
   }
   Serial.flush();
}

void setLED(char* data) {
   if ((data[0] == 'r') || (data[0] == 'R')) {
      int Ans = strtol(data+1, NULL, 10);
      Ans = constrain(Ans,0,255);
      analogWrite(RedPin, Ans);
      Serial.print("Red is set to: ");
      Serial.println(Ans);
   }
   if ((data[0] == 'g') || (data[0] == 'G')) {
      int Ans = strtol(data+1, NULL, 10);
      Ans = constrain(Ans,0,255);
      analogWrite(GreenPin, Ans);
      Serial.print("Green is set to: ");
      Serial.println(Ans);
   }
   if ((data[0] == 'b') || (data[0] == 'B')) {
      int Ans = strtol(data+1, NULL, 10);
      Ans = constrain(Ans,0,255);
      analogWrite(BluePin, Ans);
      Serial.print("Blue is set to: ");
      Serial.println(Ans);
   }
}

როდესაც პროგრამას გაუშვებთ ვიზუალურად არაფერიც არ მოხდება. იმიტომ, რომ პროგრამა ელოდება თქვენს ბრძანებას. დააწკაპუნეთ IDE-ში შესაბამის პიქტოგრამაზე და გაუშვით Serial Monitor. ტექსტის ფანჯარაში შეიყვანეთ თითოეული R, G, და B შუქდიოდების ნათების შესაბამისი მნიშნელობები. შედეგად მივიღებთ რაღაც ჯამურ ფერს. მაგ. თუ ჩაწერთ მხოლოდ R255, მაშინ წითელი შუქდიოდი აინთება სრული სიკაშკაშით. თუ ჩაწერთ R255, G255, მაშინ ორივე, წითელი და მწვანე გაანათებს სრული სიკაშკაშით. ჩაწერეთ R127, G100, B255 შედეგად მიიღებთ მეწამულ-იასამნის ფერს. ჩაწერეთ r0, g0, b0 და სამივე შუქდიოდი ჩაქრება. ტექსტის შეყვანა შეიძლება ქვედა და ზედა რეგისტრშიც, ხოლო მნიშვნელობები კი უნდა იყოს [0; 255] დიაპაზონში. ([]კვადრატილი ფრჩხილები ნიშნავს, რომ 0 და 255 ამ დიაპაზონს ეკუთვნის.)

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

r255 b100
r127 b127 g127
G255, B0
B127, R0, G255

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

ამ გაკვეთილში პირველად განვიხილავთ ისეთ ახალ საკითხებს, როგორიცაა serial monitor -თან კავშირი, მაჩვენებლები (pointers), და სტრიქონის გამოყენება.

პირველ რასაც ვაკეთებთ, არის char (characters) ტიპის მასივის გამოცხადება, ტექსტის 18 სიმბოლოიანი სირგძის მითითებით.

char buffer[18];

შემდეგ ვაცხადებთ integer ტიპის წითელი, მწვანე, ლურჯი ფერის შესაბამის red, green, blue ცვლადებს და გამოყენებულ ციფრულ კონტაქტებს:

int red, green, blue;
int RedPin = 11;
int GreenPin = 10;
int BluePin = 9;

მომდევნო setup ფუნქციაში ვაცხადებთ სამ PWM გამომყვან კონტაქტს. მაგრამ ფუნქცია იწყება ბრძანებით Serial.begin:

void setup()
{
   Serial.begin(9600);
   Serial.flush();
   pinMode(RedPin, OUTPUT);
   pinMode(GreenPin, OUTPUT);
   pinMode(BluePin, OUTPUT);
}

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

Serial.flush ბრძანება საჭიროა, რომ გაიწმინდოს, წაშალოს ნებისმიერ სიმბოლო და serial monitor-ის ფანჯარა მზად იყოს არდუინოზე ბრძანებების გადასაცემად და იქედან ინფორმაციის მისაღებად.

მთავარ ციკლში გვაქვს ifპირობა:

if (Serial.available() > 0) {

რომელიც იყენებს რა Serial.available ბრძანებას, ამოწმებს ჩავწერეთ თუ არა ახლიდან რაიმე სიმბოლო serial monitor-ის ფანჯარაში. ხოლო თუ ჩაწერილია მაშინ შესრულდება if პირობისბლოკში{ } მოთავსებული კოდი:

if (Serial.available() > 0) {
   int index=0;
   delay(100); // დაყოვნება, ბუფერმა რომ შეძლოს შევსება
   int numChar = Serial.available();
   if (numChar>15) {
      numChar=15;
   }
   while (numChar--) {
      buffer[index++] = Serial.read();
   }
   splitString(buffer);
}

გამოვაცხადეთ integer ტიპის ცვლადი სახელად index თავდაპირველად ის ნულის ტოლია. ეს ცვლადი ღებულობს მნიშვნელობებს, რომელიც აღნიშნავს მაჩვენებლის (pointer) პოზიციას char ტიპის მასივში არსებულ რომელიღაც სიმბოლოზე.

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

რადგან სიმბოლოების სტრიქონის შეყვანის დროს Serial.available ფუნქცია მყისიერ ღებულობს ნულზე მეტი სიდიდის მონაცემებს, ამიტომ კოდის შემდგომ სტრიქონში მოთავსებული if ფუნქციას შეუძლია დაიწყოს თავისი კოდი შესრულება. ამიტომ, რომ არ იყოს delay(100) დაყოვნება, მაშინ , როგორც უკვე ავღნიშნეთ, შესაძლებელია delay()ისმომდევნო if პირობა ჩაითვალოს უკვე შესრულებულად და მოხდეს serial monitor-ის ფანჯარაში აკრეფილი სტრიქონის მხოლოდ საწყისი ნაწილის გადაცემა არდუინოში. რაც იქნება არასწორი.

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

თუ Serial Monitor-ში შეყვანილია

R255, G255, B255

მაშინ numChar მნიშვნელობა იქნება 17 და არა 16, იმიტომ, რომ ყოველი ტექსტის ბოლო არის უხილავი სიმბოლო სახელად NULL რომელიც ეუბნება არდუინოს რომ მიღწეულია სტრიქონის ბოლო.

შემდეგი if ამოწმებს არის თუ არა numChar მნიშვნელობა 15-ზე მეტი, და თუ მეტია, მაშინ მინიჭებს მას 15. ეს აუცილებელია იმისათვის, რომ მასივი char buffer[18]არ გადაივსოს.

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

while(expression) {
       // ოპერატორები
}

ჩვენს პროგრამაში ციკლი whileასე გამოიყურება:

while (numChar--) {
     buffer[index++] = Serial.read();
}

შესამოწმებელი სიდიდე, პირობა, არის numChar. ანუ მოწმდება, რომ ის მნიშვნელობა რომელიც ინახება integer ტიპის numChar ცვლადში არ არის ნული ტოლი. მიაქციეთ ყურადღება, რომ numChar შემდეგ მოდის . ეს არის ე.წ. პოსტდეკრემეტი(post-decrement): რაც ნიშნავს, რომ შესამოწმებელი სიდიდე იქნება დეკრემენტირებული, მხოლოდ მისი გამოყენების შემდეგ. ანუ numChar-ს გამოკლდება 1 მანამ, სანამ ის იქნება ხელახლა შემოწმებული. ჩვენს შემხვევაში while ციკლი ამოწმებს numChar და შემდეგ გამოაკლებს 1. თუ numChar არ არის ნულის ტოლი, მაშინ შესრულდება ფიგურულ ფრჩხილებში მოთავსებული კოდი.

რადგან numChar წარმოადგენს Serial Monitor-ის ფანჯარაში შეყვანილი ტექსტური სტრიქონის სიგრძეს, ამიტომ while ციკლში მოთავსებული კოდი შესრულდება რამოდენიმეჯერ.

while ციკლში მოთავსებული კოდი არის:

buffer[index++] = Serial.read();

რომელიც Serial Monitor-ის ფანჯარაში შეყვანილი ტექსტური სტრიქონის თითოეულ სიმბოლოს მიაკუთვნებს ბუფერის მასივის თითოეულ ელემეტს. Serial.read() ბრძანება კითხულობს შემოსულ მიმდევრობით მონაცემებს, თითო ბაიტს ცილის თითო გავლაზე. შეყვანილი სიმბოლოებით სტრიქონული მასივის შევსების შემდეგ while ციკლი დმათვრდება მაშინ როდესაც numChar გახდება ნული.

while ციკლის შემდეგ მოდის შემდეგი სტრიქონი:

splitString(buffer);

რომელის არის splitString() ფუნქციის გამოძახება. ეს ფუნქცია კი ასე გამოიყურება:

void splitString(char* data) {
   Serial.print("Data entered: ");
   Serial.println(data);
   char* parameter;
   parameter = strtok (data, " ,");
   while (parameter != NULL) {
       setLED(parameter);
       parameter = strtok (NULL, " ,");
   }
   // ტექსტის წაშლა და ბუფერის გაწმენდა
   for (int x=0; x<16; x++) {
       buffer[x]='';
   }
   Serial.flush();
}

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

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

ჩვენთვის კი საკმარისი ვიცოდეთ, რომ ცვლადების როგორც მითითებლის გამოცხადებით, ეს უკანასკნელი ხდება ცვლადი რომელიც მიუთითებს ანუ მიანიშნებს სხვა ცვლადზე. ჩვენ შეგვიძლია ან & სიმბოლოს გამოყენებით მივუთითოთ ის მისმართი მახსოვრობაში სადაც ინახება ცვლადი, ან ამ მისამართზე შენახული ცვლადის სიდიდე ანუ მნიშვნელობა *სიმბოლოს გამოყენებით. ასე შეგვიძლია ”მოვატყუოთ” სისტემა, რადგან C\C++ში ნებადართულია სიმბოლოების მასივის მაჩვენებლების გადაცემა ფუნქციისათვის.

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

საბოლოოდ და მოკლედ: გამოვიძახეთ რა splitString(), ჩვენ მას სრულად გადავეცით ბუფერში მყოფი სიმბოლოების მასივი,

splitString(buffer);

პირველი სტრიქონი ფუნქციაში არის:

Serial.print(“Data entered: “);

ამ გზით შეიძლება მონაცემების გადმოგზავნა არდუინოდან უკან, კომპიუტერში. აქ მოცემული print ბრძანება ბრჭყალებში მოთავსებულ ნებისმიერ სიმბოლოებს USB კაბელის საშუალებით აგზავნის უკან, კომპიუტერში რომელიც გამოჩნდება Serial Monitor-ის ფანჯარაში. ჩვენს შემთხვევაში ფანჯარაში გამოვა Data entered: . დააკვრდით, ორწერტილის შემდეგ არის შუალედი, ინტერვალი, რომელის შემდეგ გამოვა მომდევნო ტექსტი.

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

Serial.println(data);

აქაც ადგილი აქვს მონაცემების გადაცემას არდუინოდან კომპიუტერზე. გადაიცემა char ტიპის ცვლადის data-ს მნიშვნელობები, რომლიც არის ბუფერში შენახული მონაცემების ასლი. მაგ. თუ თავიდან Serial Monitor-ის ფანჯრიდან არდუინოში გადაცემული იყო:

R255 G127 B56

მაშინ გახილული სტრიქონი

Serial.println(data);

კომპიუტერში, Serial Monitor-ის ფანჯარაში დააბრუნებს იგივე ტექსტს.

ასევე ყურადღება მიაქციეთ print ბრძანების ის ბოლოში lnს. println ბრძანება ნიშნავს Serial Monitor-ის ფანჯარაში ინფრომაციის გამოყვანას და ამის შემდეგ ახალ სტრიქონზე გადასვლას. განხვავებით print ბრძანებისგან, როდესაც ახალ სრიქონზე გადასვლა არ ხდება.

საბოლოოდ, ამ არი ბრძანების შემდეგ:

Serial.print("Data entered: ");
Serial.println(data);

ეკრანზე გამოვა ჯერ Data entered: შემდეგ კურსორი დარჩება ტექსტის ბოლოს იმავე სტრიქონზე, ერთი ინტერვალით მარჯვნივ გადასული. შემდეგ, მეორე ბრძანება გამოიყვანს არდუინოზე ადრე გადაგზავნილ ტექსტს და მხოლოდ ამის შემდეგ გადავა კურსორი ახალ სტრიქონზე.

მომდევნო სტრიქონი ქმნის char ტიპის მოცემების ცვლადს სახელად parameter

Char* parameter;

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

შემდეგი ბრძანებაა strtok, რომელიც საკმაოდ სასრგებლოა ტექსტთან სამუშაოდ.

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

პირველი არგუმენტი რომელსაც გადავცემთ strtok-ს არის data მასივი, ხოლო მეორე არგუმენტი კი ბრჭყალებში მოქცეული მოსაძებნი სიმბოლო( token). ამიტომ შემდეგი სტრიქონი ასე გამოიყურება:

parameter = strtok (data, ” ,”);

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

მაგ. თუ შეყვანილი იყო სტრიქონი:

R127 G56 B98

მაშინ parameter მიიღებს მნიშნელობას:

R127

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

შემოგვაქს while ციკლი, სადაც მითითებულია პირობა, რომ parameter არ არის ცარიელი, ანუ სტიქონი ბოლომდე არ არის დამუშავებული:

while (parameter != NULL) {

ამავე ციკლში ვიძახებთ მეორე ფუნქციას:

setLED(parameter);

(რომლის მუშაობას მოგვიანებით განვიხილავთ). შემდეგ parameter ცვლადს ვიყენებთ ტექსტის დარჩენილ ნაწილში მომდევნო შუალედის ან მძიმის მოსაძებნად. ამისათვის strtok-ს გადავცემთ NULL პარამეტრს შემდეგნაირად:

parameter = strtok (NULL, ” ,”);

რომელიც მიუთითებს strtok ბრძანებას გაარძელოს მოქმედება ბოლო გაჩერების ადგილიდან.

ფუნქციის შემდეგი ნაწილი:

char* parameter;
parameter = strtok (data, " ,");
while (parameter != NULL) {
      setLED(parameter);
      parameter = strtok (NULL, " ,");
}

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

განხილული splitString() ფუნქციის დარჩენილი ნაწილი ბუფერულ მასის ავსებს NULL სიდიდით, რომელიც ხორციელდება \0 სიმბოლოთი, ხოლო შემდეგ, გაწმენდს მიდევრობითი ბუფერს მონაცემებისაგან, ამის შემდეგ ბუფერი მზად იქნება ახალი მოცემების მისაღებად.

// ტექსტის წაშლა და ბუფერის გაწმენდა

for (int x=0; x<16; x++) {
    buffer[x]='';
}
Serial.flush();

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

მაგ. თუ ჩავწერეთ:

G125 B55

მაშინ splitString() ფუნქცია მას დაყოფს ორ დამოუკიდებელ ნაწილად :

G125

B55

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

დავუბრუნდეთ setLED() ფუნქციას:

void setLED(char* data) {
    if ((data[0] == 'r') || (data[0] == 'R')) {
       int Ans = strtol(data+1, NULL, 10);
       Ans = constrain(Ans,0,255);
       analogWrite(RedPin, Ans);
       Serial.print("Red is set to: ");
       Serial.println(Ans);
    }
    if ((data[0] == 'g') || (data[0] == 'G')) {
       int Ans = strtol(data+1, NULL, 10);
       Ans = constrain(Ans,0,255);
       analogWrite(GreenPin, Ans);
       Serial.print("Green is set to: ");
       Serial.println(Ans);
    }
    if ((data[0] == 'b') || (data[0] == 'B')) {
       int Ans = strtol(data+1, NULL, 10);
       Ans = constrain(Ans,0,255);
       analogWrite(BluePin, Ans);
       Serial.print("Blue is set to: ");
       Serial.println(Ans);
    }
}

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

if ((data[0] == 'r') || (data[0] == 'R')) {
   int Ans = strtol(data+1, NULL, 10);
   Ans = constrain(Ans,0,255);
   analogWrite(RedPin, Ans);
   Serial.print("Red is set to: ");
   Serial.println(Ans);
}

if პირობა ამოწმებს, რომ ტექსტის ნაწილში data[0] პირველი სიმბოლო არის ასო r ან R. C და C++ განასხვავებს ქვედა და ზედა რეგისტრებს. r და R ასოების არჩევისათვის გამოიყენება ლოგიკური ბრძანება OR(ან), რომლის სიმბოლოა ||.

თუ პირველი სიმბოლო არის r ან R, მაშინ if პირობამ ”იცის”, რომ გვინდა შევცვალოთ წითელი შუქდიოდის ნათება და ის შესრულბს შესაბამის კოდს. ამისათვის ვაცხადებთ int ტიპის ლოკალურ ცვლადს Ans (გამოყენება მხოლოდ შუქდიოდის პარამეტრის შესაცვლელად) და ვიყენებთ strtol (Stringდან long integer-ზე) ბრძანებას იმისათვის, რომ გარდავქმნათ R(r) -ის შემდეგ შეყვანილი სიმბოლოები integer ტიპად. strtol ბრძამებას აქვს სამი პარამეტრი. პირველი, იმ სიმბოლოების ერთობლიობა რომელის უნდა გადაეცეს მას. მეორე, მაჩვენებელი(pointer) integer-ის შემდგომ მყოფ სიმბოლოზე(მაგრამ არ ვიყენებთ, რადგან, ჩვენ უკვე დავყავით სიმბოლოების მწკრივი strtok ბრძანების გამოყენებით და ამიტომ ან შემთხვევაში გადავცემთ NULL სიმბოლოა), და თვლის სისტემა, ჩვენს შემთხვევაში ათობითი, რაზეც მითუთითებს მესამე პარამეტრი 10.

მოკლედ რომ ვთქვათ, შემოვიღეთ integer ტიპის ცლადი, გადავეცით მას R-ის შემდეგ ჩაწერილი მნიშვნელობა, შემდეგ constrain ბრძანებით დავადგინეთ, რომ Ans იცვლება [0 ; 255] შუალედში. ამის შემდეგ analogWrite ბრძანებით წითელი შუქდიოდის კონტაქტს გადავეცით Ans მნიშნელობა. ხოლო შემდეგ Serial.print ბრძანებით Serial Monitor-ის ფანჯარაში გავაგზავნეთ Red is set to:და Ans მნიშვნელობა. დანარჩენი ორი if-ის მოქმედება კი განხილულის იდენტურია.

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

№№11,12,13, და 14 გაკვეთილებში განვიხილავთ პიეზო ელემენტის გამოყენებას.

One Response to პროექტი №10 – Serial Monitor-ით მართული RGB ნათურა.

  1. scienceasm says:

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

Leave a Reply

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

WordPress.com Logo

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

Google photo

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

Twitter picture

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

Facebook photo

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

Connecting to %s

%d bloggers like this: