ADIM ADIM ARDUINO.pdf

“ARAŞTIR, ÖĞREN, GELİŞTİR, UYGULA”

ADIM ADIM ARDUİNO

SENCER ALTUN

KITAP HAKKINDA

YAZAR SENCER ALTUN

KAPAK TASARIMI EMRE KILIÇ

BASKI 2017

ÖNSÖZ Günümüzde elektronik büyük bir hızla gelişmektedir. Bu gelişen teknolojiye yetişebilmemiz, gelişmeleri iyi izleyebilmemiz, onlardan faydalanmamızla mümkün olacaktır. Arduino, Raspberry Pİ, Beaglebone vs. bir çok geliştirme kartları mevcut. Elektroniği anlayabilmemiz için deneyler yapmalıyız.Bu kitapta en popüler olan Arduino kartını inceleyeceğiz ve deneyler yapacağız. Bu kitapdaki uygulamalar denenmiştir. Faydalı olmak dileğiyle…

SENCER ALTUN

İÇİNDEKİLER TEMEL ELEKTRONİK .................................................................................................................................8 DİRENÇLER ............................................................................................................................................9 POTANSİYOMETRE(AYARLI DİRENÇ) ............................................................................................... 11 BUZZER .......................................................................................................................................... 12 ULTRASONİK MESAFE SENSÖRÜ(HC – SR04) ............................................................................. 12 LM35 SICAKLIK SENSÖRÜ ....................................................................................................... 12 LED (LIGHT EMİTTİNG DİODE - IŞIK YAYAN DİYOT) ............................................................. 13 ARDUİNO NEDİR ................................................................................................................................... 15 ARDUİNO İDE PROGRAMINA GİRİŞ ...................................................................................................... 17 1-ARDUİNO’YA GİRİŞ ............................................................................................................................ 20 2-DİGİTAL PİNLERİ ÇIKIŞ OLARAK KULLANMA ..................................................................................... 23 ARDUİNO KARAŞİMŞEK UYGULAMASI .............................................................................................. 24 3-DİGİTAL PİNLERİ GİRİŞ OLARAK KULLANMA..................................................................................... 26 ARDUİNO LED-BUTON UYGULAMASI ................................................................................................ 27 4-İF – ELSE KOMUTUNU KULLANMAK.................................................................................................. 29 ARDUİNO BUTON - KARAŞİMŞEK UYGULAMASI................................................................................ 30 5-SERİAL MONİTÖR VE DEBUGGİNG .................................................................................................... 34 6-DEĞİŞKEN TANIMLAMA VE VERİ TİPLERİ(1) ..................................................................................... 38 7-DEĞİŞKEN TANIMLAMA VE VERİ TİPLERİ(2) ..................................................................................... 40 8-CONST VE DEFİNE İFADELERİNİN KULLANIMI ................................................................................... 42 9-TEMEL MATEMATİK İŞLEMLERİ ......................................................................................................... 47 ARDUİNO İLE DÖRT İŞLEM .............................................................................................................. 48 KALAN BULMA............................................................................................................................... 49 KAREKÖK BULMA ....................................................................................................................... 50 MUTLAK DEĞER ...................................................................................................................... 50 10-DEĞİŞKEN ÖMÜRLERİ, KARŞILAŞTIRMA VE MANTIK İFADELERİ .................................................... 51 DEĞİŞKEN TANIMLAMA ..................................................................................................................... 52 KARŞILAŞTIRMA.............................................................................................................................. 54 MANTIK İFADELERİ ....................................................................................................................... 55 UYGULAMA(PARK SENSÖRÜ) ............................................................................................................... 57

11- WHİLE DÖNGÜSÜ............................................................................................................................ 61 12- DO WHİLE DÖNGÜSÜ ..................................................................................................................... 67 13- SWİTCH CASE YAPISI ....................................................................................................................... 71 14- FOR DÖNGÜSÜ................................................................................................................................ 78 15- BREAK VE CONTİNUE ...................................................................................................................... 83 FOR İLE KULLANIM............................................................................................................................. 85 WHİLE İLE KULLANIM ...................................................................................................................... 86 16- ANALOG GİRİŞ VE 10BİT ADC ......................................................................................................... 91 POTANSİYOMETRE İLE GELEN BİLGİYİ OKUMA ................................................................................. 92 UYGULAMA(ARDUİNO İLE LM35 KULLANIMI) ..................................................................................... 95 RGB LED HAKKINDA BİLİNMESİ GEREKENLER.................................................................................. 103 17- ANALOG ÇIKIŞ – PWM .................................................................................................................. 106 ANALOG ÇIKIŞ .................................................................................................................................. 107 PWM NEDİR................................................................................................................................... 110 DİGİTAL SİNYAL .......................................................................................................................... 111 ANALOG SİNYAL ................................................................................................................... 111 ANALOG SİNYALLER İLE RGB LED ...................................................................................... 112 18- FONKSİYONLAR -1- ....................................................................................................................... 113 PARAMETRE ALMAYAN VE DEĞER DÖNDÜRMEYEN FONKSİYONLAR............................................. 114 19- FONKSİYONLAR -2- ....................................................................................................................... 118 PARAMETRE ALMAYAN VE DEĞER DÖNDÜREN FONKSİYONLAR .................................................... 119 20- FONKSİYONLAR -3- ....................................................................................................................... 125 PARAMETRE ALAN VE DEĞER DÖNDÜRMEYEN FONKSİYONLAR .................................................... 126 HESAP MAKİNESİ UYGULAMASI ................................................................................................... 128 21- FONKSİYONLAR -4- ....................................................................................................................... 131 PARAMETRE ALAN VE DEĞER DÖNDÜREN FONKSİYONLAR............................................................ 132 22- MİLLİS – MİCROS – DELAY – DELAYMİCROSECONDS................................................................... 135 delay(); ............................................................................................................................................. 136 delayMicrosaniye(); .................................................................................................................... 136 millis(); ..................................................................................................................................... 137 micros(); ............................................................................................................................... 141 23- TEK BOYUTLU DİZİLER (ARRAY) .................................................................................................... 142 DİZİLER ............................................................................................................................................. 143 24- ÇİFT BOYUTLU DİZİLER(ARRAY) .................................................................................................... 150

ADIM ADIM ARDUİNO – SENCER ALTUN

Sayfa 6

TEMEL ELEKTRONİK


Sayfa 7

TEMEL ELEKTRONİK Bu ilk dersimizde, kullanacağımız bileşenler hakkında bilgi edineceğiz.

DİRENÇLER Dirençler pasif devre elemanlarıdır. Pasif olarak nitelendirilmelerinin sebebi, kendi kendine gerilim yada akım üretmemeleridir. Direnç elektrik akıma karşı gösterilen zorluk olarak bilinir. Direnç değeri yükseldikçe uçlarındaki gerilim artmakta, direnç üzeriden geçen akım azalmakta, direnç değeri azaldıkça dirençten geçen akım artmakta, direnç uçlarındaki gerilim ise azalmaktadır. Böylece elektronik devrelerde akım ve gerilimi direnç aracılığıyla değiştirebiliyoruz. Dirençler ohm(Ω), kiloohm(KΩ) ve megaohm(MΩ) birimlerinde kullanılmaktadır. Direncin kullanıldığı devre çeşidine göre tolerans ve güç değerleri önem kazanmaktadır. Toleransı yüksek bir direnç hassas devrelerde kullanıldığında hataya yol açabileceği gibi, yüksek akıma maruz kalacak dirençlerin güç değerlerininde buna uygun olarak seçilmesi gerekmektedir. Bir direncin tam değeri üzerinde yazan değer değildir. Fabrika verilerine göre belirlenmiş toleransa sahip dirençler, tolerans değerine göre direnç değerinin değişim aralığını belirler. Örneğin değeri 100Ω olan bir direncin tolerans değeri +%10 ise bu direncin ölçülen değeri 90Ω ila 110Ω arasında bir değer olacaktır. Aynı direncin toleransı +%1 olsaydı, ölçülen direnç değeri 99Ω ila 101Ω arasında bir değer olacaktı. Hassasiyet gerektiren devrelerde mümkün olduğunca düşük toleranslı dirençler kullanarak devremizin doğruluğunu ve kesinliğini artıracaktır.

DİRENÇ DEĞERLERİNİN OKUNMASI Dirençler üretilirken iki farklı yöntem ile değerleri belirlenir. Birinci yöntem, sıklıkla kullanılan renk kodları ile değerleri belirlenirken ikinci yöntem ise, British Standart olarak bilinen BS1859 standardıdır. Diğer bir yöntem ise SMD dirençlerde sadece sayılar ile değerlendirilmesidir.

Dirençleri genellikle renkleri ile değerlendiririz. Piyasada sıklıkla kullanılan dirençlerin üzerinde 4, 5 yada 6 renk bandı bulunur. 4 renkli dirençler en çok karşılaşacağımız direnç çeşididir ve bu dersimizde 4 renkli dirençleri inceleyeceğiz. Aşağıdaki tabloda direncin değerini, kenara en yakın olan banttan itibaren okumaya başlarız.


Sayfa 8

İlk iki renk değerleri tablodan bakılarak aynen alınır. 3. renk direncin değerini belirleyen çarpan rengidir. Bu değerde tablodan okunarak direncin ilk iki renginden dolayı elde edilen değerin çarpanı olarak kullanılır. 4. renk değeri ise direncin tolerans değerini belirler. Tabloda 4 ve 5 renkli direnç değerleri gösterilmiştir. Şimdi siz sadece 4. renk değerlerini dikkate alınız.

Yandaki resimde direnç sembolünü görmektesiniz.


Sayfa 9

POTANSİYOMETRE(AYARLI DİRENÇ) Ayarlı dirençler, çok farklı çeşitlerde üretilmektedirler. Genel yapı karbon bir hat üzerinde hareket eden bir uç direncin değerini değiştirmektedir. Çoğu potansiyometrenin 3 bacağı bulunur. Sabit iki uç ve ayar ucu olarak belirtilir. Potansiyometreler, ihtiyaca göre sürgülü çok turlu, tek turlu, trimpot gibi çeşitlerde imal edilmişlerdir.

Yandaki

resimde

potansiyometrenin

iç

yapısını

görmektesiniz.

Yandaki resimde Amerikan Sembollerini görmektesiniz.


potansiyometrenin

Uluslararası

ve

Sayfa 10

BUZZER Zil olarak bilinirler. Sesli geri bildirim almak istenilen projelerde kullanılırlar. Arduino ile kullanacağımız buzzer’i hem digital hemde PWM çıkışıyla kontrol edebilirsiniz. Yüksek PWM sinyali gönderdiğinizde buzzer’dan çıkan sesinde şiddetlendiğini fark edeceksiniz.

ULTRASONİK MESAFE SENSÖRÜ(HC – SR04) Sensör 2cm-4m arasındaki uzaklıkları ölçmektedir. Fakat 4m’e doğru sensör kalitesi bozulmaktadır. Sensör insan kulağının duyamayacağı bir frekansta ses yollar. Ses eğer bir yere çarpar ise geri yansız ve sensörümüze gelir. Sensör bu sesin gidip gelme süresini hesaplar ve böylece cismin uzaklığını bulur. Bu yüzden bu sensöre ultrasonik ses sensörü de denir.

LM35 SICAKLIK SENSÖRÜ LM35 serisi sıcaklık sensörleri, çıkış olarak sıcaklık ile doğru orantılı bir voltaj verirler. LM35 kullanırken kalibrasyon amaçlı bir devre kurmamız gerekmez. 60 µA gibi düşük bir akım çeker. Bu nedenle, çalışırken kendi içinde ısı düşüktür ve entegrenin kendisi ortam sıcaklığından yalnız 0.1 ºC fazla olur. Çıkış empedansı düşük olduğu için, verdiği voltaj ölçülürken hata payı küçük olur.


Sayfa 11

LM35 BACAKLARI 3 adet bacağı vardır. Bunlardan ikisi besleme voltajı ve toprak için kullanılır. Geri kalan bir bacaktan sıcaklığa bağlı olarak değişen çıkış voltajını alırız. 1.numara; besleme voltajı. 2. numara; çıkış. 3. numara; toprak(GND).

LED (LIGHT EMİTTİNG DİODE - IŞIK YAYAN DİYOT) Işık yayan diyotlar veya bilinen adıyla ledler, birçok alanda kullanılan farklı tipteki yarı iletken diyotlardır. Bu diyotların birçoğunun yaydığı ışık, görünür bant genişliği (400700mm) aralığında ışık yayar. Görünmeyen dalga boyunda ışık yayan infra-red diyotlar ise uzaktan kontrol uygulamalarında sıklıkla kullanılmaktadır. Ledler flamanlı lambalara benzemez. Led’in harcadığı enerjinin büyük bir kısmı ışık enerjisine çevrilirken, lambalarda harcanan enerjinin büyük kısmı ısı enerjisine çevrilir. Bu yüzden son yıllarda gelişen led teknolojisi sayesinde birçok aydınlatma alanında ledler kullanılmaya başlanmıştır. Led’in anot ve katot olmak üzere iki bacağı vardır. Anot = Artı, Katot = Eksi’dir. Güç kaynağımızın (+) kutbunu anot’a, (-) kutbunu katot’a bağlayarak ledi yakabiliriz. Aksi taktirde led yanmaz.

LED RENKLERİ;

Led’ler kristal diyotlara yada güç diyotlarına yapı olarak benzemezler. Sadece germanyum yada silisyumdan imal edilmemişlerdir. GalyumArsenid(GaAs), Galyum Fosfat(GaP), GalyumArsenidFosfat(GaAsP), Silikonkarbit(SiC) veya Galyumindium nitrit(GalnN) gibi maddelerden yapılmıştır. Tüm bu maddeler, led’in farklı dalga boylarında ışık yaymasını sağlar.

Yanda led’in simgesini görüyorsunuz.

LED KARAKTERİSTİĞİ;

Led’in yaydığı ışığın rengi yapım maddesine göre değişim göstermektedir. Bu maddenin direncide değişim göstermekte ve üzerinden geçen akım miktarı ışığın rengine göre değişmektedir. Bir led’i normal şartlar altında ileri yönde kutuplayarak çalıştırmak için led’e seri bağlı bir direnç bağlamak gerekir. Bu direnç, led’in çektiği akımı sınırlama ve koruma görevi yapar. Led’i direk olarak bir güç kaynağına bağladığımızda led’in bozulması çok uzun sürmeyecektir. Led’in normal şartlarda çekmiş olduğu akım değeri yaklaşık 20mA civarıdır. ADIM ADIM ARDUİNO – SENCER ALTUN

Sayfa 12

Devrede kullanılacak seri direnci ohm kanunu ile hesaplayabiliriz. Burada kullanacağımız direnç değeri, Yukarıdaki formül ile hesaplanır. Burada If led’in çektiği akım, Vs gerilim kaynağı, Vf led uçlarındaki gerilim olarak verilmiştir.

OHM KANUNU Sıcaklığın sabit tutulduğu bir ortamda iletkenin direnci de sabittir. İletken uçlarındaki gerilim değerini, iletkenden geçen akım miktarına böldüğümüzde iletkenin direncini elde etmiş oluruz. Direnç, gerilim ve akım arasındaki bu ilişkiye OHM Kanunu diyoruz.

V = Potansiyel Fark (Gerilim-Volt) I = Akım (Amper) R = Direnç (Ohm)

Potansiyel Fark(Gerilim-Volt)’ı Bulmak İçin; Devreden Geçem Akımı Bulmak İçin; Devrenin Direncini Bulmak İçin;


Sayfa 13

ARDUİNO NEDİR


Sayfa 14

ARDUİNO NEDİR? Arduino kolay bir şekilde çevresiyle etkileşime girebilen sistemler tasarlayabileceğiniz, hem acemi hem de ileri düzeydeki elektronik meraklılarına hitap eden, anlaşılması kolay bir dili olan, kolayca programlanabilen ve üzerine elektronik devre kurulabilen açık kaynaklı bir geliştirme platformudur. Arduino Uno en yaygın kullanılan Arduino kartıdır. 14 dijital giriş / çıkış'a (6 PWM çıkışı), 6 analog girişe, bir 16 MHz kristal osilatöre, bir USB bağlantısına, bir güç girişine, bir ICSP başlığına ve bir reset düğmesine sahiptir(varolan program butona basıldığında silinmez sadece baştan başlatır). Arduino’nun üzerinde ledler bulunur. Bunlarda biri açık olduğunu gösteren “on” etiketli led. Diğeri “L” etiketli led, işlevini tamamen bizim belirleyeceğimiz leddir. Geriya kalan iki led ise “RX” ve “TX” etiketli ledlerdir. Bu ledler Arduino’nuzla bilgisayarınız arasında bir iletişim olduğunda seri bir şekilde yanıp sönerler. “RX” alım anlamına gelir. “TX” ise gönderim anlamına gelir.

Arduino ile birçok uygulama yapabilirsiniz, bunun için biraz elektronik temeli ve birazcıkta program yazma yeteneğiniz olması gerekli. Bahçenizdeki sulama sistemlerinden tutunda, çiçeklerinizin nem oranını ölçmeye, arabalardaki park sensöründen tutun, hızsız alarm sistemlerine kadar aklınıza gelebilecek birçok elektronik uygulamaları bu kart ile yapabilirsiniz.

Projelerinizde kullanacağınız birçok Arduino kartları mevcuttur. İstediğiniz kartı, yapacak olduğunuz projelere göre seçebilirsiniz. Biz bu kitapçıkta en çok tercih edilen kartı, Arduino Uno kartını kullanacağız.


Sayfa 15

ARDUİNO İDE PROGRAMINA GİRİŞ


Sayfa 16

ARDUİNO IDE PROGRAMINA GİRİŞ

