Arduino 101 Eğitimi - Ali Keşfet – Keşfet Ali Keşfet · Web viewEğer mesajlarımız doğru...

Arduino 101 Eğitimi

Eğitim İçeriğiElektroniğe Giriş

o Breadboard

o Direnço Voltaj Bölücü ve Potansiyometreo Diğer Elektronik Elemanlar

Yazılıma Giriş

o Fonksiyonlar ve Koşul Yapıları

o Döngüler

Arduino'ya Giriş

o Windows İçin Arduino Kurulumu

o Linux İçin Arduino Kurulumuo Mac OS X İçin Arduino Kurulumu

Arduino'nun Besleme Kaynakları Temel Arduino Fonksiyonları

Temel Arduino Uygulamaları

o Kara Şimşek Uygulaması

o Düğme Kullanımı

Elektroniğe GirişYazar: Geleceği Yazanlar Ekibi

Arduino, yazılım ve elektroniğin bir araya getirildiği ortamdır. Bu yüzden Arduino kullanmaya başlamadan önce temel elektronik bilgilerimizi tazelemeliyiz. Bu bölümde temel elektronik devre elemanlarını tanıyacağız ve bu elemanların nasıl kullanıldığını öğreneceğiz. Bu konuda daha önce çalışma yapmış olanlar bir sonraki konuya geçebilirler.

https://gelecegiyazanlar.turkcell.com.tr/kisi/gy

Dijital ve analog sinyaller

Sinyaller analog ve dijital olmak üzere ikiye ayrılır. Analog sinyaller devamlı sinyallerdir ve her değeri alabilirler. Örnek olarak Sinüs sinyali verilebilir. Dijital sinyaller ise devamlı değildir ve adım adım değişir. Örnek olarak PWM, kare dalgalar verilebilir. Arduino analog sinyalleri işleyemez, fakat doğadaki etkiler ve sensörler analog sinyal ile çalışır. Bu sinyallerin Arduino'da işlenebilmesi için dijital sinyale çevrilmesi gerekir. Bu çevirme işlemine analog dijital çevrim (ADC) denir.

Arduino'nun çıkış pinleri sadece 0 veya 5 volt verebilmektedir. Eğer bu pinlerden analog çıkış almak isterseniz, yani 0 veya 5 volt arasında, dijital analog çevrim (DAC) yapmalısınız. Bu özellikleri daha sonraki konularımızda daha detaylı olarak işleyeceğiz.

BreadboardYazar: Geleceği Yazanlar Ekibi

Breadboard, kullanacağımız elektronik elemanları bir arada tutmak ve gerekli kablo bağlantılarını gerçekleştirmek için kullanılır. Breadboard üzerinde iki çeşit yol vardır. Bunlardan ilki güç yollarıdır. Güç yolları, yani beslememizin artı ve eksi uçlarını taktığımız yer, resimde görülen kırmızı ve mavi şeritlerdir. Aşağıya doğru inen çizgilere karşılık gelen delikler kısa devre durumundadır. Bir başka deyişle, sol üstteki kırmızıdan bağlanan bir kablo aynı çizgi üzerinden bağlanacak kablolar ile birleşiktir. Aynı durum mavi çizgiler için de geçerlidir. Diğer elektronikçilerin de devrenizi anlayabilmesi için standartlara uygun olarak pilin artı ucu kırmızı çizgiye, eksi ucu ise mavi çizgiye takılmalıdır.

Diğer bir hatırlatma olarak da şunu belirtmekte fayda var. Bazı breadboardlarda yanlarda bulunan besleme hatları ikiye bölünmüş olduğu gibi, bazı breadboardlarda ise güç hatları tüm hat boyunca (yukarıdan aşağıya kadar) birbirine bağlıdır. Breadboard üzerindeki diğer yollar, güç hatlarının arasında bulunan yatay hatlardır. Bu hatlar yatay olarak birbirine bağlanmıştır. Fakat iki yatay hattı birbirinden ayırmak için arada bir boşluk vardır. Kısacası bu hatlar boşluğa kadar yatayda birbirine bağlıdır. Bu boşluğun amacı, elektronik entegrelerin takılabilmesini sağlamaktır.


Yukarıdaki görselde bir Breadboard'un iç yapısını görmektesiniz. Böylece Breadboard'daki deliklerin hangilerinin birbirine bağlı olduğunu anlayabilirsiniz.

DirençYazar: Geleceği Yazanlar Ekibi

Daha önce elektronikle çok az ilgilenmiş birinin bile bildiği direnç elemanı, hat üzerinden geçen akımı ayarlamak için kullanılır. V = İ * R formülünden de anlaşıldığı gibi sabit bir gerilime sahip hat üzerinden geçen akım azaltılmak isteniyorsa, direncin değeri yani R değeri artırılmalıdır. Aynı hat üzerinde bulunan elektronik elemanlar üzerinden geçen akımların birbirine eşit olmasından dolayı bu hat üzerinden geçen akımı kontrol etmek için uygun direnci kullanırız.

Örneğin, LED dediğimiz lambaların üzerinden fazla akım geçmesi bu lambalara zarar vermektedir. Bu lambaların fazla akım çekmesini engellemek


için LED'in bağlantısından önce 220 ohm değerinde bir direnç takılır. Böylece LED üzerinden geçen akım azaltılmış olur. Eğer 220 ohm yerine daha büyük bir direnç bağlanırsa LED'in parlaklığında azalma olduğu görülür.

Direncin değeri ne yazık ki direnç üzerinde sayısal olarak yazmamaktadır. Fakat direncin değerinin anlaşılması için, direnç üzerinde renkli şeritler vardır. İlk iki şeritin değerleri ile iki haneli sayı oluşturulur. Bu iki haneli sayının da 103. şeridin değeri ile çarpılmasıyla direncin değeri bulunmuş olur.

Formül şu şekilde özetlenebilir:Direncin değeri = ( 10x(ilk şeritin değeri) + 1x(ikinci şeritin değeri) )x10üçüncü şeridin

değeri

Renklerin değerleri:

Siyah = 0 Kahverengi = 1 Kırmızı = 2 Turuncu = 3 Sarı = 4Yeşil = 5 Mavi = 6 Mor = 7 Gri = 8 Beyaz = 9

Haydi, resimdeki direncin değerini hesaplayalım.

Resimde dört adet şerit görülmektedir. Gümüş renkli şerit 4. şerittir. Bu şerit bize direncin toleransını göstermektedir. Direnç üzerindeki ilk şerit turuncu, ikinci şerit beyaz ve üçüncü şerit ise yeşildir. Yani ilk iki şeritin değeri 39'dur. Üçüncü şerit on üzeri şeklinde yazılırsa 105 yani 100000 elde edilir. Bu sayıların çarpımı sonucunda direncin değeri 3900000 olarak hesaplanır. Kısaca direncin değeri 3,9M ohm'dur.

Voltaj Bölücü ve Potansiyometre

Yazar: Geleceği Yazanlar Ekibi

Voltaj Bölücü: Hattaki gerilimi daha düşük bir gerilime çevirmek için voltaj bölücü devresini kullanılır. Bu devrede iki tane direnç vardır. Kullanılan dirençlerin değerine göre çıkış gerilimi değişir. Voltaj bölücünün çıkışı besleme kaynağı olarak kullanılmamalıdır. Çünkü çıkıştaki elemanların iç direnci, voltaj bölücünün çıkış gerilimini de değiştirmektedir.

Resimde voltaj bölücü devresinin şeması gösterilmiştir. Çıkış gerilimi R1 ve R2 dirençlerine bağlıdır. Vout = Vin*R2/(R1+R2) şeklinde yazılır.

Örneğin, R1=4.7k R2= 10k ohm olarak seçilir ve giriş voltajımız da 5 volt olursa, çıkış voltajımız = 5*10K/(4,7K+10K) = 3,4 Volt olarak bulunur.

Potansiyometre

Voltaj bölücünün çalışma prensibine bağlı devre elemanıdır. Besleme, toprak ve çıkış olmak üzere üç pini bulunur. 2. (ortadaki) pin genellikle çıkış pini olmaktadır. Geriye kalan pinler sırası önemli olmaksızın besleme ve toprak pinleridir. Potansiyometrenin başlığı çevrilerek çıkış gerilimi değiştirilebilir.


Diğer Elektronik ElemanlarYazar: Geleceği Yazanlar Ekibi

Diyot

Tek yönde akım geçiren devre elemanıdır. Çeşitli amaçları yerine getirmesi için farklı diyotlar bulunmaktadır. Klasik diyotların kullanım amacı, akımın tek yönde akmasını sağlamaktır. Eğer akımın istenmeyen bir yönde akma ihtimali varsa, burada diyot kullanılır.

Not: Diyot üzerinde yaklaşık 0,7 Voltluk bir harcama olur. Yani hattımızda 5 volt var ise diyot kullandığımızda diyotun diğer ucunda 4,3 Voltluk bir gerilim kalır. Bu 0,7 Volt diyotun üzerinde kalmıştır.

Başka amaçlarda kullanılmak için geliştirilmiş özel diyotlar vardır:

LED: Normal bir diyot gibi üzerinden tek yönde akım geçmektedir. Normal bir diyottan farkı, üzerinden akım geçtiğinde akımın değerine göre ortama ışık vermesidir.

Zener Diyot: Bu diyot devreye ters (tıkama) yönde bağlanır. Bağlandığı İki hat arasındaki gerilim farkını sabit tutmak için kullanılır. Örneğin hattımızın en fazla 5 volt gerilime sahip olmasını istiyorsak, hat ile toprak arasına zener diyot bağlamalıyız.

Böylece 5 voltun üzerinde bir gerilim oluşursa zener diyot bunu toprağa aktaracaktır.

Transistör

Girişine uygulanan sinyali kuvvetlendiren devre elemanıdır. Aynı zamanda anahtarlama elemanı olarak da kullanılmaktadır.

NPN ve PNP olmak üzere iki tip transistör bulunmaktadır. NPN tipi transistörlerde Kollektör'den (C) gelen akımın Emetör'e (E) geçebilmesi için Base'e (B) gerilim uygulanmalıdır. PNP tipi transistörler ise bunun tam tersi çalışmaktadır.

LDR

Üzerine düşen ışık miktarına göre direnç değeri değişen elektronik devre elemanıdır. Ortam ışığının ölçülmesi gereken projelerde kullanılır. LDR'nin direnci eğer üzerine fazla ışık düşüyorsa sıfıra yakın, az ışık düşüyor vaya karanlık ortamda ise sonsuza yakın olmaktadır.

Yapacağımız projelerde sıklıkla kullanacağımız devre elemanlarını ve bu elemanların kullanım nedenini öğrendik.

Bu bölümde öğrenilen bilgiler, Arduino projelerinde kurulan devreleri anlamaya yardımcı olacaktır. Bu nedenle yeni başlayanlar için, bu bölümün zaman zaman tekrar edilmesi yararlı olacaktır.

Yazılıma GirişYazar: Geleceği Yazanlar Ekibi

Temel elektronik bilgilerimizi tazeledikten sonra, sıra temel yazılım bilgilerimizi de gözden geçirmeye geldi. Bu bölümde diğer programlama dillerinde de benzerlik gösteren, projelerimizde kullanacağımız temel yazılım bilgilerini göreceğiz.

Değişkenler

Bir değeri veya karakteri daha sonra tekrardan kullanmak/değiştirmek için hafızada tutabilirsiniz. Bu değerler değişkenlerde tutulur. Hafızada tutacağınız değerin türüne göre değişken tanımlanması gerekir.

Aşağıdaki tabloda, Arduino'da kullanılan değişken türlerini ve tutabilecekleri değerleri görebilirsiniz.

Değişken

Boyut Açıklama

byte 1 byte 0 – 255 arası işaretsiz sayılar.

boolean 1 byte 0 (FALSE) veya 1 (TRUE) değerini alır.

char 1 byte

-128 ile 127 arasındaki değerleri alır. Tek bir karakterin saklanması için kullanılır.

string 1 byte Metin işlemleri için kullanılır (char dizisi)

int 2 byte

İşaretli sayılar için -32.768 – 32.767İşaretsiz sayıları için 0 – 65,535


long 4 byte

İşaretli sayılar için -2.147.483.648 – 2.147.483.647İşaretsiz sayılar için 0 – 4.294.967.295

float 4 byte İşaretli ondalıklı sayılar -3,4028235E – 3,4028235E

double 4 byte

3,4028235E+38 ile -3,4028235E+38 arasındahassasiyeti yüksek kesirli sayılar barındırır

Örneğin sayi adında bir değişken tanımlayalım. Bu değişkenin içerisine sadece tamsayılar yazılır. Bu değişkeni tanımlamak için aşağıdaki komut kullanılabilir.

int sayi = 5;

Bu satırda tamsayı tutabilen (integer) 'sayi' değişkeni oluşturulmuştur. Oluşturma esnasında 'sayi' değişkeninin değeri 5 olarak belirlenmiştir. Değişken, değer ataması yapmadan da oluşturulabilirdi.

Eğer değişken bir fonksiyonun içerisinde oluşturulursa, sadece o fonksiyonun içerisinde geçerlidir. Bir başka deyişle fonksiyonun dışarısında o değişken kullanılamaz. Her yerde kullanılabilecek bir değişken tanımlanacaksa o değişken, tüm fonksiyonların dışında, programın başında oluşturulmalıdır. Bu değişkenlere 'global' adı verilir.

Fonksiyonlar ve Koşul Yapıları


Fonksiyonlar

Bir görevi yerine getirmesi için yazdığınız kodları başka bir yerde de kullanmanız gerekirse, o kod satırlarını kopyalayıp yeni kodların arasına yapıştırmanız gerekir. Bu yöntemle programınız gereksiz olarak uzar. Ayrıca kopyaladığınız satırlarda yapacağınız en küçük bir değişimi bile, programın ilgili yerlerinde tek tek değiştirmeniz gerekir. Bu sorunu çözmek için fonksiyonlar kullanılır. Gerekli görev için yazılacak tek bir fonksiyon, istenen yerlerde kolayca kullanılabilir. Kullanıcı kendi fonksiyonlarını yazabileceği gibi, daha önce başkaları tarafından yazılmış fonksiyonları da kullanabilir.

Fonksiyon yazarken, fonksiyonda kullanılacak değişkenlerin alınmasına ve fonksiyonda yapılacak işlem sonucunun hangi türde olacağına dikkat edilmelidir. Fonksiyonun türü, işlem sonucunda döndürülecek değişken ile aynı tipte olmalıdır. Eğer fonksiyon, hiçbir değer döndürmeyecekse fonksiyon 'void' türünde tanımlanmalıdır.

Örneğin toplama işlemi yapan ve sonucu geri döndüren bir fonksiyon yazalım. Fonksiyon a ve b olmak üzere iki sayı almaktadır. Bunları toplayıp sonucu geri döndürmektedir.


int toplama(int a, int b){

int sonuc;

sonuc = a + b;

return sonuc;

}

Burada oluşturulan sonuç değişkeni sadece fonksiyon içerisinde geçerlidir. Fonksiyonun görevi bittikten sonra sonuç değişkeni kaybolur. Bu fonksiyonu programınızın gerekli yerinde kullanmak isterseniz;

int islemSonucu;

islemSonucu = toplama(2 + 3);

şeklinde fonksiyonu çağırmanız yeterli olacaktır.

Koşul yapıları (if-else-elseif)

Hemen hemen her yazılım dilinde bulunan temel kod yapılarından birisidir. Koşul yapıları ile bir durumun sonucu doğrultusunda yapılacak işi belirtebiliriz. Eğer bu durum istediğimiz gibi sonuçlanmadıysa da yapılacak görevi belirleyebiliriz. Örneğin; A değişkeni 1'e eşit ise A_fonk() , eğer 2'ye eşitse B_fonk() ve diğer koşullarda C_fonk() fonksiyonunu çağıralım.

if( A == 1 ){

A_fonk();

}else if( A == 2){

B_fonk();

}else{

C_fonk();

}

Fark ettiyseniz A'nın 1'e eşitlik durumunu '==' ile kontrol ettik. Bu işaret aslında denklik anlamına gelmektedir. Bir sayının diğer sayıya eşitliğini kontrol ettiğimiz gibi, büyüklüğü küçüklüğünü de test edebiliriz.

Koşul olarak kullanılabilen ifadeler:

== Denkse != Denk değilse

> Büyüktür < Küçüktür

>= Büyük veya eşitse <= Küçük veya eşitse

Koşul1 && Koşul 2 ve Koşul1 || Koşul 2 veya

Döngüler


Yazılan kodlarda belirli satırların birden fazla tekrar edilmesi istenebilir. Böyle durumlarda döngü yapıları kullanılır. Döngü yapılarında, döngünün kaç kere tekrar edeceği dinamik olarak belirlenebilir. Hatta döngünün tekrarlaması bir koşula bağlanabilir.

For döngüsü: İçerisinde tanımlanan değişkenin değeri, büyüklük koşulunu sağladığı sürece döngü devam eder. Her döngü turu tamamlandığında, yeni tura geçmeden önce değişkenin değeri bir arttırılır ve koşul test edilir. Eğer koşul hala geçerli ise döngü turu başlar. Koşulun geçerliliği bittiğinde döngü biter ve program kaldığı yerden devam eder.

Örneğin 5 kere tekrar eden for döngüsü yazalım.

for(int i =0; i < 5; i ++){/*Burası 5 kere okunacak program buraya her uğradığında i değeri bir arttırılacak i değeri 5'e ulaşana kadar döngü devam edecek i değeri 5 olduğu zaman döngü bitecek*/}

While döngüsü: While döngüsü genellikle bir koşula bağlanır. Eğer koşul doğru ise döngü devam eder. Koşul bozulduğunda döngü biter ve program kaldığı yerden devam eder. Örneğin while dışında 'h' değişkeni tanımlayalım. Bu değişkenin ilk değeri 5 olsun. Eğer 'h' değişkeni 100'den küçükse döngü devam etsin. Döngünün her turunda da 'h' değişkeninin değeri 2 katına çıksın.Dikkat: Her döngüde iki katına çıkan değişkenlerin bulunduğu kodlarda genellikle ilk değişken hatası yapılmaktadır. Değişkenin ilk değeri kesinlikle belirlenmeli ve çarpma işlemi olduğu için bu değer '0' olmamalıdır. Aksi durumda koşul sonsuza kadar doğru olur ve döngü hiçbir zaman sona ermez.

int h = 5;while( h < 100){/*Burası h değişkeni 100den küçük olduğu sürece çalışacak*/

h = h * 2;/*Üst satırdaki h'ı iki katına çıkartma işlemi alttaki satırdaki gibi de tanımlanabilirdih *= 2;Eğer h'ın değeri arttırılmazsa döngü koşulu doğru olduğu için döngü sonsuza kadar devam edecektir*/}

Arduino'ya GirişYazar: Geleceği Yazanlar Ekibi

Arduino, üzerinde bulundurduğu özel giriş ve çıkış portları yardımıyla, programcının yazdığı özel kodları fiziksel etkiye çeviren elektronik devre kartıdır. Yazılımsal ve donanımsal olarak tamamen açık kaynaklı veözgür olmasından dolayı, isteyen herkes Arduino'nun gelişmesine katkı sağlayabilmektedir. Diğer programcılar tarafından hazırlanmış geniş kütüphaneler ve örnek projeler sayesinde Arduino, Dünya üzerinde en çok kullanılan elektronik devre kartlarındandır.

Arduino ile proje ve prototip hazırlama diğer mikroişlemcilere göre daha hızlı olmaktadır. Bu yüzden Arduino prototip hazırlamada ve elektronik programlamaya girişte yaygın olarak kullanılmaktadır.

Arduino üzerinde bulunan donanımlar ve pinler, Arduino'ya yüklenen kodlar tarafından kolaylıkla kontrol edilebilmektedir. Programcı tarafından yazılan bu kodların işlenmesi için Arduino üzerinde Atmel marka mikroişlemciler bulunmaktadır. Bu mikroişlemcilerin türüne göre de Arduino türleri belli olmaktadır. Arduino'nun bir türü için yazılmış bir kod, eğer o türe has özel donanımlar kullanmıyorsa diğer Arduino türleri üzerinde de sorunsuz çalışmaktadır. Bu yüzden çoğu Arduino projesi hemen hemen her Arduino türünde çalışmaktadır.

Yaygın olarak kullanılan Arduino türleri ve özellikleri

Arduino UNO

Mikrokontrolcü: ATmega328Çalışma gerilimi: 5 VoltÖnerilen giriş voltajı: 7 – 12 VoltI/O (giriş/çıkış) sayısı: 14 (6 PWM)I/O çıkış akımı: 40 mAAnalog giriş: 6Flash bellek: 32 KBSRAM: 2 KBEEPROM: 1 KB

Arduino Mega

Mikrokontrolcü: ATmega2560Çalışma gerilimi: 5 VoltÖnerilen giriş voltajı: 7 – 12 VoltI/O (giriş/çıkış) sayısı: 54 (15 PWM)I/O çıkış akımı: 40 mAAnalog giriş: 16Flash bellek: 256 KBSRAM: 8 KBEEPROM: 4 KB

Arduino Nano

Mikrokontrolcü: ATmega168 ya da ATmega328Çalışma gerilimi: 5 VoltÖnerilen giriş voltajı: 7 – 12 VoltI/O (giriş/çıkış) sayısı: 14 (6 PWM)I/O çıkış akımı: 40 mAAnalog giriş: 8Flash bellek: 16 KBNot: Arduino seçimi yapılacak projeye göre seçilmektedir. Projede kullanılacak giriş çıkış pinleri, analog girişler, program/EEPROM hafızası gibi değişkenler kullanılacak Arduino türünü belirlemektedir. Genel amaçlı projelerde kullanmak için genellikle Arduino Uno veya Mega seçilmektedir. Arduino için ayrılan yerin az olduğu projelerde Arduino Nano kullanılmaktadır.

Eğitim sırasında Arduino UNO kullanılacaktır. Uygulamalarda yazılan kodların diğer Arduino türlerinde de çalışması için özen gösterilmiştir. Arduino IDE üzerinde yazılan Arduino kodları, yine bu yazılımla Arduino kartına yüklenecektir.

Arduino'nun resmi web sitesine ulaşmak için tıklayın.Windows İçin Arduino KurulumuYazar: Geleceği Yazanlar Ekibi

Arduino'yu kullanmaya başlayacağız. Bunun için öncelikle Arduino'nun USB kablosunu Arduino'ya bağlayın ve ardından bilgisayarınıza takın. Windows 7 ve üst sürümlerinde Arduino sürücüsü otomatik olarak yüklenecektir. Biraz bekledikten sonra Arduino bilgisayar tarafından tanınacaktır.

