ARDUİNO 301

(Arduino bilgimizi örnek

uygulamalarla
pekiştiriyoruz)
Arduino'da Analog Sinyal Üretme
Arduino pinlerinin çıkış olarak ayarlandığında 0 veya 5 volt verebildiğini daha önce öğrenmiştik.
Arduino üzerinden 0 ile 5 volt arasında çıkış gerilimi verebilmek için analog sinyal üretmeliyiz. Bu
sinyali Arduino'nun tüm pinleri üretememektedir. Bu sinyalin üretimi için seçilecek pinlerin PWM
çıkışa sahip olması gerekir. Üretilen analog sinyalin genliğiyle motor hız kontrolü, LED
parlaklığının ayarlanması gibi uygulamalar yapılmaktadır.

Hatırlatma: Kullandığınız kartın üzerindeki PWM çıkışları öğrenmek için Arduino'nun web sitesine
bakabilirsiniz.

PWM sinyali daha önce servo motor kontrolünde öğrenmiştik. Arduino üzerinden üretilin analog
sinyal aslında bir PWM sinyalidir. Analog çıkışın gerilimi, PWM sinyalinin görev zamanıyla (duty
cycle) doğru orantılı olarak değişmektedir. Örneğin %50 görev zamanına sahip bir PWM sinyali
üretildiğinde çıkış geriliminin 2,5 volt olduğu görülmektedir.

Aşağıdaki resimde PWM sinyalinin görev zamanıyla çıkış gerilimi arasındaki doğru orantı
gösterilmiştir:
Her ne kadar analog çıkış denilse bile aslında bu pinlerden PWM sinyali üretildiği için, bazı
uygulamalarda alçak geçiren filtre kullanılması gerekebilir. Alçak geçiren filtre, yüksek frekansa
sahip sinyalleri süzerek sadece düşük frekanstaki sinyallerin kullanılmasını sağlar, yani sinyali
yumuşatır. Bu filtre PWM sinyaline uygulandığında dalga tepeleri ve çukurlarını birleştirerek,
dalga tepesi ve çukurları oranında sabit bir çıkış gerilimi sağlamaktadır.

Alçak geçiren filtrenin devre şeması aşağıdaki resimde gösterilmiştir. Bu filtredeki direnç ve
kapasitenin değerine göre, filtrenin hassasiyeti değiştirilebilir.

Motorların hız kontrolü ve LED ışığın parlaklığının ayarlanması gibi projelerde alçak geçiren filtre
kullanılmasına gerek yoktur. Bu filtre sadece kesin olarak sabit analog değere ihtiyaç duyan
hassas uygulamalarda kullanılmaktadır.

Analog sinyalin üretilmesi için, daha önce temel Arduino fonksiyonlarında öğrendiğimiz
analogWrite fonksiyonu kullanılır. Bu fonksiyon iki giriş değişkenine ihtiyaç duymaktadır. Bu
değişkenlerden ilki analog çıkışın yapılacağı pini belirler. İkinci değişken ise çıkış geriliminin
belirleyecek PWM sinyalinin görev zamanıdır. Buraya 0 ile 255 arasındaki değerler yazılır.
Fonksiyona 0 değeri yollandığında bu pinden 0 volt, 255 değeri yollandığında 5 volt düzeyinde
çıkış gerilimi alınır.

Çıkış gerilimi 0 - 255 değerleriyle doğru orantılı olarak değişmektedir. Örneğin, 3,3 volt çıkış
gerilimine sahip olmak için fonksiyona 168 değeri yazılmalıdır. Bu sinyal Arduino'nun 10. pininden
alınmak istenseydi fonksiyon analogWrite(10,168); şeklinde yazılırdı.
Değişken Parlaklığa Sahip LED Işık
Bu uygulamada, Arduino'ya bağlanan 3 farklı LED'in parlaklıkları üretilen analog sinyallerle ayrı
ayrı kontrol edilmektedir. Arduino her 500 milisaniyede bir 1. LED'in parlaklığını azaltırken, 3.
LED'in parlaklığını artırmaktadır. 2. LED'in parlaklığı ise 'LEDParlaklıgi' dizisindeki rastgele
parlaklık değerlerine göre kontrol edilmektedir. Bu uygulamadaki amaç analogWrite fonksiyonuyla
analog sinyalin nasıl üretildiğini öğrenmek ve fonksiyona verilen değerlerle sinyalin değişimini
gözlemlemektir.

Bu uygulamayı yapmak için ihtiyacımız olan malzemeler:

 1 x Arduino
 1 x breadboard
 3 x LED
 3 x 220 ohm direnç

/* LED pinleri 9,10,11 olarak belirlendi */

const int LED1= 9, LED2 = 10, LED3 = 11;

/*
LED Parlaklıklarının tutulduğu değişkenler tanımlandı
LED1 tam yanık pozisyona, LED3 tam sönük pozisyonda başlatılacak
LED2 rastgeleParlakliklar dizisinden parlaklık değerlerini alacak
*/
int LED1Parlakligi = 255,LED2Parlakligi=0,LED3Parlakligi = 0;

/* LED2 için rastgele parlaklık değerleri tanımlandı */

int rastgeleParlakliklar[20] =
{182,183,10,125,152,102,88,6,95,1,245,178,224,227,74,62,196,177,254,116}
;
void setup()
{
/* LED pinleri çıkış olarak ayarlandı */
pinMode(LED1,OUTPUT);
pinMode(LED2,OUTPUT);
pinMode(LED3,OUTPUT);
}

void loop()
{
/* LED1 parlaklığı LED1Parlakligi değişkeninin değeri olarak
ayarlandı */
analogWrite(LED1,LED1Parlakligi);
/* LED1 parlaklığı bir azaltıldı */
LED1Parlakligi --;
/* Eğer LED1 parlaklığı 0'dan az olur ise tam yanık pozisyona
ayarlandı */
if(LED1Parlakligi < 0)
LED1Parlakligi = 255;

/* LED1 parlaklığı rastgeleParlakliklar dizisinin LED2Parlakligi.

elemanın değeri olarak ayarlandı */
analogWrite(LED2,rastgeleParlakliklar[LED2Parlakligi]);
/* rastgeleParlakliklar dizisinin bir sonraki elemanına geçiş
yapıldı */
LED2Parlakligi ++;
/* Dizi sınırlarından çıkılmaması için koşul eklendi */
if(LED2Parlakligi>19)
LED2Parlakligi = 0;

/* LED3 parlaklığı LED1Parlakligi değişkeninin değeri olarak

ayarlandı */
analogWrite(LED3,LED3Parlakligi);
/* LED3 parlaklığı bir azaltıldı */
LED3Parlakligi ++;
/* Eğer LED3 parlaklığı 0'dan az olur ise tam yanık pozisyona
ayarlandı */
if(LED3Parlakligi > 255)
LED3Parlakligi = 0;

delay(25);
}
Yukarıda belirtildiği gibi devre kurulduktan sonra Arduino'ya kod yüklenmelidir. analogWrite
fonksiyonuyla LED parlaklıkları istenilen değere ayarlanmıştır. Bu bölümde analogWrite
fonksiyonu kullanılarak 0 ile 5 volt arasındaki gerilimlerin projelere uygun olarak nasıl üretildiğini
öğrenmiş olduk.
Arduino ile DC Motor Sürme
Arduino projeleri denildiğinde akla ilk gelen DC motorla kontrol edilen otonom araçlardır. Bu
bölümde DC motorun Arduino ile nasıl kontrol edileceğini öğreneceğiz. DC motorun ileri veya geri
dönmesinin yanında, dönme hızını da Arduino üzerinden kontrol edeceğiz. Arduino pinlerinden
verilebilen akım motorları çalıştırmak için yeterli olmamaktadır. Bu yüzden DC motorlar, motor
sürücülerle kullanılmalıdır. Motor sürücüsü kullanmadan doğrudan motoru Arduino'ya bağlamak,
Arduino'nun pinlerine zarar verebilir.

DC motorları kullanmak için motor sürücüsünü hazır devre kartı olarak alabileceğiniz gibi kendiniz
de devreyi kurabilirsiniz. Fakat devre üzerinde çok fazla bağlantı olduğu için, devreye yeni
fonksiyonlar da eklendiğinde devre karışıklığı artmaktadır.

Sistemin nasıl çalıştığını kavrayabilmek için bir kereye mahsus olsa da devrenin hazır kart
kullanılmadan kurulması yararlı olabilir. DC motorlar için Arduino pinlerinden çıkan akımı
kuvvetlendirmek ve motorların hızını kontrol etmek için L298 entegresini kullanacağız. Benzer
entegreler de aynı görevi yapmaktadır. L298 entegresinin en önemli özellikleri, 2 ampere kadar
dayanabilmesi ve iki adet H köprüsünün bulunmasıdır.