Programı bilgisayara kurduktan sonra büyük olasılıkla karşımıza türkçe bir arayüz menüsü çıkacaktır(yukarıda görüldüğü gibi). Dosya bölümüne girdiğimizde bizi karşılayan başlıklar ”Yeni proje oluşturma”-“Varolan dosyayı açma” – “taslak defteri” – “örnek programlar” gibi önemli başlıklar mevcut. Düzenle bölümüne girdiğimizde genellikle program içerisindeki işlemleri “kopyalama – yapıştırma – geri alma – kelime bulma” düzenleme komutları mevcut. Taslak bölümüne girdiğimizde “Yazdığımız programı kontrol etme/derleme – programın hangi klasörde olduğunu” gibi işlemleri barındırıyor. Araçlar sekmesine baktığımızda “Seri port ekranı – kart(hangi Arduino’yu kullanıyorsak seçilmesi gereken alan ) – Port(hangi portu kullanıyorsak seçilmesi gereken port). ADIM ADIM ARDUİNO – SENCER ALTUN

Sayfa 17

1.bölüme baktığımızda yazdığımız programımızı derlememiz içindir.Hata varsa bize turuncu arkaplan üzerinde yazılı bilgi verilecektir. 2.bölüme baktığımızda, programımızda herhangi bir sorun/hata yoksa ve Arduino’muzu bilgisayara bağladığımızdan emin olduğumuzda karta yükleme yapıyoruz. 3.bölüme baktığımızda, yeni bir dosya oluşturmamız için verilen kısayol. 4.bölüme baktığımızda, varolan dosyayı açmak için verilen başka bir kısayol. 5.bölüme baktığımda ise yaptığımız çalışmayı kayıt etmemize yarayan kısayol.


Sayfa 18

1. BÖLÜM ARDUİNO’YA GİRİŞ


Sayfa 19

ARDUİNO’YA GİRİŞ GİRİŞ Arduino iki bölümden oluşur; Void setup(){////}

Arduino çalışmaya başlamadan önce yapması gereken ayarları söylediğimiz bölüm. Void loop’da Arduino’ya verdiğimiz işleri yapabilmesi için Arduino’ya ön hazırlık olarak gerekli ayarları yaptırıyoruz.

Örnek; “1,2,3, pin çıkış” “3,4,8, pinler giriş pini olacak” gibi..

Void loop(){////}

Sürekli tekrar etmesini istediğimiz eylemleri yazarız.

ÖRNEK PROGRAM

Led için 220 OHM direnç kullanılmıştır.


Sayfa 20

void setup() { pinMode(13, OUTPUT); // 13.Pini çıkış pini atadık. } void loop() { digitalWrite(13, HIGH); // 13. Bacağa güç ver, ledi yak. delay(1000);

// 1 saniye bekle.

digitalWrite(13, LOW); //13. Bacağı söndür. delay(1000);

//1 saniye bekle.

}

pinMode(X, OUTPUT-INPUT);

Daima void setup bölümüne yazılır. X pinimiz çıkış mı yosa giriş mi tanımlamasının yapıldığı yer. Bir pinden dışarıya komut yada güç vericeksek tercih etmemiz gereken komut OUTPUT(Çıkış) komutudur.

Örnek; Led Eğer bir bileşenden geri bildirim almak istiyorsak tercih etmemiz gereken komut INPUT(Giriş) komutudur.

Örnek; Isı sensörü, buton. DigitalWrite(X, HIGH – LOW);

Daima void loop bölüne yazılır. X pinimiz HIGH(5V) mı yoksa LOW(0V) mu tanımlamasının yapıldığı yer.

delay(xxxx); Beklenecek sürenin tanımlandığı yer. Milisaniye cinsinden. İnt xxxx = x ;

X pinimizin ismini atadık. Void setup bölümünün üzerine yazılır. İlerleyen aşamalarda x pini değilde xxxx pini dememiz için.(

NOT; Kod satırını açıklamak istiyorsak eğer, satırın sonuna veya herhangi bir yere “//” işareti ile istediğimiz açıklamayı yazabiliriz. Programa dahil olmaz. Örneklerimizde görüldüğü gibi.


Sayfa 21

2. BÖLÜM DİGİTAL PİNLERİ ÇIKIŞ OLARAK KULLANMAK


Sayfa 22

DİGİTAL PİNLERİ ÇIKIŞ OLARAK KULLANMAK ARDUİNO KARAŞİMŞEK UYGULAMASI

Led için 220OHM direnç kullanılmıştır.

void setup() { pinMode(2, OUTPUT);

// 2. pinimizi çıkış olarak tanımladık.

pinMode(3, OUTPUT);


pinMode(4, OUTPUT);


pinMode(5, OUTPUT);


pinMode(6, OUTPUT);


} void loop() { digitalWrite(2, HIGH);

// 2. pinimize lojik-1 değerini atadık.(+5V)

delay(500);

// 500mS bekle. 500x10-3 = 0.5sn

digitalWrite(2, LOW);


delay(500);

// 500mS bekle. 500x10-3 = 0.5sn


Sayfa 23

digitalWrite(3, HIGH);


delay(500);

// 500mS bekle. 500x10-3 = 0.5sn



delay(500);

// 500mS bekle. 500x10-3 = 0.5sn



delay(500);

// 500mS bekle. 500x10-3 = 0.5sn



delay(500);

// 500mS bekle. 500x10-3 = 0.5sn



delay(500);

// 500mS bekle. 500x10-3 = 0.5sn



delay(500);

// 500mS bekle. 500x10-3 = 0.5sn



delay(500);

// 500mS bekle. 500x10-3 = 0.5sn



delay(500);

// 500mS bekle. 500x10-3 = 0.5sn



delay(500);

// 500mS bekle. 500x10-3 = 0.5sn



delay(500);

// 500mS bekle. 500x10-3 = 0.5sn

}


Sayfa 24

3. BÖLÜM DİGİTAL PİNLERİ GİRİŞ OLARAK KULLANMAK


Sayfa 25

DİGİTAL PİNLERİ GİRİŞ OLARAK KULLANMAK ARDUİNO LED-BUTON UYGULAMASI

Led için 220 OHM buton için 10K OHM direnç kullanılmıştır.

NOT;

Butona basılıp basılmama bilgisini Arduino’ya okutacağız ardındanda bu bilgi dahilinde ledin yanıp yanmayacağına karar vereceğiz.

int led =4;

// digital 4. Pine led ismini verdik.

int buton =5;

// digital 5. Pine buton ismini verdik.

int butondurumu;

// butondurumu adında değişken tanımladık.

void setup(){ pinMode(led, OUTPUT);

// led(4) pini çıkış olarak atadık.

pinMode(buton, INPUT);

// buton(5) pini giriş olarak atadık.

}


Sayfa 26

void loop(){ butondurumu=digitalRead(buton);

// Butonun basılıp basılmadığını butondurumu’na ata.

if(butondurumu == HIGH)

// Eğer buton durumu HIGH ise aşağıdaki kodu işle.

digitalWrite(led, HIGH);

// Led(4) pini yak.

else

// değilse yukarı. if sağlanmıyorsa aşağıdaki kodu işle.

digitalWrite(led, LOW);

// Butona basılmıyorsa ledi söndür.

}

digitalRead(bilgi alınacak olan pin); İf(değişken ismi == HIGH- LOW)

okumak, bilgi almak.

Eğer komutu. Void loop bölümünde

işlem görür.

else önceki komut haricindeki herşey. NOT; digitalRead komutunda okunan bilgi bir yere kayıt edilmesi gerekiyor. O yeri şu şekilde tanımlıyoruz;

Değişken = digitalRead(bilgi alınacak olan pin);


Sayfa 27

4. BÖLÜM İF – ELSE KOMUTUNU KULLANMAK


Sayfa 28

İF – ELSE KOMUTUNU KULLANMAK xx = digitalRead(x); x değikenini xx değişkenine kaydet. İf(x == HIGH – LOW)

= digitalRead bölümünde x’se basıldımı basılmadımı? Eğer if koşulu sağlanmışsa bir altındaki komutu çalıştırır.

else if = buradaki if bir önceki if ile bağlantılı durum. { } = else if komutu bir sonraki komutu okuyacağı için iki komutu okumaz fakat “else if {xxxxx}” bu şekildeki süslü parantez içine yazılan birçok komut okunur.

ARDUİNO BUTON - KARAŞİMŞEK UYGULAMASI

Yukarıdaki uygulamada 6.pin ve 1 adet buton kullanılmamıştır. Led için 220 OHM butonlar için 10K direnç kullanılmıştır.


Sayfa 29

int but1 = 2;

// 2. Pine but1 dedik.

int but2 = 3;


int but3 = 4;


int but4 = 5


int led1 = 8;

// 8. Pine led1 dedik.

int led2 = 9;


int led3 = 10;


int b1d;

// buton1durumu değişken ismi atadık.

int b2d;


int b3d;


int b4d;


void setup(){ pinMode(but1, INPUT);

// 2.(but1) pini giriş olarak atadık.

pinMode(but2, INPUT);






pinMode(led1 , OUTPUT);

// 8.(led1) pini çıkış olarak atadık.

pinMode(led2 , OUTPUT);


pinMode(LED3 , OUTPUT);


} void loop(){ b1d = digitalRead(but1);

// digitalRead komutuyla but1 durumunu b1d’ye atadık.

b2d = digitalRead(but2);







Sayfa 30

if(b1d == HIGH)

// Eğer 1. Butona basılırsa bir alttaki kodu işleme al.

digitalWrite(led1, HIGH);

// eğer 1. Butona basılırsa ledi yak.

else if (b2d == HIGH){

// sadece 2. Butona basıldıysa {---} arasındaki kodu işleme al.


// butona basıldıysa 1. Ledi yak.



} else if(b3d == HIGH){

// sadece 3. Butona basıldığında {---} arasındaki kodu işle.







} else if (b4d == HIGH){

// sadece 3. Butona basıldığında {---} arasındaki kodu işle.



delay(250);

// 250 ms bekle.

digitalWrite(led1, LOW);

// butona basıldıysa 1. Ledi sündür.



delay(250);

// 250 ms bekle.


// butona basıldıysa 2. Ledi söndür.



} else {

// eğer hiçbiri değilse {----} arasındaki kodu işleme al.


// 1. Ledi söndür


// 1. Ledi söndür


// 1. Ledi söndür

} }


Sayfa 31

PULL-UP ve PULL-DOWN Pull-Up ve Pull-Down dirençler genel olarak lojik sistemlerde kullanılırlar. Devrede bağlı oldukları mikrodenetleyicilerde yada entegrelerde lojik değerler arasında geçişi manuel bir switch butonla sağlamaktadır. Örneğin mikrodenetleyicimiz (veya Arduino’muz), başlangıçta lojik-0 olarak atanan bir pini, lojik-0’dan lojik-1’e getirilmek istendiğinde Pull-Down direnç kullanılır. Bu dirençler mikrodenetleyicinin giriş yani input atanan pini 10k’lık direnç üzerinden toprağa bağlanarak lojik-0(low) değerini alır. Buton ile toprak arasındaki direnci kullanmamızın nedeni mikrodenetleyici pininin kararsız durumda kalmamasını sağlamaktır. Aradaki direncin olmadığını düşünürsek, butona basıldığında +Vcc ile toprak arasında kısa devre oluşacak ve buradan mikrodenetleyicinin pinine kararsız bir veri (örneğin 0-5V arası sürekli değişen bir gerilim değeri) gönderilecektir. Pull-Up dirençlerde aynı mantıkla çalışmaktadır. Tek fark giriş(ınput) olarak atanan mikrodenetleyici pininin lojik-1’den(HIGH) lojik-0’a(LOW) geçmesi sağlanır. Mikrodenetleyiciye butona basılmaksızın lojik-1 gönderir. Butona basıldığında ise +Vcc ve toprak arasında akım oluşur. Mikrodenetleyicinin pini direk olarak toprağa bağlandığı için pine kararlı bir lojik-0 verisi gönderir.

X = digitalRead(XXX); BU KOMUT = BURAYI OKUYARAK HIGH VEYA LOW DURUMUNU X’E ATA. ATANACAK


Sayfa 32

5. BÖLÜM SERİAL MONİTÖR VE DEBUGGİNG


Sayfa 33

SERİAL MONİTÖR VE DEBUGGİNG

void setup() { Serial.begin(9600);

//9600 Seri haberleşmenin hızını belirliyor.

} void loop() { Serial.println("merhaba dunya");

//ekrana parantez içindeki ifadeyi yaz.

Serial.println("Sencer Altun");

//ekrana parantez içindeki ifadeyi yaz.

delay(1000);

//bu işlemi 1000 milisaniye(1 saniye) de yap.

}

Serial.begin(9600);

Programlamada Serial Monitörü kullanacağımızı belirler.

9600 ise hızı olarak karşılanır.

Serial.print(“x”);

Bu komutu parantez içindeki istediğimiz ifadeyi monitörde seri şekilde, yanyana göstermek için kullanırız.

Serial.println(“x”);

Bu komutu parantez içindeki istediğimiz ifadeyi monitörde alt alta göstermek için kullanırız.

Ledler için 220 OHM, Butonlar için 10K direnç kullanıldı.


Sayfa 34

int but1 = 2;

//2. Pini but1 diye atadık.

int but2 = 3;


int but3 = 4;


int led1 = 5;

//5. Pini led1 diye atadık.

int led2 = 6;


int led3 = 7;


int b1d;

//buton1durumu değişkeni atadık.

int b2d;


int b3d;


void setup() { pinMode(but1, INPUT);

//but1’i giriş olarak ayarladık.





pinMode(led1, OUTPUT);

//led1’i çıkış olarak ayarladık.





Serial.begin(9600);

//Serial monitörü kullanacağız.

} void loop() { b1d = digitalRead(but1);

//but1’in HIGH veya LOW durumunu b2d’na ata.






Sayfa 35

if(b1d == HIGH){

//eğer b1d HIGH ise led1’i yak.


//led1’i yak.

Serial.println("birinci butona basildi");

//butona basıldıyla S. monitörde göster.

delay(600);

//bu işlemi 600ms’de yap.

else if (b2d == HIGH){

//eğer b2d HIGH ise led1 ve led2’yi yak.

}


//led1’i yak.


//led2’i yak.

Serial.println("ikinci butona basildi");


delay(600);


} else if(b3d == HIGH){

//eğer b3d HIGH ise tümünü yak.


//led1’i yak.


//led2’i yak.


//led3’i yak.

Serial.println("ucuncu butona basildi");


delay(600);


} else {

//eğer hiçbiri değilse { } arasını işleme al.


//led1’i söndür.





Serial.println("hicbir butona basilmiyor.."); //butona basılmadıyla S. monitörde göster. } }

İnt x = x ; İnteger anlamına geliyor. Tamsayı. İlerleyen konularda değinilecektir. ADIM ADIM ARDUİNO – SENCER ALTUN

Sayfa 36

6. BÖLÜM DEĞİŞKEN TANIMLAMA VE VERİ TİPLERİ(1)


Sayfa 37

DEĞİŞKEN TANIMLAMA VE VERİ TİPLERİ(1)

int a = 1453;

// a değişkeninin değeri 1453


// serial monitör kullanılacak

} void loop() { Serial.println(a);

// a değişkeninin değerini ekrana yaz

}

VERİ TİPİ

BOYUT(BAYT) KULLANILDIĞI ARALIK

int Unsigned int long

2 bayt 2 bayt 4 bayt

Unsigned long

4 bayt

-32768 <->+32767 0 <-> 65535 -2147485648 <-> +2147485647 0<-> 4294967295

char byte

1 bayt 1 bayt

Tek bir karakter 0-255

float

4 bayt

double

4 bayt

boalean

1 bayt

-3.4028235E+38 <> +3.4028235E+37 -3.4028235E+38 <> +3.4028235E+38 TRUE(1) , FALSE(0)

İÇERİK TAM SAYILAR POZİTİF SAYILAR ÇOK BÜYÜK TAM SAYILAR ÇOK BÜYÜK POZİTİF TAM SAYILAR TEK BİR KARAKTER O İLE 255 ARASI TAMSAYI ONDALIK SAYILAR FLOAT İLE AYNI MANTIK 1 VEYA 0

İnt = integer = Tamsayı Serial.println(x); Ekrana x değişkeninin değerini yaz. Serial.println(“x”); Ekrana x ifadesini yaz. NOT; Değişken ataması yaparken Türkçe karakter kullanılmaz.


Sayfa 38

7. BÖLÜM DEĞİŞKEN TANIMLAMA VE VERİ TİPLERİ(2)


Sayfa 39

DEĞİŞKEN TANIMLAMA VE VERİ TİPLERİ(2)

float pi_sayisi = 3.14;

// ondalıklı sayıyı pi_sayisi değişkenine atadık



} void loop() { Serial.println(pi_sayisi);

// pi_sayisi değişkeninin değeri ekranda yazılacak(3.14)

}

Yukarıdaki örnek programın amacı “float” veri tipindeki değişkenin değerini ondalıklı yani noktadan sonrasıyla beraber ekrana yazdırmak.

float; 4 Bayt – 3.4028235E+38 <-> +3.4028235E+38 – Ondalıklı sayılar double; 4 Bayt – 3.4028235E+38 <-> +3.4028235E+38 – Ondalıklı sayılar

char karakter = 'k';

// Char veri tipinde ‘k’ değerini karakter değişkene atadık


// Serial monitör kullanılacak

} void loop() { Serial.println(karakter);

// karakter değişkeninin değerini monitörde göster

}

char;

1 bayt – Tek bir karakter. Yukarıdaki program örneğinde char ile bir karakter değişkeni atadığımızda tek tırnak ile atama yapmalıyız. ( ‘k’ gibi.)


Sayfa 40

8. BÖLÜM CONST VE DEFİNE İFADELERİNİN KULLANIMI


Sayfa 41

CONST VE DEFİNE İFADELERİNİN KULLANIMI

int sayac = 0;

// int veri tipinde sayı atadık ve onu sayac değişkenine atadık



} void loop() { sayac = sayac+1;

// sayac değişkenini her seferinde 1 artır

Serial.print("sayac=");

// ekrana sayac’ı yazdır

Serial.println(sayac);

// ekrana sayac değişkeninin değerini yazdır

Serial.println("---------");

// ekrana yazdır

delay(1000);

// her defasında bu işlem 1000 ms sürsün(1saniye)

}

Yukarıdaki örnek programda sayac değişkeni 0’dan başlayarak 1 arta arta int veri tipinin değeri olan ‘32767’ sayısına kadar gidecek.

NOT; Algoritma yukarıdaki programda, “int sayac =0;” komutunun bir pin numarasımı yoksa tamsayı numarasımı olduğunu biliyor. Pin numarası olduğunu, Void loop bölümünde yazan digitalWrite veya digitalRead kodlarının(buton veya led gibi) parantez içini okuyarak birbirinden ayırıyor.

ÖRNEK; int buton = 3; İnt sayac = 32000; XXX = XXX +1 İŞLEM İŞLEM YAPILACAK DEĞIŞKEN


DEĞİŞKENİN İLK DEĞERİ

Sayfa 42

const int buton =3; int sayac = 32000;

// const ile int tipinide 3 pinini buton değişkenine atadık // int veri tipinde sayac adlı değişken atadık ve değeri 32000



} void loop() { digitalRead(buton);

// buton değerini oku

buton = 7;

// 7. Pini buton olarak atadık

Serial.print("sayac=");

// ekrana sayac kelimesini yazdır


// ekrana sayac değişkeninin değerini yazdır

Serial.println("---------");

// ekrana yazdır

sayac=1;

// sayac değişkenine 1 atadık

}

