Adim Adim Arduino

“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İ‘ENÇLE‘ ............................................................................................................................................9
POTAN“İYOMET‘E AYA‘LI Dİ‘ENÇ ............................................................................................... 11
BUZZER .......................................................................................................................................... 12
ULT‘A“ONİK ME“AFE “EN“Ö‘Ü HC – SR04) ............................................................................. 12
LM “ICAKLIK “EN“Ö‘Ü ....................................................................................................... 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
A‘DUİNO KA‘AŞİMŞEK UYGULAMA“I .............................................................................................. 24
3-DİGİTAL PİNLERİ GİRİŞ OLARAK KULLANMA..................................................................................... 26
A‘DUİNO LED-BUTON UYGULAMASI ................................................................................................ 27
4-İF – ELSE KOMUTUNU KULLANMAK.................................................................................................. 29
A‘DUİNO BUTON - KA‘AŞİMŞEK UYGULAMA“I................................................................................ 30
5-SERİAL MONİTÖR VE DEBUGGİNG .................................................................................................... 34
6-DEĞİŞKEN TANIMLAMA VE VERİ TİPLERİ ..................................................................................... 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
A‘DUİNO İLE DÖ‘T İŞLEM .............................................................................................................. 48
KALAN BULMA............................................................................................................................... 49
KAREKÖK BULMA ....................................................................................................................... 50
MUTLAK DEĞE‘ ...................................................................................................................... 50
10-DEĞİŞKEN ÖMÜRLERİ, KARŞILAŞTIRMA VE MANTIK İFADELERİ .................................................... 51
DEĞİŞKEN TANIMLAMA ..................................................................................................................... 52
KA‘ŞILAŞTI‘MA.............................................................................................................................. 54
MANTIK İFADELE‘İ ....................................................................................................................... 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
FO‘ İLE KULLANIM............................................................................................................................. 85
WHİLE İLE KULLANIM ...................................................................................................................... 86
16- ANALOG GİRİŞ VE BİT ADC ......................................................................................................... 91
POTAN“İYOMET‘E İLE GELEN BİLGİYİ OKUMA ................................................................................. 92
UYGULAMA ARDUİNO İLE LM35 KULLANIMI ..................................................................................... 95
‘GB LED HAKKINDA BİLİNME“İ GE‘EKENLE‘.................................................................................. 103
17- ANALOG ÇIKIŞ – PWM .................................................................................................................. 106
ANALOG ÇIKIŞ .................................................................................................................................. 107
PWM NEDİ‘................................................................................................................................... 110
DİGİTAL “İNYAL .......................................................................................................................... 111

ANALOG “İNYAL ................................................................................................................... 111
ANALOG “İNYALLE‘ İLE ‘GB LED ...................................................................................... 112
18- FONKSİYONLAR -1- ....................................................................................................................... 113
PA‘AMET‘E ALMAYAN VE DEĞE‘ DÖNDÜ‘MEYEN FONK“İYONLA‘............................................. 114
19- FONKSİYONLAR -2- ....................................................................................................................... 118
PA‘AMET‘E ALMAYAN VE DEĞE‘ DÖNDÜ‘EN FONK“İYONLA‘ .................................................... 119
20- FONKSİYONLAR -3- ....................................................................................................................... 125
PA‘AMET‘E ALAN VE DEĞE‘ DÖNDÜ‘MEYEN FONK“İYONLA‘ .................................................... 126
HE“AP MAKİNE“İ UYGULAMA“I ................................................................................................... 128
21- FONKSİYONLAR -4- ....................................................................................................................... 131
PA‘AMET‘E ALAN VE DEĞE‘ DÖNDÜ‘EN FONK“İYONLA‘............................................................ 132
22- MİLLİS – MİCROS – DELAY – DELAYMİCROSECONDS................................................................... 135
delay(); ............................................................................................................................................. 136
delayMicrosaniye(); .................................................................................................................... 136
millis(); ..................................................................................................................................... 137
micros(); ............................................................................................................................... 141
23- TEK BOYUTLU Dİ)İLER ARRAY .................................................................................................... 142
Dİ)İLE‘ ............................................................................................................................................. 143
24- ÇİFT BOYUTLU Dİ)İLER ARRAY .................................................................................................... 150
ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 6

TEMEL ELEKTRONİK

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.

İ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.

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 potansiyometrenin Uluslararası ve

Amerikan Sembollerini görmektesiniz.

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.

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 (400-
700mm) 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.

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;

ARDUİNO NEDİR

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.

ARDUİNO İDE PROGRAMINA GİRİŞ

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).

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.

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

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.

