ARDUİNO ÖĞRENİYORUM · 2019. 12. 19. · ARDUİNO ÖĞRENİYORUM PROGRAM YAPISI: void setup():...

ARDUİNO ÖĞRENİYORUM PROGRAM YAPISI:

void setup(): Değişkenleri başlatmak, Pin durumlarını belirlemek, kütüphaneleri kullanmaya başlatmak için kullanılır. Program çalışmaya başladıktan sonra ya da reset atıldıktan sonra bir kez çalışır.

Örnek1:

int buton = 3; // Buton değişkenine 3 sayısını yükle void setup() { Serial.begin(9600); // Bilgisayarla iletişim kurmak için Seri veri iletim hızını saniyedeki bit sayısı (baud) cinsinden ayarlar. pinMode(buton, INPUT); // 3 numaralı pini giriş yap. } void loop() { // ... }

void loop(): Program çalışmaya başladıktan sonra bu bölüm sürekli döngü halinde çalışır. Programın yazıldığı kısımdır.

Örnek1:

const int buton = 3; // buton değişkenine 3 sayısı yüklendi const bir daha değiştirilemeyeceğini ifade eder. void setup() { Serial.begin(9600); // Bilgisayarla iletişim kurmak için Seri veri iletim hızını saniyedeki bit sayısı (baud) cinsinden ayarlar. pinMode(buton, INPUT); // 3 numaralı pini giriş yap. } void loop() { // döngünün başladığı yer if (digitalRead(buton) == HIGH) // buton =1 ise Serial.write('H'); //ekrana H yaz else // değilse Serial.write('L'); //ekrana L yaz delay(1000); } // döngünün bittiği yer. Buradan döngünün başladığı yere gider. Örnekten de anlaşılacağı üzere loop içerisi sürekli döngü halinde tekrar tekrar çalıştırılır. ( , - arası ) Arduino çalışma sayfası açıldığında void setup() ve void loop() satırları otomatik olarak açılır.

#define: Program derlenmeden önce programcının sabit bir değere isim vermesine izin verir. Değişken değeri daha sonra değiştirilemez program hata verir. const int ile aynı görevi görür. const int; veri türleri bölümünde detaylı anlatılmaktadır. #define deger 5 // const int deger=5; ile aynı görevi görür. #define deger=5 ; //şeklinde yazarsak hata alırız herhangi bir eşittir yada noktalama işareti kullanılmaz.

#include: Hazır kütüphaneleri çağırmak için kullanılır. #include yada #include"kutuphane2.h" şeklinde kullanılır.

; {} // /**/ Kullanımı:

Noktalı virgül (;) : Satır sonlarında ; işareti kullanılır. Kullanılmadığı zaman derleyici hata verir böyle durumlarda bakılacak ilk iş hata satırının hemen üstünde ; işaretinin kullanılıp kullanılmadığıdır. Örnek1: pinMode(3,OUTPUT); // ( ; ) işareti koymasaydık hata verirdi.