const;

const ifadesi programın ilerleyen kısımlarında algoritmanın çalışmasını son derece önemli olan değişkenlerin yanlış bir şekilde değişmesini engellemek için o değişkeni korumaya alır.

Yukarıdaki programı çalıştırdığımızda bir hata ile karşılaşacağız. Bize hata ekranında “buton değişkeni yukarıda tanımlanmış siz tekrar loop bölümünde buton değişkeninin pinini veya değerini belirleyemezsiniz” hatası vericek. İşte bu hatayı vermesi const ifadesi ile alakalı. Const ifadesi bu gibi durumlarda yani var olan değişkeni yanlışlıkla programın ilerleyen kısımlarında tanımlanmasını engelliyor. Örnek programımızda “const int buton =3;” yerine “int buton=3” ile değiştirirsek hata ile karşılaşmayacağız ancak mantık hatası ile karşılaşacağız ve programımız düzgün çalışmayacak.


Sayfa 43

char krt1 = 'A';

// tek tip bir karakter atandı

char krt2 = 'R';


char krt3 = 'D';


char krt4 = 'U';


char krt5 = 'I';


char krt6 = 'N';


char krt7 = 'O';


#define bek_sure 1000

// define ile değişken atadık ve suresini verdik



} void loop() { Serial.println(krt1);

// krt1 değerini ekrana yaz

delay(bek_sure);

// yukarıda belirtilen sure kadar bekle

Serial.println(krt2);


delay(bek_sure);




delay(bek_sure);




delay(bek_sure);




delay(bek_sure);




delay(bek_sure);




delay(bek_sure);


}


Sayfa 44

SORU; Bekleme süresini neden int veya float gibi tanımlamıyoruzda define ile tanımlıyoruz?

CEVAP;

Define değişken tanımlama ismi değil.

#define;

Bekleme süresi adında bir değişken oluşturduk ve Arduino’nun hafızasında yer hacamış olmadık, hafızasından tasarruf ettik.

NOT; Eğer biz bu değişkeni int, float gibi tanımlamış olsaydık( yukarıdaki programdan bahsediliyor), Arduino hafızasında 1 bayt, 2 bayt gibi yer kaplayacaktı. define ifadesi Arduino’nun hafızasına yazılan bir işlem değildir. #define ismiyle atanmış tüm komutlar yanındaki değişkenle değiştirilir. Bu yüzden atama anlamına gelen ( = ) işareti, normal kod olduğunu belirten ( ; ) ifadesini kullanmıyoruz.

#define XXXX XX DEĞİŞKEN İSMİ


DEĞERİ

Sayfa 45

9. BÖLÜM TEMEL MATEMATİK İŞLEMLERİ


Sayfa 46

TEMEL MATEMATİK İŞLEMLERİ ARDUİNO İLE DÖRT İŞLEM

float x=5;

// float tipinde sayı atadık ve ona x dedik

int y=3;

// int tipinde sayı atadık ve ona y dedik

float sonuc;

// float tipinde değişken atadık. Bölme işleminde float kullanılır



} void loop() { sonuc =x/y; Serial.println(sonuc);

// x değişken değerini y’ye böl // sonuc değişkeninin değerini ekrana yaz

}

NOT; Toplama – Çıkarma – Çarpma işlemlerinde int veri tipini kullanabiliriz. Fakat Bölme yaparken “sonuc” değişlenini float ile atamamız yetmiyor, ayrıca bölünecek iki sayıdan birininde float ile atanması gerekiyor. Yukarıdaki örnek programımızda olduğu gibi.

ÖNEMLİ NOT;

“=” eşittir ifadesi matematiksel ifade değildir. “=” eşittir kullanıyorsak orada atama yapıyoruz demektir. “==” çift eşittir ise bizim bildiğiniz “=” eşittir. Yani birşeyin birşeye eşit olduğunu söyleyen eşittir.

ÖNEMLİ NOT; sayici =sayici+1 -> Bunun (+) yerine bunlarda olabilir. sayici = sayici / 1 sayici = sayici - 1 sayici = sayici * 1 ADIM ADIM ARDUİNO – SENCER ALTUN

Sayfa 47

KALAN BULMA   

Void loop bölümünde gerçekleşir. %(yüzde) işareti ile olur. Herhangi veri tipi ile tanımlanmış sayıların bölümünden kalanı verir.

KALAN BULAN PROGRAM

int x=6;

// 6 değerini x değişkenine atadık

int y=5;

// 5 değerini y değişkenine atadık

float sonuc;

// float veri tipinde sonuc değişleni atadık



} void loop() { sonuc = x%y;

// x ve y değerlerinde kalanı veren kod

Serial.println(sonuc);

// sonuc değişleninin değerini ekrana göster

Serial.println("----------");

// ekrana yaz

delay(1000);

// bu işlemi 1000 ms(1 saniye)’de yap

}


Sayfa 48

KAREKÖK BULMA

int x=6;

// 6 değerini x değişkenine atadık

int y=5;

// 5 değerini y değişkenine atadık

float sonuc;

// float veri tipinde sonuc değişleni atadık



} void loop() { sonuc = sqrt(y);

// sqrt karekök onun önündeki ifadenin karekökün alır


// sonuc değişleninin değerini ekranda göster


// ekrana yaz

delay(1000);

// bu işlemi 1000 ms(1 saniye)’de yap

}

NOT; Karekök bulmak için sayının tam veya ondalıklı olduğuna dikkat etmemiz gerekli. Ondalık ise “sonuc” değişkenini float ile atama yaparsak gerçeklerşir. Karekök bulmak için;

sqrt(karekökü alınacak değişken veya sayı); MUTLAK DEĞER abs(mutlak değeri alınacak değişken veya sayı); ADIM ADIM ARDUİNO – SENCER ALTUN

Sayfa 49

10. BÖLÜM DEĞİŞKEN ÖMÜRLERİ, KARŞILAŞTIRMA VE MANTIK İFADELERİ


Sayfa 50

DEĞİŞKEN ÖMÜRLERİ , KARŞILAŞTIRMA VE MANTIK İFADELERİ DEĞİŞKEN TANIMLAMA

int x=5;

// 5 sayısını x değişkenine ata

int y=6;

// 6 sayısını y değişkenine ata

void setup() { int z=8;

// sadece void setup bölümünde geçerli int v.tipinde sayı tanımlandı

Serial.begin(9600);


} void loop() { int k=4;

// 4 sayısını k değişkenine ata

Serial.println("x=");

// Serial ekrana paraztez içindeki ifadeyi yaz

Serial.println(x);

// Serial ekrana x değişkeninin değerini yaz



Serial.println("z=");


Serial.println(z);




Serial.println("k=");


Serial.println(k);




delay(500);

// 500ms bekle

}


Sayfa 51

NOT; Yukarıdak programda en başta tanımlanan veri tipindeki değişkenler her yerde kullanılabilir(GLOBAL). Void Setup ve Void Loop bölümündeki tanımlanan değişkenler sadece kendilerini temsil eder ve sadece kendi bölgelerinde çalışırlar(LOKAL).

void setup() { int led = 13;

// int veri tipinde sadece bu bölümde geçerli

pinMode(led, OUTPUT);

// led değişkenini çıkış olarak atadık

} void loop() { digitalWrite(13, HIGH);

// 13. Pine (5v) HIGH dedik

delay(1000);

// 1000ms(1saniye) bekle


// 13. Pine (0v) LOW dedik

delay(1000);


}


Sayfa 52

KARŞILAŞTIRMA EŞİTTİR “==” EŞİT DEĞİLDİR “!=” KÜÇÜKTÜR “<” BÜYÜKTÜR “>” KÜÇÜK EŞİTTİR “<=” BÜYÜK EŞİTTİR “>=”

Yukarıdaki ifadeleri kullanabilmemiz için öncelikle ilk başa boolean veri tipinde bir değişken atamamız gerekir. Atanan bu değişkene bizim karşılaştırma ifadeleri atanarak sonucu ekranda gösterir.

int x =9;

// 9 değerini x değişkenine kaydet

int y =15;

// 15 değerini y değişkenine kaydet

boolean kayit;

// boolean veri tipinde değişken atadık



} void loop() { if(x>y)

// eper x, y’den büyükse aşağıdaki kodu işle

kayit=1;

// kayit değişkeni 1 olsun

else

// değilse aşağıdaki kodu işle

kayit=0;

// kayit değişkeni 0 olsun

Serial.println(kayit);

// kayit değişkeninin değerini ekranda göster

}

NOT;

Yukarıdaki programda Void loop bölümünde “if(x>y)” ifadesine istediğimiz karşılaştırma ifadelerini yazabiliriz. Yazdığımız karşılaştırma ifadeleri yukarıda gösterilmiştir.


Sayfa 53

MANTIK İFADELERİ VE (AND) 1.İFADE 0 0 1 1

2.İFADE 0 1 0 1

SONUÇ 0 0 0 1

VEYA (OR) 1.İFADE 0 1 1 0

2.İFADE 1 0 1 0

SONUÇ 1 1 1 0

DEĞİL(NOT) 1.İFADE 1 0

2.İFADE 0 1

Ve “&&” Veya “||” int a=10;

// int veri tipinde 10 değerine a değişkenini atadık

int b=10;

// int veri tipinde 10 değerine b değişkenini atadık

int c=20;

// int veri tipinde 20 değerine c değişkenini atadık

int d=30;

// int veri tipinde 30 değerine d değişkenini atadık

int sonuc;

// int veri tipinde sonuc değişkeni atadık



}


Sayfa 54

