პირველი პროექტი AVR მიკროკონტროლერზე

November 24, 2012

პირველათ როდესაც მიკროკონტროლერზე იწყებ მოშაობას, ცდილობ რაც შეიძლება მარტივი მაგალითიდან დაიწყო მაგალითად შუქდიოდის აციმციმება, ისევე როგორც პროგრამირების ენის სწავლისას პირველი პროგრამაა კონსოლზე “hello, world!” -ის დაწერაა. ჩვენს შემთხვევაშიც, მიმოვიხილავთ პირველ რამოდენიმე საფეხურს მიკროკოტროლერებთან სამუშაოთ და ავაწყობთ პირველ საცდელ პროექტს.  პირველი რაც დაგვჭირდება ეს არის პროგრამატორი STK-200 , რისი აწყობაც უმარტივესია LPT პორტზე, დაგვჭირდება პრინტერის პორტის კონექტორი და რამოდენიმე რეზისტორი. პროგრამატორის სქემა მოცემულია ქვემოთ, რეზისტორები შეიძლება შიეირჩეს 220-330 ომის შუალედში, და დაყენდეს კონექტორშივე, დამატებითი პლატის გამოყენების გარეშე.



პროგამატორის აწყობის შემდეგ დაგვჭირდება პროგრამა პროგრმატორი. ერთერთი ასეთი მარტივი პროგრამატორია PonyProg – ი.
(PonyProg-ს გადმოსაწერი ბმული.  ჩამონათვალში პიველი არის ძველი ვერსია, ხოლო მის ქვემოთ ახალი ეწ. ბეტა ვერსიებია, გადმოვიწერთ ახალ ბეტა ვერსია და დავაინსტალიროთ.)
მიკროკოტროლერისთვის პროგრამა შეიძლება დაიწერო ასემბლერში ან რაიმე შედარებით მაღალი დონის ენით მგალითად C, Basic, Pascal, ხოლო შემდეგ დაკომპილირდეს (გარდაიქმნას ორობით კოდათ) ეწ. .hex ფორმატში და შემდგომ ჩაიწეროს მიკოროკონტროლერში. .hex ფორმატი წარმოადგენს ორობითი კოდის ჩანაწერს 16-ით ათვლის სისტემაში და მიღებულია .hex ფორმატში კომპილირება რადგან ადვილია 16-ით კოდში ცალკეული ელემენტების გარჩევა ვიდრე ორობით კოდში.
არა აქვს მნიშვნელობა პროგრამას დაწერ ასემბლერში C -ზე თუ სხვა რომელიმე ენაზე, ყველა შემთხვევაში საჭიროა ეწ. კომპილატორი, პროგრამა რომელიც სიტყვებით და აბრევიატურებით დაწერილ ბრძანებებს გადაიყვანს კონტროლერისთვის გასაგებ ენაზე ორობით კოდში. ასემბლერზე პროგრამის დაწერა შრომატევადია და კომპლექსური ამოცანებისთვის თითქმის გამოუსადეგარი ხდება. ასემბლერზე პროგრამის დაწერა რეკომენდირებულია მაშინ როდასაც საჭიროა რაც შეიძლება ოპტიმალური და მაღალი სიზუსტის პროგრამა. მაგრამ, ჩვენს შემთხვევაში საქმეს არ გავირთულებთ და პროგრამას დავწერთ C ზე.  C კომპილატორები მრავალია და ყველაზე ცნობილი ვარიანტებია: IAR, mikroC, CodeVisionAVR, GCC. აქედან პირველი სამი ფასიანია ხოლო GCC უფასო კომპილატორია. მოცემული კომპილატორებიდან ავიჩიოთ GCC კომპილატორი, რადგან ყველაზე გავრცელებული GNU კომპილატორია თან კონტროლერების და მიკროპროცესორების მწარმოებლებისგან ყველაზე მეტადაა რეკომედირებული.
გადმოვიწეროთ Atmel Studio Atmel-ის IDE (Integrated Development Environment), მომელსაც მოყვება GCC C და C++ კომპილატორები. დავაინსტალიროთ (დაინსტალირების დროს პროგრამა მოითხოვს .net Framework-ის დაყენაბას თუ არა არის უკვე დაყენებული კომპიუტერზე. .Net Framework-ის გადმოწერა შეიძლება აქედან) და მივყვეთ პირველი პროექტის  თანმიმდევრობას (ვისაც .net პროექტეზე უმუშავია, მისთვის გარემო ნაცნობი იქნება, რადგან Atmel Studio იგივე Visual  Studio-ა).

მოციმციმე შუქციოდი

გაუშვათ AtmelStudio და ავირჩიოთ New Project > Installed Templates – C/C++ – GCC C Executable Project დავარქვათ TestProject და OK, მიკროკონტროლერი ავირჩიოთ ATtiny2313. თანმიმდევრობა .gif ანიმაციაზეა ნაჩვენები.

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

/*
 * TestProject.c
 *
 * Created: 11/22/2012 6:37:43 PM
 *  Author: scienceasm
 */ 

#define F_CPU 1000000UL //პროცესორის ტაქტური სიხშირის განსაზღვრა 1MHz-ით
#include <avr/io.h>     //input output ფუნქციების ბიბლიოთეკის მიბმა
#include <util/delay.h> 
//ფუნქციების ბიბლიოთეკის მიბმა,_delay_ms ფუნქციის გამოსაყენებლათ