Süslü parantez ( {} ) : Koşullu ifadelerde, fonksiyonlarda, döngülerde, dizilerde süslü parantez kullanılır. Örnek1: void loop(){ // } Örnek2: if (deger==5){ // } Örnek 3: for(i=1;i

Seri haberleşme: Yazdığımız programların doğruluğunu monitörde görüp test etmek için seri haberleşmeyi sıkca kullanacağız bu septen dolayı bu konuya öncelik vermek daha uygun olacaktır. Arduino kartı ile bir bilgisayar veya diğer cihazlar arasındaki iletişim için kullanılır. Seri haberleşme Dijital pin 0 (RX) ve 1 (TX) üzerinden ve ayrıca USB kablo aracılığı ile bilgisayar üzerinden iletişim kurar. Bu nedenle haberleşme esnasında , 0 (RX) ve 1 (TX) pimlerini dijital giriş veya çıkış olarak kullanamazsınız. 0 (RX) ve 1 (TX) pinlerine bluetooth gibi haberleşme modülü bağlanırsa USB bağlantısı ile karta program yüklerken hata alırız bu sebepten dolayı yükleme ve seri haberleşme esnasında 0 (RX) ve 1 (TX) pinlerini boşta bırakmalıyız. Bir Arduino kartı ile iletişim kurmak için Arduino ortamının dahili seri monitörünü kullanabilirsiniz. Araç çubuğundaki seri port ekranı düğmesini tıklayarak haberleşmeyi başlatabilirsiniz.

Serial.begin(verihizi): Seri iletişim için veri hızını saniyedeki bit sayısı (baud) cinsinden ayarlar. Bilgisayarla iletişim kurmak için veri hizi olarak şu oranlardan birini kullanabilirsiniz: 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 veya 115200. Örnek: void setup() { Serial.begin(9600); // seri bağlantı noktası açar, veri hızını 9600 bps'ye (bit per seconds) ayarlar } void loop() { // yapılacak işlemler }

Örneğin 300 baud veri hızıyla bilgisayar ile seri porttan bağlantı kurup ekrana robothobi.com yazan program satırını yazıp çalıştıralım. void setup() { Serial.begin(300); } void loop() { Serial.println("robothobi.com"); delay(1000); } Programı karta yükledikten sonra Araçlar kısmından seri port ekranını açalım ve sağ alt köşedeki veri hızı ayarını 300 baud yapalım aksi halde veri kaybı yaşarız. Not: Bundan sonraki çalışmalarımızda bağlantı hızımızı 9600 bps(baud) olarak ayarlayacağız. Arduino Mega için dört seri bağlantı noktasını da farklı hızlarda kullanabiliriz (Seri, Seri1, Seri2, Seri3) void setup(){ Serial.begin(9600); Serial1.begin(38400); Serial2.begin(19200); Serial3.begin(4800); Serial.println("Merhaba bilgisayar"); Serial1.println("Seri iletisim 1"); Serial2.println("Seri iletisim 1"); Serial3.println("Seri iletisim 1"); } void loop() {}

Serial.print(veri): veri içerisine karakter, değişken, harf yazılabilir ancak bunların ekrana istendik veri tipinde doğru yazılması için birtakım kurallar vardır. () içerisindeki veri bilgisini yan yana yazarak ekranda gösterir. Örnek: void setup() { Serial.begin(9600); } void loop() { Serial.print(4); // 4 yazar Serial.print('4'); // 4 yazar Serial.print('N'); // N yazar Serial.print("N"); // N yazar Serial.print(1.2345); //1.23 yazar Serial.print(1.23456,4); //1.2345 yazar virgülden sonra 4 basamak alır. Serial.print(78, BIN); // 1001110 yazar 78 sayısını binary sayı sistemine çevirdi. Serial.print(78, OCT); // 116 yazar 78 sayısını 8 lik sayı sistemine çevirdi 64+8+6=78 yapar. Serial.print(78, DEC); // 78 sayısını 10 luk sayı sisteminde tekrar yazdı. Serial.print(78, HEX); // 4E yazar 78 sayısını 16 lık sayı sistemine çevirdi. 4*16+14=78 yapar. Serial.println(1.23456, 0); // 1 yazar virgülden sonra 0 basamak alır. Serial.println(1.23456, 2); // 1.23 yazar virgülden sonra 2 basamak alır. delay(1000); } Not: Serial.print("\t"); // bir sekme boşluk yazar Serial.print("\n"); // bir alt satıra geçer Örnek: EKRAN GÖRÜNTÜSÜ int x = 0; // x ‘ e 0 değeri ver void setup() { Serial.begin(9600); // 9600 veri hızında seri haberleşmeyi başlat. } void loop() { Serial.print("VERI"); //ekrana VERI yazar. Serial.print("\t"); // Bir sekme yana geçer. Serial.print("IKILIK SAYI"); //ekrana IKILIK SAYI yazar. Serial.print("\n"); //alt satıra geçer. for(x=0; x< 16; x++){ // 0 dan 15 e kadar x e değer atar Serial.print(x); // Ekrana X değeri ne ise onu yazar. Serial.print("\t"); //Bir sekme yana geçer. Serial.print(x, BIN); //Ekrana x sayısının ikilik karşılığını yazar. Serial.print("\n"); //alt satıra geçer. delay(1000); //1 sn bekle. }}

Serial.println(veri): veri içerisine karakter, değişken, harf yazılabilir ancak bunların ekrana istendik veri tipinde doğru yazılması için birtakım kurallar vardır. () içerisindeki veri bilgisini alt alta yazarak ekranda gösterir. Önce ekrana yazar sonra bir alt satıra geçer.

Serial.write(veri): void setup(){ Serial.begin(9600); } void loop(){ Serial.write(44); // 1.SATIR ascii codu 44 olan ,(virgül) karakteri ekrana yazar. int x = Serial.write("merhaba"); // 2.SATIR Serial.print(" kelimesinde "); //3.SATIR Serial.print(x); //4.SATIR ekrana 7 yazar. Serial.print(" bayt karakter var"); //5.SATIR delay(10000); //10 sn bekler. } Açıklama: 1.SATIR: Ekrana (, )noktalama işaretini yazar. 2.SATIR: merhaba kelimesinin kaç bayt olduğunu x değişkenine yükle ve ekrana “merhaba” yaz. x=7 olur. 3.SATIR: Ekrana “kelimesinde” yazar . 4. SATIR: Ekrana “7” yazar. 5.SATIR: Ekrana “bayt karakter var” yazar. Ekran Görüntüsü;

Serial.read(): Ekrana gelen seri dataları okur. Gelen bilgilerin hangi veri tipinde yüklenmesini istiyorsak eşitlenecek olan değişken tanımlamasında istenilen veri tipi seçilmelidir. Örnek: int incomingByte = Serial.read(); Serial.println(incomingByte); //ekrana serial olarak girilen bilginin ascıı karşılığını yazar. Örnek: char incomingByte = Serial.read(); Serial.println(incomingByte); //ekrana serial olarak girilen karakteri aynen ekrana yazar.

Seri.available (): Seri bağlantı noktasından gelen verilerin kaç bayt (karakter) olduğunu sayar. Seri alıcı kendi belleğinde en fazla 64 bayt tutar bundan dolayı available () ile enfazla 0 dahil 63 e kadar karakter sayabiliriz. Her bir karakter 1 bayt olduğundan 64 bayt sayar. Dışarıdan veri girişi olmadığı sürece yani seri haberleşmeden veri gelmedikçe Serial.available() = 0 değeri üretir. Şimdi bunu bir program satırı ile inceleyelim: void setup() { Serial.begin(9600); } void loop() { if (Serial.available() > 0) { Serial.println(Serial.available()); } } Açıklama: Programı yükleyip seri port ekranını açtıktan sonra veri girişi kısmına bir yada birkaç karakter yazalım ve entere basalım klavyeden ekrana kaç adet karakter girdiysek onları sayar ve adeti yazar yani en az bir karakter girdiysek ekrana 1 yazar. Klavyeden veri girişi sağlandığında available() fonksiyonu en 1 yada daha fazla değer üreteceğinden dolayı bu özellik seri haberleşmenin başladığını anlamak için if (Serial.available() > 0) şeklinde koşul ile birlikte kullanılır. En az bir karakter girişi yaparak (bu boşlukta olabilir) seri haberleşmeyi başlatırsak Serial.available() değeri en az 1 olur ve if(1>0) şartı doğrulanır ve if yapısı içindeki satırların işlemesine izin verir. Bu şu anlama gelir seri haberleşme başladı. Artık seri haberleşme başladıktan sonra if yapısı içinde istediğimizi yaptırabiliriz. Örnek: char girilen_karakter; void setup() { Serial.begin(9600); } void loop() { if (Serial.available() > 0) { // 1.SATIR Serial.println(Serial.available()); //2.SATIR girilen_karakter=Serial.read(); //3.SATIR Serial.print("girilen karakter="); //4.SATIR Serial.println(girilen_karakter); //5.SATIR Serial.end(); } } 1.SATIR: Veri girişi yapıldığında Serial.available()= 1 olur ve 1>0 şartı doğrulanır ve if yapısı içindeki işlemlerin yapılmasına izin verilir. Kısacası seri haberleşme başlar. 2.SATIR: Ekrana Serial.available()=1 olduğundan 1 yazar ve alt satıra geçer. 3.SATIR: Seri haberleşmeden gelen bilgi char tipindeki girilen_karakter adlı değişkene atanır (en fazla 1 bayt yani bir karakter atanır) 4.SATIR: ekrana "girilen karakter=" yazar. 5.SATIR: Ekrana seri haberleşmeden gelen karakter ne ise o yazar örneğin seri port ekranından A harfini girip enter diyelim ve sonucu gözlemleğelim. 6.SATIR: Seri haberleşmeyi devre dışı bırakır Not: char girilen_karakter; değişkeni, int girilen_karakter; şeklinde tanımlansaydı ekrana karakterlerin ascii kodları yazardı. Örneğin A harifini girip entere bassaydık ekrana 65 yazardı.

Serial.end(): Seri haberleşmeyi devre dışı bırakır, RX ve TX pinlerinin genel giriş ve çıkış için kullanılmasına izin verir. Seri iletişimin yeniden etkinleştirilmesi için Serial.begin () işlevini çağırılması gerekir.

DEĞİŞKENLER:

Arduino ile yazılan programlarda hatta çoğu programlama dillerinde program içerisinde kullanılacak olan değişkenlerin veri türü

önceden belirlenmelidir. Pozitif sayı mı? ondalıklı sayı mı? karakter mi? olup olmadığı belirlenmeli ve hafızada yer ayrılmalıdır.

Değişken tanımlamanın birçok avantajı vardır, bunlardan bir kaçına değinmek gerekirse;

Değişken isimleri program yazarken hatırlatıcı bilgiler verir. int yesil_led=11; int sari_led=12; int kirmizi_led=13; yukarıdaki tanımlamalara bakarak donanımsal olarak devremizi tasarlamak istersek hangi pinlere ne renk led bağlayacağımızı rahatlıkla görebiliriz aylar sonra bile devreyi tasarlamaya kalksak sadece programa bakarak hatırlatıcı bilgilerle devremizi tasarlayabilir Yada programın ilerleyen bölümlerinde örneğin yeşil ledin hangi pine bağlı olduğuna bakmamıza gerek kalmadan yesil_led değişkenini kullanarak istediğimizi yaparız. Örnek1: int yesil_led=11; int sari_led=12; int kirmizi_led=13; void setup() { pinMode(yesil_led,OUTPUT); } void loop() { digitalWrite(yesil_led,HIGH); } Örnek2: void setup() { pinMode(11,OUTPUT); // 11 Nolu pin çıkış yapıldı } void loop() { digitalWrite(11,HIGH); // 11 Nolu pin 1 yapıldı (+5 volt) } Sonuç: Her iki örneğe bakarak yeşil ledin hangi pine bağlandığını bize net bir şekilde gösteren programın örnek1 olduğunu görmekteyiz.

Değişkenler Program üzerinde değişiklik yaparken zamandan tasarruf sağlamamıza yardımcı olur. Örnek: int a=9; int b=7; int toplama; int carpma; int cikarma; unsigned long denklem; void setup() { } void loop() { toplama=(a+b); carpma=(a*b); cikarma=(a-b); denklem= (a^2)+(2*a*b)+(b^2); } Örnek: int toplama; int carpma; int cikarma; unsigned long denklem; void setup() { } void loop() { toplama=(9+7); carpma=(9*7); cikarma=(9-7); denklem= (9^2)+(2*9*7)+(7^2); } Sonuç : Her iki örneğe bakarak diyelim ki matematiksel işlemlerde kullanılan 9 ve 7 sayısını 10 ve 8 yapma ihtiyacı doğdu örnek3 de sadece a=10, b=8 yapmak yeterliyken örnek4 de 9 ve 7 sayılarını tek tek bulup değiştirmek zorunda kalırız bu da zaman kaybına yol açacaktır. Evet değişken tanımlamanın ne kadar gerekli olduğunu bu iki madde ile açıklamak yeterli sanırım şimdi değişkenlerde kullanılan veri türlerinin neler olduğuna bir bakalım.

Değişken Tanımlarken kullanılacak veri türleri şunlardır:

boolean : true(doğru) yade false(yanlış) değerlerinden birine sahip olabilir.

char : Karakter tanımlamalarında kullanılır Karakterleri ASCII kodlarına göre hafızaya alır ayrıca -128 den 127 ye kadar olan değerleri tutabilirler. Buda 8 bitlik bir hafızaya denk gelir 2^(8)=256 dir. -128 ile +127 arasında toplam 256 sayı olduğunu gösterir. char robot_hobi='A'; //robot_hobi değişkenine A yükledik ASCII koduna göre yazmak istersek: char robot_hobi=65; //robot_hobi değişkenine A harfinin ascii kodunu yükledik bu değeri karakter olarak çağırmak istersek değer A olur. char kelime[] = "ufuk bengi"; char string [6] = {'d', 'e', 'n', 'e', 'm', 'e'}; char string [6] = "deneme"; // Toplam 6 değişken yer ayırttık string [0]=d,string [5]=e değerlerini alır. 6 yerine 5 yazarsak hata alırız. Örnek1: char kelime[]="Robot hobi"; // char kelime*+=,'R','o','b','o','t','h','o','b','i'-; şeklindede yazılabilir. void setup() { Serial.begin(9600); // ekrana yazı yazmak için gerekli ilerleyen bölümlerde detaylı anlatılacak. } void loop() { delay(1000); Serial.println(kelime); // Ekrana Robot hobi yazar. Serial.println(kelime[0]); // Ekrana R yazar }

unsigned char : 0-255 arasındaki ASCII kodlara sahip karakterleri hafızada tutar. (Dikkat: Negatif sayı yok) byte: 0-255 arasındaki 8 bit yani 1 bytlık pozitif sayıları tutar. 2^8=256 eder 0-255 arası toplam 256 sayı vardır. (Dikkat: Negatif sayı yok) Örnek1: byte ikilik_sayi=B1101; void setup() { Serial.begin(9600); } void loop(){ Serial.println(ikilik_sayi); // Ekrana 1101 binary sayısının onluk sayı sistemindeki karşılığı olan 13 sayısı yazılır. delay(1000); }

int : Ardiuno da kullanılan en çok veri türüdür. 2 bytlık yani 16 bitlik tam sayıları hafızada tutar. 2^16=65536 Buradan -32768 ile +32767 arası sayıları hafızada tuttuğunu hesaplayabiliriz. int yesil_led=11; //değer atayarak kullanım şekli. int a; //değer atamadan kullanım şekli. Örnekler:

char karakter_1=66; //Asci codu 66 olan B harfi karakter_1 değişkenine yüklenir. char karakter_2='A'; //A harfi karakter_2 değişkenine yüklendi. int asci_cod_1='A'; //A harfinin Ascii kodu olan 65 sayısı asci_cod adlı değişkene yüklenir. int asci_cod_2=karakter_2; //A harfi yukarıda karakter_2 ye atanmıştı şimdi A harfinin Ascii kodu(65) asci_cod_2 değişkenine yüklendi. Eğer int yerine char yapsaydık 65 değil A harfini yüklerdik. boolean a=true; // a değişkenine 1 değeri yüklendi. boolean b=false; // b değişkenine 0 değeri yüklendi. byte c=0; // buraya en fazla 0'dan 255'e kadar olan sayılar yazılabilir.Aksi taktirde c sayısına kontrolümüz dışında sayılar yüklenir.

unsigned int : 0-65535 kadar olan 16 bitlik sayıları hafızada tutar . (Dikkat: Negatif sayı yok) long: 32 bitlik(4 byte) sayıyı hafızada tutar. Negatif ve pozitif tam sayılar dahil toplam -2^31 den +2^31-1 ‘ e kadar olan sayıları tutar.

unsigned long: 32 bitlik(4 byte) pozitif sayıyı hafızada tutar. 2^32-1 (Dikkat: Negatif sayı yok) float: Ondalıklı sayıları tanımlamada kullanılan veri türüdür.(virgüllü sayılar) 32 bit yani 4 byte hafıza tutar. Analog işlemlerde hassasiyeti sağlamada oldukça gereklidir. Virgülden sonra 2 basamağa kadar hassasiyeti vardır.

double: Çok büyük ondalıklı sayıları hafızada tutar. Mantık olarak float ile aynı işi görür. String: Metinsel bilgileri depolamak için kullanılır LCD ye yada seri porttan ekrana bir kelime yazmak için kullanılabilir. Char veri türünden olan karakterler toplamıdır. String cumle="Merhaba Robot hobi ";

Substring: string içerisindeki kelimeden kaç karakter alacağımızı belirler. String cumle="Merhaba Robot hobi"; void setup() { Serial.begin(9600); } void loop() { Serial.println(cumle.substring(8,13)); // 0 dahil soldan sağa sayar 7. harfi alır 13-8=5 adet karakteri soldan sağa yazar. yani ekrana Robot yazar. delay(1000); }

array(dizi): Program içerisinde çok sayıda değişken tanımlamak gerektiğinde dizileri kullanmak işimizi kolaylaştıracaktır. int led [ ]={1,4,9,7,6}; Burada sırası ile led*0]=1 ,led[1]=4….. şeklinde değer atanır. Aynı satır şu şekilde de yazılabilir; int led*5+=,1,4,8,7,6- oluşturulan değişkenler led *0 +=1, led [1 ]=4, led [2 ]=8, led [3 ]=7, led *4 +=6 şeklinde tanımlamış oluruz.

DEĞİŞKEN KAPSAMLARI:

Değişken tanımlarken veri türlerinden önce yazılan bazı komutlar değişkene farklı özellikler katar bunlar şu şekildedir.

const: Değişken değeri sabitlenir ve sonradan değiştirilemez.

const float pi_sayisi=3.14;

Burada; pi_sayisi olarak tanımlanan değişken ondalıklı sayı olduğundan float kullanıldı ayrıca sabit sayı olması için const

kullanılmıştır. const float dediğimizde programın ilerleyen bölümlerinde değişken değeri değiştirilemez hata verir.

Static: Static ile tanımlanan değişken değerleri bellekte tutulur ve daha sonra kullanmak istersek yeniden oluşturulmaz bellekten çağırılır.

static int bellekte_tut=15;

volatile: Volatile ile tanımlanan değişkenler Arduino’ nun ram bölgesine kaydedilir. Kullanmak istersek direk ram bellekten okunur. Volatile kullanıyorsak değişkenin değerini interrupt ile değiştirmemiz gerekir.

ARAÇLAR:

progmem: Bilgiyi SRAM bellek yerine Flash bellekte depolamaya yarar. Arduino da programımızda uzun char yazmaya kalkarsak SRAM sorun çıkarabilir. Bu yüzden çok uzun metinleri Flash belleğe kaydederiz. Kullanabilmemiz için programa #include kütüphanesini eklemeliyiz.

#include

const char mesajlar [] PROGMEM = {"Herhangi bir metni bu sekilde kaydedebiliriz"};

int k=0;

char karakterler;

void setup() {

Serial.begin(9600);

}

void loop() {

while (!Serial);

int len = strlen_P(mesajlar);

for (k = 0; k < len; k++)

{

karakterler = pgm_read_byte_near(mesajlar + k);

Serial.print(karakterler);

}

delay(1000);

Serial.println();

}

sizeof(); Değişkenlerin kaç byte yer tuttuğunu tespit eder. char mesaj[] ="testdenemesi";

int i;

int kac_bayt;

void setup()

{

Serial.begin(9600);

}

void loop()

{

kac_bayt=sizeof(mesaj); //Her bir karakter 1 byte olduğundan boşlukta dahil olmak üzere 13’e eşitlenir.(fazladan 1 tane

boşluk sayar)

Serial.println(kac_bayt);

delay(1000);

Serial.println(mesaj[11]); // Ekrana i harfi yazılır.

delay(1000);

Serial.println(mesaj[12]); // Ekranda boşluk bırakır.

delay(1000);

}

OPERATÖRLER

Aritmetik operatörler: Aritmetik işlemlerde kullanılacak olan değişkenlerin türleri belirlendikten sonra toplama,çıkarma, çarpma ve bölme işlemleri

yapılabilir. Değişken veri türü hesaplama yapılırken de belirlenebilir. +,-,* ve / işaretleri kullanılır

Örnek1:

float a=5; // bu sayı bölme işleminde de kullanıldığından float olarak tanımladık.

float b=7; // bu sayı bölme işleminde de kullanıldığından float olarak tanımladık.

int toplama; // değişken türü önceden belirlendi

int cikarma;

float bolme;

void setup()

{

Serial.begin(9600);

}

void loop()

{

toplama=a+b;

cikarma=a-b;

bolme=(b/a); //eğer bölme işlemde kullanılan a ve b değişkenleri float olarak tanımlanmasaydı bolme =1.00 olurdu.

int carpma=(a*b); // carpma değişkeninin türünü sonradan belirledik isterseniz yukarıda da tanımlayabilirsiniz.

Serial.println(toplama); //ekrana 12 yazar

delay(1000);

Serial.println(cikarma); //ekrana -2 yazar

delay(1000);

Serial.println(bolme); //ekrana 1.40 yazar

delay(1000);

Serial.println(carpma); //ekrana 35 yazar

delay(1000);

}

Karşılaştırma operatörleri:

Program yazarken olmazsa olamazlardan olan karşılaştırma operatörleri genellikle for,while,if gibi karşılaştırma gerektiren

komutlarla beraber kullanılır.

Operatörlerin kullanım şekilleri şöyledir;

x == y (x, y ye eşit) x != y (x, y ye eşit değil ) x < y (x, y den küçük) x > y (x, y den büyük) x = y (x, y den büyük eşit)

Örnek1:

int a=4;

int b;

void setup()

{

Serial.begin(9600); //Seri haberleşmeyi 9600 veri iletim hızında başlattık

}

void loop()

{

if(a

Boolean operatörleri:

Genellikle if yapısı içerisinde birden fazla karşılaştırma gerektiren durumlarda kullanılır.

Mantıksal VE (&&):

Karşılaştırmalar && ile bağlandığında her karşılaştırma durumunun doğru olması şartı ile döngü içine girmeye izin verilir.

&& (ve) operatörü karşılaştırma sonuçlarını çarpma işlemine tabii tutar. Şartlardan biri 0 ise sonuç 0 olur.

Örnek1:

int a=5;

int b=4;

void setup()

{

Serial.begin(9600);

}

void loop()

{

if(a==5&&b

Mantıksal VEYA (||): Karşılaştırmalar || ile bağlandığında Şartlardan herhangi birinin doğru olması durumunda döngü içerisindeki işlemlerin

yapılmasına izin verilir. ||(veya) operatörü karşılaştırmaları toplama işlemine tabii tutar şartlardan biri doğru ise sonuç doğru

olur.

Örnek1:

int a=5;

int b=8;

void setup()

{

Serial.begin(9600);

}

void loop()

{

if(a==5||b

Birleşik operatörler:

++ (arttırma), -- (azaltma) Operatörleri :

degisken++; //değişken değerini 1 arttır.

++degisken; // değişken değerini 1 arttır.

degisken=degisken+1; // değişken değerini 1 arttır.

degisken--; //değişken değerini 1 azalt.

--degisken; // değişken değerini 1 azalt.

degisken=degisken-1; // değişken değerini 1 azalt.

+= , -= , *= , /= , %= Operatörleri:

x+=y; // x=x+y

x-=y; //x=x-y

x*=y; //x=x*y

x/=y; //x=x/y

x%=y; // x sayısının y sayısına bölümünden kalanı x’e atar.

Örnek1:

int x=4;

int y=3;

void setup() {

Serial.begin(9600);}

void loop()

{

x %= y; // 4 ün 3 e bölümünden kalan 1 dir.

Serial.println(x); // Ekrana 1 yazar.

}

Bitsel işlemler: &= (Bitsel Lojik Ve) & ile bağlanan sayıların binary değerlerinin karşılıklı bitlerini çarpar.

Örneğin:

x=11&13;

11= 1011

13 = 1101

x= 1001 olur. Aynı hizadaki bitleri çarptık sonra x değeri tekrar onluk sayı olarak atandı x=9 olur.

Örnek1:

int x=11; // binary karşılığı 1011

int y=13; // binary karşılığı 1101

int z;

void setup()

{

Serial.begin(9600);

}

void loop()

{

z=x&y;

Serial.println(z); // Ekrana 9 yazar

delay(1000);

}

|= (Bitsel Lojik Veya)

|= ile bağlanan sayıların binary değerlerinin karşılıklı bitlerini VEYA işlemine tabi tutar. Aynı hizadaki(basamaktaki)

Bitlerin herhangi biri 1 ise değeri bir kabul eder

Örneğin:

x=11|13;

11= 1011

13 = 1101

x= 1111 olur. x=15 olur.

Örnek1:

int x=11; // binary karşılığı 0111

int y=13; // binary karşılığı 0011

int z;

void setup(){


void loop()

{

z=x|y;

Serial.println(z); // ekrana 15 yazar

delay(1000);

}

Matematiksel işlemler: min(x,y): Parantez içine yazılan iki değişkenden küçük olanını alır.İkiden fazla değişken yazılamaz.Değişkenler ondalıklı sayı yada negatif

sayı da olabilir.

Örnek1:

int z;

float t;

void setup()

{

Serial.begin(9600);

}

void loop()

{

z=min(7,8);

t=min(3.14,78);

Serial.println(z); // ekrana 7 yazar .

delay(1000);

Serial.println(t); // ekrana 3.14 yazar.

delay(1000);

}

max(x,y): Parantez içine yazılan iki değişkenden büyük olanını alır. İkiden fazla değişken yazılamaz.Değişkenler ondalıklı sayı yada negatif

sayı da olabilir.

Örnek1:

int z;

float t;

void setup(){


void loop() {

z=max(7,8);

t=max(3.14,78);

Serial.println(z); // ekrana 8 yazar.

delay(1000);


delay(1000);

}

Not: min ve max ile ilk yazılan değişkenin sınırlarını ikinci yazılan değişkenle belirleriz. Örneğin okunan ve sürekli değişen bir

sensör değeri var ve bu sensör bilgisinin belli bir değerin altına yada üstüne çıkmasını istemiyorsak bu komutu kullanabiliriz.

map(): Genellikle analog bilgilerin belli bir aralıkta sınırlanması amacı ile kullanılır. Örneğin analog bilgimiz 0-1023 arasında değişen değerler alıyor ve biz bunu orantılı olarak 0-255 arasında ayarlamak istiyorsak bu komutu kullanabiliriz.

Örnek:

int sensor_gercek_bilgi=512;

int sensor_sinirlanan_bilgi;

void setup() {

Serial.begin(9600); }

void loop(){

sensor_sinirlanan_bilgi=map(sensor_gercek_bilgi,0,1023,0,255);

Serial.println(sensor_sinirlanan_bilgi); // Ekrana orantılı olarak 127 yazar.

delay(1000);

}

abs(x): Bir sayının mutlak değerini hesaplar dolayısı ile her zaman sayının pozitif değerini verir. Örnek:

int z;

float t;

void setup() {


void loop() {

z=abs(-8);

t=abs(3.14);

Serial.println(z); // ekrana 8 yazar.

delay(1000);


delay(1000);

}

constrain(x,a,b) : Değişken değerini a ile b değerleri arasına hapseder. x değişken, a alt değer, b üst değerdir. Eğer x değeri en küçük sayısı ise sonuç alt değer olan a ya eşit olur. Eğer x değeri en büyük sayı ise sonuç üst değer olan b ye eşit

olur. Eğer x değeri a ile be arasında bir değerse sonuç x değerine eşit olur. Örnek:

int sensor_bilgim=180;

void setup()

{

Serial.begin(9600);

}

void loop()

{

sensor_bilgim=constrain(sensor_bilgim,90,200);

Serial.println(sensor_bilgim); // değer 90-200 arasında olduğundan Ekrana 180 yazar.

delay(1000);

}

Yukarıdaki örnekte ;

int sensor_bilgim=180; yerine int sensor_bilgim=260; gibi bir sayı yazılırsa sonuç :200 olur yani üst sınır alınır. 180

yerine 70 yazılırsa sonuç : 90 olur yani alt sınır alınır.

floor(x): x sayısını küçük tam sayı değerine yuvarlar.

ceil(x): x sayısını büyük tam sayı değerine yuvarlar

Örnek1:

float a=3.6;

void setup() {


void loop(){

int b=floor(a); //b=3 oldu

int c=ceil(a); //c=4 oldu

Serial.println(b); // ekrana 3 yazar

delay(1000);

Serial.println(c); // ekrana 4 yazar

delay(1000);

}

pow(x,y): xy işlemini yapar. Üslü sayılarda kullanılır.

Örnek1:

int a;

void setup() {


void loop(){

a=pow(2,3);

Serial.println(a); // ekrana 8 yazar.

delay(1000);

}

sqrt(x): x Sayısının karekökünü alır. int a;

void setup() {


void loop(){

a=sqrt(36);

Serial.println(a); // ekrana 6 yazar.

delay(1000);

}

Trigonometrik hesaplamalar:

sin(radyan): Bir açının sinüs değerini radyan cinsinden hesaplar. Sonuç -1 ile +1 dahil arasında bir değer alır. *-1,1]

cos(radyan): Bir açının cosinüs değerini radyan cinsinden hesaplar. Sonuç -1 ile +1 dahil arasında bir değer alır. *-1,1]

tan(radyan): Bir açının tanjant değerini radyan cinsinden hesaplar. Sonuç - ∞ ile +∞ arasında bir değer alır. (-∞,∞)

Örnek:

float x;

double y=90;

void setup() {


void loop(){

x=sin(y); // x float y ise double seçilmeli

Serial.println(x); //-1 ile 1 arası bir değer yazar.

delay(1000);

}

Karakterler: isAlphaNumeric():Karakterlerin alfanumerik olup olmadığını kontrol eder eğer alfanumerik ise 1 değilse 0 olur.

isAlpha():Karakterlerin Harf olup olmadığını kontrol eder eğer harf ise 1 değilse 0 olur. if (isAlpha(bilgi)) {

Serial.println("Alfabetik bilgi ");}

isAscii(): Karakterlerin asci olup olmadığını kontrol eder. Bir karakterin ascii kodunu bulmak için aşağıdaki programı inceleyiniz.

Örnek1:

void setup() {

Serial.begin(9600); //Seri haberleşme

while (!Serial) {

; // seri port haberleşmesinin beklenmesi

}

Serial.println("Klavyeden bilgi girin");

Serial.println();}

void loop() {

if (Serial.available() > 0) {

int thisChar = Serial.read();

Serial.print("Gonderilen: \'");

Serial.write(thisChar);

Serial.print("\' ASCII Degeri: ");

Serial.println(thisChar);

Serial.println();

Serial.println("Baska bir karakter girin:");

Serial.println();

}

}

isWhiteSpace():Karakterlerin Boşluk olup olmadığını kontrol eder eğer boşluk ise 1 değilse 0 olur. if (isWhitespace(bilgi)) {

Serial.println("Bosluk girdiniz");}

isSpace():Karakterlerin Boşluk olup olmadığını kontrol eder eğer boşluk ise 1 değilse 0 olur. if ( isSpace(bilgi) ) {

Serial.println("Bosluk karakteri");}

isControl(): Karakterlerin Kontrol karakteri olup olmadığını kontrol eder eğer Kontrol karakteri ise 1 değilse 0 olur.

if (isControl(bilgi)) {

Serial.println("Bu kontrol karakteri");}

isDigit(): Karakterlerin ikilik sayı sistemi(dijital-1 yada dijital-0) olup olmadığını kontrol eder eğer dijital değer ise 1 değilse 0 olur.

if (isDigit(bilgi)) {

Serial.println("Bu numeric digit");}

isGraph(): Karakterlerin grafik karakter olup olmadığını kontrol eder eğer grafik karakter ise 1 değilse 0 olur.

if (isGraph(thisChar)) {

Serial.println("Bosluk degil yazdirilabilr karakter");}

isPrintable(): Karakterlerin yazdırılabilir karakter olup olmadığını kontrol eder eğer yazdırılabilir karakter ise 1 değilse 0 olur.

if (isPrintable(bilgi)) {

Serial.println("Yazdirilabilir");}

isPunct(): Karakterlerin noktalama işareti olup olmadığını kontrol eder eğer noktalama karakter ise 1 değilse 0 olur.

if (isPunct(bilgi)) {

Serial.println("Noktalama isareti");}

isUpperCase(): Karakterlerin Büyük harf olup olmadığını kontrol eder eğer büyük harf ise 1 değilse 0 olur.

if (isUpperCase(bilgi)) {

Serial.println("Buyuk Harf ");}

isLowerCase(): Karakterlerin Küçük harf olup olmadığını kontrol eder eğer küçük harf ise 1 değilse 0 olur.

if (isLowerCase(thisChar)) {

Serial.println("Kucuk harf");}

isHexaDecimalDigit(): Karakterler Hexadecimal(16 sayı sistemi) sayılardan birini içeriyorsa 1 içermiyorsa 0 olur (0,1,2,3,4,5,6,7,8,9,a,A,b,B,c,C,d,D,e,E)

if (isHexadecimalDigit(thisChar)) {

Serial.println("Gecerli hexadecimaldigit var ( 0 - 9, a - F, or A - F)");}

Sabitler:

Hıgh: Lojik 1 anlamına gelir Elektriksel olarak +5 Volt ‘dur. Genellikle dijital pin olarak belirlenen pinleri lojik 1 yapmak için kullanılır.

Örnek:

digitalWrite(13,HIGH); // 13 numaralı pin çıkışını 1 yap.

Low: Lojik 0 anlamına gelir Elektriksel 0 Volt ‘dur. Genellikle dijital pin olarak belirlenen pinleri lojik 0 yapmak için kullanılır. digitalWrite(13,LOW); //13 numaralı pin çıkışını 0 yap.

input: Pinleri giriş olarak belirlemek için kullanılır. Dışarıdan bilgi girişi istendiğinde ilgili pini giriş pini olarak belirler. Genellikle sensörlerin yada butonların bağlanacağı pinler için kullanılır.

pinMode(13,INPUT); // 13 Numaralı pin giriş olarak ayarlandı.

output: Pinleri çıkış olarak belirlemek için kullanılır. Genellikle led yada motor gibi kaynakların kontrol edilmesi için kullanılan pinleri çıkış olarak ayarlamada kullanılır.

pinMode(12,OUTPUT); // 12 Numaralı pin çıkış olarak ayarlandı.

true: Doğru anlamına gelir. Dijital olarak 1 değeri üretir.

Örnek1:

İf(buton==true),

Serial.println(“Butona basildi”); // Butona basma durumunu donanımsal olarak lojik 1 ayarlarsak ekrana Butona basıldı yazar

}

false: Yanlış anlamına gelir. Dijital olarak 0 Değeri üretir.

Örnek1:

İf(buton==false),

Serial.println(“Butona basilmadi”); // Butona basma durumunu donanımsal olarak lojik 1 ayarlarsak butona basılmadığı zaman

ekrana Butona basilmadi yazar

}

Dijital giriş-çıkışlar Arduinoda 0-13 arası dijital giriş yada çıkış olarak kullanılabilr. Ayrıca A0-A5 Analog giriş olmasına rağmen dijital giriş yada çıkış

olarak tanımlanarak kullanılabilir.

pinMode(pin,Mode): Belirli bir pini giriş yada çıkış yapmada kullanılır.

pinMode(12,INPUT); //12 numaralı pin giriş olarak ayarlandı.

pinMode(12,INPUT_PULLUP); // 12 numaralı pin giriş yapıldı pin boşta olma durumunu 1 yapar Pull-up direnci kullanmayız.

pinMode(13,OUTPUT); //13 numaralı pin çıkış olarak ayarlandı.

digitalWrite(pin,deger): Belirli bir pini 0,1,HIGH yada LOW yapmak için kullanılır.

digitalWrite(12,HIGH); // 12 numaralı pin HIGH yanı 1 yapıldı. Bu pine led bağlı ise led yanar.

digitalWrite(13,LOW); // 13 numaralı pin LOW yanı 0 yapıldı. Bu pine led bağlı ise led söner.

digitalRead(pin): Belirli bir pinin değerini okumak için kullanılır.

digitalRead(2); // 2 numaralı pinin durumunu okur. Eğer bu pini +5 volta bağlarsak değer 1 olur gnd’ye bağlarsak değer 0 olur.

Örnek1:

Şekildeki bağlantıda butona basılmadığı sürece pull-Down direnci üzerinden 2 Nolu pine GND yani 0 gider. Butona bastığımızda

+5 volt donanımsal olarak 2 Nolu pine gider. Kısacası Butonumuza basma durumunu lojik 1 Diğer durumu ise lojik 0 olarak

ayarladık. Not: Burada Pull-Down direncinin kullanılmasının sebebi butona bastığımızda +5 volt ve GND nin kısa devre olmasını

engellemektir.

2 Nolu pin

Şimdi donanımsal olarak BreadBoard yardımı ile 2 numaralı pine buton bağlayalım ve yazılımsal olarak 2 numaralı pini dijital giriş

olarak ayarlayıp butonun durumunu ekrana yazdıralım.

int buton=2;

int durum;

void setup() {

Serial.begin(9600); //seri haberleşme.

pinMode(buton,INPUT); // 2 numaralı pin giriş olarak ayarlandı.

}

void loop() {

durum=digitalRead(buton); // butona bastığımızda durum 1 basmadığımızda durum 0 olur.

Serial.println(durum); // butona basarsak ekrana 1 basmaz isek 0 yazar.

delay(1000);

}

Yukarıdaki devreyi direnç kullanmadan yapalım. Bu durumda INPUT yerine INPUT_PULLUP kodunu kullanmak zorundayız.

Örnek2:

Şekildeki bağlantıya baktığımızda butona basma durumu 0 iken diğer durumda 2 numaralı pin boşta kalmaktadır bu istenmeyen

bir durumdur. Çünkü boşta olması bazen 0 bazen 1 olarak algılanabilir. Bu durumun önüne geçebilmek için INPUT_PULLUP

kullanılır bu durumda 2 numaralı pinin boşta olma durumu yazılımsal olarak 1 kabul edilir.

2 Nolu pin

Şimdi Donanımsal olarak BreadBoard kullanarak 2 numaralı pin ile GND arasına buton bağlayalım ve yazılımsal olarak 2 numaralı

pini dijital giriş olarak ayarlayıp butonun durumunu ekrana yazdıralım.

int buton=2;

int durum;

void setup() {

Serial.begin(9600); //seri haberleşme

pinMode(buton,INPUT_PULLUP); // 2 numaralı pin giriş olarak ayarlandı ayrıca pinin boş durumu 1 kabul edildi.

}

void loop() {

durum=digitalRead(buton); // butona bastığımızda durum 0 basmadığımızda durum 1 olur.

Serial.println(durum); //butona basarsak ekrana 0 basmaz isek 1 yazar.

delay(1000);

}

Analog giriş-çıkışlar: Analog giriş olarak sadece A0-A5 kullanılır. Diğer pinler analog giriş olarak tanımlanamaz. Analog çıkış olarak Arduino Uno’da

3,5,6,9,10,11 pinleri analog çıkış olarak tanımlanabilir. Diğer pinler Analog çıkış olarak kullanılmaz.

Arduino Nano, Uno, Mega ve Mini’de Donanımsal olarak 10 bitlik Analog-Dijital çevirici vardır. (10 bit analog to digital converter)

Dolayısı ile analog gelen bilgi 10 bitlik binary sayı ya çevrilir (dijital) .

Binary sayı sisteminde 10 bitlik en büyük sayı ve en küçük sayıyı bulalım:

En büyük : (1 1 1 1 1 1 1 1 1 1) Toplam 10 bit.

Şimdi bu sayıyı 10 luk sayı sistemine çevirelim en sağdaki basamaktan başlayarak sırası ile sayıları (1,2,4,8,16,32,64,128,256,512)

sayıları ile çarpıp toplayalım sonuç:

(1*1)+(1*2)+(1*4)+(1*8)+(1*16)+(1*32)+(1*64)+(1*128)+(1*256)+(1*512)= 1023 En büyük sayı.

En küçük : (0 0 0 0 0 0 0 0 0 0) Toplam 10 bit. Yukarıdaki

matematiksel işlemi buraya uygularsak sonuc= 0 En küçük sayı.

Yani biz analog girişe 0-5 Volt arasında bir değer uygulayıp PWM çıkışlarındaki (3,5,6,9,10,11 nolu pinler ) veriyi seri porttan

okumak istediğimizde ekrana 0-1023 arası bir değer yazar. Max 5 voltu max 1023 olarak okuyabiliyorsak bunu basit bir

matematiksel işlemle ekrana voltaj değeri olarak yazdırabiliriz.

voltaj= okunanbilgi*(5/1023) dediğimizde 1023 ün 5 volta, 512 nin 2.5 volta 0 ‘ın ise 0 volta denk geldiğini görürüz.

analogRead(pin):

Arduino uno da analog giriş pinleri A0- A5 olduğuna göre analog sensörler buraya bağlanır ve biz bu sensör bilgilerini analog

giriş pinlerine bağlayarak okuyabiliriz dolayısı ile pin değeri olarak arduino uno için A0-A5 arası pinler yazılır. Arduinonun diğer

kartlarının analog girişleri için datasheetlerine bakınız.(nano,mini,mega vs.)

okunan_bilgi=analogRead(A0); // şeklinde yazılır.

Örnek1:

Öncelikle devremizi tasarlayıp sonra da programı yazalım. 10K lık bir potansiyometrenin orta bacağını (terminal) A0’a bağlayıp

diğer bacaklarından bir tanesini GND ye +5 volta bağlayalım burada 220 ohmu araya koymamızın sebebi potansiyemetre sona

kadar çevrildiğinde direnci 0 yakın olur , buradaki amacım min. değeri 220 ohm gibi bir değerle sınırlamaktır. İsterseniz 220 ohm

yerine kablo ile doğrudan bağlantı sağlayabilirsiniz.

Devre kurulumu:

int pot=A0; // buraya 14 yada A0 yazılabilir.

float okunan;

float voltaj;

void setup() {

Serial.begin(9600);

pinMode(pot,INPUT); // bu satırı yazmasak ta olur.

}

void loop() {

okunan=analogRead(pot);

Serial.println(okunan); // ekrana 0-1023 arası değer yazar.

voltaj=5*(okunan/1023); // ekrana 0-5 arası değer yazar.

Serial.println(voltaj);

delay(1000);

}

Not: Araya bağlanan 220 ohm dirençten dolayı potun orta bacağından tam olarak +5 volt okuyamayız bundan dolayı max değer

1023 ün altında çıkar. Max voltaj ise +5 voltun altında çıkar. Potansiyometrenin ortabacağındaki gerilimi manuel ölçmek için

voltmetre kullanabilirsiniz voltmetreyi dc kademesine alarak – probu gnd ye + probu potansiyometrenin orta bacağa

dokundurunuz okuduğunuz değerle monitördeki değerin aynı olduğunu gözlemleyiniz.

analogWrite(pin,deger):

Arduino uno için analog çıkış pinleri 3,5,6,9,10,11 nolu pinlerdir. Analog çıkış pinlere PWM pinleri de denir ve ~ sembolü ile

gösterilir. Arduinonun diğer kartlarının analog çıkış pinleri (PWM) için datasheetlerine bakınız.(nano,mini,mega vs.)

Bu pinleri örneğin ledin parklaklığını sönükten parlağa doğru kademeli bir şekilde ayarlamak için yada bir motor sürücü vasıtası

ile dc bir motorun hızını yavaştan hızlıya yada hızlıdan yavaşa doğru kademeli bir şekilde arttırmak amacı ile kullanılabilir.

Örnek1:

Öncelikle devremizi tasarlayalım potansiyometremizin orta bacağını analog girişlerden birine (A3 nolu pin) bağlayalım. Ve

Potansiyometrenin min değerini 220 ohm olarak sınırlayalım (devrede) Ledimizi ise analog yani PWM çıkışlardan birine (9 nolu

pin) 220 ohm’luk koruma direnci ile birlikte bağlayalım burada kullandığımız 220 ohm’luk direnç max. PWM değeri geldiğinde

ledi koruma amaçlıdır.

Devre kurulumu:

int led=9; // led degişkenine 9 değeri yüklendi.

int pot=A3; // pot degişkenine A3 değeri yüklendi. Buraya 17 değeri yada 3 değeri de yazılabilir.

int okunan_deger;

void setup() {

pinMode(led,OUTPUT); // 9 nolu pin çıkış olarak ayarlandı.

pinMode(pot,INPUT); // A3 pini giriş olarak ayarlandı Bu satırı yazmasak ta olur .

Serial.begin(9600);

}

void loop() {

okunan_deger=analogRead(pot); // A3 pinine gelen analog sinyali (0-1023) arası okunan_deger değişkenine yükledik.

analogWrite(led,okunan_deger); // analog bilgiyi led pinine yolla.

Serial.println(okunan_deger);

}

analogReference():

Analog giriş için kullanılan referans voltajını (yani, giriş aralığının üstü olarak kullanılan değer) konfigüre eder. Seçenekler

şunlardır:

DEFAULT: Varsayılan 5 volt analog referans (5V Arduino kartlarda) veya 3.3 volt (3.3V Arduino kartlarında) INTERNAL: ATmega168 veya ATmega328'de 1,1 volta ve ATmega8'de 2,56 volt'a eşit olan dahili bir referans (Arduino Mega'da mevcut değildir) INTERNAL1V1: 1.1 Volt referans sadece Arduino megada kullanılabilir.

INTERNAL2V56: 2,56 Volt sadece arduino megada kullanılabilir.

EXTERNAL: Aref pinine uygulanan voltaj referans olarak kullanılabilir.(0-5V)

analogReference(EXTERNAL); // şeklinde kullanılır.

AREF pinine harici referans voltajı için 0V'dan az veya 5V'den fazla gerilim uygulanmamalıdır. AREF pinine harici bir referans

kullanıyorsanız analogRead () çağrılmadan önce analog referansı EXTERNAL olarak ayarlamanız gerekir. Aksi halde, aktif referans

voltajını (dahili olarak üretilen) ve AREF pimini birlikte kısaltır ve muhtemelen Arduino kartındaki mikro denetleyiciye zarar

verirsiniz.

Gecikmeler: delay(sure): Programı milisaniye cinsinden durdurur. Not: 1000 ms 1sn’dir. Örnek1:

int led = 13;

void setup(){

pinMode(led, OUTPUT);

}

void loop(){

digitalWrite(led, HIGH); // ledi yak.

delay(1000); // 1 sn bekle.

digitalWrite(led, LOW); // ledi söndür.

delay(1000); // 1 sn bekle.

}

delayMicroseconds(sure): Programı mikro saniye cinsinden durdurur. 1 sn= 1 000ms=1 000 000 mikro saniye demektir.

milis(): Program çalışmaya başladığı andan itibaren geçen süreyi milisaniye cinsinden sayar. Max. 50 gün kadar süreyi sayar 50 günü

geçtikten sonra taşma olur ve 0’a döner.

50 Günü mili saniye olarak hesaplayalım

50gün*24saat*60dk*60sn*1000 ms = 4.320.000.000 ms yapar.

unsigned long gecen_sure=millis(); // unsigned long 4 byte yani 32 bit olduğundan 2^32 = 4.294.967.296 ya kadar sayar.

Örnek1:

unsigned long gecen_sure;

void setup()

{

Serial.begin(9600);

}

void loop()

{

gecen_sure=millis();

Serial.println(gecen_sure); // geçen süreyi 0 ,999,1999 şeklinde ekrana yazar.

delay(1000); // 1 sn bekle

}

micros(): Program çalışmaya başladığı andan itibaren geçen süreyi mikro saniye cinsinden sayar. Max. 70 kadar süreyi sayar 70 dk

geçtikten sonra taşma olur ve 0’a döner.

70 dk*60sn*1000milisn*1000mikrosn= 4 200 000 000 unsigned long veri tipinin max. değerine(4 294 967 296) yakın bir değer.

16 MHz Arduino da (örneğin, Duemilanove ve Nano), bu işlevin çözünürlüğü dört mikro saniyedir (yani, döndürülen değer daima dördün katıdır). 8 MHz Arduino panolarında (ör. LilyPad), bu işlevin sekiz mikro saniyelik bir çözünürlüğü vardır.

KONTROL YAPILARI:

-if -if...else -for -switch case -while -do... while -break -continue -return -goto

https://www.arduino.cc/en/Reference/Ifhttps://www.arduino.cc/en/Reference/Elsehttps://www.arduino.cc/en/Reference/Forhttps://www.arduino.cc/en/Reference/SwitchCasehttps://www.arduino.cc/en/Reference/Whilehttps://www.arduino.cc/en/Reference/DoWhilehttps://www.arduino.cc/en/Reference/Breakhttps://www.arduino.cc/en/Reference/Continuehttps://www.arduino.cc/en/Reference/Returnhttps://www.arduino.cc/en/Reference/Goto

if: Genellikle karşılaştırma operatörleri ile birlikte kullanılır. Şart doğru ise 1 değeri , yanlış ise 0 değeri üretilir. Aslında if yapısının içerisindeki değerin 1 olma şartı aranır.

if(koşul), // Koşul doğru ise 1 değeri üretilir ve ,- arasındaki işlemler gerçekleştirilir.

// yapılacak işlemler.

}

3 Farklı şekilde kallanılır.

Örnek1:

int a=5;

void setup() {

Serial.begin(9600);

}

void loop() {

if(a==5)Serial.println("Bir tek sart saglandiginda beni yaz");

Serial.println("sart saglansada saglanmasada buradan devam eder");

Serial.println("aynen devam");

delay(5000);

}

Örnek2:

int a=5;

void setup() {

Serial.begin(9600);

}

void loop() {

if(a==6) // şart sağlanırsa if parantez içi () 1 şart sağlanmazsa if parantez içi () 0 olur.

Serial.println("Bir tek sart saglandiginda beni yaz"); // şart sağlanırsa bu satır çalışır sağlanmaz ise bir alt satırdan devam eder.

delay(1000); // şart sağlansa da sağlanmasa da buradan devam eder.


delay(1000);

Serial.println("aynen devam");

delay(1000);

}

Örnek3:

int a=5;

void setup() {

Serial.begin(9600);

}

void loop() {

if(a==5){ // şart doğru ise bir kez ,- içindekiler gerçekleşir sonra program akmaya devam eder.

Serial.println("sart saglandiginda beni yaz"); // şart doğru ise burayı görür.

delay(1000); // şart doğru ise burayı görür.

} //şart doğru değil ise ,- içindekileri yapmadan program buradan devam eder.


delay(1000);

}

if yapısını uygulamalı olarak pekiştirelim.

Üç adet butondan hangisine basıldığını ekrana yazan bir program tasarlayalım. Butonlarımızı 5,6,7 nolu pinlere sırası ile

bağlayalım.

Lütfen 3 farklı şekilde yazılan programı uygulamalı olarak çalıştırınız.

int sol_buton=7; // 7 sayısı sol_buton değişkenine yüklendi.

int orta_buton=6; // 6 sayısı orta_buton değişkenine yüklendi.

int sag_buton=5; // 5 sayısı sag_buton değişkenine yüklendi.

void setup() {

Serial.begin(9600); // Seri haberleşme 9600 veri hızında başlatıldı.

pinMode(sol_buton,INPUT); // 7 nolu pin giriş olarak ayarlandı.

pinMode(orta_buton,INPUT); // 6 nolu pin giriş olarak ayarlandı.

pinMode(sag_buton,INPUT); // 5 nolu pin giriş olarak ayarlandı.

}

void loop() {

if(digitalRead(sol_buton)==true)Serial.println("sol butona basildi"); //7 nolu pine 1 gelirse sol butona basıldı yazar.

delay(10); // şart sağlansada sağlanmasada 10 ms bekler.

if(digitalRead(orta_buton)==true)Serial.println("orta butona basildi"); //6 nolu pine 1 gelirse orta butona basıldı yazar.


if(digitalRead(sag_buton)==1)Serial.println("sag butona basildi"); //5 nolu pine 1 gelirse sağ butona basıldı yazar.


}

Aynı program şu şekildede yazılabilir.




void setup() {





}

void loop() {

if(digitalRead(sol_buton)==true) // true yerine HIGH yada 1 yazılabilir . 7 nolu pin 1 ise anlamına gelir.

Serial.println("sol butona basildi"); //şart sağlandığında bu satır işler.


if(digitalRead(orta_buton)==HIGH) // true yerine HIGH yazılabildiğini görelim. 6 nolu pin 1 ise anlamına gelir.

Serial.println("orta butona basildi"); // şart sağlandığında bu satır işler.


if(digitalRead(sag_buton)==1) // true yerine 1 yazılabildiğini görelim. 5 nolu pin 1 ise anlamına gelir.

Serial.println("sag butona basildi"); // şart sağlansada sağlanmasada 10 ms bekler.


}

Aynı program şu şekildede yazılabilir.




void setup() {





}

void loop() {

if(digitalRead(sol_buton)==true){ // 7 nolu pin 1 ise süslü parantez içindeki işlemleri yapar.

Serial.println("sol butona basildi"); // şart sağlandığında bu satır işler.

delay(10); // şart sağlandığında 10 ms bekler.

}

//şart sağlansa da sağlanmasa da buradaki satır işler.

if(digitalRead(orta_buton)==true){ // 6 nolu pin 1 ise süslü parantez içindeki işlemleri yapar.

Serial.println("orta butona basildi"); //şart sağlandığında bu satır işler.


}


if(digitalRead(sag_buton)==1){

Serial.println("sag butona basildi"); //true yerine HIGH yada 1 yazılabilir şart sağlandığında bu satır işler


}


}

if yapısı içerisinde birden fazla karşılaştırma kullanmak istersek mantıksal operatörler kullanılmalıdır.

Bunlar &&(And) , ||(or) ve ! (not) operatörleridir.

&&=Karşılaştırmaları çarpma işlemine tabii tutar.

||= Karşılaştırmaları toplama işlemine tabii tutar.

!= Değil işlemine tabii tutar 0 ise 1 , 1 ise 0 yapar.

Örnek1:

Aşağıdaki örnekte üç buton birlikte basılı ise led yansın aksi halde led sönsün.

int sol_buton=10; // sol_buton değişkenine 10 sayısı yüklendi.

int orta_buton=9; // orta_buton değişkenine 10 sayısı yüklendi.

int sag_buton=8; // sağ_buton değişkenine 10 sayısı yüklendi.

int led=4; // led değişkenine 4 sayısı yüklendi.

void setup() {

pinMode(sol_buton,INPUT); // 10 nolu pin giriş yapıldı.

pinMode(orta_buton,INPUT); // 9 nolu pin giriş yapıldı.

pinMode(sag_buton,INPUT); // 8 nolu pin giriş yapıldı.

pinMode(led,OUTPUT); // 4 nolu pin çıkış yapıldı.

}

void loop() {

if(digitalRead(sol_buton)==1&&digitalRead(orta_buton)==1&&digitalRead(sag_buton)==1) { // butonların üçü de basılı ise

digitalWrite(led,HIGH); // ledi yak.

}

// bu satır her zaman işler çünkü if süslü parantezi kapatıldıktan sonra yazılmış.

if(digitalRead(sol_buton)==0||digitalRead(orta_buton)==0||digitalRead(sag_buton)==0){ // butonlardan herhangi biri 0 ise

digitalWrite(led,LOW); // ledi söndür.

}

// bu satır her zaman işler çünkü if süslü parantezi kapatıldıktan sonra yazılmış.

}

Örnek2:

Sol ve orta buton birlikte basılı ise yada Sağ buton basılı ise led yansın aksi halde sönsün.





void setup() {





}

void loop() {

if(digitalRead(sol_buton)==1&&digitalRead(orta_buton)==1||digitalRead(sag_buton)==1){

// Sol ve orta buton birlikte basılı ise yada Sağ buton basılı ise

digitalWrite(led,HIGH); // ledi yak.

}

if(!(digitalRead(sol_buton)==1&&digitalRead(orta_buton)==1||digitalRead(sag_buton)==1)){ // ! İşareti ile değili alındı.

// Sağ buton basılı değilse yada Sol ve orta buton birlikte basılı değilse

digitalWrite(led,LOW); // ledi söndür.

}

}

Ledi başa döndürmek için İkinci if döngüsünde şart aynen yazıldı ve ! (değil) i alındı yani 1 ise 0 , 0 ise 1 yapıldı dolayısı ile 1. İf

döngüsünün dışında bir durum gerçekleşirse ledin durumu sürekli 1 kalmasın diye yazıldı.

Aynı programı ikinci if döngüsünü yazmadan if… else yapısı ile daha kolay bir şekilde yazabiliriz.

İf…else: if (sart) // karşılaştırma doğru ise.

{

// sart sağlandığında buradaki işlemleri yap.

}

else // karşılaştırma doğru değil ise.

{

// karşılaştırma doğru değil ise buradaki işlemleri yap.

}

Örnek1:





void setup() {





}

void loop() {

if(digitalRead(sol_buton)==1&&digitalRead(orta_buton)==1||digitalRead(sag_buton)==1){

// Sağ buton basılı ise yada Sol ve orta buton birlikte basılı ise

digitalWrite(led,HIGH); // ledi yak

}

else { // yukarıdaki koşul sağlanmaz ise

digitalWrite(led,LOW); // ledi sondur.

}

}

if…elseif…else: Bu yapıyı bir örnekle açıklayalım; Şekildeki devrede hangi butonların basılı olduğunu ekrana yazdıran programı yazalım.

Örnek1:




void setup() {




Serial.begin(9600);} // seri haberleşme 9600 veri hızında başlatıldı.

void loop() {

if(digitalRead(sol_buton)==1&&digitalRead(orta_buton)==0&&digitalRead(sag_buton)==0){

Serial.println("sadece sol buton basılı");

delay(10);}

else if(digitalRead(sol_buton)==0&&digitalRead(orta_buton)==1&&digitalRead(sag_buton)==0){

Serial.println("sadece orta buton basılı");

delay(10);}


Serial.println("sadece sag buton basılı");

delay(10);}


Serial.println("sol ve orta buton basılı");

delay(10);}


Serial.println("sag ve orta buton basılı");

delay(10);}


Serial.println("sag ve sol buton basılı");

delay(10);}


Serial.println("sag,sol ve orta buton basılı");

delay(10);}

else{

Serial.println("hiç biri basılı değil");

delay(10);}

}

Not: Burada Programı else ile bitirmesek te olur yani else if ile de bitirebiliriz. aynı programı birden fazla if yapısı ile de

yazabiliriz.

switch / case: switch içerisindeki değerle case önüne yazılan değeri karşılaştırır. Eşitlik durumunda ilgili case yapısının sınırları arasındaki işlemleri gerçekleştirir. default ise hiçbir şart sağlanmadığı durumda devreye girer ve default sınırları içindeki işlemleri gerçekleştirir.

switch (degisken) {

case 1:

// degisken 1 ise bu satırı gerçekleştir.

break; // “döngü sonu” olarak gösterilen yere yollar.

case 2:

// degisken 2 ise bu satırı gerçekleştir.


default:

// değisken ile case değerlerinden hic biri uyuşmaz ise bu satırı gerçekleştir.


}

//döngü sonu

Örnek1:

int degisken=1; // degisken değeri 1 olarak ayarlandı.

void setup() {

Serial.begin(9600); // seri haberleşme 9600 veri hızında başlatıldı.

}

void loop() {

switch (degisken) {

case 1: // degisken 1 ise

Serial.println("1"); // ekrana 1 yaz.

break; // dongu sonu olan kısıma git.

case 2: // degisken 2 ise

Serial.println("2"); // ekrana 2 yaz.


default: // degisken yukarıdaki case lerden hic biri degilse.

Serial.println("1 ve 2 den farkli deger"); // ekrana 1 ve 2 den farkli deger yaz.


} //döngü sonu

Serial.println("beni gormeden gecemezsin"); // her zaman bu satır çalışır çünkü break (süslü parantez sonu)buraya yollar.

}

Not: case önüne char yada int veri tipine sahip değişkenler yazılabilir.

case 'A' // karakter olup olmadığını sorguluyoruz.

case deger // deger değişkeni const int olarak tanımlanmak zorunda aksi halde hata verir.

Şimdi switch-case yapısını uygulamalı olarak pekiştirelim.

Dışarıdan potansiyometre ile ledin üzerine PWM uygulayalım. Ledin üzerine uygulanan PWM değeri 0-255 arası ise led yansın

PWM değeri 255 in üzerine çıktığında ise ledi korumaya alsın ve ledi söndürsün.

Şimdi devreyi tasarlayıp programını yazalım.

Potansiyometremizi analog girişlerden A1’e bağlayalım ledimizi ise PWM çıkışlardan birine 9 nolu pine bağlayalım.

int pot=A1; // pot değişkenine A1 yüklendi. int led=9; // led değişkenine 9 sayisi yüklendi. int referans_gerilimi; // referans_gerilimi adında değişken int veri tipinde tanımlandı. int sinir; // sınır adında değişken int veri tipinde tanımlandı. void setup() { pinMode(pot,INPUT); // A1 pini giriş olarak tanımlandı. Bu satır olmasa da olur. pinMode(led,OUTPUT); // 9 nolu pin çıkış olarak tanımlandı. Serial.begin(9600); } void loop() { referans_gerilimi=analogRead(A1); // A1 pinine uygulanan gerilim 0-1023 arasında referans_gerilimi değişkenine yüklendi. sinir=map(referans_gerilimi,0,1023,0,4); // 0-255 arası 0'a 255-512 arası 1 'e 512-767 arası 2'... şeklinde orantılı dağıtır. Serial.println(referans_gerilimi); // 0-1023 arası değerler ekrana yazdırılır. switch(sinir){ // karşılaştırılan sayı 0-4 arası. case 0: // sinir değişkeni 0 ise yani referans gerilim 0-255 arası ise. analogWrite(led,referans_gerilimi); // 9 nolu pine analog olarak referans gerilimini yolla. break; default: // sinir değişkeni 0 değilse(255-1023 arası ise) analogWrite(led,LOW); // 9 nolu pine 0 volt yolla. break; } delay(1); // 1ms bekle. (Tüm breaklar buraya yollar ) }

while: while döngüsü, parantez içindeki ifade () yanlış olana kadar sürekli ve sonsuz döngü yapar. Şart sağlandıktan sonra test edilen değişkenin değerini ,parantez sınırları içinde bir satırda değiştirmeniz gerekiyor aksi taktirde while döngüsünden asla çıkılamaz. Bu, kodunuzda artan bir değişken veya sensör testi gibi harici bir koşul olabilir. while(koşul), //yapılacak işlemler } Şimdi while yapısını birkaç örnekle pekiştirelim. Örnek: int a; // a değişkeni int veri tipinde tanımlandı. void setup() { Serial.begin(9600); // Seri haberleşme 9600 hızında başlatıldı. } void loop() { a=1; //a değişkeni 1'e eşitlendi. a=a+1; // a değişkeni ne 1 ekle. while(a

Şimdi while yapısı içindeki koşulu sürekli değişen sensör bilgisi ile birlikte kullanalım. Dışarıdan potansiyometre ile ledin üzerine PWM uygulayalım. Ledin üzerine uygulanan PWM değeri 0-255 arası ise led yansın

PWM değeri 255 in üzerine çıktığında ise ledi korumaya alsın ve ledi söndürsün.

(aynı uygulama switch-case yapısı ile de yapıldı bkz.)

Şimdi devreyi tasarlayıp programını yazalım.

Potansiyometremizi analog girişlerden A1’e bağlayalım ledimizi ise PWM çıkışlardan birine 9 nolu pine bağlayalım.

int pot=A1; // pot değişkenine A1 yüklendi. int led=9; // led değişkenine 9 değeri yüklendi. int okunan_deger; // okunan_deger adında değişken tanımlandı. void setup() { pinMode(pot,INPUT); // A1 pini giriş olarak ayarlandı. Bu satır olmasa da olur. pinMode(led,OUTPUT); // 9 pini çıkış olarak ayarlandı. Serial.begin(9600); //seri haberleşme 9600 hızında başlatıldı. } void loop() { // loop() Döngü başlangıcı okunan_deger=analogRead(pot); //1. SATIR A1 e bağlı analog bilgiyi okunan_deger e yükle. while(okunan_deger

Açıklama: Program çalışmaya başladığında 1.SATIR A1 ‘e bağlı potumuzdan gelen analog bilgi okunan_deger adındaki değişkene yüklenir. 2. SATIR while döngüsü içerisindeki koşul sağlanırsa yani okunan_deger küçük yada eşit 255 ise while ait süslü parantez içerisindeki satırlar işlemeye başlar. 3.SATIR ve ekrana okunan_deger ne ise o yazar sonra 4.SATIR 9 nolu pine PWM olarak okunan_deger bilgisi yollanır. Yollanan PWM bilgisine göre ledin parlaklığı değişir. Daha sonra 5.SATIR while döngüsü içerisinde analog bilginin değişip değişmediğini kontrol etmek için A1 ‘e bağlı potumuzdan gelen analog bilgi okunan_deger adındaki değişkene tekrar yüklenir ve böylece while döngüsü içerisinde sürekli olarak okunan_deger bilgisi güncellenir. Bu satırı yazmazsak okunan_deger bilgisi güncellenemez ve while döngüsüne girmeden önceki değer ne ise o kalır ve program istediğimiz gibi çalışmaz. 6. SATIR 10ms bekledikten sonra while döngüsü içerisindeki şartı kontrol etmek üzere 2. SATIRA tekrar döner ve program ikinci satırdan itibaren çalışmaya devam eder. Eğer okunan_deger bilgisi 255 ten büyük ise while döngüsünden çıkılır ve 7.SATIR 9 nolu pine 0 değeri yüklenir ve led söner daha sonra ekrana 8.SATIR okunan_deger bilgisi yazdırılır ve loop() Döngü sonu kısmından loop() Döngü başlangıcı kısmına gider ve program başlangıçtaki gibi çalışmaya devam eder. Şimdi 5. SATIR silelim ve durumu gözlemleyelim. int pot=A1; // pot değişkenine A1 yüklendi. int led=9; // led değişkenine 9 değeri yüklendi. int okunan_deger; // okunan_deger adında değişken tanımlandı. void setup() { pinMode(pot,INPUT); // A1 pini giriş olarak ayarlandı. Bu satır olmasa da olur. pinMode(led,OUTPUT); // 9 pini çıkış olarak ayarlandı. Serial.begin(9600); //seri haberleşme 9600 hızında başlatıldı. } void loop() , // loop() Döngü başlangıcı okunan_deger=analogRead(pot); //1. SATIR A1 e bağlı analog bilgiyi okunan_deger e yükle. while(okunan_deger

do….while: Do ... while döngüsü while döngüsü ile aynı şekilde çalışır, ancak koşul döngü sonunda sınanır, böylece do döngüsü daima en az bir kez çalışır. Uyarı : do..wihile yapısında while yapısından farklı olarak while(kosul) satırından sonra (;) işareti koyulur. int kosul=1; void setup() { Serial.begin(9600); } void loop() { do { Serial.println("do yapisi ici"); //1.SATIR kosul=kosul+1; //2.SATIR delay(1000); //3.SATIR } while(kosul

for: for ifadesi, belli koşul altında kendine ait süslü parantez sınırları içerisine yazılmış program satırını tekrarlamak için kullanılır. Döngüyü artırmak ve sonlandırmak için genellikle bir artış sayacı kullanılır.(i++ vb.) for ifadesi tekrar eden işlemler için yararlıdır ve genellikle veri / pin topluluğu üzerinde çalışmak için dizilerle birlikte kullanılır. for(başlatma; şart; artım){ // açıklama } Örnek: int i; void setup() { Serial.begin(9600); } void loop() { for (i=5;i

Şimdi 9 numaralı pine(PWM pin) bağlı ledin parlaklığını PWM olarak 0-255 arasında değiştiren devreyi tasarlayıp programını yazalım. int led = 9; int pwm_deger; void setup() { pinMode(led,OUTPUT); // bu satır yazılmasa da olur. Çünkü 9 nolu pin PWM çıkış olarak ayarlıdır. } void loop() { for (pwm_deger=0; pwm_deger

UYARI: for, while ve if yapısının sınırları süslü parantez ile belirlenmez ise karşılaştırma satırından sonraki ilk satır süslü parantez sınırı olarak kabul edilir ve program o şekilde akışına devam eder. Yani, for döngüsü için; for (pwm_deger=0; pwm_deger

Yukarıdaki program satırlarında ki gibi süslü parantez ile do while sınırları belirlenmemiş ise do satırından sonra en fazla bir satırlık işleme izin verilir ikinci bir satırı yazmak istesek te hata ile karşılaşırız. Bu bir satırlık kısım do…while’nin süslü parantez sınırları dahilindeymiş gibi işlem görürür.

break: for, while veya do ... while döngüsünün dışına çıkmak için kullanılır. Ayrıca switch case deyiminden çıkmak için de kullanılır. Program akışını ilgili kontrol yapısına(for,while..) ait süslü parantezin hemen altına dallandırır. Örnek: int i=1; void setup() { Serial.begin(9600); } void loop() { while(i==1){ Serial.println("while yapisi icindeyim"); delay(1000); break; //while ait süslü parantezin altına yollar. } // break buraya yollar. Serial.println("break sayesinde while dongusunden ciktim"); delay(1000); i=i+1; // i sayısı her defasında 1 arttırılır. } break if yapısı içerisinden çıkmak amacı ile kullanılmaz. Ancak if yapısı for,while yada do while sınırları içerisinde bir yerde kullanılmışsa if içerisinde bir satıra break yazılabilir. if yapısının içerisine yazılan break satırı if yapısının sınırları dışına değil içerisinde bulunduğu ilgili for,while yada do while döngüsünün sınırları dışına program akışını dallandırır. Örnek: int i=1; int a=4; void setup() { Serial.begin(9600); } void loop() { while(i==1){ //while başlangıç. Serial.println("while yapisi icindeyim"); delay(1000); if(a

continue:

Continue deyimi, bir döngünün tekrarlanan kısmının istenilen belli bir bölümünü atlar (for, while veya do ... while). Döngünün koşullu ifadesini kontrol ederek atlanan kısımdan sonra kalanını devam ettirir. Örnek: int a; void setup() { Serial.begin(9600); } void loop() { for(a=0;a1&&a

goto:

Program akışını istenilen herhangi bir etiketli noktaya aktarırı. adres: goto adres; Örnek: int a=1; void setup() { Serial.begin(9600); } void loop() { a=a+1; // 1.SATIR while(a

return: İki şekilde kullanılır; return 1.Kullanım şekli: Program akarken return ile karşılaşıldığında döngü başına döndürülür ve return’dan sonra gelen program satırları işlemez. void loop(){ // asıl çalışması istenen kısım return; // burası hiçbir zaman işlemez } Örnek: int a=1; void setup() { Serial.begin(9600); } void loop() { a=a+1; // 1.SATIR while(a

Fonksiyonlar: Program yazarken en çok kullanılan özelliklerden biri de fonksiyon oluşturma ve fonksiyonları çağırmadır. Kullanım sebebi program yazılırken defalarca aynı satırları yazmak yerine işlemlerin bir fonksiyon içerisinde tanımlanmasını sağlamak ve o işlemlere ihtiyaç duyduğumuzda ait olduğu fonksiyonu çağırarak programı daha sade hale dönüştürmektir. Bir nevi alt program da diyebiliriz. Şimdi fonksiyonları kullanmaya başladığımızda ne demek istendiğini daha iyi anlayacaksınız. Fonksiyonlar fonksiyon içerisinde tanımlanamazlar yani vood loop() içerisinde fonksiyon tanımlayamayız. Fonksiyon tiplerini 4 ana başlık altında toplamak gerekirse;

Parametre almayan ve değer döndürmeyen fonksiyonlar.

Parametre almayan ve değer döndüren fonksiyonlar.

Parametre alan ve değer döndürmeyen fonksiyonlar.

Parametre alan ve değer döndüren fonksiyonlar.

Parametre almayan ve değer döndürmeyen fonksiyonlar: En basit fonksiyon tipidir değer döndürmeyen fonksiyon tipi olduğu için void olarak fonksiyonumuzu tanımlıyoruz. void fonksiyon_adi() Şeklinde kullanılır. Örnek: void fonksiyonum() // fonksiyonum() adında fonksiyon tanımladık burası sadece çağrıldığı zaman işlem yapar. { Serial.println("fonksiyonu cagirdiniz"); //ekrana “fonksiyonu cagirdiniz” yazar. delay(5000); //5 sn bekler. } void setup() { Serial.begin(9600); //seri haberleşme 9600 veri hızında başlatıldı. } void loop() { Serial.println("merhaba birazdan fonksiyonu cagiricagiz"); // ekrana "merhaba birazdan fonksiyonu cagiricagiz" yazar. delay(4000); // 4 sn bekler. fonksiyonum(); // fonksiyonum adındaki fonksiyonu buraya çağır. Serial.println("fonksiyondan cikmis bulunuyorsunuz"); //ekrana "fonksiyondan cikmis bulunuyorsunuz" yazar. delay(4000); }

Program: const int sol_buton=5; const int sag_buton=4; const int kirmizi_led=10; const int yesil_led=11; int i; void solbuton(){ digitalWrite(kirmizi_led,HIGH); delay(5000); digitalWrite(kirmizi_led,LOW); } void sagbuton(){ digitalWrite(yesil_led,HIGH); delay(5000); digitalWrite(yesil_led,LOW); } void ikisibir(){ for(i=0;i

Parametre almayan ve değer döndüren fonksiyonlar: Değer döndüren olduğu için void yerine int, float vb veri tipleri kullanılarak fonksiyonun alacağı veri tipi belirlenir. Fonksiyon adından sonra parantez içerisine herhangi bir değişken yazılmaz bu da paramatre almadığı anlamına gelir. int fonksiyon_adi() Şeklinde kullanılır. Örnek: int a=7; // a=7 değeri yüklendi. int b=9; // b=9 değeri yüklendi. int sonuc; // sonuc adında değişken tanımladık. int toplama; //toplama adında değişken tanımladık. int toplama_fonksiyonum(){ // toplama_fonksiyonum adında bir parametre içermeyen fonksiyon tanımladık. toplama=a+b; // daha önceden tanımladığımız toplama değişkenine a ve b sayılarını toplayarak atadık. return(toplama); // toplama sonucunu toplama_fonksiyonum()’ a ata ve fonksiyonun çağrıldığı yere git. } void setup() { Serial.begin(9600); // Seri haberleşmeyi 9600 hızında başlat. } void loop() { sonuc= toplama_fonksiyonum(); //toplama_fonksiyonum() adlı fonksiyonu çağır ve değerini sonuc adlı değişkene yükle. Serial.println(sonuc); //sonuc değişkeninin değerini ekrana yaz 16 yazar. while(1){ //Sonsuz döngüye gir sürekli while içinde döner program. } } Örnek: int a=7; // a=7 değeri yüklendi. int b=9; // b=9 değeri yüklendi. int sonuc; // sonuc adında değişken tanımladık. int toplama; //toplama adında değişken tanımladık. int sensorkontrol () { // sensorkontrol adında bir parametre içermeyen fonksiyon tanımladık. if(a > 5) { // a değeri büyük 5 ise return 1 ; // sensorkontrol () fonksiyonunun değerini 1 yap ve fonksiyonun çağrıldığı yere git. } else // a değeri 5 ten büyük değil ise return 0; sensorkontrol () fonksiyonunun değerini 0 yap ve fonksiyonun çağrıldığı yere git. } void setup() { Serial.begin(9600); // Seri haberleşmeyi 9600 hızında başlat. } void loop() { sonuc= sensorkontrol (); // sensorkontrol () adlı fonksiyonu çağır ve değerini sonuc adlı değişkene yükle. Serial.println(sonuc); //sonuc değişkeninindeğerini ekrana yaz. while(1) //sonsuz döngüye gir. }

Parametre alan ve değer döndürmeyen fonksiyonlar: Gönderildiği yerden istekte bulunarak fonksiyon içerisindeki parametrelere (değişkenlere) müdahale edilmesi durumuna parmetre alan fonksiyon denir. Değer döndürmeyen fonksiyon ise return içerisine değişkenin yazılmadığı durumdur. Bu sebepten dolayı fonksiyon tanımlanırken veri tipi yerine void ile tanımlama yapılır. void fonksiyon_adi ( int parametre1, int parametre2…) Şeklinde kullanılır. Örnek:

9 nolu pine bağlı ledi 1sn. Aralıklarla 6 defa yakıp Söndüren sistemin devresini yapıp programını yazalım.

const int led=9; // led değişkeni 9 yapıldı. Devre Şeması:

void parametreli_fonksiyon(int parametre){ //Çağrıldığı yerden gönderilen parametre değerini parametre’ye ata ve fonks. başla. for(int i=0; i

Parametre alan ve değer döndüren fonksiyonlar: Fonksiyon içerisinde kullanılan parametre değerleri fonksiyon çağrılırken belirlenebilir (parametre alan) ayrıca fonksiyon hesaplandıktan sonra fonksiyona return yardımı ile bir değer yüklenip çağrıldığı yere yollanabilir.(değer döndüren) int fonksiyon_adi ( int parametre1, int parametre2…) şeklinde kullanılır. Örnek:

Analog olarak gelen bilgi 0-255 arasında ise yeşil ledi analog olarak yakıp 0 sayısını döndüren fonksiyonun değerini ve ledi yakan PWM değerini ekrana yazan ayrıca; Analog olarak gelen bilgi 256-511 arasında ise kırmızı ledi analog olarak yakıp 1 sayısını döndüren fonksiyonun değerini ve ledi yakan PWM değerini ekrana yazan ayrıca; Analog olarak gelen bilgi 512-767 arasında ise sari ledi analog olarak yakıp 2 sayısını döndüren fonksiyonun değerini ve ledi yakan PWM değerini ekrana yazan ayrıca; Analog olarak gelen bilgi 767-1023 arasında ise tüm ledleri analog olarak yakıp 3 sayısını döndüren fonksiyonun değerini ve ledi yakan PWM değerini ekrana yazan sistemin devresini yapıp programını yazalım.

Devre Şeması

Program:

const int yesil_led=9; const int kirmizi_led=10; const int sari_led=11; const int pot=A0; int s_donen; int y_donen; int k_donen; int l_donen; int yesil_fonk(int sensor_degeri){ for(int i=0;i

Kesme işlemleri(interrupt): Program çalışırken anlık müdahalede bulunulması gereken durumlarda kesmeler kullanılır. Normalde program çalışma mantığı yukarıdan aşağıya doğrudur ve her komut satırı sırası geldiğinde belli kurallar dahilinde işler. Örneğin if yapısı kullanarak bir butona basıldığında ledi 10 sn aralıklarla yakıp söndüren program düşünün burada ledin yanma süresi delay() komutu ile 10 sn bekletilerek yapılmışsa program akışını değiştirmek istersek 10 sn sürenin geçmesini beklemeliyiz. fakat böyle bir durmda Dışarıdan reset butonuna basarsak 10 sn lik süre beklemeden program çalışması başa dönecektir. İşte kesme tamda buna benzer reset atmak gibi düşünülebilir. Yani kısaca interrupt, anlık müdehale yapmamız gereken yerlerde kullanılır.

Kesme çeşitleri: Dış kesme.

Zaman kesmesi. Dış kesme: Ardunida belirlenmiş özel pinlere uygulanan voltaj değerlerine göre dış kesme özelliği kullanılır. Örneğin Ardunio UNO için 2,3 nolu pinler dış kesme pinleridir. Diğer arduniolara ait dış kesme pinleri aşağıdaki gibidir.

KARTLAR Kesme pinleri

Uno, Nano, Mini, other 328-based 2, 3

Mega, Mega2560, MegaADK 2, 3, 18, 19, 20, 21

Micro, Leonardo, other 32u4-based 0, 1, 2, 3, 7

Zero 4 Hariç tüm digital pinler.

MKR1000 Rev.1

0, 1, 4, 5, 6, 7, 8, 9, A1, A2

Due Tüm digital pinler

101 Tüm digital pinler (Sadece 2,5,7,8,10,11,12,13) CHANGE ile birlikte çalışır

Yukarıdaki bilgiler dahilinde, Arduino UNO’nun 2. pinine bir buton bağlayalım ve kesme olarak kullanılacak şekilde ayarlayalım. Bu butona basıldığında kod satırı her nerede işliyor olursa olsun yaptığı işi bırakıp bizim istediğimiz işlemleri yapacaktır. Arduino da dış kesme AttachInterrupt(); fonksiyonu kullanılarak yapılmaktadır. AttachInterrup fonksiyonunun kullanım şekli: attachInterrupt ( digitalPinToInterrupt (pin), fonksiyon_adi, gerilim_durumlari); digitalPinToInterrupt (pin); pin yerine ardunio uno çin 2 ya da 3 yazılabilir. digitalPinToInterrupt(2); ya da digitalPinToInterrupt(3); şeklinde yazılmalıdır. Bu kısıma tanımlı olan kesme sayılarıda doğrudan yazılabilir. digitalPinToInterrupt(2) yerine 0 değeri yazılabilir. digitalPinToInterrupt(3) yerine 1 değeri yazılabilir. attachInterrupt ( 0, fonksiyon_adi, gerilim_durumlari ); // Şeklinde de yazılablir. attachInterrupt ( 1, fonksiyon_adi, gerilim_durumlari ); // Şeklinde de yazılablir.

Not: Burada kullanılan 0 ve 1 değerleri pin numarası değil digitalPinToInterrupt(2), ve digitalPinToInterrupt(3) satırlarının yerine atanan özel değerlerdir. Bu özel durumların kullanılması tavsiye edilmeyen durumdur. Diğer ardunio kartlarının kesme pinlerine tanımlı kesme sayıları şunlardır;

int.0 int.1 int.2 int.3 int.4 int.5

Uno, Ethernet 2 3 Mega2560 2 3 21 20 19 18 32u4 based (e.g Leonardo, Micro) 3 2 0 1 7 Due, Zero, MKR1000, 101 interrupt number = pin number

ARDUİNO ÖĞRENİYORUM · 2019. 12. 19. · ARDUİNO ÖĞRENİYORUM PROGRAM YAPISI: void setup():...

Documents

Transcript of ARDUİNO ÖĞRENİYORUM · 2019. 12. 19. · ARDUİNO ÖĞRENİYORUM PROGRAM YAPISI: void setup():...