void loop() { if((a==b)&&(c==d))

// eğer a, b’ye ve c, d’ye eşitse çalıştır

sonuc=1;

// yukarıdaki durum sağlanıyorsa bu kodu işle

else if ((a!=b)&&(d
// değilse eğer, a, b’ye eşit değilse ve d, c’den küçükse

sonuc=2;


else if ((a==b)&&(d
// değilse eğer, a, b’ye eşitse ve d, c’den küçükse

sonuc=3;


else if ((a==b)||(d==c))

// değilse eğer, a, b’ye eşitse veya d, c’ye eşitse

sonuc=4;

else if ((a==b)||(c<=d))


// d. e. , a, b’ye eşitse veya c, d’den büyükse veya eşitse

sonuc=5;

else if ((ab)) sonuc=6;


// değilse eğer, a, b’den küçükse veya a, b’den büyükse


else

// yukarıdakiler haricinde herşey

sonuc=7;



// sonuc değişkeninin değerini ekranda göster

}


Sayfa 55

UYGULAMA PARK SENSÖRÜ


Sayfa 56

UYGULAMA(PARK SENSÖRÜ)

MALZEMELER LED 4 ADET ( Kırmızı/Sarı/Yeşil/Mavi) Buzzer 220 veya 330 OHM Direnç HC-SR04 Sensör (Ultrasonik) const int trig =13;

// 13.pin trig olarak atandı

const int echo =12;

// 12.pin echo olarak atandı

const int buzzer =2;

// 2.pin buzzer olarak atandı

const int mled =3;

// 3.pin mled olarak atandı

const int yled =4;

// 4. Pin yled olarak atandı

const int sled =5;

// 5. Pin sled olarak atandı

const int kled =6;

// 6.pin kled olarak atandı

int sure;

// int veri tipinde sure değişkeni atandı

int mesafe;


// int veri tipinde mesafe değişkeni atandı

Sayfa 57

void setup() { pinMode(kled, OUTPUT);

// ledler çıkış olarak atandı

pinMode(sled, OUTPUT);


pinMode(yled, OUTPUT);


pinMode(mled, OUTPUT);


pinMode(buzzer, OUTPUT);

// buzzer çıkış olarak atandı

pinMode(echo, INPUT);

// sensörün echo pini çıkış olarak atandı

pinMode(trig, OUTPUT);

// sensörün trig pini çıkış olarak atandı

} void loop() { digitalWrite(trig, HIGH);

// trig pinine HIGH (5V) verdik

delayMicroseconds(1000);

// 1 mikrosaniye bekle

digitalWrite(trig, LOW);

// trig pinine LOW(0V) verdik

sure=pulseIn(echo, HIGH);

// atama gerçekleştirdık.

mesafe =(sure/2) / 28.5;

// sensör için gereken kod

if(mesafe <=10){

// eğer mesafe 10 saniyeye eşit veya küçükse

digitalWrite(kled, HIGH);

// kled’i yak

digitalWrite(buzzer, HIGH);

// buzzer’i çalıştır

delay(250);

// 250 ms bekle

digitalWrite(kled, LOW);

// kled’i söndür

digitalWrite(buzzer, LOW);

// buzzer’i durdur

delay(250); }

// 250ms bekle


Sayfa 58

else if(mesafe <=25){

// değilse eğer mesafe 25m’ye eşit veya küçükse

digitalWrite(sled, HIGH);

// sled’i yak



delay(500);

// 500ms bekle

digitalWrite(sled, LOW);

// sled’i söndür



delay(500); }

// 500ms bekle

else if(mesafe <=50){

// değilse eğer mesafe 50m’ye eşit veya küçükse

digitalWrite(yled, HIGH);

// sled’i yak



delay(750);

// 750ms bekle

digitalWrite(yled, LOW);

// sled’i söndür



delay(750); }

// 750ms bekle

else {

// hiçbiri değilse aşağıdaki kodu çalıştır

digitalWrite(mled, HIGH);

// mled’i yak

delay(1000);


digitalWrite(mled, LOW);

// mled’i söndür

delay(1000); }


}

NOT; “sure=pulseIn(echo, HIGH);” pulseIn komutu ile echo pininin 5V-0V durumunu sure değişkenine atama yaptık.


Sayfa 59

11. BÖLÜM WHİLE DÖNGÜSÜ


Sayfa 60

WHİLE DÖNGÜSÜ While (koşul / şart ifadesi) { Kodlar } ÖRNEK; while(a<50) {

1 2 3

}

NOT;

Loop döngüsü gibi her sona geldiğinde while geri dönecek. Döngü eğer yukarıdaki örnek kod ise hep öyle devam eder.

int a=0;

// a’nın değeri 0 olarak atandı

void setup(){ Serial.begin(9600);


void loop(){ Serial.println(a);

// a’nın değerini ekrana yaz

while(a<50)

// a, 50’den küçükse çalıştır

{ Serial.println("While dongusu calisiyor");

// while koşulu sağlanıyorsa ekrana yaz

} }


Sayfa 61

int a=0;

// a değişkeninin değerini 0 olarak atadık



} void loop(){ while (a<50)

// a, 50’den küçükse while döngüsünü çalıştır

{ a = a+1;

// a değişkenini her defasında 1 arttır

Serial.println(a);

// a değişkeninin değerini ekrana yazdır

Serial.println("While dongusu calisiyor");

// ekrana yazdır

} }

NOT;

Yukarıdaki programda a<50 ise bu döngüyü çalıştır. 50 olduğu anda buradaki şart bozuldu. While döngüsü sağlanana kadar program akışı while ise devam eder. While koşulu sağlanmazsa program loop bölümüne gelerek oradan devam eder.

int a=0;

// a değişkeninin değerini 0 olarak atadık



} void loop(){ Serial.println(a); while (a<=50)

// a değişkeninin değerini ekrana yazdır // a, 50’den küçük veya eşitse döngüyü çalıştır

{ a = a+1;

// a değişkenini her defasında 1 arttır

delay(100);

// 100ms bekle

Serial.println(a);

// a değişkeninin değerini ekrana yazdır

ADIM ADIM ARDUİNO – SENCER ALTUN Serial.println("While dongusu calisiyor");

Sayfa 62

Serial.println("While dongusu calisiyor");

// ekrana yazdır

} Serial.println("donguden ciktik");

// ekrana yazdır

while(1);

// tüm işlemi 1 kere yap

}

NOT; Loop döngüsünün 1 kere dönmesini istediğiniz için “while(1);” kodunu kullandık.

LED 1 ADET BUTON 1 ADET 220 veya 330 OHM ve 10K OHM DİRENÇ


Sayfa 63

const int buton =3; int durum;

// 3. Pine buton değişkeni ismini verdik // durum değişkeni atadık

void setup(){ pinMode(buton, INPUT);

// buton’u giriş olarak atadık

pinMode(5, OUTPUT);

// 5. Pini çıkış olarak atadık

Serial.begin(9600);


} void loop(){ durum=digitalRead(buton);

// butona basılıp basılmama bilgisini durum’a ata

while(durum == HIGH)

// butona basılırsa döngüyü çalıştır

{ digitalWrite(5, HIGH);

// 5. Pine HIGH(5V) dedik

delay(500);

// 500ms bekle


// 5. Pine LOW(0V) dedik

delay(500);

// 500ms bekle

} Serial.println("butona basilmiyor");

// butona basılmazsa ekrana yaz

}

NOT;

Yukarıdaki programda bir hata var. Hatanın nedeni while döngüsünde yapılan mantık hatası. Biz butona basıldığında while döngüsü çalışacak dedik. Bastık çalışıyor led ama bırakınca sönmesi lazım ve while komutunun altındaki “Serial.println("butona basilmiyor");” komutu ekranda görünmesi lazım. Bunun için while komutunun içine while döngüsünün en altına “durum=digitalRead(buton);” yazmamız gerekiyor ve butona basıldımı basılmadımı durumunu bu şekilde görebiliriz.


Sayfa 64

const int buton =3; int durum;

// 3. Pine buton değişkeni ismini verdik // durum değişkeni atadık

void setup(){ pinMode(buton, INPUT);

// buton’u giriş olarak atadık

pinMode(5, OUTPUT);

// 5. Pini çıkış olarak atadık

Serial.begin(9600);


} void loop(){ durum=digitalRead(buton);

// butona basılıp basılmama bilgisini durum’a ata

while(durum == HIGH)

// butona basılırsa döngüyü çalıştır

{ digitalWrite(5, HIGH);

// 5. Pine HIGH(5V) dedik

delay(500);

// 500ms bekle


// 5. Pine LOW(0V) dedik

delay(500);

// 500ms bekle

durum = digitalRead(buton);

// buton’u kontrol et basılmaya devam ediyormu?

} Serial.println("butona basilmiyor");

// butona basılmazsa ekrana yaz

}

NOT;

Her while döngüsünde butona basılıp basılmadığını kontrol etmemiz gerektiği için while bloğunun içine “durum=digitalRead(buton);” kodunu yazıyoruz. Böylelikle kodumuz doğru çalışıyor.

NOT; While döngüsünün çalışması için while koşulunun sağlanması gerekiyor.


Sayfa 65

12. BÖLÜM DO WHİLE DÖNGÜSÜ


Sayfa 66

DO WHİLE DÖNGÜSÜ Do while döngüsü mutlaka bir kere çalışır.

do { Kodlar } while(koşul)

int a=0;

// 0 değerini a değişkenine atadık



} void loop(){ Serial.println(a); do{

// a değişkeninin değerini ekrana yaz // do döngüsüne her seferinde 1 kez girer

a=a+1;

// a değişkenini 1 attır

Serial.println(a);

// a değişkeninin değerini ekranayaz

Serial.println("dongu calisiyor");

// ekrana yaz

delay(250);

// 250ms bekle

} while(a<50);

// a, 50’den küçükmü kontrol et

Serial.println("dongoden cikildi.");

// while koşulu sağlanmazsa bunu yap

delay(250);

// 250ms bekle

}


Sayfa 67

NOT; Yukarıdaki program her defasında do döngüsünü ekrana yazdırır. Fakat “a<50” koşulu sağlanmazsa do döngüsü burada biter. “do” döngüsünün koşulu bittiği zaman program her defasında başa döndüğünde yine 1 kere “do” döngüsüne girer. Yani while kodunu kontrol etmeden önce do döngüsünün içini mutlaka çalıştırır. Böyle olmasının nedeni; void loop döngümüz her seferine en sona geldikten sonra tekrar yukarıdan başladığı için her çalışmaya başladığında “do while” döngüsünü bir kez çalıştırır. “do while” döngüsü işlem sırası ona gelir gelmez hemen çalışır. Yani “do” yu gördüğünde hemen çalışır. “While” koşulunu sonradan kontrol eder. Hatırlarsanız While döngüsü koşulu kontrol ediyordu koşul sağlanıyorsa içindeki kodu işliyordu. Fakat “do – while” döngüsü direk içersindeki kodları çalıştırır, koşul sağlanıyorsa çalıştırmaya devam eder. Yani “do – while” döngüsü en kötü şartlarda koşul sağlanmasa bile mutlaka en az bir kere çalışır. Loop döngüsü her döndüğünde “do – while “ döngüsü bir kere çalıştırıldı. While’den farklı içerdeki kodu en az bir kere döndürür. Sonra şartı kontrol eder, eğer şart sağlanıyorsa “do” dan itibaren çalıştırmaya başlar.

int a=0;

// 0 değerini a değişkenine atadık



} void loop(){ Serial.println("loop basliyor");

// ekrana yaz

Serial.println(a);


do {

// do döngüsüne her seferinde 1 kez

a=a+1;

// a değişkenini 1 attır

if( a ==49)

// eğer a, 49’a eşitse “if”i çalıştır

a=1;

// a’yi 1 ata

Serial.println(a);


Serial.println("dongu calisiyor");

// ekrana yaz

delay(100);

// 100ms bekle

}

while(a<50); ADIM ADIM ARDUİNO – SENCER ALTUN Serial.println("donguden cikildi"); Serial.println("loop dongusu bitti");

Sayfa 68

while(a<50);

// a, 50’den küçükse while döngüsünü çalıştır

Serial.println("donguden cikildi");

// ekrana yaz

Serial.println("loop dongusu bitti");

// ekrana yaz

delay(250);

// 250ms bekle

}

NOT;

Yukarıdaki programı “if” ile sonsuz döngüye sokmuş olduk. Şöyleki a’yı 1 artırarak 49 sayısına gelmeden 1’e geri döndürecek böylelikle “do” döngüsünden çıkılmayacak.


Sayfa 69

13. BÖLÜM SWİTCH CASE YAPISI


Sayfa 70

SWİTCH CASE YAPISI

3 adet 10K Direnç 1 adet switch 2 adet buton

const int arttir =3;

// 3. Pine arttir değişken ismi tanımladık

const int azalt =4;

// 4. Pine azalt değişken ismi tanımladık

const int dongu =2;

// 2. Pine dongu(switch) değişken ismi tanımladık

int durum_arttir;

// değişken tanımladık

int durum_azalt;


int durum_dongu;


int sayac=0;


void setup() { pinMode(arttir, INPUT);

// butonları giriş olarak atadık

pinMode(azalt, INPUT);

// butonları giriş olarak atadık

pinMode(dongu, INPUT);

// switch’i giriş olarak atadık

Serial.begin(9600);


}


Sayfa 71

void loop() { durum_dongu=digitalRead(dongu);

// dongu değişkenini atama yaptı

while(durum_dongu == HIGH)

// dongu (swicth) 5v’da ise çalıştır

{ durum_arttir=digitalRead(arttir); durum_azalt=digitalRead(azalt); if(durum_arttir == HIGH){ sayac++; Serial.println("sayac=");

// arttir değişkenini atama yaptı // azalt değişkenini atama yaptı // eğer arttırma butonuna basılırsa if’i işle // sayac değişkenini 1 arttır // ekrana yaz


// sayac değişkeninin değerini ekrana yaz

delay(200);

// 200ms bekle

} else if(durum_azalt == HIGH){ sayac--;

// değilse eğer azalt butonuna basıldıysa // sayac değişkenini 1 azalt

Serial.println("sayac=");

// ekrana yaz



delay(200);

// 200ms bekle

} durum_dongu=digitalRead(dongu);

// switch açakmı kapalımı kontrol et

} }

NOT; Yukarıdaki programda 1 tane switch 2 adet buton kullanıldı. Switch’in açık olma durumunu hangi butona basıldı veya basılmadı bilgisini ekranda görebiliriz.


Sayfa 72

ÖRNEK PROGRAM (SWİTCH CASE YAPISI)

void loop() { durum_dongu=digitalRead(dongu);

// dongu değişkenini atama yaptı

while(durum_dongu == HIGH)

// dongu (swicth) 5v’da ise çalıştır

{ durum_arttir=digitalRead(arttir); durum_azalt=digitalRead(azalt); if(durum_arttir == HIGH){ sayac++; Serial.println("sayac=");

// arttir değişkenini atama yaptı // azalt değişkenini atama yaptı // eğer arttırma butonuna basılırsa if’i işle // sayac değişkenini 1 arttır // ekrana yaz



delay(200);

// 200ms bekle

} else if(durum_azalt == HIGH){ sayac--;

// değilse eğer azalt butonuna basıldıysa // sayac değişkenini 1 azalt


// ekrana yaz



delay(200);

// 200ms bekle

} durum_dongu=digitalRead(dongu);

// switch açakmı kapalımı kontrol et

}


Sayfa 73

switch(sayac)

// switch sayac değişkenini işler

{ case 1:

// 1.değer okunmak istenirse

Serial.println("1. motor calisiyor");

// ekrana yazdır

break;

// başa dön

case 2:



// ekrana yazdır

break;

// başa dön

case 3:



// ekrana yazdır

break;

// başa dön

case 4:



// ekrana yazdır

break;

// başa dön

default:

// yukarıdakiler dışında herşey

Serial.println("yanlis deger girildi");

// ekrana yazdır

break;

// başa dön

} }


Sayfa 74

Switch – case; switch – case kullanmak için switch yazıyoruz ardından switch – case yapısını hangi değişkene göre çalışmasını istiyorsak o değişkeni parantez içinde yazıyoruz. Daha sonra bu değişkeni hangi değer karşısında ne iş yapmasını istiyorsak bunları yazıyoruz;

Switch(değişken) { case x: Serial.println(“xxxx”); break; default: Serial.println(“xxxx”); break; } NOT;

Yukarıdaki program örneğimizde sayac değişkeninin değeri 1 olursa ekrana “1.motor calisiyor” yazmasını istedik. Aynı şekilde 1 ve 4 arasında bu örnekleri yaptık.

default;

Eğer bunlar dışında bir değer girilirse yani eksili sayılar veya bu programla ilgili 4 değilde 5 sayısı girilirse yanlış değer ifadesini ekrana yazdırmasını istedik.

Dikkat edilmesi gereken bir nokta var. Biz case dedikten sonra bizim değişkenimizin değeri tam sayıysa sayıyı yazdıktan sonra iki noktayla bitirilir.

ÖRNEK; case 1:


Sayfa 75

iki nokta’dan sonra yapılmasını istediğimiz kodları yazıyoruz. Yani case – break komutu arasına istediğimiz kodları yazabilir, işlemleri yapabiliriz. Örnek programımızda sayac’ın değeri 1 ise “case :1” kodu çalışacaktır. Break komutunu gördüğünde tüm kodları atlayacak tekrar başa dönecek. Eğer “case = 1:” komutu hala sayac 1 ise çalışacak, değilse başka komuta geçecek. Ancak!! Break komutunu yazmaksak program bir alt satırı işlemeye başlayacaktır. Örnek programda olduğu gibi;

{ case = 1: Serial.println(“motor calisiyor”); case =2; Serial.println(“motor durdu”); break; } Yukarıdaki örnek programda bizim algoritmamız 2 kod satırını işleyecek. Birincisi break olmayan komutu, diğeride break olan komutu. Ekrana 2 aynı değeri girecektir.

Default; Bunlar dışında her şey. NOT;

Switch-case yapısını sadece sayılar için değil aynı zamanda karakter – harf içinde kullanabiliriz.

Char sayac=0; Switch(sayac) { case ‘a’: Serial.println(“xxx”); break; } Yukarıdaki örnek switch – case yapsında karakter kullanmanın örneği gösterildi.


Sayfa 76

14. BÖLÜM FOR DÖNGÜSÜ


Sayfa 77

FOR DÖNGÜSÜ for(başlama ; sınır/şart ; güncelleme) { Kodlar } for yazıyoruz parantez açıyoruz, for döngüsünün içine 3 tane bilgi giriyoruz. Sırasıyla birincisi, başlangıç değeri(başlangıç şartı), ikincisi devam etme şartı(for döngüsünün ne kadar süre çalışması), üçüncüsü ise güncelleme şartı.

int a;

// a değişkeni atandı



} void loop() { for(int b=0; b<10 ; b++)

// 0’dan başlayacak 10’a kadar, 1 arttıracak

Serial.println("b=");

// ekrana yazdır

Serial.println(b);

// b değişkeninin değerini ekrana yazdır

delay(250);

// 250ms bekle

{

} }

Yukarıdaki programda for döngüsüne bakarsak, döngümüz başladığında b değişkenimiz 0 oluyor. Daha sonra bu b değişkeni 10’dan küçük olana kadar çalışıyor. b değişkeni birer birer arttılıyor. Bizim for döngümüz her döndüğünde güncel b değerini ekrana yazdıracak.

NOT; İstediğimiz mantık operatörlerini kullanabiliriz.


Sayfa 78

FOR DÖNGÜSÜ İLE KARAŞİMŞEK UYGULAMASI

6 adet led 220 veya 330 OHM direnç 6 adet


// led pinleri çıkış olarak atandı

pinMode(3, OUTPUT);


pinMode(4, OUTPUT);


pinMode(5, OUTPUT);


pinMode(6, OUTPUT);


pinMode(7, OUTPUT);


}


Sayfa 79

void loop() { for(int b=2; b<8 ; b++){ digitalWrite(b, HIGH);

// 2’den, 8’e kadar birer birer arttır // b’ye 5V ver (ledi yak)

delay(250);

// 250ms bekle

digitalWrite(b, LOW);

// b’ye 0V ver (ledi söndür)

delay(250);

// 250ms bekle

}

NOT; Yukarıdaki programda for döngüsünde b’yi 2’den başlattık, 8’e kadar dedik, b’yi birer birer artırdık. “int b=2;” burada kod her döndüğünde “b” değerini 2 yazıcak. Örneğin “2’yi HIGH yapacak 250 ms sonra LOW yapıcak” gibi. Ardından yukarı çıkacak 2’yi bir artıracak, 3 içinde { } süslü parantez içindeki işlemleri yapacak. Bu böyle devam edecek. 7, 8’den küçük mü diye sonra işlemi gerçekleştirecek. Daha sonra tekrar 7’yi bir arttıracağı zaman bakacak şart sağlanıyormu, “hayır sağlanmıyor”. İşte bu yüzden for döngüsünden çıkacak.

8’de bitmesinin nedeni 7, 8’den küçük olduğu için, “7’de bitsin. 8. Pini çalıştırmasın” dedik.



pinMode(3, OUTPUT);


pinMode(4, OUTPUT);


pinMode(5, OUTPUT);


pinMode(6, OUTPUT);


pinMode(7, OUTPUT);


}


Sayfa 80

void loop() { for(int b=2; b<8 ; b++){

// 2’den, 8’e kadar birer birer arttır

digitalWrite(b, HIGH);

// b’ye 5V ver (ledi yak)

delay(250);

// 250ms bekle

} for(int b=2; b<8 ; b++){

// 2’den, 8’e kadar birer birer arttır

digitalWrite(b, LOW);

// b’ye 0V ver (ledi söndür)

delay(250);

// 250ms bekle

} }

NOT; Yukarıdaki programda sürekli ileri giden sırasıyla ledi yakan bir program yazıldı. Aşağıdaki kod satırı ile ileri ardından geri gelen programı yazabiliriz.

for (int b=7 ; b>=2 ; b - -) Değişken;

b değişkenini en yukarıda “Global” tanımlama yapabilirsiniz. Loop bölümünde “Local” tanımlamada yapabilirsiniz.

NOT; Aşağıdaki şekilde for tanımlaması olabilir. b=2;

b=2;

for( ; b<8 ; b++)

for( ; b<8 ;) { b++; }


Sayfa 81

15. BÖLÜM BREAK VE CONTİNUE


Sayfa 82

BREAK VE CONTİNUE Break;

Hatırlayacağınız üzere break komutunu switch – case yapısındayken kullanmıştık. Break komutu case değerini çalıştırmaya başladıktan sonra atlama yapmasın diye kullanılıyordu. Bizim algoritmamız break komutunu gördüğünde switch – case içerisinden çıkıyordu. Bu komutu(break), sadece “switch – case” komutuyla değil bir çok komutla kullanabiliriz. Örneğin for döngüsü çalışırken for döngüsünde, herhangi bir olaydan sonra, for döngüsünü terk etmesini söylemiştik.

1 Adet buton 1 adet 10Kohm direnç

int durum;

// durum değişkeni atadık

void setup() { pinMode(8, INPUT);

// 8. Pini buton olduğu için giriş olarak atadık

Serial.begin(9600);


} void loop() { for(int b=0; b<20 ; b++) { Serial.println(b);


// b değişkenini 20’ye kadar birer birer arttır // b değişkeninin değerini ekranda göster

Sayfa 83

delay(500);

// 500ms bekle

durum=digitalRead(b);

// b değişkenini durum değişkenine ata

if (durum== HIGH)

// if koşulu sağlanıyorsa veya butona basılırsa

{ break;

// durdur

} } Serial.println("donguden cikildi");

// ekrana yazdır

}

NOT;

Yukarıdaki programda 0’dan 20’ye kadar sayıcak butona, basıldığında break komutu ile tekrar başa dönecek. Birçok örnek ile break komutunu kullanabiliriz.

FOR İLE KULLANIM int durum;

// durum değişkeni atadık


// 8. Pini buton olduğu için giriş olarak atadık