Not: H Köprüsü DC motorların ileri ve geri yönde hareket etmesini sağlayan devredir. Devrede 2
adet NPN ve 2 adet PNP transistör bulunur.

L298 entegresiyle motor sürücü kartının yapımı

L298 entegresinde 15 adet pin bulunmaktadır. Bu pinlerden bazıları motorlara, bazıları Arduino'ya
bazıları ise besleme kaynağına bağlanacaktır. L298 entegresinin pinleri aşağıdaki resimde
gösterilmiştir.
Entegre üzerinde bulunan pinlere ve bu pinlerin görevlerine kısaca göz atalım:

 INPUT 1, 2, 3 ve 4 (5, 7, 10 ve 12. pinler): INPUT pinleri motorların dönme yönünün

kontrolü için Arduino'ya bağlanır. INPUT 1 ve 2 pinleri 1. motorun, INPUT 3 ve 4 pinleri
ise 2. motorun kontrolünde kullanılır. Örneğin 1. Motorun kontrolü için, INPUT 1 pini 5
volt, INPUT 2 pini 0 volt yapılır ise motor ileri yönde dönmeye başlar. Eğer INPUT 1 pini 0
volt ve INPUT 2 pini 5 volt yapılır ise motor geri yönde dönmeye başlar. İki pinin aynı
anda 5 volt olması motoru kilitleyerek fren yapmasını sağlar. İki pininde 0 volt düzeyinde
olması ise motorun boşta olmasına neden olup kısa süre sonra motorun durmasını
sağlar.
 OUTPUT 1, 2, 3 ve 4 (2, 3, 13 ve 14. pinler): Bu pinler motorlara bağlanan pinlerdir.
OUTPUT 1 ve 2. pinler 1. Motora, OUTPUT 3 ve 4. pinler ise 2. motora bağlanır.
 ENABLE A ve ENABLE B (6. ve 11. pinler): Bu iki pin motorların dönüş hızını ayarlamak
için kullanılır. Bu yüzden bu pinleri Arduino'nun PWM ayaklarına bağlamamız gerekir.
PWM sinyalinin görev zamanına göre motorun hızı arttırılabilir veya azaltılabilir. ENABLE
A pini 1. motorun, ENABLE B pini ise 2. motorun hızını kontrol etmek için kullanılır. Eğer
hız kontrolü yapılmayacak sa bu pinler 5 volt hattına bağlanabilir.

Hatırlatma: PWM sinyali daha önce öğrendiğimiz gibi bir kare sinyaldir. Bu sinyalin 5 volt ve 0
volt düzeylerinin oranına görev zamanı denir. Görev zamanı çıkış sinyalinin genliğini belirlediği
için motorların dönme hızını ayarlamada kullanılır. Motorlar için PWM sinyalini üretmek için
Arduino'nun analogWrite fonksiyonunu kullanacağız.

 VSS (LOGIC SUPPLY voltAGE – 9. pin): Adından da anlaşıldığı gibi bu pinin 5 volta
bağlanması gerekmektedir. Devrenin kararsızlığını azaltmak için bu pinle toprak arasına
100nF'lık kondansatör bağlanabilir.
 GND (8. pin): Besleme hattının devreyi tamamlayabilmesi için bu pin toprak hattına
bağlanması gerekir. Ayrıca entegrenin üzerindeki demir de GND pinine bağlıdır. Bu
metalin devre kurulumunda yanlış pinlere değip kısa devre yapmamasına özen
göstermek gerekir.
 VS (4. pin): Entegrenin motorlara vereceği enerjiyi aldığı ana besleme hattıdır. Bu hatta
bağlanacak enerji kaynağı motorlara verileceği için, motorlarımızın özelliğine göre
besleme gerilimi kullanmalıyız. Genellikle bu hatta 7 ila 12 volt arasında besleme
kaynakları bağlanmaktadır.

Entegre üzerinde bulunan pinlerin görevlerini öğrendiğimize göre motor sürücü devresini
kurabiliriz. Devreyi test etmek için öncelikle breadboard üzerinde devre elemanını yerleştirip kablo
bağlantılarını yapalım. Devre için kullanılacak Arduino kodu, konunun ilerleyen kısmında
paylaşılacaktır. Devrenizin hatasız olarak çalıştığından emin olduktan sonra devrenizi delikli
pertinaks üzerine kurabilirsiniz.

Yukarıda anlatılan tüm işlemler ilk defa motor sürücüsüyle tanışanlar için anlatılmıştır. Her
projede tekrardan motor sürücüsünü kurmak hem zahmetli olmakta, hem de devrenin
fonksiyonları arttığında karmaşıklığı arttırmaktadır. Bu yüzden piyasada bulunan hazır motor
sürücüleri kullanmak daha mantıklıdır. Fakat hazır motor sürücüler kullanılsa bile sistemin nasıl
çalıştığının bilinmesinde fayda vardır.

Piyasada Arduino üzerine direkt olarak takılabilen shield sürücüler bulunduğu gibi, harici olarak
pinle Arduino'ya bağlanabilen motor sürücüler de bulunur. İki motor sürücü türü de aynı işlemi
yapmaktadır. Shield tarzı motor sürücülerin kullanımı daha kolaydır, fakat fiyatları diğer motor
sürücülere göre daha fazladır.
Harici Motor Sürücü Kullanımı
Shield motor sürücülere göre daha ucuz olduğu için harici motor sürücüler proje bütçesine göre
tercih edilebilmektedir. Harici motor sürücüler, bu bölümde gösterilen kendinizin kurabileceği
motor sürücülerin hazır kart şekline getirilmiş halidir. Bu sürücülerde INPUT, OUTPUT, ENABLE
ve besleme pinleri bulunur. INPUT pinleri daha önce öğrendiğimiz gibi yön kontrolünde, ENABLE
pinleri motorların dönme hızını kontrol etmede kullanılır.

Motor sürücüsünün nasıl çalıştığını bildiğimize göre kablo bağlantılarını yapmaya başlayabiliriz.
Motorlara enerji sağlayacak besleme 7-12 volt arasındaki besleme kaynaklarına bağlanmalıdır.
Mantıksal besleme 5 volt hattına ve GND ise toprak hattına bağlanmalıdır. INPUT pinleri
Arduino'nun çıkış pinlerine; ENABLE pinleri ise Arduino'nun PWM çıkış verebilen pinlerine
bağlanmalıdır. Motor pinleri sürücü yanlarında bulunan OUTPUT pinlerine bağlanmalıdır.

Not: Motorun ileri gitmesi beklenirken geri yönde dönmesi, OUTPUT pinlerinin ters bağlanmış
olduğundan kaynaklanmaktadır. Bu pinlerin yerleri değiştirilerek motorların doğru yönde dönmesi
sağlanabilir.

Motor sürücü bağlantısını aşağıdaki gibi yapınız.

Resimde yapılan kablo bağlantıları aşağıdaki tablolarda gösterilmiştir.

Arduino Motor Sürücü

8 INPUT 1

9 INPUT 2

13 INPUT 3

12 INPUT 4

11 ENABLE A

10 ENABLE B

Motor Motor Sürücü

Motor1 + OUTPUT 1

Motor1 - OUTPUT 2

Motor2 + OUTPUT 3

Motor2 - OUTPUT 4

(Motorun + veya – ucunun hangisi olduğu farketmez)

Besleme Motor Sürücü

+12 volt VCC

Toprak (- uç) GND

+5 volt VS

Devre kurulumunu yaptığımıza göre aşağıdaki kodu Arduino'ya yükleyerek devremizi test edelim.
Kendi motor sürücüsünü kurmuş olanlar da aşağıdaki Arduino kodunu kullanabilirler.
int DonmeHizi = 175;
/* bu değişken ile motorların dönme hızı kontrol edilebilir */

/* motor sürücüsüne bağlanacak INPUT ve ENABLE pinleri belirleniyor

*/
const int sagileri = 9;
const int saggeri = 8;
const int solileri = 12;
const int solgeri = 13;
const int solenable = 11;
const int sagenable = 10;

void ileri(int hiz){

/* ilk değişkenimiz sag motorun ikincisi sol motorun hızını
göstermektedir.
* motorlarımızın hızı 0-255 arasında olmalıdır.
* Fakat bazı motorların torkunun yetersizliğiniden 60-255 arasında
çalışmaktadır.
* Eğer motorunuzdan tiz bir ses çıkıyorsa hızını arttırmanız
gerekmektedir.
*/
analogWrite(sagenable, hiz); /* sağ motorun hız verisi */
digitalWrite(sagileri,HIGH); /* ileri dönme sağlanıyor */
digitalWrite(saggeri,LOW); /* ileri dönme sağlanıyor */

analogWrite(solenable, hiz); /* sol motorun hız verisi */

digitalWrite(solileri, HIGH); /* ileri dönme sağlanıyor */
digitalWrite(solgeri,LOW); /* ileri dönme sağlanıyor */
}