Arduino'nun bilgisayar tarafından tanınıp tanınmadığını görmek için aygıt yöneticisinden kontrol edin ve Arduino'nun bağlı olduğu COM portunu not edin (Aygıt yöneticisi: Bilgisayarım'a sağ tıklayın -> Yönet -> Aygıt Yöneticisi).


Eğer bilgisayarımız Arduino'yu otomatik olarak tanımadıysa, Arduino sürücüsü yüklemeliyiz. Bunun için yukarıda belirtildiği gibi aygıt yöneticisini bulunuz. Diğer aygıtlar kısmında Arduino'yu temsil eden kısma çift tıklayarak "Aygıt Özellikleri" penceresini açınız. Bu pencerenin sağ alt kısmındaki "Sürücüyü Güncelleştir" düğmesine tıklayın. "Sürücü yazılımı için bilgisayarımı tara" dedikten sonra "Gözat" düğmeyi yardımıyla Arduino sürücüsünü seçin ve ileri düğmesine tıklayarak yüklemeyi gerçekleştirin.

Arduino sürücüleri Arduino modeline özgü olarak değişmektedir. Arduino'nun kendi sitesinden modelinize göre sürücü bulabilirsiniz.

Dikkat: Arduino sürücüsünü bilgisayarınıza yüklerken, yukarıdaki gibi bir hata mesajı çıkabilir. "Bu sürücü yazılımını yine de yükle" diyerek yükleme işlemine devam ediniz.

Yazılımı indirin

http://www.arduino.cc/en/main/Software

Arduino Bütünleşik Geliştirme Ortamı'nı (IDE) indirmek için Arduino sitesine gidip, bu IDE'nin güncel halini kurunuz. Yazılım kurulumunda özel olarak yapılması gereken bir ayar yoktur, normal bir program kurulumu gibidir. Hatasız bir şekilde kurulumu gerçekleştirdikten sonra IDE'yi açabilirsiniz.Not: Arduino IDE'si tüm Arduino türleri için ortaktır. Aynı arayüzü kullanarak tüm Arduino kartlarına (Uno, Mega, Micro...) kodunuzu yükleyebilirsiniz.

Arduino IDE'sini çalıştırdığınızda yukarıdaki gibi bir ekran sizi karşılayacaktır. Bu ekranın ortasındaki kısma proje kodları yazılır. Arayüzün en sağ altındaki yer, size kullandığınız Arduino modelini ve Arduino'nun hangi porta bağlı

http://www.arduino.cc/en/Main/Software

olduğunu gösterir. Eğer bu ayarlar doğru değilse, öncelikle bu ayarlar düzenlenmelidir:

Tools menüsü: Buradan kullandığınız Arduino türünü ve Arduino'nun bağlı olduğu COM portunu seçiniz. Eğer Arduino'nun bağlı olduğu portu bilmiyorsanız, aygıt yöneticisinden bakabilirsiniz.

Program Compile: Bu düğmeyle yazdığınız programı kontrol edebilirsiniz. Eğer kodda hata varsa alttaki siyah bölümde turuncu yazıyla yaptığınız hata ve satırı yazacaktır. Hatırlatma: Bulunduğumuz satırın sayısı sol atta yazmaktadır.

Program Compile & Upload: Bu düğmeyle önce yazdığınız kod derlenir. Eğer kodda hata yok ise yazılan kod Arduino'nun anlayacağı dile çevrilir ve otomatik olarak Arduino'ya atılır. İşlem sırasında ilerleme çubuğundan işlem durumunu görebilirsiniz. Ayrıca programın atılma sürecinde, Arduino üzerinde bulunan Tx ve Rx LED'leri hızlı bir şekilde yanıp söner. Programı bir kere Arduino'ya atmanız yeterli olacaktır. Arduino'ya yeni program atmak istediğinizde eskisini silmenize gerek yoktur. Yine bu düğmeyle her zaman yeni kod atabilirsiniz.

Serial Monitor: Yeni pencere açan bu düğmeyle Arduino'dan yolladığınız verileri görebilirsiniz. İlerleyen konularda bu düğme sıklıkla kullanılacaktır.

Arduino ile ilgili bilmemiz gereken temel bilgileri öğrendik. Artık Arduino programlamaya başlayabiliriz.

Linux İçin Arduino KurulumuYazar: Ali Işıngör

Herhangi bir Linux dağıtımına Arduino Bütünleşik Geliştirme Ortamı'nın (IDE) kurulumu, diğer platformlara göre biraz daha uzun bir işlem. Öte yandan Arduino geliştiricilerinin önemli bir kısmı Linux kullandığından, yenilikler ilk olarak bu platforma geliyor. Bu nedenle de Arduino ile geliştirme yapacaklara Linux platformunu kullanmalarını salık veriyoruz.

Bu eğitim içeriğimizde Ubuntu'nun 15.04 sürümünün üzerine Arduino IDE'sini nasıl kuracağımızı anlatacağız.

Kurulum

Ubuntu'nun Yazılım Merkezi'nde Arduino IDE'sinin 1.0.5 sürümü mevcut ancak biz sitesinden daha güncel olan sürümü kuracağız.

İlk olarak Arduino'nun sitesine gidiyoruz ve yukarıdaki Download sekmesine tıklıyoruz:

Bu aşamada Arduino bize açık kaynak kodlu ve özgür projeye bağış yapıp yapmayacağımızı soracak.

Bağış yapmak için Contribute&Download, bağış yapmadan devam etmek içinse Just Download düğmesine tıklıyoruz. Yükleme işleminin başlamasıyla birlikte yaklaşık 90 MB'lık bir dosyayı bilgisayarımıza indiriyoruz.

Son 5 yıl içinde alınmış bir bilgisayara sahipseniz, çok yüksek bir ihtimalle 64 bitlik bir işletim sistemi kullanıyorsunuzdur. Biz de bu nedenle Linux 64 bits yazan bağlantıda yer alan kurulum dosyasını bilgisayarımızdaki İndirilenler dizinine (İngilizce kurulumlarda Downloads) indirdik.

Bu yazı yazıldığında Arduino IDE'sinin güncel sürümü 1.6.5'ti. Daha yeni bir sürümle karşılaşırsanız şaşırmayın, o sürümü indirin. Böylesi bir durumda, aşağıda yer alan komutlarda geçen dosya adının indirdiğiniz sürümle aynı olmasına dikkat etmenizde fayda var :).

CTRL + ALT + T tuş üçlüsüyle terminali açıyor ve kurulum dosyasını /opt dizinine taşıyoruz.

$ cd ~/İndirilenler$ tar -xf arduino-1.6.5-linux64.tar.xz$ sudo mv arduino-1.6.5 /opt

Sistemimize Java geliştirme ortamını kuruyoruz.

$ sudo apt-get install openjdk-7-jre

"Ek bağımlılıkları da kurmak istiyor musunuz?" sorusuna Evet (e) diyerek devam ediyoruz.

Bu aşamada elimizdeki Arduino'yu USB kabloyla bilgisayara bağlayacağız. USB yuvasına okuma ve yazma izni vermemiz gerekiyor.

$ sudo chmod a+rw /dev/ttyACM0

Terminalde dmesg yazıp çıktısına dikkatle bakalım:

$ dmesg -- ilgili kısım --

usb 1-2: new full-speed USB device number 6 using xhci_hcd[15619.872405] usb 1-2: New USB device found, idVendor=2341, idProduct=0036[15619.872408] usb 1-2: New USB device strings: Mfr=2, Product=1, SerialNumber=0[15619.872409] usb 1-2: Product: Arduino Leonardo[15619.872411] usb 1-2: Manufacturer: Arduino LLC

[15619.872599] usb 1-2: ep 0x82 - rounding interval to 1024 microframes, ep desc says 2040 microframes[15619.893510] cdc_acm 1-2:1.0: ttyACM0: USB ACM device[15619.893694] usbcore: registered new interface driver cdc_acm[15619.893696] cdc_acm: USB Abstract Control Model driver for USB modems and ISDN adapters

Göreceğiniz üzere, sistemimize bir Arduino Leonardo kartı, /dev/ttyACM0 üzerinden bağlı.

Sonradan kolaylık olması için masaüstümüzde bir kısayol oluşturalım:

$ cd ~/Masaüstü/$ ln -s /opt/arduino-1.6.5/arduino

Geriye son bir iş daha kaldı.

Ubuntu çalıştırılabilir dosyaları açmak yerine bir editörle açıyor. Bir dosyayı çalıştırabilmek için başlatıcıdan (Daha bilinen adıyla Dash) Dosyalar programını çağıralım. Üstteki Değiştir menüsünden "Tercihler"i seçelim. Davranış sekmesindeki "Açıldığında çalıştırılabilir metin dosyalarını çalıştır" seçeneğini işaretliyoruz.

Arduino Bütünleşik Geliştirme Ortamı (IDE) artık emir ve komutalarınıza hazırdır!

Mac OS X İçin Arduino KurulumuYazar: Cansu Uludağ

Mac OS X'e Arduino Bütünleşik Geliştirme Ortamı'nı (IDE) kurmak için buradan indirme sayfasına gidelim.

Karşımıza gelen sayfadan "Mac OS X 10.7 Lion or newer" düğmesine tıklayarak indirme işleminin ilk adımını atalım.

İndirme sayfasında karşımıza bağış ekranı gelecek. Eğer bağış yapmak istemiyorsanız "Just Download" seçeneğini seçerek kurulum dosyasının indirmesine başlıyoruz.

Dosya indikten sonra üzerine çift tıklıyoruz ve cihazınızın ilk kurulumu yapmasını sağlıyoruz. Ardından dosyanın bulunduğu yere Arduino simgesinin geldiğini göreceksiniz. IDE'niz kullanıma hazır.

Kodlarınızı yazabileceğiniz editör aşağıdaki şekilde görünmeli. Arduino kartınızı bağladığınız zaman bilgisayarınız otomatik olarak kartı tanıyacak. Kolay gelsin!

Arduino'nun Besleme KaynaklarıYazar: Geleceği Yazanlar Ekibi

Arduino'nun çalışması için gerekli olan enerji, Arduino'nun farklı besleme girişlerinden sağlanabilmektedir. Arduino'nun farklı besleme girişleri

kullanılırken, bu girişe uygulanacak maksimum gerilimin bilinmesi gerekir. Eğer girişe uygulanması gereken gerilimden fazla bir gerilim uygulanırsa, Arduino zarar görebilir.

Arduino'nun USB ile beslenmesi

Arduino'nun USB kablosunu bilgisayarınıza bağladığınızda, Arduino çalışması için gerekli enerjiyi bilgisayarınızdan almaktadır. Bu giriş, Arduino için gerekli enerjiyi sağlarken, aynı zamanda Arduino'nun bilgisayarla haberleşmesini, Arduino'ya yeni kod atılmasını da sağlar.

Yukarıdaki görselde 1 numaralı giriş Arduino'nun USB girişidir. Görselde de görüldüğü gibi bu giriş, yazıcı kablosu olarak tarif edilen USB B girişidir. USB standartlarına uygun olarak tasarlanan bu girişe en fazla 5 Volt gerilim uygulanmalıdır. Eğer bu girişe 5 Volt üzeri bir gerilim uygulanırsa, Arduino zarar görebilir.

Arduino'nun pille çalıştırılması

https://gelecegiyazanlar.turkcell.com.tr/sites/default/files/icerik/resim1_4.jpg

Arduino harici besleme kaynaklarıyla da çalıştırılabilir. Bunun için Arduino üzerinde birbirine bağlı iki farklı giriş bulunmaktadır. Bu girişlerden ilki, yukarıdaki görselde 2 numara ile gösterilen jack girişidir. Bu girişe 7 ile 12 Volt (önerilen) arasındaki gerilimler uygulanabilir. Bu girişe bağlı regülatör (gerilim düzenleyicisi) ile girişe uygulanan gerilim, Arduino'nun çalışma gerilimine düşürülür.

Arduino üzerinde bulunan 'Vin' pini, Arduino'nun jack girişine bağlı bir pindir. Bu pine uygulanan gerilim, Arduino'ya ulaşmadan önce bu pine bağlı regülatör yardımıyla Arduino için uygun gerilime düşürülür. 'Vin' girişine 7 ile 12 Volt arasındaki gerilimler uygulanmalıdır. Pilin artı (+) ucu 'Vin' pinine bağlandıktan sonra, pilin eksi (-) ucu Arduino'nun 'GND' yani toprak ucuna bağlanmalıdır. 'Vin' pini yukarıdaki görselde 3 numara ile gösterilmiştir.

Eğer bu girişlere uygulanması gereken gerilimden fazla bir gerilim uygulanırsa, Arduino zarar görebilir.

Arduino'nun 5 Volt pininden beslenmesi

Arduino üzerinde bulunan 5 Volt pini de Arduino'yu beslemek için kullanılabilir. Arduino yaygın olarak bu pinden beslenmese bile, buraya 5 Volt gerilim uygulandığında, Arduino'nun çalıştığı görülmektedir. Bu pine 5 Volt geriliminden fazla bir gerilim uygulanması, Arduino'nun bozulmasına neden olacaktır. Pek tercih edilmese bile, eğer elinizde düzenli olarak 5 Volt gerilim veren bir kaynak varsa, kaynağın artı (+) ucunu Arduino'nun 5 Volt, eksi (-) ucunu da Arduino'nun 'GND' yani toprak pinine bağlayarak kullanabilirsiniz.

Bu pin yukarıdaki görselde 4 numara olarak gösterilmiştir.Temel Arduino FonksiyonlarıYazar: Geleceği Yazanlar Ekibi

Fonksiyonların ne olduğunu daha önce öğrenmiştik. Arduino geliştiricileri tarafından yazılmış bazı hazır fonksiyonlar vardır. Bu fonksiyonların yardımıyla yapmak istediğimiz işlemleri daha kolay yapabiliriz. Bazı genel fonksiyonlar için herhangi bir kütüphaneye ihtiyaç yoktur. Daha özel görevler için yazılmış fonksiyonları kullanmak için, o fonksiyonun kütüphanesini dosyanıza eklemeniz gerekir.

Kütüphane ekleme

Yeni bir kütüphane eklemek için kütüphane dosyalarını Arduino programını kurduğunuz dizinin altında bulunan 'libraries' klasörüne taşıyın. Eğer bu sırada Arduino programı açıksa, taşıma işlemi bittikten sonra, kapatıp yeniden açın. Dosyanın en başında kütüphaneyi projenize ekleyin. Bunun için aşağıdaki kodu kullanabilirsiniz.

#include <kutuphaneadi.h>

Artık kütüphanenin içerisinde bulunan fonksiyonları kullanabilirsiniz.

Setup ve Loop fonksiyonları

Arduino projenizi ilk açtığınızda karşınıza iki fonksiyon çıkar. Bunlar setup ve loop fonksiyonlarıdır.

Setup fonksiyonu, kod çalışmaya başladığında Arduino'nun ilk olarak okuduğu yerdir. Arduino bu kısmı okuduktan sonra diğer kısımları okumaya başlar. Bu kısım sadece bir kere okunur ve program esnasında yeniden okunmaz. Bu alanda, pinlerin çalışma modları gibi önemli ve bir kere yapılması yeterli olacak ayarlamalar yapılır.

Loop fonksiyonu, setup fonksiyonu okunduktan sonra okunur. Bu bir ana fonksiyondur ve yapılmasını istediğiniz görevler buraya yazılır. Loop fonksiyonu, sonsuz döngü şeklindedir, yani buradaki görevler tamamlandığında, program tekrar başa dönerek işlemleri yeniden yapar. Bu döngü, Arduino çalıştığı sürece devam eder.

Arduino programlamadan önce kodlarınız ilk başta aşağıdaki gibi olmalıdır.

void setup(){ /* Burası sadece bir kere çalışır Genel ayarlar buradan yapılır */}void loop(){ /* Bu fonksiyon sonsuza kadar çalışır Arduino'nun yapması gereken işlemler buraya yazılır */}

PinMode

Arduino kartı üzerinde bulunan pinleri çıkış veya giriş olarak tanımlayabilirsiniz. Giriş olarak tanımlanmış pinler düğme gibi elemanlar için kullanılırken, çıkış olarak tanımlanmış pinler ise LED gibi elemanlar için kullanılır. Programın en başında (Setup içerisinde), kullanılacak pinler ayarlanmalıdır. Bunun için aşağıdaki kod kullanılır:

pinMode(13,OUTPUT);

Böylece 13. Pin çıkış olarak tanımlanır. Giriş olarak tanımlanması için OUTPUT yerine INPUT yazılması gerekir.

DigitalWrite: Çıkış olarak tanımlanmış pinlerden enerji vermek için veya enerji vermeyi durdurmak için kullanılır. Örneğin:

digitalWrite(13,HIGH);

Böylece, daha önce çıkış olarak tanımlanmış 13 numaralı pinden enerji çıkışı sağlanır. Enerji çıkışı durdurulmak istenildiğinde HIGH yerine LOW yazılması yeterlidir.AnalogWrite: Seçilen pinde PWM sinyalinin üretilmesini sağlar. PWM sinyalinin görev zamanı (Duty cycle) fonksiyona verilen değer ile belirlenir. Örneğin bu pine bağlanan bir LED ışığının parlaklığı verilen PWM sinyali ile ayarlanabilir.

analogWrite(LEDPin, 175);

Seçilen pinlerde PWM desteği bulunmasına dikkat edilmelidir. Bu konu ilerleyen konularda daha detaylı olarak incelenecektir.

DigitalRead: Daha önce giriş olarak tanımlanmış bir pinin girişindeki gerilimin yüksek (5 volta yakın) veya düşük (0 volta yakın) olduğu anlaşılır. Örneğin daha önceden giriş olarak tanımlanmış 13 nolu pindeki durumu daha önceden tanımlanmış 'durum' değişkenine yazdıralım

durum = digitalRead(13);

13 numaralı pindeki gerilim 5 volta yakın ise 'durum' değişkeni 1 (HIGH), 0 volta yakın ise 0 (LOW) olmuştur.

AnalogRead: Bir önceki fonksiyon ile 13 numaralı pindeki gerilimin 5 veya 0 olmasını ölçtük. digitalRead fonksiyonu, 0 ve 5 volt arasındaki gerilimlerin tam değerini ölçemez. 0 ve 5 volt arasındaki gerilimin tam değerinin ölçülmesi için analogRead fonksiyonu kullanılmalıdır. Fakat bu fonksiyon, tüm pinler için kullanılamaz. Bu fonksiyonun kullanılabileceği özel pinler vardır. Bunlara analog pinler denir ve genellikle A harfi ile başlarlar: A0, A1, A2… gibi. Kullanılan Arduino türüne göre bu pinlerin sayısı değişiklik gösterir.

Arduino Uno'da 6, Arduino Mega'da 16 tane analog giriş bulunur. Kullanılacak analog pin, öncelikle giriş olarak tanımlanmalıdır:

pinMode(A0,INPUT)

Örneğin A0'daki değeri 'analogDeger' değişkenine kaydedelim. A0'daki gerilim 10 bit olarak kaydedilecektir. Bu durumu ilerleyen bölümlerde daha detaylı olarak göreceğiz.

analogDeger = AnalogRead(A0);

Delay

İki kod arasında bir süre beklenmesi istenirse, delay fonksiyonu kullanılır. Örneğin yanıp sönen lamba uygulaması yapılmak istenirse, lamba yakıp söndürme kodları arasında bekleme amacıyla delay fonksiyonu kullanılır. Delay fonksiyonunun içerisine yazılan değer milisaniye düzeyindedir. Bir saniyelik bir bekleme için fonksiyona 1000 değeri verilmelidir.

Örneğin yarım saniyelik bir bekleme fonksiyonu yazalım;

delay(500);

Bu bölümde, Arduino projelerimizde kullanacağımız temel fonksiyonları öğrendik. Geri kalan fonksiyonları, ilerleyen konularda örneklerle inceleyeceğiz.Temel Arduino UygulamalarıYazar: Geleceği Yazanlar Ekibi

Yeni bir programlama dili öğrendiğimizde ilk başta nasıl "Merhaba Dünya" yazıyorsak, Arduino programlamanın da giriş uygulaması LED (lamba) yakıp söndürmektir. Daha önce LED'in ne olduğundan bahsetmiştik. Şimdi de LED'in nasıl kullanıldığından bahsedelim. LED bilindiği gibi bir çeşit diyottur, akım sadece bir yönde akmaktadır. Bu yüzden LED'in devreye bağlanma yönü önemlidir.

https://tr.wikipedia.org/wiki/Merhaba_d%C3%BCnya_program%C4%B1


LED'in yönünü iki şekilde anlayabiliriz. İlk yöntemimiz LED'in ayak uzunluklarıdır. LED'in iki ayağından uzun olanı + (anot), kısa olan – (katot) ucunu göstermektedir. Böylece Arduino'dan gelen kabloyu LED'in uzun ayağına, kısa ayağını da toprağa (GND) bağlayacağız. Bu yöntem ile anot ve katot uçlarını ayırmak kolay olsa da güvenilir değildir. Eğer LED daha önce kullanılmış ise ayak uzunlukları değiştirilmiş olabilir.

Diğer ve daha güvenilir olan ikinci yöntemle LED'in anot ve katot uçlarını daha kolay anlayabiliriz. LED'in içine bakıldığında, arası açık bir köprü görülür. Bu köprünün kısa yolu + (anot), uzun yolu ise – (katot) ucu göstermektedir.

LED'in bağlantısının nasıl yapılacağını öğrendik. Fakat LED'i devreye doğrudan bağlama pek önerilen bir yöntem değildir. LED'in bağlı olduğu hatta akımı azaltmak için direnç bağlanmalıdır. Genellikle 220 veya 330 ohm değerinde direnç bağlanır. Bu değerlerden daha büyük bir direnç hatta bağlanırsa, LED'in parlaklığı azalır.

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

1 x Arduino 1 x LED (rengi farketmez) 1 x 220 ohm direnç (220 ile 10k arasında bir direnç de olur) 1 x Breadboard

Resimde görüldüğü gibi devrenizi kurunuz. Arduino'nun 7 numaralı pininden bir kablo yardımıyla çıkış alıp Breadboard üzerindeki dirence bağlayınız. Daha sonra direncin diğer ucunu LED'in + ucuna bağlayın. LED'in diğer ucunu ise Arduino'nun toprağına bağlayın. Aynı hat üzerindeki akım her yerde aynı olduğu için direncin LED'den önce veya sonra bağlanması önemli değildir.

Arduino kodunu yazmaya başlayalım. Amacımız 1 saniye boyunca yanan ve sonra 1 saniye boyunca sönük kalan LED yapmaktır. Bunun için setup

fonksiyonu içerisinde LED'in bağlı olduğu Arduino'nun 7. pinini çıkış olarak ayarlayacağız. Daha sonra loop fonksiyonu içerisine 1 saniye aralıklı LED yakma ve söndürme kodunu yazacağız. Loop fonksiyonu sürekli döngü halinde olduğu için bir kere LED yakma ve söndürme kodunu yazmamız yeterli olacaktır. 1 saniyelik bekleme için delay fonksiyonu kullanılmıştır.

void setup(){ pinMode(7, OUTPUT); /* 7 numaralı pini çıkış yaptık */}

void loop(){ digitalWrite(7,HIGH); /* 7 numaralı pine enerji verildi */ delay(1000); /* 1000 milisaniye = 1 saniye bekleme */ digitalWrite(7,LOW); /* 7 numaralı pindeki enerji kesildi */ delay(1000); /* 1 saniye bekleme */}

Böylece Arduino'da yapılabilecek en temel işlerinden biri olan LED yakıp söndürmeyi öğrendik. Burada kullanılan fonksiyonlar çoğu projede de kullanılır. Örneğin LED yerine çıkış veren başka bir elektronik eleman (örn: buzzer) konulduğunda, aynı Arduino programı ile o eleman da çalışabilir. Kapsamlı projelerde LED genellikle Arduino'nun durumunu göstermek için kullanılır. Örneğin Arduino bir işlem yaparken kırmızı ışık yanık tutulursa, Arduino'nun o sürede meşgul olduğu kullanıcı tarafından anlaşılabilir. Aşağıdaki uygulama ile öğrendiklerimizi pekiştirelim:

Kara Şimşek UygulamasıYazar: Geleceği Yazanlar Ekibi

Arduino ile LED nasıl yakılıp söndürüldüğünü öğrendiğimize göre, artık biraz daha karmaşık bir uygulama yapabiliriz. Bu uygulamamızda kara şimşek yani sırayla yanıp sönen LED'ler yapacağız. LED bağlantılarını resimdeki gibi


yapabilirsiniz. Her LED'in bağlantısına ayrı ayrı 220 Ohm'luk dirençler koymayı unutmayın. LED'lerin Breadboard'a eşit uzaklıklarda takılması, projenin daha güzel görünmesini sağlayacaktır.


1 x Arduino 8 x LED 8 x 220 Ohm Direnç 1 x Breadboard

Kara şimşek programı iki şekilde yazılabilir. Birinci yöntemde her LED için ayrı bir değişken tanımlanmış olup, bütün LED'ler tek tek kontrol edilir. Bu yöntem kod kalabalığı yarattığı için pek tercih edilmemektedir. Bu yüzden projeyi daha profesyonelce olan ikinci yöntem ile yazacağız.

İkinci yöntem için, LED'leri 2'den 9'a pinlere sırası ile takalım. Bu pinleri bir diziye kaydederek LED'leri daha kolay kontrol edeceğiz. Dizi kullanılmasının nedeni, program içerisinde for döngüsünün kullanılacak olmasıdır. Her bir for döngüsünde bir sonraki LED'e kolayca geçiş yapılabilir.Not: LED geçişlerinin daha yumuşak olması için her LED'in artı ve eksi pinlerine kondansatör konulabilir.const int LEDdizisi[] = {2,3,4,5,6,7,8,9};

void setup () { for(int i=0; i<8 ;i++) { /* For dongusuyle LEDdizisi elemanlarina ulasiyoruz */ pinMode(LEDdizisi[i], OUTPUT); /* LED pinleri cikis olarak ayarlandi */ }

}

void loop() {

for(int i=0; i<8; i++){ /* Tum LEDleri sirayla 50 milisaniye yakip sonduruyoruz */ digitalWrite(LEDdizisi[i],HIGH); delay(50); digitalWrite(LEDdizisi[i],LOW); } for(int j=7;j>-1; j--) { /* LEDleri geri yonde 50 milisaniye yakip sonduruyoruz */ digitalWrite(LEDdizisi[j],HIGH); delay(50); digitalWrite(LEDdizisi[j], LOW); }}

Düğme KullanımıYazar: Geleceği Yazanlar Ekibi

Kullanıcıyla etkileşim halinde olan birçok projede düğme kullanılmaktadır. Düğme, arasında az bir boşluk bulunan iki tel gibi düşünülebilir. Kullanıcı düğmeye bastığında bu boşluk kapanır ve düğme iletken duruma geçer, üzerinden akım akar. Kullanıcı düğmedan elini çektiğinde devrenin eski konumuna dönmesi için, pull up ve pull down denilen direnç bağlantıları kullanılır. Pull up ve pull down direnç ismi değil, dirençlerin bağlanma şeklidir. Genellikle 10K ohm direnç kullanılır.

Pull Down Direnç: Düğmeye basıldığında gerilim kaynağıyla Arduino'nun girişi kısa devre olur. Elinizi düğmeden çektiğinizde hat üzerinde hâlâ enerji kalır. Bu enerji düğmeye basılmadığı durumunda bile Arduino'nun düğmeye


basılmış gibi davranmasına neden olur. Bu enerjinin yok edilmesi için hat genellikle 10K ohm'luk bir direnç ile toprağa bağlanır. Bu dirence pull down direnç denir.

Pull Up Direnç: Düğmeye basılmadığı durumlarda Arduino'nun giriş pini 5 volt düzeyindedir. Düğmeye basıldığında akım, Arduino'nun giriş pini yerine doğrudan toprağa ulaşmaktadır. Böylece pull-down direnç sistemini tam tersi çalışmaktadır. Arduino düğmeye basıldığında 0, düğmeye basılmadığında 1 değerini görmektedir. Pull-up direnci kullanma amacımız ise, düğmeye basıldığında toprak ve besleme hattının direkt olarak kısa devre olmasını engellemektir. Pull-down dirençte olduğu gibi pull-up dirençlerde genellikle 10K ohm olur.

