PWM (Pulse Width Modulation- Sinyal Genişlik Modülasyonu) Tekniği Nedir?

PWM Nedir?

Açılımı Pulse Width Modulation yani Sinyal Genişlik Modülasyonu olan bu teknik, sinyal işleme veya sinyal aktarma gibi daha çok elektronik devrelerin yanı sıra Arduino veya elektrik makineleri gibi özel uygulama alanlarında da yer alan bir tekniktir.

En basit haliyle bir sinyal modülasyon tekniği olarak tanımlanabilir. Sinyal bilgisinin aktarım için uygun hale çevirilmesi amacının yanı sıra güç kontrolü sağlamak ve elektrik makineleri, güneş pili şarj üniteleri gibi özel devrelere destek olmak amacı da taşır. Arduino ile Analog sinyaller gönderemeyiz ama Analog sinyalleri taklit eden Dijital sinyaller gönderebiliriz. Bu yönteme PWM (Pulse-Width Modulation) yöntemi denir

Bu kontrolde tamamen anahtarlama ile sağlanır. Anahtarlama ne kadar hızlı yapılırsa, PWM ile aktarılan sinyalin gücü o kadar da artar. Örneğin bir lambaya gönderilen sinyalde PWM tekniğine ihtiyaç duyuluyorsa, bu teknik 120 Hz frekans değerinde uygulandığında maksimum verim elde edilebilir.

"Duty Cycle" yani görev döngüsü olarak tanımlanan bir kavram bulunuyor ve PWM tekniğinde de sıkça karşımıza çıkıyor. Görev döngüsü kavramı aslında yapılan işlemin periyodunu belirtiyor. Bu döngü düşük seviyelerde ise aktarılan güç düşük olurken, döngünün yüksek seviyelerinde yüksek güç aktarılıyor.

PWM Tekniğinin Avantajları

Peki PWM tekniği ile sinyallere işlemler uygulamanın avantajı ne? Öncelikle anahtarlama kaybı düşük seviyede. Anahtar kapalı olduğunda pratik olarak hiç akım

akmıyor iken, anahtar açık olduğunda anahtar üzerindeki gerilim düşümü yok denecek kadar az.

Bu sayede güç kaybının az olmasının yanı sıra, PWM tekniği dijital kontrol üniteleri ile büyük bir uyum içerisinde. Sistem, açık-kapalı anahtarlama değişimlerine bu sayede çok daha rahat uyum sağlayabiliyor.

Ayrıca iletişim ve haberleşme teknolojilerinde kullanılan sinyallerin görev döngüleri ile ilgili düzenlemelerde de PWM tekniği sık sık kullanılıyor. Böylece kanal üzerinde çeşitli ayarlamalar ile istenilen sinyaller elde edilebiliyor.

Arduino ve PWM

Arduino bünyesinde de PWM tekniği kullanılabiliyor. Arduino bünyesinde kullanılan PWM tekniği ile dijital sonuçlardan analog sonuçlar elde edilebiliyor. Bunun yanı sıra özellikle kontrol için ihtiyaç olan kare dalga üretimi de gerçekleşiyor. Kare dalga, bilindiği gibi "on" ve "off" konumlarını sağlıyor.

Böylece kare dalga gönderildiğinde "on" konumunda 5V uygulanırken, "off" konumunda 0V uygulanmış oluyor. İşte bu "on" kısmının aktif olduğu genişliğe "Pulse Width" yani "Sinyal Genişliği" adı veriliyor. Bu doğrultuda istenilen sinyal genişliği elde etmek için de modülasyon tekniği uygulamanız gerekiyor ki bu da PWM'in temel mantığıdır.

PWM sinyaller kare dalga sinyallerdir. Arduinonun çalışma gerilimi olan 5 Voltu belirli aralıklarla gönderip – keserek 5 Volttan daha küçük gerilimlerin elde edilmesi sağlanır. Bu yöntemle dijital sinyaller kullanılarak analog sinyaller taklit edilmiş olur.

Arduino ile yanıp sönen bir LED devresi kurmak veya Arduino ile DC motor kontrolü gerçekleştirmek için PWM tekniğini kullanmamız gerekiyor. Bu teknik de Arduino'ya gömülen yazılımda yatıyor. "analogWrite(...)" fonksiyonu ile görev döngüsünün miktarı belirleniyor ve kare dalga elde ediliyor.

PWM Tekniğinin Prensipleri

PWM tekniğinin temeli kare dalga üretmekte yatıyor. Bu kare dalga da genellikle referans olarak aldığı dalganın ortalaması kadar büyüklüğe sahip oluyor. Bunun yanı sıra sistemdeki dalganın büyüklüğü ise görev döngüsünün büyüklüğü ile doğru orantılıdır.

PWM dalgasını elde etmenin birden fazla yöntemi bulunuyor. Bunları listelersek:

♦ Delta: Delta modülasyonlu PWM sinyali, integral alıcı ve limitleyici devre yapıları ile elde edilir. İntegral sonucunun limitlere değmesi "off", diğer durumlarda "on" durumu oluştuğu için kare dalga oluşur.

♦ Sigma - Delta: Bu modülasyonda ise çıkış sinyali, referans alınan sinyalden çıkartılır. Böylece hata sinyali elde edilmiş olur. Hata sinyalinin integralinin sonucuna göre eğer limite değiyorsa "off", değmiyorsa "on" durumu oluşturularak kare dalga elde edilir.

♦ Boşluk - Vektör: 3 fazlı AC uygulamalar için algoritma kullanılarak kare dalga elde edilir.

♦ Direkt Tork Kontrol (DTC): AC motorlarda kullanılmak üzere geliştirilen bir PWM tekniğidir. Delta modülasyon tekniğinden üretilmiştir. Motora gönderilen sinyal belirli bir filtreden geçirilir ve motorun torku ile manyetik akı kontrol altında tutulur.

♦ Zaman Bölücü: Özellikle mikroişlemcilerin PWM çıkışları tarafından kullanılırlar. Değişken görev döngüsüne sahip devrelerde de kullanılabilirler.

PWM Uygulama Alanları

► Haberleşme Sistemleri: Telekomünikasyon sistemlerinde sinyallerin önemi çok büyük ve bu sinyallerin kontrol edilmesi ve modülasyon tekniğine uygun olması gibi kabiliyetler

de çok önemli. "0" ve "1"lerden oluşan lojik haberleşme devrelerinde kare dalga ve PWM en sık kullanılan 2 unsur olarak görülüyor.

► Güç Aktarımı ve Elektrik Makineleri: Güç kontrolü ve aktarılan güç miktarının ayarlanması da elektrik-elektronik dünyasında önemli unsurların başında geliyor. Yüksek frekanslı devrelerde PWM sinyal kontrolü sayesinde bu durum gerçekleşebiliyor.

Çeşitli devre yapılarına göre MOSFET veya IGBT kullanılabilirken giriş gücünü ayarlamak için de Varyak kullanılabiliyor. Ancak bazı devrelerde ise bu elemanlar istenilen fonksiyonu yerine getiremediğinde PWM kontrolüne başvuruluyor. Özellikle motor devir kontrolü için PWM tekniği sık sık karşımıza çıkıyor.

► Voltaj Regülatör Devreleri: Voltaj regülatör devrelerinde de PWM tekniğine başvurulabilir. Uygun görev döngüsüne anahtarlama yaparak voltajı kesme ve düzenleme işlemleri ile regüle edebilen PWM tekniği sonucunda bir takım elektronik gürültü oluşuyor. Ancak LC filtre ile bu durumu aşmak mümkün.

► Ses Efektleri ve Yükselticiler: Osilatörler ile birlikte bazı ses efektlerini elde etmek için PWM tekniği kullanılabiliyor. Aynı zamanda yükseltici devrelerinde ve amfilerde kontrol amacıyla da PWM tekniğine başvuru yapılabiliyor.