void sagaDon(int hiz){

analogWrite(sagenable, hiz); /* sağ motorun hız verisi */
digitalWrite(sagileri,LOW); /* geri dönme sağlanıyor */
digitalWrite(saggeri,HIGH); /* geri dönme sağlanıyor */

analogWrite(solenable, hiz); /* sol motorun hız verisi */

digitalWrite(solileri, HIGH); /* ileri dönme sağlanıyor */
digitalWrite(solgeri,LOW); /* ileri dönme sağlanıyor */
}

void solaDon(int hiz){

analogWrite(sagenable, hiz); /* sağ motorun hız verisi */
digitalWrite(sagileri,HIGH); /* ileri dönme sağlanıyor */
digitalWrite(saggeri,LOW); /* ileri dönme sağlanıyor */

analogWrite(solenable, hiz); /* sol motorun hız verisi */

digitalWrite(solileri, LOW); /* geri dönme sağlanıyor */
digitalWrite(solgeri,HIGH); /* geri dönme sağlanıyor */
}
void geri(int hiz){
analogWrite(sagenable, hiz); /* sağ motorun hız verisi */
digitalWrite(sagileri,LOW); /* geri yönde dönme sağlanıyor */
digitalWrite(saggeri, HIGH); /* geri yönde dönme sağlanıyor */

analogWrite(solenable, hiz); /* sol motorun hız verisi */

digitalWrite(solileri, LOW); /* geri yönde dönme sağlanıyor */
digitalWrite(solgeri, HIGH); /* geri yönde dönme sağlanıyor */
}

void dur()
{
/* Tüm motorlar kitlenerek durma sağlanıyor */
digitalWrite(sagileri, HIGH);
digitalWrite(saggeri, HIGH);
digitalWrite(solileri, HIGH);
digitalWrite(solgeri, HIGH);
}

void setup(){
/* motorları kontrol eden pinler çıkış olarak ayarlanıyor */
pinMode(sagileri,OUTPUT);
pinMode(saggeri,OUTPUT);
pinMode(solileri,OUTPUT);
pinMode(solgeri,OUTPUT);
pinMode(sagenable,OUTPUT);
pinMode(solenable,OUTPUT);
}

void loop(){
ileri(DonmeHizi);
delay(1000);
dur();
delay(1000);
solaDon(DonmeHizi);
delay(1000);
dur();
delay(1000);
sagaDon(DonmeHizi);
delay(1000);
dur();
delay(1000);
geri(DonmeHizi);
delay(1000);
dur();
delay(1000);
}
Yukarıdaki kodla motorlar dönmeye başlamalıdır. Eğer motorların dönmesinde bir sorun var ise,
öncelikle kablo bağlantılarınızı gözden geçiriniz. INPUT pinleri hatalı bağlanmış olabilir, birbiri
arasında yerlerini değiştirmeyi deneyebilirsiniz. Motorun ileri yönde dönmesi beklenirken geri
yönde dönüyorsa motor bağlantılarının yerini değiştirebilirsiniz.
Bu bölümde Arduino ile DC motor kontrolünün nasıl yapıldığını öğrenmiş olduk. Motor kontrolü
için gereken motor sürücülerin türlerini ve kendimiz nasıl motor sürücü yapacağımızı da öğrendik.
Artık hareket gerektiren projelerimizde motor sürücüler yardımıyla DC motorlarımızı kullanabiliriz.

Motor Shield Kullanımı

Öncelikle motor shield'ı Arduino kartının üzerine takınız. Takma işleminden sonra Arduino
pinlerine shield yokmuş gibi, shield üzerindeki pinlerden ulaşabilirsiniz fakat bu pinlerden bazıları
motor sürücüde kullanıldığı için başka işlemler için kullanılamaz. Motor sürücüsü Arduino'nun
Dijital pinlerinden 3, 8, 9, 11, 12 ve 13; analog pinlerden A0 ve A1'i kullanmaktadır. Bu pinlerinde
kullanım amaçları aşağıdaki tabloda gösterilmiştir.

Görev A motoru B motoru

Yön Dijital 12 Dijital 13

Hız (PWM) Dijital 3 Dijital 11

Fren Dijital 9 Dijital 8

Akım ölçümü Analog 0 Analog 1

Fark edildiği gibi normal motor sürücülerden farklı olarak tek pinle ileri ve geri yön kontrolü
yapılmaktadır. Yön pinlerinin 5 volt yada 0 volt olmasına göre motor ileri veya geri yönde
dönmektedir. Fren pini ise motorun durmasını sağlamaktadır.

Örneğin motorlardan birini harekete geçirmek için öncelikle motorun döneceği yönü belirlemek
için yön pinini 5 volt veya 0 volt düzeyine çekmeliyiz. İleri yönde dönmesi için bu pin 5 volt, geri
yönde dönmesi için 0 volt düzeyine getirilmelidir. Yön ayarlandıktan sonra motorun dönmesi için
fren pini 0 volt düzeyine getirilmelidir. Motorun hızının ayarlanması için hız pinine analogWrite
fonksiyonuyla 0-255 arasında hız bilgisi gönderilmelidir.

Shield doğrudan Arduino üzerine takıldığı için harici olarak devre kurulmasına gerek
kalmamaktadır. Motor ve besleme bağlantısını aşağıdaki resimde gösterildiği gibi shield üzerine
bağlanmalıdır.
Motor shield Arduino üzerine şekildeki gibi yerleştirildikten ve pin bağlantıları resimdeki gibi
yapıldıktan sonra Arduino programlanabilir. Aşağıdaki programla iki motor ayrı ayrı kontrol
edilmiştir. Program çalıştığında iki motor da 1 saniye boyunca ileri yönde dönmektedir. Daha
sonra motorlar 1 saniye boyunca fren yapmakta ve bir saniye sonunda iki motor farklı yönlerde
dönmeye başlamaktadır.

Dikkat! Aşağıdaki Arduino kodu sadece motor shield'larla çalışmaktadır. Diğer motor sürücüler
için Arduino kodu konunun ilerleyen bölümlerinde paylaşılacaktır.

int DonmeHizi = 175;

/* bu değişken ile motorların dönme hızı kontrol edilebilir */

void ileri(int hiz){

/* A motoru ileri yönde dönmesi için ayarlanıyor */
digitalWrite(12, HIGH); /* ileri yön ayarı yapıldı */
digitalWrite(9, LOW); /* fren kapatıldı */
analogWrite(3, hiz); /* dönme hızı ayarlandı */

/* B motoru ileri yönde dönmesi için ayarlanıyor */

digitalWrite(13, HIGH); /* ileri yön ayarı yapıldı */
digitalWrite(8, LOW); /* fren kapatıldı */
analogWrite(11, hiz); /* dönme hızı ayarlandı */
}
void solaDon(int hiz){
/* A motoru geri yönde dönmesi için ayarlanıyor */
digitalWrite(12, LOW); /* geri yön ayarı yapıldı */
digitalWrite(9, LOW); /* fren kapatıldı */
analogWrite(3, hiz); /* dönme hızı ayarlandı */

/* B motoru ileri yönde dönmesi için ayarlanıyor */

digitalWrite(13, HIGH); /* ileri yön ayarı yapıldı */
digitalWrite(8, LOW); /* fren kapatıldı */
analogWrite(11, hiz); /* dönme hızı ayarlandı */
}

void sagaDon(int hiz){

/* A motoru ileri yönde dönmesi için ayarlanıyor */
digitalWrite(12, HIGH); /* ileri yön ayarı yapıldı */
digitalWrite(9, LOW); /* fren kapatıldı */
analogWrite(3, hiz); /* dönme hızı ayarlandı */

/* B motoru geri yönde dönmesi için ayarlanıyor */

digitalWrite(13, LOW); /* geri yön ayarı yapıldı */
digitalWrite(8, LOW); /* fren kapatıldı */
analogWrite(11, hiz); /* dönme hızı ayarlandı */
}

void geri(int hiz){

/* A motoru geri yönde dönmesi için ayarlanıyor */
digitalWrite(12, LOW); /* geri yön ayarı yapıldı */
digitalWrite(9, LOW); /* fren kapatıldı */
analogWrite(3, hiz); /* dönme hızı ayarlandı */

/* B motoru geri yönde dönmesi için ayarlanıyor */

digitalWrite(13, LOW); /* geri yön ayarı yapıldı */
digitalWrite(8, LOW); /* fren kapatıldı */
analogWrite(11, hiz); /* dönme hızı ayarlandı */
}

void dur(){
digitalWrite(9, HIGH); /* fren yapıldı */
digitalWrite(8, HIGH); /* fren yapıldı */
}