Serial.begin(9600);


} void loop() { for(int b=0; b<20 ; b++) {

// b değişkenini 20’ye kadar birer birer arttır

Serial.println(b);

// b değişkeninin değerini ekranda göster

delay(500);

// 500ms bekle

if (b == 10)


// eğer 10’a gelirse aşağıdaki kodu işle

Sayfa 84

{ break;

// durdur


// ekrana yazdır

}

NOT; Yukarıdaki programda b değişkeni 10 olduğunda program başa dönecek.Bu her defasında tekrarlanacak.

WHİLE İLE KULLANIM

int durum;

// durum değişkeni atandı

int b=0;

// 0 değeri b değişkenine atandı


// 8. Pin buton olduğu için giriş olarak atandı

Serial.begin(9600);


} void loop() { while(1)

// 1’den başlayacak

{ b++;

// birer birer b değişkeninin değerini arttıracak

Serial.println(b);

// b değişkeninin değerini ekrana yaz

delay(500);

// 500ms bekle

durum = digitalRead(8);

// 8.pinin değerini durum değişkenine ata


Sayfa 85

if(durum == HIGH) { break;

// buton’a basılırsa alt kodu işle // durdur


// ekrana yazdır

}

NOT;

Yukarıdaki programda “while” döngüsü “while(1)” parantez içerisinde 1 koşul vardı. Biz bu koşula göre while döngüsüne giriş – çıkış sağlayabiliyoruz. Biz 1 dedik “while(1)” ve while döngüsünü sonsuz döngüye soktuk. Örnek programda her buton’a bastığımızda while döngüsünden çıkıp ilk komutu çalıştıracak ve kaldığı yerden devam edecek.

Continue;

Break komutu bir döngünün çalışmasına son veriyordu. Continue ise o andaki işlemi atlıyor.


// Serial monitör kullanıldı

} void loop() { for(int a=0; a<20 ; a++) {

// a’nın değerini 20’ye kadar birer birer artır

if(a==6) {

// eğer 6 rakamına gelince

continue;

// 6 rakamını atla

} Serial.println(a);

// ekrana a değişkeninin değerini yaz

delay(500); }

// 500ms bekle

}


Sayfa 86

NOT; Yukarıdaki programda a değişkeninin değeri 6 olduğu zaman for döngüsündeki kodların hepsi atlanıp tekrar kodun başına geçiyor. Şöyleki; her seferinde kodlar çalıştırılıyorsa bir “continue” ifadesi gördüğünde algoritma döngünün neresinde olursa olsun döngüyü orda yarıda bırakır, bir tur daha yukarı çıkar ve kaldığı yerden devam eder. Bizim örnek programımızda 6 rakamını atlayacak ve biz ekranda göremeyeceğiz.

1,2,3,4,5,7,8…..

1 Adet buton 1 adet 10Kohm direnç

int durum;

// durum değişkeni atandı



pinMode(8, INPUT);

// 8. Pini giriş olarak atadık

} void loop() { for(int a=0; a<60 ; a++) { durum = digitalRead(8); if(durum == HIGH)

// a, 60’a kadar birer birer artacak // 8 değerini durum değişkenine atama yaptık // butona basılırsa aşağıdaki kodu işle

{ delay(250);


// 250 ms bekle

Sayfa 87

continue;

// atlama yaptı

} Serial.println(a);

// a değişken değerini ekrana yaz

delay(250);

// 250ms bekle

} }

N0T;

Yukarıdaki programda her butona bastığımızda 1 sayı atlayacak ve kaldığı yerden devam edecek. “For” ile kullanılan “continue” aynı şekilde “while” komutu ile kullanılabilir. Örnek programı aşağıda görebilirsiniz.

int durum; int a=0;

// durum değişkeni atandı // a değişkeninin değeri 0 oldu



pinMode(8, INPUT);

// 8. Pini giriş olarak atadık

} void loop() { while(1) { a++;

// 1’den başlayacak // int değeri kadar birer birer artacak

durum =digitalRead(8);

// 8 değerini durum değişkenine atama yaptık

if (durum == HIGH) {

// if koşulu sağlanıyorsa aşağıdaki kodu işle

delay(250);

// 250 ms bekle

continue;

// atlama yap

}


Sayfa 88

Serial.println(a); delay(250);

// a değişkeninin değerini ekrana yaz // 250 ms bekle

} }

NOT;

Yukarıdaki programda a değerini int veri tipinin en son değerine kadar arttıracak. Örneğin ekrana 103’ü yazdırdık. Yazdıktan sonra sayının değerini arttırdı. Bu sırada buton’a bastık, buton’a basınca “continue” ifadesini gördü, bu yüzden a değişkeninin değerinin 104 olmuş halini ekrana yazdıramadan , tekrar en başına gittiği için a değerini 1 daha arttırdı. 104’den 105 oldu ve sonra çalışmaya devam etti. Bu yüzden biz 103’den sonra 104 değerini görmeden direk 105 değerini görmüş olduk.

ÖZET OLARAK; Break; Bu komut döngüden çıkartıyor. Continue;

Bir seferliğine mahsus bizim algoritmamızın çalışmasını bir miktar

engelliyor.

ÖNEMLİ NOT;

“xxxx=xxxx+1;” ile “xxx++;” komutlarıx değişkenlerini 1 arttıran komutlardır ve ikiside aynı işlemi yapar.


Sayfa 89

16. BÖLÜM ANALOG GİRİŞ VE 10BİT ADC


Sayfa 90

ANALOG GİRİŞ VE 10BİT ADC POTANSİYOMETRE İLE GELEN BİLGİYİ OKUMA

1 ADET POTANSİYOMETRE(100K)

int gelen_veri;

// gelen veri adında değişken tanımlandı



} void loop() { gelen_veri=analogRead(A0);

// A0 değerini gelen_veri değişkenine atama yaptı

Serial.println(gelen_veri);

// gelen_veri değeri ekrana yazıldı

delay(250);

// 250ms bekledi

}


Sayfa 91

NOT; Yukarıdaki programda “A0” analog

0.pinini temsil etmekle beraber istediğimiz isimleri verebiliyoruz. Fakat digital pinler gibi 1-2-3 vs.. değilde A0-A1-A2 vs gibi yazabiliyoruz. Potansiyometre’yi void setup bölümünde GİRİŞ(INPUT) olarak atamamıza gerek yok çünkü yapılan işlem zaten giriş. Yukarıdaki örnek programda, Serial Monitörde 0-1023 arasında değer görüyoruz. Analog değerlerimizin 0 ile 1023 değerlerinin okunması; Bizim Arduino’muzda 10-Bit’lik ADC var(ANALOG DİGİTAL CONVERTER). Analog’dan digital’e dönüşrürücü.

2x2x2x2x2x2x2x2x2x2

2

4

8

16

32 64 128 256 512 1024

Bizim ADC’miz 10 Bitlik veri çalışıyor.

ÖRNEK;

10 adet boş kutu düşünelim. Bu kutucukların her birine 1 veya 0 girecek yani 2 değerin girilmesini hesaplıyoruz.

2

2

1,0 2

1,0 4

2

2

1,0 1,0 8 16

2

2

1,0 32

1,0 64

2

2

2

2

1,0 1,0 1,0 1,0 128 256 512 1024

Örnekte görüldüğü üzere 0-124 değeri çıkıyor. Serial monitör’de 1023 değerinin görülmesinin sebebi 0’ıda hesaba kattığı için. 0-1023


Sayfa 92

ANALOG PİNE KAÇ VOLT GELDİĞİNİ BULAN PROGRAM

const int pot_pin=A0;

// A0’a pot_pin değişken ismi verdik

int okunan_deger;


float voltaj;

// float tipinde değişken tanımladık



} void loop() { okunan_deger=analogRead(pot_pin);

// okunan değer’e atama yap

Serial.print("okunan_deger");

// ekrana yazdır

Serial.println(okunan_deger);

// değişkenin değerini ekrana yazdır

Serial.print("voltaj=");

// ekrana yazdır

Serial.println((okunan_deger *5)/1023.0);

// değeri yaz

delay(250);

// 250ms bekle

}

VOLTAJ DEĞERİNİ HESAPLAMA Gelen değer x 5V

5V

1023

1024

=0,0047V =4,8mV

Formülde 5V bizim Arduino’muzun pinine gelen Voltaj. 1023’e bölmemizin nedeni aralığın en yüksek değerinin 1023 olması. Yani biz 5Voltu 1024’e bölüp 1023(sondeğer) ile çarparsak “(5/1024) * 1023(okunan_deger)=4.99v)” 5V’dan daha küçük bir değer göstereceği içindir ki buda yanlış okunan değer oluyor, işte bunu önlemek amacıyla 1023 yazılıyor.

“(5/1023)*1023(okunan_deger)=5V”


Sayfa 93

UYGULAMA ARDUİNO İLE LM35 KULLANIMI


Sayfa 94

UYGULAMA(ARDUİNO İLE LM35 KULLANIMI) Bu projede LM35 ile sıcaklık bilgisini okuyacağız. Okuduğumuz sıcaklık bilgisine bağlı olarak led yakacağız. Burada RGB led kullanacağız. RGB led sayesinde değerler dahilinde renk elde edeceğiz.

220 veya 330 OHM direnç(3 adet)

NOT: BU UYGULAMADA KULLANILAN

1 adet RGB LED(ANOT)

RGB LED HAKKINDA BİLGİYİ, BU

1 ADET LM35 sıcaklık sensörü

DERS SONUNDA BULABİLİRSİNİZ.

const int sensor_pin =A3;

// analog 3. Pine değişken ismi verdik

const int k_led =5;

// 5. Pine k_led değişken ismi verdik

const int y_led =4;

// 4. Pine y_led değişken ismi verdik

const int m_led=3;

// 3. Pine m_led değişken ismi verdik

int sensor_deger =0;

// değişken tanımladık ve değeri 0 verdik

int voltaj_deger =0;


int sicakli_deger =0;



Sayfa 95

void setup() { pinMode(k_led, OUTPUT);

// RGB ledlerin sinyal bacakları çıkış olarak atandı

pinMode(y_led, OUTPUT);


pinMode(m_led, OUTPUT);


Serial.begin(9600);


} void loop() { sensor_deger = analogRead(sensor_pin);

// atama yapılacak

Serial.print("okunan deger=");

// ekrana yazdır

Serial.println(sensor_deger);


}

NOT;

Yukarıdaki program bizim Serial monitörden, sensörün okuduğu değeri gösteriyor. Ekranda 65 rakamını görüyoruz. Bu bilgi sıcaklık değeri değil onu bilmeniz gerekir. Bu bilgiyi sıcaklığa çevirmek için, sensörün bir takım bilgilerini bilmemiz gerekiyor. Örneğin “nasıl çalışıyor, nasıl veri alıyor, gönderiyor” gibi..

Bu bilgileri “datasheet” isimli siteden bulabiliriz. Bu siteler genellikle ürünlerin özelliklerini veriyor. Arama motoruna “LM35 Datasheet” yazmamız yeterli. Ürününüz eğer çakma , çin malı vs. ise orijinal datasheet ile aynı olmasa bile genel olarak birbirine benziyor. “Datasheet” dosyasına baktığımızda çoğunlukla ingilizce kaynakları görüyoruz. Türkçe bulmamız bi’ihtimal.

Bildiğimiz üzere Arduino’nun içinde 10 Bitlik ADC olduğu için 0-1023 arasında değişen değerler alıyoruz. Biz bu değerleri miliVolta çevireceğiz. Örnek programı inceleyelim.


Sayfa 96



const int k_led =5;


const int y_led =4;


const int m_led=3;




int voltaj_deger =0;


int sicakli_deger =0;








Serial.begin(9600);


} void loop() { sensor_deger = analogRead(sensor_pin);

// atama yapılacak


// ekrana yazdır



voltaj_deger =(sensor_deger /1023)/5000;

// işlem yapar

Serial.print("gelen voltaj=");

// ekrana yazdır

Serial.println(voltaj_deger);

// ekrana değişkenin değerini yazdır

delay(250);

// 250ms bekle

}


Sayfa 97

NOT;

Yukarıdaki programda “voltaj_deger =(sensor_deger /1023)/5000;” bu kodu açıklamak gerekirse; sensor_deger’i 1023’e böldük çünkü 10Bitlik ADC’miz vardı. 5000’e çarpmamızın nedeni ise öncelikle değeri mV cinsinden istiyoruz. Ayrıca pinlerimiz max. 5V çıkış verebildiği için 5 ile çarptırıyoruz.

ÖNEMLİ NOT;

Yukarıdaki programda hata var. İstediğimiz değeri bize veremiyor. Çünkü bunun sebebi “voltaj_değer”i int olarak tanımladık oysaki float veri tipinde tanımlamamız gerekiyordu.

Float;Ayrıca

float yani küsüratlı çıkış istiyorsak, float’ın hesaplandığı değişkende mutlaka 2 tane değişken float olarak tanımlanması gerekiyor. Biz”voltaj_deger”, float olarak tanımladık. 1023’ede “.0” eklersek(1023.0) bu iş tamamdır.

NOT;

62 sayısının gelmesinin tanımı yok. Gereksiz bit. Yazdığımız program ile voltajımızı ölçtük. Buradaki 303,03mV bilgisini sıcaklığa çevirecek programımıza devam ediyoruz.



const int k_led =5;


const int y_led =4;


const int m_led=3;




float voltaj_deger =0;


float sicaklik_deger =0;








Serial.begin(9600);


}


Sayfa 98

void loop() { sensor_deger = analogRead(sensor_pin);

// atama yapılacak


// ekrana yazdır




// işlem yapar


// ekrana yazdır



sicaklik_deger=voltaj_deger/10.0;

// gerekli işlemi yaptı

Serial.print("sicaklik");

// ekrana yazdır

Serial.println(sicaklik_deger);


Serial.println("derece");

// ekrana yazdır

delay(250);

// 250ms bekle

NOT;

Yukarıdaki programda “62 biti, voltajı, dereceyi” görebiliriz. “sicaklik_deger” değişkenini float olarak tanımladık ki bize küsürlü değerleri göstersin. Son olarak “Gelen sıcaklığa bağlı olarak ledi yakan program” uygulamasını yaparak bu dersimizi bitirelim. Bazı derslerde yazdığımız fazladan programlar dikkat çekmiştir ve çoğunluğuda hatalıdır. Bilinmelidir ki hepsi bilerek yapılan hatalardır. Siz kullanıcıların yapabilecek olduğu potansiyel hataları yaparak doğrusunu öğreniyoruz.


Sayfa 99



const int k_led =5;


const int y_led =4;


const int m_led=3;




float voltaj_deger =0;


float sicaklik_deger =0;








Serial.begin(9600);


} void loop() {

sensor_deger = analogRead(sensor_pin);

// atama yapılacak


// ekrana yazdır




// işlem yapar


// ekrana yazdır




Sayfa 100

sicaklik_deger=voltaj_deger/10.0;

// gerekli işlemi yaptı

Serial.print("sicaklik");

// ekrana yazdır

Serial.println(sicaklik_deger);


Serial.println("derece");

// ekrana yazdır

delay(500);

// 500ms bekle

if(sicaklik_deger>=35){

// şart sağlanıyorsa kodu işle

digitalWrite(k_led, LOW);

// Ledi yak, (RGB Bölümünü okuyunuz)

digitalWrite(y_led, HIGH);

// Ledi söndür, (RGB Bölümünü okuyunuz)

digitalWrite(m_led, HIGH);


} else if (sicaklik_deger = 35 && sicaklik_deger >=30){

// koşul sağlanıyorsa işle

digitalWrite(k_led, LOW);


digitalWrite(y_led, LOW);




} else if(sicaklik_deger<30){

// koşul sağlanıyorsa işle

digitalWrite(k_led, HIGH);




digitalWrite(m_led, LOW);


} }

NOT;

Yukarıdaki programda sıcaklık 35 dereceden büyükse kırmızı led yanacak. Sıcaklık 35 dereceden küçük, 30 dereceden büyükse yeşil veya sarı led yanacak. Sıcaklık 30 derecenin altındaysa mavi ledi yakacak.


Sayfa 101

RGB LED HAKKINDA BİLİNMESİ GEREKENLER RGB led üç farklı rengin birleştiği led demektir.

R=RED (KIRMIZI) G=GREEN(YEŞİL) B=BLUE(MAVİ) Ortak anotlu RGB ledde artı, Ortak katot ise eksiye bağlanmalı. Tüm led bacakları 220 veya 330 OHM direnç ile bağlamalısınız.

ANOT RGB LED 1.bacağı bağlarsak(kırmızı) 3.bacağı bağlarsak(yeşil) 4.bacağı bağlarsak(mavi) 1.ve 3.ledi bağlarsak(sarı) 1.ve 4. ledi bağlarsak(mor) 1.3.ve 4. ledi bağlarsak(beyaz) 3.ve 4. ledi bağlarsak(turuncu)

NOT; Bu bacakları GND’ye bağlayacağız.


Sayfa 102

KATOT RGB LED 1.bacağı bağlarsak(kırmızı) 3.bacağı bağlarsak(yeşil) 4.bacağı bağlarsak(mavi) 1.ve 3.ledi bağlarsak(sarı) 1.ve 4. ledi bağlarsak(mor) 1.3.ve 4. ledi bağlarsak(beyaz) 3.ve 4. ledi bağlarsak(turuncu)

NOT; Bu bacakları 5V’a bağlayacağız. Örnek Programı inceleyelim.

NOT;

PWM sinyali olan pinlerimize bağlıyoruz RGB ledimizin renk bacaklarını. Anot RGB (+), Katot(-) bağlanacak.

1 Adet RGB Led 3 Adet RGB Ledin bacakları için 220 veya 330 OHM direnç


Sayfa 103

const int k_led=11;

// 11. Pini k_led değişkenine atama yap

const int y_led=10;

// 10. Pini y_led değişkenine atama yap

const int m_led=9;