int main(void)   //მთავარი ფუნქციის დასაწყისი
{
    DDRB=0xFF;  //PORT B იყოს Output-ი. 
    // 0x ნიშნავს რომ ჩანაწერი არის თექვსმეტობით ათვლის სისტემაში
    PORTB=0x00; //PORT B -ს განულება

    while(1)    //უწვეტი ციკლის დასაწყისი
    {
        PORTB=0b00000000;//port B რეგისტრის განულება
        // 0b მიუთითებს რომ ჩანაწერი არის ორობით ათვლის სისტემაში
        _delay_ms(500); //დაყოვნების ფუნქცია დაახლოვებით 500ms-ით
        PORTB=0b00000001;//port B0 ბიტი = 1
        _delay_ms(500);        
    }//უწყვეტი ციკლის დასასრული, ამ შემთხვევაში ციკლი არ სრულდება 
     //და მუდმუვათ მეორდება, ანუ მოცემული ადგილიდან ბრუნდება ისევ
     //while ციკლის დასაწყისში.
}

პროგრამა საკმაოდ მარტივია და დამატებით განხილვას არ საჭიროებს მათვის ვინც C პროგრამირების ენის საფუძვლები მინიმალურ დონეზე მაინ იცის. კომპილაციისთვის მენიუდან ავირჩიოთ  Build > Rebuild Solution .  ვნახოთ როგორ მუშაობს ჩვენი პროგრამა Protheus-სში.
პროგრამა Proteus VSM მძლავრი საშუალებაა ელექტრონული სისტემების მოდელირებითვის, პროთეუსით შეგვიძლია ავაწყოთ სქემა მივაბათ კონტროლერს .hex ფაილი ან .elf ფაილი (.elf ფაილი იქმნება AtmelStudio-თი კომპილირების შედეგათ) და ვნახოთ თუ როგორ მუშაობს, თუ რამე შეცდომაა პროგრამაში ან სქემაზე გამოვასწორებთ, ამის შიმდეგ ავაწყობთ ფიზიკურად სქემას და უკვე აღარ მოგვიწევს რაიმეს გადაკეთება თუ პროგრამის ახლიდან გადაწერა) .
ავაწყოთ პროთეუსში სქემა, დაგვჭირდება: კონტროლერი ATtiny2313, რეზისტორი 10k, რეზისტორი 330ომი, შუქდიოდი.


ვისაც პროთეუსში არ უმუშავია კარგი იქნება თუ ელემენტარული უნარჩვევებისთვის გადახედავს ამ ვიდეოგაკვეთილებს მაგ. Proteus Isis Tutorial. 10 კილოომიანი რეზისტორით Reset შესასვლელზე მიწოდებულია დადებითი პოტენციალი, მიკროკონტროლერის Reset გამომყვანი დანიშნულია ყველა მოწყობილობის, რეგისტრები, ტაიმერები, პროგრამული თვლელი იქნება ეს თუ ALU(Arithmetic and Logic Unit)-ს ეწ. აპარატურული რესეტისთვის (ნულოვან მდგომარეობაში გადაყვანისთვის). ანუ იმ შემთხვევაში Reset შესასვლელზე მივაწოდეთ ლოგიკური ნულის ტოლი პოტენციალი (დაახლოვებით 0 ცოლტიდან 1 ვოლტამდე) მიკროკონტროლერს მთლიანად გადაიყვანს საწყის მგომარეობაში, და პროგრამაც დაიწყებს თავიდან მუშაობას. R2 რეზისტორით იზღუდება გამავალი დენის მნოშვნელობა დიოდში რომ არ გადააჭარბოს დასაშვებ დონეს. ადვილი შესამჩნევია, რომ პროთეუსში მიკროკონტროლერი არ არის კვების წყაროსთან შეერთებული, რადგან სიმულაციის პროცესში უბრალოთ იგულისხმება რომ მიერთებულია კვების წყარო.

სიმულაციის ასამუშავებლათ მიკროკოტროლერს მივაბათ .elf გაფართოვების ფაილი, შეგვიძლია ასევე .hex ფაილის მიბმა. თანმიმდევრობა ნაჩვენებია .gif ანიმაციაზე

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

აუცილებელია გაუშვათ PonyProg “Run as administrator”-ით, წინააღმდეგ შემთხვევაში პროგრამატორმა შეიძლება არ იმუშაოს.

დავაკონფიგურიროთ პროგრამატორის პორტი ისე როგორც ზემოთ არის ნაჩვენები, და ასევე ავირჩიოთ მიკროკონტროლერი რომლის დაპროგრამებაც გვინდა და მივუთითოთ .hex ფაილი, ჩვენს შემთხვევაში ფაილი მოთავსებულია *\Atmel Studio\TestProject\TestProject\Debug ფოლდერში.

ამის შემდეგ უკვე მიკროკოტროლერი მზათ არის დასაპროგრამებლათ, მაგრამ სანამ დავაპროგრამებთ გავხსნათ ისევ “I/O port setup” ფანჯარა და დავაჭიროთ Probe ღილაკს, თუ ფანჯარაში გაიხსნა “Test OK” ე.ი. ყველაფერი რიგზეა. (თუ “Test Failed” დაეწერა, გამოაერთეთ პროგრამატორი კონტროლერს და ახლიდან დააჭირეთ “Probe” ღილაკს, თუ ისევ “Test Failed” ამოაგდო ესეიგი პროგრამატორია არასწორედ აწყობილი.)  პროგრამის ჩასაწერათ დავაწვეთ Write Device -ს, ხოლო წასაკითხათ Read Device.

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


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

November 24, 2012

ამ გაკვეთილში გავაკეთოთ პიეზო პლეიერი. გამოვიყენოთ მე-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 – პიეზო სირენა.

November 19, 2012

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

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

პიეზო დისკი

კონტაქტები*

*ამ პროექტისთვის აუცილებელი არ არის. შეგიძლიათ პიეზო ელემენტის გამომყვანებს მიარჩილოთ 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 მილიწამიანი დაყოვნება, სიხშირის ახალ ცვლილებამდე.

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

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

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