void setup() {
/* A motorunun ayarları */
pinMode(12, OUTPUT); /* yön pini çıkış olarak ayarlandı */
pinMode(9, OUTPUT); /* Fren pini çıkış olarak ayarlandı */

/* B motorunun ayarları */
pinMode(13, OUTPUT); /* yön pini çıkış olarak ayarlandı */
pinMode(8, OUTPUT); /* Fren pini çıkış olarak ayarlandı */
}
void loop(){
ileri(DonmeHizi);
delay(1000);
dur();
delay(1000);
solaDon(DonmeHizi);
delay(1000);
dur();
delay(1000);
sagaDon(DonmeHizi);
delay(1000);
dur();
delay(1000);
geri(DonmeHizi);
delay(1000);
dur();
delay(1000);
}

Servo Motor
Servo motor 0 ila 180 derece arasında 1 derece hassasiyetle dönebilen motor çeşididir. Tam tur
atamaz. Genellikle robot kol gibi tam tur dönmesine gerek olmayan, hassas açılı yerlerde
kullanılır. Servo motor içerisinde bir adet DC motor bulunur. DC motorun ucuna bağlı dişli
sisteminin yardımıyla servo mili daha fazla yük kaldırabilmektedir. Bu işlem sırasında servonun
dönüş hızı da yavaşlamış olur. Kullanılan dişli sistemine göre servo motorların kaldırabileceği yük
değişir.

Servoların kaldırabileceği yük tork gücü üzerinden ifade edilir. Servo motorların torku, motor
miline bağlı 1 cm uzunluğundaki çubuğun kaldırabileceği maksimum yük olarak tarif edilir.
Piyasada bulunan servolar genellikle 1,4 [Link] torka sahiptir. Bu da demek oluyor ki, motor
milinize bağlı 1 cm uzunluğunda bir çubuk varsa ve bu çubuğun ucuna bağlı yük 1,4 kilogramdan
fazlaysa motorunuzun gücü mili döndürmeye yetmez. Eğer çubuğun uzunluğu 10 cm ise en fazla
140 gram kaldırabilirsiniz.

Kaliteli dişli sistemine sahip daha güçlü servo motorlar da vardır. Projede kullanılacak servo
motorun seçimi, taşıyacağı maksimum yüke göre yapılmalıdır.

Servo motorun üç adet bağlantı kablosu bulunmaktadır. Bu kablolar genellikle kırmızı, turuncu
(bazen sarı) ve siyah (bazen kahverengi) olmaktadır. Bu renkler kabloların görevini
göstermektedir. Kırmızı renk besleme (genellikle 5 volt) bağlantısını, siyah veya kahverengi renk
de toprak bağlantısını göstermektedir. Geriye kalan turuncu kablo ise motorun açısını
belirleyecek olan veri bağlantısıdır. Motorun dönüş açısının belirlenmesi için veri hattı üzerinden
PWM adı verilen özel kare dalga sinyalleri yollanmaktadır. PWM sinyali belirli bir süre 5 volt, belirli
bir süre 0 volt düzeyinde verilen gerilimdir. 5 volt düzeyinde geçen süreye "görev zamanı", toplam
süreye de "PWM periyodu" denir. Servo motorun kontrolü için ayarlanmış özel görev zamanları
ve PWM periyotları vardır. Bu ayarlar dışındaki PWM sinyalleri servo motoru düzgün çalıştıramaz.
Arduino’da servo motor kontrolü için özelleştirilmiş PWM pinleri bulunmaktadır. PWM pin sayısı
Arduino’nun türüne göre değişmektedir. Bu pinlerin yanında dalga (~) işareti bulunmaktadır.

Servo motor kontrolü için öncelikle Servo.h kütüphanesini projemize eklemeliyiz. Servo
kütüphanesi eklendikten sonra Servo nesnesi kullanılarak yeni servo motorlar tanımlanır.
Tanımlanan servo motorın bağlı olduğu pinler seçilir ve servo kullanıma hazır hale getirilir. Motor
milinin konumunu değiştirmek için Servo nesnesinin attach metodu kullanılır. Bu metodun
içerisine motor milinin gitmesi istenilen 0-180 derece arasında açı yazılır. Servonun yeni
konumunu alması biraz zaman alabilir. Bu yüzden bekleme (Delay) komutu kullanılmalıdır.

#include <Servo.h> /* Servo kutuphanesi projeye dahil edildi */

Servo servoNesnesi; /* servo motor nesnesi yaratildi */

void setup()
{
[Link](9); /* Servo motor 9 numarali pine baglandi */
}

void loop()
{
[Link](100); /* Motorun mili 100. dereceye donuyor */
delay(1000);
[Link](20); /* Motor mili 20. dereceye donuyor */
delay(1000);
}
Servo gibi mekanik içyapıya sahip elektronik elemanların kullanımına dikkat edilmelidir. Bu
elemanlar zorlanmalara bağlı olarak fazla akım çekebilir. Besleme kaynağının fazla akımlar için
yeterli olmasına dikkat edilmelidir.
Servo motorun teknik bilgilerinde önerilen besleme geriliminden fazlası, motorun iç yapısına ve
dişli sistemine zarar verebilir. Bu yüzden servo motora önerilen besleme geriliminden (genellikle 5
volt) fazlası verilmemelidir. Servo motor ve benzeri mekanik elemanların fazla akım çekmesinden
dolayı, bu elemanların besleme ve toprak bağlantıları arasına kapasitör konmalıdır. Böylece
devremiz, bu elemanların yaratacağı gerilim dalgalanmalarından korunmuş olur.

Uygulama: Potansiyometreyle servo motor kontrolü

Potansiyometrenin ve servo motorun nasıl kullanıldığını öğrenmiştik. Bu uygulamada, servo
motoru potansiyometreyle kontrol edeceğiz. Potansiyometrenin dönmesiyle değişien gerilimi
servonun dönebilmesi için 0 ila 180 derece arasında çevireceğiz. Böylece potansiyometrenin
döndürülme oranında servo motor da dönecektir.

Eğer projede motor gibi fazla akım çekebilecek elemanların kullanılması gerekiyorsa bu
elemanları Arduino üzerinden beslemek doğru değildir. Bu yüzden fazla akım çekebilecek
elemanlar genellikle Arduino üzerinden değil, harici bir kaynak üzerinden beslenir. Uygulamada
servo motor Arduino üzerinden değil, harici bir pil (yaklaşık 5 volt) üzerinden beslenecektir.
Arduino ve harici besleme kaynağının toprak hatları birbirine bağlanmalıdır. Aksi halde motor
düzgün çalışmayacaktır.
#include <Servo.h> /* Servo kutuphanesi projeye dahil edildi */

Servo servoMotor; /* servo motor nesnesi yaratildi */

int Potansiyometre = A0; /* Potansiyometre pini belirlendi*/

int PotDeger; /* Potansiyometre degeri icin degisken olusturuldu */

void setup()
{
[Link](9); /* Servo motor 9 numarali pine baglandi */
}

void loop()
{
PotDeger = analogRead(Potansiyometre); /* Potansiyometrenin cikis
gerilimi olculuyor */
PotDeger = map(PotDeger, 0, 1023, 0, 179);
/*
Potansiyometreden olculen 0 ve 1023 arasindaki deger map
fonksiyonu ile
Servo motorun calisma araligina yani 0 ve 180 dereceye cevriliyor.
Bu fonksiyon 0 ve 1023 arasindaki degerleri, lineer olarak 0 ve
180 arasina cevirir
*/
[Link](PotDeger); /* Hesaplanan deger servo motora
yollaniyor*/
delay(15); /* Motorun konumunu almasi icin bir sure bekleniyor */
}
Dâhili EEPROM Nedir ve Nasıl Kullanılır?
EEPROM, ihtiyacımız olan değişken verilerini tutabilen, elektriksel olarak bu verileri yazıp
silebilen küçük depolama birimidir. Arduino'nun mikroişlemcisinde dâhili olarak bulunan
EEPROM'a verilerimizi kaydedebilir, istediğimiz zaman bu verileri tekrar kullanabiliriz.

Arduino'nun enerjisi kesilse dahi EEPROM'daki veriler silinmez. Bu özellikten dolayı Arduino'nun
çalışmaya başladığında ilk olarak yapması gereken önemli işlerin verileri bu alanda depolanır.
EEPROM depo alanı, Arduino'nun üzerinde bulunan mikroişlemcinin türüne göre değişmektedir.
ATmega328'in 1024 byte, ATmega168 ve ATmega8'in 512 byte, ATmega1280 ve
ATmega2560'ın ise 4 kb depolama alanı vardır. Bu alanlar projelerimiz için yeterli olacak. Yeterli
olmadığı durumlarda hafıza alanının artırılması için harici EEPROM'lar da kullanılabilir.