// 9. Pini m_led değişkenine atama yap


// RGB Bacaklarının renk bacakları çıkış





} void loop() { digitalWrite(k_led, LOW);

// kırmızı ledi yak


// yeşil ledi söndür


// mavi ledi söndür

}

NOT;

Yukarıdaki programda Anot RGB Led bağlantılarını yaparak kırmızı rengi elde ettik. Kırmızı ledi yakarken digital sinyaller kullandık. Bir sonraki örnek programda Analog çıkışlarla RGB ledi yakacağız.

Void loop bölümünde Kırmızı ledi elde ettik ama bunu LOW olarak elde ettik. Nedeni ise Anot RGB ledi kullanmamız. Farkındaysanız sinyal bacaklarını Arduino’muzun pinlerine, Anot bacağını 5V’a bağladık. Burada GND olarak herhangi işlem yapmadık. Yapmak için programda istediğiniz renkleri elde etmek için o pini LOW olarak tanımlarız. Fakat bunu Anot’ta yaparız Katot’da ise tam tersi HIGH yaparız.

NOT; RGB ledin Anot – Katot olma durumunu ölçü aletimizle test edebiliriz. Öncelikle ölçü aletimizi diyot ölçme fonksiyonuna getiriyoruz ve ardından kırmızı probu Ortak(Anot veya Katot) bacağa tutuyoruz. Siyah probu’da herhangi renk bacağına tutuyoruz eğer yanarsa RGB led Anot. Ortak kısma siyah, Renk bacaklarında birine kırmızı probu değdirdiğimizde yanarsa Katot RGB led oluyor.


Sayfa 104

17. BÖLÜM ANALOG ÇIKIŞ – PWM


Sayfa 105

ANALOG ÇIKIŞ – PWM ANALOG ÇIKIŞ Potansiyometre ile buzzerin sesini kontrol edeceğiz. Potansiyometre’nin 1.ucu(-), 2.ucu(AnalogPin), 3.ucu(+). Buzzer’in 1.ucu(-), 2.ucu Arduino’muzun PWM sinyali gönderen pinine bağlıyoruz.(~ - 3,5,6,9,10,11).

1 adet 100k Potansiyometre 1 adet buzzer

const int pot_pin = A0;

// analog 0. Pin’de değişken atadık

const int buzzer =11;

// 11 digital(PWM) pine değişken tanımladık

int durum=0;

// değişken tanımladık ve değerini 0 dedik

int cikti=0;

// değişken tanımladık ve değerini 0 dedik


Sayfa 106

void setup() { pinMode(buzzer, OUTPUT);

// buzzer pini çıkış olarak atandı

Serial.begin(9600);


} void loop() { durum = analogRead(pot_pin);

// atama yapıldı durum değişkenine

Serial.println(durum);

// durum değişkeninin değerini ekrana yaz

cikti =map(durum, 0,1023, 0,255);

// buzzer pini çıkış olarak atandı

analogWrite(buzzer, cikti);

// senkronize ediyor

}

NOT; Bizim Analog pinlerimiz 0-1023 arasında okuma işlemi yapıyorsa, çıktı işlemini 0-1023 arasında okuma yapıyor sanıyorsanız yanılgıya düşersiniz. Çünkü 0-1023 arasında okuma yapıyor ama 0-255 değerler arasında çıktı alıyor. 0-1023 arasında giriş alıp, 0-255 arasında çıktı vericeksek bu iki değeri birbirine senkronize etmemiz gerekiyor.

SENKRONİZE TANIMI;

Eş zamanlama veya eşleşme, eş güdümlü çalışan parçaları istemlerin zamanlamalarının eşleştirilmiş olduğunu ifade eder. Birimler, bu şekilde çalışan sistemler senkronize veya eşzamanlı olarak anılır.

Senkronize etmemiz için “map” komutunu kullanacağız. Bu komutu isterseniz direk durum değişkeni üzerinde yeni bir atama yaparak kullanabilirsiniz. İstersenizde “map” komutundan çıkacak olan veriyi yeni bir değişkene atayabilirsiniz. Biz programımızda yeni bir değişkene atadık. Programımızda “cikti=map(durum, 0,1023, 0,255);” kod satırında 0-1023 ile 0255 sayılarını birbirleriyle senkronize etmiş olduk. “cikti” değişkenini yazmamızın nedeni, “ map(durum, 0,1023, 0,255);” bu işlem sırasında ortaya çıkan değişken, “cikti”’ya kayıt edilsin, sonrada biz bu değeri(cikti’ya atanan) kullanalım.


Sayfa 107

MAP KOMUTU; “map(değişken, 1,2,3,4);” Öncelikle parantez açıldıktan sonra değişkenimizin ismini yazıyoruz. Daha sonra virgül koyup 4 adet sayı girmemiz gerekiyor. Bu sayıların;

1)Eski formatın en düşük değeri = 0 2)Eski formatın en yüksek değeri = 1023 3) Yeni formatın en düşük değeri = 0 4) Yeni formatın en yüksek değeri = 255 Bu kodla algoritmamız 0-1023 arasındaki değeri, 0-255 arasında senkronize etti.

NOT;

Giriş kullanmadan yada map komutu kullanmadan’da direk analog çıkış alabiliriz.

analogWrite(buzzer, 0-255 arası deger); Programımızda “analogWrite(buzzer, ?);” bu komut satırında soru işareti yerine “HIGH veya LOW” gelmeyecek çünkü HIGH veya LOW değerleri digital işlemleri gerçekleştirir. Biz burada “cikti” değişkeni ile çalışacağız. Çünkü biz map kullanarak kendimize değer oluşturduk ve bu oluşturduğumuz değerde sürmek istiyoruz. “analogWrite(buzzer, cikti);” sadece buzzer değil birçok bileşenide kullanabilirsiniz(led).

AKILDA KALANLAR; 1) Neden 0-255 arasında çıktı veriyorda, 0-1023 arasında vermiyor? CEVAP;

Öncelikle Arduino’nun sitesinde “PWM; 3,5,6,9,10 ve 11. Pinleri 8-bit PWM destekli sinyali çıkış olarak alabilirsiniz. “analogWrite()” fonksiyonunu kullanarak.”diyor.


Sayfa 108

16. derste gösterildiği gibi 10BİT değilde 8BİT olarak işlem yapacağız.

2

2

1,0 2

2

1,0 4

2

1,0 1,0 8 16

2

2

2

2

1,0 1,0 1,0 32 64 128

1,0 256

Burada “0” sıfır’ıda kattığımız için hesaba değer toplamı 256 oluyor. İşte bu yüzden Arduino’muzun içindeki PWM sinyali destekli pinler 8BİT olduğu için 0-255 arasında çıktı veriyor.

PWM NEDİR? “Pulse width modeslation” darbe genlikli modülasyon. 16.derste 10Bit’in ne anlama geldiğini öğrenmiştik.

“10BİT-ADC -> Analog Digital Converter Analog Dijital Dönüştürücü”

Digital çıkış alıyoruz fakat “10Bit-ADC” gibi analog değerinde bir modülü varmı diye düşünebilirsiniz ama düşünmeyin çünkü yok. Bu işi PWM yapıyor. Öncelikle PWM Sinyalini anlayabilmemiz için digital ve analog sinyaller hakkında bilgi sahibi olmamız gerekli.


Sayfa 109

DİGİTAL SİNYAL

DC; Bir doğru akım elektrik yük akımının zamanla değişmediği sabit kaldığı akımdır. ANALOG SİNYAL

AC; Alternatif(analog) akım elektrik yük akımının zamanla değiştiği akımdır. ÖZET;

1 Saniye aralıklarla çalışan grafikleri yani bu aralıkları iyice küçülterek mikrosaniye cinsinden sinyal yaparsak, PWM pinleri bizim bu küçük aralıklarda çalışmamızı sağlıyor.


Sayfa 110

ANALOG SİNYALLER İLE RGB LED

const int kled =11;

// 11 pini kled dedik

const int yled =10;

// 10 pini yled dedik

const int mled =9;

// 9 pini mled dedik

void setup() { pinMode(kled, OUTPUT);

// RGB Ledlerin sinyal bacakları çıkış

pinMode(yled, OUTPUT);


pinMode(mled, OUTPUT);


} void loop() { analogWrite(kled, 255-150);

// analog çıkış ile parlaklık ayarlandı

analogWrite(yled, 255-0);


analogWrite(mled, 255-0);


}

NOT; Yukarıdaki programda analog değerler ile istediğimiz işlemleri yapıyoruz. 255 Sayısını daha önce öğrenmiştik.

8-BİTLİK sayı = 0-255


Sayfa 111

18. BÖLÜM FONKSİYONLAR -1-


Sayfa 112

FONKSİYONLAR -1Algoritmanın içinde çalışan küçük fonksiyonlardır. Void setup ve Void loop’da birer fonksiyondur. 4 adet fonksiyon tipi var. Şuana kadar kullandığımız fonksiyonlar mutlaka bu 4 fonksiyonun içine giriyordur. 1- PARAMETRE ALMAYAN VE DEĞER DÖNDÜRMEYEN FONKSİYONLAR 2- PARAMETRE ALMAYAN VE DEĞER DÖNDÜREN FONKSİYONLAR 3- PARAMETRE ALAN VE DEĞER DÖNDÜRMEYEN FONKSİYONLAR 4- PARAMETRE ALAN VE DEĞER DÖNDÜREN FONKSİYONLAR Bu dersimizde birinci fonksiyonumuz olan “Parametre almayan ve değer döndürmeyen fonksiyonlar” konusunu inceleyeceğiz.

PARAMETRE ALMAYAN VE DEĞER DÖNDÜRMEYEN FONKSİYONLAR Fonksiyon tanımlama yaparken bize 3 adet bilgi lazım.

Soru;

Bu fonksiyon nasıl değer döndürecek yani bu fonksiyon sonunda bilgi ne tarz bilgi olacak?(int – float – long – double – void ) -Bir değer döndürmemesini istediğimiz için “Void” ile başlıyoruz.

void fonksiyon1() { Serial.println("fonksiyon basladi"); delay(2500); Serial.println("fonksiyon calismaya devam ediyor");

// fonksiyon oluşturduk // ekrana yazdır // 2500ms (2.30 saniye)bekle // ekrana yazdır

delay(2500);

// 2500ms (2.30 saniye)bekle

Serial.println("fonksiyon birazdan biticek");

// ekrana yazdır

delay(2500);

// 2500ms (2.30 saniye)bekle

}


Sayfa 113



} void loop() { Serial.println("sistem calismaya basladi");

// ekrana yazdır

delay(2000);

// 2000ms (2 saniye)bekle

fonksiyon1();

// fonksiyon1 değişkenini kullan

delay(1000);

// 1000ms (1 saniye)bekle

Serial.println("program calismayi bitirdi");

// ekrana yazdır

while(1);

// bir kere döndür programı

}

“fonksiyon1();”

Pazantez içine birşey yazmamamızın nedeni bizim fonksiyonumuzun “Parametre almayan ve değer döndürmeyen” olduğu içindir. Bu tanımlamayı yukarıda yapıyoruz ve süslü parantez açarak istediğimiz işlemin “fonksiyon1” adlı değişkene geldiğinde çalışmasını sağlıyoruz. Void ile tanımlamamızın nedeni değer döndürmediği içindir. “( )” parametre almayan.

NOT;

Pin tanımlamalarını aynı şekilde fonksiyon tanımlamamızın en üstüne yapabilirsiniz. Yukarıdaki program ilk başta void setup bölümüyle başlar. En yukarıyı görmez. Sonra void loop ile devam eder. Void loop’ta “fonksiyon1();” kod satırını görür ve hemen bakar nerde tanımlanmış diye sonra gider “fonksiyon1();” adlı değişkene ve onu çalıştırır. “while(1)” ise programı 1 kez çalıştırır. “fonksiyon1();” değişkende işlemini bitirdikten sonra kaldığı yerden devam eder. Bu fonksiyonun kolaylığı; Algoritma yazdığınızı düşünün, Belli bir mesafe aralığınma mayın arama dedektörü yaptınız. Dedektörde birden fazla sensör var. Böyle bir algoritma yazarsanız en büyük yük sensörlerden ölçüm yapmaktır. Devamlı sensörlerden veri almamız gerekiyör. Aynı kod satırını yazmaktansa en yukarıda değerleri girilerek o değerler etrafında mayını arayabiliriz. Void loop’ta sadece yukarıda tanımladığımız fonksiyon’a gider. Bir satır kod ile fonksiyonu çağırabiliyoruz.


Sayfa 114

Aşağıdaki Örnek programda bir değişiklik yapmak istedik. Sadece fonksiyonla ilgili satırı değiştirerek, programda değişiklik yapabiliriz.

2 Adet 220 veya 330 OHM direnç 1 Adet 10K direnç 1 Adet led 1 Adet buton 1 Adet buzzer

const int led_pin =3;

// 3. Pine led_pin ismini verdik

const int buzzer_pin =2;

// 2. Pine buzzer_pin ismini verdik

const int buton_pin=4;

// 4. Pine buton_pin ismini verdik

int buton_durum =0;


void basla(){

// fonksiyon tanımladık

digitalWrite(led_pin, HIGH);

// ledi yak

delay(200);

// 200ms bekle

digitalWrite(led_pin, LOW);

// ledi söndür

delay(200);

// 200ms bekle

}


Sayfa 115

void baslama(){

// fonksiyon tanımladık

digitalWrite(buzzer_pin, HIGH);

// buzzeri çalıştır

delay(200);

// 200ms bekle

digitalWrite(buzzer_pin, LOW);

// buzzeri durdur

delay(200);

// 200ms bekle

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

// ledi çıkış olarak atadık

pinMode(buzzer_pin, OUTPUT);

// buzzeri çıkış olarak atadık

pinMode(buton_pin, INPUT);

// butonu giriş olarak atadık

} void loop() { buton_durum = digitalRead(buton_pin); if(buton_durum == HIGH){ basla();

// buton_pin durumunu atama yaptık

// if koşulu sağlanıyorsa çalıştır // “basla()” fonksiyonunu çalıştır

} else if(buton_pin == LOW){ baslama();

// else if koşulu sağlanıyorsa // “baslama()” fonksiyonunu çalıştır

} }

NOT; Yukarıdaki programda void olarak tanımladığımız değişkenden istediğimiz kadar tanımlayabiliyoruz. Butona basıldığında ledi yakan, basılmadığında ledi söndüren, buzzeri çalıştıran program yazdık. Kullanım açısından normal kodlarla hiçbir farkları yok. “if-for-while” gibi istediğimiz komutlarla kullanabiliriz.


Sayfa 116



Sayfa 117

FONKSİYONLAR -2Fonksiyonlar konusunun birinci dersinde “Parametre Almayan ve Değer Döndürmeyen Fonksiyonlar” konusunu ele almıştık. Bu dersimizde ise “ Parametre almayan ve değer döndüren fonksiyonlar” konusunu inceleyeceğiz.

PARAMETRE ALMAYAN VE DEĞER DÖNDÜREN FONKSİYONLAR NOT;

Bu dersimizdeki örnek programımızda, bugüne kadar işlediğimiz tüm konuları barındırıyor.

1 adet led 2 adet buton 1 adet switch 1 adet 220 veya 330 OHM direnç 3 adet 10k Direnç


Sayfa 118

const int buton1 =2;

// 1. Kod satırı


// 2. Kod satırı


// 3. Kod satırı

const int led =7;

// 4. Kod satırı

int arti;

// 5. Kod satırı

int eksi;

// 6. Kod satırı

int durum;

// 7. Kod satırı

int sayac;

// 8. Kod satırı

int tur_sayisi;

// 9. Kod satırı

int fonksiyon2(){

// 10. Kod satırı

durum=digitalRead(buton3);

// 11. Kod satırı

while(durum==HIGH){

// 12. Kod satırı

arti =digitalRead(buton1);

// 13. Kod satırı

eksi =digitalRead(buton2);

// 14. Kod satırı

if(arti == HIGH) {

// 15. Kod satırı

sayac++;

// 16. Kod satırı

Serial.println("sayac =");

// 17. Kod satırı


// 18. Kod satırı

if(arti == HIGH) {

// 19. Kod satırı

while(1) {

// 20. Kod satırı

arti = digitalRead(buton1); if(arti == LOW) break;

// 21. Kod satırı // 22. Kod satırı // 23. Kod satırı

} } }


Sayfa 119

else if (eksi == HIGH){

// 24. Kod satırı

sayac--;

// 25. Kod satırı


// 26. Kod satırı

Serial.println(sayac); if (eksi == HIGH){ while(1){ eksi = digitalRead(buton2); if (eksi == LOW) break;

// 27. Kod satırı // 28. Kod satırı // 29. Kod satırı // 30. Kod satırı // 31. Kod satırı // 32. Kod satırı

} } } durum = digitalRead(buton3);

// 33. Kod satırı

} return sayac;

// 34. Kod satırı

} void setup() { pinMode(buton1, INPUT);

// 35. Kod satırı

pinMode(buton2, INPUT);

// 36. Kod satırı

pinMode(buton3, INPUT);

// 37. Kod satırı3

pinMode(led , OUTPUT);

// 38. Kod satırı

Serial.println(9600);

// 39. Kod satırı

} void loop() { tur_sayisi = fonksiyon2();

// 40. Kod satırı

for(int i=0; i
// 41. Kod satırı

digitalWrite(led , HIGH);


// 42. Kod satırı

Sayfa 120

delay(100); digitalWrite(led, LOW); delay(100);

// 43. Kod satırı // 44. Kod satırı // 45. Kod satırı

} while(1)

// 46. Kod satırı

{ durum = digitalRead(buton3);

// 47. Kod satırı

if(durum == HIGH)

// 48. Kod satırı

break;

// 49. Kod satırı

} }

KOD AÇIKLAMALARI; 