► Diğer Elektriksel Alanlar: Güneş enerji sistemlerinde ve rüzgar enerjisi sistemlerinde kullanılan mikro inverterlerin dizaynları PWM tekniğine uygun olarak gerçekleştirilir. Aynı zamanda PWM sinyali FET tipi transistörlere iletilir. Ayrıca PWM tekniği robotik devrelerde ve servo motor devrelerinde yine kontrol amacıyla kullanılabilir.

Arduino ile DC Motor Sürme

Arduino projeleri denildiğinde akla ilk gelen DC motorla kontrol edilen otonom araçlardır. Bu bölümde DC motorun Arduino ile nasıl kontrol edileceğini öğreneceğiz. DC motorun ileri veya geri dönmesinin yanında, dönme hızını da Arduino üzerinden kontrol edeceğiz. Arduino pinlerinden verilebilen akım motorları çalıştırmak için yeterli olmamaktadır. Bu

yüzden DC motorlar, motor sürücülerle kullanılmalıdır. Motor sürücüsü kullanmadan doğrudan motoru Arduino'ya bağlamak, Arduino'nun pinlerine zarar verebilir.

DC motorları kullanmak için motor sürücüsünü hazır devre kartı olarak alabileceğiniz gibi kendiniz de devreyi kurabilirsiniz. Fakat devre üzerinde çok fazla bağlantı olduğu için, devreye yeni fonksiyonlar da eklendiğinde devre karışıklığı artmaktadır. Sistemin nasıl çalıştığını kavrayabilmek için bir kereye mahsus olsa da devrenin hazır kart kullanılmadan kurulması yararlı olabilir. Bunun için aşağıdaki örnek verilmiştir:

DC Motor – H bridge L293D ile Kontrolü

/*

Adafruit Arduino - Lesson 15. Bi-directional Motor

*/

int enablePin = 11;

int in1Pin = 10;

int in2Pin = 9;

int switchPin = 7;

int potPin = 0;

void setup()

{

pinMode(in1Pin, OUTPUT);

pinMode(in2Pin, OUTPUT);

pinMode(enablePin, OUTPUT);

pinMode(switchPin, INPUT_PULLUP);

}

void loop()

{

int speed = analogRead(potPin) / 4;

boolean reverse = digitalRead(switchPin);

setMotor(speed, reverse);

}

 

Eğer motor sürücü devresi ile system kurmak istersek, 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.

L298 entegresi 4 giriş 4 çıkışa sahip H bridge (H köprü) motor sürücü entegresidir.L298 ile iki motoru birbirinden bağımsız olarak iki yöne sürmek mümkündür.Girişleri IN1-IN2-IN3-IN4 , çıkışları OUT1-OUT2-OUT3-OUT4 ile belirtilmiştir.IN1-IN2 pini OUT1-OUT2 çıkışlarını , IN3-IN4 pinleri OUT3-OUT4 çıkışlarını kontrol etmektedir.İki yöne dönebilen bir motor için iki kanala ihtiyaç duyulduğundan L298N ‘in 4 çıkışı ile 2 motor kontrol edilebilir.IN1den 5 volt uygulandığında OUT1 kanalında Vs pininden uygulanan gerilim görülür.Vs pininden uygulanan gerilimi ise enable pini kontrol eder.EnableA OUT1 ve OUT2 çıkışlarını , EnableB OUT3 ve OUT4 çıkışlarını kontrol etmektedir.Enable pinine 0-5 volt arası gerilim uygulanır.Enable pininden uygulanacak gerilim o enable’a bağlı çıkış kanalının beslemesini belirler.

int input1 = 3; // Arduino'nun 3. digital pinine bağlanmıştır.int input2 = 4; // Arduino'nun 4. digital pinine bağlanmıştır.int input3 = 5; // Arduino'nun 5. digital pinine bağlanmıştır.int input4 = 6; // Arduino'nun 6. digital pinine bağlanmıştır.

void setup() 

{      //Motorları sürmek için input pinleri çıkış olarak ayarlandı.  pinMode(input1,OUTPUT);pinMode(input2,OUTPUT);pinMode(input3,OUTPUT);pinMode(input4,OUTPUT);}void loop() {  //MOtorlar İleri  digitalWrite(input1,HIGH);  digitalWrite(input2,LOW);    digitalWrite(input3,HIGH);  digitalWrite(input4,LOW);    delay(1000);//1 saniye bekle    //Motorlar Geri  digitalWrite(input1,LOW);  digitalWrite(input2,HIGH);    digitalWrite(input3,LOW);  digitalWrite(input4,HIGH);  

  delay(1000);//1 saniye bekle}

Servo Motor

Servo motor 0 ila 180 derece arasında 1 derece hassasiyetle dönebilen motor çeşididir. Tam tur atamaz. Genellikle robot kol gibi tam tur dönmesine gerek olmayan, hassas açılı yerlerde kullanılır. Servo motor içerisinde bir adet DC motor bulunur. DC motorun ucuna bağlı dişli sisteminin yardımıyla servo mili daha fazla yük kaldırabilmektedir. Bu işlem

sırasında servonun dönüş hızı da yavaşlamış olur. Kullanılan dişli sistemine göre servo motorların kaldırabileceği yük değişir.

Servoların kaldırabileceği yük tork gücü üzerinden ifade edilir. Servo motorların torku, motor miline bağlı 1 cm uzunluğundaki çubuğun kaldırabileceği maksimum yük olarak tarif edilir. Piyasada bulunan servolar genellikle 1,4 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 */ }

 

Seri Port Üzerinden Haberleşme

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}

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.

Tıklama Sayacı

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.

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

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şme

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.

#include <SoftwareSerial.h>

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

Bluetooth ile İletişim

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.

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

 

Arduino üzerine doğrudan takılabilen Bluetooth Shield

Dikkat! 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.

Bluetooth Eşleştirmesi

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.

Telefon Kontrollü Işık Projesi

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.

#include <SoftwareSerial.h>

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

Harici Motor Sürücü KullanımıShield motor sürücülere göre daha ucuz olduğu için harici motor sürücüler proje bütçesine göre tercih edilebilmektedir. Harici motor sürücüler, bu bölümde gösterilen kendinizin kurabileceği motor sürücülerin hazır kart şekline getirilmiş halidir. Bu sürücülerde INPUT, OUTPUT, ENABLE ve besleme pinleri bulunur. INPUT pinleri daha önce öğrendiğimiz gibi yön kontrolünde, ENABLE pinleri motorların dönme hızını kontrol etmede kullanılır.

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

// Simple Motor Shield sketch

// -----------------------------------//// By arduino.cc user "Krodal".// June 2012// Open Source / Public Domain//// Using Arduino 1.0.1//// A simple sketch for the motor shield,// without using the Adafruit library.//// The outputs can be used for DC-motors // (either full H-bridge or just On and Off), lights, // relays, solenoids, etc.// But stepper motors can not be used !// Servo motors can be used with the default Servo library.//// A maximum of 4 DC motors can be used with full-bridge,// or a maximum of 8 normal outputs, or a combination.// Two servo motors can always be used, they use the +5V // of the Arduino board, so the voltage regulator could // get hot.//// Tested with an Ebay clone with the Arduino Uno.//// Parts of the code are from an old Adafruit Motor Shield// library, which was public domain at that time.// This code is also public domain//// This simplified program is using the normal // Arduino library functions as much as possible.//// The motors will make a whistling sound, // due to the analogWrite() PWM frequency.// The Adafruit library is specifically designed to avoid// this, so use the Adafruit library for a better result.//////// Connector usage// ---------------// The order is different than what you would expect.// If the Arduino (Uno) board is held with the USB// connector to the left, the positive (A) side is // at the top (north), and the negative (B) side is // the bottom (south) for both headers.//// Connector X1:// M1 on outside = MOTOR1_A (+) north// M1 on inside = MOTOR1_B (-)// middle = GND// M2 on inside = MOTOR2_A (+)// M2 on outside = MOTOR2_B (-) south//// Connector X2:// M3 on outside = MOTOR3_B (-) south