Uygulamalarda Arduino'nun dâhili EEPROM'u kullanılacaktır. Bunun için öncelikle EEPROM.h

kütüphanesini projemize dâhil etmeliyiz. EEPROM kütüphanesini dâhil etmemizle artık
EEPROM'a yazma ve EEPROM'dan okuma fonksiyonlarını kullanabiliriz. EEPROM'a veri yazmak
için "[Link]" fonksiyonu kullanılır.

Bu fonksiyon veri olarak sırasıyla EEPROM'da kaydedilecek adresi ve kaydedilmesi gereken

veriyi almaktadır. EEPROM'a kaydedilecek adres kullanıcı tarafından belirlenmektedir. Böylece
kullanıcı kaydettiği verinin hangi adreste olduğunu bilmektedir. İhtiyaç olunduğunda bu verinin
geri alınması için "[Link]" fonksiyonu kullanılır. Bu fonksiyon veri olarak EEPROM'un
okunmak istenen adresini almaktadır.

#include <EEPROM.h> /* EEPROM fonksiyonları için kütüphane dahil

edilmelidir. */

int kayitAdresi , kaydedilecekVeri;

int okunacakAdres, okunanVeri;

void setup()
{
[Link](9600); /* Bilgisayara veri göndermek için */
}

void loop()
{
/* EEPROMa veri kaydediyoruz */
kayitAdresi = 10; /* Verinin yazılacağı EEPROM adresi */
kaydedilecekVeri = 50; /* EEPROMA kaydedilecek veri */
[Link](kayitAdresi, kaydedilecekVeri); /* EEPROMun 10 adresine 50
verisi yazdırıldı. */
delay(10);

/* EEPROMa kaydedilmiş verileri okuyalım */

okunacakAdres = 10; // 10 adresini okuyacağız
okunanVeri = [Link](okunacakAdres ); /* EEPROMun 10 adresindeki veri
okunanVeri değişkenine aktarılıyor. */
delay(10);
/* Sonuçlar bilgisayar ekranına yazdırıldı */
[Link]("EEPROMun ");
[Link](okunacakAdres);
[Link](" Adresindeki Deger= ");
[Link](okunanVeri);
[Link]();
delay(1000); // biraz bekleyelim
}

Uygulama: Kaldığı yeri hatırlayan servo motor

Servo motorlar tek yönlü PWM sinyaliyle kontrol edilir. Bu kontrolün tek yönlü olması nedeniyle
Arduino'ya geri bilgi gelmez. Arduino servo motoru kontrol ettikten sonra kapatılıp açılırsa, servo
motorun en son hangi konumda kaldığını hatırlayamaz. Bu durum bazı projeler için sorun teşkil
edebilir. Servo motorun en son konumunu Arduino'ya hatırlatmak için, servoyu kontrol ettikten
sonra Arduino'nun EEPROM'una en son yollanan açıyı kaydedeceğiz. Böylece Arduino'nun gücü
kesilip tekrar başlatılsa bile, servo motor en son konumundan başlayacak.

EEPROM kullanmanın yaratacağı fark görülmesi için aşağıda verilen ilk kodda EEPROM
kullanılmamıştır. İkinci kodda son açı EEPROM'a kaydedilmiş ve servonun kaldığı yerden
çalışması sağlanmıştır.

Bu uygulamayı yapmak için ihtiyacımız olan malzemeler:

 1 x Arduino
 1 x Servo motor
#include <Servo.h>
Servo servoMotor;

int servoAcisi = 1;
int donusYonu = 0; /* 0 ise servo ileri, 1 ise geri yönde dönmektedir.
*/

void setup()
{
[Link](9); /* Servo Arduinonun 9 numaralı pinine takıldı */
[Link](9600);
}

void loop()
{
[Link](servoAcisi); /* Servo motoru kontrol ediyoruz */

if(donusYonu == 0){ /* Motor ileri yönde donuyorsa */

servoAcisi = servoAcisi + 5; /* 5 derece döndürelim */
[Link](servoAcisi);

if(servoAcisi > 179){ /* Motor ileri yönde sona ulaştıysa */

servoAcisi = 179;
donusYonu = 1; /* Geri yönde dönmeye basla */
}
}else{ /* Motor geri yönde donuyorsa */
servoAcisi = servoAcisi - 5; /* 5 derece geri don */
[Link](servoAcisi);
if(servoAcisi < 1){ /* Motor geri yönde sona ulaştıysa */
servoAcisi = 1;
donusYonu = 0; /* ileri yönde dönmeye basla */
}
}

delay(15); /* Motorun konumunu alması için biraz bekleme */

}
Aşağıdaki kodda yukarıdaki koddan farklı olarak açı ve yön bilgisi EEPROM'a kaydedilmiştir. İlk
kodda Arduino'yu motor herhangi bir konumdayken kapatıp tekrar açtığınızda, motor hareketine
en baştan başlamaktadır. Aşağıdaki kodda açı ve yön bilgisi EEPROM'a kaydedildiği için
Arduino'nun gücü kesilse bile, Arduino'ya tekrar güç verildiğinde servo motor kaldığı yerden
çalışmaya devam edecektir.
EEPROM diğer projelerde de benzer mantıkla kullanılabilir.

#include <Servo.h>
#include <EEPROM.h>
Servo servoMotor;

int servoAcisi;
int donusYonu = 0; /* 0 ise servo ileri, 1 ise geri yönde dönmektedir.
*/

void setup()
{
[Link](9); /* Servo Arduinonun 9 numaralı pinine takıldı */

servoAcisi = [Link](1); /* Servonun kaldığı yer EEPROMdan alınıyor

*/
if(servoAcisi < 1 || servoAcisi > 179){ /* EEPROMda servo açısı yerine
başka bir veri varsa */
servoAcisi = 1; /* Motor ilk konumuna donsun */
}
donusYonu = [Link](0);
if(donusYonu != 1 && donusYonu !=
0){ /* EEPROMda dönüş yönü yerine
başka bir veri varsa */
donusYonu = 0; /* Motor ileri yönde donsun */
}
}
void loop()
{
[Link](servoAcisi); /* Servo motoru kontrol ediyoruz */
[Link](1,servoAcisi); /* Son açıyı EEPROMa kaydediyoruz */

if(donusYonu == 0){ /* Motor ileri önde donuyorsa */

servoAcisi = servoAcisi + 5; /* 5 derece döndürelim */
if(servoAcisi > 179){ /* Motor ileri yönde sona ulaştıysa */
servoAcisi = 179;
donusYonu = 1; /* Geri yönde dönmeye basla */
[Link](0,donusYonu); /* Yon bilgisi EEPROMa kaydedildi */
}
}else{ /* Motor geri yönde donuyorsa */
servoAcisi = servoAcisi - 5; /* 5 derece geri don */
if(servoAcisi < 1){ /* Motor geri yönde sona ulaştıysa */
servoAcisi = 1;
donusYonu = 0; /* ileri yönde dönmeye basla */
[Link](0,donusYonu); /* Yon bilgisi EEPROMa kaydediliyor */
}
}

delay(15); /* Motorun konumunu alması için biraz bekleme */

}
Arduino ile Uzaklık Ölçümü
Uygulamalarda uzaklık ölçümü için HC-SR04 ultrasonik uzaklık sensörü kullanılacaktır. Bu sensör
elektronik/robotik malzeme satan mağazalarda kolaylıkla bulunabilir. Sensör üzerinde giriş ve
çıkış olmak üzere iki yüzey bulunmaktadır. Çıkış yüzeyinden ortama belirli bir frekansta ultrasonik
ses dalgası salınır. Giriş yüzeyi de çıkış yüzeyinin ortama saldığı belirli frekanslardaki ses
dalgalarını toplar. Uzaklık ölçümü için öncelikle çıkış yüzeyinden ortama ses dalgası salınır.
Salınan ses dalgası 15 derece açıyla ortamda yayılır. Yayılan ses dalgası bu alanda bulunan bir
cisme çarptığında, cisim yüzeyinden sensöre geri yansır. Yansıyan dalganın giriş yüzeyine
gelmesiyle işlem tamamlanır. Dalganın çıkış yüzeyinden çıkmasıyla giriş yüzeyine ulaşması
arasında geçen süre ölçülerek, cismin uzaklığı hesaplanır. Bu basit mantıkla çalışan sensör, 2 cm
ile 200 cm arasındaki uzaklıkları 1 cm hassasiyetle ölçebilmektedir. Sensör bu aralık dışındaki
uzaklıkları istikrarlı olarak ölçememektedir.