1 ve 4. Kod satır aralığında Arduino’muza bağladığımız bileşenlerin pin ve isim atamalarını yaptık.



5. ve 6. Kod satır aralığında buton’a basılıp basılmama bilgisi için değişken atadık.



Buton1’den okunan değeri “arti” değişkenine, buton2’den akunan değeri “eksi” değişkenine, buton3’den okunan değeride “durum” isimli değişkene kayıt edeceğiz.



Void setup bölümünde pinlerin giriş-çıkış durumlarını atadık.



40. ve 45. Kod satırları aralığında for döngüsünün içinde “tur_sayisi” adlı değişkenin değerini “fonksiyon2()” ile belirliyoruz.



Fonksiyon tanımlanırken bize üç adet bilgi gerekliydi.(void – int – float). Geçtiğimiz derste void kullanmıştık. Çünkü değer döndürmeyen olduğu için void kullandık. Yukarıdaki programda int kullandık. Çünkü değer döndüren fonksiyon yapıyoruz.


Sayfa 121

 

“int fonksiyon2()” bu bizim ismimiz.”( )” parantez içine fonksiyonun çalışmadan önce alması gereken parametreleri yazıyorduk.(int a, float b) gibi. Biz burda parametre vermeyeceğimiz için burayı boş bırakacağız. 11. Kod satırındaki kod “durum=digitalRead(buton3);” burada buton3’den durum okunuyor, oda durum adlı değişkene kayıt ediliyor. Sonra durum adlı değişkene bağlı kalarak while döngüsü çalışıyor veya çalışmıyor.



While döngüsüne giriş elde ettikten sonra geri while döngüsünden çıkabilmek için okuma işleminin aynısını yazmak lazım. Onuda 33. Program satırında yazdık.



13. ve 14. Kod satırında, “if(arti==HIGH)” ve “if(eksi==HIGH)” kodları için okuma işlemi yapan kodları yazıyoruz. Bu sayede “arti” ve “eksi” adlı değişkenleri “buton1” – “buton2”’den okuyup kayıt etmiş olduk. Buna bağlı kalarakta sayıcımız artacak veya azalacak.



Son olarakta while döngüsünden çıkış sağladıktan sonra ortaya çıkan sayac değerini, geri “fonksiyon2()” adlı değişkene göndermemiz gerekiyorki, bu sayac değişkeni “tur_sayisi” adlı değişkene kayıt edilsin, bu değişkende gelip for döngüsünde kullanılsın. Bu yüzden “fonksiyon2()” değişkenine sayac’ı göndermemiz için 10. Kod satırında “int fonksiyon2()” değişkenin en sonuna “return sayac;” ifadesini ekliyoruz. 34. Kod satırında yapıldı.. Bu sayede sayac adlı değişken(34) hesaplandıktan sonra “fonksiyon2()”nin yerine 40. Kod satırında “tur_sayisi” adlı değişkene gönderiyouz. Ordanda for döngüsünde kullanılıyor.



Eğer 12. Kod satırında while kullanmasaydık, her bir butona bastığımızda, basar basmaz o değişkeni gönderecekti, her seferinde hatalı çalışacaktı.



Önce biz 16. Kod satırında sayac değerini ayalıyoruz, ayarlama bittikten sonra sayac değişkeninin durumunu kapatıyoruz, daha sonra sayac değişkenimizin değeri aşağıya gidiyor. Biz ayarlama esnasında kapanmasın diye bir switch ile kontrol ediyoruz.



“fonksiyon2()” burada parantez koymamız şart yoksa çalışmaz. Parantez içine parametre yazmasak bile parantez koymalıyız.”( )”



15. Kod satırında “arti” HIGH iken if komutu çalışıyor. sayac’ı 1 artırdı, ekrana sayac adlı kelimeyi yazdı arkasından değeri yazdı.



19. Kod satırında “hala butona basılıyormu”. Eğer butona basılmaya devam ediliyorsa tutup bu sayac’ı artırmasın diye kendisini “while(1)” döngüsünün içine kilitlemesi gerekiyor(20).



Bu sayede kendisini while içersine kilitledi. Bu durum sonsuz döngü olur. Sonsuz döngüden çıkarmak için “while(1)”den çıkarmamız lazım. Onuda “if(arti == LOW)” yani butona basılma işlemi bırakılmışsa “break” ile bitiriyoruz.



Bu sayede buton’a basılma işlemi bitince, while’den çıkacak. Buton’a her bastığımızda bir kere arttırma işlemi yapacak.


Sayfa 122



Aynı kodu 23. Ve 32. Kod satır aralığında yazıyoruz. Eksi olarak değiştiriyoruz.



21. ve 30. Kod satırında if durumunu okuması için gereken kodu yazdık.



46. Kod satırında “while(1)” yazarak yapılacak işlemin bir kere yapılmasını istedik. While’den bunu çıkartmamız için ise 48. ve 49. Kod satırında durum değişkenimiz HIGH olduğunda while’de çıkmasını istedik.



12. Satırda durum değişkeni HIGH olduğu zaman sayac çalışmaya başlıyordu, durum değişkeni LOW olduğu zamanda ledi yakmaya başlıyor.



48. Kod satırında durum değişkenini HIGH yaptığımızda break komutu sayesinde while içinden çıkacak. Fakat öncesinde 47. Kod satırında olduğu gibi durum’u okumamız gerekiyor.


Sayfa 123



Sayfa 124

FONKSİYONLAR -3Bu dersimizde “ Parametre Alan ve Değer Döndürmeyen Fonksiyonlar” konusunu inceleyeceğiz.

PARAMETRE ALAN VE DEĞER DÖNDÜRMEYEN FONKSİYONLAR “Veri ismi Fonksiyon ismi ( Parametre )”

const int led =7;

// 1. KOD SATIRI

int tur_sayisi;

// 2. KOD SATIRI

void fonksiyon3(int a){

// 3. KOD SATIRI

for(int i =0; i
// 4. KOD SATIRI

digitalWrite(led, HIGH);

// 5. KOD SATIRI

delay(100);

// 6. KOD SATIRI

digitalWrite(led, LOW);

// 7. KOD SATIRI

delay(100);

// 8. KOD SATIRI

} } void setup() { digitalWrite(led, OUTPUT);

// 9. KOD SATIRI

Serial.begin(9600);

// 10. KOD SATIRI

}


Sayfa 125

void loop() { Serial.println("algoritma calismaya basliyor");

// 11. KOD SATIRI

delay(2500);

// 12. KOD SATIRI

tur_sayisi=10;

// 13. KOD SATIRI

fonksiyon3(tur_sayisi);

// 14. KOD SATIRI

Serial.println("algoritma bitti");

// 15. KOD SATIRI

while(1);

// 16. KOD SATIRI

}


İlk olarak 11. Kod satırındaki kod parçacığı yazılacak. 2.30 saniye sonra “tur_sayisi” adlı değişkene 10 değeri atanacak. Sonrada 14. Kod satırında “fonksiyon3(tur_sayisi)” çalıştırılacak ve fonksiyon3’de “tur_sayisi” adlı değişken parametre olarak gönderilecek.



“fonksiyon3” de yapılacak işlemler yapılacak. Fonksiyon çalışması bittikten sonrada 15. Kod satırı okunacak ve 16. Kod satırına geldiğinde kendini kilitleyecek.



Bildiğiniz gibi fonksiyon tanımlama için 3 tane bilgi lazım; Veri tipi Fonksiyon ismi (Parametre).



3. Kod satırında “Parametre alan ve değer döndürmeyen fonksiyon” istediğimiz için void olarak veri tipi atadık.”Fonksiyon3” ismimizi yazdık ve parametre olarakta “tur_sayisi” adlı değişken tanımladık. “tur_sayisi” adlı değişken int tipinde değişken olduğu için parametre olarak (int a) yazıyoruz.



“Bu fonksiyon, kendisine gönderilen parametre dahilinde ledi o kadar yakıp söndürsün.”



3. Kod satırında(int a) dedik. Daha sonra gelen bilgiyi aşağıda a olarak kullanabiliyoruz. Yani 14. Kod satırındaki “tur_sayisi” adlı değişkeni fonksiyon’a gönderdiğimizde, aslında tur_sayisi’ni göndermiyoruz bu değişlenin değeri gidiyor. O değer ise 13. Kod satırındaki 10 sayısını gönderiyoruz. Daha sonra fonksiyon, bizim yukarı gönderdiğimiz 10’u tutuyor 3. Kod satırındaki a’ya kayıt ediyor. 10’u istediğimiz yerlerde kullanabiliyoruz.


Sayfa 126



Bu sayede fonksiyon’a parametreyi gönderdiğimizde 13. Kod satırında “tur_sayisi” adlı değişkeni, değiştirmiş olmuyoruz. Yani “tur_sayisi” adlı değişkeni değil sadece onun değerini yolluyoruz.



13. Kod satırında 10 sayısının yerine yazdığımız sayıları buton’a basarak sayı adeti kadar ledi yakabiliriz.

HESAP MAKİNESİ UYGULAMASI

int a;

// 1. KOD SATIRI

int b;

// 2. KOD SATIRI

int toplam;

// 3. KOD SATIRI

void topla(int a, int b){

// 4. KOD SATIRI

toplam = a+b;

// 5. KOD SATIRI

} void setup() { Serial.begin(9600);

// 6. KOD SATIRI

} void loop() { a=5;

// 7. KOD SATIRI

b=16;

// 8. KOD SATIRI

topla(a,b);

// 9. KOD SATIRI

Serial.print("toplam=");

// 10. KOD SATIRI

Serial.println(toplam);

// 11. KOD SATIRI

}


Sayfa 127

KOD AÇIKLAMALARI 

7. Kod satırında “a”’nın değerini 5, 8. Kod satırında “b”’nin değerini 16 vedik. 9. Kod satırında a ve b değerlerini kullanarak topla adlı fonksiyonu çağırdık.



Daha sonra algoritma gidiyor 4. Kod satırına “topla” adlı değişkeni buluyor ve sonra a ve b adlı 2 tane değişken getiriyor. A’dan geleni birincisine, B’den geleni 2.’ne kayıt ediyor.



Bu arada 4. Kod satırında a ve b yerine “h ve g” gibi harfler yazılabilir. Oraya yazılanların aynısı 5. Kod satırında yazılmalıdır.



5. Kod satırında “a+b” değişkenini kopyalayarak topla adlı değişkene kayıt edecek.



Toplam değişkeni global değişken olduğu için heryerde kullanılabilir.



Bu program algoritmanın toplam adlı fonksiyonunda a ve b değerlerini 5 ve 16 değerlerini toplam adlı değişkene kayıt etmesi gerekiyor.

int a;

// 1. KOD SATIRI

int b;

// 2. KOD SATIRI

int toplam;

// 3. KOD SATIRI

int cikartma;

// 4. KOD SATIRI

void topla(int a, int b){

// 5. KOD SATIRI

toplam = a+b;

// 6. KOD SATIRI

} void cikart(int z, int y){ cikartma= b-a;

// 7. KOD SATIRI // 8. KOD SATIRI

} void setup() { Serial.begin(9600);

// 9. KOD SATIRI

}


Sayfa 128

void loop() { a=5;

// 10. KOD SATIRI

b=16;

// 11. KOD SATIRI

topla(a,b);

// 12. KOD SATIRI


// 13. KOD SATIRI


// 14. KOD SATIRI

cikart(b,a);

// 15. KOD SATIRI

Serial.print("sonuc=");

// 16. KOD SATIRI

Serial.println(cikartma);

// 17. KOD SATIRI

while(1);

// 18. KOD SATIRI

}


15. kod satırında “cikart” adlı fonksiyon tanımladık. Bunuda “b,a” olarak tanımladık. B 1.değişkene, A ise 2. Değişkene tanımlanacak. Yani 16’dan 5’i çıkartacak. Oda 11 olacak. 18. Kod satırında da “while(1);” diyerek programı kilitliyoruz.Yani döngü sadece 1 kere çalışacak.



Birden fazla fonksiyon tanımlayıp aynı anda kullanabilirsiniz. Fonksiyon içinde fonksiyon kullanabilirsiniz ama fonksiyon içinde fonksiyon tanımlayamazsınız.


Sayfa 129



Sayfa 130

FONKSİYONLAR -4Bu dersimizde “Parametle Alan ve Değer Döndüren Fonksiyonlar” konusunu inceleyeceğiz.

PARAMETRE ALAN VE DEĞER DÖNDÜREN FONKSİYONLAR Toplama – çıkartma – çarpma – bölme işlemlerinin sonucunu ekranda gösteren programı inceleyelim.

int toplam;

//1. KOD SATIRI

int cikarma;

// 2. KOD SATIRI

float bolme;

// 3. KOD SATIRI

int carpma;

// 4. KOD SATIRI

int fonksiyonarti(int t, int y){

// 5. KOD SATIRI

int z = t+y;

// 6. KOD SATIRI

return z;

// 7. KOD SATIRI

} int fonksiyoneksi(int k, int l ) {

// 8. KOD SATIRI

int m=k-l;

// 9. KOD SATIRI

return m;

// 10. KOD SATIRI

} int fonksiyoncarpma(int s, int abc){

// 11. KOD SATIRI

int ksl= s*abc;

// 12. KOD SATIRI

return ksl;

// 13. KOD SATIRI

}