// M3 on inside = MOTOR3_A (+)// middle = GND// M4 on inside = MOTOR4_B (-)// M4 on outside = MOTOR4_A (+) north////// -------------------------------// | -+s |// | -+s |// M1 A | | M4 A// M1 B | | M4 B// GND | | GND// M2 A | | M3 A// M2 B | | M3 B// | ..... |// -------------------------------// + - //////// Pin usage with the Motorshield// ---------------------------------------// Analog pins: not used at all// A0 ... A5 are still available// They all can also be used as digital pins.// Also I2C (A4=SDA and A5=SCL) can be used.// These pins have a breadboard area on the shield.// Digital pins: used: 3,4,5,6,7,8,9,10,11,12// Pin 9 and 10 are only used for the servo motors.// Already in use: 0 (RX) and 1 (TX).// Unused: 2,13// Pin 2 has an soldering hole on the board, // easy to connect a wire.// Pin 13 is also connected to the system led.// I2C is possible, but SPI is not possible since // those pins are used.//

#include <Servo.h>

// Arduino pins for the shift register#define MOTORLATCH 12#define MOTORCLK 4#define MOTORENABLE 7#define MOTORDATA 8

// 8-bit bus after the 74HC595 shift register // (not Arduino pins)// These are used to set the direction of the bridge driver.#define MOTOR1_A 2#define MOTOR1_B 3#define MOTOR2_A 1#define MOTOR2_B 4#define MOTOR3_A 5

#define MOTOR3_B 7#define MOTOR4_A 0#define MOTOR4_B 6

// Arduino pins for the PWM signals.#define MOTOR1_PWM 11#define MOTOR2_PWM 3#define MOTOR3_PWM 6#define MOTOR4_PWM 5

#define SERVO1_PWM 10#define SERVO2_PWM 9

// Codes for the motor function.#define FORWARD 1#define BACKWARD 2#define BRAKE 3#define RELEASE 4

// Declare classes for Servo connectors of the MotorShield.//Servo servo_1;//Servo servo_2;