Sensör üzerinde VCC, Trig, Echo, GND olmak üzere 4 adet pin bulunmaktadır. Bunlardan VCC
pini besleme (5 volt), GND pini toprak hattıdır. Trig pini çıkış yüzeyinden dalganın salınmasını
sağlayan pindir. Echo pini ise giriş yüzeyine yansıyan dalganın ulaştığını Arduino'ya haber veren
pindir. Açıklamalardan da anlaşıldığı gibi Arduino'da trig pini çıkış, echo pini ise giriş olarak
ayarlanmalıdır.

Aşağıdaki resimde sensörün Arduino bağlantılarını görebilirsiniz.

Arduino ve uzaklık sensörünün bağlantıları resimdeki gibi yapıldıysa, kodlama kısmına

başlayabiliriz.
İlk olarak setup fonksiyonu içerisinde sensörün trig ve echo pinleri ayarlanmalıdır. Sensör
önündeki cismin uzaklığını ölçmesi için trig pini aktif yapılmalıdır. Daha önceden bu pinin aktif
kalma ihtimalinden dolayı öncelikle pin LOW durumuna getirilmelidir. Kısa bir süre bekledikten
sonra trig pini 10 mikro saniye boyunca HIGH konumuna tutulmalıdır. 10 mikro saniye sonunda
pin, tekrardan LOW konumuna getirilmelidir. Böylece çıkış yüzeyinden ses dalgası salınmış oldu.
Salınan dalga sensörün önündeki bir cisme çarptığında giriş yüzeyine yansıyacaktır. Dalga giriş
yüzeyine ulaştığında sensör otomatik olarak echo pinini HIGH konumuna getirecektir. Echo
pininin HIGH konumuna gelme süresi pulseIn fonksiyonuyla ölçülür. Ölçülen süre 14,55'e
bölünerek cismin uzaklığı ölçülür. Uygulamada sensör yardımıyla ölçülen uzaklığın kullanıcı
tarafından görülmesi için, uzaklık bilgisi seri haberleşmeyle bilgisayara aktarılmaktadır.

int trigPin = 6; /* Sensorun trig pini Arduinonun 6 numaralı ayağına

bağlandı */
int echoPin = 7; /* Sensorun echo pini Arduinonun 7 numaralı ayağına
bağlandı */

long sure;
long uzaklik;

void setup(){
pinMode(trigPin, OUTPUT); /* trig pini çıkış olarak ayarlandı */
pinMode(echoPin,INPUT); /* echo pini giriş olarak ayarlandı */
[Link](9600); /* Seri haberlesme baslatildi */
}
void loop()
{
digitalWrite(trigPin, LOW); /* sensör pasif hale getirildi */
delayMicroseconds(5);
digitalWrite(trigPin, HIGH); /* Sensore ses dalgasının üretmesi için
emir verildi */
delayMicroseconds(10);
digitalWrite(trigPin, LOW);/* Yeni dalgaların üretilmemesi için trig
pini LOW konumuna getirildi */
sure = pulseIn(echoPin, HIGH); /* ses dalgasının geri dönmesi için geçen
sure ölçülüyor */
uzaklik= sure /29.1/2; /* ölçülen sure uzaklığa çevriliyor */
if(uzaklik > 200)
uzaklik = 200;
[Link]("Uzaklik ");
[Link](uzaklik); /* hesaplanan uzaklık bilgisayara aktarılıyor
*/
[Link](" CM olarak olculmustur.");
delay(500);
}
Uygulama: Kısa menzilli radar yapımı
Uygulamada yeni öğrendiğimiz uzaklık sensörünü servo motorun üzerine bağlayarak, 0-180
derece arasındaki cisimlerin uzaklığını bulan basit bir radar yapacağız. Bunun için servo motoru
10 derecelik açılarla döndürüp, o açıdaki maksimum uzaklığı ölçeceğiz. Uzaklığı daha kolay
ölçebilmek için bu uygulamamızda "mesafeOlcumu” fonksiyonunu tanımlayacağız. Servonun
10'ar derecelik açılarla dönmesini sağlayabilmek için 2 tane for döngüsü kullanılacaktır. Her 10
derecelik açılardaki maksimum uzaklıklar bilgisayardan görüntülenebilmesi için seri port
yardımıyla USB üzerinden bilgisayara yollanacaktır.

Bu uygulamayı yapmak için ihtiyacımız olan malzemeler:

 1 x Arduino
 1 x Breadboard
 1 x HC-SR04 (ultrasonik uzaklık sensörü)
 1 x Servo motor

#include <Servo.h>

const int trigPin = 8; /* Sensorun trig pini Arduinonun 6 numaralı

ayağına bağlandı */
const int echoPin = 7; /* Sensorun echo pini Arduinonun 7 numaralı
ayağına bağlandı */
Servo radarServosu;

int aci = 0;

long mesafeOlcumu(){
long sure;
long uzaklik;
digitalWrite(trigPin, LOW); /* sensor pasif hale getirildi */
delayMicroseconds(5);
digitalWrite(trigPin, HIGH); /* Sensöre ses dalgasının üretmesi için
emir verildi */
 delayMicroseconds(10);
digitalWrite(trigPin, LOW);/* Yeni dalgaların üretilmemesi için trig
pini LOW konumuna getirildi */
sure = pulseIn(echoPin, HIGH, 11600); /* ses dalgasının geri dönmesi
icin gecen sure ölcülüyor */
uzaklik= sure /29.1/2; /* ölçülen sure uzaklığe çevriliyor */
if(uzaklik > 200 || uzaklik < 1 )
uzaklik = 200;
return uzaklik;
}

void ekranaYazdir(int aciDegeri, long uzaklikDegeri){

[Link]("aci= ");
[Link](aciDegeri);

[Link]("uzaklik= ");
[Link](uzaklikDegeri);
}

void setup(){
pinMode(trigPin, OUTPUT); /* trig pini cikis olarak ayarlandi */
pinMode(echoPin,INPUT); /* echo pini giris olarak ayarlandi */

[Link](9);

[Link](9600); /* Seri haberleşme başlatıldı */

}

void loop()
{
for(aci = 0; aci < 180; aci += 10) /* radarımız 0dan 180 kadar 10ar
10ar dönecektir */
{
[Link](aci); /* radari donduruyoruz */
delay(15); /* radarin donmesini bekliyoruz */
ekranaYazdir(aci, mesafeOlcumu());
}
for(aci = 180; aci>=1; aci-=10) /* radarımız 180dan 0 kadar 10ar 10ar
dönecektir */
{
[Link](aci); /* radarı donduruyoruz */
delay(15); /* radarın dönmesini bekliyoruz */
ekranaYazdir(aci, mesafeOlcumu());
}
}
Eğer sensörün ölçüm mesafesi içinde engel yoksa, sensörde bir miktar yavaşlama olmaktadır. Bu
durumdan kurtulmak için, eğer sensörün önünde engel yoksa zaman aşımına uğraması için
pulseIn fonksiyonunu güncelledik. Böylece belirli bir uzaklıkta engel yoksa sistem beklemeden
çalışmaya devam edecektir. PulseIn fonksiyonuna yazılan 2895 değeri sensöre ve ortama göre
değişiklik gösterebilir.
Genel Arduino Uygulamaları
Arduino ile en çok kullanılan fonksiyon ve özellikleri önceki yazılarımızda öğrendik. Artık
öğrendiklerimizle uygulamalar yapmaya başlayabiliriz. Bu bölümde yapacağımız uygulamalar
kolaydan zora doğru gitmektedir. Bölümde gösterilen uygulamaların, ilk etapta incelenmesi ve
denenmesi, daha sonra da üzerinde değişiklikler yapılarak yeni projelerin üretilmesi, Arduino
kullanımını pekiştirecektir.

Trafik Lambaları
Arduino pinlerinin kontrolünü pekiştirmek için her gün gördüğümüz trafik lambalarını Arduino ile
yapacağız. Arduino pinlerine bağlanan kırmızı, sarı ve yeşil LED'ler trafik lambalarının sırasına
göre kontrol edilecek. Buna göre program ilk başta kırmızı ışığı yakacak. Kırmızı ışık 5 saniye
yandıktan sonra sönecek ve 1 saniye boyunca sarı ışık yanacak. Sarı ışık söndükten sonra da 3
saniye boyunca yeşil ışık yanacak.

Proje devresini kurmak için bağlantılarınızı aşağıdaki gibi yapınız:

Yukarıdaki devreyi kurduktan sonra Arduino'ya aşağıdaki kodu yükleyiniz.

/* LEDlerin bağlı olduğu pinler tanımlandı */
const int kirmizi = 2,sari = 3,yesil = 4;

void setup()
{
/* LED pinleri çıkış olarak ayarlandı */
pinMode(kirmizi,OUTPUT);
pinMode(sari,OUTPUT);
pinMode(yesil,OUTPUT);
}

/* Sadece kırmızı ışığı yakan fonksiyon */

void kirmiziIsik(){
digitalWrite(kirmizi,HIGH);
digitalWrite(sari,LOW);
digitalWrite(yesil,LOW);
}