float fonksiyonbolme(int s, int g){ ADIM ADIM ARDUİNO – SENCER ALTUN float tt= s/ 6.0; return tt;

Sayfa 131

float fonksiyonbolme(int s, int g) {

// 14. KOD SATIRI

float tt= s/ 6.0;

// 15. KOD SATIRI

return tt;

// 16. KOD SATIRI

} void setup(){ Serial.begin(9600);

// 17. KOD SATIRI

} void loop(){ int a=5;

// 18. KOD SATIRI

int b=6;

// 19. KOD SATIRI

toplam = fonksiyonarti(a,b);

// 20. KOD SATIRI

cikarma = fonksiyoneksi(a,b);

// 21. KOD SATIRI

carpma = fonksiyoncarpma(a,b);

// 22. KOD SATIRI

bolme = fonksiyonbolme(a,b);

// 23. KOD SATIRI


// 24. KOD SATIRI


// 25. KOD SATIRI

Serial.print("cikarma=");

// 26. KOD SATIRI

Serial.println(cikarma);

// 27. KOD SATIRI

Serial.print("carpma=");

// 28. KOD SATIRI

Serial.println(carpma);

// 29. KOD SATIRI

Serial.print("bolme=");

// 30. KOD SATIRI

Serial.println(bolme);

// 31. KOD SATIRI

while(1);

// 32. KOD SATIRI

}


Sayfa 132



18. ve 19. Kod satırında “int a ve int b”yi tanımladık ve onlar artık local değişken oldu. Fonksiyon çağırırken ona vereceğimiz parametre değişkenleri en yukarıda ”global” tanımlanmasına gerek yok. Local değişkenleride fonksiyonlara parametre olarak verebiliriz. Bu kod satırında da onu yaptık.



20. ve 23. Kod satır aralığında dört tane değişkenimiz var ve bunları en yukarıda int veri tipin’de tanımdadık. 20. ve 23. Kod satırlarında fonksiyon isimlerimizi tanımladık.



Gördüğünüz gibi 5,8,11,14. Kod satırlarında 4 adet fonksiyon tanımladık.



Hatırlatma olarak 18. ve 19. Kod satırlarındaki a ve b değişken isimlerini 5,8,11,14. kod satırlarında fonksiyon içine kendi parametremizi çağırabiliyoruz. Çünkü void loop kısmında bir fonksiyon çağırdığımız zaman, parametre kullanarak bu parametrenin kendisi değil parametrenin değeri, değişkenlerin değerleri gidiyor. 5,8,11,14. Kod satırlarında fonksiyon parametrelerinde “int k, int s “vs. bunların hiçbir önemi yok.(s, k, ksl, l ,vs bu harflerin).



14. Kod satırında bölme işleminde çıkan sonucunda float veri tipinde olması için yeni sayıdan sonra noktalı kısmın olması için(6.0), küsüratlı çıkmasını istiyorsak yapmamız gereken 3 değişkenden en az 1 tanesini float tanımlamamız gerekiyor. Yani sonuç, bölen ve bölünen’in sonuçtan sonra en az 1 tanesini float olarak tanımlanması gerekiyor. Burada bolme değişkeni float olarak tanımlandı.



Küsüratlı sayıyı görelim diye 15. Kod satırında “0.6” olarak tanımladık.


Sayfa 133

22. BÖLÜM MİLLİS – MİCROS – DELAY – DELAYMİCROSECONDS


Sayfa 134

MİLLİS – MİCROS – DELAY – DELAYMİCROSECONDS Bu bölümde zaman fonksiyonlarını inceleyeceğiz. delay, delayMicroseconds, millis, micro.

delay();

Bu komut milisaniye’yi kendine parametre olarak alıyor. Parantez içine yazdığımız değer milisaniye oluyor.(10) =10000 milisaniye (1000)=1 saniye. 35 milisaniye’de yanıp sönen bir led devresi kurduğunuzda, ledin yanıp sönmesini yavaşlattığı için, yavaşlatmaktan kasıt “ledi yaktı ve led 35 milisaniye yanıyor. Ledi söndürüyor ve 35 milisaniye sönük duruyor” yani bekliyor hiçbir şey yapmıyor. Altını çizerek söylüyorum, “Hiçbir şey yapmaması ve beklemesi.”

1000 milisaniye = 1 saniye 10.000 milisaniye = 10 saniye İstediğiniz kadar delay ile bekleme yapabilirsiniz.

delayMicrosaniye();

Bu fonksiyonda parametre değerleri mikronsaniye cinsinde olduğu için ona göre değer vermelisiniz. 1 milisaniyeden daha düşük değerlerde bekleme vermek istiyorsanız, (kurduğunuz bir sistemin, sensörlerinin 100micronsaniye aralıklarla ölçüm yapması), işte bu durumda, 1milisaniyeden daha düşük değerde bekleme yapmak istiyorsanız “delayMicrosecond();” komutunu kullanmanız gerekiyor.

1 saniye = 1000 milisaniye 1 milisaniye = 1000 mikronsaniye void setup() { pinMode(4, OUTPUT); } void loop() { digitalWrite(2, HIGH); delayMicroseconds(35000); digitalWrite(2, LOW); delayMicroseconds(35000); }


Sayfa 135

NOT;

Yukarıdaki program çalışmayacaktır. Çalışacak fakat led yanıp – sönme durumunu göremeyeceksiniz. Nedeni ise “delayMicroseconds()” komutuyla 16383 mikrosaniyeye kadar bekleme yapabilirsiniz. Çünkü tanımlı olduğu değişken ona izin veriyor. Bu yüzden 16383 mikrosaniye’den daha fazla bekleme süresi oluşturmak istiyorsanız delay komutu kullanılır. Böylelikle delayMicroseconds komutunu 16383 sayısından daha büyük değerlerde kullanmıyoruz. Hatırlarsaniz ultrasonic mesafe sensöründe delayMicroseconds komutunu kullanmıştık(park sensörü uygulaması).

millis();

unsigned long simdikizaman; void setup() { Serial.begin(9600); } void loop() { simdikizaman = millis(); Serial.println(simdikizaman); }

NOT;

Yukarıdaki programda, “unsigned long” adında bir değişken oluşturduk. Adını “simdikizaman” diye tanımladık. Bu değişkene “millis()” fonksiyonuyla değer atıyoruz. “millis()” fonksiyonu çalışmaya başladığı andan itibaren Arduino’nun çalıştığı süreyi “simdikizaman” değişkenine aktaracak. Milisaniye cinsinden.

SORU; Yukarıdaki yazdığımız program kayıt edilen süre nereye kadar kayıt edecek? CEVAP; unsigned lond veri tipi’nin değeri kadar.


Sayfa 136



İnternette millis fonksiyonunu araştımaya başladığınızda, hep 50 günde bir sıfırlandığını görürsünüz. Bunun nedeni “unsigned long” ile atadığımızdan dolayı.



Unsigned long’un değeri; 4.294.967.295’e kadar sayabiliyor. Bu sürede 50 gün olarak hesaplanıyor.



Örnek programımızda bu veri tipinin en sonuna geldiği zaman millis fonksiyonu, “simdikizaman” değişkenini sıfırlayacak.

50 GÜNE DENK GELMESİ

1 GÜN = 24 1 SAAT/DAKİKA = 60 1 DAKİKA/SANİYE = 60 KAÇ MİLİSANİYE/DK = 1000 VERİ TİPİ = 4.294.967.295

24 X 60 =1440 X 60 = 86400 X 1000 = 86400000 4.294.967.295 / 86400000 = 49.7 GÜN


Sayfa 137

1 ADET LED 1 ADET 220 VEYA 330 OHM DİRENÇ

const int led =3;

// 1. KOD SATIRI

unsigned long simdikizaman;

// 2. KOD SATIRI

unsigned long oncekizaman;

// 3. KOD SATIRI

int aralik =1000;

// 4. KOD SATIRI

boolean durum = HIGH;

// 5. KOD SATIRI

void setup() { pinMode(led, OUTPUT);

// 6. KOD SATIRI

Serial.begin(9600);

// 7. KOD SATIRI

} void loop() { simdikizaman = millis(); Serial.println(simdikizaman);



Sayfa 138

if(simdikizaman - oncekizaman >= aralik){ oncekizaman = simdikizaman;


if(durum == HIGH)

// 12. KOD SATIRI

durum = LOW;

// 13. KOD SATIRI

else if(durum == LOW)

// 14. KOD SATIRI

durum = HIGH;

// 15. KOD SATIRI

digitalWrite(led, durum);

// 16. KOD SATIRI

} }


Yukarıdaki programda ilk olarak pinleri tanımladık. Led’i 3. Digital pine tanımladık.



Değişkenleri tanımladık.



“int aralik = 1000;” bu kod satırı benim ledimin kaç saniye aralıklarla yanmasını istediğim kısım.



“boolean durum = HIGH;” kod satırında ledin yanıp sönmesini kontrol etmemiz için durum adında değişken tanımladık. Sadece HIGH veya LOW değerleri aldığı için 1Bitlik boolean tipinde tanımladık.



“simdikizaman = milis();” kod satırında millis fonksiyonu saymaya başladı ve tüm verileri “simdikizaman”değişkenine aktardı.



10. Kod satırında if komutu her defasında sağlandıktan sonra güncel olan “simdikizaman” değerini bizim “oncekizaman” değişkenimize atasınki bu algoritma her dündüğünde (simdikizaman – oncekizaman) çıkartma işlemini tekrar yapsın.


Sayfa 139



Bundan dolayıdır ki 11. Kod satırına yazdığımız kod sayesinde, 10. Kod satırında “simdikizaman” 1 oldu oncekizaman 0’dı. 1, 0’dan büyük olduğu için “>=aralik” aralik değeri 1000’di, eğer 1-0’dan büyük veya eşitse 12. Kod satırı çalışıyor.



Sonra 10. Kod satırında “oncekizaman” 0 kaldığı için “simdikzaman” arttığı için 11. Kod satırını yazarak sürekli kontrol ediyoruz.

delay komutu milisaniye cinsinde işlem yapıyorsa, millis komutu milisaniye cinsinden işlem yapıyorsa, delayMicroseconds komutu mikrosaniye cinsinden işlem yapıyorsa, micros komutu’da mikrosaniye cinsinden işlem yapıyor.

micros(); Daha hassas ölçümler için kullanılabilir. Örnek programımızı inceleyelim.

unsigned long simdikizaman;




} void loop() { simdikizaman = micros(); Serial.println(simdikizaman);

// işlem micros cinsinden yapılacak // simdikizaman değişken değeri ekrana yazılacak

}

NOT; “simdikizaman” değişkeni veya bu değerlikli değişkenleri “unsigned long” olarak atamayı unutmayın, çünkü değerler çok hızlı büyüyor. Yukarıdaki programda S. Monitörü açtığımızda program “mikronasiye” cinsinden arttığını göreceğiz. Bu fonksiyonun “micros();”komutunun “delayMicroseconds” gibi 16383 değeri yok. Bu fonksiyonu “unsigned long” değeri dolana kadar kullanabliriz.


Sayfa 140

23. BÖLÜM TEK BOYUTLU DİZİLER (ARRAY)


Sayfa 141

TEK BOYUTLU DİZİLER (ARRAY) DİZİLER;

Belli miktardaki verileri toplu olarak tutmaya yarıyor. Örnek programı

inceleyelim.

int ogrenci1 =01; int ogrenci2 =20; int ogrenci3 =23; int ogrenci4 =45; int ogrenci5 =18; int ogrenci6 =33; int ogrenci7 =62; int ogrenci8 =73; int ogrenci9 =12; int ogrenci10 =86; void setup() {

Serial.begin(9600); } void loop() { Serial.println(ogrenci1); }

NOT;

Yukarıdaki programda int veri tipinde öğrencilerin notları tanımlanmış. Serial monitörde öğrencilerin notunu girmek için “Serial.println(ogrenci1);” yazarak istediğimiz öğrencinin notunu ekranda görebiliyoruz. “ogrenci1” değerine yeni bir atama yapmak için void loop’ta en başa “ogrenci1=100” yazıyoruz ve ilk değerin yerine(01), 100’ü yazıyor. Aşağıdaki programı inceleyelim.


Sayfa 142

int ogrenciler[10] = {10,15,20,25,30,35,40,45,50,55};

void setup() { Serial.begin(9600); } void loop() { Serial.println(ogrenciler[5]); }

NOT; Yukarıdaki programda, serial monitörde 5. öğrencinin notu görülmesi gerekiyor fakat 6. öğrencinin notu görünüyor. Bunun nedeni ise 1’den değil 0’dan başlıyor olması. Bizim dizilerimiz 0’dan başlıyor.

VERİ TİPİ XXX[X] = {X,X,X,X,X,X,X,X}; EN YUKARIYA YAZILIR.

Serial.println( xxx[x]); LOOPA YAZILIR. 

Dizileri tanımlarken veya onlara değer atarken sıkıntı yok ama o dizileri kullanmak için aşağıda çağırırken ki bizde çağırdık. “(ogrenciler[5]);” 0’dan başlıyor.



Aynı şekilde buradada öğrencinin notunu değiştirmek istiyorsak, loop bölümünde en başa “ogrenciler[5]=100;” yazarak varolan notu 100 ile değiştiriyoruz.



Genel olarak dizilerin nasıl kullanıldıklarını öğrenmiş olduk; Diziler bizi fazla satır kod yazmaktan kurtarır.


Sayfa 143

KURALLAR 

Dizinin boyutunu başta belitmesekte olur.

ÖRNEK; int ogrenciler[

] = {50,55,60…};



Bu sefer algoritmamız “{xxxxx};” kaç tane değer vermişsek o kadar yerlik yer açar( [ ] ).



Biz “[ x x x x ];” içerisine 10 tane değer atadıysa otomatik olarak “( [ ] );” boş bıraksak bile dizi kendini 10 atayacak.



Dizi belirtirken mutlaka [ ] boşta olsa köşeli parantez yazılmalıdır aksi taktirde hata vericektir.



Diziye değer vermeyeceksek, diziyi boş bırakırsak “{ x x x }” burada değer belirtmek zorundayız aksi taktirde hata vericektir.

ÖRNEK; “İnt ogrenciler[ ];” Burada hatalı bir kullanım yapıldı, hem değer vermiyorsunuz hemde diziyi belirtmiyorsunuz.

ÖRNEK; “int ogrenciler[10] = {1,2,3,4,5};” Burada dizinin değeri 10, “{ x x x }” süslü parantez içerisine 5 değer atadık. Böyle durumda otomatik olarak, 10 tane yer açtık, 5 değer verdiğimiz için otomatik olarak geriye kalan 5’e sıfır değerleri atanır.


Sayfa 144

int ogrenciler[10] = {1,2,3,4,5};

void setup() { Serial.begin(9600); } void loop() { Serial.println(ogrenciler[8]); }

NOT;

Yukarıdaki programı çalıştırdığımızda, ekrana otomatik olarak sıfır değeri gelecektir. Çünkü 8 olarak bir değer atamadık.

int ogrenciler[10] = {1,2,3,4,5}; int y;

void setup() { Serial.begin(9600); } void loop() { ogrenciler[0] =y; Serial.println(ogrenciler[0]); }

NOT;

Şimdi bu dizilerin değer atamalarına bakalım. Yukarıdaki programda, “int=y;” adında değişken atadık. Biz bu “y” değişkenine istersek diziden bir eleman atayabiliriz.


Sayfa 145

“y = ogrenciler[0];” Bu şekilde y değişkenine 1 değerini atamış olduk.

Aynı şekilde bir değişkene dizinin elemanını atayabiliyorsak bir diziyede farklı bir değişkenin elemanını atayabiliriz.

int ogrenciler[10] = {1,2,3,4,5}; int y =800;

void setup() { Serial.begin(9600); } void loop() { ogrenciler[0] =y; Serial.println(ogrenciler[0]); }

NOT;

“ogrenciler[0]=y;” dersek y’nin ilk değeri 800 olursa 0. Diziye yani ogrenciler[ ] ilk elemanına y değişkeninin değeri 800 ekrana yazılacaktır.



Karakter dizisi oluşturmak istersek, char ile tanımlıyoruz.



Karakter ataması yaparken örneğin {a,b,c,d} gibi yazarsak hata verir. Karakterleri tek tırnak ile tanımlamalıyız. “{‘a’ , ‘b’, ‘c’ , ‘d’};” gibi. Örnek programı inceleyelim.


Sayfa 146

int ogrenciler[10] = {1,2,3,4,5}; char klavye[5] = { 'a' , 'b', 'c' , 'd'};

void setup() { Serial.begin(9600); } void loop() { Serial.println(klavye[3]); }

NOT;

Yukarıdaki programda 3. Karakteri ekrana yazdırırız. 0(sıfır)’dan saymaya başladığımız için “d” harfi ekranda görülecek.

int ogrenciler[10] = {1,2,3,4,5}; char klavye[5] = { 'a' , 'b', 'c' , 'd'}; char fare = 't';

void setup() { Serial.begin(9600); } void loop() { klavye[1] = fare; Serial.println(klavye[1]); }


Sayfa 147

NOT;

Burada “fare”nin değeri olan ‘t’ harfi kavyedeki b’nin yerine yazacaktır. Bu şekilde birçok uygulamada bu dizileri kullanabilirsiniz.( Eğer kopyalayarak arduino programında çalışacaksınız, programda ‘a’ gibi işlemleri silip tekrar tanımlayınız.)

FOR DÖNGÜSÜ İLE NOTLARI TEK TEK EKRANA GİRME

int ogrenciler[10] = {15,25,35,45,55,65,67,43,49,37};

// 1. Kod satırı


// 2. Kod satırı

} void loop() { for(int i =0 ; i<10 ; i++){

// 3. Kod satırı

Serial.print("ogrenci");

// 4. Kod satırı

Serial.print(i);

// 5. Kod satırı

Serial.print(" = ");

// 6. Kod satırı

Serial.println(ogrenciler[i]); delay(500);

// 7. Kod satırı // 8. Kod satırı

} while(1);

// 9. Kod satırı

}

NOT;

İlk olarak 4. Kod satırındaki gibi “ogrenci”yi ekrana yazdırıyoruz. Daha sonra 5. Kod satırındaki gibi “ogrenci”nin numarasını yazdıracağız. “( i ilk başta 0’dan başlıyor, “ogrenci0”ın değerini ekrana yazdırıyor, sonra for döngüsü 1 tur atıyor “i”nin değeri 1 oluyor. Bu böyle gidiyor. )” 5. Kod satırında “i”yi yazdık ve “ogrenci”nin hangi “ogrenci” olduğunu ekranda numarasıyla gösteriyor. Bu diziler gibi daha birçok dizi bilgilerini ekrana yazdırabilirsiniz.


Sayfa 148

24. BÖLÜM ÇİFT BOYUTLU DİZİLER(ARRAY)


Sayfa 149

ÇİFT BOYUTLU DİZİLER(ARRAY)

int ogrenciler[ 5 ] = { 12,21,33,42,95}; (tek boyutlu dizi)

12

21

0

1

33

42

95

2

3

4

ogrenciler adlı dizimiz.

ÇİFT BOYUTLU DİZİLER; int ogrenciler [ 2 ] [ 2 ] = { 51,12}; { 12, 12 };

5 0

3

9 1

9

Bu şekilde çift boyutlu dizilere değer ataması yaparken { } süslü parantez altına aynı şekilde “{ 12, 12 };” yazıyoruz ve değerleri giriyoruz.

6

0

1

Bizim dizimiz 2,2 boyutundaydı. İlk 2, bizim satır bilgimiz, ikinci 2 ise sütun bilgisidir.

2,2 SATIR

SATIR

SÜTUN

9 9 SÜTUN


Sayfa 150

ÖRNEK; int ogrenciler[3] [5] = {{13,12,11,10,9} , {1,2,3,4,5} , {2,12,33,44,63}};

0

1

2

3 4

0

13

12

11

10

9

1

1

92

3

94

95

2

2

12 9

33

944 963

9

9

Örnek kodda dikkat edilmesi gereken dizi değerleri tanımlarken (,) virgülleri ve en son ( { } ) süslü parantez içine almayı unutmayın. Gelin Bu örneğimizi örnek program ile pekiştirelim.

9

int ogrenciler [3] [5] = {{1,2,3,4,5} , {6,7,8,9,10} , {11,12,13,14,15}};

void setup() { Serial.begin(9600); } void loop() { Serial.println(ogrenciler [1] [3]); }

0 1

2

3

4

0

1

2

3

4

5

1

6

97

8

99

910

2

11

12 9

13

914 915

9

9

Yukarıdaki programı çalıştırdığımızda, Serial monitörde “Serial.println(ogrenciler[1][3]);” kodu ile 1. satır 3. sütundan bir sayı gösterecek. Oda 9 sayısı. Herhangi bir dizinin elemanını istediğimiz sayının elemanı ile değiştirebiliriz. Bir önceki dersteki gibi.

9


Sayfa 151

int ogrenciler [3] [5] = {{1,2,3,4,5} , {6,7,8,9,10} , {11,12,13,14,15}};

void setup() { Serial.begin(9600); } void loop() { ogrenciler[0] [1] = 189; Serial.println(ogrenciler [0] [1]); }

Yukarıdaki örnek programımızda 2’nin değerini 189 sayısı ile değiştiriyoruz. ogrenciler[0][1] = 189; DEĞİŞTİRİLECEK

YENİ DEĞER

Ekranı çalıştırdığımızda 189 değerini görüyoruz.

int ogrenciler [3] [5] = {{0 ,1,2,3,4} , {5,6,7,8,9} , {10,11,12,13,14}};

void setup() { Serial.begin(9600); } void loop() { for(int j=0; j<3 ; j++){ for(int i=0; i<5 ; i++) {


Sayfa 152

Serial.print("//"); Serial.print(j); Serial.print(" * "); Serial.print(i); Serial.print("="); Serial.print(ogrenciler [j][i]); delay(500); } Serial.println(); } while(1); }

Bu program sayesinde tabloyu sırasıyla önce satır sonra sütun olacak şekilde ekrana yazdıracağız. “Serial.println();” komutuyla bir alt satıra geçmesini sağlıyoruz.


Sayfa 153

ADIM ADIM ARDUINO.pdf

Recommend Documents