You are on page 1of 154

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

ADIM ADIM ARDUİNO


SENCER ALTUN
KITAP HAKKINDA

YAZAR
SENCER ALTUN

KAPAK TASARIMI
EMRE KILIÇ

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

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

MANTIK İFADELERİ ....................................................................................................................... 55


UYGULAMA(PARK SENSÖRÜ) ............................................................................................................... 57
11- WHİLE DÖNGÜSÜ............................................................................................................................ 61
12- DO WHİLE DÖNGÜSÜ ..................................................................................................................... 67
13- SWİTCH CASE YAPISI ....................................................................................................................... 71
14- FOR DÖNGÜSÜ................................................................................................................................ 78
15- BREAK VE CONTİNUE ...................................................................................................................... 83
FOR İLE KULLANIM............................................................................................................................. 85
WHİLE İLE KULLANIM ...................................................................................................................... 86
16- ANALOG GİRİŞ VE 10BİT ADC ......................................................................................................... 91
POTANSİYOMETRE İLE GELEN BİLGİYİ OKUMA ................................................................................. 92
UYGULAMA(ARDUİNO İLE LM35 KULLANIMI) ..................................................................................... 95
RGB LED HAKKINDA BİLİNMESİ GEREKENLER.................................................................................. 103
17- ANALOG ÇIKIŞ – PWM .................................................................................................................. 106
ANALOG ÇIKIŞ .................................................................................................................................. 107
PWM NEDİR................................................................................................................................... 110

DİGİTAL SİNYAL .......................................................................................................................... 111


ANALOG SİNYAL ................................................................................................................... 111
ANALOG SİNYALLER İLE RGB LED ...................................................................................... 112
18- FONKSİYONLAR -1- ....................................................................................................................... 113
PARAMETRE ALMAYAN VE DEĞER DÖNDÜRMEYEN FONKSİYONLAR............................................. 114
19- FONKSİYONLAR -2- ....................................................................................................................... 118
PARAMETRE ALMAYAN VE DEĞER DÖNDÜREN FONKSİYONLAR .................................................... 119
20- FONKSİYONLAR -3- ....................................................................................................................... 125
PARAMETRE ALAN VE DEĞER DÖNDÜRMEYEN FONKSİYONLAR .................................................... 126
HESAP MAKİNESİ UYGULAMASI ................................................................................................... 128
21- FONKSİYONLAR -4- ....................................................................................................................... 131
PARAMETRE ALAN VE DEĞER DÖNDÜREN FONKSİYONLAR............................................................ 132
22- MİLLİS – MİCROS – DELAY – DELAYMİCROSECONDS................................................................... 135
delay(); ............................................................................................................................................. 136
delayMicrosaniye(); .................................................................................................................... 136
millis(); ..................................................................................................................................... 137
micros(); ............................................................................................................................... 141
23- TEK BOYUTLU DİZİLER (ARRAY) .................................................................................................... 142
DİZİLER ............................................................................................................................................. 143
24- ÇİFT BOYUTLU DİZİLER(ARRAY) .................................................................................................... 150

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 6


TEMEL ELEKTRONİK

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 7


TEMEL ELEKTRONİK

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

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

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


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

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


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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 8


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

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 9


POTANSİYOMETRE(AYARLI DİRENÇ)

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


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

Yandaki resimde potansiyometrenin iç yapısını


görmektesiniz.

Yandaki resimde potansiyometrenin Uluslararası ve


Amerikan Sembollerini görmektesiniz.

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 10


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

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


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

LM35 SICAKLIK SENSÖRÜ


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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 11


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

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