/* Sadece sarı ışığı yakan fonksiyon */

void sariIsik(){
digitalWrite(kirmizi,LOW);
digitalWrite(sari,HIGH);
digitalWrite(yesil,LOW);
}

/* Sadece yeşil ışığı yakan fonksiyon */

void yesilIsik(){
digitalWrite(kirmizi,LOW);
digitalWrite(sari,LOW);
digitalWrite(yesil,HIGH);
}

void loop()
{
kirmiziIsik();
delay(5000);

sariIsik();
delay(1000);

yesilIsik();
delay(3000);
}
Bu uygulamada tek bir trafik lambası için kodlama ve devre tasarımı yapıldı. Kendinizi geliştirmek
için, yukarıda paylaşılan koda eklemeler yaparak birden fazla trafik lambasını tek bir Arduino
üzerinden kontrol edebilirsiniz.
Çarpmayan Robot Yapımı
Bu uygulamada hemen hemen tüm robot yarışmalarındaki robotlarda kullanılan, engellerden
kaçma algoritması üzerine çalışacağız. Bunu yapabilmek için önceki konularda öğrendiğimiz DC
motor kontrolü ve ultrasonik uzaklık sensörü ile uzaklık ölçümünü kullanacağız. Bu uygulamada
öğrenilen bilgiler, robot yarışmalarında bulunan çöp toplama, labirent çözme, yangın söndürme
gibi kategorilerde kullanılabilir.

Bu projede yapılacak olan 4 tekerli robot hareket için 4x4 şeklinde, her bir tekere bağlanan DC
motorlardan oluşacak. Bu motorların kontrolü için DC motor sürücüsü kullanacağız. Uzaklık
ölçümü için HC-SR04 ultrasonik uzaklık sensörü kullanacağız.

Arduino sürekli olarak uzaklık sensöründen gelen uzaklık verisini kontrol edecek. Eğer ölçülen
uzaklık verisi 10 cm'den kısa ise robot durdurulacaktır. Robot engelden kaçmak için yaklaşık 90
derece sola dönecektir. Eğer sola döndükten sonra önünde herhangi bir engel yoksa ilerlemeye
devam edecektir. Önüne yeni bir engel geldiğinde robot, tekrar bu işlemleri yapacaktır. Böylece
robotumuz engellere çarpmadan ilerleyebilecek.

Bu uygulamayı yapmak için ihtiyacınız olan malzemeler:

 1 x Arduino
 4 x Tekerlek
 1 x Robot şasesi
 4 x DC motor
 1 x DC motor sürücüsü
 1 x HC-SR04 uzaklık sensörü
Devre şemasında görüldüğü gibi aynı tarafta bulunan iki DC motor birbirine paralel olarak
bağlanmıştır. Böyle bağlanmasının nedeni bu motorun her zaman için aynı şekilde dönecek
olmasıdır. Eğer ayrı ayrı bağlanması istenseydi, o zaman iki adet DC motor sürücüye ihtiyaç
duyulurdu. Uzaklık sensörü robotun en önüne takılmıştır. Uzaklığın doğru olarak bulunması için
robotun hiçbir parçası sensörün görüş açısında bulunmamalıdır. Resimdeki devreyi robot
şasesine bağlayarak Arduino programlamaya başlayabiliriz.

Resimde gösterilen devre şemasının kablo bağlantıları aşağıdaki tablolarda gösterilmiştir:

Arduino Motor Sürücü

8 INPUT 1

9 INPUT 2

13 INPUT 3

12 INPUT 4

11 ENABLE A

10 ENABLE B

Motor Motor Sürücü

Motor1 + OUTPUT 1

Motor1 - OUTPUT 2

Motor2 + OUTPUT 3

Motor2 - OUTPUT 4

(Motorun + veya – ucunun hangisi olduğu farketmez)

Besleme Motor Sürücü

+12 Volt VCC

Toprak (- uç) GND

+5 Volt VS

Arduino HC-SR04 Uzaklık Sensörü

+5 Volt VCC

6 Trig

7 Echo

Toprak (- uç) GND

Devre kurulumunu gerçekleştirdikten sonra aşağıdaki kodu Arduino'ya yükleyelim

const int trigPin = 6; /* Sensorun trig pini Arduinonun 6 numarali
ayagina baglandi */
const int echoPin = 7; /* Sensorun echo pini Arduinonun 7 numarali
ayagina baglandi */

int DonmeHizi = 175;

/* bu değişken ile motorların dönme hızı kontrol edilebilir */
int DonmeZamani = 250;
/* DonmeZamani değişkeni robotun 90 derece dönmesini sağlayan
değişkendir
* Robotun yaklaış 90 derece dönmesi için robotunuza göre bu süreyi
ayarlayın
*/

/* motor sürücüsüne bağlanacak INPUT ve ENABLE pinleri belirleniyor

*/
const int sagileri = 9;
const int saggeri = 8;
const int solileri = 12;
const int solgeri = 13;
const int solenable = 11;
const int sagenable = 10;

/* Uzaklık ölçümünün yapılacağı fonksiyon */

long mesafeOlcumu(){
long sure;
long uzaklik;
digitalWrite(trigPin, LOW); /* sensor pasif hale getirildi */
delayMicroseconds(5);
digitalWrite(trigPin, HIGH); /* Sensore ses dalgasinin uretmesi icin
emir verildi */
delayMicroseconds(10);
digitalWrite(trigPin, LOW); /* Yeni dalgalarin uretilmemesi icin trig
pini LOW konumuna getirildi */

sure = pulseIn(echoPin, HIGH, 11600); /* ses dalgasinin geri donmesi

icin gecen sure olculuyor */
uzaklik= sure /29.1/2; /* olculen sure uzaklige cevriliyor */

return uzaklik;
}
void ileri(int hiz){
/* ilk değişkenimiz sag motorun ikincisi sol motorun hızını
göstermektedir.
* motorlarımızın hızı 0-255 arasında olmalıdır.
* Fakat bazı motorların torkunun yetersizliğiniden 60-255
arasında çalışmaktadır.
* Eğer motorunuzdan tiz bir ses çıkıyorsa hızını arttırmanız
gerekmektedir.
*/
analogWrite(sagenable, hiz); /* sağ motorun hız verisi */
digitalWrite(sagileri,HIGH); /* ileri dönme sağlanıyor */
digitalWrite(saggeri,LOW); /* ileri dönme sağlanıyor */

analogWrite(solenable, hiz); /* sol motorun hız verisi */

digitalWrite(solileri, HIGH); /* ileri dönme sağlanıyor */
digitalWrite(solgeri,LOW); /* ileri dönme sağlanıyor */
}

void sagaDon(int hiz){

analogWrite(sagenable, hiz); /* sağ motorun hız verisi */
digitalWrite(sagileri,LOW); /* geri dönme sağlanıyor */
digitalWrite(saggeri,HIGH); /* geri dönme sağlanıyor */

analogWrite(solenable, hiz); /* sol motorun hız verisi */

digitalWrite(solileri, HIGH); /* ileri dönme sağlanıyor */
digitalWrite(solgeri,LOW); /* ileri dönme sağlanıyor */
}

void solaDon(int hiz){

analogWrite(sagenable, hiz); /* sağ motorun hız verisi */
digitalWrite(sagileri,HIGH); /* ileri dönme sağlanıyor */
digitalWrite(saggeri,LOW); /* ileri dönme sağlanıyor */

analogWrite(solenable, hiz); /* sol motorun hız verisi */

digitalWrite(solileri, LOW); /* geri dönme sağlanıyor */
digitalWrite(solgeri,HIGH); /* geri dönme sağlanıyor */
}

void geri(int hiz){

analogWrite(sagenable, hiz); /* sağ motorun hız verisi */
digitalWrite(sagileri,LOW); /* geri yönde dönme sağlanıyor */
digitalWrite(saggeri, HIGH); /* geri yönde dönme sağlanıyor */

analogWrite(solenable, hiz); /* sol motorun hız verisi */

digitalWrite(solileri, LOW); /* geri yönde dönme sağlanıyor */
digitalWrite(solgeri, HIGH); /* geri yönde dönme sağlanıyor */
}
void dur()
{
/* Tüm motorlar kitlenerek durma sağlanıyor */
digitalWrite(sagileri, HIGH);
digitalWrite(saggeri, HIGH);
digitalWrite(solileri, HIGH);
digitalWrite(solgeri, HIGH);
}

void setup(){
/* Uzaklık sensörünün pinleri ayarlanıyor */
pinMode(trigPin, OUTPUT); /* trig pini cikis olarak ayarlandi */
pinMode(echoPin,INPUT); /* echo pini giris olarak ayarlandi */

/* motorları kontrol eden pinler çıkış olarak ayarlanıyor */

pinMode(sagileri,OUTPUT);
pinMode(saggeri,OUTPUT);
pinMode(solileri,OUTPUT);
pinMode(solgeri,OUTPUT);
pinMode(sagenable,OUTPUT);
pinMode(solenable,OUTPUT);
}