void setup(){ Serial.begin(9600); Serial.println("Simple Motor Shield sketch");

// Use the default "Servo" library of Arduino. // Attach the pin number to the servo library. // This might also set the servo in the middle position. //servo_1.attach(SERVO1_PWM); // servo_2.attach(SERVO2_PWM);}

void loop(){ // Suppose there are two servo motors connected. // Let them move 180 degrees. //servo_1.write(0); //delay(1000); //servo_1.write(180); //delay(2000);

//servo_2.write(0); //delay(1000); //servo_2.write(180); //delay(2000);

// Suppose there is a relay, or light or solenoid // connected to M3_A and GND. // Note that the 'speed' (the PWM, the intensity)

// is for both M3_A and M3_B. // The output is a push-pull output (half bridge), // so it can also be used to drive something low. // The 'speed' (the PWM, the intensity) can be set // to zero, that would make the output disabled // and floating. //motor_output(MOTOR3_A, HIGH, 255); //delay(2000); //motor_output(MOTOR3_A, LOW, 255);

// Suppose a DC motor is connected to M1_A(+) and M1_B(-) // Let it run full speed forward and half speed backward. // If 'BRAKE' or 'RELEASE' is used, the 'speed' parameter // is ignored. //motor(3, FORWARD, 255); //delay(2000); // Be friendly to the motor: stop it before reverse. //motor(3, RELEASE, 0); //delay(500); //motor(3, BACKWARD, 255); //delay(2000); //motor(3, RELEASE, 0); // motor(2, FORWARD, 255); //delay(2000); // Be friendly to the motor: stop it before reverse. //motor(2, RELEASE, 0); //delay(500); //motor(2, BACKWARD, 255); //delay(2000); //motor(2, RELEASE, 0); char input; if (Serial.available()) { // read the most recent character input = Serial.read(); // switch based on the character switch(input){ case 'F': // forward motor(3, FORWARD, 255); motor(2, FORWARD, 255); Serial.println("Forward"); delay(1500); break; case 'B': // backwards motor(3, BACKWARD, 255); motor(2, BACKWARD, 255); Serial.println("Backward"); delay(1500); break; case 'S': // stop motor(3, RELEASE, 255);

motor(2, RELEASE, 255); Serial.println("Stop"); delay(1500); break; case 'L': // left motor(3, FORWARD, 255); motor(2, BACKWARD, 255); Serial.println("Left"); delay(1500); break; case 'R': // right motor(3, BACKWARD, 255); motor(2, FORWARD, 255); Serial.println("Right"); delay(1500); break; default: // if character not recognized then stop motor(3, RELEASE, 255); motor(2, RELEASE, 255); Serial.println("Dont understand"); delay(1500); break; } } }

// Initializing// ------------// There is no initialization function.//// The shiftWrite() has an automatic initializing.// The PWM outputs are floating during startup, // that's okay for the Motor Shield, it stays off.// Using analogWrite() without pinMode() is valid.//

// ---------------------------------// motor//// Select the motor (1-4), the command, // and the speed (0-255).// The commands are: FORWARD, BACKWARD, BRAKE, RELEASE.//void motor(int nMotor, int command, int speed){ int motorA, motorB;

if (nMotor >= 1 && nMotor <= 4) { switch (nMotor) {

case 1: motorA = MOTOR1_A; motorB = MOTOR1_B; break; case 2: motorA = MOTOR2_A; motorB = MOTOR2_B; break; case 3: motorA = MOTOR3_A; motorB = MOTOR3_B; break; case 4: motorA = MOTOR4_A; motorB = MOTOR4_B; break; default: break; }

switch (command) { case FORWARD: motor_output (motorA, HIGH, speed); motor_output (motorB, LOW, -1); // -1: no PWM set break; case BACKWARD: motor_output (motorA, LOW, speed); motor_output (motorB, HIGH, -1); // -1: no PWM set break; case BRAKE: // The AdaFruit library didn't implement a brake. // The L293D motor driver ic doesn't have a good // brake anyway. // It uses transistors inside, and not mosfets. // Some use a software break, by using a short // reverse voltage. // This brake will try to brake, by enabling // the output and by pulling both outputs to ground. // But it isn't a good break. motor_output (motorA, LOW, 255); // 255: fully on. motor_output (motorB, LOW, -1); // -1: no PWM set break; case RELEASE: motor_output (motorA, LOW, 0); // 0: output floating. motor_output (motorB, LOW, -1); // -1: no PWM set break; default: break; } }}

// ---------------------------------// motor_output

//// The function motor_ouput uses the motor driver to// drive normal outputs like lights, relays, solenoids, // DC motors (but not in reverse).//// It is also used as an internal helper function // for the motor() function.//// The high_low variable should be set 'HIGH' // to drive lights, etc.// It can be set 'LOW', to switch it off, // but also a 'speed' of 0 will switch it off.//// The 'speed' sets the PWM for 0...255, and is for // both pins of the motor output.// For example, if motor 3 side 'A' is used to for a// dimmed light at 50% (speed is 128), also the // motor 3 side 'B' output will be dimmed for 50%.// Set to 0 for completelty off (high impedance).// Set to 255 for fully on.// Special settings for the PWM speed:// Set to -1 for not setting the PWM at all.//void motor_output (int output, int high_low, int speed){ int motorPWM;

switch (output) { case MOTOR1_A: case MOTOR1_B: motorPWM = MOTOR1_PWM; break; case MOTOR2_A: case MOTOR2_B: motorPWM = MOTOR2_PWM; break; case MOTOR3_A: case MOTOR3_B: motorPWM = MOTOR3_PWM; break; case MOTOR4_A: case MOTOR4_B: motorPWM = MOTOR4_PWM; break; default: // Use speed as error flag, -3333 = invalid output. speed = -3333; break; }

if (speed != -3333) { // Set the direction with the shift register // on the MotorShield, even if the speed = -1. // In that case the direction will be set, but

// not the PWM. shiftWrite(output, high_low);

// set PWM only if it is valid if (speed >= 0 && speed <= 255) { analogWrite(motorPWM, speed); } }}

// ---------------------------------// shiftWrite//// The parameters are just like digitalWrite().//// The output is the pin 0...7 (the pin behind // the shift register).// The second parameter is HIGH or LOW.//// There is no initialization function.// Initialization is automatically done at the first// time it is used.//void shiftWrite(int output, int high_low){ static int latch_copy; static int shift_register_initialized = false;

// Do the initialization on the fly, // at the first time it is used. if (!shift_register_initialized) { // Set pins for shift register to output pinMode(MOTORLATCH, OUTPUT); pinMode(MOTORENABLE, OUTPUT); pinMode(MOTORDATA, OUTPUT); pinMode(MOTORCLK, OUTPUT);

// Set pins for shift register to default value (low); digitalWrite(MOTORDATA, LOW); digitalWrite(MOTORLATCH, LOW); digitalWrite(MOTORCLK, LOW); // Enable the shift register, set Enable pin Low. digitalWrite(MOTORENABLE, LOW);

// start with all outputs (of the shift register) low latch_copy = 0;

shift_register_initialized = true; }

// The defines HIGH and LOW are 1 and 0. // So this is valid. bitWrite(latch_copy, output, high_low);

// Use the default Arduino 'shiftOut()' function to // shift the bits with the MOTORCLK as clock pulse. // The 74HC595 shiftregister wants the MSB first. // After that, generate a latch pulse with MOTORLATCH. shiftOut(MOTORDATA, MOTORCLK, MSBFIRST, latch_copy); delayMicroseconds(5); // For safety, not really needed. digitalWrite(MOTORLATCH, HIGH); delayMicroseconds(5); // For safety, not really needed. digitalWrite(MOTORLATCH, LOW);}

ARDUİNO ETHERNET UYGULAMASI – LED TOGGLE30 OCAK 2013 ADMİN 1 YORUM

Bu uygulamada Arduino Ethernet Shield kullanarak, web üzerinden led yakıp söndüreceğiz.

Ethernet Shield R3Ethernet katmanımızı Arduino kartımızın üstüne takıyoruz. LED bağlantılarını şekilde ki gibi yapıyoruz.

Led bağlantılarımızı sırasıyla 1.LED +’sı -> D2 2.LED +’sı -> D3 3.LED +’sı -> D4 4.LED +’sı -> D5

…. şeklinde yapıyoruz. Bu şekilde istediğimiz kadar led bağlayabiliriz. Bağladığımız

led sayısı kadar programı düzenlememiz gerekir. Bizim kodumuz 8 led içinLED yakıp söndürme işlemimizi toggle kütüphanesiyle yapıcaz. Toggle geçerli durumun tersine dönmesini sağlar. Yani LED yanıyor (HIGH-1 durumunda)  ise toggle işleminden sonra LED söner (LOW-0). Tekrar toggle işlemine girince de LED yanar.

Toggle kütüphanesini buradan   edinebilirsiniz. Zip dosyasının içindeki klasörü Arduino>Libraries klasörüne kopyalayın.Ethernet katmanımızın (shield) ayarlarını yapmak için öncelikle bilgisayarımızın ağ bilgisini öğrenmemiz lazım.

Yerel Ağ Bağlantısı > Ayrıntılar > IPv4 adresine ve ağ maskesine bakın. Buradan router’ımızın adresini öğreniyoruz. Genellikle 192.168.1.xx şeklinde

olur. Daha sonra Arduino’muza uygun boş bir ip veriyoruz 192.168.1.yyArduino’nun ip adresi ve router adresi için IPv4 Adresinin ilk 3 kısmı aynı olmalı 4.kısım değişmeli yani;

byte ip[] = { 192, 168, 1, 199 };               //arduino için ip adresibyte gateway[] = { 192, 168, 1, 50 };     //router için ip adresi

Ağ maskesinin ise birebir aynı olması gerekiyor.Yani;

byte subnet[] = { 255, 255, 255, 0 };     //ağ maskesi

Ağ bilgilerini de elde ettikten sonra şimdi sıra program kısmında

Kod:

Source code      

#include <Ethernet. h>

 

#include <SPI. h>

#include <DigitalToggle. h>

boolean reading = false;

byte ip[] = { 192, 168, 1, 199 }; //arduino için ip adresi

byte gateway[] = { 192, 168, 1, 50 }; //router için ip adresi

byte subnet[] = { 255, 255, 255, 0 }; //ağ maskesi

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };// Ethernet entegresinin fiziksel adresi

Server server = Server(80); // Server portu 80

 

void setup(){

//10,11,12 & 13 ethernet katmanı tarafından kullanılıyor

 

//LED bağlantılarımız

 

pinMode(2, OUTPUT);

pinMode(3, OUTPUT);

pinMode(4, OUTPUT);

pinMode(5, OUTPUT);

pinMode(6, OUTPUT);

pinMode(7, OUTPUT);

pinMode(8, OUTPUT);

pinMode(9, OUTPUT);

 

//Ethernet başlatılıyor

 

Ethernet.begin(mac, ip, gateway, subnet);

server.begin();

}

 

void loop()

 

{

Client client = server.available();

 

if (client) {

 

boolean currentLineIsBlank = true;

boolean sentHeader = false;

 

while (client.connected()) {

 

if (client.available()) {

 

if(!sentHeader){

 

//HTML başlığı ekleniyor

 

client.println("HTTP/1.1 200 OK");

 

client.println("Content-Type: text/html");

client.println();

sentHeader = true;

}

 

char c = client.read(); //okunan değeri stringe ata

 

if(reading && c == ' ') reading = false;

if(c == '?') reading = true; //? bulundu pin numarasını belirle

 

if(reading){   //bir değer girildiyse

Serial.print(c);  //değeri ekranı yazdır

 

switch (c) {  //değere göre karşılık gelen ledi yak

case '2':

//2 numara toggle

triggerPin(2, client);

break;

case '3':

//3 numara toggle

triggerPin(3, client);

break;

case '4':

//4 numara toggle

triggerPin(4, client);

break;

case '5':

//5 numara toggle

triggerPin(5, client);

break;

case '6':

//6 numara toggle

triggerPin(6, client);

break;

case '7':

//7 numara toggle

triggerPin(7, client);

break;

case '8':

//8 numara toggle

triggerPin(8, client);

break;

case '9':

//9 numara toggle

triggerPin(9, client);

break;

}

 

}

 

if (c == 'n' && currentLineIsBlank) break;

 

if (c == 'n') {

currentLineIsBlank = true;

}else if (c != 'r') {

currentLineIsBlank = false;

}

}

}

delay(1); // bekle

client.stop(); // iletişimi kapat:

}

}

void triggerPin(int pin, Client client){

 

//Sayfa üstünde yazdırılacaklar

 

client.println(pin);

client.print("Numarali Led Toggle");

client.print(" 

");

digitalToggle(pin);

}

 Bilgisayar ile Internet Explorer ya da benzeri bir program ile aşağıdaki resimde gösterildiği gibi Arduino için atadığınız ip adresine ulaşırsanız boş bir ekran çıkacaktır. Yani http://192.168.1.199/ adresine ulaşabiliyorsanız tüm bağlantılarınız ve işlemleriniz doğru demektir.

Kodumuz http://192.168.1.199/?Lednumarası mantığı ile çalışmaktadır.

Yani http://192.168.1.199/?3 yazdığınızda dijital 3. pine bağlı olan Led aktif olacaktır.

http://192.168.1.199/?234 yazdığınızda ise 2. 3. ve 4. pinlerdeki Ledler aktif olacaktır.

ethernet shield kartı kullanarak ip üzerinden kameradan görüntü almak

Malzemeler:

1. Arduino

2. Arduino Ethernet Shield

3. Serial kamera

Kamera Kod

12345678

#include <Adafruit_VC0706.h>#include <SPI.h>#include <SdFat.h>#include <SdFatUtil.h>#include <Ethernet.h>#include <SoftwareSerial.h> // Arduino Ethernet shield: pin 4#define chipSelect 4

9101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354

// Using SoftwareSerial (Arduino 1.0+) or NewSoftSerial (Arduino 0023 & prior):#if ARDUINO >= 100// On Uno: camera TX connected to pin 2, camera RX to pin 3:SoftwareSerial cameraconnection = SoftwareSerial(2, 3);// On Mega: camera TX connected to pin 69 (A15), camera RX to pin 3://SoftwareSerial cameraconnection = SoftwareSerial(69, 3);#elseNewSoftSerial cameraconnection = NewSoftSerial(2, 3);#endif Adafruit_VC0706 cam = Adafruit_VC0706(&cameraconnection); /************ ETHERNET STUFF ************/byte mac[] = {0x90,0xa2,0xda,0x0e,0xf7,0xfc};byte ip[] = {192, 168, 0, 30};char rootFileName[] = "index.htm";EthernetServer server(80); /************ SDCARD STUFF ************/SdFat SD;Sd2Card card;SdVolume volume;SdFile root;SdFile file; // store error strings in flash to save RAM#define error(s) error_P(PSTR(s))void error_P(const char* str) {PgmPrint("error: ");SerialPrintln_P(str);if (card.errorCode()) {PgmPrint("SD error: ");Serial.print(card.errorCode(), HEX);Serial.print(',');Serial.println(card.errorData(), HEX);}while(1);} /**********************SETUP()*********************/ void setup() {#if !defined(SOFTWARE_SPI)#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)if(chipSelect != 53) pinMode(53, OUTPUT); // SS on Mega#elseif(chipSelect != 10) pinMode(10, OUTPUT); // SS on Uno, etc.#endif#endif PgmPrint("Free RAM: ");Serial.println(FreeRam());pinMode(10, OUTPUT);digitalWrite(10, HIGH);

555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100

 if (!card.init(SPI_HALF_SPEED, 4)) error("card.init failed!");if (!volume.init(&card)) error("vol.init failed!"); PgmPrint("Volume is FAT");Serial.println(volume.fatType(),DEC);Serial.println(); if (!root.openRoot(&volume)) error("openRoot failed"); PgmPrintln("Files found in root:");root.ls(LS_DATE | LS_SIZE);Serial.println(); PgmPrintln("Files found in all dirs:");root.ls(LS_R); Serial.println();PgmPrintln("Done");Serial.begin(9600);Serial.println("VC0706 Camera snapshot test");if (!SD.begin(chipSelect)) {Serial.println("Card failed, or not present");return;}Ethernet.begin(mac, ip);server.begin();} #define BUFSIZ 100 /**********************LOOP()*********************/ void loop() {char clientline[BUFSIZ];char *filename;int index = 0;int image = 0; EthernetClient client = server.available();if (client) {boolean current_line_is_blank = true;index = 0;while (client.connected()) {if (client.available()) {char c = client.read();if (c != '\n' && c != '\r') {clientline[index]= c;index++;if (index >= BUFSIZ)index = BUFSIZ -1;continue;}clientline[index]= 0;

101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146

filename = 0;Serial.println(clientline);if (strstr(clientline, "GET / ") != 0) {filename = rootFileName;}if (strstr(clientline, "GET /") != 0) {if (!filename) filename = clientline + 5;(strstr(clientline, " HTTP"))[0] = 0;Serial.println(filename);if (strstr(filename, "tttt") != 0)takingPicture();if (strstr(filename, "rrrr") != 0)removePicture();if (! file.open(filename, O_READ)) {client.println("HTTP/1.1 404 Not Found");client.println("Content-Type: text/html");client.println();client.println("File Not Found!");break;} Serial.println("Open!");client.println("HTTP/1.1 200 OK");if(strstr(filename, ".css") != 0)client.println("Content-Type: text/css");else if (strstr(filename, ".htm") != 0)client.println("Content-Type: text/html");else if (strstr(filename, ".jpg") != 0)client.println("Content-Type: image/jpeg");client.println(); int16_t c;while ((c = file.read()) >= 0) {Serial.print((char)c);client.print((char)c);}file.close();}else {// everything else is a 404client.println("HTTP/1.1 404 Not Found");client.println("Content-Type: text/html");client.println();client.println("File Not Found!");}break;}}delay(1000);client.stop();}} /**********************FUNCTION1()*********************/ void takingPicture(){

147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190

if (cam.begin()) {Serial.println("Camera Found:");} else {Serial.println("No camera found?");return;}char *reply = cam.getVersion();if (reply == 0) {Serial.print("Failed to get version");} else {Serial.println("-----------------");Serial.print(reply); Serial.println("-----------------");}//cam.setImageSize(VC0706_640x480); // biggestcam.setImageSize(VC0706_320x240); // medium//cam.setImageSize(VC0706_160x120); // small uint8_t imgsize = cam.getImageSize();Serial.print("Image size: ");if (imgsize == VC0706_640x480) Serial.println("640x480");if (imgsize == VC0706_320x240) Serial.println("320x240");if (imgsize == VC0706_160x120) Serial.println("160x120"); Serial.println("Snap in 3 secs...");delay(3000);cam.takePicture();Serial.println("taking picture"); file.open("IMAGE.jpg", O_RDWR | O_CREAT); uint16_t jpglen = cam.frameLength();pinMode(8, OUTPUT); byte wCount = 0;while (jpglen > 0) {uint8_t *buffer;uint8_t bytesToRead = min(32, jpglen);buffer = cam.readPicture(bytesToRead);file.write(buffer, bytesToRead);if(++wCount >= 64) {Serial.print('.');wCount = 0;}jpglen -= bytesToRead;}file.close();Serial.println("end of taking picture");}/**********************FUNCTION2()*********************/void removePicture(){file.open("IMAGE.jpg", O_READ | O_WRITE);file.remove();}

IOT ‘ ye Giriş

İlk örneği 1990 yılında kahve makinesinin boş olup olmadığını kontrol edebilmek için kurulan kameralı sistem ile fikir olarak ortaya çıkan nesnelerin interneti daha sonradan asıl adını almaya başladı. Orijinal ismi internet of things (IoT) olan ‘’Nesnelerin İnterneti’’ kavramı teknoloji öncülerinden Kevin Ashton tarafından ilk defa 1999 yılında ortaya atıldı. ‘Nesnelerin interneti nedir?’ derseniz ‘’Cihazların birbirleri arasında iletişim kurması mantığına dayanarak kullanıcıların hayatlarını kolaylaştıran bir teknolojidir. ‘’ tanımını yapabiliriz.

Günümüzdeki Durum nedir?Yapılan araştırmalara göre bugün internete 10-11 milyar cihazın bağlı olduğu tahmin edilmekte ve bu rakamın 2020 yılına gelindiğinde 50 milyar cihaz seviyesine çıkması öngörülmektedir. Aynı araştırmalara göre; 2003 yılında dünyada kişi başına düşen birbirleriyle bağlantılı cihaz oranı 0,08 iken bu oranın 2020 tahmini ise "6,48"dir. Ayrıca 2020 yılında, 20 adet tipik ev cihazının üreteceği bilgi trafiğinin, 2008 yılında üretilen tüm internet trafiğinden daha fazlaolacağı tahmin edilmektedir

.

Nesnelerin interneti konusuna girişte benim önerim ESP8266 serisidir. Birçok pine sahip olan esp’nin 12 serisini kullanmanızı tavsiye ederim. Kullanımı en rahat olarak üzerinde herşeyi hazır olan Nodemcu nasıl kullanılır nerelerde kullanılır bunları göreceğiz.

Esp 12 herhangi bir işlemciye gerek duymadan tek başına çalışabiliyor.Bir arduino gibi kullanabildiğimiz modülde analog/digital giriş ve çıkışların bulunduğu pinler var.Bu pinlerden sensör okuyabilir, motor sürebilir yada dünyanın diğer ucuna bir veri gönderebiliriz. Proglamlamasını arduino IDE kullanarak rahatça yapabilirsiniz.

Esp8266 ile en rahat kullanılan portal ‘’blynk” adı verilen uygulama. Google Play’ den inirip kaydolup hemen kullanmaya başlayabilirsiniz.

NODEMCU BLYNK UYGULAMA 1 LED YAKMAArduino’ya blynk kütüphanesini yüklemekle başlayalım işe. Kütüphane’yi gitub’tan indirebilirsiniz.( https://github.com/blynkkk/blynk-library) arduinoya blynk kütüphanesini yükledikten sonra esp’yi arduinoda board kısmında görebilmek için esp’yi tercihler kısmından eklemek gerekli.

( http://arduino.esp8266.com/stable/package_esp8266com_index.json)

Kütüphaneyi ve esp’yi arduinoya yükledikten sonra örneklere başlayabiliriz.

Token kodunu blynk’e üye olduktan sonra ekranda görebilirsiniz.Token kodunu yazdıktan sonra esp’yi internete bağlamak için sizin internet bağlantınızın adını ve şifresini doğru bir şekilde girin. Araçlardan kartı ve portu seçtikten sonra kodu yükleyin.

Kodu yükledikten sonra uygulamayı açın ve bir buton seçin. Seçtiğiniz butonun üzerine dokunarak hangi pini aktif hale getirecek seçebilirsiniz. Seçtiğiniz pine bir led bağlarsanız internete bağlı olduğunuz sürece o ledi istediğiniz yerden açıp kapatırsınız.

LED’s Control through TTY

HW setup

I added a blue LED to make the demo more fun.  Here is what I have now….

Note: I stopped using the 9V battery (as I had posted earlier).  It was getting drained to fast so using the 5V output from the Arduino board that is then regulated down to 3.3V using my home mode variable voltage regulator (described in my previous post: Mini Power supply from LM317T)

SW setup

The code is pretty straight forward if you have been following my previous post referenced above in “The Plan” section.  I start up the sever –> wait for incoming string –> if some key words are found, do something to IO’s connected to 3 LED’s.  The actual code is at the bottom of this post.

Testing

The testing steps will be:

1. Start up the Arduino and ESP8266 with the code below loaded.  This should get my ESP8266 on my Wifi network.

2. Use TeraTerm to open a raw TCP/IP connection3. Type in key words to control various LED.4. Watch LED light show.

5. Code used for this post6. /*

7. Try to start the server autonomously8. */9. #include <SoftwareSerial.h>10.#include <string.h>11.12.#define TIMEOUT 5000 // mS13.#define GREENLED 414.#define REDLED 515.#define BLUELED 316.17.SoftwareSerial mySerial(7, 6); // RX, TX18.19.20.21.void setup() 22. {23. pinMode(REDLED,OUTPUT); 24. pinMode(GREENLED,OUTPUT);25. Serial.begin(9600);26. mySerial.begin(9600);27. mySerial.setTimeout(100);28.29. int CommandStep = 1;30. 31. //This initializes the Wifi Module as a server 32. BlinkLED(REDLED,CommandStep,50); 33. SendCommand("AT+RST", "Ready", true);34. BlinkLED(GREENLED,CommandStep,50);35. CommandStep++;36. 37. 38. 39. BlinkLED(REDLED,CommandStep,50); 40. SendCommand("AT+GMR", "OK", true);41. BlinkLED(GREENLED,CommandStep,50);42. CommandStep++;43. 44. delay(5000);45. 46. BlinkLED(REDLED,CommandStep,50); 47. SendCommand("AT+CIFSR", "OK", true);48. BlinkLED(GREENLED,CommandStep,50);49. CommandStep++;50. 51. 52. BlinkLED(REDLED,CommandStep,50);

53. SendCommand("AT+CIPMUX=1","OK",true);54. BlinkLED(GREENLED,CommandStep,50);55. CommandStep++;56. 57. BlinkLED(REDLED,CommandStep,50); 58. SendCommand("AT+CIPSERVER=1,22","OK",true);59. BlinkLED(GREENLED,CommandStep,50);60. //----------------------------------------------------61. 62. }63.64.void loop(){65. String IncomingString="";66. char SingleChar;67. boolean StringReady = false;68. 69.70. while (mySerial.available()) 71. {72. IncomingString=mySerial.readString();73. StringReady= true; 74. }75. 76. //********** Only run when string is available ************//77. if (StringReady){78. Serial.println("Received String: " + IncomingString); 79.80. if ((IncomingString.indexOf("xmas") != -1) || (IncomingString.indexOf("christmas")

!= -1 )) {81. int loopdelay = 50;82. for (int x=1; x <= 50 ; x ++){83. digitalWrite(REDLED,HIGH);84. delay(loopdelay);85. digitalWrite(GREENLED,HIGH);86. delay(loopdelay);87. digitalWrite(BLUELED,HIGH);88. delay(loopdelay);89. digitalWrite(REDLED,LOW);90. delay(loopdelay);91. digitalWrite(GREENLED,LOW);92. delay(loopdelay);93. digitalWrite(BLUELED,LOW); 94. } 95. }96.97.

98. if ((IncomingString.indexOf("red") != -1) || (IncomingString.indexOf("all") != -1)) {99. Serial.println("Someone trying to control RED LED");100. ProcessLEDCommand(REDLED, IncomingString);101. }102.103. if ((IncomingString.indexOf("green") != -1) || (IncomingString.indexOf("all") != -

1)) {104. Serial.println("Someone trying to control GREEN LED");105. ProcessLEDCommand(GREENLED, IncomingString);106. }107. if ((IncomingString.indexOf("blue") != -1) || (IncomingString.indexOf("all") != -1))

{108. Serial.println("Someone trying to control YELLOW LED");109. ProcessLEDCommand(BLUELED, IncomingString);110. }111. }112.113.114.115. //************************************************************116. }117.118. void ProcessLEDCommand(int LEDPin, String IncomingString){119. if (IncomingString.indexOf("on") != -1) {120. Serial.println("Someone trying to turn on LED");121. digitalWrite(LEDPin,HIGH);122. }123. if (IncomingString.indexOf("off") != -1) {124. Serial.println("Someone trying to turn off LED");125. digitalWrite(LEDPin,LOW);126. }127. if (IncomingString.indexOf("blink") != -1) {128. Serial.println("Someone trying to blink LED");129. BlinkLED(LEDPin,5,200); 130. }131. }132.133.134. void BlinkLED(int LEDPin, int NumberOfBlinks, int OnDuration)135. {136. for (int x=1; x <= NumberOfBlinks ; x ++){137. digitalWrite(LEDPin,HIGH);138. delay(OnDuration);139. digitalWrite(LEDPin,LOW);140. delay(OnDuration); 141. }

142. }143.144.145. boolean SendCommand(String cmd, String ack, boolean halt_on_fail)146. {147. mySerial.println(cmd); // Send "AT+" command to module148.149. // Otherwise wait for ack.150. if (!echoFind(ack)) // timed out waiting for ack string151. if (halt_on_fail)152. errorHalt(cmd+" failed");// Critical failure halt.153. else154. return false; // Let the caller handle it.155. return true; // ack blank or ack found156. }157.158. // Read characters from WiFi module and echo to serial until keyword occurs or

timeout.159. boolean echoFind(String keyword)160. {161. byte current_char = 0;162. byte keyword_length = keyword.length();163. 164. // Fail if the target string has not been sent by deadline.165. long deadline = millis() + TIMEOUT;166. while(millis() < deadline)167. {168. if (mySerial.available())169. {170. char ch = mySerial.read();171. Serial.write(ch);172. if (ch == keyword[current_char])173. if (++current_char == keyword_length)174. {175. Serial.println();176. return true;177. }178. }179. }180. return false; // Timed out181. }182.183. // Print error message and loop stop.184. void errorHalt(String msg)185. {186. Serial.println(msg);

187. Serial.println("HALT");188. digitalWrite(REDLED,HIGH);189. digitalWrite(GREENLED,HIGH);190. while(true){};191. }

LED’s Control Through ESP8266 + Arduino Web Page

The Web Page Implementation

I will use a HTML form to send a POST request back to the server.  If you are like me and not familiar with how this works, I will explain what I know and how I will try to get it to work.

First I found out how to create a form with radio buttons and a submit button.  Here is what the page looks like…

I found www.w3schools.com/tags/tag_form.asp that helped me write the HTML code for the above like this…<html>

<body>

<form action="" method="post">

<fieldset>

<legend>Red LED State</legend>

<input type="radio" name="RedLEDState" value="RED_ON"> ON

<input type="radio" name="RedLEDState" value="RED_OFF" checked="checked"> OFF<br>

</fieldset>

<fieldset>

<legend>Green LED State</legend>

<input type="radio" name="GreenLEDState" value="GREEN_ON"> ON

<input type="radio" name="GreenLEDState" value="GREEN_OFF" checked="checked"> OFF<br>

</fieldset>

<fieldset>

<legend>Blue LED State</legend>

<input type="radio" name="BlueLEDState" value="BLUE_ON"> ON

<input type="radio" name="BleuLEDState" value="BLUE_OFF" checked="checked"> OFF<br>

</fieldset>

<input type="submit" value="Submit">

</form>

</body>

</html>

The Server Implementation

Disclaimer: I am no expert.  Just sharing what I found through googl’ing and trial and error.When someone clicks the submit button in the form above, it will send a “POST” to the server.  This post will include the name / value pair as defined in the above.  Best to just show what my server sees when someone clicks the submit button above….

POST / HTTP/1.1

Host: 192.168.0.175

Connection: keep-alive

Content-Length: 64

Cache-Control: max-age=0

Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8

Origin: http://192.168.0.175

User-Agent: Mozilla/5.0 (Linux; Android 4.1.2; SPH-L300 Build/JZO54K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.93 Mobile Safari/537.36

Content-Type: application/x-www-form-urlencoded

Referer: http://192.168.0.175/

Accept-Encoding: gzip, deflate

Accept-Language: en-US,en;q=0.8

RedLEDState=RED_OFF&GreenLEDState=GREEN_ON&BlueLEDState=BLUE_OFF

Note the last line highlighted in cyan.  In this example, the RED and GREEN LED ON button would have been checked and the BLUE LED OFF button was checked.  I plan on using this request line to control the LED states.  The one side effect is that the browser is now waiting for a HTML response.  My simple hack to address this is to just re-send the same web page again for now.  Eventually I will add code pre-populate the radio buttons with the current state of the LED’s instead of all OFF.

The Hardware Setup

If you missed it in my earlier post…

Arduino + ESP8266 remote control LED using an Android App with Camera Live View

The Android App (built in AppInventor2)

The screen layout is made up of

6 buttons to turn on/off 3 LED’s.  The buttons are just sending custom WebPutText keywords.

A WebViewer element which loads will load web page defined in text box element when the Go button is clicked.

Another text box to specify the web address of the Arduino + ESP8266 system.Here is what is looks like….

The AppInventor code to point the Web component to the ESP8266/Arduino server will set the Web1 URL to point to the web address that is entered in the corresponding text box.  I was running out of screen space and didn’t want to have to add another button so I just have the code run after the address is typed into the box and something else on the screen is touched.  It looks like this…

The code to start up the live camera view is really just creating a Webviewer window which will display the web site specified in the corresponding text box whenever the Go button is clicked.  The rest is really up to the Foscam camera to serve up the live stream….

The LED controls are just sending some custom strings using the Web.PutText function. I am using “PtcApp” as a keyword that is not likely to be seen by the server that I can key off of.  I follow up “PtcApp” keyword with a code for the {first letter of the LED color}:{1 for on / 0 for off}.  The magic will happen on the upcoming Arduino code.  Here is the AppInventor code….

The Arduino Code

I am only going to cover the additional Arduino code I add to implement the AppInventor functionality here.  The rest of the program has been detailed in many of my previous post.

The first step is really simple.  I just added another parser block to look for “PtcApp” in the incoming line from the ESP8266.  I left all the previous parsing blocks and function so that all the previous features will still continue working (ie: the web page interface is still fully functional).   Once the “PtcApp” is found, I call a function to parse out which color LED to control and if it is a request for On or OFF.  Here is the code snips….

if (InLine.indexOf("PtcApp ") != -1) {

CommandQue[QueIn++]=PUT_REQUEST; //** See next section in post for what this is for ** ParseCustomAppRequest(InLine); UpdateLCDStats(); NumberAppReq++; UpdateLCDStats(); }....//*** This parses out the LED control strings from custom Android App and sets the appropriate state vars *** void ParseCustomAppRequest(String InLine){

if (InLine.indexOf("R:0")!=-1) RED_State=false; if (InLine.indexOf("G:0")!=-1) GREEN_State=false; if (InLine.indexOf("B:0")!=-1) BLUE_State=false;

if (InLine.indexOf("R:1")!=-1) RED_State=true; if (InLine.indexOf("G:1")!=-1) GREEN_State=true; if (InLine.indexOf("B:1")!=-1) BLUE_State=true;}

The First Test

This all actually started working very well initially.  Everything worked pretty much on the first attempt, but after 5 LED change requests from the Android App, the ESP8266+Arduino stopped seeing any more requests.

Debugging the logs, I found that each PUT request was holding an additional IPD channel open.  (In case you haven’t been following my previous posts, an IPD channel is the ESP8266 way of handling multiple TCP clients.  Each channel corresponds to a client so the server can send messages to a specific client).  The ESP8266 seems to have a limit to only be able to hold open 5 open IPD channels and then stop accepting any more connections.

I remembered another similar situation where the client wasn’t closing the connection. It was because I wasn’t sending an HTTP header back for a GET request (see the “Extra Fix” section in my post “Arduino + ESP8266 Mini Server with Command Que“). Hoping it was the same problem I made a very simple HTTP header with 0 length response and send it back each time I get a PUT request…String PutResponse ="HTTP/1.0 200 OK \r\n"

"Date: Fri, 31 Dec 1999 23:59:59 GMT\r\n"

"Content-type: text/html\r\n"

"Content-length: 0\r\n"

"Connection: Closed\r\n"

"\r\n";

...

case PUT_REQUEST:

SendCIPChunk(PutResponse,CommandQueIPD_CH[QueOut]); // Send the CIPSEND command to respond to Put request

break;

Once I sent back the proper HTTP header, the client automatically closed the connection and all the requests from the AppInventor Web.PutText button clicks were coming in on IPD channel 0 consistently.  I was able to get the LED to change +100 times through a day of testing so I think it is pretty stable now.  :)

Voice Controlled Arduino Drone

Show All Items

The drones are very good toys and tools, but usually they haven’t any extra skills. I love to fly any R/C model and I just wanted to make a drone that’s a little bit smarter than the usual models. That’s why I developed this mini voice controlled tricopter robot. The main concept is pretty easy, the drone is based on an Arduino Pro Mini board, the

motors can be controlled through PWM pins. I made a bluetooth connection with my Android smartphone and using an app the phone transmits words through serial communucation to the HC-05 bluetooth module to the Arduino board. The best thing is that this project didn’t costs more than 11 dollars.

I made a “motor shield” or something like that using a few transistors that increase the current of the digital output pins. I used 2N2222, but would be better to use a SMD power transistort. The drone works well with both. The propellers and the motors are bought from eBay.

Some features:” speech controlled” Arduino Pro Mini based” voice recognition with a smatphone” moves left, right, backward, forward, upand down” hasn’t build in gyroscope, you should make a code that holds the drone in balance, this can be made after a few experiments” low weight, 22 grams, you can add 5 extra gramms

I made a tricopter because I have only 3 motors with propeller, but of course you can make a quad or hexcopter.You’ll need some experience in soldering, but isn’t so hard. Only the motor shield requires some skill.

Step 1: The Sofware

Show All Items

Before gathering materials write upload this code to your Arduino Mini Pro. If your drone is made perfectly this code will work. If isn’t you should modify the code at the end. To programm the Arduino Mini I used an Arduino Uno that was set on 3.3 volts.

1. Arduino Mini Pro to Arduino Uno

2. RX –> TX3. TX –> RX4. VCC –> 3.3v5. GND –> GND6. RST –> RSTNow upload the code and you’ll have a programmed board. I wrote some explanations in the sketch, but if you have questions feel free to ask. The Arduino analyzes the word through serial reading and reacts to them.

Step 2: How the code works?

The code is relatively simple. Analyzes the voice variable and reacts to them by controlling the motors. After turning left or right the Arduino quickly changes its value to the original, so your drone doesn’t need a gyroscope, because automatically turns back in his oroginal position thanked to the sofware. This makes your flight safe and

fun. 

//copy this code in the IDE

String voice;int motor1 = 3; //Connect motor 1 To Pin #3 left motor int motor2 = 9; //Connect motor 2 To Pin #9 rear motor int motor3 = 11; //Connect motor 3 To Pin #11, right motor

//————————–Call A Function——————————-//

//the values after each anlogWrite commands are controlling the motor’s speed, the max value is 255

//if your drone isn’t in balance try to modify the values, example change 130 to 135 if your drone goes backward

void middlespeed() { analogWrite(motor1, 130); analogWrite(motor2, 130); analogWrite(motor3, 130); } void fastspeed() { analogWrite(motor1, 255); analogWrite(motor2, 255); analogWrite(motor3, 255); }

void lowspeed() { analogWrite(motor1, 100); analogWrite(motor2, 100); analogWrite(motor3, 100);

} //———————————————————————–// void setup() { Serial.begin(9600); pinMode(motor1, OUTPUT); pinMode(motor2, OUTPUT); pinMode(motor3, OUTPUT); } //———————————————————————–// void loop() { while (Serial.available()) { //Check if there is an available byte to read delay(10); //Delay added to make thing stable char c = Serial.read(); //Conduct a serial read if (c == ‘#’) { break; //Exit the loop when the # is detected after the word } voice += c; //Shorthand for voice = voice + c } if (voice.length() > 0) { Serial.println(voice); //———————————————————————–// //———-Control motors———-// if (voice == “*start motors”) { lowspeed(); //The motors start spin, and the drone slowly comes downer if already flies } else if (voice == “*fly low”) { middlespeed(); //Fly the drone, stay in one place } else if (voice == “*fly higher”) { fastspeed(); //Maximum motor speed, the drone will go upward very fast }

//———-Directions———-// //The drone can be controlled the best in middlespeed state else if (voice == “*go left”) { analogWrite(motor1, 100); delay(450); analogWrite(motor1, 130); } else if (voice == “*go right”) { analogWrite(motor3, 100); delay(450); analogWrite(motor3,130); } else if (voice == “*go backward”) { analogWrite(motor2, 130); delay(300); analogWrite(motor2, 130); } else if (voice == “*go forward”) { analogWrite(motor2, 200); delay(350); analogWrite(motor2, 130); } else if (voice == “*right back”) { analogWrite(motor1, 200); delay(350); analogWrite(motor1, 130); } else if (voice == “*left back”) { analogWrite(motor3, 200); delay(350); analogWrite(motor3, 130); }

//———————————————————————–// voice = “”; } } //Reset the variable after initiating

Voice_Controlled_Drone.ino

Step 3: Parts and Tools

Show All Items

Tools:For this project you’ll need a soldering iron, a glue gun, a variable power supply unit and a PC with Arduino IDE.

Parts:

Main, most important parts:” Arduino Pro Mini 3.3v or similar clone” 3 Motors” HC-05 Bluetooth Module

Secondary parts:” 2N2222 transistors (local hobby-shop, $0.1)” 3 Propeller Blades (you can buy together with the motors)” A Battery (mine is from an MP3 Player)” Straws and a small lightweight plastic piece (from any store)” Rubberbands (from a store)” 100Ohm resistor (local hobby-shop, $0.05)

” Some Wires (local hobby-shop or salvage from other electronic stuff)

You can buy all main parts on the eBay. Click on it to open the link.

Step 4: Soldering…

Show All Items

Arduino Mini Pro to HC-05 RX –> TX TX –> RX VCC –> 3.3v GND –> GND

Solder the two circuits together using short wires. It’s very easy.

Step 5: How to build the tricopter’s frame?

Show All Items

Insert the motors in the bigger straws and glue a frame with the other straws, just like on the pictures. I bought very strong straws from a local supermarket and they hold the motors very strong, so they won’t fall down. Behind the design are a lot of physics calculations. I can’t explain these now formulas and rules but if you’re interested read this article. Using those formulas given in link, you can design an own frame and drone.

Step 6: The Rear Motor

Show All Items

You need to make a small difference between the vertical axis and the rear motor’s axis otherwise the drone will spin. 10 degrees are enough for this.

Step 7: Motors

Show All Items

You can see some metal sticks on the first picture, I plugged them into the endings of the motors. This is important, because you’ll have a joining piont for soldering.

Step 8: Check the polarity!

Show All Items

On the pictures you can see how my motors should spin. I used my PSU unit and tried out every motors on 2.1 volts.

Step 9: The “motor shield”

Show All Items

Now you should make a small circuit that can be easily attached to the Mini Pro board. The circuit schematic shows you the connections but I missed the 10kOhm resistor because its value is too high, so it’s better to use 100Ohm resistors. This circuit should be very small. Solder connection legs to the 9, 3, 11, GND and VCC pins just like me.

Step 10: Soldering the Transistors

Show All Items

The appearence of this circuit is bad, but it’s small and has a low weight. I soldered one more connector for the battery.

Step 11: Adding the Motors

Show All Items

And now it’s time to use your soldering skills to solder the motors to the positive voltage source and to theirs transistor’s collector. Sorry I haven’t more pictures for this step, but I hope it’s clear what should you do.

Step 12: The done circuit

Show All Items

The harder part is done. We are close to finish the project. Take your Arduino board and slowly connect to the motor shield. Be careful, do not damage or shortcircuit the circuits. Connect the battery to the device, and if the circuit’s power LED lights you did a good

job. 

Step 13: Stabilize the circuit!

Show All Items

Use two rubberbands and fix the circuit on the frame.

Step 14: The Application

Show All Items

Download this application from the Playstore: BT Voice Control for Arduino. Charge up your battery with a PSU or with a lithium polymer battery charger. If you’re done try it out.

Step 15: First Flight

Show All Items

As you can see at the first time I din’t flew very good, but later after an hour of practice I became a good pilot. Sorry for the bad pictures, but the drone moved in the air. I crashed a few times, but nothing happened with my new gadget.

Step 16: How to balance in the air?If your drone can’t stay in one place in the air modify the analogWrite values in the code.

Step 17: The End

Show All Items