void setup() {
pinMode(13, OUTPUT); // .Pi i çıkış pi i atadık.
void loop() {
digitalWrite(13, HIGH); // . Ba ağa güç er, ledi ak.
delay(1000); // 1 saniye bekle.
digitalWrite(13, LOW); // . Ba ağı sö dü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.

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

KULLANMAK

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); // . pi i izi çıkış olarak ta ı ladık.
void loop() {
digitalWrite(2, HIGH); // 2. pinimize lojik- değeri i atadık. + V
delay(500); // 500mS bekle. 500x10-3 = 0.5sn
digitalWrite(2, LOW); // 2. pinimize lojik- değeri i atadık. + V


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

KULLANMAK

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; // uto duru u adı da değişke ta ı ladık.
void setup(){
pinMode(led, OUTPUT); // led pi i çıkış olarak atadık.
pinMode(buton, INPUT); // uto pi i giriş olarak atadık.

void loop(){
butondurumu=digitalRead(buton); // Buto u asılıp asıl adığı ı uto duru u a ata.
if(butondurumu == HIGH) // Eğer uto duru u HIGH ise aşağıdaki kodu işle.
digitalWrite(led, HIGH); // Led(4) pini yak.
else // değilse ukarı. if sağla ı orsa aşağıdaki kodu işle.
digitalWrite(led, LOW); // Buto a asıl ı orsa ledi sö dür.
digitalRead(bilgi alınacak olan pin); okumak, bilgi almak.
İf(değişken ismi == HIGH- LOW) 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);

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

İ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.

int but1 = 2; // 2. Pine but1 dedik.
int but4 = 5 // 5. Pine but4 dedik.
int led1 = 8; // 8. Pine led1 dedik.
int b1d; // uto duru u değişke is i atadık.
void setup(){
pinMode(but1, INPUT); // . ut pi i giriş olarak atadık.
pinMode(led1 , OUTPUT); // . led pi i çıkış olarak atadık.
pinMode(led2 , OUTPUT); // . led pi i çıkış olarak atadık.
pinMode(LED3 , OUTPUT); // . led pi i çıkış olarak atadık.
void loop(){
b1d = digitalRead(but1); // digitalRead komutuyla but1 duru u u d e atadık.
b2d = digitalRead(but2); // digital‘ead ko utu la ut duru u u d e atadık.

if(b1d == HIGH) // Eğer . Buto a asılırsa ir alttaki kodu işle e al.
digitalWrite(led1, HIGH); // eğer . Buto a asılırsa ledi ak.
else if (b2d == HIGH){ // sade e . Buto a asıldı sa {---} arası daki kodu işle e al.
digitalWrite(led1, HIGH); // uto a asıldı sa . Ledi ak.
else if(b3d == HIGH){ // sade e . Buto a asıldığı da {---} arası daki kodu işle.
else if (b4d == HIGH){ // sade e . Buto a asıldığı da {---} arası daki kodu işle.
delay(250); // 250 ms bekle.
digitalWrite(led1, LOW); // uto a asıldı sa . Ledi sü dür.
delay(250); // 250 ms bekle.
digitalWrite(led2, LOW); // uto a asıldı sa . Ledi sö dür.
else { // eğer hiç iri değilse {----} arası daki kodu işle e al.
digitalWrite(led1, LOW); // . Ledi sö dür

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

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

SERİAL MONİTÖR VE DEBUGGİNG
void setup() {
Serial.begin(9600); // “eri ha erleş e i hızı ı elirli or.
void loop() {
Serial.println("merhaba dunya"); //ekra a para tez içi deki ifade i az.
Serial.println("Sencer Altun"); //ekra a para tez içi deki ifade i az.
delay(1000); // u işle i ilisa i e sa i e de ap.
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ı.

int but1 = 2; // . Pi i ut di e atadık.
int led1 = 5; // . Pi i led di e atadık.
int led2 = 6; //6. Pini led di e atadık.
int led3 = 7; // . Pi i led di e atadık.
int b1d; // uto duru u değişke i atadık.
void setup() {
pinMode(but1, INPUT); // ut i giriş olarak a arladık.
pinMode(led1, OUTPUT); //led i çıkış olarak a arladık.
Serial.begin(9600); //“erial o itörü kulla a ağız.
void loop() {
b1d = digitalRead(but1); // ut i HIGH e a LOW duru u u d a ata.

if(b1d == HIGH){ //eğer d HIGH ise led i ak.
digitalWrite(led1, HIGH); //led i ak.
Serial.println("birinci butona basildi"); // uto a asıldı la “. o itörde göster.
delay(600); // u işle i s de ap.
else if (b2d == HIGH){ //eğer d HIGH ise led e led i ak.
Serial.println("ikinci butona basildi"); // uto a asıldı la “. o itörde göster.
else if(b3d == HIGH){ //eğer d HIGH ise tü ü ü ak.
Serial.println("ucuncu butona basildi"); // uto a asıldı la “. o itörde göster.
else { //eğer hiç iri değilse { } arası ı işle e al.
digitalWrite(led1, LOW); //led i sö dür.
Serial.println("hicbir butona basilmiyor.."); //butona asıl adı la “. o itörde göster.
İnt x = x ; İnteger anlamına geliyor. Tamsayı. İlerleyen konularda değinilecektir.

6. BÖLÜM
DEĞİŞKEN TANIMLAMA VE VERİ

TİPLERİ(1)

DEĞİŞKEN TANIMLAMA VE VERİ TİPLERİ(1)
int a = 1453; // a değişke i i değeri
void setup() {
Serial.begin(9600); // serial o itör kulla ıla ak
void loop() {
Serial.println(a); // a değişke i i değeri i ekra a az
VERİ TİPİ BOYUT(BAYT) KULLANILDIĞI İÇERİK

ARALIK
int 2 bayt -32768 <->+32767 TAM SAYILAR
Unsigned int 2 bayt 0 <-> 65535 POZİTİF SAYILAR
long 4 bayt -2147485648 <-> ÇOK BÜYÜK TAM
+2147485647 SAYILAR
Unsigned long 4 bayt 0<-> 4294967295 ÇOK BÜYÜK POZİTİF
TAM SAYILAR
char 1 bayt Tek bir karakter TEK BİR KARAKTER
byte 1 bayt 0-255 O İLE 255 ARASI
TAMSAYI
float 4 bayt -3.4028235E+38 <- ONDALIK SAYILAR
> +3.4028235E+37
double 4 bayt -3.4028235E+38 <- FLOAT İLE AYNI
> +3.4028235E+38
boalean 1 bayt TRUE(1) , FALSE(0) 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.

7. BÖLÜM
DEĞİŞKEN TANIMLAMA VE VERİ

TİPLERİ(2)

DEĞİŞKEN TANIMLAMA VE VERİ TİPLERİ(2)
float pi_sayisi = 3.14; // o dalıklı sa ı ı pi_sa isi değişke i e atadık
void setup() {
void loop() {
Serial.println(pi_sayisi); // pi_sa isi değişke i i değeri ekra da azıla ak .
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 eri tipi de k değeri i karakter değişke e atadık
void setup() {
Serial.begin(9600); // “erial o itör kulla ıla ak
void loop() {
Serial.println(karakter); // karakter değişke i i değeri i o itö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.)

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

KULLANIMI

CONST VE DEFİNE İFADELERİNİN KULLANIMI
int sayac = 0; // i t eri tipi de sa ı atadık e o u sa a değişke i e atadık
void setup() {
void loop() {
sayac = sayac+1; // sa a değişke i i her seferi de artır
Serial.print("sayac="); // ekra a sa a ı azdır
Serial.println(sayac); // ekrana sayac değişke i i değeri i azdır
Serial.println("---------"); // ekra a azdır
delay(1000); // her defası da u işle s sürsü sa i e
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İ

const int buton =3; // const ile int tipinide 3 pi i i uto değişke i e atadık
int sayac = 32000; // i t eri tipi de sa a adlı değişke atadık e değeri
void setup() {
void loop() {
digitalRead(buton); // uto değeri i oku
buton = 7; // 7. Pini uto olarak atadık
Serial.print("sayac="); // ekra a sa a keli esi i azdır
Serial.println(sayac); // ekra a sa a değişke i i değeri i azdır
Serial.println("---------"); // ekra a azdır
sayac=1; // sa a değişke i e 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.

char krt1 = 'A'; // tek tip ir karakter ata dı
char krt2 = 'R'; // tek tip ir karakter ata dı
char krt3 = 'D'; // tek tip ir karakter ata dı
char krt4 = 'U'; // tek tip ir karakter ata dı
char krt5 = 'I'; // tek tip ir karakter ata dı
char krt6 = 'N'; // tek tip ir karakter ata dı
char krt7 = 'O'; // tek tip ir karakter ata dı
#define bek_sure 1000 // defi e ile değişke atadık e suresi i erdik
void setup() {
void loop() {
Serial.println(krt1); // krt değeri i ekra a az
delay(bek_sure); // ukarıda elirtile sure kadar ekle
delay(bek_sure); // ukarıda belirtilen sure kadar bekle
Serial.println(krt7); // krt değerini ekrana yaz

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İ

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

TEMEL MATEMATİK İŞLEMLERİ
ARDUİNO İLE DÖRT İŞLEM
float x=5; // float tipi de sa ı atadık e o a dedik
int y=3; // i t tipi de sa ı atadık e o a dedik
float sonuc; // float tipinde değişke atadık. Böl e işle i de float kulla ılır
void setup() {
void loop() {
sonuc =x/y; // değişke değeri i e öl
Serial.println(sonuc); // so u değişke i i değeri i ekra a az
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

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; // değeri i değişke i e atadık
int y=5; // değeri i değişke i e atadık
float sonuc; // float eri tipi de so u değişle i atadık
void setup() {
void loop() {
sonuc = x%y; // e değerleri de kala ı ere kod
Serial.println(sonuc); // so u değişle i i değeri i ekra a göster
Serial.println("----------"); // ekrana yaz
delay(1000); // u işle i s sa i e de ap

KAREKÖK BULMA
int x=6; // değeri i değişke i e atadık
int y=5; // değeri i değişke i e atadık
float sonuc; // float veri tipi de so u değişle i atadık
void setup() {
void loop() {
sonuc = sqrt(y); // sqrt karekök o u ö ü deki ifade i karekökü alır
Serial.println(sonuc); // so u değişle i i değeri i ekra da göster
Serial.println("----------"); // ekrana yaz
delay(1000); // u işle i s sa i e de ap
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ı);

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

DEĞİŞKEN ÖMÜRLERİ , KARŞILAŞTIRMA VE MANTIK
İFADELERİ
DEĞİŞKEN TANIMLAMA
int x=5; // sa ısı ı değişke i e ata
int y=6; // sa ısı ı değişke i e ata
void setup() {
int z=8; // sade e oid setup ölü ü de geçerli i t .tipi de sa ı ta ı la dı
void loop() {
int k=4; // sa ısı ı k değişke i e ata
Serial.println("x="); // “erial ekra a paraztez içi deki ifade i az
Serial.println(x); // “erial ekra a değişke i i değeri i az
Serial.println("----------"); // “erial ekra a paraztez içi deki ifade i az
Serial.println("z="); // “erial ekra a paraztez içi deki ifade i yaz
Serial.println(z); // “erial ekra a değişke i i değeri i az
Serial.println("k="); // “erial ekra a paraztez içi deki ifade i az
Serial.println(k); // “erial ekra a değişke i i değeri i az
delay(500); // 500ms bekle

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; // i t eri tipi de sade e u ölü de geçerli
pinMode(led, OUTPUT); // led değişke i i çıkış olarak atadık
void loop() {
digitalWrite(13, HIGH); // 13. Pine (5v) HIGH dedik
delay(1000); // 1000ms(1saniye) bekle
digitalWrite(13, LOW); // 13. Pine (0v) LOW dedik

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; // değeri i değişke i e ka det
int y =15; // 15 değeri i y değişke i e ka det
boolean kayit; // oolea eri tipi de değişke atadık
void setup() {
void loop() {
if(x>y) // eper , de ü ükse aşağıdaki kodu işle
kayit=1; // ka it değişke i olsu
else // değilse aşağıdaki kodu işle
kayit=0; // ka it değişke i olsu
Serial.println(kayit); // ka it değişke i i değeri i ekra da 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.

MANTIK İFADELERİ
VE (AND)
1.İFADE 2.İFADE SONUÇ
0 0 0
0 1 0
1 0 0
1 1 1
VEYA (OR)
1.İFADE 2.İFADE SONUÇ
0 1 1
1 0 1
1 1 1
0 0 0
DEĞİL(NOT)
1.İFADE 2.İFADE
1 0
0 1
Ve “&&”
Veya “||”
int a=10; // i t eri tipi de değeri e a değişke i i atadık
int b=10; // i t eri tipi de değeri e değişke i i atadık
int c=20; // i t eri tipi de değeri e değişke i i atadık
int d=30; // i t eri tipi de değeri e d değişke i i atadık
int sonuc; // int veri tipi de so u değişke i atadık
void setup() {

void loop() {
if((a==b)&&(c==d)) // eğer a, e e , d e eşitse çalıştır
sonuc=1; // ukarıdaki duru sağla ı orsa u kodu işle
else if ((a!=b)&&(d<c)) // değilse eğer, a, e eşit değilse e d, de küçükse
else if ((a==b)&&(d<c)) // değilse eğer, a, e eşitse e d, de küçükse
else if ((a==b)||(d==c)) // değilse eğer, a, e eşitse e a d, e eşitse
else if ((a==b)||(c<=d)) // d. e. , a, e eşitse e a , d de ü ükse e a eşitse
else if ((a<b)||(a>b)) // değilse eğer, a, de küçükse veya a, b de ü ükse

else // ukarıdakiler hari i de herşe
Serial.println(sonuc); // so u değişke i i değeri i ekra da göster

UYGULAMA
PARK SENSÖRÜ

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; // .pi trig olarak ata dı
const int echo =12; // 12.pin echo olarak ata dı
const int buzzer =2; // 2.pin buzzer olarak ata dı
const int mled =3; // 3.pin mled olarak ata dı
const int yled =4; // 4. Pin yled olarak ata dı
const int sled =5; // 5. Pin sled olarak ata dı
const int kled =6; // 6.pin kled olarak ata dı
int sure; // i t eri tipi de sure değişke i ata dı
int mesafe; // i t eri tipi de esafe değişke i ata dı

void setup() {
pinMode(kled, OUTPUT); // ledler çıkış olarak ata dı
pinMode(sled, OUTPUT); // ledler çıkış olarak ata dı
pinMode(yled, OUTPUT); // ledler çıkış olarak ata dı
pinMode(mled, OUTPUT); // ledler çıkış olarak ata dı
pinMode(buzzer, OUTPUT); // buzzer çıkış olarak ata dı
pinMode(echo, INPUT); // se sörü e ho pi i çıkış olarak ata dı
pinMode(trig, OUTPUT); // se sörü trig pi i çıkış olarak ata dı
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); // ata a gerçekleştirdık.
mesafe =(sure/2) / 28.5; // se sör içi gereke kod
if(mesafe <=10){ // eğer esafe sa i e e eşit e a küçükse
digitalWrite(kled, HIGH); // kled i ak
digitalWrite(buzzer, HIGH); // uzzer i çalıştır
delay(250); // 250 ms bekle
digitalWrite(kled, LOW); // kled i sö dür
digitalWrite(buzzer, LOW); // uzzer i durdur
delay(250); } // 250ms bekle

else if(mesafe <=25){ // değilse eğer esafe e eşit e a küçükse
digitalWrite(sled, HIGH); // sled i ak
digitalWrite(sled, LOW); // sled i sö dür
else if(mesafe <=50){ // değilse eğer esafe 50 e eşit e a küçükse
digitalWrite(yled, HIGH); // sled i ak
digitalWrite(yled, LOW); // sled i sö dür
else { // hiç iri değilse aşağıdaki kodu çalıştır
digitalWrite(mled, HIGH); // led i ak
digitalWrite(mled, LOW); // led i sö dür
delay(1000); } // 1000ms(1saniye) bekle
NOT; “sure=pulseIn echo, HIGH ;” pulseIn komutu ile echo pininin 5V-0V durumunu sure
değişke i e ata a aptık.

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

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 ı değeri olarak ata dı
void setup(){
void loop(){
Serial.println(a); // a ı değeri i ekra a az
while(a<50) // a, de küçükse çalıştır
Serial.println("While dongusu calisiyor"); // hile koşulu sağla ı orsa ekra a az

int a=0; // a değişke i i değeri i olarak atadık
void setup(){
void loop(){
while (a<50) // a, de küçükse hile dö güsü ü çalıştır
a = a+1; // a değişke i i her defası da arttır
Serial.println(a); // a değişke i i değeri i ekra a azdır
Serial.println("While dongusu calisiyor"); // ekra a azdı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şke i i değeri i olarak atadık
void setup(){
void loop(){
while (a<=50) // a, de küçük e a eşitse dö gü ü çalıştır
a = a+1; // a değişke i i her defası da arttır

Serial.println("While dongusu calisiyor"); // ekra a azdır
Serial.println("donguden ciktik"); // ekra a azdır
while(1); // tü işle i kere ap
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Ç

const int buton =3; // . Pi e uto değişke i is i i erdik
int durum; // duru değişke i atadık
void setup(){
pinMode(buton, INPUT); // uto u giriş olarak atadık
pinMode(5, OUTPUT); // . Pi i çıkış olarak atadık
void loop(){
durum=digitalRead(buton); // uto a asılıp asıl a a ilgisi i duru a ata
while(durum == HIGH) // uto a asılırsa dö gü ü çalıştır
digitalWrite(5, HIGH); // 5. Pine HIGH(5V) dedik
digitalWrite(5, LOW); // 5. Pine LOW(0V) dedik
Serial.println("butona basilmiyor"); // uto a asıl azsa ekra a az
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.

const int buton =3; // . Pi e uto değişke i is i i erdik
void setup(){
pinMode(buton, INPUT); // uto u giriş olarak atadık
pinMode(5, OUTPUT); // . Pi i çıkış olarak atadık
void loop(){
durum=digitalRead(buton); // uto a asılıp asıl a a ilgisi i duru a ata
while(durum == HIGH) // uto a asılırsa dö gü ü çalıştır
digitalWrite(5, HIGH); // 5. Pine HIGH(5V) dedik
digitalWrite(5, LOW); // 5. Pine LOW(0V) dedik
durum = digitalRead(buton); // uto u ko trol et asıl a a de a edi or u?
Serial.println("butona basilmiyor"); // uto a asıl azsa ekra a az
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.

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

DO WHİLE DÖNGÜSÜ
Do while döngüsü mutlaka bir kere çalışır.
do
{
Kodlar
}
while(koşul)
int a=0; // değeri i a değişke i e atadık
void setup(){
void loop(){
do{ // do dö güsü e her seferi de kez girer
a=a+1; // a değişke i i attır
Serial.println("dongu calisiyor"); // ekrana yaz
while(a<50); // a, de küçük ü ko trol et
Serial.println("dongoden cikildi."); // hile koşulu sağla azsa u u ap

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; // değeri i a değişke i e atadık
void setup(){
void loop(){
Serial.println("loop basliyor"); // ekrana yaz
do { // do dö güsü e her seferi de kez
a=a+1; // a değişke i i attır
if( a ==49) // eğer a, a eşitse if i çalıştır
a=1; // a i ata
Serial.println("dongu calisiyor"); // ekrana yaz

while(a<50); // a, de küçükse hile dö güsü ü çalıştır
Serial.println("donguden cikildi"); // ekrana yaz
Serial.println("loop dongusu bitti"); // ekrana yaz
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.

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

SWİTCH CASE YAPISI
3 adet 10K Direnç

1 adet switch
2 adet buton
const int arttir =3; // . Pi e arttir değişke is i ta ı ladık
const int azalt =4; // 4. Pine azalt değişke is i ta ı ladık
const int dongu =2; // 2. Pine dongu(switch) değişke is i ta ı ladık
int durum_arttir; // değişke ta ı ladık
int durum_azalt; // değişke ta ı ladık
int durum_dongu; // değişke ta ı ladık
int sayac=0; // değişke ta ı ladık
void setup() {
pinMode(arttir, INPUT); // uto ları giriş olarak atadık
pinMode(azalt, INPUT); // uto ları giriş olarak atadık
pinMode(dongu, INPUT); // s it h i giriş olarak atadık

void loop() {
durum_dongu=digitalRead(dongu); // do gu değişke i i ata a aptı
while(durum_dongu == HIGH) // do gu s i th da ise çalıştır
durum_arttir=digitalRead(arttir); // arttir değişke i i ata a aptı
durum_azalt=digitalRead(azalt); // azalt değişke i i ata a aptı
if(durum_arttir == HIGH){ // eğer arttır a uto u a asılırsa if i işle
sayac++; // sa a değişke i i arttır
Serial.println("sayac="); // ekrana yaz
Serial.println(sayac); // sa a değişke i i değeri i ekra a az
else if(durum_azalt == HIGH){ // değilse eğer azalt uto u a asıldı sa
sayac--; // sa a değişke i i azalt
durum_dongu=digitalRead(dongu); // s it h açak ı kapalı ı ko trol 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.

ÖRNEK PROGRAM (SWİTCH CASE YAPISI)
void loop() {
durum_dongu=digitalRead(dongu); // do gu değişke i i ata a aptı
while(durum_dongu == HIGH) // do gu s i th da ise çalıştır
durum_arttir=digitalRead(arttir); // arttir değişke i i ata a aptı
durum_azalt=digitalRead(azalt); // azalt değişke i i ata a aptı
if(durum_arttir == HIGH){ // eğer arttır a uto u a asılırsa if i işle
sayac++; // sa a değişke i i arttır
Serial.println(sayac); // saya değişke i i değeri i ekra a az
else if(durum_azalt == HIGH){ // değilse eğer azalt uto u a asıldı sa
sayac--; // sa a değişke i i azalt
durum_dongu=digitalRead(dongu); // s it h açak ı kapalı ı ko trol et

switch(sayac) // s it h sa a değişke i i işler
case 1: // .değer oku ak iste irse
Serial.println("1. motor calisiyor"); // ekra a azdır
break; // aşa dö
case 2: // .değer oku ak istenirse
break; // aşa dö
break; // aşa dö
break; // aşa dö
default: // ukarıdakiler dışı da herşe
Serial.println("yanlis deger girildi"); // ekra a azdır
break; // aşa dö

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:

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.

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

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şke i ata dı
void setup() {
void loop() {
for(int b=0; b<10 ; b++) // da aşla a ak a kadar, arttıra ak
Serial.println("b="); // ekra a azdır
Serial.println(b); // değişke i i değeri i ekra a azdır
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.

FOR DÖNGÜSÜ İLE KARAŞİMŞEK UYGULAMASI
6 adet led
220 veya 330 OHM direnç 6 adet
void setup() {
pinMode(2, OUTPUT); // led pi leri çıkış olarak ata dı

void loop() {
for(int b=2; b<8 ; b++){ // de , e kadar irer irer arttır
digitalWrite(b, HIGH); // e V er ledi ak
digitalWrite(b, LOW); // e V er ledi sö dür
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.
void setup() {

void loop() {
digitalWrite(b, HIGH); // e V er ledi ak
digitalWrite(b, LOW); // e V er ledi sö dür
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++;
}

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

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ç
void setup() {
pinMode(8, INPUT); // . Pi i uto olduğu içi giriş olarak atadık
void loop() {
for(int b=0; b<20 ; b++) { // değişke i i e kadar irer irer arttır
Serial.println(b); // değişke i i değeri i ekra da göster

durum=digitalRead(b); // değişke i i duru değişke i e ata
if (durum== HIGH) // if koşulu sağla ı orsa e a uto a asılırsa
break; // durdur
Serial.println("donguden cikildi"); // ekra a azdı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
void setup() {
pinMode(8, INPUT); // . Pi i uto olduğu içi giriş olarak atadık
void loop() {
for(int b=0; b<20 ; b++) { // değişke i i e kadar irer irer arttır
Serial.println(b); // değişke i i değeri i ekra da göster
if (b == 10) // eğer a gelirse aşağıdaki kodu işle

{
break; // durdur
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; // duru değişke i ata dı
int b=0; // değeri değişke i e ata dı
void setup() {
pinMode(8, INPUT); // . Pi uto olduğu içi giriş olarak ata dı
void loop() {
while(1) // de aşla a ak
b++; // irer irer değişke i i değeri i arttıra ak
Serial.println(b); // değişke i i değeri i ekra a az
durum = digitalRead(8); // .pi i değeri i duru değişke i e ata

if(durum == HIGH) { // uto a asılırsa alt kodu işle
break; // durdur
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.
void setup() {
Serial.begin(9600); // “erial o itör kulla ıldı
void loop() {
for(int a=0; a<20 ; a++) { // a ı değeri i e kadar irer irer artır
if(a==6) { // eğer raka ı a geli e
continue; // raka ı ı atla
Serial.println(a); // ekra a a değişke i i değeri i az

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ç
void setup() {
pinMode(8, INPUT); // . Pi i giriş olarak atadık
void loop() {
for(int a=0; a<60 ; a++) // a, a kadar irer irer arta ak
{ durum = digitalRead(8); // değeri i duru değişke i e ata a aptık
if(durum == HIGH) // uto a asılırsa aşağıdaki kodu işle

continue; // atla a aptı
Serial.println(a); // a değişke değeri i ekra a az
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 a=0; // a değişke i i değeri oldu
void setup() {
pinMode(8, INPUT); // . Pi i giriş olarak atadık
void loop() {
while(1) { // de aşla a ak
a++; // i t değeri kadar irer irer artacak
durum =digitalRead(8); // değeri i duru değişke i e ata a aptık
if (durum == HIGH) { // if koşulu sağla ı orsa aşağıdaki kodu işle
continue; // atlama yap

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.

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

ANALOG GİRİŞ VE 10BİT ADC
POTANSİYOMETRE İLE GELEN BİLGİYİ OKUMA
1 ADET POTANSİYOMETRE(100K)
int gelen_veri; // gele eri adı da değişke ta ı la dı
void setup() {
void loop() {
gelen_veri=analogRead(A0); // A değeri i gele _ eri değişke i e ata a aptı
Serial.println(gelen_veri); // gele _ eri değeri ekra a azıldı
delay(250); // 250ms bekledi

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 2 2 2 2 2 2 2 2
1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0 1,0
2 4 8 16 32 64 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

ANALOG PİNE KAÇ VOLT GELDİĞİNİ BULAN PROGRAM
const int pot_pin=A0; // A a pot_pi değişke is i erdik
int okunan_deger; // değişke ta ı ladık
float voltaj; // float tipi de değişke ta ı ladık
void setup() {
void loop() {
okunan_deger=analogRead(pot_pin); // oku a değer e ata a ap
Serial.print("okunan_deger"); // ekra a azdır
Serial.println(okunan_deger); // değişke i değeri i ekra a azdır
Serial.print("voltaj="); // ekrana yazdır
Serial.println((okunan_deger *5)/1023.0); // değeri az
VOLTAJ DEĞERİNİ HESAPLAMA

Gelen değer x 5V 5V =0,0047V =4,8mV
1023 1024
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”

UYGULAMA
ARDUİNO İLE LM35 KULLANIMI

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; // a alog . Pi e değişke is i erdik
const int k_led =5; // . Pi e k_led değişke ismi verdik
const int y_led =4; // . Pi e _led değişke is i erdik
const int m_led=3; // . Pi e _led değişke is i erdik
int sensor_deger =0; // değişke ta ı ladık e değeri erdik
int voltaj_deger =0; // değişke ta ı ladık e değeri erdik
int sicakli_deger =0; // değişke ta ı ladık e değeri erdik

void setup() {
pinMode(k_led, OUTPUT); // ‘GB ledleri si al a akları çıkış olarak ata dı
pinMode(y_led, OUTPUT); // ‘GB ledleri si al a akları çıkış olarak ata dı
pinMode(m_led, OUTPUT); // RGB ledleri si al a akları çıkış olarak ata dı
void loop() {
sensor_deger = analogRead(sensor_pin); // ata a apıla ak
Serial.print("okunan deger="); // ekra a azdır
Serial.println(sensor_deger); // değişke i değeri i ekra a azdır
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.

const int k_led =5; // . Pi e k_led değişke is i erdik
int voltaj_deger =0; // değişke ta ı ladık e değeri erdik
int sicakli_deger =0; // değişke ta ı ladık e değeri verdik
void setup() {
pinMode(m_led, OUTPUT); // ‘GB ledleri si al a akları çıkış olarak ata dı
void loop() {
voltaj_deger =(sensor_deger /1023)/5000; // işle apar
Serial.print("gelen voltaj="); // ekra a azdır
Serial.println(voltaj_deger); // ekra a değişke i değeri i azdır

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.
float voltaj_deger =0; // değişke ta ı ladık e değeri erdik
float sicaklik_deger =0; // değişke ta ı ladık e değeri erdik
void setup() {

void loop() {
sicaklik_deger=voltaj_deger/10.0; // gerekli işle i aptı
Serial.print("sicaklik"); // ekra a azdır
Serial.println(sicaklik_deger); // ekra a değişke i değeri i azdır
Serial.println("derece"); // ekra a azdır
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.

float voltaj_deger =0; // değişke ta ı ladık e değeri erdik
float sicaklik_deger =0; // değişke ta ı ladık e değeri erdik
void setup() {
void loop() {

sicaklik_deger=voltaj_deger/10.0; // gerekli işle i aptı
Serial.print("sicaklik"); // ekra a azdır
Serial.println(sicaklik_deger); // ekra a değişke i değeri i azdır
Serial.println("derece"); // ekra a azdır
if(sicaklik_deger>=35){ // şart sağla ı orsa kodu işle
digitalWrite(k_led, LOW); // Ledi ak, ‘GB Bölü ü ü oku u uz
digitalWrite(y_led, HIGH); // Ledi sö dür, ‘GB Bölü ü ü oku u uz
digitalWrite(m_led, HIGH); // Ledi sö dür, ‘GB Bölü ü ü oku u uz
else if (sicaklik_deger = 35 && sicaklik_deger >=30){ // koşul sağla ı orsa işle
digitalWrite(k_led, LOW); // Ledi ak, ‘GB Bölü ü ü oku u uz
digitalWrite(y_led, LOW); // Ledi ak, ‘GB Bölü ü ü oku u uz
digitalWrite(m_led, HIGH); // Ledi sö dür, ‘GB Bölü ü ü oku u uz
else if(sicaklik_deger<30){ // koşul sağla ı orsa işle
digitalWrite(k_led, HIGH); // Ledi sö dür, ‘GB Bölü ü ü oku u uz
digitalWrite(y_led, HIGH); // Ledi sö dür, ‘GB Bölü ü ü oku unuz)
digitalWrite(m_led, LOW); // Ledi ak, ‘GB Bölü ü ü oku u uz
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.

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.

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ç

const int k_led=11; // . Pi i k_led değişke i e ata a ap
const int y_led=10; // 10. Pini y_led değişke i e ata a ap
const int m_led=9; // 9. Pini m_led değişke i e ata a ap
void setup() {
pinMode(k_led, OUTPUT); // ‘GB Ba akları ı re k a akları çıkış
pinMode(y_led, OUTPUT); // RGB Ba akları ı re k a akları çıkış
pinMode(m_led, OUTPUT); // ‘GB Ba akları ı re k a akları çıkış
void loop() {
digitalWrite(k_led, LOW); // kır ızı ledi ak
digitalWrite(y_led, HIGH); // eşil ledi sö dür
digitalWrite(m_led, HIGH); // a i ledi sö dü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.

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

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; // a alog . Pi de değişke atadık
const int buzzer =11; // digital PWM pi e değişke ta ı ladık
int durum=0; // değişke ta ı ladık e değeri i dedik
int cikti=0; // değişke ta ı ladık e değeri i dedik

void setup() {
pinMode(buzzer, OUTPUT); // uzzer pi i çıkış olarak ata dı
void loop() {
durum = analogRead(pot_pin); // ata a apıldı duru değişke i e
Serial.println(durum); // duru değişke i i değeri i ekra a az
cikti =map(durum, 0,1023, 0,255); // uzzer pi i çıkış olarak ata dı
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 0-
255 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.

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.

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

2 4 8 16 32 64 128 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.

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.

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); // ‘GB Ledleri si al a akları çıkış
pinMode(yled, OUTPUT); // ‘GB Ledleri si al a akları çıkış
pinMode(mled, OUTPUT); // ‘GB Ledleri si al a akları çıkış
void loop() {
analogWrite(kled, 255-150); // analog çıkış ile parlaklık a arla dı
analogWrite(yled, 255-0); // a alog çıkış ile parlaklık a arla dı
analogWrite(mled, 255-0); // a alog çıkış ile parlaklık a arla dı
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

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

FONKSİYONLAR -1-
Algoritmanı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() { // fo ksi o oluşturduk
Serial.println("fonksiyon basladi"); // ekra a azdır
delay(2500); // 2500ms (2.30 saniye)bekle
Serial.println("fonksiyon calismaya devam ediyor"); // ekra a azdır
Serial.println("fonksiyon birazdan biticek"); // ekra a azdır

void setup() {
void loop() {
Serial.println("sistem calismaya basladi"); // ekra a azdır
delay(2000); // 2000ms (2 saniye)bekle
fonksiyon1(); // fo ksi o değişke i i kulla
delay(1000); // 1000ms (1 saniye)bekle
Serial.println("program calismayi bitirdi"); // ekra a azdır
while(1); // ir kere dö dür progra ı
“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.

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; // değişke ta ı ladık
void basla(){ // fo ksi o ta ı ladık
digitalWrite(led_pin, HIGH); // ledi yak
digitalWrite(led_pin, LOW); // ledi sö dür

void baslama(){ // fo ksi o ta ı ladık
digitalWrite(buzzer_pin, HIGH); // buzzeri çalıştır
digitalWrite(buzzer_pin, LOW); // buzzeri durdur
void setup() {
pinMode(led_pin, OUTPUT); // ledi çıkış olarak atadık
pinMode(buzzer_pin, OUTPUT); // uzzeri çıkış olarak atadık
pinMode(buton_pin, INPUT); // uto u giriş olarak atadık
void loop() {
buton_durum = digitalRead(buton_pin); // uto _pi duru u u ata a aptık
if(buton_durum == HIGH){ // if koşulu sağla ı orsa çalıştır
basla(); // asla fo ksi o u u çalıştır
else if(buton_pin == LOW){ // else if koşulu sağla ı orsa
baslama(); // asla a fo ksi o u u ç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.

19. BÖLÜM
FONKSİYONLAR -2-

FONKSİYONLAR -2-
Fonksiyonlar 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ç

const int buton1 =2; // . Kod satırı
const int buton2 =3; // 2. Kod satırı
const int buton3 =4; // 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ı
Serial.println(sayac); // 18. Kod satırı
if(arti == HIGH) { // 19. Kod satırı
while(1) { // 20. Kod satırı
arti = digitalRead(buton1); // 21. Kod satırı
if(arti == LOW) // 22. Kod satırı
break; // 23. Kod satırı

else if (eksi == HIGH){ // . Kod satırı
sayac--; // 25. Kod satırı
Serial.println("sayac="); // 26. Kod satırı
Serial.println(sayac); // 27. Kod satırı
if (eksi == HIGH){ // 28. Kod satırı
while(1){ // 29. Kod satırı
eksi = digitalRead(buton2); // 30. Kod satırı
if (eksi == LOW) // 31. Kod satırı
durum = digitalRead(buton3); // 33. Kod satırı
return sayac; // 3 . 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<tur_sayisi ; i++) { // 41. Kod satırı
digitalWrite(led , HIGH); // 42. Kod satırı

delay(100); // 43. Kod satırı
digitalWrite(led, LOW); // 44. Kod satırı
while(1) // 46. Kod satırı
durum = digitalRead(buton3); // 47. Kod satırı
if(durum == HIGH) // 48. 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.

 “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.

 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.

20. BÖLÜM
FONKSİYONLAR -3-

FONKSİYONLAR -3-
Bu 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<a ; i++){ // 4. KOD SATIRI
digitalWrite(led, HIGH); // 5. KOD SATIRI
delay(100); // 6. KOD SATIRI
digitalWrite(led, LOW); // 7. KOD SATIRI
void setup() {
digitalWrite(led, OUTPUT); // 9. KOD SATIRI
Serial.begin(9600); // 10. KOD SATIRI

void loop() {
Serial.println("algoritma calismaya basliyor"); // 11. 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
KOD AÇIKLAMALARI;
 İ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.

 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() {
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

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){ // 7. KOD SATIRI
cikartma= b-a; // 8. KOD SATIRI
void setup() {

void loop() {
a=5; // 10. KOD SATIRI
b=16; // 11. KOD SATIRI
topla(a,b); // 12. KOD SATIRI
cikart(b,a); // 15. KOD SATIRI
Serial.print("sonuc="); // 16. KOD SATIRI
Serial.println(cikartma); // 17. KOD SATIRI
KOD AÇIKLAMALARI;
 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.

21. BÖLÜM
FONKSİYONLAR -4-

FONKSİYONLAR -4-
Bu 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) { // 14. KOD SATIRI
float tt= s/ 6.0; // 15. KOD SATIRI
return tt; // 16. KOD SATIRI
void setup(){
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
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

 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.

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

DELAYMİCROSECONDS

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);

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.

 İ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

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
void loop() {
simdikizaman = millis(); // 8. KOD SATIRI
Serial.println(simdikizaman); // 9. KOD SATIRI

if(simdikizaman - oncekizaman >= aralik){ // 10. KOD SATIRI
oncekizaman = simdikizaman; // 11. KOD SATIRI
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
KOD AÇIKLAMALARI;
 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.

 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; // değişke ta ı ladık
void setup() {
void loop() {
simdikizaman = micros(); // işle i ros i si de apıla ak
Serial.println(simdikizaman); // si dikiza a değişke değeri ekra a azıla ak
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.

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

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.

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.

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.

int ogrenciler[10] = {1,2,3,4,5};
void setup() {
Serial.begin(9600);
void loop() {
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;
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.

“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;
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.

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]);

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}; // . Kod satırı
void setup() {
Serial.begin(9600); // 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]); // 7. 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.

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

ÇİFT BOYUTLU DİZİLER(ARRAY)
int ogrenciler[ 5 ] = { 12,21,33,42,95}; (tek boyutlu dizi)
12 21 33 42 95
0 1 2 3 4
ogrenciler adlı dizimiz.
ÇİFT BOYUTLU DİZİLER;

int ogrenciler [ 2 ] [ 2 ] = { 51,12};
{ 12, 12 };
5 9 Bu şekilde çift boyutlu dizilere değer ataması

0 1 yaparken { } süslü parantez altına aynı şekilde “{ 12,
9 12 };” yazıyoruz ve değerleri giriyoruz.
3 6
0 1
Bizim dizimiz 2,2 boyutundaydı. İlk 2, bizim satır bilgimiz, ikinci 2 ise sütun bilgisidir.
2,2 SATIR
9
SATIR SÜTUN
9
SÜTUN

Ö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 Örnek kodda dikkat edilmesi gereken dizi

değerleri tanımlarken (,) virgülleri ve en son ( { } )
1 1 92 3 94 95 süslü parantez içine almayı unutmayın. Gelin Bu
örneğimizi örnek program ile pekiştirelim.
2 2 12
9 33 944 963
9 9 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
Yukarıdaki programı çalıştırdığımızda, Serial

0 1 2 3 4 5 monitörde “Serial.println(ogrenciler[1][3]);” kodu ile
1. satır 3. sütundan bir sayı gösterecek. Oda 9 sayısı.
1 6 97 8 99 910 Herhangi bir dizinin elemanını istediğimiz sayının
2 11 12 13 elemanı ile değiştirebiliriz. Bir önceki dersteki gibi.
9 914 915
9 9 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() {
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++)

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.

Adim Adim Arduino

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Adim Adim Arduino

Uploaded by

Copyright:

Available Formats

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

ADIM ADIM ARDUİNO

MANTIK İFADELE‘İ ....................................................................................................................... 55

DİGİTAL “İNYAL .......................................................................................................................... 111

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 6

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 7

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

DİRENÇ DEĞERLERİNİN OKUNMASI

Dirençleri genellikle renkleri ile değerlendiririz. Piyasada sıklıkla kullanılan

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 8

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 9

Ayarlı dirençler, çok farklı çeşitlerde üretilmektedirler.

Yandaki resimde potansiyometrenin iç yapısını

Yandaki resimde potansiyometrenin Uluslararası ve

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 10

ULTRASONİK MESAFE SENSÖRÜ(HC – SR04)

LM35 SICAKLIK SENSÖRÜ

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 11

LED (LIGHT EMİTTİNG DİODE - IŞIK YAYAN DİYOT)

Yanda led’in simgesini görüyorsunuz.

LED KARAKTERİSTİĞİ; Led’in yaydığı ışığın rengi yapım maddesine göre

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 12

V = Potansiyel Fark (Gerilim-Volt)

Potansiyel Fark(Gerilim-Volt)’ı Bulmak İçin;

Devreden Geçem Akımı Bulmak İçin;

Devrenin Direncini Bulmak İçin;

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 13

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 14

Projelerinizde kullanacağınız birçok Arduino kartları mevcuttur. İstediğiniz kartı,

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 15

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 16

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 17

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 18

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 19

Void loop(){////} Sürekli tekrar etmesini istediğimiz eylemleri yazarız.

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 20

pinMode(13, OUTPUT); // .Pi i çıkış pi i atadık.

digitalWrite(13, HIGH); // . Ba ağa güç er, ledi ak.

delay(1000); // 1 saniye bekle.

digitalWrite(13, LOW); // . Ba ağı sö dür.

delay(1000); //1 saniye bekle.

pinMode(X, OUTPUT-INPUT); Daima void setup bölümüne yazılır. X pinimiz

Örnek; Isı sensörü, buton.

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 21

DİGİTAL PİNLERİ ÇIKIŞ OLARAK

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 22

ARDUİNO KARAŞİMŞEK UYGULAMASI

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

pinMode(2, OUTPUT); // . pi i izi çıkış olarak ta ı ladık.

pinMode(3, OUTPUT); // . pi i izi çıkış olarak ta ı ladık.

pinMode(4, OUTPUT); // . pi i izi çıkış olarak ta ı ladık.

pinMode(5, OUTPUT); // . pi i izi çıkış olarak ta ı ladık.

pinMode(6, OUTPUT); // . pi i izi çıkış olarak ta ı ladık.

digitalWrite(2, HIGH); // 2. pinimize lojik- değeri i atadık. + V

delay(500); // 500mS bekle. 500x10-3 = 0.5sn

digitalWrite(2, LOW); // 2. pinimize lojik- değeri i atadık. + V

delay(500); // 500mS bekle. 500x10-3 = 0.5sn

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 23

delay(500); // 500mS bekle. 500x10-3 = 0.5sn

digitalWrite(3, LOW); // 2. pinimize lojik- değeri i atadık. + V