void loop(){

while( mesafeOlcumu() > 10 ){ // önüne engel gelene kadar düz git

ileri(DonmeHizi);
}
dur();
delay(500);
solaDon(DonmeHizi);
delay(DonmeZamani);
dur();
delay(500);

Bluetooth Kontrollü Araç Yapımı

Daha önceki uygulamalarımızda Bluetooth üzerinden devremizi telefon veya Bluetooth özelliği
bulunan cihazlarla nasıl kontrol edeceğimizi öğrenmiştik. DC motor kontrol etmeyi de
öğrendiğimize göre Bluetooth üzerinden kontrol edilen bir araç yapabiliriz. Aracımız daha önce
yaptığımız gibi 4 tekerlek ve DC motordan oluşmaktadır. Bir önceki uygulamamızdan farklı olarak
uzaklık sensörü yerine Bluetooth modülü kullanacağız.

Robotun harekete geçmesi için Bluetooth modülünden veri gelmesi gerekiyor. Bu veri akıllı
telefonlardan veya Bluetooth özelliği bulunan tablet ve bilgisayarlardan gelecek. Öncelikle
Bluetooth modülüyle cihazlarımızı eşleştirmemiz gerekiyor. Bu konuyu hatırlamıyorsanız,
tekrardan "Bluetooth ile Haberleşme" konusuna göz atmanızı öneririz.
  Windows kullanıcıları Bluetooth ile haberleşmek için, ücretsiz olarak Tera
Term programını indirebilirler.
 Android kullanıcıları ise haberleşme için Bluetooth Terminal isimli ücretsiz uygulamayı
kullanabilirler.

Bu uygulamayı yapmak için ihtiyacınız olan malzemeler;

 1 x Arduino
 4 x Tekerlek
 1 x Robot şasesi
 4 x DC motor
 1 x DC motor sürücüsü
 1 x HC-05 veya HC-06 Bluetooth modülü

Resimde gösterilen devre şemasının kablo bağlantıları aşağıdaki tablolarda gösterilmiştir:

Arduino Motor Sürücü

8 INPUT 1

9 INPUT 2

13 INPUT 3

12 INPUT 4

11 ENABLE A

10 ENABLE B

Motor Motor Sürücü

Motor1 + OUTPUT 1

Motor1 - OUTPUT 2

Motor2 + OUTPUT 3

Motor2 - OUTPUT 4

(Motorun + veya – ucunun hangisi olduğu farketmez)

Besleme Motor Sürücü

+12 Volt VCC

Toprak (- uç) GND

+5 Volt VS

Arduino Bluetooth Modülü

+3,3 Volt VCC

Tx Rx

Rx Tx

Toprak (- uç) GND

Devre kurulumunu gerçekleştirdikten sonra aşağıdaki kodu Arduino'ya yükleyelim. Arduino'ya

Bluetooth üzerinden veri geldiğinde, gelen veri bir char değişkenine yazılır. Araç eğer bu veri 'w'
ise ileriye, 'd' ise sağa, 'a' ise sola, 'x' ise geriye doğru gitmeye başlar. Eğer gelen veri 's' ise de
araç durur. Yukarıda önerilen programlar yardımıyla bu karakterleri yollayarak aracınızı kontrol
edebilirsiniz.
Not: Bluetooth üzerinden yollanan veri ile Arduino tarafından beklenen verinin tıpatıp aynı olması
gerekmektedir. Yani yollanan veri 'a' ise, Arduino 'A' komutunu bekliyor ise büyük küçük harf
farkından dolayı sistem çalışmayacaktır.

int DonmeHizi = 175;

/* bu değişken ile motorların dönme hızı kontrol edilebilir */

/* motor sürücüsüne bağlanacak INPUT ve ENABLE pinleri belirleniyor

*/
const int sagileri = 9;
const int saggeri = 8;
const int solileri = 12;
const int solgeri = 13;
const int solenable = 11;
const int sagenable = 10;

void ileri(int hiz){

/* ilk değişkenimiz sag motorun ikincisi sol motorun hızını
göstermektedir.
* motorlarımızın hızı 0-255 arasında olmalıdır.
* Fakat bazı motorların torkunun yetersizliğiniden 60-255
arasında çalışmaktadır.
* Eğer motorunuzdan tiz bir ses çıkıyorsa hızını arttırmanız
gerekmektedir.
*/
analogWrite(sagenable, hiz); /* sağ motorun hız verisi */
digitalWrite(sagileri,HIGH); /* ileri dönme sağlanıyor */
digitalWrite(saggeri,LOW); /* ileri dönme sağlanıyor */

analogWrite(solenable, hiz); /* sol motorun hız verisi */

digitalWrite(solileri, HIGH); /* ileri dönme sağlanıyor */
digitalWrite(solgeri,LOW); /* ileri dönme sağlanıyor */
}
Lazerli Güvenlik Devresi
Arduino günlük projelerin hemen hemen hepsinde kolaylıkla kullanılabilmektedir. Örneğin odanız
için basit bir lazerli güvenlik sistemi kurabilirsiniz. Lazer ışığının algılanabilmesi için LDR
kullanılacaktır. LDR lazer ışığını alamadığında yani lazerin önünde bir şey geçtiğinde Arduino
buna tepki verecektir. Böylece kapıdan birinin girip girmediğini anlayabilirsiniz.

Daha önceden de öğrendiğimiz gibi LDR ışığın şiddetiyle değişen bir dirençtir. LDR çıkışı
Arduino'nun analog girişine bağlanmıştır. Arduino analog girişini sürekli kontrol etmelidir. Eğer
analog girişin değeri belirli bir değerin altına düşer ise Arduino, lazer ışığı ile LDR arasından bir
şey geçtiğini anlayacaktır.

LDR ışığa duyarlı olduğu için çevre ışıklardan da etkilenmektedir. Bu yüzden LDR'a lazer ışığı
düşmediğinde tam karanlıkta olması gerekir. Bu yüzden LDR'ın opak bir boru içerisinde karanlıkta
kalması sağlanmalıdır.

Bu uygulamayı yapmak için ihtiyacınız olan malzemeler;

 1 x Arduino
 1x 220 ohm direnç
 1x 10 K ohm direnç
 1 x LED
 1 x LDR
 1 x Lazer
 1 x Breadboard
Yukarıdaki devreyi breadboard üzerine kurunuz ve aşağıdaki Arduino kodunu kartınıza yükleyiniz.

/* LED ve LDR pinleri tanımlandı */

const int LED = 2;
const int LDR = A0;

int LDRdegeri = 0;

void setup()
{
/* LED pini çıkış olarak ayarlandı */
pinMode(LED,OUTPUT);
/* LDR pini giriş olarak ayarlandı */
pinMode(LDR,INPUT);
}

void loop()
{
/* LDR'ın çıkışı analog olarak okunuyor */
LDRdegeri = analogRead(LDR);
/*
Eğer LDR'ın değeri 550'den küçük ise
Lazerin önünden bir şey geçmiştir
550 sayısını kendi devrenize göre güncellemelisiniz
*/
if(LDRdegeri < 550){
digitalWrite(LED,HIGH);
delay(250);
}else{
digitalWrite(LED,LOW);
delay(250);
}
}
Yukarıdaki kod ile basit bir güvenlik devresi kurmuş ve analog okuma ve LDR kullanımını tekrar
etmiş olduk. Yukarıdaki kodun çalışma mantığını anladıktan sonra, proje üzerinde değişiklikler
yaparak kendi projelerinizi oluşturabilirsiniz. Örneğin iki adet lazer devresi kurup tek bir
Arduino'dan lazer değerlerini okuyabilirsiniz. İki lazer sistemini aralarında yaklaşık 20 cm olacak
şekilde yerleştirerek, odaya birinin girdiğini veya odadan birinin çıktığını belirleyebilirsiniz.
Projenizin bir sonraki aşamasında da odada kaç kişinin olduğunu hesaplayabilirsiniz.

Odaya giriş mi çıkış mı yapıldığını anlamak için yerleştirilen iki sistemin çalışma mantığı çok
kolaydır. Örneğin ilk olarak çıkışa yakın olan lazerin, daha sonrada girişe yakın olan lazerin ışığı
kesiliyor ise odaya birinin girdiği anlaşılır. Eğer girişe yakın lazer ilk olarak kesiliyor ve daha sonra
da çıkıştaki lazer kesiliyorsa, odadan birinin çıktığı anlaşılır. Bu şekilde projeyi geliştirerek Arduino
kullanımınızı pekiştirebilirsiniz.