Düğmelerin Arduino'ya nasıl bağlanacağını öğrendik. Resimde breadboard (Eskiden elektronikçiler buna gofret derlerdi) üzerine düğme ve LED devresi kurulmuştur. Siz de resimdeki devreyi kurabilirsiniz.


1 x Arduino 1 x düğme 1 x 10K ohm direnç 1 x LED 1 x 220 ohm direnç 1 x breadboard (gofret)

Bu devredeki düğmenin amacı LED'i kontrol etmek olacaktır. Kullanıcı düğmeye bastığında LED yanıyorsa sönecek, sönük ise de yanacaktır. Burada bilmemiz gereken bir diğer nokta ARK olaylarıdır. Düğmeye basıldığı anda oluşan atlamalardan dolayı Arduino çok kısa zamanda yüzlerce kere düğmeye basıldığını sanmaktadır. Bu istenmeyen durumdan kurtulmak için basıldığı anda Arduino'yu biraz bekleteceğiz (delay fonksiyonu ile). Böylece devremiz, düğmeye basıldığında oluşan istenmeyen dalgalanmalardan korunmuş olacaktır. Delay fonksiyonuna yazılan bekleme zamanı insanın fark edemeyeceği kadar kısa bir süredir.

Düğmeye her basıldığında yeni bir işlem yapılmasını istiyoruz. Bunu sağlamak için düğmeye basıldığında yapılması gereken işlem yapıldıktan sonra, kişinin düğmeden elini çekmesi beklenmelidir. Eğer bunu yapmazsak kişi, düğmeye bastığında LED'i sürekli yanıp sönecektir. Bu işlem o kadar hızlı olacaktır ki insan gözü bunu algılayamaz.

Düğmenin durumu digitalRead fonksiyonu ile kontrol edilecektir. Okunan düğme değeri 'dugmeDurumu' değişkenine yüklenecektir. Eğer düğmeye basılmışsa LED'in durumunu değiştireceğiz. LED'in düğmeye her basıldığında konumunun değişmesi için, LED durumu bir değişkene atanır ve LED'in eski durumuna göre LED farklı konuma getirilir.

Arduino koduconst int Dugme = 6; /* düğmenin bağlı olduğu pin */const int LED = 5; /* LEDin bağlı olduğu pin */

int dugmeDurumu = 0; /* düğmenin durumu */ int LEDDurumu = 0; /* birinci yöntem için LED durumu */

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

pinMode(Dugme, INPUT); /* düğme pini giriş olarak ayarlandı */}

void loop(){ dugmeDurumu = digitalRead(Dugme); /* düğmenin durumu okundu ve değişkene aktarıldı */ if(dugmeDurumu == HIGH) { /* düğmeye basılmış ise */ delay(10); /* dalgalanmalar için biraz bekleyelim */ if(LEDDurumu == 0){ /* LED yanmıyorsa */ digitalWrite(LED, HIGH); /* LEDi yak */ LEDDurumu = 1; }else { /* LED yanıyorsa */ digitalWrite(LED, LOW); /* LEDi sondur */ LEDDurumu = 0; } while(dugmeDurumu == HIGH){ /* düğmeye basili olduğu surece bekle */ dugmeDurumu = digitalRead(Dugme); /* düğmenin durumunu kontrol et */ } delay(10); /* dalgalanmalar için biraz bekleyelim */ } }


RSS Beslemesi Eğitim İçeriğiSeri Port Üzerinden Haberleşme

o Tıklama Sayacı o SoftwareSerial Kütüphanesiyle Haberleşme

Bluetooth ile İletişim

o Bluetooth Eşleştirmesi o Telefon Kontrollü Işık Projesi

Analog Sinyal Okuma

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-201/analog-sinyal-okuma

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-102/telefon-kontrollu-isik-projesi

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-102/bluetooth-eslestirmesi

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-201/bluetooth-ile-iletisim

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-102/softwareserial-kutuphanesiyle-haberlesme

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-102/tiklama-sayaci

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-201/seri-port-uzerinden-haberlesme

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/201/feed

Arduino ile Renk Okuma

o Yüzey Renklerinin Algılanması o Millis Fonksiyonu Nedir ve Nerelerde Kullanılır?

Arduino ile Gösterge Kullanımı

7 Segmentli Göstergede İki Haneli Sayıların Gösterilmesi Arduino ile LCD Ekran Kullanımı Seri Port Üzerinden Haberleşme Yazar: Geleceği Yazanlar Ekibi Projelerimizde Arduino'ya komut yollamak veya sensörlerdeki değerleri

görüntülemek için seri haberleşmeyi kullanırız. Seri haberleşmeyle bu protokolü destekleyen cihazlarla haberleşebiliriz. Eğitimlerimizde Bluetooth ve USB üzerinden bilgisayara veri aktarmak için seri haberleşme protokolünü kullanacağız.

Arduino'nun 0 ve 1 numaralı yani Rx ve Tx pinleri seri haberleşmeyi sağlamaktadır. Bu pinler aynı zamanda Arduino'nun bilgisayarla haberleşmesini sağlayan USB hattına da bağlıdır. 0 ve 1 numaralı pinler başka bir yere bağlı olduğunda, Arduino bilgisayarla haberleşmesini sağlayamamaktadır. Bu yüzden Arduino'ya kod atarken bu pinlerin bir yere bağlı olmamasına dikkat edilmelidir.

USB üzerinden bilgisayara veri aktaralım Arduino'nun USB kablosu üzerinden bilgisayara veri aktaracağız. Bunun

için öncelikle haberleşme hızını (BaudRate) ayarlamalıyız. Bu ayarın sadece bir kere yapılması yeterli olduğu için, haberleşme hızı setup fonksiyonu içerisinde ayarlanmalıdır. Artık bilgisayara veri aktarmaya hazırız.

Aşağıdaki kodla her saniye bilgisayara "Merhaba Dunya" yazdıralım. Haberleşme için daha önceden bizim için tanımlanmış olan "Serial" nesnesini kullanacağız.

void setup() { Serial.begin(9600); /* haberleşme hızını ayarlayıp

haberleşmeyi başlattık */ } void loop() { Serial.println("Merhaba Dunya"); /* aktarmak istedigimiz

veriyi yazdık */ /* mesajımızı yeni satırda yazmak için Serial.println, aynı satırda yazdırmak için Serial.print kullanmalıyız */ delay(1000); // Bir saniye bekle

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-102/arduino-ile-lcd-ekran-kullanimi

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-102/7-segmentli-gostergede-iki-haneli-sayilarin-gosterilmesi

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-201/arduino-ile-gosterge-kullanimi

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-201/millis-fonksiyonu-nedir-ve-nerelerde-kullanilir

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-102/yuzey-renklerinin-algilanmasi

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-201/arduino-ile-renk-okuma

} Gönderdiğimiz mesajları görmek için Arduino programının sağ üstünde

büyüteç şeklindeki butona (Serial Monitor) basalım. Eğer mesajlarımız doğru bir şekilde görüntülenemiyor ise, Baud Rate hızımız yanlış olabilir. Serial Monitor ekranının sağ altından baud hızımızı 9600 olarak ayarlayalım.

Eğer gönderdiğimiz mesajı bilgisayarda hatasız bir şekilde görebiliyorsak, diğer uygulamamıza geçebiliriz.

Tıklama SayacıYazar: Geleceği Yazanlar Ekibi

Bu uygulamamızda daha önce nasıl kullanacağımızı öğrendiğimiz butonu kullanacağız. Butona her basıldığında ilk başta tanımlayacağımız değişkenin değerini bir arttıracağız. Böylece butona kaç kere basıldığını sayacağız. Aynı zamanda butona basıldığında, butona kaç kere basıldığını bilgisayara da göndereceğiz.


1 x Arduino 1 x Buton 1 x 10K ohm direnç 1 x breadboard

const int buton = 6; /* Butonun bağlı olduğu pin */int sayac = 0; /* butona basılma sayısını tutacak değişken */int butonDurumu = 0; /* Butonun durumu */

void setup() { pinMode(buton, INPUT); Serial.begin(9600);}


void loop() { butonDurumu = digitalRead(buton); if (butonDurumu == HIGH) { delay(10); /* dalgalanmalar için biraz bekleyelim */ sayac ++; /* sayaç = sayaç + 1 yani sayaç değeri bir arttırıldı */ Serial.print("Butona "); Serial.print(sayac); /* sayaç değerimizi ekrana yazdırıyoruz */ Serial.println(". defa basildi."); while(butonDurumu == HIGH){ /* Butona basili olduğu surece bekle */ butonDurumu = digitalRead(buton); /* Butonun durumunu kontrol et */ } delay(10); /* dalgalanmalar için biraz bekleyelim */ }}

Şu ana kadar yaptığımız uygulamalarda Arduino'dan bilgisayara veri yolladık. Şimdi de bilgisayardan Arduino'ya veri yollayalım. Bilgisayardan veri yollamak için Serial Monitor penceresindeki metin kutusunu kullanacağız.

Aşağıda yazdığımız kodlar, bilgisayardan Arduino'ya yolladığımız mesajları okuyacak ve okuduğu mesajları aynı şekilde bilgisayara geri yollayacaktır.

char gelenVeri = 0; /* gelen verinin kaydedileceği değişken */void setup() { Serial.begin(9600); /* haberleşmeyi başlatalım */}void loop() { if (Serial.available() > 0) { /* bilgisayardan veri gelmesini bekliyoruz */ gelenVeri = Serial.read(); /* bilgisayardan gelen karakteri oku */ Serial.print("gelen veri: "); Serial.println(gelenVeri); /* bilgisayardan gelen veriyi bilgisayara geri yolluyoruz */ }}

SoftwareSerial Kütüphanesiyle HaberleşmeYazar: Cansu Uludağ

Bilgisayarla seri haberleşme yaptığımız gibi, diğer elektronik elemanlarla da seri haberleşme yapabiliriz. Bunun için haberleşilecek elemanların Tx ve Rx

uçlarını çapraz bir şekilde Arduino'nun Tx ve Rx pinlerine takmalıyız. Arduino UNO'da sadece bir çift Tx ve Rx (1. ve 0. pinler) bulunur. Bu pinler aynı zamanda USB üzerinden bilgisayarla haberleşmemizi sağlayan pinlerdir. Yani bilgisayarla haberleşme halinde bulunan Arduino'nun 0 ve 1. pinler kullanılamaz.

Arduino MEGA gibi gelişmiş kartlarda birden fazla Tx Rx çifti bulunduğu için bu cihazlar, hem harici olarak başka modüllerle seri haberleşebilirken hem de bilgisayara veri yollayabilir. "SoftwareSerial" kütüphanesi Arduino Uno gibi sadece bir çift Tx Rx pini bulunan kartlar için geliştirilmiştir. Bu kütüphane yardımıyla Arduino'nun diğer pinleri de Tx ve Rx olarak kullanılabilmektedir.Dikkat! "SoftwareSerial" kütüphanesiyle tanımlanacak Rx pinlerinin OnChange kesmesini (interrupt) sağlamaları gerekmektedir.

"SoftwareSerial" kütüphanesi kullanabilmek için öncelikle bu kütüphaneyi projemize eklemeliyiz. Bu kütüphane Arduino IDE'si kurulduğunda otomatik olarak oluşturulmaktadır. Eğer Arduino'nun yüklü olduğu dizindeki "libraries" dosyasında "SoftwareSerial" kütüphanesi bulunmuyor ise, kütüphaneyi internetten indirip bu dizine atabilirsiniz.Hatırlatma: "Libraries" dosyasına yeni kütüphane yüklediğinizde, açık olan Arduino programlarını kapatıp tekrar açmayı unutmayınız.

"#include <SoftwareSerial.h>" komutuyla kütüphaneyi kodumuza ekledikten sonra seçeceğimiz iki pini Rx ve Tx olarak tanımlayabiliriz. Bunun için;

SoftwareSerial seriHaberlesmeNesnesi(10, 11);

Komutu kullanılır. Burada "seriHaberlesmeNesnesi" yerine farklı bir değişken ismi verilebilir. Bu değişken seri haberleşme fonksiyonlarını çağırabilmek için kullanacağımız nesnedir. Nesne kurulumuna yazılan 10 ve 11 numaraları pin sayılarını göstermektedir. Örneğin burada 10. pin Rx olarak, 11. pin ise Tx olarak tanımlanmıştır.Hatırlatma: Rx pininin kullandığınız Arduino türünde onChange Interrupt'ını desteklediğinden emin olunuz. Aksi taktirde bu porttan veri alınamaz.

Rx ve Tx pinleri tanımlandığına göre bu portlar üzerinde işlem yapabiliriz. Öncelikle donanımsal serialda yapıldığı gibi "seriHaberlesmeNesnesi.begin(9600)" komutuyla haberleşme başlatılmalıdır. Bu komutun bir kere kullanılması yeterli olduğu için setup fonksiyonu içerisine yazılması yeterlidir. Normal Serial nesnesinin sahip olduğu diğer fonksiyonlar da bu kütüphaneyle oluşturulacak nesnelerde mevcuttur.

Aşağıdaki kodla 10 ve 11. pinlere seri haberleşmeyi destekleyen cihaz bağlayarak haberleşebilirsiniz.

#include <SoftwareSerial.h>

SoftwareSerial yeniSeriPort(10, 11);/*Arduino -> Diğer Cihaz10(Rx) -> Tx11(Tx) -> Rx*/

void setup() { Serial.begin(9600); /* bilgisayarla haberleşmeyi başlatıyoruz */ yeniSeriPort.begin(9600); /* Yeni oluşturduğumuz haberleşme portunu açıyoruz */ yeniSeriPort.println("Merhaba Dunya"); /* Yeni porta mesaj yolluyoruz */}

void loop(){ while(yeniSeriPort.available()){ /* Yeni porta gelen bir mesaj var mı */ Serial.write(yeniSeriPort.read()); /* Yeni porta gelen mesaj var ise mesaj bilgisayara yollanıyor */ delay(1); } yeniSeriPort.println("selam"); /* Yeni porta "selam" mesajı yollanıyor */ delay(100);}

İlerleyen konularımızda seri haberleşme portu olarak tanımladığımız 10 ve 11. pinlere, Bluetooth gibi seri haberleşme yapabilen cihazlar bağlayacağız.

Birden fazla Software Serial nesnesi

"SoftwareSerial" kütüphanesi kullanılarak birden fazla seri port aynı anda açılabilir. Bunun için her bir port için yeni bir nesne oluşturmalıyız. Bu nesnelere de Rx ve Tx için farklı pinler atamalıyız. Arduino donanımsal haberleşme portları için hafızasında buffer denilen özel alanlar bulunur. Porttan gelen mesajlar otomatik olarak bu alanlara kaydedilir. Software Serial

kütüphanesi yazılımsal haberleşme oluşturduğu için donanımsal haberleşme kadar başarılı olmamaktadır.

Aynı anda iki Software Serial portu dinlenemediği için, portlar arasında geçiş yapmak için listen() fonksiyonu kullanılır. Bu fonksiyon tanımlandığında, tanımlanan nesnenin portu dinlenmeye başlanır. Porta gelen mesajlar otomatik olarak kaydedilir. Dinlenme işlemi bittiğinde listen() fonksiyonu diğer nesneler için kullanılabilir. Böylece tüm Software Serial portları sırayla dinlenir.

Aşağıdaki kodda bilgisayar bağlantısı için donanımsal seri haberleşme portu açılmıştır. Arduino'ya seri haberleşme destekleyen iki farklı cihaz bağlanabilmesi için iki adet yazılımsal seri haberleşme portu açılmıştır. Bu portlara gelen mesajlar sırasıyla dinlenmiş ve gelen mesajlar bilgisayara aktarılmıştır.


SoftwareSerial portbir(10,11);/*Port Bir:Arduino -> Diğer Cihaz10(Rx) -> TX11(Tx) -> RX*/

SoftwareSerial portiki(8,9);/*Port İki:Arduino -> Diğer Cihaz8(Rx) -> TX9(Tx) -> RX*/

void setup(){ Serial.begin(9600); /* Bilgisayar ile haberleşmeyi başlatıyoruz */

portbir.begin(9600); /* birinci yazılımsal haberleşme portu başlatılıyor */ portiki.begin(9600); /* ikinci yazılımsal haberleşme portu başlatılıyor */}

void loop()

{ /* portbir dinleniyor */ portbir.listen(); Serial.println("Birinci porttan gelen mesaj:"); while (portbir.available() > 0) { char karakter = portbir.read(); Serial.write(karakter); }

Serial.println();

/* portiki dinleniyor */ portiki.listen(); Serial.println("ikinci porttan gelen mesaj:"); while (portiki.available() > 0) { char karakter = portiki.read(); Serial.write(karakter); }

Serial.println();}Böylece Arduino'da donanımsal ve yazılımsal olarak seri haberleşme nasıl yapılır öğrenmiş olduk. Bu haberleşme türünü ilerleyen konularda tekrar kullanacağız.

Bluetooth ile İletişimYazar: Geleceği Yazanlar Ekibi

Bluetooth kısa mesafeli haberleşmeler için geliştirilmiş, 2,4 – 2,48 GHz ISM bandını kullanan bir haberleşme protokolüdür. Bluetooth modülleri arasındaki iletişim mesafesi eğer arada bir engel yoksa yaklaşık 20 metredir. Geliştirilen yeni teknolojiler ile bu mesafe yaklaşık 100 metreye kadar arttırılmıştır. Bu yeni geliştirilen Bluetooth modülleri henüz Arduino projelerinde kullanılmamaktadır. Arduino projelerinde genellikle HC-05 veya HC-06 Bluetooth modülleri kullanılır. Biz de projelerimizde bu Bluetooth modüllerini kullanacağız.

HC-05 ve HC-06 Bluetooth modülleri özellik olarak hemen hemen birbirinin aynısıdır. Tek fark, HC-05 hem kendisine gelen bağlantı isteklerine cevap verirken hem de başka Bluetooth cihazlarına bağlantı isteği yollayabilmesidir. HC-06 Bluetooth modülü ise yalnızca kendisine gelen bağlantı isteklerini cevaplayabilir, başka bir Bluetooth modülüne bağlantı isteği yollayamaz. Kısacası HC-05 hem master (yönetici) hem de slave (köle) modunda çalışabilirken, HC-06 sadece slave (köle) modunda çalışabilmektedir.

HC-05 ve HC-06 Bluetooth modüllerinin ortak özellikleri aşağıda verilmiştir.

https://tr.wikipedia.org/wiki/Bluetooth