Işık yayan diyotlar veya bilinen adıyla ledler,
birçok alanda kullanılan farklı tipteki yarı
iletken diyotlardır. Bu diyotların birçoğunun
yaydığı ışık, görünür bant genişliği (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.

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 12


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

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

V = Potansiyel Fark (Gerilim-Volt)


I = Akım (Amper)
R = Direnç (Ohm)

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

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

Devrenin Direncini Bulmak İçin;

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 13


ARDUİNO NEDİR

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 14


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

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

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


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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 15


ARDUİNO İDE PROGRAMINA GİRİŞ

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 16


ARDUİNO IDE PROGRAMINA GİRİŞ

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 17


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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 18


1. BÖLÜM

ARDUİNO’YA GİRİŞ

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 19


ARDUİNO’YA GİRİŞ
GİRİŞ
Arduino iki bölümden oluşur;
Void setup(){////} Arduino çalışmaya başlamadan önce yapması gereken
ayarları söylediğimiz bölüm. Void loop’da Arduino’ya verdiğimiz işleri yapabilmesi için
Arduino’ya ön hazırlık olarak gerekli ayarları yaptırıyoruz.

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

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

ÖRNEK PROGRAM

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 20


void setup() {

pinMode(13, OUTPUT); // 13.Pini çıkış pini atadık.

void loop() {

digitalWrite(13, HIGH); // 13. Bacağa güç ver, ledi yak.

delay(1000); // 1 saniye bekle.

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

delay(1000); //1 saniye bekle.

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


çıkış mı yosa giriş mi tanımlamasının yapıldığı yer.
Bir pinden dışarıya komut yada güç vericeksek tercih etmemiz gereken komut
OUTPUT(Çıkış) komutudur.

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

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


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

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


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

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 21


2. BÖLÜM

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


KULLANMAK

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 22


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

ARDUİNO KARAŞİMŞEK UYGULAMASI

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

void setup() {

pinMode(2, OUTPUT); // 2. pinimizi çıkış olarak tanımladık.

pinMode(3, OUTPUT); // 3. pinimizi çıkış olarak tanımladık.

pinMode(4, OUTPUT); // 4. pinimizi çıkış olarak tanımladık.

pinMode(5, OUTPUT); // 5. pinimizi çıkış olarak tanımladık.

pinMode(6, OUTPUT); // 6. pinimizi çıkış olarak tanımladık.

void loop() {

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

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

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

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 23


digitalWrite(3, HIGH); // 3. pinimize lojik-1 değerini atadık.(+5V)

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

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

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

digitalWrite(4, HIGH); // 3. pinimize lojik-1 değerini atadık.(+5V)

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

digitalWrite(4, LOW); // 2. pinimize lojik-0 değerini atadık.(+0V)

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

digitalWrite(5, HIGH); // 3. pinimize lojik-1 değerini atadık.(+5V)

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

digitalWrite(5, LOW); // 2. pinimize lojik-0 değerini atadık.(+0V)

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

digitalWrite(6, HIGH); // 3. pinimize lojik-1 değerini atadık.(+5V)

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

digitalWrite(6, LOW); // 2. pinimize lojik-0 değerini atadık.(+0V)

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

digitalWrite(2, HIGH); // 3. pinimize lojik-1 değerini atadık.(+5V)

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

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

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 24


3. BÖLÜM

DİGİTAL PİNLERİ GİRİŞ OLARAK


KULLANMAK

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 25


DİGİTAL PİNLERİ GİRİŞ OLARAK KULLANMAK

ARDUİNO LED-BUTON UYGULAMASI

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

NOT; Butona basılıp basılmama bilgisini Arduino’ya okutacağız ardındanda bu bilgi


dahilinde ledin yanıp yanmayacağına karar vereceğiz.

int led =4; // digital 4. Pine led ismini verdik.

int buton =5; // digital 5. Pine buton ismini verdik.

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

void setup(){

pinMode(led, OUTPUT); // led(4) pini çıkış olarak atadık.

pinMode(buton, INPUT); // buton(5) pini giriş olarak atadık.

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 26


void loop(){

butondurumu=digitalRead(buton); // Butonun basılıp basılmadığını butondurumu’na ata.

if(butondurumu == HIGH) // Eğer buton durumu HIGH ise aşağıdaki kodu işle.

digitalWrite(led, HIGH); // Led(4) pini yak.

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

digitalWrite(led, LOW); // Butona basılmıyorsa ledi söndür.

digitalRead(bilgi alınacak olan pin); 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);

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 27


4. BÖLÜM

İF – ELSE KOMUTUNU KULLANMAK

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 28


İF – ELSE KOMUTUNU KULLANMAK

xx = digitalRead(x); x değikenini xx değişkenine kaydet.


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

else if = buradaki if bir önceki if ile bağlantılı durum.


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

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

Yukarıdaki uygulamada 6.pin ve 1 adet buton kullanılmamıştır.


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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 29


int but1 = 2; // 2. Pine but1 dedik.

int but2 = 3; // 3. Pine but2 dedik.

int but3 = 4; // 4. Pine but3 dedik.

int but4 = 5 // 5. Pine but4 dedik.

int led1 = 8; // 8. Pine led1 dedik.

int led2 = 9; // 9. Pine led2 dedik.

int led3 = 10; // 10. Pine led3 dedik.

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

int b2d; // buton2durumu değişken ismi atadık.

int b3d; // buton3durumu değişken ismi atadık.

int b4d; // buton4durumu değişken ismi atadık.

void setup(){

pinMode(but1, INPUT); // 2.(but1) pini giriş olarak atadık.

pinMode(but2, INPUT); // 3.(but3) pini giriş olarak atadık.

pinMode(but3, INPUT); // 4.(but4) pini giriş olarak atadık.

pinMode(but4, INPUT); // 5.(but5) pini giriş olarak atadık.

pinMode(led1 , OUTPUT); // 8.(led1) pini çıkış olarak atadık.

pinMode(led2 , OUTPUT); // 9.(led2) pini çıkış olarak atadık.

pinMode(LED3 , OUTPUT); // 10.(led3) pini çıkış olarak atadık.

void loop(){

b1d = digitalRead(but1); // digitalRead komutuyla but1 durumunu b1d’ye atadık.

b2d = digitalRead(but2); // digitalRead komutuyla but2 durumunu b2d’ye atadık.

b3d = digitalRead(but3); // digitalRead komutuyla but3 durumunu b3d’ye atadık.

b4d = digitalRead(but3); // digitalRead komutuyla but4 durumunu b4d’ye atadık.

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 30


if(b1d == HIGH) // Eğer 1. Butona basılırsa bir alttaki kodu işleme al.

digitalWrite(led1, HIGH); // eğer 1. Butona basılırsa ledi yak.

else if (b2d == HIGH){ // sadece 2. Butona basıldıysa {---} arasındaki kodu işleme al.

digitalWrite(led1, HIGH); // butona basıldıysa 1. Ledi yak.

digitalWrite(led2, HIGH); // butona basıldıysa 2. Ledi yak.

else if(b3d == HIGH){ // sadece 3. Butona basıldığında {---} arasındaki kodu işle.

digitalWrite(led1, HIGH); // butona basıldıysa 1. Ledi yak.

digitalWrite(led2, HIGH); // butona basıldıysa 2. Ledi yak.

digitalWrite(led3, HIGH); // butona basıldıysa 3. Ledi yak.

else if (b4d == HIGH){ // sadece 3. Butona basıldığında {---} arasındaki kodu işle.

digitalWrite(led1, HIGH); // butona basıldıysa 1. Ledi yak.

delay(250); // 250 ms bekle.

digitalWrite(led1, LOW); // butona basıldıysa 1. Ledi sündür.

digitalWrite(led2, HIGH); // butona basıldıysa 2. Ledi yak.

delay(250); // 250 ms bekle.

digitalWrite(led2, LOW); // butona basıldıysa 2. Ledi söndür.

digitalWrite(led3, HIGH); // butona basıldıysa 3. Ledi yak.

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

digitalWrite(led1, LOW); // 1. Ledi söndür

digitalWrite(led2, LOW); // 1. Ledi söndür

digitalWrite(led3, LOW); // 1. Ledi söndür

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 31


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

X = digitalRead(XXX);

BU KOMUT = BURAYI OKUYARAK HIGH VEYA LOW DURUMUNU X’E ATA.

ATANACAK

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 32


5. BÖLÜM

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 33


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

void setup() {

Serial.begin(9600); //9600 Seri haberleşmenin hızını belirliyor.

void loop() {

Serial.println("merhaba dunya"); //ekrana parantez içindeki ifadeyi yaz.

Serial.println("Sencer Altun"); //ekrana parantez içindeki ifadeyi yaz.

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

Serial.begin(9600); Programlamada Serial Monitörü kullanacağımızı belirler.


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

Serial.print(“x”); Bu komutu parantez içindeki istediğimiz ifadeyi monitörde seri


şekilde, yanyana göstermek için kullanırız.

Serial.println(“x”); Bu komutu parantez içindeki istediğimiz ifadeyi monitörde


alt alta göstermek için kullanırız.

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 34


int but1 = 2; //2. Pini but1 diye atadık.

int but2 = 3; //3. Pini but2 diye atadık.

int but3 = 4; //4. Pini but3 diye atadık.

int led1 = 5; //5. Pini led1 diye atadık.

int led2 = 6; //6. Pini led2 diye atadık.

int led3 = 7; //7. Pini led3 diye atadık.

int b1d; //buton1durumu değişkeni atadık.

int b2d; //buton2durumu değişkeni atadık.

int b3d; //buton3durumu değişkeni atadık.

void setup() {

pinMode(but1, INPUT); //but1’i giriş olarak ayarladık.

pinMode(but2, INPUT); //but2’i giriş olarak ayarladık.

pinMode(but3, INPUT); //but3’i giriş olarak ayarladık.

pinMode(led1, OUTPUT); //led1’i çıkış olarak ayarladık.

pinMode(led2, OUTPUT); //led2’i çıkış olarak ayarladık.

pinMode(led3, OUTPUT); //led3’i çıkış olarak ayarladık.

Serial.begin(9600); //Serial monitörü kullanacağız.

void loop() {

b1d = digitalRead(but1); //but1’in HIGH veya LOW durumunu b2d’na ata.

b2d = digitalRead(but2); //but2’in HIGH veya LOW durumunu b2d’na ata.

b3d = digitalRead(but3); //but3’in HIGH veya LOW durumunu b2d’na ata.

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 35


if(b1d == HIGH){ //eğer b1d HIGH ise led1’i yak.

digitalWrite(led1, HIGH); //led1’i yak.

Serial.println("birinci butona basildi"); //butona basıldıyla S. monitörde göster.

delay(600); //bu işlemi 600ms’de yap.

else if (b2d == HIGH){ //eğer b2d HIGH ise led1 ve led2’yi yak.

digitalWrite(led1, HIGH); //led1’i yak.

digitalWrite(led2, HIGH); //led2’i yak.

Serial.println("ikinci butona basildi"); //butona basıldıyla S. monitörde göster.

delay(600); //bu işlemi 600ms’de yap.

else if(b3d == HIGH){ //eğer b3d HIGH ise tümünü yak.

digitalWrite(led1, HIGH); //led1’i yak.

digitalWrite(led2, HIGH); //led2’i yak.

digitalWrite(led3, HIGH); //led3’i yak.

Serial.println("ucuncu butona basildi"); //butona basıldıyla S. monitörde göster.

delay(600); //bu işlemi 600ms’de yap.

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

digitalWrite(led1, LOW); //led1’i söndür.

digitalWrite(led2, LOW); //led2’i söndür.

digitalWrite(led3, LOW); //led3’i söndür.

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

İnt x = x ; İnteger anlamına geliyor. Tamsayı. İlerleyen konularda değinilecektir.

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 36


6. BÖLÜM

DEĞİŞKEN TANIMLAMA VE VERİ


TİPLERİ(1)

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 37


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

int a = 1453; // a değişkeninin değeri 1453

void setup() {

Serial.begin(9600); // serial monitör kullanılacak

void loop() {

Serial.println(a); // a değişkeninin değerini ekrana yaz

VERİ TİPİ BOYUT(BAYT) KULLANILDIĞI İÇ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.

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 38


7. BÖLÜM

DEĞİŞKEN TANIMLAMA VE VERİ


TİPLERİ(2)

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 39


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

float pi_sayisi = 3.14; // ondalıklı sayıyı pi_sayisi değişkenine atadık

void setup() {

Serial.begin(9600); // serial monitör kullanılacak

void loop() {

Serial.println(pi_sayisi); // pi_sayisi değişkeninin değeri ekranda yazılacak(3.14)

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

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


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

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

void setup() {

Serial.begin(9600); // Serial monitör kullanılacak

void loop() {

Serial.println(karakter); // karakter değişkeninin değerini monitörde göster

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 40


8. BÖLÜM

CONST VE DEFİNE İFADELERİNİN


KULLANIMI

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 41


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

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

void setup() {

Serial.begin(9600); // Serial monitör kullanılacak

void loop() {

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

Serial.print("sayac="); // ekrana sayac’ı yazdır

Serial.println(sayac); // ekrana sayac değişkeninin değerini yazdır

Serial.println("---------"); // ekrana yazdır

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

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

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

ÖRNEK; int buton = 3;


İnt sayac = 32000;

XXX = XXX +1
İŞLEM

İŞLEM YAPILACAK DEĞIŞKEN DEĞİŞKENİN İLK DEĞERİ

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 42


const int buton =3; // const ile int tipinide 3 pinini buton değişkenine atadık

int sayac = 32000; // int veri tipinde sayac adlı değişken atadık ve değeri 32000

void setup() {

Serial.begin(9600); // serial monitör kullanılacak

void loop() {

digitalRead(buton); // buton değerini oku

buton = 7; // 7. Pini buton olarak atadık

Serial.print("sayac="); // ekrana sayac kelimesini yazdır

Serial.println(sayac); // ekrana sayac değişkeninin değerini yazdır

Serial.println("---------"); // ekrana yazdır

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

const; const ifadesi programın ilerleyen kısımlarında algoritmanın çalışmasını son


derece önemli olan değişkenlerin yanlış bir şekilde değişmesini engellemek için o
değişkeni korumaya alır.

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 43


char krt1 = 'A'; // tek tip bir karakter atandı

char krt2 = 'R'; // tek tip bir karakter atandı

char krt3 = 'D'; // tek tip bir karakter atandı

char krt4 = 'U'; // tek tip bir karakter atandı

char krt5 = 'I'; // tek tip bir karakter atandı

char krt6 = 'N'; // tek tip bir karakter atandı

char krt7 = 'O'; // tek tip bir karakter atandı

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

void setup() {

Serial.begin(9600); // serial monitör kullanılacak

void loop() {

Serial.println(krt1); // krt1 değerini ekrana yaz

delay(bek_sure); // yukarıda belirtilen sure kadar bekle

Serial.println(krt2); // krt1 değerini ekrana yaz

delay(bek_sure); // yukarıda belirtilen sure kadar bekle

Serial.println(krt3); // krt1 değerini ekrana yaz

delay(bek_sure); // yukarıda belirtilen sure kadar bekle

Serial.println(krt4); // krt1 değerini ekrana yaz

delay(bek_sure); // yukarıda belirtilen sure kadar bekle

Serial.println(krt5); // krt1 değerini ekrana yaz

delay(bek_sure); // yukarıda belirtilen sure kadar bekle

Serial.println(krt6); // krt1 değerini ekrana yaz

delay(bek_sure); // yukarıda belirtilen sure kadar bekle

Serial.println(krt7); // krt1 değerini ekrana yaz

delay(bek_sure); // yukarıda belirtilen sure kadar bekle

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 44


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

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

#define; Bekleme süresi adında bir değişken oluşturduk ve Arduino’nun


hafızasında yer hacamış olmadık, hafızasından tasarruf ettik.

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

#define XXXX XX

DEĞİŞKEN İSMİ DEĞERİ

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 45


9. BÖLÜM

TEMEL MATEMATİK İŞLEMLERİ

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 46


TEMEL MATEMATİK İŞLEMLERİ

ARDUİNO İLE DÖRT İŞLEM

float x=5; // float tipinde sayı atadık ve ona x dedik

int y=3; // int tipinde sayı atadık ve ona y dedik

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

void setup() {

Serial.begin(9600); // serial monitör kullanılacak

void loop() {

sonuc =x/y; // x değişken değerini y’ye böl

Serial.println(sonuc); // sonuc değişkeninin değerini ekrana yaz

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

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

ÖNEMLİ NOT; sayici =sayici+1 -> Bunun (+) yerine bunlarda olabilir.
sayici = sayici / 1
sayici = sayici - 1
sayici = sayici * 1

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 47


KALAN BULMA

 Void loop bölümünde gerçekleşir.


 %(yüzde) işareti ile olur.
 Herhangi veri tipi ile tanımlanmış sayıların bölümünden kalanı verir.

KALAN BULAN PROGRAM

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

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

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

void setup() {

Serial.begin(9600); // serial monitör kullanılacak

void loop() {

sonuc = x%y; // x ve y değerlerinde kalanı veren kod

Serial.println(sonuc); // sonuc değişleninin değerini ekrana göster

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

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 48


KAREKÖK BULMA

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

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

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

void setup() {

Serial.begin(9600); // serial monitör kullanılacak

void loop() {

sonuc = sqrt(y); // sqrt karekök onun önündeki ifadenin karekökün alır

Serial.println(sonuc); // sonuc değişleninin değerini ekranda göster

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

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

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

sqrt(karekökü alınacak değişken veya sayı);

MUTLAK DEĞER

abs(mutlak değeri alınacak değişken veya sayı);

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 49


10. BÖLÜM

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 50


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

DEĞİŞKEN TANIMLAMA

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

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

void setup() {

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

Serial.begin(9600); // serial monitör kullanılacak

void loop() {

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

Serial.println("x="); // Serial ekrana paraztez içindeki ifadeyi yaz

Serial.println(x); // Serial ekrana x değişkeninin değerini yaz

Serial.println("----------"); // Serial ekrana paraztez içindeki ifadeyi yaz

Serial.println("z="); // Serial ekrana paraztez içindeki ifadeyi yaz

Serial.println(z); // Serial ekrana x değişkeninin değerini yaz

Serial.println("----------"); // Serial ekrana paraztez içindeki ifadeyi yaz

Serial.println("k="); // Serial ekrana paraztez içindeki ifadeyi yaz

Serial.println(k); // Serial ekrana x değişkeninin değerini yaz

Serial.println("----------"); // Serial ekrana paraztez içindeki ifadeyi yaz

delay(500); // 500ms bekle

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 51


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

void setup() {

int led = 13; // int veri tipinde sadece bu bölümde geçerli

pinMode(led, OUTPUT); // led değişkenini çıkış olarak atadık

void loop() {

digitalWrite(13, HIGH); // 13. Pine (5v) HIGH dedik

delay(1000); // 1000ms(1saniye) bekle

digitalWrite(13, LOW); // 13. Pine (0v) LOW dedik

delay(1000); // 1000ms(1saniye) bekle

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 52


KARŞILAŞTIRMA

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

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

int x =9; // 9 değerini x değişkenine kaydet

int y =15; // 15 değerini y değişkenine kaydet

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

void setup() {

Serial.begin(9600); // Serial monitör kullanılacak

void loop() {

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

kayit=1; // kayit değişkeni 1 olsun

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

kayit=0; // kayit değişkeni 0 olsun

Serial.println(kayit); // kayit değişkeninin değerini ekranda göster

NOT; Yukarıdaki programda Void loop bölümünde “if(x>y)” ifadesine istediğimiz


karşılaştırma ifadelerini yazabiliriz. Yazdığımız karşılaştırma ifadeleri yukarıda
gösterilmiştir.

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 53


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; // int veri tipinde 10 değerine a değişkenini atadık

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

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

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

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

void setup() {

Serial.begin(9600); // Serial monitör kullanılacak

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 54


void loop() {

if((a==b)&&(c==d)) // eğer a, b’ye ve c, d’ye eşitse çalıştır

sonuc=1; // yukarıdaki durum sağlanıyorsa bu kodu işle

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

sonuc=2; // yukarıdaki durum sağlanıyorsa bu kodu işle

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

sonuc=3; // yukarıdaki durum sağlanıyorsa bu kodu işle

else if ((a==b)||(d==c)) // değilse eğer, a, b’ye eşitse veya d, c’ye eşitse

sonuc=4; // yukarıdaki durum sağlanıyorsa bu kodu işle

else if ((a==b)||(c<=d)) // d. e. , a, b’ye eşitse veya c, d’den büyükse veya eşitse

sonuc=5; // yukarıdaki durum sağlanıyorsa bu kodu işle

else if ((a<b)||(a>b)) // değilse eğer, a, b’den küçükse veya a, b’den büyükse


sonuc=6; // yukarıdaki durum sağlanıyorsa bu kodu işle

else // yukarıdakiler haricinde herşey

sonuc=7; // yukarıdaki durum sağlanıyorsa bu kodu işle

Serial.println(sonuc); // sonuc değişkeninin değerini ekranda göster

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 55


UYGULAMA

PARK SENSÖRÜ

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 56


UYGULAMA(PARK SENSÖRÜ)

MALZEMELER

LED 4 ADET ( Kırmızı/Sarı/Yeşil/Mavi)

Buzzer

220 veya 330 OHM Direnç

HC-SR04 Sensör (Ultrasonik)

const int trig =13; // 13.pin trig olarak atandı

const int echo =12; // 12.pin echo olarak atandı

const int buzzer =2; // 2.pin buzzer olarak atandı

const int mled =3; // 3.pin mled olarak atandı

const int yled =4; // 4. Pin yled olarak atandı

const int sled =5; // 5. Pin sled olarak atandı

const int kled =6; // 6.pin kled olarak atandı

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

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 57


void setup() {

pinMode(kled, OUTPUT); // ledler çıkış olarak atandı

pinMode(sled, OUTPUT); // ledler çıkış olarak atandı

pinMode(yled, OUTPUT); // ledler çıkış olarak atandı

pinMode(mled, OUTPUT); // ledler çıkış olarak atandı

pinMode(buzzer, OUTPUT); // buzzer çıkış olarak atandı

pinMode(echo, INPUT); // sensörün echo pini çıkış olarak atandı

pinMode(trig, OUTPUT); // sensörün trig pini çıkış olarak atandı

void loop() {

digitalWrite(trig, HIGH); // trig pinine HIGH (5V) verdik

delayMicroseconds(1000); // 1 mikrosaniye bekle

digitalWrite(trig, LOW); // trig pinine LOW(0V) verdik

sure=pulseIn(echo, HIGH); // atama gerçekleştirdık.

mesafe =(sure/2) / 28.5; // sensör için gereken kod

if(mesafe <=10){ // eğer mesafe 10 saniyeye eşit veya küçükse

digitalWrite(kled, HIGH); // kled’i yak

digitalWrite(buzzer, HIGH); // buzzer’i çalıştır

delay(250); // 250 ms bekle

digitalWrite(kled, LOW); // kled’i söndür

digitalWrite(buzzer, LOW); // buzzer’i durdur

delay(250); } // 250ms bekle

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 58


else if(mesafe <=25){ // değilse eğer mesafe 25m’ye eşit veya küçükse

digitalWrite(sled, HIGH); // sled’i yak

digitalWrite(buzzer, HIGH); // buzzer’i çalıştır

delay(500); // 500ms bekle

digitalWrite(sled, LOW); // sled’i söndür

digitalWrite(buzzer, LOW); // buzzer’i durdur

delay(500); } // 500ms bekle

else if(mesafe <=50){ // değilse eğer mesafe 50m’ye eşit veya küçükse

digitalWrite(yled, HIGH); // sled’i yak

digitalWrite(buzzer, HIGH); // buzzer’i çalıştır

delay(750); // 750ms bekle

digitalWrite(yled, LOW); // sled’i söndür

digitalWrite(buzzer, LOW); // buzzer’i durdur

delay(750); } // 750ms bekle

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

digitalWrite(mled, HIGH); // mled’i yak

delay(1000); // 1000ms(1saniye) bekle

digitalWrite(mled, LOW); // mled’i söndür

delay(1000); } // 1000ms(1saniye) bekle

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 59


11. BÖLÜM

WHİLE DÖNGÜSÜ

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 60


WHİLE DÖNGÜSÜ

While (koşul / şart ifadesi)


{
Kodlar
}

ÖRNEK; while(a<50)
{ 1
2
3
}

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

int a=0; // a’nın değeri 0 olarak atandı

void setup(){

Serial.begin(9600); // serial monitör kullanılacak

void loop(){

Serial.println(a); // a’nın değerini ekrana yaz

while(a<50) // a, 50’den küçükse çalıştır

Serial.println("While dongusu calisiyor"); // while koşulu sağlanıyorsa ekrana yaz

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 61


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

void setup(){

Serial.begin(9600); // serial monitör kullanılacak

void loop(){

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

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

Serial.println(a); // a değişkeninin değerini ekrana yazdır

Serial.println("While dongusu calisiyor"); // ekrana yazdır

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

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

void setup(){

Serial.begin(9600); // serial monitör kullanılacak

void loop(){

Serial.println(a); // a değişkeninin değerini ekrana yazdır

while (a<=50) // a, 50’den küçük veya eşitse döngüyü çalıştır

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

delay(100); // 100ms bekle

Serial.println(a); // a değişkeninin değerini ekrana yazdır

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 62


Serial.println("While dongusu calisiyor");
Serial.println("While dongusu calisiyor"); // ekrana yazdır

Serial.println("donguden ciktik"); // ekrana yazdır

while(1); // tüm işlemi 1 kere yap

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

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 63


const int buton =3; // 3. Pine buton değişkeni ismini verdik

int durum; // durum değişkeni atadık

void setup(){

pinMode(buton, INPUT); // buton’u giriş olarak atadık

pinMode(5, OUTPUT); // 5. Pini çıkış olarak atadık

Serial.begin(9600); // serial monitör kullanılacak

void loop(){

durum=digitalRead(buton); // butona basılıp basılmama bilgisini durum’a ata

while(durum == HIGH) // butona basılırsa döngüyü çalıştır

digitalWrite(5, HIGH); // 5. Pine HIGH(5V) dedik

delay(500); // 500ms bekle

digitalWrite(5, LOW); // 5. Pine LOW(0V) dedik

delay(500); // 500ms bekle

Serial.println("butona basilmiyor"); // butona basılmazsa ekrana yaz

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 64


const int buton =3; // 3. Pine buton değişkeni ismini verdik

int durum; // durum değişkeni atadık

void setup(){

pinMode(buton, INPUT); // buton’u giriş olarak atadık

pinMode(5, OUTPUT); // 5. Pini çıkış olarak atadık

Serial.begin(9600); // serial monitör kullanılacak

void loop(){

durum=digitalRead(buton); // butona basılıp basılmama bilgisini durum’a ata

while(durum == HIGH) // butona basılırsa döngüyü çalıştır

digitalWrite(5, HIGH); // 5. Pine HIGH(5V) dedik

delay(500); // 500ms bekle

digitalWrite(5, LOW); // 5. Pine LOW(0V) dedik

delay(500); // 500ms bekle

durum = digitalRead(buton); // buton’u kontrol et basılmaya devam ediyormu?

Serial.println("butona basilmiyor"); // butona basılmazsa ekrana yaz

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

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 65


12. BÖLÜM

DO WHİLE DÖNGÜSÜ

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 66


DO WHİLE DÖNGÜSÜ

Do while döngüsü mutlaka bir kere çalışır.

do
{
Kodlar
}
while(koşul)

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

void setup(){

Serial.begin(9600); // serial monitör kullanılacak

void loop(){

Serial.println(a); // a değişkeninin değerini ekrana yaz

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

a=a+1; // a değişkenini 1 attır

Serial.println(a); // a değişkeninin değerini ekranayaz

Serial.println("dongu calisiyor"); // ekrana yaz

delay(250); // 250ms bekle

while(a<50); // a, 50’den küçükmü kontrol et

Serial.println("dongoden cikildi."); // while koşulu sağlanmazsa bunu yap

delay(250); // 250ms bekle

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 67


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

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

void setup(){

Serial.begin(9600); // serial monitör kullanılacak

void loop(){

Serial.println("loop basliyor"); // ekrana yaz

Serial.println(a); // a değişkeninin değerini ekrana yaz

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

a=a+1; // a değişkenini 1 attır

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

a=1; // a’yi 1 ata

Serial.println(a); // a değişkeninin değerini ekrana yaz

Serial.println("dongu calisiyor"); // ekrana yaz

delay(100); // 100ms bekle

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

Serial.println("loop dongusu bitti");


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

Serial.println("donguden cikildi"); // ekrana yaz

Serial.println("loop dongusu bitti"); // ekrana yaz

delay(250); // 250ms bekle

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 69


13. BÖLÜM

SWİTCH CASE YAPISI

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 70


SWİTCH CASE YAPISI

3 adet 10K Direnç


1 adet switch
2 adet buton

const int arttir =3; // 3. Pine arttir değişken ismi tanımladık

const int azalt =4; // 4. Pine azalt değişken ismi tanımladık

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

int durum_arttir; // değişken tanımladık

int durum_azalt; // değişken tanımladık

int durum_dongu; // değişken tanımladık

int sayac=0; // değişken tanımladık

void setup() {

pinMode(arttir, INPUT); // butonları giriş olarak atadık

pinMode(azalt, INPUT); // butonları giriş olarak atadık

pinMode(dongu, INPUT); // switch’i giriş olarak atadık

Serial.begin(9600); // serial monitör kullanılacak

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 71


void loop() {

durum_dongu=digitalRead(dongu); // dongu değişkenini atama yaptı

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

durum_arttir=digitalRead(arttir); // arttir değişkenini atama yaptı

durum_azalt=digitalRead(azalt); // azalt değişkenini atama yaptı

if(durum_arttir == HIGH){ // eğer arttırma butonuna basılırsa if’i işle

sayac++; // sayac değişkenini 1 arttır

Serial.println("sayac="); // ekrana yaz

Serial.println(sayac); // sayac değişkeninin değerini ekrana yaz

delay(200); // 200ms bekle

else if(durum_azalt == HIGH){ // değilse eğer azalt butonuna basıldıysa

sayac--; // sayac değişkenini 1 azalt

Serial.println("sayac="); // ekrana yaz

Serial.println(sayac); // sayac değişkeninin değerini ekrana yaz

delay(200); // 200ms bekle

durum_dongu=digitalRead(dongu); // switch açakmı kapalımı kontrol et

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 72


ÖRNEK PROGRAM (SWİTCH CASE YAPISI)

void loop() {

durum_dongu=digitalRead(dongu); // dongu değişkenini atama yaptı

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

durum_arttir=digitalRead(arttir); // arttir değişkenini atama yaptı

durum_azalt=digitalRead(azalt); // azalt değişkenini atama yaptı

if(durum_arttir == HIGH){ // eğer arttırma butonuna basılırsa if’i işle

sayac++; // sayac değişkenini 1 arttır

Serial.println("sayac="); // ekrana yaz

Serial.println(sayac); // sayac değişkeninin değerini ekrana yaz

delay(200); // 200ms bekle

else if(durum_azalt == HIGH){ // değilse eğer azalt butonuna basıldıysa

sayac--; // sayac değişkenini 1 azalt

Serial.println("sayac="); // ekrana yaz

Serial.println(sayac); // sayac değişkeninin değerini ekrana yaz

delay(200); // 200ms bekle

durum_dongu=digitalRead(dongu); // switch açakmı kapalımı kontrol et

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 73


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

case 1: // 1.değer okunmak istenirse

Serial.println("1. motor calisiyor"); // ekrana yazdır

break; // başa dön

case 2: // 2.değer okunmak istenirse

Serial.println("2. motor calisiyor"); // ekrana yazdır

break; // başa dön

case 3: // 3.değer okunmak istenirse

Serial.println("3. motor calisiyor"); // ekrana yazdır

break; // başa dön

case 4: // 4.değer okunmak istenirse

Serial.println("4. motor calisiyor"); // ekrana yazdır

break; // başa dön

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

Serial.println("yanlis deger girildi"); // ekrana yazdır

break; // başa dön

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 74


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

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

default:
Serial.println(“xxxx”);
break;
}

NOT; Yukarıdaki program örneğimizde sayac değişkeninin değeri 1 olursa ekrana


“1.motor calisiyor” yazmasını istedik. Aynı şekilde 1 ve 4 arasında bu örnekleri yaptık.

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

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

ÖRNEK;
case 1:

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 75


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

{
case = 1:
Serial.println(“motor calisiyor”);

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

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


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

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 76


14. BÖLÜM

FOR DÖNGÜSÜ

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 77


FOR DÖNGÜSÜ

for(başlama ; sınır/şart ; güncelleme)


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

int a; // a değişkeni atandı

void setup() {

Serial.begin(9600); // serial monitör kullanılacak

void loop() {

for(int b=0; b<10 ; b++) // 0’dan başlayacak 10’a kadar, 1 arttıracak

Serial.println("b="); // ekrana yazdır

Serial.println(b); // b değişkeninin değerini ekrana yazdır

delay(250); // 250ms bekle

Yukarıdaki programda for döngüsüne bakarsak, döngümüz başladığında b


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

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 78


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 pinleri çıkış olarak atandı

pinMode(3, OUTPUT); // led pinleri çıkış olarak atandı

pinMode(4, OUTPUT); // led pinleri çıkış olarak atandı

pinMode(5, OUTPUT); // led pinleri çıkış olarak atandı

pinMode(6, OUTPUT); // led pinleri çıkış olarak atandı

pinMode(7, OUTPUT); // led pinleri çıkış olarak atandı

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 79


void loop() {

for(int b=2; b<8 ; b++){ // 2’den, 8’e kadar birer birer arttır

digitalWrite(b, HIGH); // b’ye 5V ver (ledi yak)

delay(250); // 250ms bekle

digitalWrite(b, LOW); // b’ye 0V ver (ledi söndür)

delay(250); // 250ms bekle

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

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

void setup() {

pinMode(2, OUTPUT); // led pinleri çıkış olarak atandı

pinMode(3, OUTPUT); // led pinleri çıkış olarak atandı

pinMode(4, OUTPUT); // led pinleri çıkış olarak atandı

pinMode(5, OUTPUT); // led pinleri çıkış olarak atandı

pinMode(6, OUTPUT); // led pinleri çıkış olarak atandı

pinMode(7, OUTPUT); // led pinleri çıkış olarak atandı

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 80


void loop() {

for(int b=2; b<8 ; b++){ // 2’den, 8’e kadar birer birer arttır

digitalWrite(b, HIGH); // b’ye 5V ver (ledi yak)

delay(250); // 250ms bekle

for(int b=2; b<8 ; b++){ // 2’den, 8’e kadar birer birer arttır

digitalWrite(b, LOW); // b’ye 0V ver (ledi söndür)

delay(250); // 250ms bekle

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

for (int b=7 ; b>=2 ; b - -)

Değişken; b değişkenini en yukarıda “Global” tanımlama yapabilirsiniz. Loop


bölümünde “Local” tanımlamada yapabilirsiniz.

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


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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 81


15. BÖLÜM

BREAK VE CONTİNUE

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 82


BREAK VE CONTİNUE

Break; Hatırlayacağınız üzere break komutunu switch – case yapısındayken


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

1 Adet buton
1 adet 10Kohm direnç

int durum; // durum değişkeni atadık

void setup() {

pinMode(8, INPUT); // 8. Pini buton olduğu için giriş olarak atadık

Serial.begin(9600); // serial monitör kullanılacak

void loop() {

for(int b=0; b<20 ; b++) { // b değişkenini 20’ye kadar birer birer arttır

Serial.println(b); // b değişkeninin değerini ekranda göster

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 83


delay(500); // 500ms bekle

durum=digitalRead(b); // b değişkenini durum değişkenine ata

if (durum== HIGH) // if koşulu sağlanıyorsa veya butona basılırsa

break; // durdur

Serial.println("donguden cikildi"); // ekrana yazdır

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

FOR İLE KULLANIM

int durum; // durum değişkeni atadık

void setup() {

pinMode(8, INPUT); // 8. Pini buton olduğu için giriş olarak atadık

Serial.begin(9600); // serial monitör kullanılacak

void loop() {

for(int b=0; b<20 ; b++) { // b değişkenini 20’ye kadar birer birer arttır

Serial.println(b); // b değişkeninin değerini ekranda göster

delay(500); // 500ms bekle

if (b == 10) // eğer 10’a gelirse aşağıdaki kodu işle

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 84


{

break; // durdur

Serial.println("donguden cikildi"); // ekrana yazdır

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


defasında tekrarlanacak.

WHİLE İLE KULLANIM

int durum; // durum değişkeni atandı

int b=0; // 0 değeri b değişkenine atandı

void setup() {

pinMode(8, INPUT); // 8. Pin buton olduğu için giriş olarak atandı

Serial.begin(9600); // serial monitör kullanılacak

void loop() {

while(1) // 1’den başlayacak

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

Serial.println(b); // b değişkeninin değerini ekrana yaz

delay(500); // 500ms bekle

durum = digitalRead(8); // 8.pinin değerini durum değişkenine ata

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 85


if(durum == HIGH) { // buton’a basılırsa alt kodu işle

break; // durdur

Serial.println("donguden cikildi"); // ekrana yazdır

NOT; Yukarıdaki programda “while” döngüsü “while(1)” parantez içerisinde 1 koşul


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

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

void setup() {

Serial.begin(9600); // Serial monitör kullanıldı

void loop() {

for(int a=0; a<20 ; a++) { // a’nın değerini 20’ye kadar birer birer artır

if(a==6) { // eğer 6 rakamına gelince

continue; // 6 rakamını atla

Serial.println(a); // ekrana a değişkeninin değerini yaz

delay(500); } // 500ms bekle

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 86


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

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

1 Adet buton
1 adet 10Kohm direnç

int durum; // durum değişkeni atandı

void setup() {

Serial.begin(9600); // serial monitör kullanılacak

pinMode(8, INPUT); // 8. Pini giriş olarak atadık

void loop() {

for(int a=0; a<60 ; a++) // a, 60’a kadar birer birer artacak

{ durum = digitalRead(8); // 8 değerini durum değişkenine atama yaptık

if(durum == HIGH) // butona basılırsa aşağıdaki kodu işle

delay(250); // 250 ms bekle

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 87


continue; // atlama yaptı

Serial.println(a); // a değişken değerini ekrana yaz

delay(250); // 250ms bekle

N0T; Yukarıdaki programda her butona bastığımızda 1 sayı atlayacak ve kaldığı


yerden devam edecek.
“For” ile kullanılan “continue” aynı şekilde “while” komutu ile kullanılabilir.
Örnek programı aşağıda görebilirsiniz.

int durum; // durum değişkeni atandı

int a=0; // a değişkeninin değeri 0 oldu

void setup() {

Serial.begin(9600); // serial monitör kullanılacak

pinMode(8, INPUT); // 8. Pini giriş olarak atadık

void loop() {

while(1) { // 1’den başlayacak

a++; // int değeri kadar birer birer artacak

durum =digitalRead(8); // 8 değerini durum değişkenine atama yaptık

if (durum == HIGH) { // if koşulu sağlanıyorsa aşağıdaki kodu işle

delay(250); // 250 ms bekle

continue; // atlama yap

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 88


Serial.println(a); // a değişkeninin değerini ekrana yaz

delay(250); // 250 ms bekle

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

ÖZET OLARAK;
Break; Bu komut döngüden çıkartıyor.
Continue; Bir seferliğine mahsus bizim algoritmamızın çalışmasını bir miktar
engelliyor.

ÖNEMLİ NOT; “xxxx=xxxx+1;” ile “xxx++;” komutlarıx değişkenlerini 1 arttıran


komutlardır ve ikiside aynı işlemi yapar.

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 89


16. BÖLÜM

ANALOG GİRİŞ VE 10BİT ADC

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 90


ANALOG GİRİŞ VE 10BİT ADC

POTANSİYOMETRE İLE GELEN BİLGİYİ OKUMA

1 ADET POTANSİYOMETRE(100K)

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

void setup() {

Serial.begin(9600); // serial monitör kullanılacak

void loop() {

gelen_veri=analogRead(A0); // A0 değerini gelen_veri değişkenine atama yaptı

Serial.println(gelen_veri); // gelen_veri değeri ekrana yazıldı

delay(250); // 250ms bekledi

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 91


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

2x2x2x2x2x2x2x2x2x2

2 4 8 16 32 64 128 256 512 1024


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

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

2 2 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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 92


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

const int pot_pin=A0; // A0’a pot_pin değişken ismi verdik

int okunan_deger; // değişken tanımladık

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

void setup() {

Serial.begin(9600); // serial monitör kullanılacak

void loop() {

okunan_deger=analogRead(pot_pin); // okunan değer’e atama yap

Serial.print("okunan_deger"); // ekrana yazdır

Serial.println(okunan_deger); // değişkenin değerini ekrana yazdır

Serial.print("voltaj="); // ekrana yazdır

Serial.println((okunan_deger *5)/1023.0); // değeri yaz

delay(250); // 250ms bekle

VOLTAJ DEĞERİNİ HESAPLAMA


Gelen değer x 5V 5V =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”

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 93


UYGULAMA

ARDUİNO İLE LM35 KULLANIMI

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 94


UYGULAMA(ARDUİNO İLE LM35 KULLANIMI)

Bu projede LM35 ile sıcaklık bilgisini okuyacağız. Okuduğumuz sıcaklık bilgisine


bağlı olarak led yakacağız. Burada RGB led kullanacağız. RGB led sayesinde değerler
dahilinde renk elde edeceğiz.

220 veya 330 OHM direnç(3 adet) NOT: BU UYGULAMADA KULLANILAN


1 adet RGB LED(ANOT) RGB LED HAKKINDA BİLGİYİ, BU
1 ADET LM35 sıcaklık sensörü DERS SONUNDA BULABİLİRSİNİZ.

const int sensor_pin =A3; // analog 3. Pine değişken ismi verdik

const int k_led =5; // 5. Pine k_led değişken ismi verdik

const int y_led =4; // 4. Pine y_led değişken ismi verdik

const int m_led=3; // 3. Pine m_led değişken ismi verdik

int sensor_deger =0; // değişken tanımladık ve değeri 0 verdik

int voltaj_deger =0; // değişken tanımladık ve değeri 0 verdik

int sicakli_deger =0; // değişken tanımladık ve değeri 0 verdik

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 95


void setup() {

pinMode(k_led, OUTPUT); // RGB ledlerin sinyal bacakları çıkış olarak atandı

pinMode(y_led, OUTPUT); // RGB ledlerin sinyal bacakları çıkış olarak atandı

pinMode(m_led, OUTPUT); // RGB ledlerin sinyal bacakları çıkış olarak atandı

Serial.begin(9600); // Serial monitör kullanılacak

void loop() {

sensor_deger = analogRead(sensor_pin); // atama yapılacak

Serial.print("okunan deger="); // ekrana yazdır

Serial.println(sensor_deger); // değişkenin değerini ekrana yazdı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.

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 96


const int sensor_pin =A3; // analog 3. Pine değişken ismi verdik

const int k_led =5; // 5. Pine k_led değişken ismi verdik

const int y_led =4; // 4. Pine y_led değişken ismi verdik

const int m_led=3; // 3. Pine m_led değişken ismi verdik

int sensor_deger =0; // değişken tanımladık ve değeri 0 verdik

int voltaj_deger =0; // değişken tanımladık ve değeri 0 verdik

int sicakli_deger =0; // değişken tanımladık ve değeri 0 verdik

void setup() {

pinMode(k_led, OUTPUT); // RGB ledlerin sinyal bacakları çıkış olarak atandı

pinMode(y_led, OUTPUT); // RGB ledlerin sinyal bacakları çıkış olarak atandı

pinMode(m_led, OUTPUT); // RGB ledlerin sinyal bacakları çıkış olarak atandı

Serial.begin(9600); // Serial monitör kullanılacak

void loop() {

sensor_deger = analogRead(sensor_pin); // atama yapılacak

Serial.print("okunan deger="); // ekrana yazdır

Serial.println(sensor_deger); // değişkenin değerini ekrana yazdır

voltaj_deger =(sensor_deger /1023)/5000; // işlem yapar

Serial.print("gelen voltaj="); // ekrana yazdır

Serial.println(voltaj_deger); // ekrana değişkenin değerini yazdır

delay(250); // 250ms bekle

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 97


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

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

Float;Ayrıca float yani küsüratlı çıkış istiyorsak, float’ın hesaplandığı değişkende


mutlaka 2 tane değişken float olarak tanımlanması gerekiyor. Biz”voltaj_deger”, float
olarak tanımladık. 1023’ede “.0” eklersek(1023.0) bu iş tamamdır.

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

const int sensor_pin =A3; // analog 3. Pine değişken ismi verdik

const int k_led =5; // 5. Pine k_led değişken ismi verdik

const int y_led =4; // 4. Pine y_led değişken ismi verdik

const int m_led=3; // 3. Pine m_led değişken ismi verdik

int sensor_deger =0; // değişken tanımladık ve değeri 0 verdik

float voltaj_deger =0; // değişken tanımladık ve değeri 0 verdik

float sicaklik_deger =0; // değişken tanımladık ve değeri 0 verdik

void setup() {

pinMode(k_led, OUTPUT); // RGB ledlerin sinyal bacakları çıkış olarak atandı

pinMode(y_led, OUTPUT); // RGB ledlerin sinyal bacakları çıkış olarak atandı

pinMode(m_led, OUTPUT); // RGB ledlerin sinyal bacakları çıkış olarak atandı

Serial.begin(9600); // Serial monitör kullanılacak

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 98


void loop() {

sensor_deger = analogRead(sensor_pin); // atama yapılacak

Serial.print("okunan deger="); // ekrana yazdır

Serial.println(sensor_deger); // değişkenin değerini ekrana yazdır

voltaj_deger =(sensor_deger /1023)/5000; // işlem yapar

Serial.print("gelen voltaj="); // ekrana yazdır

Serial.println(voltaj_deger); // ekrana değişkenin değerini yazdır

sicaklik_deger=voltaj_deger/10.0; // gerekli işlemi yaptı

Serial.print("sicaklik"); // ekrana yazdır

Serial.println(sicaklik_deger); // ekrana değişkenin değerini yazdır

Serial.println("derece"); // ekrana yazdır

delay(250); // 250ms bekle

NOT; Yukarıdaki programda “62 biti, voltajı, dereceyi” görebiliriz. “sicaklik_deger”


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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 99


const int sensor_pin =A3; // analog 3. Pine değişken ismi verdik

const int k_led =5; // 5. Pine k_led değişken ismi verdik

const int y_led =4; // 4. Pine y_led değişken ismi verdik

const int m_led=3; // 3. Pine m_led değişken ismi verdik

int sensor_deger =0; // değişken tanımladık ve değeri 0 verdik

float voltaj_deger =0; // değişken tanımladık ve değeri 0 verdik

float sicaklik_deger =0; // değişken tanımladık ve değeri 0 verdik

void setup() {

pinMode(k_led, OUTPUT); // RGB ledlerin sinyal bacakları çıkış olarak atandı

pinMode(y_led, OUTPUT); // RGB ledlerin sinyal bacakları çıkış olarak atandı

pinMode(m_led, OUTPUT); // RGB ledlerin sinyal bacakları çıkış olarak atandı

Serial.begin(9600); // Serial monitör kullanılacak

void loop() {

sensor_deger = analogRead(sensor_pin); // atama yapılacak

Serial.print("okunan deger="); // ekrana yazdır

Serial.println(sensor_deger); // değişkenin değerini ekrana yazdır

voltaj_deger =(sensor_deger /1023)/5000; // işlem yapar

Serial.print("gelen voltaj="); // ekrana yazdır

Serial.println(voltaj_deger); // ekrana değişkenin değerini yazdır

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 100


sicaklik_deger=voltaj_deger/10.0; // gerekli işlemi yaptı

Serial.print("sicaklik"); // ekrana yazdır

Serial.println(sicaklik_deger); // ekrana değişkenin değerini yazdır

Serial.println("derece"); // ekrana yazdır

delay(500); // 500ms bekle

if(sicaklik_deger>=35){ // şart sağlanıyorsa kodu işle

digitalWrite(k_led, LOW); // Ledi yak, (RGB Bölümünü okuyunuz)

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

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

else if (sicaklik_deger = 35 && sicaklik_deger >=30){ // koşul sağlanıyorsa işle

digitalWrite(k_led, LOW); // Ledi yak, (RGB Bölümünü okuyunuz)

digitalWrite(y_led, LOW); // Ledi yak, (RGB Bölümünü okuyunuz)

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

else if(sicaklik_deger<30){ // koşul sağlanıyorsa işle

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

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

digitalWrite(m_led, LOW); // Ledi yak, (RGB Bölümünü okuyunuz)

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.

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 101


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

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

ANOT RGB LED


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

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 102


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

NOT; Bu bacakları 5V’a bağlayacağız.

Örnek Programı inceleyelim.

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

1 Adet RGB Led


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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 103


const int k_led=11; // 11. Pini k_led değişkenine atama yap

const int y_led=10; // 10. Pini y_led değişkenine atama yap

const int m_led=9; // 9. Pini m_led değişkenine atama yap

void setup() {

pinMode(k_led, OUTPUT); // RGB Bacaklarının renk bacakları çıkış

pinMode(y_led, OUTPUT); // RGB Bacaklarının renk bacakları çıkış

pinMode(m_led, OUTPUT); // RGB Bacaklarının renk bacakları çıkış

void loop() {

digitalWrite(k_led, LOW); // kırmızı ledi yak

digitalWrite(y_led, HIGH); // yeşil ledi söndür

digitalWrite(m_led, HIGH); // mavi ledi söndür

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

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

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 104


17. BÖLÜM

ANALOG ÇIKIŞ – PWM

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 105


ANALOG ÇIKIŞ – PWM

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

1 adet 100k Potansiyometre


1 adet buzzer

const int pot_pin = A0; // analog 0. Pin’de değişken atadık

const int buzzer =11; // 11 digital(PWM) pine değişken tanımladık

int durum=0; // değişken tanımladık ve değerini 0 dedik

int cikti=0; // değişken tanımladık ve değerini 0 dedik

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 106


void setup() {

pinMode(buzzer, OUTPUT); // buzzer pini çıkış olarak atandı

Serial.begin(9600); // serial monitör kullanılacak

void loop() {

durum = analogRead(pot_pin); // atama yapıldı durum değişkenine

Serial.println(durum); // durum değişkeninin değerini ekrana yaz

cikti =map(durum, 0,1023, 0,255); // buzzer pini çıkış olarak atandı

analogWrite(buzzer, cikti); // senkronize ediyor

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

SENKRONİZE TANIMI; Eş zamanlama veya eşleşme, eş güdümlü çalışan


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

Senkronize etmemiz için “map” komutunu kullanacağız.


Bu komutu isterseniz direk durum değişkeni üzerinde yeni bir atama yaparak
kullanabilirsiniz. İstersenizde “map” komutundan çıkacak olan veriyi yeni bir değişkene
atayabilirsiniz. Biz programımızda yeni bir değişkene atadık.
Programımızda “cikti=map(durum, 0,1023, 0,255);” kod satırında 0-1023 ile 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.

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 107


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

1)Eski formatın en düşük değeri = 0


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

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

analogWrite(buzzer, 0-255 arası deger);

Programımızda “analogWrite(buzzer, ?);” bu komut satırında soru işareti yerine


“HIGH veya LOW” gelmeyecek çünkü HIGH veya LOW değerleri digital işlemleri
gerçekleştirir. Biz burada “cikti” değişkeni ile çalışacağız. Çünkü biz map kullanarak
kendimize değer oluşturduk ve bu oluşturduğumuz değerde sürmek istiyoruz.
“analogWrite(buzzer, cikti);” sadece buzzer değil birçok bileşenide kullanabilirsiniz(led).

AKILDA KALANLAR;

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

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 108


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.

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 109


DİGİTAL SİNYAL

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

ANALOG SİNYAL

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


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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 110


ANALOG SİNYALLER İLE RGB LED

const int kled =11; // 11 pini kled dedik

const int yled =10; // 10 pini yled dedik

const int mled =9; // 9 pini mled dedik

void setup() {

pinMode(kled, OUTPUT); // RGB Ledlerin sinyal bacakları çıkış

pinMode(yled, OUTPUT); // RGB Ledlerin sinyal bacakları çıkış

pinMode(mled, OUTPUT); // RGB Ledlerin sinyal bacakları çıkış

void loop() {

analogWrite(kled, 255-150); // analog çıkış ile parlaklık ayarlandı

analogWrite(yled, 255-0); // analog çıkış ile parlaklık ayarlandı

analogWrite(mled, 255-0); // analog çıkış ile parlaklık ayarlandı

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 111


18. BÖLÜM

FONKSİYONLAR -1-

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 112


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() { // fonksiyon oluşturduk

Serial.println("fonksiyon basladi"); // ekrana yazdır

delay(2500); // 2500ms (2.30 saniye)bekle

Serial.println("fonksiyon calismaya devam ediyor"); // ekrana yazdır

delay(2500); // 2500ms (2.30 saniye)bekle

Serial.println("fonksiyon birazdan biticek"); // ekrana yazdır

delay(2500); // 2500ms (2.30 saniye)bekle

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 113


void setup() {

Serial.begin(9600); // Serial monitör kullanılacak

void loop() {

Serial.println("sistem calismaya basladi"); // ekrana yazdır

delay(2000); // 2000ms (2 saniye)bekle

fonksiyon1(); // fonksiyon1 değişkenini kullan

delay(1000); // 1000ms (1 saniye)bekle

Serial.println("program calismayi bitirdi"); // ekrana yazdır

while(1); // bir kere döndür programı

“fonksiyon1();” Pazantez içine birşey yazmamamızın nedeni bizim


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

NOT; Pin tanımlamalarını aynı şekilde fonksiyon tanımlamamızın en üstüne


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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 114


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

2 Adet 220 veya 330 OHM direnç


1 Adet 10K direnç
1 Adet led
1 Adet buton
1 Adet buzzer

const int led_pin =3; // 3. Pine led_pin ismini verdik

const int buzzer_pin =2; // 2. Pine buzzer_pin ismini verdik

const int buton_pin=4; // 4. Pine buton_pin ismini verdik

int buton_durum =0; // değişken tanımladık

void basla(){ // fonksiyon tanımladık

digitalWrite(led_pin, HIGH); // ledi yak

delay(200); // 200ms bekle

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

delay(200); // 200ms bekle

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 115


void baslama(){ // fonksiyon tanımladık

digitalWrite(buzzer_pin, HIGH); // buzzeri çalıştır

delay(200); // 200ms bekle

digitalWrite(buzzer_pin, LOW); // buzzeri durdur

delay(200); // 200ms bekle

void setup() {

pinMode(led_pin, OUTPUT); // ledi çıkış olarak atadık

pinMode(buzzer_pin, OUTPUT); // buzzeri çıkış olarak atadık

pinMode(buton_pin, INPUT); // butonu giriş olarak atadık

void loop() {

buton_durum = digitalRead(buton_pin); // buton_pin durumunu atama yaptık

if(buton_durum == HIGH){ // if koşulu sağlanıyorsa çalıştır

basla(); // “basla()” fonksiyonunu çalıştır

else if(buton_pin == LOW){ // else if koşulu sağlanıyorsa

baslama(); // “baslama()” fonksiyonunu çalıştır

NOT; Yukarıdaki programda void olarak tanımladığımız değişkenden istediğimiz


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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 116


19. BÖLÜM

FONKSİYONLAR -2-

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 117


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ç

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 118


const int buton1 =2; // 1. 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ı

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 119


else if (eksi == HIGH){ // 24. 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ı

break; // 32. Kod satırı

durum = digitalRead(buton3); // 33. Kod satırı

return sayac; // 34. Kod satırı

void setup() {

pinMode(buton1, INPUT); // 35. Kod satırı

pinMode(buton2, INPUT); // 36. Kod satırı

pinMode(buton3, INPUT); // 37. Kod satırı3

pinMode(led , OUTPUT); // 38. Kod satırı

Serial.println(9600); // 39. Kod satırı

void loop() {

tur_sayisi = fonksiyon2(); // 40. Kod satırı

for(int i=0; i<tur_sayisi ; i++) { // 41. Kod satırı

digitalWrite(led , HIGH); // 42. Kod satırı

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 120


delay(100); // 43. Kod satırı

digitalWrite(led, LOW); // 44. Kod satırı

delay(100); // 45. Kod satırı

while(1) // 46. Kod satırı

durum = digitalRead(buton3); // 47. Kod satırı

if(durum == HIGH) // 48. Kod satırı

break; // 49. Kod satırı

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

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


atadık.

 Buton1’den okunan değeri “arti” değişkenine, buton2’den akunan değeri “eksi”


değişkenine, buton3’den okunan değeride “durum” isimli değişkene kayıt
edeceğiz.

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

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

 Fonksiyon tanımlanırken bize üç adet bilgi gerekliydi.(void – int – float).


Geçtiğimiz derste void kullanmıştık. Çünkü değer döndürmeyen olduğu için void
kullandık. Yukarıdaki programda int kullandık. Çünkü değer döndüren fonksiyon
yapıyoruz.

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 121


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

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

 13. ve 14. Kod satırında, “if(arti==HIGH)” ve “if(eksi==HIGH)” kodları için okuma


işlemi yapan kodları yazıyoruz. Bu sayede “arti” ve “eksi” adlı değişkenleri
“buton1” – “buton2”’den okuyup kayıt etmiş olduk. Buna bağlı kalarakta
sayıcımız artacak veya azalacak.

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

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

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

 “fonksiyon2()” burada parantez koymamız şart yoksa çalışmaz. Parantez içine


parametre yazmasak bile parantez koymalıyız.”( )”

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

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

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

 Bu sayede buton’a basılma işlemi bitince, while’den çıkacak. Buton’a her


bastığımızda bir kere arttırma işlemi yapacak.

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 122


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

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

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

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

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 123


20. BÖLÜM

FONKSİYONLAR -3-

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 124


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

delay(100); // 8. KOD SATIRI

void setup() {

digitalWrite(led, OUTPUT); // 9. KOD SATIRI

Serial.begin(9600); // 10. KOD SATIRI

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 125


void loop() {

Serial.println("algoritma calismaya basliyor"); // 11. KOD SATIRI

delay(2500); // 12. KOD SATIRI

tur_sayisi=10; // 13. KOD SATIRI

fonksiyon3(tur_sayisi); // 14. KOD SATIRI

Serial.println("algoritma bitti"); // 15. KOD SATIRI

while(1); // 16. KOD SATIRI

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.

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 126


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

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

HESAP MAKİNESİ UYGULAMASI

int a; // 1. KOD SATIRI

int b; // 2. KOD SATIRI

int toplam; // 3. KOD SATIRI

void topla(int a, int b){ // 4. KOD SATIRI

toplam = a+b; // 5. KOD SATIRI

void setup() {

Serial.begin(9600); // 6. KOD SATIRI

void loop() {

a=5; // 7. KOD SATIRI

b=16; // 8. KOD SATIRI

topla(a,b); // 9. KOD SATIRI

Serial.print("toplam="); // 10. KOD SATIRI

Serial.println(toplam); // 11. KOD SATIRI

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 127


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

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

 Bu arada 4. Kod satırında a ve b yerine “h ve g” gibi harfler yazılabilir. Oraya


yazılanların aynısı 5. Kod satırında yazılmalıdır.

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


edecek.

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

 Bu program algoritmanın toplam adlı fonksiyonunda a ve b değerlerini 5 ve 16


değerlerini toplam adlı değişkene kayıt etmesi gerekiyor.

int a; // 1. KOD SATIRI

int b; // 2. KOD SATIRI

int toplam; // 3. KOD SATIRI

int cikartma; // 4. KOD SATIRI

void topla(int a, int b){ // 5. KOD SATIRI

toplam = a+b; // 6. KOD SATIRI

void cikart(int z, int y){ // 7. KOD SATIRI

cikartma= b-a; // 8. KOD SATIRI

void setup() {

Serial.begin(9600); // 9. KOD SATIRI

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 128


void loop() {

a=5; // 10. KOD SATIRI

b=16; // 11. KOD SATIRI

topla(a,b); // 12. KOD SATIRI

Serial.print("toplam="); // 13. KOD SATIRI

Serial.println(toplam); // 14. KOD SATIRI

cikart(b,a); // 15. KOD SATIRI

Serial.print("sonuc="); // 16. KOD SATIRI

Serial.println(cikartma); // 17. KOD SATIRI

while(1); // 18. KOD SATIRI

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.

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 129


21. BÖLÜM

FONKSİYONLAR -4-

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 130


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


ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 131
float tt= s/ 6.0;

return tt;
float fonksiyonbolme(int s, int g) { // 14. KOD SATIRI

float tt= s/ 6.0; // 15. KOD SATIRI

return tt; // 16. KOD SATIRI

void setup(){

Serial.begin(9600); // 17. KOD SATIRI

void loop(){

int a=5; // 18. KOD SATIRI

int b=6; // 19. KOD SATIRI

toplam = fonksiyonarti(a,b); // 20. KOD SATIRI

cikarma = fonksiyoneksi(a,b); // 21. KOD SATIRI

carpma = fonksiyoncarpma(a,b); // 22. KOD SATIRI

bolme = fonksiyonbolme(a,b); // 23. KOD SATIRI

Serial.print("toplam="); // 24. KOD SATIRI

Serial.println(toplam); // 25. KOD SATIRI

Serial.print("cikarma="); // 26. KOD SATIRI

Serial.println(cikarma); // 27. KOD SATIRI

Serial.print("carpma="); // 28. KOD SATIRI

Serial.println(carpma); // 29. KOD SATIRI

Serial.print("bolme="); // 30. KOD SATIRI

Serial.println(bolme); // 31. KOD SATIRI

while(1); // 32. KOD SATIRI

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 132


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

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

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

 Hatırlatma olarak 18. ve 19. Kod satırlarındaki a ve b değişken isimlerini


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

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

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 133


22. BÖLÜM

MİLLİS – MİCROS – DELAY –


DELAYMİCROSECONDS

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 134


MİLLİS – MİCROS – DELAY – DELAYMİCROSECONDS

Bu bölümde zaman fonksiyonlarını inceleyeceğiz. delay, delayMicroseconds,


millis, micro.

delay(); Bu komut milisaniye’yi kendine parametre olarak alıyor. Parantez içine


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

1000 milisaniye = 1 saniye


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

delayMicrosaniye(); Bu fonksiyonda parametre değerleri mikronsaniye


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

1 saniye = 1000 milisaniye


1 milisaniye = 1000 mikronsaniye

void setup() {

pinMode(4, OUTPUT);

void loop() {

digitalWrite(2, HIGH);

delayMicroseconds(35000);

digitalWrite(2, LOW);

delayMicroseconds(35000);

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 135


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

millis();

unsigned long simdikizaman;

void setup() {

Serial.begin(9600);

void loop() {

simdikizaman = millis();

Serial.println(simdikizaman);

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

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 136


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

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


olarak hesaplanıyor.

 Örnek programımızda bu veri tipinin en sonuna geldiği zaman millis fonksiyonu,


“simdikizaman” değişkenini sıfırlayacak.

50 GÜNE DENK GELMESİ

1 GÜN = 24

1 SAAT/DAKİKA = 60

1 DAKİKA/SANİYE = 60

KAÇ MİLİSANİYE/DK = 1000

VERİ TİPİ = 4.294.967.295

24 X 60 =1440 X 60 = 86400 X 1000 =


86400000

4.294.967.295 / 86400000 = 49.7 GÜN

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 137


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

const int led =3; // 1. KOD SATIRI

unsigned long simdikizaman; // 2. KOD SATIRI

unsigned long oncekizaman; // 3. KOD SATIRI

int aralik =1000; // 4. KOD SATIRI

boolean durum = HIGH; // 5. KOD SATIRI

void setup() {

pinMode(led, OUTPUT); // 6. KOD SATIRI

Serial.begin(9600); // 7. KOD SATIRI

void loop() {

simdikizaman = millis(); // 8. KOD SATIRI

Serial.println(simdikizaman); // 9. KOD SATIRI

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 138


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.

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 139


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

 Sonra 10. Kod satırında “oncekizaman” 0 kaldığı için


“simdikzaman” arttığı için 11. Kod satırını yazarak sürekli kontrol
ediyoruz.

delay komutu milisaniye cinsinde işlem yapıyorsa,


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

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

unsigned long simdikizaman; // değişken tanımladık

void setup() {

Serial.begin(9600); // serial monitör kullanılacak

void loop() {

simdikizaman = micros(); // işlem micros cinsinden yapılacak

Serial.println(simdikizaman); // simdikizaman değişken değeri ekrana yazılacak

NOT; “simdikizaman” değişkeni veya bu değerlikli değişkenleri “unsigned long” olarak


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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 140


23. BÖLÜM

TEK BOYUTLU DİZİLER (ARRAY)

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 141


TEK BOYUTLU DİZİLER (ARRAY)

DİZİLER; Belli miktardaki verileri toplu olarak tutmaya yarıyor. Örnek programı
inceleyelim.

int ogrenci1 =01;

int ogrenci2 =20;

int ogrenci3 =23;

int ogrenci4 =45;

int ogrenci5 =18;

int ogrenci6 =33;

int ogrenci7 =62;

int ogrenci8 =73;

int ogrenci9 =12;

int ogrenci10 =86;

void setup() {

Serial.begin(9600);

void loop() {

Serial.println(ogrenci1);

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 142


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

void setup() {

Serial.begin(9600);

void loop() {

Serial.println(ogrenciler[5]);

NOT; Yukarıdaki programda, serial monitörde 5. öğrencinin notu görülmesi gerekiyor


fakat 6. öğrencinin notu görünüyor. Bunun nedeni ise 1’den değil 0’dan başlıyor olması.
Bizim dizilerimiz 0’dan başlıyor.

VERİ TİPİ XXX[X] = {X,X,X,X,X,X,X,X};

EN YUKARIYA YAZILIR.

Serial.println( xxx[x]);

LOOPA YAZILIR.

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

 Aynı şekilde buradada öğrencinin notunu değiştirmek istiyorsak, loop


bölümünde en başa “ogrenciler[5]=100;” yazarak varolan notu 100 ile
değiştiriyoruz.

 Genel olarak dizilerin nasıl kullanıldıklarını öğrenmiş olduk; Diziler bizi


fazla satır kod yazmaktan kurtarır.

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 143


KURALLAR
 Dizinin boyutunu başta belitmesekte olur.

ÖRNEK;
int ogrenciler[ ] = {50,55,60…};

 Bu sefer algoritmamız “{xxxxx};” kaç tane değer vermişsek o kadar yerlik


yer açar( [ ] ).

 Biz “[ x x x x ];” içerisine 10 tane değer atadıysa otomatik olarak “( [ ] );”


boş bıraksak bile dizi kendini 10 atayacak.

 Dizi belirtirken mutlaka [ ] boşta olsa köşeli parantez yazılmalıdır aksi


taktirde hata vericektir.

 Diziye değer vermeyeceksek, diziyi boş bırakırsak “{ x x x }” burada değer


belirtmek zorundayız aksi taktirde hata vericektir.

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

ÖRNEK; “int ogrenciler[10] = {1,2,3,4,5};” Burada dizinin değeri 10,


“{ x x x }” süslü parantez içerisine 5 değer atadık. Böyle durumda otomatik olarak, 10
tane yer açtık, 5 değer verdiğimiz için otomatik olarak geriye kalan 5’e sıfır değerleri
atanır.

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 144


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

void setup() {

Serial.begin(9600);

void loop() {

Serial.println(ogrenciler[8]);

NOT; Yukarıdaki programı çalıştırdığımızda, ekrana otomatik olarak sıfır değeri


gelecektir. Çünkü 8 olarak bir değer atamadık.

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

int y;

void setup() {

Serial.begin(9600);

void loop() {

ogrenciler[0] =y;

Serial.println(ogrenciler[0]);

NOT; Şimdi bu dizilerin değer atamalarına bakalım. Yukarıdaki programda, “int=y;”


adında değişken atadık. Biz bu “y” değişkenine istersek diziden bir eleman atayabiliriz.

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 145


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

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

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

int y =800;

void setup() {

Serial.begin(9600);

void loop() {

ogrenciler[0] =y;

Serial.println(ogrenciler[0]);

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

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

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 146


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

char klavye[5] = { 'a' , 'b', 'c' , 'd'};

void setup() {

Serial.begin(9600);

void loop() {

Serial.println(klavye[3]);

NOT; Yukarıdaki programda 3. Karakteri ekrana yazdırırız. 0(sıfır)’dan saymaya


başladığımız için “d” harfi ekranda görülecek.

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

char klavye[5] = { 'a' , 'b', 'c' , 'd'};

char fare = 't';

void setup() {

Serial.begin(9600);

void loop() {

klavye[1] = fare;

Serial.println(klavye[1]);

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 147


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

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

int ogrenciler[10] = {15,25,35,45,55,65,67,43,49,37}; // 1. Kod satırı

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ı

delay(500); // 8. Kod satırı

while(1); // 9. Kod satırı

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 148


24. BÖLÜM

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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 149


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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 150


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

0 1 2 3 4

0 13 12 11 10 9 Ö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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 151


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

void setup() {

Serial.begin(9600);

void loop() {

ogrenciler[0] [1] = 189;

Serial.println(ogrenciler [0] [1]);

Yukarıdaki örnek programımızda 2’nin değerini


189 sayısı ile değiştiriyoruz.

ogrenciler[0][1] = 189;

DEĞİŞTİRİLECEK YENİ DEĞER

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

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

void setup() {

Serial.begin(9600);

void loop() {

for(int j=0; j<3 ; j++){

for(int i=0; i<5 ; i++)

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 152


Serial.print("//");

Serial.print(j);

Serial.print(" * ");

Serial.print(i);

Serial.print("=");

Serial.print(ogrenciler [j][i]);

delay(500);

Serial.println();

while(1);

Bu program sayesinde tabloyu sırasıyla önce


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

ADIM ADIM ARDUİNO – SENCER ALTUN Sayfa 153