2,4 GHz haberleşme frekansı (ISM) Hassasiyet: ≤-80 dBm Çıkış gücü: ≤+4 dBm Asenkron hız: 2,1 MBps / 160 KBps Senkron hız: 1 MBps / 1 MBps Çalışma gerilimi: 1,8 - 3,6 V (Önerilen 3,3 V Akım: 50 mA Kimlik doğrulama ve şifreleme

Bluetooth modülü satın alınırken dikkat edilmesi gereken bazı noktalar vardır. Projede Bluetooth modülünün master modunda çalışması isteniyorsa HC-05 tercih edilmelidir. Modülün sadece slave modunda çalışması yeterliyse bu iki modülden birisi seçilebilir. Projede kullanım kolaylığı için breakout'a (kılıf) sahip Bluetooth modülü seçilmesi gerekir. Breakout kablolamada kolaylık sağlamaktadır. Proje mühendisinin işini daha da kolaylaştırmak için Arduino üzerine direkt takılabilen Bluetooth Shield'leri de bulunmaktadır.

Kılıfa (breakout) sahip olan (solda) ve olmayan Bluetooth modülü

Arduino üzerine doğrudan takılabilen Bluetooth ShieldDikkat! Bluetooth modülleri 3,3 Volt ile çalışmaktadır fakat kılıfa (Breakout) sahip Bluetooth modülleri üzerinde genellikle voltaj regülatörü bulunmaktadır. Bu Bluetooth modülleri 3,3 V – 5 V arası gerilimde çalışmaktadır. Bluetooth modülünün üzerinde genellikle çalışma gerilimi yazmaktadır.

Bluetooth modülünün üzerinde VCC, GND, Rx ve Tx olmak üzerine 4 adet pin bulunmaktadır. Bu pinlerden VCC ve GND modülü beslemek için kullanılır. Arduino tarafından yollanan komutlar Bluetooth modülü tarafından alınabilmesi için, Arduino'nun Tx pini Bluetooth modülünün Rx ayağına takılmalıdır. Aynı şekilde Bluetooth'a gelen mesajların Arduino'ya aktarılması için, Arduino'nun Rx pini Bluetooth modülünün Tx pinine takılması gerekmektedir.

Bluetooth modülü her ne kadar 3,3 volt ile beslense bile Rx ve Tx pinlerindeki gerilim Arduino tarafından 5 volt düzeyine çekilebilmektedir. Bazı Bluetooth modülleri için 3,3 volt gerilimin üstü cihaza zarar verebildiği için, bu pinlerin daha önce öğrendiğimiz gibi voltaj bölücü (voltage divider) ile devreye bağlanmalıdır. Bu bağlantı şekli aşağıdaki uygulamada gösterilecektir.

Bluetooth EşleştirmesiYazar: Geleceği Yazanlar Ekibi

Bluetooth modüllerinin bilgisayar veya telefon gibi Bluetooth özelliği bulunan cihazlara bağlanabilmesi için, öncelikle bu cihazların Bluetooth modülüyle eşleştirilmesi gerekmektedir. Akıllı telefonlarda bu işlem normal bir telefon eşleştirir gibi yapılabilmektedir fakat bilgisayar ile eşleşme yapıldığında bilgisayar, Bluetooth modülü için otomatik olarak COM (haberleşme portu)

oluşturmaktadır. Haberleşme için kullanacağımız bilgisayar programları da bu port üzerinden Bluetooth modülüne bağlanacaktır.

Bluetooth modülünün parolası değiştirilmemiş ise fabrika ayarı parola 1234 şeklindedir. Eşleşme sırasında modülün parolası sorulduğunda, bu şifre girilmelidir.Hatırlatma: Bilgisayar ile eşleştirildikten sonra Bluetooth modülünün aldığı port numaraları için 'Aygıt Yöneticisi' kontrol edilmelidir. Aygıt yöneticisinin yeri daha önceki konularımızda anlatılmıştı. Burada iki adet Bluetooth portu görülebilir. Bunlardan büyük olanı projelerde kullanılacak olan haberleşme portudur.

Eşleştirilme işlemleri bittikten sonra, Bluetooth ile akıllı cihazların haberleşmesini sağlayacak ara programlara ihtiyaç duymaktayız. Bu programlar, normal bir seri haberleşme yapan bilgisayar programları olarak düşünülebilir.

Windows kullanıcıları Bluetooth ile haberleşmek için, ücretsiz olarak 'Tera Term' yazılımını indirebilirler. Android kullanıcıları ise haberleşme için 'Bluetooth Terminal' isimli ücretsiz uygulamayı kullanabilirler.Not: Daha önce bilgisayar programı geliştirmiş yazılımcılar, Bluetooth haberleşmesini sağlayacak programı kendileri de yazabilirler. Bu programın temel amacı seri porttan gelen verileri ekranda gösterme ve program kullanıcının mesajlarını seri porta yazmadır.

Eğer eşleştirme işlemini başarıyla tamamlamış ve gerekli yazılımlar indirilmiş ise ilk bağlantımızı kurabiliriz. Bunun için Bluetooth modülünün sadece VCC ve GND pinlerinin takılması yeterlidir. Bu pinler takıldığında Bluetooth modülü üzerinde bulunan ışık yanıp sönmeye başlamaktadır. Bu ışığın hızlı bir şekilde yanıp sönmesi bağlantı isteklerine açık olduğunu göstermektedir.

Akıllı cihazımızdaki program aracılıyla Bluetooth modülüne bağlanmayı deneyiniz. Birkaç saniye bekledikten sonra, eğer cihazımız ile Bluetooth modülü başarılı bir şekilde bağlanmış ise, modül üzerindeki ışık yanıp sönmeyi bırakıp sadece yanacaktır.

Şu anda Rx ve Tx pinlerini takmadığımız için haberleşme yapamayız, fakat Bluetooth modülümüzün düzgün çalıştığını ve akıllı cihazımızın da başarılı bir şekilde eşleştirildiğini görmüş olduk.

Artık Bluetooth projeleri geliştirmeye hazırsınız.

Telefon Kontrollü Işık ProjesiYazar: Geleceği Yazanlar Ekibi


Bu uygulamada Bluetooth modülü yardımıyla Arduino'ya bağlı LED'leri akıllı telefon üzerinden kontrol edeceğiz. Projede yazılan Arduino kodu biraz değiştirilerek akıllı ev projeleri yapılabilir. Kurulan devre sadece akıllı telefonlar ile değil, Bluetooth bağlantısına sahip tüm cihazlar üzerinden kontrol edilebilir. Projede telefon kontrolünün seçilmesinin nedeni projenin taşınabilirliğini sağlamaktır.

Projede Bluetooth modülü slave (köle) modunda çalışacağından, HC-05 veya HC-06 modülleri kullanılabilir. Bluetooth modülünün haberleşme pinleri (Rx ve Tx) voltaj bölücü yardımıyla Arduino'ya bağlanmıştır. Bunun nedeni daha önce de öğrendiğimiz gibi, 3,3 volt üzerindeki gerilimlerin Bluetooth modülüne zarar verebilmesindendir.

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

1 x Breadboard 1 x Arduino 1 x Bluetooth modülü (HC-05 veya HC-06) 7 x Direnç (3 adet 220 ohm, 2 adet 1K ohm, 2 adet 2,2K ohm) 3 x LED Bluetooth bağlantısına sahip akıllı cihaz

Proje için aşağıdaki devreyi kurunuz:

Yukarıdaki resimde direnç değerleri belli olmadığı için aşağıda Bluetooth modülü ve Arduino arasına kurulacak voltaj bölücü devresi gösterilmiştir.

Not: Eğer belirtilen direçler elinizde yok ise, elektroniğe giriş konusunda öğrenmiş olduğumuz voltaj bölücü hesaplama yöntemi ile farklı direnç değerleri kullanabilirsiniz.

Arduino UNO'nun sadece bir tane haberleşme portu bulunduğu için Bluetooth modülü Arduino'nun 10 ve 11. pinlerine bağlanmıştır. Bu pinlerin seri port olarak kullanılabilmesi için 'Software Serial' kütüphanesi kullanılmıştır. Bu kütüphanenin kullanımını daha önceki konularda öğrenmiştik.Not: Bluetooth modülleri Arduino'nun donanımsal seri portuna da bağlanabilirdi. Fakat o zaman 'Serial Mönitör' üzerinden bilgisayara veri gönderilemezdi ve her programlama yapılacağı zaman bu pinlerin çıkarılması gerekirdi.

Kontrol edeceğimiz pinleri ve diğer devre bağlantılarını da yaptıktan sonra Arduino programını yazmaya başlayabiliriz. Arduino programı Bluetooth modülü için açılmış sanal seri portları dinlemektedir. Eğer burada yeni bir veri var ise bu veriyi okuyarak işleme almaktadır. Gelen verinin değerine göre LED ışıkları kontrol edilmektedir. Unutulmamalıdır ki, Bluetooth modülü üzerinden gelecek veriler karakter formatındadır. Ayrıca her 'read' fonksiyonu kullanıldığında Arduino tarafından bir karakter okunmaktadır.


SoftwareSerial bluetoothModulu(10, 11); /* Arduino -> Bluetooth modulu 10 (Rx) -> Tx 11 (Tx) -> Rx*/

const int LED1 = 2;const int LED2 = 3;const int LED3 = 4;

void setup(){ bluetoothModulu.begin(9600); /* Bluetooth haberleşmesi */

pinMode(LED1, OUTPUT); pinMode(LED2, OUTPUT); pinMode(LED3, OUTPUT);}

char okunanKarakter; /* okunan verilerin kaydedileceği değişken */void loop(){ while(bluetoothModulu.available()>0){ /* Yeni veri var mı */ okunanKarakter = bluetoothModulu.read(); /* Yeni veriyi okunanKarakter degiskenine kaydet */ switch(okunanKarakter){ /* Okunan karaktere göre işlem yap */ case 'a': /* gelen karakterin işlem karşılığı */ digitalWrite(LED1, HIGH); bluetoothModulu.println("LED 1 yakildi"); break; case 'b': digitalWrite(LED1, LOW); bluetoothModulu.println("LED 1 sonduruldu"); break; case 'c': digitalWrite(LED2, HIGH); bluetoothModulu.println("LED 2 yakildi"); break; case 'd': digitalWrite(LED2, LOW); bluetoothModulu.println("LED 2 sonduruldu"); break; case 'e': digitalWrite(LED3, HIGH); bluetoothModulu.println("LED 3 yakildi"); break; case 'f': digitalWrite(LED3, LOW); bluetoothModulu.println("LED 3 sonduruldu"); break; } /* Switch sonu */ }/* While sonu*/}/* Loop sonu */

Bu bölümde Bluetooth modülünün Arduino ile nasıl kullanıldığını öğrendik. Artık Arduino projelerimizi Bluetooth özelliği bulunan cihazlar ile kontrol edebiliriz. Bluetooth kullanımının pekişmesi için sizde yukarıdaki kod üzerinde değişiklikler yaparak kendi projenizi gerçekleştirebilirsiniz.

İlerleyen bölümlerimizde DC motor kontrolünü öğrendikten sonra, Bluetooth ile kontrol edilen araba yapacağız.

Bluetooth ile İletişimYazar: Geleceği Yazanlar Ekibi

Bluetooth kısa mesafeli haberleşmeler için geliştirilmiş, 2,4 – 2,48 GHz ISM bandını kullanan bir haberleşme protokolüdür. Bluetooth modülleri arasındaki iletişim mesafesi eğer arada bir engel yoksa yaklaşık 20 metredir. Geliştirilen yeni teknolojiler ile bu mesafe yaklaşık 100 metreye kadar arttırılmıştır. Bu yeni geliştirilen Bluetooth modülleri henüz Arduino projelerinde kullanılmamaktadır. Arduino projelerinde genellikle HC-05 veya HC-06 Bluetooth modülleri kullanılır. Biz de projelerimizde bu Bluetooth modüllerini kullanacağız.

HC-05 ve HC-06 Bluetooth modülleri özellik olarak hemen hemen birbirinin aynısıdır. Tek fark, HC-05 hem kendisine gelen bağlantı isteklerine cevap verirken hem de başka Bluetooth cihazlarına bağlantı isteği yollayabilmesidir. HC-06 Bluetooth modülü ise yalnızca kendisine gelen bağlantı isteklerini cevaplayabilir, başka bir Bluetooth modülüne bağlantı isteği yollayamaz. Kısacası HC-05 hem master (yönetici) hem de slave (köle) modunda çalışabilirken, HC-06 sadece slave (köle) modunda çalışabilmektedir.

HC-05 ve HC-06 Bluetooth modüllerinin ortak özellikleri aşağıda verilmiştir.

2,4 GHz haberleşme frekansı (ISM) Hassasiyet: ≤-80 dBm Çıkış gücü: ≤+4 dBm Asenkron hız: 2,1 MBps / 160 KBps Senkron hız: 1 MBps / 1 MBps Çalışma gerilimi: 1,8 - 3,6 V (Önerilen 3,3 V Akım: 50 mA Kimlik doğrulama ve şifreleme

Bluetooth modülü satın alınırken dikkat edilmesi gereken bazı noktalar vardır. Projede Bluetooth modülünün master modunda çalışması isteniyorsa HC-05 tercih edilmelidir. Modülün sadece slave modunda çalışması yeterliyse bu iki modülden birisi seçilebilir. Projede kullanım kolaylığı için breakout'a (kılıf) sahip Bluetooth modülü seçilmesi gerekir. Breakout kablolamada kolaylık sağlamaktadır. Proje mühendisinin işini daha da kolaylaştırmak için Arduino üzerine direkt takılabilen Bluetooth Shield'leri de bulunmaktadır.

https://tr.wikipedia.org/wiki/Bluetooth


Kılıfa (breakout) sahip olan (solda) ve olmayan Bluetooth modülü

Arduino üzerine doğrudan takılabilen Bluetooth ShieldDikkat! Bluetooth modülleri 3,3 Volt ile çalışmaktadır fakat kılıfa (Breakout) sahip Bluetooth modülleri üzerinde genellikle voltaj regülatörü bulunmaktadır. Bu Bluetooth modülleri 3,3 V – 5 V arası gerilimde çalışmaktadır. Bluetooth modülünün üzerinde genellikle çalışma gerilimi yazmaktadır.

Bluetooth modülünün üzerinde VCC, GND, Rx ve Tx olmak üzerine 4 adet pin bulunmaktadır. Bu pinlerden VCC ve GND modülü beslemek için kullanılır. Arduino tarafından yollanan komutlar Bluetooth modülü tarafından alınabilmesi için, Arduino'nun Tx pini Bluetooth modülünün Rx ayağına takılmalıdır. Aynı şekilde Bluetooth'a gelen mesajların Arduino'ya aktarılması için, Arduino'nun Rx pini Bluetooth modülünün Tx pinine takılması gerekmektedir.

Bluetooth modülü her ne kadar 3,3 volt ile beslense bile Rx ve Tx pinlerindeki gerilim Arduino tarafından 5 volt düzeyine çekilebilmektedir. Bazı Bluetooth

modülleri için 3,3 volt gerilimin üstü cihaza zarar verebildiği için, bu pinlerin daha önce öğrendiğimiz gibi voltaj bölücü (voltage divider) ile devreye bağlanmalıdır. Bu bağlantı şekli aşağıdaki uygulamada gösterilecektir.

Bluetooth EşleştirmesiYazar: Geleceği Yazanlar Ekibi

Bluetooth modüllerinin bilgisayar veya telefon gibi Bluetooth özelliği bulunan cihazlara bağlanabilmesi için, öncelikle bu cihazların Bluetooth modülüyle eşleştirilmesi gerekmektedir. Akıllı telefonlarda bu işlem normal bir telefon eşleştirir gibi yapılabilmektedir fakat bilgisayar ile eşleşme yapıldığında bilgisayar, Bluetooth modülü için otomatik olarak COM (haberleşme portu) oluşturmaktadır. Haberleşme için kullanacağımız bilgisayar programları da bu port üzerinden Bluetooth modülüne bağlanacaktır.

Bluetooth modülünün parolası değiştirilmemiş ise fabrika ayarı parola 1234 şeklindedir. Eşleşme sırasında modülün parolası sorulduğunda, bu şifre girilmelidir.Hatırlatma: Bilgisayar ile eşleştirildikten sonra Bluetooth modülünün aldığı port numaraları için 'Aygıt Yöneticisi' kontrol edilmelidir. Aygıt yöneticisinin yeri daha önceki konularımızda anlatılmıştı. Burada iki adet Bluetooth portu görülebilir. Bunlardan büyük olanı projelerde kullanılacak olan haberleşme portudur.

Eşleştirilme işlemleri bittikten sonra, Bluetooth ile akıllı cihazların haberleşmesini sağlayacak ara programlara ihtiyaç duymaktayız. Bu programlar, normal bir seri haberleşme yapan bilgisayar programları olarak düşünülebilir.

Windows kullanıcıları Bluetooth ile haberleşmek için, ücretsiz olarak 'Tera Term' yazılımını indirebilirler. Android kullanıcıları ise haberleşme için 'Bluetooth Terminal' isimli ücretsiz uygulamayı kullanabilirler.Not: Daha önce bilgisayar programı geliştirmiş yazılımcılar, Bluetooth haberleşmesini sağlayacak programı kendileri de yazabilirler. Bu programın temel amacı seri porttan gelen verileri ekranda gösterme ve program kullanıcının mesajlarını seri porta yazmadır.

Eğer eşleştirme işlemini başarıyla tamamlamış ve gerekli yazılımlar indirilmiş ise ilk bağlantımızı kurabiliriz. Bunun için Bluetooth modülünün sadece VCC ve GND pinlerinin takılması yeterlidir. Bu pinler takıldığında Bluetooth modülü üzerinde bulunan ışık yanıp sönmeye başlamaktadır. Bu ışığın hızlı bir şekilde yanıp sönmesi bağlantı isteklerine açık olduğunu göstermektedir.

Akıllı cihazımızdaki program aracılıyla Bluetooth modülüne bağlanmayı deneyiniz. Birkaç saniye bekledikten sonra, eğer cihazımız ile Bluetooth modülü başarılı bir şekilde bağlanmış ise, modül üzerindeki ışık yanıp sönmeyi bırakıp sadece yanacaktır.

Şu anda Rx ve Tx pinlerini takmadığımız için haberleşme yapamayız, fakat Bluetooth modülümüzün düzgün çalıştığını ve akıllı cihazımızın da başarılı bir şekilde eşleştirildiğini görmüş olduk.

Artık Bluetooth projeleri geliştirmeye hazırsınız.

Telefon Kontrollü Işık ProjesiYazar: Geleceği Yazanlar Ekibi

Bu uygulamada Bluetooth modülü yardımıyla Arduino'ya bağlı LED'leri akıllı telefon üzerinden kontrol edeceğiz. Projede yazılan Arduino kodu biraz değiştirilerek akıllı ev projeleri yapılabilir. Kurulan devre sadece akıllı telefonlar ile değil, Bluetooth bağlantısına sahip tüm cihazlar üzerinden kontrol edilebilir. Projede telefon kontrolünün seçilmesinin nedeni projenin taşınabilirliğini sağlamaktır.

Projede Bluetooth modülü slave (köle) modunda çalışacağından, HC-05 veya HC-06 modülleri kullanılabilir. Bluetooth modülünün haberleşme pinleri (Rx ve Tx) voltaj bölücü yardımıyla Arduino'ya bağlanmıştır. Bunun nedeni daha önce de öğrendiğimiz gibi, 3,3 volt üzerindeki gerilimlerin Bluetooth modülüne zarar verebilmesindendir.


1 x Breadboard 1 x Arduino 1 x Bluetooth modülü (HC-05 veya HC-06) 7 x Direnç (3 adet 220 ohm, 2 adet 1K ohm, 2 adet 2,2K ohm) 3 x LED Bluetooth bağlantısına sahip akıllı cihaz


Proje için aşağıdaki devreyi kurunuz:

Yukarıdaki resimde direnç değerleri belli olmadığı için aşağıda Bluetooth modülü ve Arduino arasına kurulacak voltaj bölücü devresi gösterilmiştir.

Not: Eğer belirtilen direçler elinizde yok ise, elektroniğe giriş konusunda öğrenmiş olduğumuz voltaj bölücü hesaplama yöntemi ile farklı direnç değerleri kullanabilirsiniz.

Arduino UNO'nun sadece bir tane haberleşme portu bulunduğu için Bluetooth modülü Arduino'nun 10 ve 11. pinlerine bağlanmıştır. Bu pinlerin seri port olarak kullanılabilmesi için 'Software Serial' kütüphanesi kullanılmıştır. Bu kütüphanenin kullanımını daha önceki konularda öğrenmiştik.Not: Bluetooth modülleri Arduino'nun donanımsal seri portuna da bağlanabilirdi. Fakat o zaman 'Serial Mönitör' üzerinden bilgisayara veri gönderilemezdi ve her programlama yapılacağı zaman bu pinlerin çıkarılması gerekirdi.

Kontrol edeceğimiz pinleri ve diğer devre bağlantılarını da yaptıktan sonra Arduino programını yazmaya başlayabiliriz. Arduino programı Bluetooth modülü için açılmış sanal seri portları dinlemektedir. Eğer burada yeni bir veri var ise bu veriyi okuyarak işleme almaktadır. Gelen verinin değerine göre LED ışıkları kontrol edilmektedir. Unutulmamalıdır ki, Bluetooth modülü üzerinden gelecek veriler karakter formatındadır. Ayrıca her 'read' fonksiyonu kullanıldığında Arduino tarafından bir karakter okunmaktadır.


SoftwareSerial bluetoothModulu(10, 11); /* Arduino -> Bluetooth modulu 10 (Rx) -> Tx 11 (Tx) -> Rx*/

const int LED1 = 2;const int LED2 = 3;const int LED3 = 4;

void setup(){ bluetoothModulu.begin(9600); /* Bluetooth haberleşmesi */ pinMode(LED1, OUTPUT); pinMode(LED2, OUTPUT); pinMode(LED3, OUTPUT);}

char okunanKarakter; /* okunan verilerin kaydedileceği değişken */void loop(){ while(bluetoothModulu.available()>0){ /* Yeni veri var mı */ okunanKarakter = bluetoothModulu.read(); /* Yeni veriyi okunanKarakter degiskenine kaydet */ switch(okunanKarakter){ /* Okunan karaktere göre işlem yap */ case 'a': /* gelen karakterin işlem karşılığı */ digitalWrite(LED1, HIGH); bluetoothModulu.println("LED 1 yakildi"); break; case 'b': digitalWrite(LED1, LOW); bluetoothModulu.println("LED 1 sonduruldu"); break; case 'c': digitalWrite(LED2, HIGH); bluetoothModulu.println("LED 2 yakildi");

break; case 'd': digitalWrite(LED2, LOW); bluetoothModulu.println("LED 2 sonduruldu"); break; case 'e': digitalWrite(LED3, HIGH); bluetoothModulu.println("LED 3 yakildi"); break; case 'f': digitalWrite(LED3, LOW); bluetoothModulu.println("LED 3 sonduruldu"); break; } /* Switch sonu */ }/* While sonu*/}/* Loop sonu */

Bu bölümde Bluetooth modülünün Arduino ile nasıl kullanıldığını öğrendik. Artık Arduino projelerimizi Bluetooth özelliği bulunan cihazlar ile kontrol edebiliriz. Bluetooth kullanımının pekişmesi için sizde yukarıdaki kod üzerinde değişiklikler yaparak kendi projenizi gerçekleştirebilirsiniz.

İlerleyen bölümlerimizde DC motor kontrolünü öğrendikten sonra, Bluetooth ile kontrol edilen araba yapacağız.Analog Sinyal OkumaYazar: Geleceği Yazanlar Ekibi

Yaşadığımız ortamda her etki analog bir sinyale karşılık gelir. Bu etkileri ölçen sensörler de genellikle analog çıkış verir fakat Arduino analog sinyalleri işleyememektedir. Bu yüzden analog sinyallere karşılık gelen dijital değerlerin bulunması gerekir. Bu işleme ADC (Analog Digital Converter) denir. Çok fazla detaya girmeden analog sinyalin dijitale çevrilmesini şu şekilde özetlenebilir:

Resimdeki gibi 0 ve 5 volt arasında değişen analog bir sinyalimiz olsun. Bu sinyalin dijital sinyale çevrilmesi için Arduino'da 10 bitlik bir saklayıcı bulunmaktadır. Bu saklayıcı 0 volt giriş için 0, 5 volt giriş için ise 1023 değerini almaktadır. Bu artış doğrusaldır yani girişteki 0,005 voltluk bir değişim saklayıcının değerini bir artırmaktadır. Örneğin sinyal girişimiz 3,3 volt ise okuyacağımız değer yaklaşık olarak 675'tir.

Kısacası ADC, 0 ve 5 volt arasındaki sinyali oranlayarak 0 ve 1023 arasında sayısal bir değer döndürmektedir.


Arduino'nun bu dönüşümü yapabilmesi için özelleşmiş analog okuyucu pinleri bulunmaktadır. Analog okuyucu pinlerin sayısı Arduino'nun türüne göre değişmektedir. Bu pinlerin numaraları A0, A1, A2... şeklindedir.Hatırlatma: Analog pinler de diğer dijital pinler gibi en fazla 5 volt gerilime dayanabilmektedir. Bu pine 5 voltun üzerinde bir gerilim uygulanırsa, Arduino bozulabilir. Kısacası Arduino'nun ölçebileceği en yüksek gerilim 5 volttur.

Arduino'nun A0 girişindeki gerilimi ADC yardımıyla ölçelim. Ölçülen değeri bir değişkene kaydedelim. Daha sonra da bu değeri seri haberleşme yardımıyla bilgisayara aktaralım. Eğer A0 pini boşta bırakılırsa, gürültü nedeniyle bu pinden sürekli değişen bir ADC değeri okunur. Daha doğru değerler okumak için A0 girişine potansiyometre bağlayalım. Potansiyometre bağlantısı için aşağıdaki devreyi inceleyebilirsiniz. Potansiyometreyi çevrildiğinde değişen gerilimi bilgisayardan görüntüleyebilirsiniz.


1 x Arduino 1 x Potansiyometre 1 x Breadboard

void setup() { Serial.begin(9600);}void loop() { int sensorDegeri = analogRead(A0); /* Arduinonun A0 ayagindaki gerilim olculuyor */ Serial.println(sensorDegeri); /* olculen deger seri haberlesme ile yollaniyor */ delay(10); /* daha dogru bir olcum icin biraz bekleme kullanilmalidir */}

Uygulama: Arduino ile voltmetre yapımı

Potansiyometrenin çıkışındaki analog değeri ADC kullanarak ölçmeyi öğrendik. Ölçtüğümüz bu değer 0 ile 1023 arasındaydı. Yapacağımız voltmetre uygulaması ile bu değeri daha anlamlı bir şekle getireceğiz. Bunun için öncelikle adım aralığını bulmamız gerekir. 5 volt 1023'e karşılık geldiği için adım aralığımız 5/1023 olmaktadır. Eğer bu kesir ADC ölçümü ile çarpılırsa ölçülen değerin gerilim karşılığı bulunur. Bulduğumuz bu sonucu ekrana yazdıralım. Devrede farklı gerilimleri gözlemleyebilmek için potansiyometre kullanılmıştır. Devre şeması "Analog Sinyal Okuma" konusunda verilmişti.

void setup() { Serial.begin(9600);}void loop() { int sensorDegeri = analogRead(A0); /* A0’daki gerilimin sayısal değeri */ float gerilim = ((float)5/1023)*sensorDegeri; /* 5 volt 1023 ile ölçülüyordu. Bu yüzden adim aralığını bulmak için 5/1023 kesrini bulduk.

Bu kesir okunan ADC değeri ile çarpılmıştır. Böylece gerilim değeri bulunmuştur. */ Serial.print(gerilim);/* bulunan gerilim değeri bilgisayara aktarıldı. */ Serial.println(" Volt"); delay(100); }Dikkat! Asla 5 volt üzerindeki değerleri ölçmeye çalışmayın. Böyle bir hatayı engellemek için devrenize 5 volt değerinde bir Zenner Diyotu ters bağlamanız yararlı olabilir.

Uygulama: LM35 ile sıcaklık ölçümü

Bu uygulamada LM35 sıcaklık sensörü yardımıyla ortamın sıcaklığını ölçeceğiz. LM35 sensörünün besleme (5 V), toprak ve çıkış olmak üzere üç adet pini bulunmaktadır. Çıkış pinindeki değer ortamın sıcaklığına göre doğrusal olarak değişmektedir.

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

1 x Arduino 1 x LM35 (Sıcaklık Sensörü) 1 x Breadboard

Kablo bağlantılarınızı şekildeki gibi yapınız. Sensörün resimde görüldüğü gibi yazılı kısmı size bakacak şekilde tuttuğunuzda 1. pin 5 volt besleme, 2. pin çıkış pini ve 3. pin toprak pinidir. Devreyi resimdeki gibi kurduktan sonra yazılıma geçelim.

Arduino'nun A0 pininden LM35'in çıkışındaki gerilimi ölçeceğiz. Bu gerilimin sayısal değerini LM35'in datasheet'inden aldığımız formül ile sıcaklığa çevireceğiz. Daha sonra da elde ettiğimiz sonuçları USB üzerinden bilgisayara aktaracağız.

float sicaklik;

void setup(){ Serial.begin(9600); /* Haberleşme başlatıldı */}

void loop(){ sicaklik = analogRead(A0); /* A0daki gerilim ölçüldü */ sicaklik = sicaklik * 0.48828125;/* Ölçülen gerilim sıcaklığa çevrildi */ Serial.print("SICAKLIK = "); Serial.print(sicaklik); Serial.println(" C"); delay(500);}

Bu bölümde öğrenilen bilgileri özetlemek gerekirse; analog sinyaller devamlı sinyallerdir ve sonsuz çözünürlükte değerler alabilir, bu yüzden Arduino analog sinyalleri direkt olarak işleyemez. Arduino'nun bu sinyalleri kullanabileceği duruma getirme işlemine Analog Dijital Çevrim (ADC) denir. Arduino üzerinde ADC işlemi için özelleşmiş pinler bulunur. Bu pinler ile alınan analog sinyal, 10 bitlik sayısal değere çevrilerek kullanılır.Arduino ile Renk OkumaYazar: Geleceği Yazanlar Ekibi

Fiziksel dünyada bulunan renkleri okumak için geliştirilmiş ve Arduino ile çalışabilen sensörler bulunmaktadır. Bu sensörlerden birisi CNY70'tir. Bu sensör 2-3 cm uzaktaki siyah ve beyaz renkleri ayırt etmek için kullanılır. Bu sensör genellikle çizgi takibi yapan robotlarda kullanılır. Siyah ve beyaz dışındaki renklerin algılanması için geliştirilmiş sensörler bulunmaktadır. TCS3200 bu sensörlere örnek olarak verilebilir.

Renk algılayan sensörler birçok projede kullanılabilir. Örnek olarak robot yarışmalarında farklı renkteki çöplerin ayrı ayrı toplanması için bu sensör kullanılmaktadır. Bu bölümde bu iki farklı sensörün nasıl kullanıldığını öğreneceğiz.

Arduino ile siyah ve beyaz rengi ayırma

Robot yarışmaları denildiğinde akla ilk gelen kategori çizgi izleyen robotlardır. Bu robotların yapıtaşını oluşturan kısım, siyah beyaz sensörüdür. Çizgi izleyen robotlar siyah ve beyaz zeminler üzerinde hareket etmektedir. Siyah ve beyaz renkleri ayırmak için uygulamalarda, CNY70 isimli sensör kullanılacaktır. Bu sensörü elektronik malzeme satan mağazalarda kolaylıkla bulabilirsiniz. Analog olarak çalışan çoğu siyah beyaz sensörü de CNY70 ile aynı mantıkta çalışmaktadır.

CNY70 üzerinde iki adet LED bulunmaktadır. Bu LED'lerden birisi kızılötesi ışık yayar. Yüzeye çarpan kızılötesi ışık, sensör üzerinde bulunan diğer LED'de toplanır. Toplanan kızılötesi ışığın şiddeti sensör tarafından ölçülür. Siyah ve beyaz renklerin kızılötesi ışığı yansıtma katsayıları farklı olduğu için, sensörden okunan farklı ışık şiddetleri Arduino tarafından siyah ve beyaz renk olarak algılanır. Sensör topladığı kızılötesi ışığın şiddetine göre analog bir çıkış verir. Bu yüzden CNY70 sensörü Arduino'nun analog girişlerine bağlanır.Hatırlatma: Arduino, ADC yardımıyla analog sinyalleri dijital veriye çevirir.

CNY70 sensörünün bağlantıları aşağıdaki resimde gösterilmiştir. Devreyi breadboard üzerine kurmak için sensörü baklava dilimi şeklinde kullanmak bağlantı açısından kolaylık sağlamaktadır. Kızılötesi ışık yayan LED'in bağlantısına 220 ohm'luk bir direnç bağlanmıştır. Kızılötesi ışığı toplayan LED'e de 10K ohm değerinde pull-down direnç bağlanmıştır.Not: Devre bağlantılarının doğru yapılıp yapılmadığını test etmek için, Android işletim sistemine sahip telefon kameraları kullanılabilir. Eğer sensör çalışıyorsa telefon kamerasında kızılötesi ışığı görebilirsiniz.

Aşağıdaki kodla öncelikle sensörden alınan analog sinyal dijital değere çevrilmiştir. Elde edilen dijital değer eşik gerilimiyle karşılaştırılmıştır. Eşik gerilimin üstüne siyah, altına beyaz renk denmiştir. Bu eşik değeri sensöre ve ortama göre değişmektedir. Seri Monitör'den okuduğunuz sensör değerlerine

göre, siz de programınız için siyah ve beyaz ayrımı yapabilen bir eşik değeri bulabilirsiniz. Bulduğunuz eşik değerini kodda güncelleyerek Arduino ile siyah ve beyaz yüzeyleri ayırt edebilirsiniz.

int referansDegeri = 800; /* siyah ve beyaz yuzeyin ayrimini yapan deger *//* referansDegeri sensorden okunan degerlere gore yeniden belirlenmelidir.Cunku bu deger ortama ve sensore gore degismektedir.referansDegerini belirlemek icin siyah yuzeyde okunan deger ile beyaz yuzeyde okunan degerin ortalamasi alinabilir*/void setup(){ Serial.begin(9600); /* veri yollamak icin seri haberlesmeyi 9600 baud rate hizinda baslattik */}

void loop(){ int sensorDegeri = analogRead(A0); /* Sensorden gelen analog deger dijitale cevriliyor */ Serial.print("sensorden okunan deger= "); Serial.print(sensorDegeri); /* Sensorden okunan deger ekrana yazdiriliyor. Bu degere gore referansDegeri ayarlanabilir */ Serial.print("\t renk= "); if(sensorDegeri > referansDegeri){ /* Sensorden okunan deger referansDegerinden buyuk ise renk siyahtir */ Serial.println("siyah"); }else{ /* Sensorden okunan deger referansDegerinden kucuk ise renk beyazdir */ Serial.println("beyaz"); } delay(1000); }

Arduino ile tüm renklerin algılanması

TCS3200 tüm renkleri algılayabilen ve Arduino ile kolayca çalıştırılabilen bir renk sensörüdür. Piyasada TCS3200 benzeri sensörler bulunmaktadır. Bu sensörlerle TC3200 hemen hemen aynı görevi görmektedir. Aynı kodla benzer sensörleri kullanabilirsiniz.

TCS3200 sensörü renklerin ayırt edilmesi için kullanılan bir sensördür. Sensör 3 ana rengi okumasının yanı sıra 3 ana renk oranlarını da belirleyerek bu renklerin okunmasını sağlamaktadır. Bunun için üzerinde kırmızı, yeşil, mavi ve beyaz ışık bulunmaktadır. Arduino komutlarıyla bu 4 LED farklı zamanlarda belirli bir sırayla yanması sağlanır.

Yüzeye gönderilen ışığın yansıması, yüzeyin rengine bağlı olarak değişmektedir. Sensör tarafından bir yüzeye 4 farklı renkte ışık yollanmaktadır. Bu ışıkların yansımaları sensörün ortasında bulunan alıcı tarafından ölçülmektedir. Bu ölçüm sonucunda yüzeyin rengi, ölçüm oranlarına bağlı olarak algılanmaktadır.

Sensörün çalışma teorisini öğrendiğimize göre şimdi nasıl kullanıldığına bakalım. Sensör üzerinde bulunan S0 ve S1 pinleri LED'lerin çalışma frekansını belirlemektedir. S2 ve S3 pinleri ise sensör üzerindeki LED'lerden hangilerinin etkinleştirileceğini seçmektedir. Aşağıdaki tabloda bu pinlerin kullanımı gösterilmiştir.

S0 S1 Frekans

0 0 -

0 1 1:50

1 0 1:5

1 1 1:1

S2 S3 Renk

0 0 Kırmızı

0 1 Mavi

1 0 Beyaz

1 1 Yeşil

Sensör üzerinde bulunan diğer pinlerden OUT pini ölçüm değerlerinin Arduino'ya aktarıldığı hattır. LED pini ise LED'lerin yanması veya sönmesi için kullanılan pindir. Sensörün VCC pini 5 volta, GND pini toprağa takılmalıdır.

Yüzey Renklerinin AlgılanmasıYazar: Cansu Uludağ

Sensörün nasıl çalıştığını ve kullanıldığını öğrendiğimize göre küçük bir uygulamayla bu bilgilerimizi pekiştirelim. Uygulamada sensör tutulduğu yüzeyin rengini algılayarak seri port üzerinden bilgisayara aktarmaktadır. Bunun için öncelikle aşağıdaki devreyi kurunuz.

/* Sensör pinleri tanımlanıyor */int S0 = 8;int S1 = 9;int S2 = 12;int S3 = 11;

int OUT = 10;int LED = 13;

/* Renk yüzdeleri tanımlanıyorBu sayılar ortama göre değişiklik gösterebilirBu yüzden sensörü kalibre etmek için sensörden okuduğunuz değerler ile bu sayıları güncelleyinizDizi elemanları sırasıyla sensörden ölçülen Kırmızı,Mavi ve Yeşil frekanslarını göstermektedir*/int RenkYuzdesi[5][3] = { {38,31,37}, // Sarı renk {13,65,26}, // Mavi renk {29,36,29}, // Beyaz renk {64,31,22}, // Kırmızı renk {23,34,45} }; // Yeşil renk String Renkler[5] = {"Sari", "Mavi", "Beyaz", "Kirmizi", "Yesil"};

/* Sensör hassasiyeti */int aralik = 7;

/* Renk frekanslarının tutulduğu değişkenler */int KirmiziYuzdesi, YesilYuzdesi, MaviYuzdesi;

void setup() { Serial.begin(9600); pinMode(S0,OUTPUT); pinMode(S1,OUTPUT); pinMode(S2,OUTPUT); pinMode(S3,OUTPUT); pinMode(LED,OUTPUT); pinMode(OUT,INPUT); }

void loop() { RengiTanimla(); delay(1000);}

void TCS3200_Ac() { digitalWrite(LED,HIGH); // switch LED on digitalWrite(S0,HIGH); // output frequency scaling (100%) digitalWrite(S1,HIGH); delay(5);}

void TCS3200_Kapat() {

digitalWrite(LED,LOW); // switch LED off digitalWrite(S0,LOW); // power off sensor digitalWrite(S1,LOW);}

void Filtresiz() { digitalWrite(S2,HIGH); // select no filter digitalWrite(S3,LOW); delay(5);}

void KirmiziFiltre() { digitalWrite(S2,LOW); // select red filter digitalWrite(S3,LOW); delay(5);}

void YesilFiltre() { digitalWrite(S2,HIGH); // select green filter digitalWrite(S3,HIGH); delay(5);}

void MaviFiltre() { digitalWrite(S2,LOW); // select blue filter digitalWrite(S3,HIGH); delay(5);}

void RengiTanimla() { float BeyazFrekansi, KirmiziFrekansi, YesilFrekansi, MaviFrekansi; TCS3200_Ac(); Filtresiz(); BeyazFrekansi = float(pulseIn(OUT,LOW,40000)); KirmiziFiltre(); KirmiziFrekansi = float(pulseIn(OUT,LOW,40000)); YesilFiltre(); YesilFrekansi = float(pulseIn(OUT,LOW,40000)); MaviFiltre(); MaviFrekansi = float(pulseIn(OUT,LOW,40000)); TCS3200_Kapat(); KirmiziYuzdesi = int((BeyazFrekansi / KirmiziFrekansi) * 100.0); YesilYuzdesi = int((BeyazFrekansi / YesilFrekansi) * 100.0); MaviYuzdesi = int((BeyazFrekansi / MaviFrekansi) * 100.0); RengiBul();

}

void RengiBul() { Serial.println("Renk Yuzdeleri"); Serial.print("Kirmizi="); Serial.print(KirmiziYuzdesi); Serial.print("Mavi="); Serial.print(MaviYuzdesi); Serial.print("Yesil="); Serial.println(YesilYuzdesi); Serial.println(); Serial.print("Okunan Renk="); int okunduMu=0; for(int renk =0; renk < 5; renk ++){ if(KirmiziYuzdesi > RenkYuzdesi[renk][0] - 7 && KirmiziYuzdesi < RenkYuzdesi[renk][0] + 7 && MaviYuzdesi > RenkYuzdesi[renk][1] - 7 && MaviYuzdesi < RenkYuzdesi[renk][1] + 7 && YesilYuzdesi > RenkYuzdesi[renk][2] - 7 && YesilYuzdesi < RenkYuzdesi[renk][2] + 7 ){ Serial.println(Renkler[renk]); okunduMu=1; break; } } if(okunduMu == 0) Serial.println("Renk Algilanamadi"); Serial.println(); Serial.println();}

Yukarıdaki kodlamada öncelikle renk aralıkları kalibre edilmelidir. Bu yüzden öncelikle kodu yükleyin. Beş renk için (sarı, mavi, beyaz, kırmızı, yeşil) ölçümleme yapınız. Ölçümde elde ettiğiniz sonuçları sırasıyla RenkYuzdesi değişkenine yazın. Bu noktadan sonra sensörünüz kullanıma hazırdır.

RengiTanıma fonksiyonu sensörün LED'lerini sırasıyla yakarak, sensör önünde bulunan cismin 3 ana renk için frekanslarını bulmaktadır. Bulunan renk frekansları RengiBul fonksiyonu içerisinde kullanılmaktadır. Bu fonksiyonda daha önceden kalibre edilmiş değerlerle ölçülen frekans değerleri

karşılaştırılmaktadır. Bu karşılaştırma sonucunda hesaplanan renk ekrana yazdırılmaktadır.

Bu bölümde Arduino ile kullanılan renk sensörlerini incelemiş olduk. Eğer siyah ve beyaz rengin ayırt edilmesi proje için yeterliyse, daha hızlı ölçümler için CYN70 renk sensörü kullanılmalıdır. Ara renklerin de ölçülmesi gereken projelerde TCS3200 gibi tüm renkleri algılayabilen sensörler kullanılmalıdır.Millis Fonksiyonu Nedir ve Nerelerde Kullanılır?Yazar: Geleceği Yazanlar Ekibi

Millis fonksiyonu Arduino'ya enerji verildiği zaman otomatik olarak çalışmaya başlar. Fonksiyon içerisinde Arduino'nun çalışma zamanı milisaniye cinsinden tutulur. Bu fonksiyon çağrıldığında Arduino'nun kaç milisaniye süresince çalıştığı döndürülür. Değerler milisaniye cinsinden tutulduğu için geri döndürülen değer int veya float'ın tutabileceği kapasitenin çok üstünde olabilir. Bu yüzden bu fonksiyonla birlikte unsigned long türündeki değişkenler kullanılır.Not: Millis fonksiyonunu yaklaşık 50 gün çalışabilmektedir. Bu süreden sonra kendisini sıfırlar. Arduino'yu 50 gün boyunca hiç kapatmadan çalıştırdığımızı düşünelim. 50. günün sonunda millis fonksiyonunu kullandığımızda, fonksiyon sıfırlanacağı için Arduino yeniden başlamış gibi değerler döndürecektir.

Millis fonksiyonunun kullanımı gecikme için kullanılan delay fonksiyonunun kullanımına benzemektedir fakat delay fonksiyonu kullanıldığında Arduino başka bir işlem yapamamaktadır. Örneğin saniyede bir LED yakıp söndürmek isteyelim. Bu işlemi aşağıdaki komutla çok kolay bir şekilde yapabiliriz.

void setup() { pinMode(13,OUTPUT);}void loop() { digitalWrite(13,HIGH); delay(1000); digitalWrite(13,LOW); delay(1000);}

Yukarıdaki kod denendiğinde gerçekten de saniyede bir yanan ve sönen LED elde etmiş oluruz. Bu sırada LED'i yakıp söndürmekten başka bir iş yapamayız, çünkü delay fonksiyonu Arduino'yu bir saniye süresince bekletmektedir. Eğer bir saniyede bir LED yakıp söndürmek ve bu arada da seri monitöre sürekli olarak bir şeyler yazdırmak isteseydik, burada delay fonksiyonu kullanamazdık. İşte bu noktada millis fonksiyonunun kullanılması gerekmektedir.

Delay fonksiyonu yerine millis fonksiyonunun kullanılması

Aşağıdaki kodla hem saniyede bir LED yakıp söndürülmüş hem de sürekli olarak serial monitöre "Arduino burada başka işlemler de yapabilir." mesajı yazdırılmıştır.

void setup() { pinMode(13,OUTPUT); Serial.begin(9600);}

/* zaman değerlerinin tutulması için değişkenler tanımlanmalı */unsigned long eskiZaman=0;unsigned long yeniZaman;

int LEDdurumu = 0;

void loop() { /* Arduinonun çalışma suresi milisaniye cinsinden alınıyor */ yeniZaman = millis(); /* bir önceki turdan itibaren 1000 milisaniye geçmiş mi yani yeniZaman ile eskiZaman farkı 1000den büyük mü */ if(yeniZaman-eskiZaman > 1000){ if(LEDdurumu == 1){ digitalWrite(13,LOW); LEDdurumu = 0; }else{ digitalWrite(13,HIGH); LEDdurumu = 1; } /* Eski zaman değeri yeni zaman değeri ile güncelleniyor */ eskiZaman = yeniZaman; } /*Ekrana sürekli olarak mesaj yazdırılıyor */ Serial.println("Arduino burada baska islemler de yapabilir."); /* Bekleme fonksiyonunun kullanılmasına gerek yok fakat ekrana çok hızlı yazdırmamak için biraz bekleme kullanıyoruz */ delay(10);}

Yukarıdaki kodda setup fonksiyonu içerisinde LED pini çıkış yapılmış ve seri haberleşme başlatılmıştır. Daha sonra millis fonksiyonunun döndürdüğü değerlerin tutulması için unsigned long tipinde değişkenler tanımlanmıştır. "yeniZaman" değişkeni millis fonksiyonundan dönecek sayıları tutmak için kullanılmıştır. "eskiZaman" fonksiyonu ise önceki süreyi tutmaktadır.

Bin salise yani bir saniyenin geçip geçmediğini kontrol etmek için "yeniZaman" değişkeninden "eskiZaman" değişkeni çıkartılmıştır. Eğer bu çıkartma işleminin değeri 1000 değerinden fazlaysa bir saniyenin geçtiği anlaşılmaktadır. Bu işlemlerin dışında da ekrana sürekli olarak mesaj yazdırılmaktadır. Böylece delay fonksiyonu yerine millis fonksiyonunun kullanılırsa, bu sürede başka işlemlerin de yapılabileceğini görmüş olduk.

Performans testlerinde millis fonksiyonunun kullanımı

Millis fonksiyonu Arduino'nun çalışma performansını ölçmek için de kullanılır. Örneğin, çok fazla işlem yapan bir fonksiyonumuz olsun. Bu fonksiyon her çağrıldığında Arduino'nun bu işlemleri yapabilmesi için belirli bir süre geçmesi gerekmektedir. Bu zaman kayması da bizim diğer işlerimizi aksatabilir. Bu fonksiyonun her çağrıldığında ne kadar zaman kullandığını öğrenmek için millis fonksiyonu yardımıyla aşağıdaki gibi bir test kodu yazalım.

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

void A(){ /* fonksiyon icerisinde zaman alcak islemler yapilmistir*/ unsigned long sonuc=0; for(int i = 0; i < 999; i ++){ sonuc += i; delay(1); } Serial.print("A fonksiyonunun cevabi ="); Serial.println(sonuc); Serial.println();}

/* zaman değerlerinin tutulması için değişkenler tanımlanmalı */unsigned long zamanbir=0;unsigned long zamaniki=0;

void loop() {

/* Arduinonun çalışma suresi milisaniye cinsinden alınıyor */ zamanbir = millis(); /* A fonksiyonu çağırılıyor */ A(); zamaniki = millis(); /* A fonksiyonunun çalışma süresi zamaniki-zamanbir denklemi ile hesaplanıyor */ Serial.print("A fonksiyonunun calisma suresi= "); Serial.print(zamaniki-zamanbir); Serial.println(" milisaniyedir.");}

Yukarıdaki kodda setup fonksiyonu içerisinde seri monitöre yazdırmak için her zamanki gibi seri haberleşme başlatılmıştır. Daha sonra test etmek istediğimiz fonksiyon yani A fonksiyonu tanımlanmıştır. Bu fonksiyonun içeriği önemli değildir, sadece zaman alacak bir fonksiyon yazılmıştır. Millis fonksiyonunun döndürdüğü değerleri tutmak için bir önceki uygulamamızdaki gibi iki adet unsigned long türünde değişken tanımlanmıştır.

Loop fonksiyonu içerisinde öncelikle millis fonksiyonuyla Arduino'nun o anki çalışma süresi milisaniye cinsinden zaman bir değişkenine kaydedilmiştir. Kayıt işlemi yapıldıktan sonra A fonksiyonu çağrılmıştır. Bu fonksiyon tamamlandıktan sonra ne kadar süre geçtiğini anlamak için zamaniki değişkenine Arduino'nun o anki çalışma süresi yazdırılmıştır. A fonksiyonunun toplam kullandığı zamanı hesaplamak için ikinci ölçümden birinci ölçüm çıkartılmış ve ekrana yazdırılmıştır.Arduino ile Gösterge KullanımıYazar: Geleceği Yazanlar Ekibi

Bu bölümde Arduino ile çalışabilen elektronik göstergeleri tanıyacağız ve bu göstergeler ile uygulamalar yapacağız. Eğitim kapsamında 7 segmentli göstergelerden ve 2x16 LCD ekranlardan yararlanacağız.

Arduino ile 7 segmentli gösterge kullanımı

Arduino projelerinde sayı bazlı çıktıların Bluetooth veya bilgisayara ihtiyaç duymadan gösterilmesi için 7 segmentli göstergeler kullanılır. Gösterge üzerinde bulunan ve ayrı ayrı kullanılabilen 7 çubuk LED bulunmaktadır. Bu yüzden bu göstergeye 7 segmentli gösterge denir. Gösterge üzerinde ondalıklı sayıların gösterimi için sağ altta nokta bulunmaktadır. Aşağıdaki resimde 7 segmentli gösterge ve göstergenin içi gösterilmiştir.


Bir sayının ekrana yazdırılması için a, b, c, d, e, f ve g harfleri ile temsil edilen çubuk LED'ler yakılır. Bu LED'lerin yanması için LED pinlerinin 5 Volt veya 0 Volta çekilmesi gerekir. LED'in yanması için 5 volta mı yoksa 0 volta mı çekilmesi gerektiği, göstergenin türüne göre değişmektedir. Anot göstergelerde ortak uç + 5 volta bağlanır ve yakılmak istenin LED'in pini 0 volt düzeyine çekilir. Katot türündeki bir göstergede ise tam tersi olarak ortak uç toprağa bağlanır ve yakılmak istenilen LED'in pini 5 Volt düzeyine çekilir.Not: Elektronik parça satıcılarından gösterge almak istediğinizde size ilk olarak ortak anot mu yoksa ortak katot mu istediğiniz sorulur. Bu yüzden malzemeleri satın almadan önce kullanacağınız göstergenin türünü belirlemelisiniz.

LED çubuklarının fazla akım çekmemesi için ortak uçlara 220 ohm direnç takılmalıdır. Bu direnç LED'in üzerine düşen akımı düşürmektedir. Göstergenin kullanımını daha iyi anlamak için 0 ile 9 arasında sayan bir sayıcı yapalım.

Uygulama: 0-9 arasında sayan kronometre

Bu uygulamada 0 ile 9 arasında her saniye bir artan bir sayaç yapacağız. Devre bağlantılarının daha iyi anlaşılması için öncelikle yukarıda paylaşılan LED bağlantılarına tekrar bakınız. Arduino gösterge kullanımını kolaylaştırmak için hazır kütüphaneye sahiptir. Fakat öncelikle konunun daha iyi anlaşılması için kendi kodumuzu yazacağız.


1 x Arduino

7 x 220 ohm direnç 1 x 7 segmentli gösterge 1 x Breadboard

/*

Arduino -> Gösterge 2 -> A 3 -> B 4 -> C 5 -> D 6 -> E 7 -> F 8 -> G VCC -> Ortak Uç */

byte gosterge[10][7] = { { 0,0,0,0,0,0,1 }, // = 1 { 1,0,0,1,1,1,1 }, // = 0 { 0,0,1,0,0,1,0 }, // = 2 { 0,0,0,0,1,1,0 }, // = 3 { 1,0,0,1,1,0,0 }, // = 4 { 0,1,0,0,1,0,0 }, // = 5 { 0,1,0,0,0,0,0 }, // = 6 { 0,0,0,1,1,1,1 }, // = 7 { 0,0,0,0,0,0,0 }, // = 8 { 0,0,0,1,1,0,0 } // = 9 };

void setup() { pinMode(2, OUTPUT); pinMode(3, OUTPUT); pinMode(4, OUTPUT); pinMode(5, OUTPUT); pinMode(6, OUTPUT); pinMode(7, OUTPUT); pinMode(8, OUTPUT); pinMode(9, OUTPUT);}

void sayiyiYaz(byte sayi) { byte pin = 2; for (int i = 0; i < 7; i++) { digitalWrite(pin, gosterge[sayi][i]); pin ++; }}

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

Yukarıdaki kodu ile 0-9 arasında bir sayıcı yapmış olduk. Kod biraz incelenirse, tüm sayıların gosterge isimli değişken dizisinde tutulduğu görülmektedir. Bu diziden seçilen herhangi bir sayı kümesi (satır) kendi içerisinde hangi LED'lerin yakılacağını tutmaktadır. sayiyiYaz fonksiyonu ile seçilen yazdırılmak istenin sayının satırı gosterge dizisinden alınmaktadır. Daha sonra for döngüsü yardımıyla tüm LED girişleri sayının değerine göre 5 Volt veya 0 Volt düzeyine çekilmektedir.

Eğer elinizde Anot yerine Katot türünde bir gösterge var ise, gosterge dizisindeki tüm 0'ları 1, tüm 1'leri de 0 yapmalısınız. Ayrıca göstergenin ortak ucunu da toprağa bağlamayı unutmayınız.

Loop fonksiyonu for dögüsü içerisinde 0'dan 9'a kadar saymaktadır. Döngünün her değeri sayiyiYaz fonksiyonu içerisine aktarılmaktadır. Böylece sayılar gösterge üzerinde görünmektedir. "delay" fonksiyonu ile bir saniye bekleme sağlanmıştır.

7 Segmentli Göstergede İki Haneli Sayıların GösterilmesiYazar: Geleceği Yazanlar Ekibi


Çoğu projede tek haneli göstergeler yetersiz olmaktadır. Bu yüzden birden fazla haneyi barındıran göstergeler üretilmiştir. Kablo kalabalığını azaltmak için gösterge içerisinde LED çubuk pinleri haneler arasında birbirine bağlanmıştır fakat göstergenin ortak uçları haneler arasında birbirine bağlanmamıştır. Bu fark kullanılarak haneler ayrı ayrı kontrol edilebilmektedir.

Örneğin göstergeye 25 yazdırmak isteyelim. Bunun için öncelikle onlar hanesindeki sayı, 2 ele alınır. 2 sayısının karşılığı olan pinler 'digitalWrite' fonksiyonu ile ayarlandıktan sonra bu hanenin ortak ucu transistör yardımıyla iletime geçirilir. Böylece akım bizim belirttiğimiz LED çubukları üzerinden sadece ilk haneden geçerek devreyi tamamlar. Birler hanesini yani 5 sayısını yazdırmak için öncelikle 1. haneye bağlı transistör kapatılır. Daha sonra 5 sayısına karşılık gelen LED çubuk pinlerine çıkış verilir. Hemen ardından devrenin tamamlanması için bu haneye bağlı transistör iletime geçirilir.

Bu işlem toplamda 10 milisaniyede yapılmaktadır. Aslında gösterge üzerinde hiçbir hane aynı anda yanmasa bile, insan gözü sanki tüm haneler aynı anda yanıyormuş gibi görür. Konunun daha iyi anlaşılması için bir uygulama yapalım.

Uygulama: 0-99 arasında sayan kronometre

0 ile 99 arasında saymak için iki haneli gösterge kullanılacaktır. Bir önceki uygulamamızda gösterge mantığının anlaşılması için hazır kütüphane kullanılmamıştı. Daha hızlı kullanım için Arduino'nun hazır gösterge kütüphaneleri bulunmaktadır. İnternet üzerinde birçok gösterge kütüphanesi bulunmaktadır. Projede bu kütüphanelerden "SevenSeg" isimli olan kullanılacaktır. Diğer kütüphaneler de benzer mantıkla çalışmaktadır. Bu kütüphaneyi indirip Arduino'ya ekleyiniz.Hatırlatma: Arduino kütüphaneleri dosya klasörü ile birlikte Arduino'nun yüklü olduğu dizindeki "libraries" klasörü içerisine kopyalanmalıdır.


1 x Arduino 7 x 220 ohm direnç 1 x 2 segmentli gösterge 1 x Breadboard

#include <SevenSeg.h> /* gostergenin LED pinleri sirasi ile tanimlaniyor */ SevenSeg gosterge(2,3,4,5,6,7,8);

http://playground.arduino.cc/Main/SevenSeg

const int haneSayisi =2; /* hanerli kontrol edecek transistörlerin pinleri */ int haneler[haneSayisi] = { 9,10}; void setup() { pinMode(2, OUTPUT); pinMode(3, OUTPUT); pinMode(4, OUTPUT); pinMode(5, OUTPUT); pinMode(6, OUTPUT); pinMode(7, OUTPUT); pinMode(8, OUTPUT); /* gösterge kuruluyor */ gosterge.setDigitPins(haneSayisi,haneler); } unsigned long timer=0; int i = 0; void loop() { if(millis() - timer >1000){ i ++; timer = millis(); if(i > 99) i = 0; } gosterge.write(i); }

Bu kodla öncelikle "SevenSeg" kütüphanesi projeye dâhil edilmiştir. Bu projeden gosterge adında bir nesne üretilmiş ve göstergenin kontrol pinleri nesneye yüklenmiştir. Projede kaç haneli gösterge kullanılacağı tanımlanmış ve bu haneleri kontrol eden transistörlerin pinleri belirlenmiştir. Kullanılan göstergenin türü setCommonAnode() veya setCommonCathode() fonksiyonu ile belirtilmelidir.

Loop fonksiyonu içerisinde for döngüsü ile 0 – 99 arasındaki değerler i değişkenine aktarılmıştır. Bu değişkenin değerini göstergeye yazdırmak için write(i) fonksiyonu kullanılmıştır.

Arduino ile LCD Ekran KullanımıYazar: Cansu Uludağ

Önceki uygulamalarımızda sonuçları görmek için, sayı tabanlı çıktıları 7 segmentli ekranlara ve diğer verileri de seri haberleşme ile başka cihazlara göndermiştik. Sonuçların kullanıcıya bilgisayar gibi bir ortama gerek kalmadan devre üzerinde göstermek için LCD ekranları kullanabilirsiniz.

LCD ekranın bağlantı kabloları dikkatlice takılmalıdır. Genellikle LCD uygulamalarında yapılan en büyük hata yanlış veya eksik takılan kablolardır. LCD üzerindeki pin sıralaması üretici firmaya göre değişiklik gösterebilir. Bu yüzden devre kurulumundan sonra LCD bağlantıları bir kere daha kontrol edilmelidir.

https://gelecegiyazanlar.turkcell.com.tr/kisi/uludagcansu

LCD ekran 5 volt ile çalışmaktadır. VCC ve GND bağlantıları buna göre yapılmalıdır. LCD'nin Vo bağlantısı, ekran üzerinde oluşacak karakterlerin görünürlüğünü ayarlamaktadır. Bu ayar ortama ve üretici firmaya göre değiştiği için Vo pini potansiyometreye bağlanır. Potansiyometrenin diğer iki ucu 5 volt ve GND'ye bağlanır. Böylece potansiyometre ile yazıların görünürlüğü ayarlanabilir. Eğer bu bağlantı düzgün bir şekilde yapılmaz ise ekran üzerinde görüntü oluşmayacaktır.

Yukarıdaki şemaya göre devrenizi dikkatlice kurduktan sonra programlama kısmına geçebilirsiniz. LCD ekrana yazı yazabilmeniz için kullanacağınız karakterler, daha önce Arduino geliştiricileri tarafından tanımlanmıştır. Tanımlanmış karakterleri kullanabilmeniz için öncelikle LCD kütüphanesini 'LiquidCrystal.h' projenize eklemelisiniz. Kütüphane eklendikten sonra LCD'ye bağlanan Arduino pinleri programda belirtilmelidir. Setup fonksiyonu içerisinde LCD türünü de belirttikten sonra LCD ekran kullanıma hazırdır.

Önemli LCD Fonksiyonları:

lcd.begin(sutun_sayisi, satir_sayisi): LCD ekranın tanınması için setup fonksiyonu içerisinde kullanılır. LCD kurulumu için fonksiyona sütun ve satır sayısı eklenmelidir.

lcd.print("Hasbi Sevinc"): LCD ekrana yazı yazdırmak için kullanılır. lcd.setCursor(sütun_sayısı, satır_sayısı): LCD ekran üzerinde imlecin

yerini ayarlamak için kullanılır. Sütun ve satır sayıları 0'dan başlamaktadır. Örneğin alt satıra inmek için fonksiyon içerisine (0,1) yazılmalıdır. Böylece imleç, 0. sütun ve 1. satıra gidecektir. İmlecin yeri ayarlandıktan sonra yazma işlemi, imlecin bulunduğu yerden başlar.

lcd.clear(): LCD ekranda yazan her şeyi siler ve imleci en başa alır.

Aşağıdaki kod ile LCD'yi test edebilirsiniz. Eğer tüm ayarlamalar doğru bir şekilde yapıldıysa, ekranda Arduino'nun çalışma süresi yazacaktır.

#include <LiquidCrystal.h> /* LCD kullanimi icin kutuphane dahil edilmelidir *//* Devre şeması; - LCD'nin RS pini -> Arduino'nun 12. pini - LCD'nin Enable (E) pini -> Arduino'nun 11. pini - LCD'nin D4 pini -> Arduino'nun 5. pini - LCD'nin D5 pini -> Arduino'nun 4. pini - LCD'nin D6 pini -> Arduino'nun 3. pini - LCD'nin D7 pini -> Arduino'nun 2. pini - LCD'nin R/W pini -> toprağa - LCD'nin R0 pini -> potansiyometre çıkışına - LCD VDD -> Arduino 5 Voltuna - LCD VSS -> toprağa*/LiquidCrystal lcd(12, 11, 5, 4, 3, 2); /* LCDnin baglandigi Arduino pinleri */

void setup() { lcd.begin(16, 2); /* Kullandigimiz LCDnin sutun ve satir sayisini belirtmeliyiz */ lcd.print("Hasbi Sevinc"); /* Ekrana yazi yazalim */}void loop() { lcd.setCursor(0, 1); /* Imlecin yeri 1. satir 0. sutun olarak ayarlandi */ /* Artik LCDye yazilanlar alt satirda gorunecektir */ lcd.print(millis()/1000); /* LCDye Arduinonun calisma suresi saniye cinsinden yaziliyor*/ /* millis() fonksiyonu Arduino calismaya basladiginda calisan bir Kronometredir. Fonksiyon cagirildiginda gecen sureyi milisaniye olarak dondurur Ekrana gecen sureyi saniye cinsinden yazdirmak icin fonksiyonun degeri 1000e bolunmustur */

}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şıkYazar: Cansu Uludağ

Bu uygulamada, Arduino'ya bağlanan 3 farklı LED'in parlaklıkları üretilen analog sinyallerle ayrı ayrı kontrol edilmektedir. Arduino her 500 milisaniyede

https://gelecegiyazanlar.turkcell.com.tr/kisi/uludagcansu

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ılacakLED2 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ürmeYazar: Geleceği Yazanlar Ekibi

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ıYazar: Geleceği Yazanlar Ekibi

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ıYazar: Geleceği Yazanlar Ekibi

Ö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 MotorYazar: Geleceği Yazanlar Ekibi

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 kgf.cm 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(){ servoNesnesi.attach(9); /* Servo motor 9 numarali pine baglandi */} void loop(){ servoNesnesi.write(100); /* Motorun mili 100. dereceye donuyor */ delay(1000); servoNesnesi.write(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() {

servoMotor.attach(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 */ servoMotor.write(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?Yazar: Geleceği Yazanlar Ekibi

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 "EEPROM.write" 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 "EEPROM.read" 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(){ Serial.begin(9600); /* Bilgisayara veri göndermek için */}

void loop(){ /* EEPROMa veri kaydediyoruz */ kayitAdresi = 10; /* Verinin yazılacağı EEPROM adresi */ kaydedilecekVeri = 50; /* EEPROMA kaydedilecek veri */ EEPROM.write(kayitAdresi, kaydedilecekVeri); /* EEPROMun 10 adresine 50 verisi yazdırıldı. */ delay(10); /* EEPROMa kaydedilmiş verileri okuyalım */ okunacakAdres = 10; // 10 adresini okuyacağız okunanVeri = EEPROM.read(okunacakAdres ); /* EEPROMun 10 adresindeki veri okunanVeri değişkenine aktarılıyor. */ delay(10); /* Sonuçlar bilgisayar ekranına yazdırıldı */ Serial.print("EEPROMun "); Serial.print(okunacakAdres); Serial.print(" Adresindeki Deger= "); Serial.print(okunanVeri); Serial.println(); 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.


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(){ servoMotor.attach(9); /* Servo Arduinonun 9 numaralı pinine takıldı */ Serial.begin(9600);}

void loop(){

servoMotor.write(servoAcisi); /* Servo motoru kontrol ediyoruz */

if(donusYonu == 0){ /* Motor ileri yönde donuyorsa */ servoAcisi = servoAcisi + 5; /* 5 derece döndürelim */ Serial.println(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 */ Serial.println(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(){ servoMotor.attach(9); /* Servo Arduinonun 9 numaralı pinine takıldı */

servoAcisi = EEPROM.read(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 = EEPROM.read(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(){ servoMotor.write(servoAcisi); /* Servo motoru kontrol ediyoruz */ EEPROM.write(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 */ EEPROM.write(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 */ EEPROM.write(0,donusYonu); /* Yon bilgisi EEPROMa kaydediliyor */ } } delay(15); /* Motorun konumunu alması için biraz bekleme */}

Arduino ile Uzaklık ÖlçümüYazar: Geleceği Yazanlar Ekibi

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ı */ Serial.begin(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; Serial.print("Uzaklik "); Serial.print(uzaklik); /* hesaplanan uzaklık bilgisayara aktarılıyor */ Serial.println(" 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.


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){ Serial.print("aci= "); Serial.print(aciDegeri); Serial.print("uzaklik= "); Serial.println(uzaklikDegeri);}

void setup(){ pinMode(trigPin, OUTPUT); /* trig pini cikis olarak ayarlandi */ pinMode(echoPin,INPUT); /* echo pini giris olarak ayarlandi */ radarServosu.attach(9); Serial.begin(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 */ { radarServosu.write(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 */ { radarServosu.write(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ıYazar: Geleceği Yazanlar Ekibi

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ıYazar: Geleceği Yazanlar Ekibi

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ıYazar: Geleceği Yazanlar Ekibi

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.


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:


8 INPUT 1

9 INPUT 2

13 INPUT 3

12 INPUT 4

11 ENABLE A

10 ENABLE B


Motor1 + OUTPUT 1

Motor1 - OUTPUT 2

Motor2 + OUTPUT 3

Motor2 - OUTPUT 4



+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 */


/* 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 */


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ıYazar: Geleceği Yazanlar Ekibi

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.


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ü

https://play.google.com/store/apps/details?id=ptah.apps.bluetoothterminal

http://ttssh2.sourceforge.jp/index.html.en

http://ttssh2.sourceforge.jp/index.html.en

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


8 INPUT 1

9 INPUT 2

13 INPUT 3

12 INPUT 4

11 ENABLE A

10 ENABLE B


Motor1 + OUTPUT 1

Motor1 - OUTPUT 2

Motor2 + OUTPUT 3

Motor2 - OUTPUT 4



+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 */


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 */


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 */


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(){ /* Bluetooth için port açılıyor */ Serial.begin(9600); /* 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(){ if (Serial.available() > 0) { /*Bluetooth’tan veri bekliyoruz */ char tus = (char)Serial.read(); if( tus == 'w' ) ileri(DonmeHizi); if( tus == 's' ) dur(); if( tus == 'a' ) solaDon(DonmeHizi); if( tus == 'd' ) sagaDon(DonmeHizi); if( tus == 'x' ) geri(DonmeHizi); }}

Lazerli Güvenlik DevresiYazar: Geleceği Yazanlar Ekibi

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.



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.


Eğitim İçeriğiArduino ile Interrupt (Kesmeler)

o Zaman Kesmesi (Timer Interrupt)

o Dış Kesmeler (External interrupt)

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-104/dis-kesmeler-external-interrupt

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-104/zaman-kesmesi-timer-interrupt

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-401/arduino-ile-interrupt-kesmeler

I2C Protokolü

o I2C Fonksiyonları

o I2C ile iki Arduino Arasında Veri Aktarımıo Arduino ile IMU Kullanımı

SPI Protokolü

o SPI ile İki Arduino Arasında Haberleşme

Arduino ile Kablosuz Haberleşme

Uzaktan Kontrollü Sıcaklık Sensörü

Arduino ile Ethernet Kullanımı

Arduino ile Web Tarayıcı Yapımı

Ortam Sıcaklığını Arduino ile Tweet Atmak Arduino ile Interrupt (Kesmeler) Yazar: Geleceği Yazanlar Ekibi Kesme anlamına gelen Interrupt, birden fazla işlemin yapıldığı

projelerde sıklıkla kullanılan bir özelliktir. Interrupt, Arduino'nun çalışması sırasında veya dışarıdan bir etkiyle meydana gelen olaylara otomatik olarak tepki vermesidir. Interrupt sayesinde Arduino sürekli beklenen olayın gerçekleşip gerçekleşmemesini beklemez. Arduino, başka görevleri yerine getirirken bu olay gerçekleştiğinde, otomatik olarak bu olaydan haberdar olur.

Diyelim ki Arduino'nun Interrupt özelliği bulunan bir düğmesine basıldığında bilgisayara veri yollamak istiyoruz. Bunu kolay bir şekilde loop fonksiyonunun içine yazacağımız kodlar ile yapabiliriz. Fakat Arduino'nun bu projedeki tek görevi bu olmayabilir. Arduino başka işlemler yaparken kullanıcı düğmeye basabilir. Böyle bir durumda Arduino düğmeye basıldığını anlayamayacaktır.

Böyle bir hatanın önüne geçilmesi için Interrupt kullanılmalıdır. Düğmeye atanacak bir Interrupt, Arduino başka bir işlem yapmakta olsa bile, düğmeye basıldığı gibi Arduino'ya haber verecektir. Arduino düğmeye basıldığında yapılması gereken işlemleri yaptıktan sonra, kaldığı yerden diğer işlemlere otomatik olarak geri dönecektir.

Arduino'da farklı görevlerde kullanılmak üzere çeşitli Interrupt'lar (kesmeler) bulunur. Zaman kesmesi (timer interrupt) ve dış kesmeler (external İnterrupt) en yaygın olarak kullanılan Arduino kesmeleridir.

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-104/ortam-sicakligini-arduino-ile-tweet-atmak

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-104/arduino-ile-web-tarayici-yapimi

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-401/arduino-ile-ethernet-kullanimi

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-104/uzaktan-kontrollu-sicaklik-sensoru

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-401/arduino-ile-kablosuz-haberlesme

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-104/spi-ile-iki-arduino-arasinda-haberlesme

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-401/spi-protokolu

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-104/arduino-ile-imu-kullanimi

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-104/i2c-ile-iki-arduino-arasinda-veri-aktarimi

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-104/i2c-fonksiyonlari

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-401/i2c-protokolu

Zaman Kesmesi (Timer Interrupt)Yazar: Geleceği Yazanlar Ekibi

Zaman kesmesi (timer interrupt), belirli süre aralıklarında belirli görevlerin yapılabilmesi için kullanılır. Örneğin bir LED'in saniyede bir yakıp söndürülmesi gerekmektedir. Bu işlem için loop fonksiyonunun kullanılması yerine, zaman kesmesinin kullanılması Arduino programının rahatlamasını sağlayacaktır. Kullanılan kesme her saniyede bir Arduino'ya haber vererek, LED'in yakılıp söndürülmesini sağlayacaktır.

Zaman kesmelerinin ayarlanabilmesi için bazı program değişkenlerinin ayarlanması gerekir. Bunlardan en önemlisi zaman sayıcısıdır. Bu değişkende tutulan değer, her saat darbesinde bir artar. Taşma değerine ulaştığında sıfırlanır ve Arduino'ya sürenin dolduğunu, kesmenin yapılması gerektiğini bildirir. Bu değişkenin başlangıç değeri ayarlanarak, kesmeler arasındaki geçecek zaman ayarlanabilir.

Farz edelim ki, 8 bitlik zaman sayıcısının ilk değeri 50 olarak belirlendi. Her adımda bu değer bir artırılacaktır. Zaman sayıcısının değeri 255 olduktan bir adım sonra sıfırlanacaktır. Bu noktada zaman kesmesi gerçekleşecektir. Kesme gerçekleştiğinde Arduino otomatik olarak "ISR(TIMERx_COMPA_vect)" fonksiyonunu çalıştıracaktır. Bu fonksiyonun içerisine her kesmede yapılması istenilen görevler yazılır.

Zaman kesmesinin ne kadar sürede bir gerçekleşeceği, her adımın ne kadar sürede gerçekleşeceğiyle de alakalıdır. Bu süre Arduino'nun kristalinin 1, 1/8, 1/64, 1/256 ve 1/1024 oranında olması sağlanabilir. Zaman kesmesinin oluşma süresi aşağıdaki formül ile hesaplanabilir.

Zaman kesmesi kullanarak Kara Şimşek devresi

Zaman kesmesinin ne olduğunu ve nasıl ayarlandığını öğrendiğimize göre, bilgilerimizi pekiştirmek için bir örnek yapalım. Bu örnekte, ilk uygulamalarımızda yaptığımız Kara Şimşek devresini zaman kesmesi kullanarak yapacağız. Önceki uygulamada Kara Şimşek loop fonksiyonu içerisinde yapılmıştı. Bu projede Arduino'nun tüm gücü LED'leri kontrol etmek

https://gelecegiyazanlar.turkcell.com.tr/konu/arduino/egitim/arduino-101/kara-simsek-uygulamasi


için kullanılmıştı. Eğer başka bir işlem yapılmak istenseydi, Arduino yetersiz kalabilirdi.

Bu projede ise LED'ler zaman kesmesi ile belirli sürelerde otomatik olarak yapılacağı için, Arduino başka işlemleri de rahatça yapabilecek.


1 x Arduino 8 x LED 8 x 220 Ohm direnç 1 x Breadboard

const int LEDdizisi[] = {2,3,4,5,6,7,8,9}; int j = 0; void setup() { Serial.begin(9600); for(int i=0; i<8 ;i++) { /* For döngüsüyle LEDdizisi elemanlarına ulaşıyoruz

*/ pinMode(LEDdizisi[i], OUTPUT); /* LED pinleri çıkış

olarak ayarlandı */ } cli(); /* Ayarlamaların yapılabilmesi için öncelikle kesmeler

durduruldu */ /* Timer1 kesmesi saniyede bir çalışacak şekilde

ayarlanacaktır (1 Hz)*/ TCCR1A = 0; TCCR1B = 0; TCNT1 = 0;

https://gelecegiyazanlar.turkcell.com.tr/sites/default/files/icerik/resim1_2.jpg

OCR1A = 15624; /* Bir saniye aralıklar için zaman sayıcısı ayarlandı

*/ TCCR1B |= (1 << WGM12); /* Adımlar arasında geçen süre kristal hızının 1024'e

bölümü olarak ayarlandı */ TCCR1B |= (1 << CS12) | (1 << CS10); TIMSK1 |= (1 << OCIE1A); /* Timer1 kesmesi aktif hale getirildi */ sei(); /* Timer1 kesmesinin çalışabilmesi için tüm kesmeler

aktif hale getirildi */ } /* Arduino otomatik olarak her saniye aşağıdaki

fonksiyonu çalıştıracaktır */ ISR(TIMER1_COMPA_vect){ for(int i=0; i<8; i++){ digitalWrite(LEDdizisi[i],LOW); /* Tüm LED'ler söndürüldü */ } digitalWrite(LEDdizisi[j],HIGH); /* Sıradaki LED yakıldı */ j ++; if(j > 7) j = 0; } void loop() { Serial.println("Arduino burada baska islemler

yapabilir"); delay(100); }

Yukarıdaki Arduino programında "LEDdizisi" değişkeninde Arduino'ya bağlanan LED'lerin pinleri kaydedildi. Setup fonksiyonu içinde bu LED pinleri çıkış olarak ayarlandı. Programın başka işler de yapabildiğini gösterebilmek için loop fonksiyonu içinde seri monitöre mesaj yazdırıldı. Bunun için setup fonksiyonunda seri haberleşme başlatıldı. Zaman kesmesinin açılması ve saniyede bir görev yapılabilmesi için setup fonksiyonu içerisinde Timer1 ayarlandı.

Zaman kesmesi saniyede bir "ISR(TIMER1_COMPA_vect)" fonksiyonunu çalıştırır. Bu fonksiyonun içinde LED'lerin sırayla yanmasını sağlayacak

kodlar yazıldı. Bu kodlarda öncelikle tüm LED'ler sönük konuma getirilir, daha sonra sadece yanması gereken LED yakılır.

Dış Kesmeler (External interrupt)Yazar: Geleceği Yazanlar Ekibi

Arduino projelerinde sıkça kullanılan diğer bir kesme çeşidi de dış kesmelerdir. Dış kesmeler, Arduino'nun özel pinlerinde gerçekleşen voltaj değişimlerini takip eden kesmelerdir. Örneğin Arduino'nun dış kesme pinine bağlanmış bir düğmeye basıldığında, dış kesme Arduino'ya otomatik olarak haber verir. Bu kesme sayesinde Arduino sürekli olarak düğmeye basılıp basılmadığını kontrol etmek zorunda kalmaz, bu sırada başka işlemleri yerine getirebilir.

Dış kesmelere sahip pinler Arduino türüne göre değişiklik gösterir. Aşağıdaki tabloda Arduino türlerine göre dış kesme özelliğine sahip pinler gösterilmiştir.

Arduino Türü Int.0 Int.1 Int.2 Int.3 Int.4 Int.5

Arduino Uno 2 3 - - - -

Arduino Mega 2 3 21 20 19 18

Arduino Leonardo 3 2 0 1 7 -

Kullanılacak dış kesme pini, setup fonksiyonu içerisinde "attachInterrupt" fonksiyonu ile belirtilmeli. Bu fonksiyonun içinde kullanılacak olan pinin numarası değil, kesme numarası girilir. Örneğin Arduino Uno kullanıcısı 2. pindeki kesmeler için 0, 3. pindeki kesmeler için 1 değerini kullanmalıdır. "attachInterrupt" fonksiyonun ikinci değeri kesme durumunda çalışacak fonksiyonu belirler, üçüncü değer hangi durumlarda kesmenin gerçekleşeceğini belirler.

Aşağıda "attachInterrupt" fonksiyonu için tanımlanabilecek dış kesmelerin türleri belirtilmiştir.

LOW: Pindeki voltaj 0 ise kesme oluşur. CHANGE: Pinde oluşacak voltaj değişimlerinde kesme gerçekleşir.


RISING: Yükselen kenarlarda kesme gerçekleşir. Yani pindeki voltaj değeri 0'dan 5 Volta çıktığında kesme gerçekleşir.

FALLING: Düşen kenarlarda kesme gerçekleşir. Yani pindeki voltaj değeri 5'ten 0'a düştüğünde kesme gerçekleşir.

Örneğin Arduino Uno'nun 2. pinine düğme bağlamış olalım. Bu düğmeye basıldığında "butonaBasildi" fonksiyonunun çalışmasını istemekteyiz. Bunun için setup fonksiyonunun içerisine attachInterrupt (0, butonaBasildi, RISING) yazmamız gerekir. Böylece düğmeye her basıldığında "butonaBasildi" fonksiyonu otomatik olarak çalışır.

Dış kesmeler ile düğme kontrollü LED

Bu uygulamada dış kesme özelliğinden faydalanarak düğme kontrolü yapılır. Düğmeye basıldığında Arduino'nun 5. pinine bağlanmış olan LED yakılır. Kullanıcı düğmeden elini çektiğinde yine dış kesme kullanılarak, LED otomatik olarak söndürülür. Dış kesme kullanılması Arduino'nun sürekli düğme durumunu kontrol etmek zorunda kalmasını engeller. Düğmeye basıldığında veya düğmeden el çekildiğinde, Arduino otomatik olarak anlar. Böylece Arduino düğmeyi kontrol etmeden diğer işlemleri yerine getirebilir.


1 x Arduino 1 x düğme 1 x 10K ohm direnç 1 x LED 1 x 220 ohm direnç 1 x Breadboard

int LED = 5;/* LED'in bağlı olduğu pin 5 olarak belirlendi */

void setup(){ pinMode(LED, OUTPUT); /* LED çıkış olarak ayarlandı */ attachInterrupt(0, LEDiyak, RISING); /* 0 dış kesmesi ayarlandı. Yani Arduino Uno için dugme 2. pine bağlanmalıdır */ Serial.begin(9600);}

void loop(){ Serial.println("Arduino burada baska islemler yapabilir"); delay(100);}

void LEDiyak(){ /* Dugmeye basıldığında çalışacak fonksiyon */ digitalWrite(LED,HIGH); attachInterrupt(0, LEDisondur, FALLING);}

void LEDisondur(){ /* Dugmeden el çekildiğinde çalışacak fonksiyon */ digitalWrite(LED,LOW); attachInterrupt(0, LEDiyak, RISING);

Arduino kodunda öncelikle LED'in bağlanacağı pin, 5 olarak belirlenmiş ve bu pin çıkış olarak ayarlanmıştır. Devrede düğme, 2. pine bağlanmıştır. Bu pin 0. dış kesmeye karşılık gelmektedir (Arduino Uno için). Düğmeye basıldığında ve düğmeden el çekildiğinde, Arduino farklı kesmelere girmekte ve LED'in konumunu değiştirir.

Setup fonksiyonu içinde düğmeye basıldığında yapılacak olan görev tanımlandı. Bu alanda düğmeden çekilince yapılacak görevin tanımlanmama nedeni, Arduino'nun aynı anda sadece bir adet dış kesme görevi atayabilmesidir. Bu yüzden 'LEDiyak' ve 'LEDisondur' fonksiyonlarında dış kesme fonksiyonları tekrar tanımlandı.

Zaman ve dış kesmelerin nasıl kullanıldığını öğrendik. Kapsamlı projelerde bu kesmeler kullanılarak Arduino üzerindeki yük azaltılabilir ve projenin daha sağlıklı çalışması sağlanabilir.I2C ProtokolüYazar: Geleceği Yazanlar Ekibi

Arduino, diğer Arduino veya sensörlerle haberleşmek için bazı haberleşme protokolleri kullanır. Bu protokollerden birisi de I2C'dir. I2C (Inter-Integrated Circuit), seri haberleşme türlerinden senkron haberleşmeye bir örnektir. Haberleşme için toprak hattı dışında SDA ve SCL olmak üzere iki hatta ihtiyaç duyulmaktadır. Hat sayısının fazla olması nedeniyle, uzun mesafeli haberleşmelerde tercih edilmez. Genellikle kısa mesafeli ve düşük veri aktarım hızının yeterli olduğu yerlerde kullanılır.

I2C haberleşmesinde, haberleşmeyi kontrol eden master cihazı bulunur. Her haberleşmede bir tane master bulunmalıdır. Haberleşmenin sağlanabilmesi için haberleşme hattına en az bir adet slave (köle) cihaz bağlanmalıdır. Hatta bağlanan birden fazla slave cihazlardan hangisinin veri aktaracağına, master cihaz karar verir. Böylece hat sayısında bir değişiklik olmadan birden fazla cihazla haberleşme sağlanır.

Master ve slave cihazların aynı besleme hattına bağlanmasına gerek yoktur. Fakat iletişimin sağlanması için toprak hatlarının aynı olması gerekir. Bunun yanında veri aktarımı için SDA (Serial Data Line) ve SCL (Serial Clock) olmak üzere iki adet haberleşme hattı bulunur. Bu hatlardan SDA, cihazlar arasındaki veri aktarımının sağlandığı hattır. Bu hatta çift yönlü veri aktarımı olur. Hatta aktarılan verilerin senkronizasyonu, SCL hattı tarafından gerçekleştirilir. SCL hattında master cihaz tarafından üretilen saat sinyali bulunur. SDA hattındaki haberleşme, bu sinyale göre düzenlenir.

Haberleşmenin tüm hat boyunca hatasız bir şekilde sağlanabilmesi için SDA ve SCL hatları, pull-up dirençlerle VCC hattına bağlanmalıdır. SDA ve SCL pinleri, kullanılan Arduino türüne göre değişiklik göstermektedir. Arduino türlerine göre SDA ve SCL pinleri aşağıdaki tabloda gösterilmiştir.

Arduino türü SDA pini SCL pini

Arduino Uno A4 A5

Arduino Mega 20 21

Arduino Leonardo 2 3

Arduino Due 20 21

Arduino Nano A4 A5

I2C FonksiyonlarıYazar: Geleceği Yazanlar Ekibi

I2C haberleşme protokolünün çalışma şeklini ve bağlantı hatlarını öğrendiğimize göre, Arduino'nun I2C haberleşmesini yapabilmesi için kullanmamız gereken fonksiyonları tanıyalım. Bu fonksiyonlar Arduino'nun "Wire.h" kütüphanesi içerisinde bulunmaktadır. Bu yüzden öncelikle bu kütüphaneyi projemize dâhil etmeliyiz.

wire.begin(): I2C haberleşmesini başlatan fonksiyondur. Bu fonksiyon parametre olarak slave cihazın adresini alır. Eğer cihaz master olarak tanımlanacak ise bu fonksiyona herhangi bir parametre atanmaz. Örneğin haberleşme hattında '1' adresine sahip slave bir Arduino tanımlanmak isteniyorsa, wire.begin(1); yazılır. Eğer bu Arduino haberleşme hattının master cihazı olarak tanımlanmak istenseydi fonksiyon, wire.begin(); olarak çağırılmalıydı.

wire.available(): Fonksiyon hat üzerinden Arduino'ya ulaşmış veri paketlerinin sayısını döndürür. Eğer fonksiyonun değeri 0'dan büyükse Arduino'ya gelen yeni veri paketi vardır.


wire.beginTransmission(SlaveAdresi): Master cihazın hat üzerinde bulunan slave cihazlardan hangisiyle haberleşmek istediğini belirler. Fonksiyon, parametre olarak haberleşmeye başlayacağı cihazın adresini alır.

wire.endTransmission(): Hat üzerindeki veri aktarımının sonlandığını belirtir.

wire.read(): Veri hattından gelen verinin okunmasını sağlar. wire.write(): Fonksiyona yazılan parametreyi veri hattına aktarır. Kısaca veri

yollamak için kullanılır. wire.onReceive(GorevFonksiyonu): Slave olarak tanımlanmış cihaza veri

geldiğinde, cihazın yapacağı işlemi belirleyen fonksiyondur. Fonksiyon parametre olarak veri geldiğinde, çağırılacak fonksiyonun ismini alır.

wire.requestFrom(): Master tarafında kullanılan bu fonksiyon ile slave cihazdan veri istenir. Fonksiyonun ilk parametresi, slave cihazın adresini belirler. İkinci parametre ise slave cihazdan kaç byte'lık veri beklendiğini belirler. Üçüncü ve son parametre ise hattın istekten sonraki durumunu belirler.

wire.onRequest(): Slave tarafında kullanılan bu fonksiyon, master cihazdan veri isteği geldiğinde çalıştırılacak fonksiyonu belirler. Bu fonksiyon parametre olarak çalıştırılacak fonksiyonun ismini alır.

I2C ile iki Arduino Arasında Veri AktarımıYazar: Geleceği Yazanlar Ekibi

I2C bağlantı şemasını ve kullanılacak fonksiyonları öğrendiğimize göre, artık küçük bir örnek ile I2C'yi daha iyi anlayabiliriz. Bu örnekte iki adet Arduino Uno kullanılacaktır. Arduino Uno'lardan birisi master birisi de slave görevinde bulunacaktır.

Master görevindeki Arduino, slave görevindeki Arduino'ya bağlı LED'leri kontrol edecek ve slave görevindeki Arduino'dan veri alacak. Slave görevindeki Arduino, master görevindeki Arduino'dan gelen veriyi yorumlayacak. Gelen veriye göre de LED'leri kontrol edecek ve diğer Arduino'ya veri yollayacak.


2 x Arduino 2 x 4.7K ohm direnç 1 x LED 1 x 220 ohm direnç 1 x Breadboard


Not: Devredeki iki Arduino'da ayrı ayrı veya aynı besleme kaynağından beslenmelidir. Eğer Arduino'lar ayrı kaynaklardan besleniyorsa, toprak hatlarının birleştirilmesi gerektiğini unutmayın. Slave üzerinden gelen mesajları okumak için Master görevindeki Arduino'yu bilgisayara bağlayarak Seri Monitörü açın.

Master görevindeki Arduino kodu:/* I2C haberleşmesinde Master olarak görev yapan Arduino kodu */

#include <Wire.h>/* * I2C fonksiyonlarını kullanabilmek için * Wire.h kütüphanesini projemize ekledik */ void setup(){ Wire.begin(); /* I2C haberleşmesi master olarak başlatıldı */ Serial.begin(9600); /* Bilgisayara veri yazdırabilmek için seri haberleşme başlatıldı */}

void loop(){

https://gelecegiyazanlar.turkcell.com.tr/sites/default/files/icerik/resim2_0.png

Wire.beginTransmission(1); /* 1 adresine sahip Slave (köle) cihazına veri yollanacağı bildiriliyor */ Wire.write("a"); /* a karakteri slave cihaza yollanıyor */ Wire.endTransmission(); /* Yollanacak verilerin bittiği bildiriliyor */ /* a karakteri slave cihazda LED'i yak anlamına gelecektir */ delay(1000); Wire.beginTransmission(1); /* 1 adresine sahip Slave (köle) cihazına veri yollanacağı bildiriliyor */ Wire.write("b"); /* b karakteri slave cihaza yollanıyor */ Wire.endTransmission(); /* Yollanacak verilerin bittiği bildiriliyor */ /* b karakteri slave cihazda LED'i sondur anlamına gelecektir */ delay(1000); Wire.requestFrom(1, 7); /* 1 adresine sahip slave (köle) cihazından 7 BYTE'lık veri bekleniyor */ char gelenKarakter; /* I2C hattından gelen veriler gelenKarakter değişkenine yazdırılacak */ while(Wire.available()){ /* I2C hattında yeni veri olduğu sürece döngü devam edecek */ gelenKarakter = Wire.read(); /* I2C hattından gelen veriler okunuyor */ Serial.print(gelenKarakter); /* Gelen veriler ekrana yazdırılıyor */ } Serial.println(); delay(1000);}

Master görevindeki Arduino kodunda öncelikle I2C fonksiyonlarının kullanılabilmesi için Wire.h kütüphanesi çalışmaya dahil edilmiştir. Daha sonra haberleşme Wire.begin() komutuyla master olarak başlatıldı. Slave cihazdan gelecek verilerin ekrana yazdırılabilmesi için Serial.begin(9600) komutu ile Arduino ve bilgisayar arasındaki iletişim başlatıldı.

Loop fonksiyonu içinde, bir saniye aralıklarla slave cihaza 'a' ve 'b' karakterleri yollandı. Bu karakterler slave cihazda işlenerek LED'in konumu değiştirilecek. Bu karakterlerin yollanabilmesi için öncelikle Wire.beginTransmission(1) fonksiyonuyla hangi slave cihaza veri aktarılacağı seçildi. Tüm veriler cihaza yollandıktan sonra Wire.endTransmission(); komutuyla cihaza veri aktarımının bittiği bildirildi.

Slave cihazdan veri alınmak istendiği için Wire.requestFrom(1, 7); komutu kullanıldı. Bu komutla slave cihaz 7 byte'lık veriyi master cihaza aktaracağını anladı. Yeni veri geldiği sürece işlemin devam edebilmesi için, while döngüsünün koşulu Wire.available() yapılır. I2C data hattından gelen veriler Wire.read() fonksiyonuyla okunarak seri porta yollandı.

Slave görevindeki Arduino kodu/* Slave (köle) görevindeki Arduino'nun kodu */#include <Wire.h>/* * I2C fonksiyonlarını kullanabilmek için * Wire.h kütüphanesini projemize ekledik */ const int LED = 13; /* LED 13. pinde bulunmaktadır */ void setup(){ Wire.begin(1); /* I2C haberleşmesi, haberleşme adresi 1 olan bir slave cihaz olarak başlatıldı */ Wire.onRequest(istekGeldiginde); /* Master olan cihaz bu Arduino'dan veri istediğinde gerçekleşecek işlem seçildi */ Wire.onReceive(veriGeldiginde); /* Master olan cihazdan bu Arduino'ya veri geldiğinde yapılacak işlem seçildi */ pinMode(LED,OUTPUT); /* LED pini çıkış olarak ayarlandı */} void loop()

{ /* * Tüm işlemler veri isteği geldiğinde veya yeni veri geldiğinde * yapılacağı için loop fonksiyonunun içi boş bırakılmıştır */ delay(1);} void veriGeldiginde(int veri){ /* I2C hattında bu cihaz için yeni veri olduğunda bu fonksiyon çalışır */ char gelenKarakter; /* Hattaki veri okunarak gelenKarakter değişkenine kaydedilir */ while(Wire.available()){ gelenKarakter = Wire.read(); } /* Eğer gelen veri 'a' ise LED yakılır, 'b' ise LED söndürülür */ if(gelenKarakter == 'a') digitalWrite(LED,HIGH); else if(gelenKarakter == 'b') digitalWrite(LED,LOW);} void istekGeldiginde(){ /* * Eğer master bu cihazdan veri istiyor ise master cihaza "Merhaba" verisi yollanılır * Eğer bu bir sensör olsaydı "merhaba" yerine sıcaklık veya ivme verisi yollanıyor olacaktı */ Wire.write("Merhaba"); }

Slave görevindeki Arduino kodunda öncelikle I2C fonksiyonlarının kullanılabilmesi için Wire.h kütüphanesi çalışmaya dâhil edildi. Daha sonra haberleşme Wire.begin(1) komutuyla 1 adresine sahip slave cihaz olarak başlatıldı. Master cihazından veri geldiğinde "veriGeldiginde()" fonksiyonu, istek geldiğinde "istekGeldiginde()" fonksiyonunun çalışması için "Wire.onReceive(veriGeldiginde)" ve "Wire.onRequest(istekGeldiginde)" fonksiyonları kullanıldı.

Programın ana yapısı bu iki fonksiyon ile çalışır. Arduino'ya master cihazdan yeni veri geldiğinde bu veri okunarak 'gelenKarakter' değişkenine yazdırılır. Gelen karakter eğer 'a' harfine eşitse LED yakılır, 'b' harfine eşitse LED söndürülür. Eğer master cihazdan veri isteği geldiyse, master cihaza "Merhaba" yazısı geri döndürülür. Eğer bu Arduino bir sensör olsaydı, burada "Merhaba" yazısı yerine ortam sıcaklığını veya ivme verisini döndürecekti.

İki Arduino arasında I2C ile nasıl haberleşme ağı kurulacağını öğrendik. I2C sadece mikro denetleyiciler arasında haberleşmeyi sağlamaz, aynı zamanda sensörlerle de haberleşmeyi sağlar. Bir hat üzerine bağlanmış birden fazla sensör, Arduino tarafından kolaylıkla okunabilir. Böylece sensör sayısı artmasına rağmen devredeki karmaşıklık ve kablo sayısı artmamış olur.

Arduino ile IMU KullanımıYazar: Geleceği Yazanlar Ekibi

Bu uygulamada I2C haberleşme protokolünü destekleyen MPU-6050 IMU kartının üzerinde bulunan sensörlerle sıcaklık ivme ve cayro değerlerini ölçeceğiz. Bu sensörler yerine aynı görevi yapan farklı sensörler de kullanabilirsiniz. Öncelikle kullanacağınız sensörün datasheet'ini yani belirtimini okuyarak sensörün I2C adresini ve veri isteme şeklini öğrenmelisiniz.

Bu projede kullanacağımız kart, çeşitli görevler için özelleştirilmiş bir IMU kartıdır. IMU ivme, basınç, cayro gibi sensörleri üzerinde bulunduran sensör kartıdır. MPU-6050 elektronik ve robot malzemeleri satan yerlerde kolayca bulunabilir. Ucuz olması ve kolay kullanımından dolayı bu kart seçilmiştir.

MPU-6050'nin belirtimi (datasheet) incelendiğinde görüldüğü gibi, cihazın I2C haberleşme adresi 0x68'dir. Buradan sensörler hakkında daha fazla bilgi de edilinebilir.


1 x Arduino 2 x 4.7K ohm direnç 1 x MPU-6050


Slave görevindeki Arduino kodu/* MPU-6050 ile I2C haberleşme örneği */#include<Wire.h>/* * I2C fonksiyonlarını kullanabilmek için * Wire.h kütüphanesini projemize ekledik */ const int MPU=0x68;/* MPU-6050'nin I2C haberleşme adresi */

int16_t AcX,AcY,AcZ,Tmp,GyX,GyY,GyZ;/* IMU'dan alınacak değerlerin kaydedileceği değişkenler */

void setup(){ Wire.begin(); Wire.beginTransmission(MPU); Wire.write(0x6B); Wire.write(0); /* MPU-6050 çalıştırıldı */

https://gelecegiyazanlar.turkcell.com.tr/sites/default/files/icerik/resim3_0.png

Wire.endTransmission(true); /* I2C haberleşmesi başlatıldı ve MPU-6050'nin ilk ayarları yapıldı */ Serial.begin(9600);}void loop(){ verileriOku(); /* IMU'dan değerler okundu */ /* Okunan değerler serial monitör'e yazdırılıyor */ Serial.print("ivmeX = "); Serial.print(AcX); Serial.print(" | ivmeY = "); Serial.print(AcY); Serial.print(" | ivmeZ = "); Serial.print(AcZ); Serial.print(" | Sicaklik = "); Serial.print(Tmp/340.00+36.53); /* Datasheetten alınan sıcaklık hesaplama formülü kullanıldı */ Serial.print(" | GyroX = "); Serial.print(GyX); Serial.print(" | GyroY = "); Serial.print(GyY); Serial.print(" | GyroZ = "); Serial.println(GyZ); delay(333);}

void verileriOku(){ Wire.beginTransmission(MPU); /* I2C haberleşmesi yapılacak kart seçildi */ Wire.write(0x3B); /* 0x3B adresindeki register'a ulaşıldı */ Wire.endTransmission(false); Wire.requestFrom(MPU,14,true); /* 14 BYTE'lık veri istendi */ AcX=Wire.read()<<8|Wire.read(); AcY=Wire.read()<<8|Wire.read(); AcZ=Wire.read()<<8|Wire.read(); Tmp=Wire.read()<<8|Wire.read(); GyX=Wire.read()<<8|Wire.read(); GyY=Wire.read()<<8|Wire.read(); GyZ=Wire.read()<<8|Wire.read(); /* * Sırası ile okunan her iki byte birleştirilerek sırası ile değişkenlere yazdırıldı * Böylece IMU'dan tüm değerler okunmuş oldu * 0X3B adresi imu değerlerinden ilk sensörün değerine denk gelmektedir. * IMU'dan tüm değerlerin okunabilmesi için bu adresten başlandı */}

Böylece I2C ile sensörlerden nasıl veri alacağımızı, iki Arduino'yu nasıl konuşturacağımızı öğrendik. I2C, birden fazla sensörün kullanıldığı devrelerde, sensörlerin ve Arduino'nun birbirinden fazla uzakta bulunmadığı projelerde sıklıkla kullanılır.

SPI ProtokolüYazar: Geleceği Yazanlar Ekibi

SPI (Serial Peripheral Interface), Arduino'nun desteklediği senkron seri haberleşme türlerinden biridir. Özellik ve kullanım olarak I2C'ye benzer. Bir Arduino'nun diğer Arduino veya sensörlerle kısa mesafede haberleşmesini sağlar. SPI protokolünde de I2C'de olduğu gibi bir adet Master cihaz bulunur. Bu cihaz hatta bağlı çevresel cihazları kontrol eder.

Master ve çevresel cihazlara bağlanan MISO (Master In Slave Out), MOSI (Master Out Slave In) ve SCK (Serial Clock) olmak üzere üç adet SPI hattı bulunur.

MISO: Çevresel cihazlardan (slave) yollanan verilerin master cihaza aktarıldığı hattır.

MOSI: Master cihazdan yollanan verilerin çevresel cihazlara aktrıldığı hattır. SCK: SPI haberleşmesinde senkronu sağlayan saat sinyalinin bulunduğu

hattır. Saat sinyali master cihaz tarafından üretilir.

MISO ve MOSI hatlarından da anlaşıldığı gibi SPI protokolünde I2C'den farklı olarak veri hatları tek yönlüdür. Ayrıca çevresel cihazların (slave) adreslerinin olmasına gerek yoktur. Her çevresel cihazın seçim ayağı bulunur. Bu ayağa, SS (Slave Select) denir. Bu hattın sayısı kullanılan çevresel cihazların sayısı kadardır. Her cihaz için master cihazından ayrı SS hattı çıkar. SS hattı LOW (0 volt) düzeyinde olan çevresel cihaz, master cihaz ile iletişime başlar.

Örnek bir SPI haberleşme hattı aşağıdaki resimde gösterilmiştir. Resimde de görüleceği üzere, Master cihazdan çevresel cihaz sayısı kadar SS çıkışı bulunur. Master cihaz iletişime geçmek istediği çevresel cihazın SS pinini LOW (0 Volt) düzeyine çeker.


SPI pinleri Arduino türüne göre değişiklik gösterir. Arduino türlerine göre bu pinleri aşağıdaki tabloda gösterilmiştir.

Arduino türü MOSI MISO SCK SS (slave)

SS (master)

Arduino UNO 11 veya ICSP4

12 veya ICSP1

13 veya ICSP3 10

-

Arduino Mega 51 veya ICSP4

50 veya ICSP1

52 veya ICSP3 53

-

Arduino Leonardo ICSP-4 ICSP-1 ICSP-3 -

-

Arduino Due ICSP-4 ICSP-1 ICSP-3 - -

SPI fonksiyonları

SPI protokolünü öğrendiğimize göre şimdi haberleşmenin Arduino kısmına bakalım. Arduino'da SPI fonksiyonlarını kullanabilmemiz için öncelikle "SPI.h" kütüphanesini projemize eklememiz gerekir. Kütüphane projeye eklendiğinde aşağıdaki fonksiyonlar kullanılabilir.

SPI.begin(): SPI haberleşmesini başlatır ve SPI pinlerini başlangıç konumlarına alır.

SPI.setClockDivider(): Bu fonksiyon ile SPI haberleşmesinin saati ayarlanabilir. Fonksiyon değer olarak saat değişkenlerini almaktadır. Eğer hiçbir değişiklik yapılmazsa SPI saati "SPI_CLOCK_DIV4" olarak çalışır. Fonksiyonun alabileceği değişkenler; SPI_CLOCK_DIV4, SPI_CLOCK_DIV8, SPI_CLOCK_DIV16, SPI_CLOCK_DIV32, SPI_CLOCK_DIV64, SPI_CLOCK_DIV128'dir.

SPI.transfer(): SPI hattına veri yollamak veya veri almak için bu fonksiyon kullanılır.

SPI ile İki Arduino Arasında HaberleşmeYazar: Geleceği Yazanlar Ekibi

SPI kütüphanesi, Arduino'nun her zaman master konumunda olacağı düşünülerek hazırlanmış fakat bu uygulamamızda kullanacağımız Arduino'lardan birisi master, diğeri ise slave (köle) durumunda çalışacak. Master olan Arduino için SPI kütüphanesi yeterli olacak fakat diğer Arduino için kütüphane dışında kendi komutlarımızı yazmamız gerekir.

Uygulamada master görevindeki Arduino, diğer Arduino'ya bağlı LED'lerin konumunu yollayacağı veriler ile değiştirecek. Slave görevindeki Arduino LED'in konumunu değiştirdikten sonra, SPI üzerinden kaç kere veri geldiğini master olan Arduino'ya geri bildirecek.


2 x Arduino 1 x LED 1 x 220 ohm direnç 1 x Breadboard


Master Arduino'nun 11, 12 ve 13. pinleri, köle görevindeki Arduino'nun sırası ile 11, 12 ve 13. pinlerine takıldı. Master görevindeki Arduino'nun 8. pini, SS pini olarak belirlendi ve köle görevindeki Arduino'nun 10. pinine bağlandı.Dikkat: Devredeki iki Arduino da ayrı ayrı veya aynı besleme kaynağından beslenmelidir. Eğer Arduino'lar ayrı kaynaklardan besleniyorsa toprak hatlarının birleştirilmesi gerektiğini unutmayın. Köle üzerinden gelen mesajları okumak için master görevindeki Arduino'yu bilgisayara bağlayarak Seri Monitörü açınız./* SPI haberleşmesinde Master olarak görev yapan Arduino kodu */#include <SPI.h>/* * SPI fonksiyonlarını kullanabilmek için * SPI.h kütüphanesini projemize ekledik*/

const int SSpini = 8; /* Slave görevindeki Arduino'nun seçilmesi için 8 bumaralı pin SS olarak belirlendi */ void setup(){ pinMode(SSpini, OUTPUT); /* SS pini çıkış olarak ayarlandı */ digitalWrite(SSpini, HIGH); /* Slave olan Arduino başlangıçta haberleşmeye geçmemesi için SS pini HIGH yapıldı */ SPI.begin(); /* SPI haberleşmesi başlatıldı */} void loop(){

veriGonder('a', SSpini); /* Diğer arduinoya LED'i yakması için 'a' komutu yollandı */ delay(1000); veriGonder('b', SSpini); /* Diğer arduinoya LED'i söndürmesi için 'b' komutu yollandı */ delay(1000);}

/* SPI üzerinden veri göndermek için yazılmış fonksiyondur */void veriGonder(char veri, int SSpini){ digitalWrite(SSpini, LOW); /* Diğer Arduino'nun veri dinlemeye başlaması için SS hattını LOW düzeyine çekmeliyiz */ delay(1); /* Kısa bir süre bekleyelim */ char LEDDurumu; LEDDurumu = SPI.transfer(veri); Serial.println(LEDDurumu); /* veri karakteri diğer Arduino'ya yollandı * Fonksiyon diğer arduino'dan gelen veriyi vermektedir * Geri gelen veri LEDDurumu değişkeninde tutulmuştur * Bu değişken Seri port üzerinden bilgisayardaki Serial monitöre yollanmıştır */ digitalWrite(SSpini, HIGH); /* Haberleşmeyi bitirmek için pin LOW konumuna çekilmiştir */}

Öncelikle projeye SPI fonksiyonlarının kullanılabilmesi için "SPI.h" kütüphanesi eklendi. ‘SSpini' değişkeniyle, seçilecek olan köle konumlu Arduino belirlendi. Bu değişken çoğaltılarak sisteme daha fazla köle görevli Arduino eklenebilir. Setup fonksiyonu içinde SS pinleri çıkış olarak ayarlandı ve ‘HIGH' konumuna getirildi. Daha sonra SPI.begin() fonksiyonuyla SPI protokolü başlatıldı. Projenin loop fonksiyonu içinde 1 saniye aralıklarla köle olan Arduino'ya ‘a' ve ‘b' karakterleri yollandıchar i = 0;const int LED = 7;/* LED Arduino'nun 7. pinine bağlanmıştır */void setup(){ pinMode(MISO, OUTPUT); pinMode(SS , INPUT); /* MISO pini OUTPUT, SS pini INPUT olarak ayarlandı */

pinMode(LED,OUTPUT); /* LED pini çıkış olarak ayarlandı */

SPCR |= 0b11000000; SPSR |= 0b00000000; /* Slave mod ve interrupt için ayarlamalar yapıldı */

sei(); /* Interruptlar çalıştırıldı */} void loop(){ delay(100);}

/* SPI kesmesi olduğunda çalışacak fonksiyon */ISR(SPI_STC_vect){ cli(); /* Interruptlar durdurulmuştur */ while(!digitalRead(SS)) { SPDR = i; i ++; if ( i > 255) i = 0; while(!(SPSR & (1 << SPIF))); /* SPI hattında veri aktarımı bitene kadar bekle */ char gelenVeri; gelenVeri = SPDR; if(gelenVeri == 'a'){ digitalWrite(LED,HIGH); }else if(gelenVeri == 'b'){ digitalWrite(LED,LOW); } /* SPI üzerinden gelen verinin değerine göre LED'in konumu değiştirildi */ } sei(); /* Interruptlar başlatılmıştır */}

Bu uygulamayla SPI protokolünün nasıl çalıştığını ve Arduino tarafında hem master hem de köle konumunda hangi fonksiyonların kullanıldığını öğrendik. İlerleyen konularda SPI ile çalışan cihazları inceleyeceğiz.

Arduino ile Kablosuz HaberleşmeYazar: Geleceği Yazanlar Ekibi

Arduino projelerinin çoğunda kablosuz olarak bir yerden, başka bir yere veri aktarmak isteriz. Bu veriler kimi zaman diğer Arduino'ya bağlı parçaları kontrol etmek için, kimi zaman da karşı taraftaki Arduino'dan sensör verilerini almak için kullanılır. Arduino, tek başına kablosuz veri aktarımı için yeterli değildir. Arduino, kablosuz veri aktarımı için kablosuz haberleşme modüllerine ihtiyaç duymaktadır.

Arduino ile çalışan çeşitli kablosuz haberleşme modülleri vardır. Eğitimimizde bu modüllerden kullanımı kolay ve fiyatı düşük olan, nRF24L01 modülünü kullanacağız. nRF24L01 modülü Arduino ile daha önce öğrendiğimiz SPI protokolünü kullanarak haberleşmektedir. Modülün PCB ve harici antenli modelleri bulunmaktadır. İki model de 2.4 GHz’de haberleşmektedir, fakat harici antene sahip modülün haberleşme mesafesi PCB antene sahip modülden daha fazladır.

PCB Antenli nRF24L01Harici Antenli nRF24L01

Pin bağlantıları

Modül 3.3 Volt ile çalıştığı için, modülün VCC pini Arduino'nun 3.3 Volt çıkışına takılmalıdır. Yanlışlıkla modülün 5 Volt hattına takılması, modüle zarar

verebilir. Bu uygulamada Arduino Uno kullandığımız için, modülün SPI pinlerini Arduino'nun SPI pinlerine bağlamalıyız. Bazı nRF24L01'lerde modül üzerinde pin isimleri yazmamaktadır. Aşağıdaki görselde nRF24L01 modülünün pin bağlantıları gösterilmiştir.

Aşağıdaki tabloda nRF24L01 modülü ile Arduino arasında kurulacak bağlantılar gösterilmiştir.

nRF24L01 Haberleşme Modülü Arduino UNO

VCC 3.3 V

GND GND

CS 7

CE 8

MOSI 11

MISO 12

SCK 13

Projelerimizde nRF24L01 modüllerinden birisi alıcı (receiver) diğeri ise verici (transmitter) görevinde kullanılacaktır. Modülün alıcı veya verici olması, kablo bağlantılarını değiştirmemektedir. Hangi modülün alıcı, hangi modülün verici olacağına, Arduino içerisindeki kod karar vermektedir. Projenin ihtiyacına göre haberleşme modülü çift yönlü haberleşme yapmak için, hem alıcı hem de verici (transceiver) olarak kullanılabilir.Not: Tüm kablo bağlantılarının hatasız bir şekilde yapılmasına rağmen, bazen modüller birbiri arasındaki haberleşmeyi sağlayamamaktadır. Böyle bir durumda modüllerin VCC (3.3V) ve GND pinleri arasına 3.3 uF ile 10 uF arasında bir kapasite koyarak tekrar deneyin.

Arduino yazılımı

nRF24L01 kablosuz haberleşme modülü, Arduino için "nRF24L01p.h" isimli kütüphaneye sahiptir. Arduino kodunu yazmadan önce bu kütüphaneyi indirip, Arduino projemize dâhil etmeliyiz. Kütüphaneyi indirmek için tıklayın.Not: Arduino kütüphaneleri dosya klasörü ile birlikte Arduino'nun yüklü olduğu dizindeki "libraries" klasörü içerisine kopyalanmalıdır.

Kütüphane projeye eklendikten sonra ilk olarak CS ve CE pinlerinin programa tanımlanmalıdır. Modül, SPI ile haberleştiği için SPI.begin() fonksiyonu ile SPI protokolü başlatılmalıdır. İki haberleşme modülünün birbiri arasında iletişime geçebilmesi için, modüllerin aynı kanal üzerinden haberleşmesi gerekir. “alici.channel(KanalID)” fonksiyonu ile haberleşme kanalı seçilir. Protokol ayarlamaları yapıldıktan sonra iki modül aralarında haberleşmeye hazır hale gelir.

Uzaktan Kontrollü Sıcaklık SensörüYazar: Geleceği Yazanlar Ekibi

Bu projede kullanılacak olan iki Arduino Uno'dan birinde LM35 sıcaklık sensörü bulunmaktadır. Bu, Arduino ortam sıcaklığını ölçerek, sıcaklık bilgisini nRF24L01 kablosuz haberleşme modülünü kullanarak, diğer Arduino'ya aktaracaktır. Sıcaklık bilgisini alan Arduino ,seri port üzerinden Serial Monitör'e yazdıracaktır. Bu uygulamada nRF24L01 modülünün devreye nasıl bağlandığını ve Arduino kodunun nasıl yazıldığını öğrenmiş olacağız.Not: Bu uygulamada kullanılacak olan LM35 sıcaklık sensörünün besleme (5 V), toprak ve çıkış olmak üzere 3 adet pini bulunmaktadır. Çıkış pinindeki değer, ortamın sıcaklığına göre lineer olarak değişmektedir.



2 x Arduino UNO 2 x nRF24L01 kablosuz haberleşme modülü 2 x 10 uF kapasite 1 x LM35 (sıcaklık sensörü) 1 x Breadboard

Alıcı görevindekiArduino Uno nRF24L01

3.3 Volt -> VCC

GND -> GND

7 -> CS

8 -> CE

11 -> MOSI

12 -> MISO

13 -> SCK

Verici görevindekiArduino Uno nRF24L01

3.3 Volt -> VCC

GND -> GND

7 -> CS

8 -> CE

11 -> MOSI

12 -> MISO

13 -> SCK

Verici görevindekiArduino Uno LM35

5 Volt -> 1 (VCC)

A0 -> 2 (Analog)

GND -> 3 (GND)

Verici kodu#include <SPI.h>#include <nRF24L01p.h>#include <String.h>

nRF24L01p verici(7,8);/* CSN - > 7, CE -> 8 olarak belirlendi */

float sicaklik;static char veri[10];

void setup() { Serial.begin(9600); SPI.begin(); SPI.setBitOrder(MSBFIRST); /* SPI başlatıldı */ verici.channel(90); verici.TXaddress("Hasbi"); verici.init(); /* Verici ayarları yapıldı */}void loop() { sicaklik = analogRead(A0);

/* A0daki gerilim ölçüldü */ sicaklik = sicaklik * 0.48828125; /* Ölçülen gerilim sıcaklığa çevrildi */ Serial.print("SICAKLIK = "); Serial.print(sicaklik); Serial.println(" C"); /* Sıcaklık bilgileri ekrana yazdırıldı */ dtostrf(sicaklik,5, 2, veri); /* float değerindeki sıcaklık stringe çevrildi */ verici.txPL(veri); boolean gonderimDurumu = verici.send(FAST); /* Sıcaklık bilgisi nRF24L01'e aktarıldı */ /* Eğer gönderim başarısız olursa gonderimDurumu'nun değeri false olacaktır */ if(gonderimDurumu==true){ Serial.println("mesaji gonderildi"); }else{ Serial.println("mesaji gonderilemedi"); } delay(1000); }

nRF24L01 modülünün CSN ve CE pinleri 7 ve 8 olarak belirlenmiştir. Okunan sıcaklık verisinin ekrana yazdırılabilmesi için, seri haberleşme başlatılmıştır. Modül SPI protokolünü kullandığı için SPI başlatılmıştır. Haberleşmenin sağlanabilmesi için, modüller arasındaki kanal 90 olarak belirlenmiştir. Loop fonksiyonu içerisinde bir saniye aralıklarla LM35'ten sıcaklık verisi okunmuştur. Okunan veri, kablosuz haberleşme modülüne yollanmıştır. Gönderimin başarı durumu 'gonderimDurumu' değişkeni yardımıyla ekrana yazdırılmıştır.Alıcı kodu#include <SPI.h>#include <nRF24L01p.h>

nRF24L01p alici(7,8);/* CSN - > 7, CE -> 8 olarak belirlendi */

void setup(){ Serial.begin(9600); SPI.begin(); SPI.setBitOrder(MSBFIRST); /* SPI başlatıldı */ alici.channel(90); alici.RXaddress("Hasbi"); alici.init();

/* Alıcı ayarları yapıldı */}

String sicaklik;

void loop(){ while(alici.available()){ /* Modülden veri geldiği sürece while devam edecek */ alici.read(); alici.rxPL(sicaklik); /* Modülden gelen veri okundu */ if(sicaklik.length()>0) { Serial.println(sicaklik); /* modülden gelen veri ekrana yazdırıldı */ sicaklik=""; /* eski veri temizlendi */ } }}

nRF24L01 modülünün CSN ile CE pinleri 7 ve 8 olarak belirlenmiştir. Vericiden alınan sıcaklık verisinin ekrana yazdırılabilmesi için seri haberleşme başlatılmıştır. Modül SPI protokolünü kullandığı için SPI başlatılmıştır. Haberleşmenin sağlanabilmesi için modüller arasındaki kanal 90 olarak belirlenmiştir. Loop fonksiyonu içerisinde haberleşme modülünden veri geldiği sürece, while döngüsünün devam etmesi sağlanmıştır. Gelen veriler 'sicaklik' değişkeninde tutulmuş ve ekrana yazdırılmıştır.

Bu uygulamamızda iki Arduino modülü arasında kablosuz haberleşmenin nasıl sağlandığını öğrenmiş olduk. Bu ve daha önceki bölümlerde öğrenilen bilgiler ile gelişmiş Arduino projeleri yapılabilir. Bölümde incelenen nRF24L01 modülü yerine farklı modüller de aynı şekilde kullanılabilir fakat her modülün haberleşmesi farklı olacağı için, öncelikle kullanılacak modülün belirtimleri (datasheet) incelenmelidir.

Arduino ile Ethernet KullanımıYazar: Geleceği Yazanlar Ekibi

Ethernet modülü, Arduino'yu kablolu internet ağına bağlamak için kullanılan bir karttır. Ethernet modülüyle Arduino, web tarayıcısı gibi web sitelerine girebilir, web sitelerine veri kaydedebilir hatta sizin için tweet atabilir.

Kart üzerinde Wiznet W5100 entegresi bulunmaktadır. Ethernet modülü hem TCP hem de UDP ile uyumludur. Yeni üretilen ethernet modüllerinde, internete bağlanma özelliğinin yanında SD kart kullanabilme özelliği de bulunur.

Arduino, Wiznet W5100 entegresi ve SD kart SPI üzerinden haberleşir. İnternete bağlanmayı sağlayan Wiznet entegresi ile Arduino'nun haberleşmeye geçmesi için Arduino'nun 10. pininin 0 Volt (LOW) düzeyine getirilmesi gerekir. Eğer SD kart ile işlem yapılmak isteniyorsa Arduino'nun 4. pini 0 Volt (LOW) düzeyine getirilir.

W5100 ile SD kart aynı SPI hattını kullandıkları için beraber çalışamazlar. Bu yüzden aynı anda 4. ve 10. pinler 0 Volt (LOW) düzeyine getirilmemeli. Kullanılmayacak olan özelliğin SPI kontrol pinin 5 Volt (HIGH) konumuna getirilmesi gerekir.

Arduino'yu internete bağlamak için shield'e göre daha ucuz olan ethernet modülleri kullanılabilir. Bu modüller ile Arduino arasındaki kablo bağlantıları elle yapılmalıdır. Aşağıdaki resimde shield'lere göre daha ucuz olan Enc28j60 ethernet modülü gösterilmiştir.

Enc28j60 ethernet modülünü kullanacak Arduino geliştiricilerinin, kablo bağlantılarını aşağıdaki tablo veya devre şemasına göre yapmaları gerekir.

Enc28j60 Ethernet modülü Arduino

CS 10

SI 11

SO 12

SCK 13

VCC 3.3V

GND GND

Kablo bağlantılarını yaptığımıza göre artık programlama kısmına geçebiliriz. Ethernet modüllerinin Arduino ile kullanılması için birçok hazır kütüphane bulunur. Biz bu kütüphanelerden "ethercard-master" isimli olanını kullanacağız. Bu kütüphaneyi seçme nedenimiz, diğer kütüphanelere göre daha kolay kullanıma sahip olması ve daha kararlı çalışmasıdır. Kütüphaneyi buradan indirebilirsiniz.Not: Kütüphanede tanımlanan CS pininin 10 olarak değiştirilmemesi Arduino'nun ethernet modülü ile bağlantı kuramamasına neden olacaktır. "EtherCard.h" dosyasındaki "csPin" değişkenini 10 olarak ayarlamayı unutmayınız.

Arduino ile Web Tarayıcı YapımıYazar: Geleceği Yazanlar Ekibi

Ethernet modülünün internete başarıyla bağlanıp bağlanmadığını anlamak için bu uygulamada Arduino ile internet sitelerine bağlanmaya çalışacağız. Bağlandığımız sitenin HTML kodlarını seri monitöre yazdıracağız. Böylece Arduino ile basit bir web tarayıcı yapmış olacağız.

Uygulamada daha önceden yüklediğimiz "ethercard-master" kütüphanesini kullanacağız. Ethernet Shield kullanacak Arduino geliştiricileri, Shield'i doğrudan Arduino üzerine takarak, devre kurulumunu tamamlayabilir. Enc28j60 ethernet modülünü kullanacaklar için kurulması gereken devre, aşağıdaki devre şamasında gösterilmiştir.

https://gelecegiyazanlar.turkcell.com.tr/sites/default/files/icerik/resim3.png

Devre kurulumunu gerçekleştirdiğimize göre aşağıdaki Arduino kodunu yükleyelim ve serial monitörü açalım.

#include <EtherCard.h>

static byte mymac[] = { 0x74,0x69,0x69,0x2D,0x30,0x31 }; /* Ethernet ağında tek olması gereke MAC adresi */

byte Ethernet::buffer[700];static uint32_t timer;

const char website[] PROGMEM = "www.google.com";/* bağlantı kurulacak internet sitesi */

// called when the client request is completestatic void my_callback (byte status, word off, word len) { Serial.println(">>>"); Ethernet::buffer[off+300] = 0; Serial.print((const char*) Ethernet::buffer + off); Serial.println("...");}

void setup () { Serial.begin(57600); Serial.println(F("\n[web browser]"));

if (ether.begin(sizeof Ethernet::buffer, mymac) == 0)


Serial.println(F("Ethernet baglanti hatasi")); if (!ether.dhcpSetup()) Serial.println(F("DHCP hatasi"));

ether.printIp("IP: ", ether.myip); ether.printIp("GW: ", ether.gwip); ether.printIp("DNS: ", ether.dnsip);

if (!ether.dnsLookup(website)) Serial.println("DNS failed"); ether.printIp("SRV: ", ether.hisip);}

void loop () { ether.packetLoop(ether.packetReceive()); if (millis() > timer) { timer = millis() + 5000; Serial.println(); Serial.print("Baglanti kuruluyor"); ether.browseUrl(PSTR(""), "", website, my_callback); }}

Yukarıdaki kod çalıştırıldığında, eğer tüm ayarlar ve devre kurulumu doğruysa, Arduino’nun belirtilen internet sitesine bağlanması ve bu site ile ilgili bilgileri ekrana yazdırması gerekmektedir. Bağlantı başarılı bir şekilde kurulduktan sonra sitenin HTML kodları da serial monitörde görünecektir.Seri haberleşmenin daha hızlı gerçekleşmesi için Baud Rate 57600 olarak belirlenmiştir. Serial monitörde mesajların doğru görülmesi için serial monitor penceresinin sağ altından baud rate ayarını yapmayı unutmayınız.

"mymac" değişkenine yazılacak MAC adresi, orijinal ethernet modülleri üzerinde yapıştırma şeklinde yazmaktadır. Eğer böyle bir yapıştırma bulunmuyorsa, kodda belirtilen MAC adresi denenebilir. Setup fonksiyonu içinde, modülün belirtilen MAC adresi ile ağa bağlanıp bağlanamadığı kontrol edilmiştir. Eğer bağlantı hatasız gerçekleştirildiyse, Arduino'nun ağdan aldığı IP adresi ekrana yazdırılmıştır.

Loop fonksiyonu içinde belirtilen internet sitesine bağlanma komutları bulunmaktadır. Arduino beş saniyede bir belirtilen internet sitesine tekrar bağlanmaktadır. Bunu sağlamak için daha önceden öğrendiğimiz millis fonksiyonu kullanılmıştır.

Eğer Arduino'nuz hatasız bir şekilde internete bağlandıysa, artık Nesnelerin İnterneti (Internet of Things) projelerini gerçekleştirebilirsiniz.

Ortam Sıcaklığını Arduino ile Tweet AtmakYazar: Geleceği Yazanlar Ekibi

Ethernet modülümüzü başarılı bir şekilde internete bağladığımıza göre, bu modül ile yapılabilecek projelere bakalım. "ethercard-master" kütüphanesi içerisinde tweet atmak için yazılmış örnek program bulunmaktadır. Bu program üzerinde ufak değişiklikler yaparak ortam sıcaklığını tweet atan bir devre kurabiliriz. Öncelikle Twitter'a mesaj yollayabilmemiz için kişisel jetonunuzun (token) olması gerekir. Bunun için burada linki verilen Twiter uygulamasını kullanabilirsiniz.

Twitter üye girişinizi yaptıktan ve uygulamaya izin verdikten sonra, site üzerinde jetonunuz (token) görünür. Bu sayı ve karakterleri yazacağımız Arduino koduna ekleyeceğiz.


Arduino UNO Ethernet modülü 1 x LM35 (sıcaklık sensörü) 1 x Breadboard

Devremizi yukarıdaki devre şemasında gösterildiği gibi kuralım. Ethernet kablosunu, ethernet modülümüze bağladıktan sonra devre kurulumumuz tamamlanmış olacaktır. Artık Arduino kodunu hazırlayabiliriz.

http://arduino-tweet.appspot.com/oauth/twitter/login



Öncelikle Arduino, Ethernet modülü yardımıyla internet ağına bağlanması gerekir. LM35 ile ortam sıcaklığı ölçülerek tweet mesajına eklenecektir. Oluşturulan mesaj, Twitter üzerinden aldığımız jeton (token) ve Twitter uygulaması yardımıyla tweetlenecektir.

#include <EtherCard.h> #define TOKEN "BURAYA TOKEN KODUNUZU YAZINIZ"

static uint32_t timer;

byte mymac[] = { 0x74,0x69,0x69,0x2D,0x30,0x31 };/* tekil MAC adresi */

const char website[] PROGMEM = "arduino-tweet.appspot.com";/* Tweet atabilmemiz için kullandığımız uygulama adresi */

static byte session; byte Ethernet::buffer[700];Stash stash; static void TweetAt () { Serial.println("Tweet hazirlaniyor"); float sicaklik = analogRead(A0); /* A0daki gerilim ölçüldü */ sicaklik = sicaklik * 0.48828125; /* Ölçülen gerilim sicaklığa çevrildi */

byte sd = stash.create(); stash.print("token="); stash.print(TOKEN); stash.print("&status="); stash.print("Odamin sicakligi su anda "); stash.print(sicaklik); stash.println(" derecedir."); Serial.println("Tweet hazirlandi"); stash.save(); int stash_size = stash.size(); Stash::prepare(PSTR("POST http://$F/update HTTP/1.0" "\r\n" "Host: $F" "\r\n" "Content-Length: $D" "\r\n" "\r\n" "$H"), website, website, stash_size, sd);

session = ether.tcpSend(); Serial.println("Tweet yollandi");} void setup () { Serial.begin(57600); if (ether.begin(sizeof Ethernet::buffer, mymac) == 0) Serial.println(F("Ethernet baglanti hatasi")); if (!ether.dhcpSetup()) Serial.println(F("DHCP hatasi")); ether.printIp("IP: ", ether.myip); ether.printIp("GW: ", ether.gwip); ether.printIp("DNS: ", ether.dnsip); if (!ether.dnsLookup(website)) Serial.println(F("DNS hatasi")); ether.printIp("SRV: ", ether.hisip); } void loop () { ether.packetLoop(ether.packetReceive()); const char* reply = ether.tcpReply(session); if (reply != 0) { Serial.println(reply); } if (millis() > timer) { timer = millis() + 60000; Serial.print("Baglanti kuruluyor"); TweetAt(); }

}

Not: Seri haberleşmenin daha hızlı gerçekleşmesi için Baud Rate 57600 olarak belirlenmiştir. Serial monitörde mesajların doğru görülmesi için serial monitor penceresinin sağ altından baud rate ayarını yapmayı unutmayınız.

Setup fonksiyonu içinde ethernet modülünün ağa katılabilmesi için ayarlamalar yapıldı. Arduino'nun ağ üzerindeki IP adresi de bu bölümde ekrana yazdırıldı. Loop fonksiyonu içinde ethernet modülünden gelecek mesajlar gösterildi ve 60 saniyede bir "TweetAt" fonksiyonu çağrıldı.

"TweetAt" fonksiyonu, sıcaklığın ölçülerek Twitter mesajının oluşturulduğu fonksiyondur. Burada oluşturulan mesaj daha önceden izin verdiğimiz uygulama aracılığıyla Twitter'a yollanır. Bu fonksiyon, loop fonksiyonu içerisinde 60 saniyede bir çağrılır. Kısa sürelerde aynı tweetlerin atılması, Twitter'ın yollanan mesajları engellemesine neden olabilir.

Ethernet modülü bazen tweet atarken başarısız olabilir. Bu durumlarda tekrar tweet atmayı deneyebilirsiniz.

Bu uygulama değiştirilerek yeni Nesnelerin İnterneti (Internet of Things) projeleri gerçekleştirilebilir. Örneğin burada kullanılan sıcaklık sensörü yerine, toprak-nem sensörü kullanarak çiçeğinizin durumunu çevrimiçi olarak takip edebilir, istediğiniz zaman çiçeğinizi sulayabilirsiniz.

Arduino 101 Eğitimi - Ali Keşfet – Keşfet Ali Keşfet · Web viewEğer mesajlarımız doğru...

Documents

Transcript of Arduino 101 Eğitimi - Ali Keşfet – Keşfet Ali Keşfet · Web viewEğer mesajlarımız doğru...