ARDUİNO Kullanım Kılavuzu (Bütün Fonksiyonlar)

Arduino programları üç ana bölümden oluşabilir: yapı, değerler (değişkenler ve sabitler) ve fonksiyonlar(işlevler).

Aşağıdaki tablo https://www.arduino.cc/en/Reference/HomePage adresinin birebir kopyasıdır. Türkçeye çevrilmiştir.

BÖLÜM 1: YAPI
Kontrol Yapıları
Sentaks (Söz Dizimi)
Aritmatik Operatörler
Karşılaştırma Operatörleri
Boolean (Mantık) Operatörleri
İşaretçi Erişim Operatörleri (Pointerlar)
Bit Düzeyi Operatörleri
Bileşik Oparatörler

BÖLÜM 2: DEĞİŞKENLER
Sabitler
Veri Tipleri
Dönüşümler
Değişken Skop ve Niteleyiciler
Araçlar

BÖLÜM 3: FONKSİYONLAR
Dijital Giriş/Çıkış
Analog Giriş/Çıkış
Due ve Zero için
Gelişmiş Giriş/Çıkış
Zaman
Matematik
Trigonometri
Karakterler
Rastgele Sayılar
Bitler ve Baytlar
Harici Kesmeler
Kesmeler
İletişim
USB (32u4 tabanlı kart ve Due/Zero)

BÖLÜM 1: YAPI

• setup()
• loop()

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.

Copy All Code

int buttonPin = 3;  void setup() {   Serial.begin(9600);   pinMode(buttonPin, INPUT); }  void loop() {   // ... }

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.

Copy All Code

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

Kontrol Yapıları

• if / else 
• for
• switch / case 
• while
• do while
• break
• continue
• return
• goto

Arduino Programlama temel karar komutudur. “if” ‘ten sonra verilen koşul doğru ise bu if bloğundaki işlemler, yanlış ise “else” bloğundaki işlemler yapılır.

Copy All Code

if (koşul) { // Koşul sağlanıyor ise yapılacak işlem } else { // Koşul sağlanmıyor ise yapılacak işlem }

Genellikle artış veya azalış sayacı olarak kullanılır.Bir değerden başka bir değere kadar artıp yada azalarak son değerden sonra döngüyü bitiren operatördür.

Copy All Code

for(int x = 1; x < 100; x = x+2) { println(x); }

Bu örneğimizde x değerini birden başlatarak 2 şer arttırımla 100 den küçük olana kadar tüm değerlerin çıktısını aldık. 1,3,5,7,9,….97,99

switch ifadesi bir nesneye atanan değerleri alır ve alt ifade ‘case’ operatörüne gönderir.Bu ifade de değerleri karşılaştırır ve denk gelen ifadeleri çalıştırır.Her ‘case’ ifadesinin sonunda ‘break’ komutu yer alır.Bu komutla döngü bitirilir.Yani ‘case’ komutuna yazılan ifadeler sadece bir kez çalışarak ‘break’ komutu ile sonlanır.Bu sayede algoritmada çakışmalar önlenmiş olur.Son olarak ‘default’ komutu ile de ‘case’ lerde tanımlanmamış ifadeler bu tanımlamaya girerek gerekli algoritma yapılandırılır.

Copy All Code

switch (var)  { case ‘1’: digitalWrite(led,HIGH); break;   case ‘2’: digitalWrite(led,LOW);  default: Serial.println(“Tanımlanmamış ifade”); }

“while” ile belirtilen koşul doğru olduğu sürece, döngü içindeki işlemler gerçekleştirilir.

Copy All Code

while(koşul){   // Koşul doğru olduğu sürece yapılacak işlemler }

“while” ile belirtilen koşul doğru olduğu sürece, döngüdeki işlemler yapılır. While döngüsüyle aynı mantıktadır.

Copy All Code

do {  delay(50);   x = readSensor();  } while (x < 100);

Bu örnekte x değeri 100 ün altında olduğu sürece sensörden veri okunacaktır.

break bir do, for veya while döngüsünden çıkıp normak döngü koşulunu atlamak için kullanılır. Aynı zamanda switch deyiminden çıkmak içinde kullanılır

Copy All Code

for (x = 0; x < 255; x ++) {  analogWrite(PWMpin, x);  sensor = analogRead(sensorPin);   if (sensor > eşik){  x = 0;  break;  }   delay(50); }

Yukardaki döngüde sensor eşik değerini geçtiği zaman döngüden çıkılacaktır.

Do, while veya for döngülerinde bir aralığı atlamak istiyorsak bu ifadeyi kullanmamız gerekir.

Copy All Code

for (x = 0; x < 255; x ++) { if (x > 30 && x < 110){ continue; } analogWrite(sensor, x); delay(50); }

Bu örnekte x değeri o dan 255 kadar birer artarak sensör değerine yazılmaktadır.Fakat 30 ile 110 arasındaki değerleri atlayarak sensöre yazmamaktadır.

Bir fonksiyonu sonlandırarak yeni fonksiyon çağırarak yeni değerle döndürür.

Copy All Code

double constrain(double x, float a, float b)  {  if(x < a) return a;  if(x> b) return b;  return value; }

Burada x değeri a dan küçük ise x'e a değerini ata. x'b den büyük ise x'e b değerini ata.

Programın herhangi bir yerinden başka bir yerine atlamak için goto deyimi kullanılır. goto komutunu kullanmak için, goto isminin yanınaa atlamak istediğiniz yerin sembolik ismini yazmanız gerekir. goto ile bir döngünün içine atlamanıza izin yoktur, fakat bir döngünün dışına atlayabilirsiniz. Ayrıca bir fonksiyondan ötekine de goto ile geçemezsiniz.

Copy All Code

for(byte r = 0; r < 255; r++){  for(byte g = 255; g > -1; g--){   for(byte b = 0; b < 255; b++){     if (analogRead(0) > 250){ goto atla;}  // 0. pin değeri 250'den büyük ise atla'ya geç.       ....       ....     }   } } atla:

Eğer 0.pin değeri 250'den büyükse alttaki satırları okumadan direk atla: ' ya geçecektir.

Sentaks (Söz Dizimi)

; (noktalı virgül)

Program içerisinde kullanılan tüm ifadelerin sonuna yazılması gerklidir. Bu ifadeler { } içerisindeki satırlardır. (fonksiyon çapırma, değişken atama, matematiksel işlemler gibi.) Ayrıca for fonksiyonunun  { } içerisindeki elemanlarını ayırmak için de kullanılır.

{} (kıvrık parantez)

Kıvırcık parantezler C programlama dilinin en önemli parçasıdır. " { " başlayan daima " } " şeklinde bir parantezle biter. Fonksiyonun döngü ya da diğer ifadeler içerisindeki kod kümelerini bir arada tutmak için kullanılır. Tek olarak kullanılırsa derleme hatası verir.

// (tek satırlı yorum)

Tek satırlık yorum veya açıklama yapmak için kullanılır. Bu işaretten sonra yazılan herşey program tarafından derlenmez ve görülmez. Ayrıca hafızada da yer kaplamaz.

/**/ (Çok satırlı yorum)

Diğer yorum işaretinden farkı /* ile */ arasına uzun açıklamalar yazılabilir. Çok satırlı açıklamalar gerektiğinde kullanılır.

#define

#define, program derlenmeden önce programcının sabir bir değere isim vermesine izin veren kullanışlı bir C bileşenidir. Arduino'daki tanımlı sabitler çip üzerindeki herhangi bir program bellek alanını kaplamazlar. Derleyici, bu sabitlerdeki başvuruları  derleme zamanında tanımlanan değere getirir. Bununla birlikte, bazı istenmeyen yan etkiler olabilir.

Örneğin, #define edilmiş sabit bir ad başka bir sabit veya değişken adına dahil edilirse, bu durumda metin #define numarası (veya metin) ile değiştirilir.

Genel olarak, sabitleri tanımlamak için const anahtar kelimesi tercih edilir ve #define yerine kullanılmalıdır.

Copy All Code

#define ledPin 3 // Derleyici, ledPin'i derleme anında 3 ile eşdeğer yapar.

Değerden sonra ; kullanılmadığına dikkat edin.

#include

Bu komut ile derleyeceğimiz programda kullanacağımız kütüphaneleri çağırırız.

Copy All Code

#include <LiquidCrystal.h>  // LCD ekran kütüphanesi

Aritmetik Oparatörler

• = (atama)
• + (toplama)
• - (çıkarma)
• * (çarpma)
• / (bölme)
• % (mod alma)

Bu işaret atama oparatörüdür.

Copy All Code

int sensordegeri = analogRead(0);   //sensordegeri değişkenine 0. pindeki okunan değeri atadık. 

Atama operatörü = ile eşittir == operatörlerini birbiri ile karıştırmamaya dikkat edin.

Toplama işlemi yapmak için kullanılır.

Copy All Code

toplam = deger1 + deger2   // toplam degisgenine değer1 ve değer2 nin toplamını atadık.

Çıkarma işlemi yapmak için kullanılır.

Copy All Code

sonuc = deger1 - deger2 // değer1'i değer2'den çıkarıp sonuç değişkenine atadık.

Çarpma işlemi yapmak için kullanılır.

Copy All Code

sonuc = deger1 * deger2 // değer1'i değer2 ile çarptık ve sonuç değişkenine atadık.

Bölme işlemi yapmak için kullanılır.

Copy All Code

bolum = deger1 / deger2 // değer1'i değer2 ile böldük ve bölüm değişkenine atadık.

Mod alma işlemi yapmak için kullanılır (bir sayıyı başka bir sayıya böldükten sonra kalanı verir.)

Copy All Code

x = 7 % 5;   // x 2 olarak atandı x = 9 % 5;   // x 4 olarak atandı x = 5 % 5;   // x 0 olarak atandı x = 4 % 5;   // x 4 olarak atandı 

Karşılaştırma Operatörleri

• == (eşit)
• != (eşit değil)
• < (küçük)
• > (büyük)
• <= (küçük eşit)
• >= (büyük eşit)

if deyiminde parantez içinde değerlendirilen ifadeler bir veya daha fazla operatörün kullanılmasını gerektirir.

Copy All Code

 x == y (x, y'ye eşittir) x != y (x, y'ye eşit değildir) x  < y (x, y'den küçüktür) x  > y (x, y'den büyük) x <= y (x, y'den küçük veya eşittir) x >= y (x, y'den büyük veya eşittir) 

Yanlışıkla tek eşit işareti kullanmamaya dikkat edin. (ör. if(x=10)). Tek eşit işaret, atama işleci olup x' e 10 değeri atanır. Bunun yerine, karşılaştırma işleci olan çift eşit işareti (ör. if(x==10)) kullanın. ve x'in 10' a eşitse doğrudur, diğer durumlarda yanlıştır.

if deyiminde parantez içinde değerlendirilen ifadeler bir veya daha fazla operatörün kullanılmasını gerektirir.

Copy All Code

 x == y (x, y'ye eşittir) x != y (x, y'ye eşit değildir) x  < y (x, y'den küçüktür) x  > y (x, y'den büyük) x <= y (x, y'den küçük veya eşittir) x >= y (x, y'den büyük veya eşittir) 

Yanlışıkla tek eşit işareti kullanmamaya dikkat edin. (ör. if(x=10)). Tek eşit işaret, atama işleci olup x' e 10 değeri atanır. Bunun yerine, karşılaştırma işleci olan çift eşit işareti (ör. if(x==10)) kullanın. ve x'in 10' a eşitse doğrudur, diğer durumlarda yanlıştır.

if deyiminde parantez içinde değerlendirilen ifadeler bir veya daha fazla operatörün kullanılmasını gerektirir.

Copy All Code

 x == y (x, y'ye eşittir) x != y (x, y'ye eşit değildir) x  < y (x, y'den küçüktür) x  > y (x, y'den büyük) x <= y (x, y'den küçük veya eşittir) x >= y (x, y'den büyük veya eşittir) 

Yanlışıkla tek eşit işareti kullanmamaya dikkat edin. (ör. if(x=10)). Tek eşit işaret, atama işleci olup x' e 10 değeri atanır. Bunun yerine, karşılaştırma işleci olan çift eşit işareti (ör. if(x==10)) kullanın. ve x'in 10' a eşitse doğrudur, diğer durumlarda yanlıştır.

if deyiminde parantez içinde değerlendirilen ifadeler bir veya daha fazla operatörün kullanılmasını gerektirir.

Copy All Code

 x == y (x, y'ye eşittir) x != y (x, y'ye eşit değildir) x  < y (x, y'den küçüktür) x  > y (x, y'den büyük) x <= y (x, y'den küçük veya eşittir) x >= y (x, y'den büyük veya eşittir) 

Yanlışıkla tek eşit işareti kullanmamaya dikkat edin. (ör. if(x=10)). Tek eşit işaret, atama işleci olup x' e 10 değeri atanır. Bunun yerine, karşılaştırma işleci olan çift eşit işareti (ör. if(x==10)) kullanın. ve x'in 10' a eşitse doğrudur, diğer durumlarda yanlıştır.

if deyiminde parantez içinde değerlendirilen ifadeler bir veya daha fazla operatörün kullanılmasını gerektirir.

Copy All Code

 x == y (x, y'ye eşittir) x != y (x, y'ye eşit değildir) x  < y (x, y'den küçüktür) x  > y (x, y'den büyük) x <= y (x, y'den küçük veya eşittir) x >= y (x, y'den büyük veya eşittir) 

Yanlışıkla tek eşit işareti kullanmamaya dikkat edin. (ör. if(x=10)). Tek eşit işaret, atama işleci olup x' e 10 değeri atanır. Bunun yerine, karşılaştırma işleci olan çift eşit işareti (ör. if(x==10)) kullanın. ve x'in 10' a eşitse doğrudur, diğer durumlarda yanlıştır.

if deyiminde parantez içinde değerlendirilen ifadeler bir veya daha fazla operatörün kullanılmasını gerektirir.

Copy All Code

 x == y (x, y'ye eşittir) x != y (x, y'ye eşit değildir) x  < y (x, y'den küçüktür) x  > y (x, y'den büyük) x <= y (x, y'den küçük veya eşittir) x >= y (x, y'den büyük veya eşittir) 

Yanlışıkla tek eşit işareti kullanmamaya dikkat edin. (ör. if(x=10)). Tek eşit işaret, atama işleci olup x' e 10 değeri atanır. Bunun yerine, karşılaştırma işleci olan çift eşit işareti (ör. if(x==10)) kullanın. ve x'in 10' a eşitse doğrudur, diğer durumlarda yanlıştır.

Boolean (Mantık) Operatörleri

• && (ve)
• | | (veya)
• ! (değil)

Her iki işlem de doğru ise if şartı sağlanır ve if içerisindeki komut çalıştırılır. Herhangi bir durum ya da ikiside false, yanlış sonuç ise if yapısına girilmez.

Copy All Code

 if (buton1 == HIGH && buton2 == HIGH) //eğer buton1 ve buton2 HIGH(5volt) ise { digitalWrite(led, HIGH); // ledi yak. 

Her iki işlemden herhangi birisi doğruluk şartını taşıyorusa if yapısının içine girer.

Copy All Code

 if (buton1 == HIGH || buton2 == LOW) // butonlardan herhangi birisi HIGH(5volt) ise { digitalWrite(led, HIGH); // ledi yak.

Değer olarak verilen ifadenin sıfır olma durumudur. İfadenin sıfır olma şartı sağlanıyorsa if yapısının içine girer.

Copy All Code

 if (!buton1) // eğer buton1 deki değer 0 ise { digitalWrite(led, LOW); // ledi söndür.

İşaretçi Erişim Operatörleri (Pointerlar)

• * Ayırma Operatörü
• & referans operatörü

İşaretçiler, C öğrenmede yeni başlayanların daha karmaşık konularından biridir ve Arduino eskizlerinin büyük çoğunluğunu hiç işaretçi bulamadan yazmak mümkündür. Bununla birlikte, bazı veri yapılarını değiştirmek için işaretçilerin kullanılması kodun basitleştirilmesine kullanışlıdır.

İşaretçiler, C öğrenmede yeni başlayanların daha karmaşık konularından biridir ve Arduino eskizlerinin büyük çoğunluğunu hiç işaretçi bulamadan yazmak mümkündür. Bununla birlikte, bazı veri yapılarını değiştirmek için işaretçilerin kullanılması kodun basitleştirilmesine kullanışlıdır.

Bit Düzeyi Operatörleri

• * &  (bit ve)
• | (bit veya)
• ^ (bit xor)
• ~ (bitsel değil)
• << (sola bit kaydırma)
• >> (sağa bit kaydırma)

İşleme giren bitleri ve işlemine tabi tutar. Yani işleme giren bitlerin her ikiside 1 ise 1 değerini verir. Diğer durumda 0 dır.

Copy All Code

     0  0  1  1    işlenen1    0  1  0  1    işlenen2    ----------    0  0  0  1    (işlenen1 & işlenen2) dönen değer 

Copy All Code

  int a = 92;     // ikili değer: 0000000001011100  int b = 101;    // ikili değer: 0000000001100101  int c = a & b;  // ikili değer: 0000000001000100 (ondalık 68) 

İşleme giren bitleri veya işlemine tabi tutar. Yani işleme giren bitlerin herhangi birinde 1 gördüğü zaman 1 değerini döndürür. Sadece işleme giren bitlerin her ikisinde de 0 varsa 0 ı döndürür.

Copy All Code

    0  0  1  1    işlenen1    0  1  0  1    işlenen2    ----------    0  1  1  1    (işlenen1 | işlenen2) dönen değer 

Copy All Code

 int a = 92;     // ikili değer: 0000000001011100  int b = 101;    // ikili değer: 0000000001100101  int c = a | b;  // ikili değer: 0000000001111101 (ondalık 125) 

İşleme giren bitlerin xor unu verir. Veya ile tek farkı işleme giren bitlerin her ikisinde de 1 görürse değerini verir.

Copy All Code

    0  0  1  1    işlenen1    0  1  0  1    işlenen2    ----------    0  1  1  0   (işlenen1 ^ işlenen2) dönen değer 

Copy All Code

 int a = 92;     // ikili değer: 0000000001011100  int b = 101;    // ikili değer: 0000000001100101  int c = a ^ b;  // ikili değer: 0000000000111001 (ondalık 57) 

Her biti tersine çevirir ve sadece tek bir işlenene uygulanır.

Copy All Code

 int a = 103; // binary: 0000000001100111  int b = ~a;  // binary: 1111111110011000

Bu operatörler, sol işlenendeki bitlerin sağ işlenen tarafından belirtilen konum sayısına göre sola veya sağa kaydırılmasına neden olur.

Copy All Code

 int a = 5;      // binary: 0000000000000101  int b = a << 3; // binary: 0000000000101000,  görüldüğü gibi sondan 3 bit sola kaydı.  int c = b >> 3; // binary: 0000000000000101,  şimdi de tekrar 3 bit sağa kayarak eski haline döndü.

Bu operatörler, sol işlenendeki bitlerin sağ işlenen tarafından belirtilen konum sayısına göre sola veya sağa kaydırılmasına neden olur.

Copy All Code

 int a = 5;      // binary: 0000000000000101  int b = a << 3; // binary: 0000000000101000,  görüldüğü gibi sondan 3 bit sola kaydı.  int c = b >> 3; // binary: 0000000000000101,  şimdi de tekrar 3 bit sağa kayarak eski haline döndü.

Bileşik Oparatörler

• ++ (arttır)
• - - (azalt)
• += (bileşik arttır)
• -= (bileşik azalt)
• *= (bileşik çarp)
• /= (bileşik böl)
• %= (bileşik mod al)
• &= (bileşik bit düzeyi ve)
• | = (bileşik bit düzeyi veya)

Bir değişkeni arttırmak ve azaltmak için kullanılır.

Copy All Code

 // ++x veya x++ kullanımı: // x=x+1 ile aynıdır yani amaç sayıyı 1 arttırmaktır. //--x veya x-- kullanımı: //x=x-1 ile aynıdır yani amaç sayıyı 1 azaltmaktır. y = ++x //ilk işlem yapılır sonra atama. y = x++ //ilk atama yapılır sonra işlem. 

Copy All Code

 x = 2;        // x'e 2 değerini atadık. y = ++x;      // ilk işlem yapıldı x'e 1 eklendi, x 3 oldu ve y'ye atandı. y = x--;      // ilk atama yapıldı x 3 olmuştu bu yüzden y'ye atandı, sonra işlem yapıldı x 2 oldu. 

Bir değişkeni arttırmak ve azaltmak için kullanılır.

Copy All Code

 // ++x veya x++ kullanımı: // x=x+1 ile aynıdır yani amaç sayıyı 1 arttırmaktır. //--x veya x-- kullanımı: //x=x-1 ile aynıdır yani amaç sayıyı 1 azaltmaktır. y = ++x //ilk işlem yapılır sonra atama. y = x++ //ilk atama yapılır sonra işlem. 

Copy All Code

 x = 2;        // x'e 2 değerini atadık. y = ++x;      // ilk işlem yapıldı x'e 1 eklendi, x 3 oldu ve y'ye atandı. y = x--;      // ilk atama yapıldı x 3 olmuştu bu yüzden y'ye atandı, sonra işlem yapıldı x 2 oldu. 

Aşağıdaki kodlara bakınız.

Copy All Code

 x += y; // x = x + y; x'i y ile topla ve x'e ata. x -= y; // x = x - y; x'i y'den çıkar ve x'e ata. x *= y; // x = x * y; x'i y ile çarp ve x'e ata. x /= y; // x = x / y; x'i y ile böl ve x'e ata. x %= y; // x = x % y; x ile y nin modunu alıp x'e ata. 

Copy All Code

 x = 2;       // x'e 2 değerini atadık. x += 4;      // x 6 olur. x -= 3;      // x 3 olur. x *= 10;     // x en son 3 idi. 3 ile 10 çarpıldığında 30 olur. x /= 2;      // x 30 / 2 den 15 olur. x %= 5;      // x 0 olur. 

Aşağıdaki kodlara bakınız.

Copy All Code

 x += y; // x = x + y; x'i y ile topla ve x'e ata. x -= y; // x = x - y; x'i y'den çıkar ve x'e ata. x *= y; // x = x * y; x'i y ile çarp ve x'e ata. x /= y; // x = x / y; x'i y ile böl ve x'e ata. x %= y; // x = x % y; x ile y nin modunu alıp x'e ata. 

Copy All Code

 x = 2;       // x'e 2 değerini atadık. x += 4;      // x 6 olur. x -= 3;      // x 3 olur. x *= 10;     // x en son 3 idi. 3 ile 10 çarpıldığında 30 olur. x /= 2;      // x 30 / 2 den 15 olur. x %= 5;      // x 0 olur. 

Aşağıdaki kodlara bakınız.

Copy All Code

 x += y; // x = x + y; x'i y ile topla ve x'e ata. x -= y; // x = x - y; x'i y'den çıkar ve x'e ata. x *= y; // x = x * y; x'i y ile çarp ve x'e ata. x /= y; // x = x / y; x'i y ile böl ve x'e ata. x %= y; // x = x % y; x ile y nin modunu alıp x'e ata. 

Copy All Code

 x = 2;       // x'e 2 değerini atadık. x += 4;      // x 6 olur. x -= 3;      // x 3 olur. x *= 10;     // x en son 3 idi. 3 ile 10 çarpıldığında 30 olur. x /= 2;      // x 30 / 2 den 15 olur. x %= 5;      // x 0 olur. 

Aşağıdaki kodlara bakınız.

Copy All Code

 x += y; // x = x + y; x'i y ile topla ve x'e ata. x -= y; // x = x - y; x'i y'den çıkar ve x'e ata. x *= y; // x = x * y; x'i y ile çarp ve x'e ata. x /= y; // x = x / y; x'i y ile böl ve x'e ata. x %= y; // x = x % y; x ile y nin modunu alıp x'e ata. 

Copy All Code

 x = 2;       // x'e 2 değerini atadık. x += 4;      // x 6 olur. x -= 3;      // x 3 olur. x *= 10;     // x en son 3 idi. 3 ile 10 çarpıldığında 30 olur. x /= 2;      // x 30 / 2 den 15 olur. x %= 5;      // x 0 olur. 

Aşağıdaki kodlara bakınız.

Copy All Code

 x += y; // x = x + y; x'i y ile topla ve x'e ata. x -= y; // x = x - y; x'i y'den çıkar ve x'e ata. x *= y; // x = x * y; x'i y ile çarp ve x'e ata. x /= y; // x = x / y; x'i y ile böl ve x'e ata. x %= y; // x = x % y; x ile y nin modunu alıp x'e ata. 

Copy All Code

 x = 2;       // x'e 2 değerini atadık. x += 4;      // x 6 olur. x -= 3;      // x 3 olur. x *= 10;     // x en son 3 idi. 3 ile 10 çarpıldığında 30 olur. x /= 2;      // x 30 / 2 den 15 olur. x %= 5;      // x 0 olur. 

Bileşik bitsel ve işleci, değişkendeki belirli bitleri LOW durumuna (0'a) zorlamak için genellikle bir değişkeni ve bir sabitle kullanılır. Buna genellikle programlama kılavuzlarında "temizleme , sıfırlama" bitleri denir.
x &= y; // x = x & y; (x ile y nin "ve" sini alıp x'e atadık.

Copy All Code

    0  0  1  1    işlenen1    0  1  0  1    işlenen2    ----------    0  0  0  1    (işlenen1 & işlenen2) dönen değer  

Copy All Code

 int a = 92;     // ikili değer: 0000000001011100  int b = 101;    // ikili değer: 0000000001100101  int c = a & b;  // ikili değer: 0000000001000100 (ondalık 68) 

Bileşik bitsel veya işleci, değişkendeki belirli bitleri HIGH durumuna (1'a) zorlamak için genellikle bir değişkeni ve bir sabitle kullanılır.
x |= y; // x = x | y; (x ile y nin "veya" sını alıp x'e atadık.

Copy All Code

    0  0  1  1    işlenen1    0  1  0  1    işlenen2    ----------    0  1  1  1    (işlenen1 | işlenen2) dönen değer  

Copy All Code

 int a = 92;     // ikili değer: 0000000001011100  int b = 101;    // ikili değer: 0000000001100101  int c = a | b;  // ikili değer: 0000000001111101 (ondalık 125) 

BÖLÜM 2: DEĞİŞKENLER

Sabitler

• HIGH ve LOW
• INPUT, OUTPUT, INPUT_PULLUP
• LED_BUILTIN
• true ve false
• integer constants
• floating point constants

HIGH
pinmode() ile bir INPUT olarak konfigüre edildiğinde ve digitalRead() ile okunduğunda; Arduino aşağıdaki durumlarda HIGH bildirir;

- pinde 3.0V'dan büyük bir voltaj mevcut ise (5V kartlar)
- pinde 2.0V'dan büyük bir voltaj mevcut ise (3.3V kartlar)

Bir pin, pinmode() ile bir INPUT olarak yapılandırılabilir ve daha sonra, digitalWrite() ile HIGH yapılır. Bu, dahili 20K'lık pullup dirençleri ve harici devre tarafından LOW' a çekilmediği sürece giriş pini HIGH durumunda olacaktır.

Bir pin pinMode() ile OUTPUT ile yapılandırıldığında ve digitalWrite() ile HIGH olarak ayarlandırıldığında, pin şu değerdedir.

- 5 volt (5V kartlarda)
- 3.3 volt (3.3V kartlarda)

Bu durumda pine bağlanacak seri bir direnç ve led ile ledimizi aydınlatabiliriz.

LOW
LOW'un anlamı, bir pinin INPUT veya OUTPUT olarak ayarlanmasına bağlı olarak farklı bir anlam taşır.

Pin pinMode() ile bir INPUT olarak yapılandırıldığında ve digitalRead() ile okunduğunda, Arduino şu durumlarda LOW bildirir.

- pinde 1.5V'dan daha düşük bir voltaj mevcut ise (5V kartlarda)
- pinde 1.0V'dan daha düşük bir voltaj mevcut ise (3.3 kartlarda)

Pin pinMode() ile OUTPUT olarak ayarlandığında ve digitalWrite() ile LOW olarak ayarlanırsa

- pin 0 volttuer. (her ikisi de 5V ve 3.3V kartlar)

Bu durumda ledimizi kapatabiliriz.

Dijital pinler INPUT, INPUT_PULLUP veya OUTPUT olarak kullanılabilir. Bir pinin pinMode() ile değiştirilmesi pinin elektriksel davranışını değiştirir.

INPUT
pinMode() ile INPUT olarak yapılandırılmış Arduino (Atmega) pinlerinin yüksek empedanslı bir durumda oldukları söylenir.

INPUT olarak yapılandırılan pinler, örnekleme aşamasında, pin önünde 100 Megohms’lık bir seri dirençle eşdeğer olarak, son derece küçük talepler üretirler. Bu, onları bir sensör okumak için yararlı kılar.

PIN‘inizi INPUT olarak yapılandırdıysanız ve bir anahtar okuyorsa, anahtar açık durumda iken, giriş pini “floating” olur ve bu da öngörülemeyen sonuçlara neden olur. Anahtar açıkken uygun bir okumayı sağlamak için bir pull-up veya pull-down direnci kullanılmalıdır. Bu direncin amacı, anahtar açıkken pini bilinen bir duruma çekmektir. 10 K ohm direnç genellikle floating bir girişin güvenilir şekilde önlenmesi için yeterince düşük bir değer olduğu ve anahtar kapatıldığında çok fazla akım çekmemesi için yeterince yüksek bir değer olduğu için seçilir.

Bir pull-down direnç kullanılırsa, anahtar açıkken giriş pini LOW olur ve anahtar kapatıldığında HIGH olur.

Bir pull-up direnci kullanılırsa, anahtar açıkken giriş pini HIGH ve anahtar kapalıyken LOW olacaktır.

INPUT_PULLUP
Bu şekilde yapılandırılan pinlerde INPUT ‘dan farklı olarak Atmega işlemcisine içerden dahili olarak bağlı pull_up dirençler bulunur. INPUT_PULLUP kullandığımızda harici bir dirence gerek kalmaz. Ü

NOT: INPUT veya INPUT_PULLUP ile giriş olarak yapılandırılan pinlere; (ground)(-) veya kartın türüne göre pozitif(+) (5V veya 3V)’dan fazlaysa zarar görebilir !

OUTPUT
pinMode() ile OUTPUT olarak yapılandırılan pinin düşük empedanslı bir durumda olduğu söylenir. Bu, diğer devrelere önemli miktarda akım sağlayabilecekleri anlamına gelir. Atmega pinleri, diğer cihazlara / devrelere 40 mA’a (miliamp) kadar akım sağlar. Bu, onları LED’ler için kullanışlı kılar, çünkü LED’ler tipik olarak 40 mA’den daha azını kullanır. 40 mA’dan daha büyük yükler (örn. Motorlar) bir transistör veya başka bir arabirim devresini gerektirecektir.

NOT: OUTPUT olarak yapılandırılan pinler, toprak(ground) veya pozitif güç uçlarına bağlıysa zarar görebilir !

Çoğu Arduino kartı, bir dirençle seri olarak bağlı bir LED’ye bağlı bir pime sahiptir. Sabit LED_BUILTIN, yerleşik LED’in bağlandığı pimin numarasıdır. Çoğu sürücünün bu LED’i dijital pin 13’e bağlanmıştır.

Arduino da doğru yada yanlışı göstermek için kullanılan mantıksal tanımlamadır. false 0 (sıfır) olarak tanımlanır. true 1 olarak tanımlanır, ancak doğru olanın daha geniş bir tanımı vardır.

Boolean anlamında, sıfır olmayan herhangi bir tam sayı doğrudur. Dolayısıyla -1, 2 ve -200 tümüyle Boolean anlamında doğru olarak tanımlanır. true ve false sabitlerinin HIGH, LOW, INPUT ve OUTPUT aksine küçük harflerle yazıldığına dikkat edin.

123 gibi doğrudan bir skeçde kullanılan sayılardır. Varsayılan olarak, bu sayılar int olarak kabul edilir, ancak bunu U ve L değiştiricileriyle değiştirebilirsiniz (aşağıya bakın).

Normalde, tamsayı sabitleri taban 10 (ondalık) tamsayılar olarak kabul edilir, ancak diğer tabanlara sayı girmek için özel gösterim (formatlayıcılar) kullanılabilir.

Decimal kullandığımız 10luk sayı sistemidir.
101 //ondalık sayı sisteminde 101 ile aynıdır ((1 * 10^2) + (0 * 10^1) + 1)

Binary ikili sayı sistemidir.(0 ve 1)
B101 //ondalık sayı sisteminde 5 ile aynıdır. ((1 * 2^2) + (0 * 2^1) + 1)

Octal sekizlik sayı sistemidir. (0 dan 7 ye kadar.)
0101 // ondalık sayı sisteminde 65 ile aynıdır. ((1 * 8^2) + (0 * 8^1) + 1)

Hexadecimal on altılık sayı sistemidir. (0-9,A-F,a-f)
0x101 // ondalık sayı sisteminde 257 ile aynıdır. ((1 * 16^2) + (0 * 16^1) + 1)

U ve L Formatları
Sayı tanımlamaları varsayılan int olarak kabul edilir. Başka bir veri türüne sahip olan sayıları belirtmek için U, L imzasız veri türü kullanılır.

Sabiti imzasız bir veri biçimine zorlamak için bir ‘u‘ veya ‘U‘.Örnek: 33uSabiti uzun bir veri formatına zorlamak için bir ‘l‘ veya ‘L‘.Örnek: 100000LSabiti imzasız bir uzun sabit haline getirmek için bir ‘ul‘ veya ‘UL‘. Örnek: 32767ul

Kayan nokta sabitleri olarak nitelendirilir.Sayıları daha okunabilir hale getirmek için kullanılır. E ve e olarak kabul edilir.

Copy All Code

 Kayan Nokta   Değerlendir     Ayrıca Değerlendir  Sabiti     10.0         10  2.34E5       2.34 * 10^5     234000  67e-12       67.0 * 10^-12   .000000000067  

Sabitler

• void
• boolean
• char
• unsigned char
• byte
• int
• unsigned int
• word
• long
• unsigned long
• short
• float
• double
• string (karakter dizisi)
• String (nesne)
• array

void anahtar sözcüğü yalnızca işlev bildirimlerinde kullanılır. Eylemler, setup ve loop fonksiyonlarında gerçekleştirilir.

Copy All Code

 void setup() {  // ... } void loop() {  // ... } 

boolean, true veya false olmak üzere iki değerden birini tutar. (Her boolean değişkeni bir baytlık bellek kullanır.)

Copy All Code

 int LEDpin = 5;                     // Led pin 5'de. int ButonPin = 13;                  // buton 13. pine bağlı ve diğer tarafı negatifte.   boolean yap = false;                // yap bir booelan değişken olarak atandı ve ilk değeri false(0)   void setup() {  pinMode(LEDpin, OUTPUT);           // Led pini çıkıştır.  pinMode(ButonPin, INPUT);          // Buton pini giriştir.  digitalWrite(ButonPin, HIGH);      // buton'a high verip bir pullup direnç etkisi yaptık. }   void loop() {  if (digitalRead(ButonPin) == LOW)  // eğer buton basılırsa  {   delay(100);                        // 100 mili saniye gecikme yap  yap = !yap;                        // yap boolean değişkenini tersine çevir(1)  digitalWrite(LEDpin, yap);     // yap değişkenini Led'e yazdır.  } } 

Bir karakter değeri depolayan 1 bayt bellek alan bir veri türüdür. Karakter harfleri tek tırnak işareti ile yazılır: ‘A‘ (birden fazla karakter için – dizeler – çift tırnak kullanın: “ABC“). Ancak karakterler sayı olarak saklanır. ASCII tablosunda belirli kodlamayı görebilirsiniz. Bu, karakterin ASCII değerinin kullanıldığı karakterlerle aritmetik yapmak mümkündür (ör. A’nın büyük harf A’nın ASCII değeri 65 olduğu için ‘A’ + 1’in değeri 66’dır). Karakterlerin rakamlara nasıl çevrildiği hakkında daha fazla bilgi için bkz. Serial.println referansı. Char veri türü, imzalanmış bir tiptir, yani sayıları -128’den 127‘ye kadar kodlar. İmzasız, bir bayt (8 bit) veri türü için bayt veri türünü kullanın.

Copy All Code

  char karakterim = 'A';  char karakterim = 65; // ikisi de aynı anlama gelir. A, ASCII tablosunda 65'e eşittir. 

1 baytlık bellek kullanan imzalanmamış bir veri türü. byte veri türü ile aynı. İşaretsiz char veri türü, 0’dan 255′e sayıları kodlar. Arduino programlama stilinin tutarlılığı için byte veri türü tercih edilmelidir. char komutundan farkı sadece pozitif değerler alır (0-255)

Copy All Code

 unsigned char myChar = 240; 

Bir bayt, 0’dan 255’e kadar 8 bitlik bir işaretsiz numara depolar.

Copy All Code

 byte b = B10010; // "B" binary formatlayıcıdır. (ondalık sayı sisteminde 18)  

int yani tamsayılar, sayı saklama için birincil veri türünüzdür. Arduino Uno‘da (ve diğer ATMega tabanlı kartlar) bir int, 16 bitlik (2 bayt) bir değeri saklar. Bu, -32.768 ile 32.767 aralığı verir (Minimum değer -2 ^ 15 ve maksimum (2 ^ 15) – 1 değeri).
Arduino Due ve SAMD tabanlı kartlarda (MKR1000 ve Zero gibi), bir int 32 bitlik (4 baytlık) bir değer saklar. Bu, -2,147,483,648 ile 2,147,483,647 aralığı verir (Minimum değer -2 ^ 31 ve maksimum (2 ^ 31) – 1 değeri).

Copy All Code

 int ledPin = 13;   //ledPin değişken adı, 13 ise değerimiz. 

Uno ve diğer ATMEGA tabanlı kartlarda, unsigned int, 2 baytlık bir değeri depoladıkları için int olarak aynıdır. Bununla birlikte, negatif sayılar depolamak yerine sadece 0 ile 65,535 (2 ^ 16) – 1 arasındaki pozitif değerleri depolar.

Copy All Code

 unsigned int sayac = 45555;  // sayac değişkenine 45555 değeri atandı. 

Unsigned int ile aynıdır. 2 baytlık yer kaplar. Uno ve diğer ATMEGA tabanlı kartlarda bir kelime 16 bit unsigned numarayı saklar. Due ve Zero’da bunun yerine 32 bitlik bir unsigned numara depolanır.

Copy All Code

 word w = 1000;  // w değişkenine 1000 değeri atandı. 

Uzun değişkenler, sayı saklama için genişletilmiş boyut değişkenleridir. 32 bit (4 bayt), -2,147,483,648 ile 2,147,483,647 arasında depolanır. Tamsayılarla matematik işlemi yapıyorsa, numaralardan en az birini bir L takip eder ve uzunlamasına zorlar.

Copy All Code

 long degisken = 186000L; // L için tamsayılar sabitleri sayfasına bakın. 

Sayı saklama için genişletilmiş boyut değişkenleridir ve 32 bit (4 bayt) depolamaktadır. unsigned long, 0‘dan 4.294.967.295 (2 ^ 32 – 1) aralığını depolar.

short 16 bitlik bir veri türüdür. Tüm Arduinolarda(ATMega ve ARM temelli) 16 bitlik (2 baytlık) bir değere sahiptir. int ile short verisini ayıran en büyük fark budur. Bu, -32.768 ila 32.767 aralığındadır. (Minimum değer -2 ^ 15 ve maksimum (2 ^ 15) – 1 değeri).

Kayan nokta sayıları için veri türü, ondalık sayılar.(örneğin 2.56) Ondalıklı sayılar tamsayılara göre daha yüksek çözünürlüğe sahip olduklarından, analog ve sürekli değerlerde kullanılırlar.

(Sıcaklık değerini 25 yerine 25.56 gibi vermek istediğimizde) 3.4028235E + 38 kadar büyük ve -3.4028235E + 38 kadar düşük olabilir. 32 bit (4 bayt) bilgi olarak saklanırlar. float sadece 6-7 ondalık basamak hassaslığa sahiptir. Bu, ondalık noktanın sağındaki sayı değil, toplam basamak sayısı anlamına gelir.

Arduino’da bir çift (örneğin, 15 basamaklı) kullanarak daha fazla hassasiyet elde edebileceğiniz diğer platformların aksine, çift, float ile aynı boyuttadır. float sayılar tam değildir ve karşılaştırıldığında garip sonuçlar doğurabilir. Örneğin, 6.0 / 3.0 2.0’a eşit olmayabilir. Bunun yerine rakamlar arasındaki farkın mutlak değerinin küçük bir rakamın altında olduğunu kontrol etmelisiniz.

Kayan nokta matematik de hesaplamalarda tamsayı matematikten çok daha yavaştır, bu nedenle örneğin bir döngünün kritik bir zamanlama işlevi için en yüksek hızda çalışması gerekiyorsa kaçınılmalıdır.

Copy All Code

 int x;                // x int olarak tanımlandı. int y;                // y int olarak tanımlandı. float z;              // z float olarak tanımlandı.   x = 1;                // x'e bir olarak atandı. y = x / 2;            // x'i 2'ye böldük ama y int olduğundan sonuç 0 z = x / 2.0;          // x'i 2.0 ile böldük ve z de float olduğu için 0.5 

Uno ve diğer ATMEGA tabanlı kartlarda bu 4 bayt kaplar. Yani, double uygulama tam olarak float ile aynıdır, kesin olarak bir kazanç elde edilmemektedir. Fakat Arduino Due’da çiftler 8 bayt (64 bit) hassaslığa sahiptir.

char veri türünden olan karakterler toplamıdır.

Copy All Code

   char Str1[15];   char Str2[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o'};   char Str3[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o', '\0'};   char Str4[ ] = "arduino";   char Str5[8] = "arduino";   char Str6[15] = "arduino"; 

- Bir dizi karakteri Str1’de olduğu gibi başlatmadan tanımladık.
- Bir dizi char (bir ekstra char ile) bildirin ve derleyici, gerekli null karakteri Str2’de olduğu gibi ekleyecektir
- Str3 Boş karakteri açıkça ekleyin,
- Str4’ü tırnak işaretleri içinde bir dize sabiti ile başlat; dize sabitine uyacak şekilde boyutlandırır.
- Diziyi açık bir boyut ve dize sabitiyle başlatın, Str5
- Diziyi başlatır, daha büyük bir dize, Str6 için ekstra alan bırakır

 Genellikle, dizeler boş bir karakterle sonlandırılır (ASCII kodu 0). Bu, işlevlerin (Serial.print() gibi) bir dizenin sonunun nerede olduğunu söylemesine izin verir.

Aksi takdirde, aslında dizenin bir parçası olmayan daha sonraki bellek baytlarını okumaya devam edeceklerdi. Bu nedenle, “arduino” yalnızca yedi olmasına rağmen, Str2 ve Str5’in sekiz karakter olması gerekir – son konum otomatik olarak boş bir karakterle doldurulur. Str4, otomatik olarak sekiz karaktere, birincisi fazladan boşa boyutlandırılacaktır. Str3’te açıkça null karakterini (‘\ 0’ olarak) dahil ettik.

0019'dan itibaren çekirdeğin bir parçası olan String sınıfı, metin dizelerini karakter dizilerinden daha karmaşık yollarla kullanmanıza olanak tanır. Dizeleri bir araya getirebilir, onlara ekleyebilir, alt dizeleri arayıp değiştirebilirsiniz. Basit bir karakter diziliminden daha fazla bellek alır, ancak daha kullanışlıdır. Aşağıda string sınıfına ait nesneler verilmiştir.

StringConstructors
StringAdditionOperator
StringIndexOf
StringAppendOperator 
StringLengthTrim
StringCaseChanges
StringReplace
StringRemove
StringCharacters
StringStartsWithEndsWith
StringComparisonOperators
StringSubstring

Diziler genelde fazla kod yazmaktan kaçınılırken kullanılır ve kullanımı oldukça fayda sağlar. Ne yönden fayda sağlar diyecek olursanız fazla kod yazmanızı önler.

Örnegin 4 farklı değeri saklamamız gerektiğinde ;

Copy All Code

 int deger1; int deger2; int deger3; int deger4; int degerler[4]; // 4 tane int değeri tanımlamak yerine tek seferde dizide tanımladık. // başka örnekler; int myInts[6]; int myPins[] = {2, 4, 8, 3, 6}; int mySensVals[6] = {2, 4, -8, 3, 2}; char message[6] = "hello"; 

Dönüşümler

char() , byte() , int() , word() , long() , float(),

komutları parantez içine aldıkları herhangi bir veriyi çevirmemiz için kullanılır.

Değişken Skop ve Niteleyiciler

• Değişken Skop
• Statik
• Volatile
• Const

Arduino ortamında, bir işlevin dışında bildirilen herhangi bir değişken (ör. Setup(), loop() vb.), Genel bir değişkendir. Programlar daha büyük ve daha karmaşık hale geldiğinde yerel değişkenler, yalnızca bir işlevin kendi değişkenlerine erişebilmesini sağlamak için yararlı bir yöntemdir. Bu, bir işlev yanlışlıkla başka bir işlev tarafından kullanılan değişkenleri değiştirdiğinde programlama hatalarını önler.

Static ile fonksiyonda kalıcı değişkenler oluşturulur. Bir kere oluşturulan değişken program boyunca silinmeden kalır. Normal yerel değişkenler fonksiyonnun bitimi ile siliniyordu.

Copy All Code

 static int Sensor; 

Volatile tip tanımlayıcısı (Volatile Type Quantifier) basitçe bir değişken tanımının başında bulunup, bu değişkenin, program dışında bir etki altında bulunabileceğini ifade eder. Örneğin geliştirdiğimiz bir programda, farklı işlem veya donanımsal etkiler sonucunda değeri değişen bir değişken (variable) kullanıyorsak, bu değişkeni volatile olarak tanımlamamız gerekir. Aksi halde derleyici (compiler) bu değişkeni optimize ederek görevini yerine getiremez bir hale sokabilir.

const ile tanımalanan değişkenler sonradan değiştirilemezler. Sabit tanımlar için kullanılırlar.

Copy All Code

 const int pi = 3.14 

Araçlar

• sizeof()
• PROGMEM

Bu fonksiyon değişkenin boyutunu BYTE olarak geri döndürür.

Copy All Code

 sizeof(degisken); 

Datayı SRAM yerine Flash’ta depolamaya yarar. Sadece pgmspace.h’ta tanımlanan değişken tiplerinde işe yarar. Kendisi de pgmspace.h’ta tanımlandığından yazdığınız programda kullanmak için pgmspace.h’ı da programa eklemelisiniz.

Copy All Code

 #include //aşağıdaki gibi üç şekilde de kullanılır. değişken_tipi değişken_adı[] PROGMEM = {} değişken_tipi PROGMEM değişken_adı[] = {} PROGMEM değişken_tipi değişken_adı[] = {}  

BÖLÜM 3: FONKSİYONLAR

Dijital - Giriş/Çıkış

• pinMode()
• digitalWrite()
• digitalRead()

Belirtilen pini bir giriş INPUT veya çıkış OUTPUT olarak davranacak şekilde yapılandırır. Arduino 1.0.1 itibariyle INPUT_PULLUP modlu dahili pullup dirençlerini etkinleştirmek mümkündür. Ayrıca, INPUT modu iç pullup’ları açıkça devre dışı bırakır. Örnek digitalWrite() bölümün altındadır.

Dijital pime HIGH veya LOW değer yazın. Pin pinMode() ile bir OUTPUT olarak yapılandırılmışsa, gerilimi karşılık gelen değere ayarlanır: HIGH için 5V (ya da 3.3V kartlarda 3.3V) LOW için, 0V (toprak) Pin bir INPUT olarak yapılandırılmışsa, digitalWrite(), HIGH veya LOW olabilir. Dahili pull-up direnci etkinleştirmek için pinMode() öğesini INPUT_PULLUP olarak ayarlamanız önerilir.

Copy All Code

 int ledPin = 13;                   // ledpin değişkeni 13. pindir.   void setup() {  pinMode(ledPin, OUTPUT);          // ledpin çıkış olarak yapılandırıldı. }   void loop() {  digitalWrite(ledPin, HIGH);       // Ledi yak.  delay(1000);                      // 1 saniye bekle  digitalWrite(ledPin, LOW);        // Ledi söndür.  delay(1000);                      // 1 saniye bekle } 

Belirtilen bir dijital pinden, HIGH veya LOW değerini okur.

Copy All Code

 int ledPin = 13;                 // ledPin değişkeni 13. pine bağlı. int inPin = 7;                   // inPin değişkeni 7. pine bağlı. int val = 0;                     // val değikeni 0 değerindedir.   void setup() {  pinMode(ledPin, OUTPUT);       // ledPin Çıkıştır.  pinMode(inPin, INPUT);         // inPin Giriştir. }   void loop() {  val = digitalRead(inPin);     // inPin değişkenine gelen veriyi oku ve val değikenine kayıt et.  digitalWrite(ledPin, val);    // ledPin'e yani 13. pine val değişken değerini yaz. }  

Analog - Giriş/Çıkış

• analogReference()
• analogRead()
• analogWrite() - PWM

Analog giriş için kullanılan referans voltajını (yani, giriş aralığının üstü olarak kullanılan değer) konfigüre eder.

 Seçenekler şunlardır:

DEFAULT: Varsayılan 5 voltluk analog referans (5V Arduino kartlarda) veya 3.3 volt (3.3V Arduino kartlarında)

INTERNAL: ATmega168 veya ATmega328’de 1,1 volt’a ve ATmega8’de 2,56 volt’a eşit olan dahili bir referans (Arduino Mega’da mevcut değildir)

INTERNAL1V1: dahili bir 1.1V referans (yalnızca Arduino Mega)

INTERNAL2V56: dahili 2.56V referans (yalnızca Arduino Mega)

EXTERNAL: AREF pinine uygulanan voltaj (sadece 0 – 5V) referans olarak kullanılır.

Dikkat! AREF pininde harici referans voltajı için 0V’dan az veya 5V’den fazla kullanmayın! AREF pininde harici bir referans kullanıyorsanız, analogRead() çağrılmadan önce analog referansı EXTERNAL olarak ayarlamanız gerekir. Aksi takdirde aktif referans voltajını (dahili olarak üretilen) ve AREF pinin birlikte kısaltır ve muhtemelenArduino kartındaki mikro denetleyiciye zarar verirsiniz. Alternatif olarak harici referans voltajını, harici ve dahili referans voltajları arasında geçiş yapmanıza izin veren 5K direnç aracılığıyla AREF pinine bağlayabilirsiniz. Dirençin referans olarak kullanılan voltajı değiştireceğini unutmayın çünkü AREF piminde dahili bir 32K direnç vardır. İkisi bir voltaj bölücü olarak görev yaparken, örneğin, direnç aracılığıyla uygulanan; 2,5 V, AREF pininde 2.5×32 / (32 + 5) = ~ 2.2V verir.

Belirtilen analog pinden değeri okur. Arduino kartı, 6 kanal (Mini ve Nano’da 8 kanal, Mega’da 16), 10 bitlik analogdan dijitale çeviriciye sahiptir. Bu, 0 ile 5 volt arasındaki giriş voltajlarını 0 ile 1023 arasında tam sayı değerlerine haritalandırması anlamına gelir. Bu, 5 volt / 1024 ünite veya birim başına 0,009 volt (4,9 mV) okuma arasında bir çözünürlük verir. Giriş aralığı ve çözünürlük, analogReference() kullanılarak değiştirilebilir.

Bir analog girişi okumak ~ 100 mikrosaniye (0.0001 s) alır, bu nedenle maks okuma hızı saniyede ~ 10.000 kez olur.

Copy All Code

 int analogPin = 3;                  // analogPin değişkeninin değeri 3 verip, 3. pini atadık.                                     // Potun 1. ve 3. bacağı 5v ve toprağa bağlanacaktır. int val = 0;                        // Okunan değeri depolamak için değişken val tanımaldık.   void setup() {  Serial.begin(9600);                // Serial iletişimi açtık. } void loop() {  val = analogRead(analogPin);      // val değişkenine analogPin değişkeninden okunan değeri atadık.  Serial.println(val);              // val değerini seri monitörde yazdırdık. } 

Bir pine bir analog değer (PWM dalgası) yazar. Değişik parlaklıklarda bir LED’i aydınlatmak veya çeşitli hızlarda bir motor sürmek için kullanılabilir.

analogWrite() çağrısından sonra pin, analogWrite() için sonraki çağrı (veya aynı pin üzerinde digitalRead() veya digitalWrite() çağrısı) oluncaya kadar belirtilen görev döngüsünün kararlı bir kare dalga oluşturacaktır. Çoğu pin üzerindeki PWM sinyalinin frekansı yaklaşık 490 Hz‘dir. Uno ve benzeri kartlarda 5 ve 6 numaralı pinlerin frekansı yaklaşık 980 Hz‘dir. Leonardo’da 3. ve 11. parmaklar da 980 Hz‘de çalışıyor. Çoğu Arduino kartı (ATmega168 veya ATmega328 ile olanlar) üzerinde bu işlev 3, 5, 6, 9, 10 ve 11 pinler üzerinde çalışır. Arduino Mega’da pim 2 – 13 ve 44 – 46‘da çalışır. Eski Arduino ATmega8’e sahip panolar yalnızca 9, 10 ve 11 numaralı pimlerde analogWrite() desteklemektedir.

Arduino Due, analogWrite() 2 ila 13 pinleri ve ayrıca DAC0 ve DAC1 pinlerini destekler. PWM pinlerinin aksine DAC0 ve DAC1, Dijital-Analog dönüştürücülerdir ve gerçek analog çıkışlar gibi davranırlar. analogWrite() çağrılmadan önce pimi çıkış olarak ayarlamak için pinMode() öğesini aramanız gerekmez. analogWrite işlevinin analog pinler veya analogRead işleviyle ilgisi yoktur. analogWrite() işlevinde parantez içinde 0 (her zaman kapalı) ile 255 (her zaman açık) değerler kullanılır.

Notlar ve Bilinen Sorunlar: 5 ve 6 numaralı pimlerde üretilen PWM çıkışlarının beklenenden daha yüksek çalışma devreleri olacaktır. Bunun nedeni, bu PWM çıkışlarını üretmek için kullanılan aynı dahili zamanlayıcıyı paylaşan millis() ve delay() işlevleri ile olan etkileşimlerdir. Bu, çoğunlukla düşük çalışma devri ayarları (örn., 0-10) üzerinde fark edilir ve 5 ve 6 numaralı pinlerdeki çıkışın tamamını kapatmayan 0 değerine neden olabilir.

Copy All Code

 int ledPin = 9;                    // ledPin 9 değerini alarak 9. pine tanımlandı. int analogPin = 3;                 // analogPin 3 değerini aldı, potansiyometre bağlanacak. int val = 0;                       // Okunan değeri depolamak için değişken val tanımaldık.   void setup() {  pinMode(ledPin, OUTPUT);          // ledPin değişkenini yani 9. pini çıkış olarak atadık. } void loop() {  val = analogRead(analogPin);      // val değişkenine potansiyometreden gelen değeri atadık.  analogWrite(ledPin, val / 4);     // val değerini 4'e bölüp çıkan değeri ledpine yazdırdık.                                    // analogRead değerleri 0'dan 1023'e, analogWrite değerleri 0'dan 255'e } 

DUE ve ZERO İçin

• analogReadResolution()
• analogWriteResolution()

analogWriteResolution(), Arduino Due, Genuino ve Arduino Zero ve MKR1000 için Analog API’nın bir uzantısıdır.

analogWriteResolution(), analogWrite() işlevinin çözünürlüğünü ayarlar. AVR tabanlı kartlarla geriye dönük uyumluluk için varsayılan 8 bit’dir (0-255 arasındaki değerler).

Due, aşağıdaki zor yeteneklere sahiptir: AVR tabanlı kartlar gibi 8 bit PWM‘e varsayılan 12 pindir. Bunlar 12-bit çözünürlük olarak değiştirilebilir. 12-bit DAC (Dijital-Analog Dönüştürücü) ile 1 pin. Yazma çözünürlüğünü 12 olarak ayarlayarak, tam DAC çözünürlüğünden faydalanmak veya devreden çıkarmadan PWM sinyalini ayarlamak için 0 ile 4095 arasında değerli analogWrite() kullanabilirsiniz.

Zero, aşağıdaki zor yeteneklere sahiptir: AVR tabanlı kartlar gibi 8 bit PWM‘e varsayılan 10 pindir. Bunlar 12-bit çözünürlük olarak değiştirilebilir. 10-bit DAC (Dijital-Analog Dönüştürücü) ile 1 pin. Yazma çözünürlüğünü 10 olarak ayarlayarak, tam DAC çözünürlüğünden yararlanabilmek için; analogWrite() işlevini 0 ile 1023 arasındaki değerleri kullanabilirsiniz.

MKR1000, aşağıdaki zor yeteneklere sahiptir: AVR tabanlı kartlar gibi 8-bit PWM‘e varsayılan olan 4 pin. Bunlar 8(varsayılan) ile 12 bitlik çözünürlük arasında değiştirilebilir. 10-bit DAC (Dijital-Analog Dönüştürücü) ile 1 pin. Yazma çözünürlüğünü 12 bit olarak ayarlayarak, PWM sinyalleri için 0 ile 4095 arasında değerlerle analogWrite() kullanabilirsiniz; 1024 değerlerinin tam DAC çözünürlüğünü kullanmak için DAC pininde 10 bit ayarlayın.

Syntax (Sözdizimi) ve Parametreler: analogWriteResolution(bit değeri);
Bitler: analogWrite() işlevinde kullanılan değerlerin çözünürlüğünü (bit olarak) belirler. Değer 1’den 32’ye değişebilir. Kartınızın donanım yeteneklerinden daha yüksek veya daha düşük bir çözünürlük seçerseniz, analogWrite() da kullanılan değer çok yüksekse kesilir veya çok düşükse sıfırlarla doldurulur.

Not: analogWriteResolution() değerini kartın yeteneklerinden daha yüksek bir değere ayarlarsanız, kart fazladan bitleri atacaktır. Örneğin: 12 bitlik bir DAC pininde Due ile analogWriteResolution (16) kullanıldığında; analogWrite()‘a verilen ilk 12 bit kullanılacak ve son 4 bit atılacaktır. analogWriteResolution() değerinikartınızın yeteneklerinden daha düşük bir değere ayarlarsanız, eksik bitler donanım gerektiren boyutu doldurmak için sıfırlarla doldurulacaktır. Örneğin: 12 bitlik bir DAC piminde Due ile analogWriteResolution(8) kullanan Arduino, analogWrite() içinde kullanılan 8 bit değerine 4 sıfır bit ekleyerek gerekli 12 biti elde edecektir.

Copy All Code

 void setup(){           Serial.begin(9600);                                // Seri iletişimi başlat.   pinMode(11, OUTPUT);                               // 11. pin çıkıştır.   pinMode(12, OUTPUT);                               // 12. pin çıkıştır.    pinMode(13, OUTPUT);                               // 13. pin çıkıştır. } void loop(){   int sensorVal = analogRead(A0);                    // sensorVal değişkenine A0 pininden alınan değeri depola.   Serial.print("Analog Read) : ");                   // Seri monitöre "Analog Read) : " yazısı yaz.   Serial.print(sensorVal);                           // sensorVal değişkenin değerini ver.     analogWriteResolution(8);                          // analog yazma çözünürlüğü 8 bit yani normal ayar.   analogWrite(11, map(sensorVal, 0, 1023, 0 ,255));  // 11. pine sensorVal'den aldığın 0 -1023 arasında değeri 0-255 aralığına çek.   Serial.print(" , 8-bit PWM value : ");             // Seri monitöre "8-bit PWM value : " yazısı yaz.   Serial.print(map(sensorVal, 0, 1023, 0 ,255));     //sensorVal'den aldığın 0-1023 arasında değeri seri monitöre 0-255 aralığına çek.     analogWriteResolution(12);                         // analog yazma çözünürlüğü 12 bit.   analogWrite(12, map(sensorVal, 0, 1023, 0, 4095)); // 12. pine sensorVal'den aldığın 0-1023 arasında değeri 0-4095 aralığına çek.   Serial.print(" , 12-bit PWM value : ");            // Seri monitöre " , 12-bit PWM value : " yazısı yaz.   Serial.print(map(sensorVal, 0, 1023, 0, 4095));    // sensorVal'den aldığın 0-1023 arasında değeri seri monitöre 0-4095 aralığına çek.     analogWriteResolution(4);                          // analog yazma çözünürlüğü 4 bit.   analogWrite(13, map(sensorVal, 0, 1023, 0, 15));   // 13. pine sensorVal'den aldığın 0 -1023 arasında değeri 0-15 aralığına çek.   Serial.print(", 4-bit PWM value : ");              // Seri monitöre " , 4-bit PWM value : " yazısı yaz.   Serial.println(map(sensorVal, 0, 1023, 0, 15));    // sensorVal'den aldığın 0-1023 arasında değeri seri monitöre 0-15 aralığına çek.     delay(5);                                          // 5 mili saniye bekle. } 

analogReadResolution(), Arduino Due ve Zero için Analog API’nin bir uzantısıdır. analogRead() tarafından döndürülen değerin boyutunu (bit olarak) ayarlar. AVR tabanlı panolara geriye dönük uyumluluk için varsayılan olarak 10 bit (0-1023 arasındaki değerleri döndürür).

Due ve Zero, çözünürlüğü 12 olarak değiştirerek erişilebilen 12 bit ADC yeteneklerine sahiptir. Bu, analogRead() değerlerini 0 ile 4095 arasında döndürür.

Syntax (Sözdizimi) ve Parametreler: analogReadResolution(bit değeri) Bits: analogRead () işlevi tarafından döndürülen değerin çözünürlüğünü (bit olarak) belirler. Bu 1’i ve 32’yi ayarlayabilirsiniz. Çözünürlükleri 12’den daha yüksek olarak ayarlayabilirsiniz, ancak analogRead() tarafından döndürülen değerler de yaklaşım yaşanacaktır.

Not: analogReadResolution() değerini tahtanın yeteneklerinden daha yüksek bir değere ayarlarsanız, Arduino yalnızca en yüksek özünürlüğüyle geri kalan ekstra bitleri sıfırlarla doldurarak rapor verecektir. Örneğin: Due veya Zero’u analogReadResolution(16) ile kullanmak, gerçek ADC okumasını ve son 4 biti sıfırlarla doldurulan ilk 12 bitle yaklaşık 16 bitlik sayı verecektir. analogReadResolution() değerini kartın yeteneklerinden daha düşük bir değere ayarlarsanız, ADC’den okunan ekstra bitler için boşluk atılır. 16 bit çözünürlüğü (veya gerçek donanım yeteneklerinden daha yüksek herhangi bir çözünürlük) kullanmak, gelecekte kurulu bir kod satırını değiştirmeden kullanılabilir olduğunda, daha yüksek çözünürlüklü ADC’ye sahip aygıtları otomatik olarak işleyen eskizleri yazmanıza olanak tanır.

Copy All Code

 int ledPin = 9;                    // ledPin 9 değerini alarak 9. pine tanımlandı. int analogPin = 3;                 // analogPin 3 değerini aldı, potansiyometre bağlanacak. int val = 0;                       // Okunan değeri depolamak için değişken val tanımaldık.   void setup() {  pinMode(ledPin, OUTPUT);          // ledPin değişkenini yani 9. pini çıkış olarak atadık. } void loop() {  val = analogRead(analogPin);      // val değişkenine potansiyometreden gelen değeri atadık.  analogWrite(ledPin, val / 4);     // val değerini 4'e bölüp çıkan değeri ledpine yazdırdık.                                    // analogRead değerleri 0'dan 1023'e, analogWrite değerleri 0'dan 255'e } 

Gelişmiş - Giriş/Çıkış

• tone()
• noTone()
• shiftOut()
• shiftIn()
• pulseIn()

Bir pin üzerinde belirtilen frekanstaki bir kare dalga oluşturur. Bir süre belirtilebilir, aksi takdirde dalga noTone() çağrısına kadar devam eder. Zil sesleri çalmak için pim bir piezo ziline veya başka bir hoparlöre bağlanabilir. Bir seferde yalnızca bir ton üretilebilir. Farklı bir pinde halen çalan bir ses varsa, tone() hiçbir etkiye sahip olmayacaktır. Ses aynı pinde oynuyorsa, arama frekansını ayarlar. tone() işlevi, 3 ve 11 nolu pinlerde (Mega dışındaki anakartlarda) PWM çıkışını etkiler.

NOT: birden fazla pin üzerinde farklı sahneler oynatmak isterseniz, bir sonraki pin üzerindeki tone() çağırmadan önce bir pim üzerinde noTone() çağırmanız gerekir.

Syntax (Sözdizimi) ve Parametreler:
tone(pin, frekans)
tone(pin, frekans, süre)

Pin: Sesi üretmek için pin
Frekans: ton frekansı hertz cinsindendir – unsigned int Süre: Tonun süresi (milisaniye) (isteğe bağlı) – unsigned long

tone() ile tetiklenen bir kare dalga üretimini durdurur. Hiçbir ton üretilmezse hiçbir etkisi olmaz.

NOT: birden fazla pin üzerinde farklı seslerle oynamak isterseniz, bir sonraki pin üzerindeki tone() çağırmadan önce bir pim üzerinde noTone() çağırmanız gerekir.

Syntax (Sözdizimi) ve Parametreler:
 noTone(pin) seçilen pindeki sesi durdurur.

Bir seferde bir bayt veri kaydırır. En çok (en soldaki) veya en az (en sağdaki) önemli bitten başlar. Her bit bir veri pinine yazılır ve bundan sonra bir saat pini bitli olduğunu belirtmek için (yüksek, daha sonra alçak alınır) darbeli olarak gönderilir.

Not: yükselen kenarlarla hızlandırılan bir cihazla etkileşimde bulunuyorsanız, shiftOut() çağrısı yapmadan önce saat pinin düşük olduğundan emin olmanız gerekir; ör. digitalWrite(clockPin, LOW).

Syntax (Sözdizimi) ve Parametreler:
shiftOut(veriPin, saatPin, bitSipariş, değer)

veriPin: her biti (int) çıkış pini.
saatPin: veri doğru değere ayarlandığında geçiş yapmak için pin (int)
bitsipariş: bitleri kaydırmak için hangi sıra; MSBFIRST veya LSBFIRST. (En
Önemli Bit Önce, veya En Önemli Bit Önce)
değer: kaydırılacak veriler. (bayt)

Not: veriPin ve saatPin, pinMode() çağrısı ile çıkış olarak yapılandırılmış olmalıdır. ShiftOut şu anda çıkışa 1 bayt (8 bit) yazılır, bu nedenle 255‘den büyük değerleri çıkartmak için iki adımlı bir işlem gerekir.

Copy All Code

 int data = 500; shiftOut(dataPin, clock, MSBFIRST, (data >> 8));  // yüksek baytı kaydır. shiftOut(dataPin, clock, MSBFIRST, data);         // düşük baytı kaydır.   data = 500; shiftOut(dataPin, clock, LSBFIRST, data);         // düşük baytı kaydır. shiftOut(dataPin, clock, LSBFIRST, (data >> 8));  // yüksek baytı kaydır. 

Her seferinde bir bit veri kaydırır. En çok (en soldaki) veya en az (en sağdaki) önemli bitten başlar. Her bit için saat pini yüksek, sonraki bit veri satırından okunur ve saat pini alçak alınır.

Yükselen kenarlarla hızlandırılan bir cihazla etkileşimde bulunuyorsanız, shiftIn() için ilk çağrı öncesinde saat iğnesinin düşük olduğundan emin olmanız gerekir; ör. digitalWrite(clockPin, LOW).

Syntax (Sözdizimi) ve Parametreler:
gelen Bayt = shiftIn(veriPin, saatPin, bitSipariş, değer)

veriPin: her biti (int) çıkış pini.
saatPin: veri doğru değere ayarlandığında geçiş yapmak için pin (int)
bitsipariş: bitleri kaydırmak için hangi sıra; MSBFIRST veya LSBFIRST. (En Önemli Bit Önce, veya En Önemli Bit Önce)
değer: kaydırılacak veriler. (bayt)

Bir pin üzerinde bir darbe (HIGH veya LOW) okur. Örneğin, değer HIGH ise, pulseIn(), Örneğin, değer HIGH pulseIn(), HIGH gitmek için pin bekler zamanlama başlar sonra pin LOW gitmek ve zamanlama durmasını bekler. Darbenin uzunluğunu mikrosaniye cinsinden döndürür veya zaman aşımı süresince tam darbe alınıyorsa 0 döndürür. Bu fonksiyonun zamanlaması ampirik olarak belirlenmiştir ve muhtemelen kısa palslarda hatalar gösterecektir. 10 mikrosaniyeden 3 dakikalık darbelerde çalışır. İşlev çağrıldığında pin zaten yüksekse, sayım başlamadan öncepin LOW ve sonra HIGH olmasını bekleyeceğini lütfen unutmayın. Bu rutin yalnızca, kesmeler etkinleştirildiğinde kullanılabilir. Ayrıca en yüksek çözünürlük kısa aralıklarla elde edilir.

Syntax (Sözdizimi) ve Parametreler:
pulseIn(pin, değer)
pulseIn(pin, değer, zamanAşımı)

pin: nabzı okumak istediğiniz pinin numarası. (int)
değer: okunacak darbe tipi: HIGH veya LOW. (Int)
Zaman aşımı (isteğe bağlı): darbenin tamamlanması için beklenecek mikro saniye sayısı: (zaman aşımı süresi içinde tam darbe alınmazsa, işlev 0 değerini döndürür. Varsayılan değer bir saniye (unsigned long).

Copy All Code

 int pin = 7;                        //pin değişkeni 7 olarak atandı. unsigned long sure;                 //süre değişkeni atandı.   void setup() {  pinMode(pin, INPUT);               //pin değişkeni çıkış oldu. } void loop() {  sure = pulseIn(pin, HIGH);         //sure degiskeni 7. pinden gelen HIGH darpe tipinde atandı. } 

Zaman

• millis()
• micros()
• delay()
• delayMicroseconds()

Arduino kurulu mevcut programı çalıştırmaya başlamasından bu yana milisaniye sayısını döndürür. Yaklaşık 50 gün sonra bu numara taşacaktır (sıfıra döner). Bir programcı int gibi daha küçük veri türleriyle aritmetik yapmaya çalışırsa millis() için dönüş değerinin unsigned long olduğunu, mantıksal hataların oluşabileceğini lütfen unutmayın.

Copy All Code

 unsigned long zaman;                    // zaman değişkeni tanımlandı.   void setup(){   Serial.begin(9600);                   // seri iletişim bağlatıldı. } void loop(){   Serial.print("Zaman: ");              // seri monitöre "Zaman: " yazıldı.   zaman = millis();                     // program başladığında zaman değişkeni milisaniye cinsinden saymaya başladı.   Serial.println(zaman);                // seri monitöre zaman değişkenin değeri atandı.   delay(1000);                          // 1 saniye bekle. } 

Arduino kurulu geçerli programı çalıştırmaya başladıktan sonra geçen mikrosaniye sayısını döndürür. Yaklaşık 70 dakika sonra bu numara taşacaktır (sıfıra döner). 16 MHZ Arduino kartlarda (örn., Duemilanove ve Nano), bu işlevin çözünürlüğü dört mikrosaniyeye eşittir (yani döndürülen değer daima dörtlü bir katıdır). 8 MHz Arduino kartlarında (ör. LilyPad), bu işlev sekiz mikrosaniyelik bir çözünürlüğe sahiptir.

Not: saniyede 1.000 mikrosaniye ve 1.000.000 mikrosaniye vardır.

Copy All Code

 unsigned long zaman;                    // zaman değişkeni tanımlandı.   void setup(){   Serial.begin(9600);                   // seri iletişim bağlatıldı. } void loop(){   Serial.print("Zaman: ");              // seri monitöre "Zaman: " yazıldı.   zaman = micros();                     // program başladığında zaman değişkeni mikrosaniye cinsinden saymaya başladı.   Serial.println(zaman);                // seri monitöre zaman değişkenin değeri atandı.   delay(1000);                          // 1 saniye bekle. } 

Programı parametre olarak belirtilen süre (milisaniye cinsinden) duraklatır. (Saniyede 1000 milisaniye var.) delay(milisaniye) şeklinde kullanılır.

Uyarı
delay() işlevi ile yanıp sönen bir LED oluşturmak kolaydır ve birçok skeç düğmeyi bırakmak gibi görevler için kısa gecikmeler kullansa da, bir eskizdeki delay() kullanımı önemli dezavantajlara sahiptir. delay() işlevi kullanığımızda belirttiğimiz değer kadar arduino hiçbirşey yapmadan bekler. O yüzden bazı durumlarda millis() işlevi kullanırız. Bu fonksiyon arduino programı çalıştırmaya başladığında beri geçen süreyi verdiği için istediğimiz süre aralarınlda işlem yaptırabilir ve bu sayede arduinoyu hiç durdurmamış oluruz.

Copy All Code

 int ledPin = 13;                   // ledpin değişkeni 13. pindir. void setup() {  pinMode(ledPin, OUTPUT);          // ledpin çıkış olarak yapılandırıldı. } void loop() {  digitalWrite(ledPin, HIGH);       // Ledi yak.  delay(1000);                      // 1 saniye bekle  digitalWrite(ledPin, LOW);        // Ledi söndür.  delay(1000);                      // 1 saniye bekle } 

Programı parametre olarak belirtilen süre boyunca (mikro saniye olarak) duraklatır. Milisaniye içinde bin mikrosaniye saniyede bir milyon mikrosaniye vardır. Şu anda, kesin bir gecikme yaratacak en büyük değeri 16383‘tür. Bu, gelecekteki Arduino sürümlerinde değişebilir. Bunun yerine birkaç bin mikrosaniyeden daha uzun gecikmeler için delay() kullanmalısınız.

Copy All Code

 int outPin = 8;              // outPin değişkeniş 8 olarak atandı.   void setup() {  pinMode(outPin, OUTPUT);    // outpin değişkeni çıkış oldu. } void loop() {  digitalWrite(outPin, HIGH); // out pine enerji ver.  delayMicroseconds(50);      // 50 mikrosaniye bekle.  digitalWrite(outPin, LOW);  // outpinin enerjisini kes.  delayMicroseconds(50);      // 50 mikrosaniye bekle. } 

8 numaralı pini, bir çıkış pini olarak çalışacak şekilde yapılandırır. Yaklaşık 100 mikrosaniye süreli bir darbe şekli gönderir.

Uyarılar ve Bilinen Sorunlar
Bu işlev, 3 mikrosaniye ve üzeri aralıklarla çok doğru çalışır. 3 Mikrosaniye’den daha az değerlerde bu fonksiyon doğru çalışmayalabilir.

! Arduino 0018 itibarıyla, delayMicroseconds() artık kesmeleri devre dışı bırakmaz.

Matematik

• min(x,y)
• min(x,y)
• abs(x)
• constrain(x, a, b)
• map()
• pow(temel, üs)
• sqrt(x)

Copy All Code

 sensor = min(sensor, 100); // sensor değeri 100 olana kadar sensor değerini verir.                            // 100'ü geçerse de otomatik olarak 100'ü verir.                            // Böylece asla 100'ü aşamaz. 

Copy All Code

 sensor = max(sensor, 20); // sensor değişkeni 20'den büyükse sensor değerini, küçükse de 20 yi atar.                           // bu şekilde 20 nin altına düşmez. 

Copy All Code

 1 2 x = abs(-10); // x = 10 x = abs(10);  // x = 10 

Bir sayıyı bir aralık içinde sınırlar.
x: sınırlandırılacak sayı, tüm veri türleri
a: aralığın alt sınırı, tüm veri türleri
b: aralığın üst sınırı, tüm veri türleri

x döndürür:  x, a ile b arasındaysa
a döndürür: eğer x bir a’dan küçükse
b döndürür: eğer x, b’den büyükse

Copy All Code

 sensVal = constrain(sensVal, 10, 150);   //Sensör değer aralıklarını 10 ile 150 arasında sınırlar             

Copy All Code

 / * Bir analog değeri 8 bit'e (0-255) eşleştirir * / void setup() {}   void loop() {   int val = analogRead(0);          // val değişkenine 0. analog pindeki değeri depola.   val = map(val, 0, 1023, 0, 255);  // aldığın 0-1023 arasındaki değeri 0-255 formatında yapılandır.   analogWrite(9, val);              // 9. analog pine bu değeri yaz. } 

Copy All Code

 x = pow(a,b)  // a üzeri b değerini x’e atar.               // x double veri tipinde olmalıdır.               // a ve b float veri tipinde olmalıdır. 

Copy All Code

 x = sqrt(4); // Karakökünü hesaplayıp 2 değerini döndürür. 

Trigonometri

• sin(radyan)
• cos(radyan)
• tan(radyan)

Bir açının sinüsünü hesaplar (radyan cinsinden). Sonuç -1 ile 1 arasında olacak. radyan float olmalı. (x=sin(y) //y ise double olmalı)

Bir açının cos’ı (radyan cinsinden) hesaplar. Sonuç -1 ile 1 arasında olacak. radyan float olmalı. (x=cos(y) //y ise double olmalı)

Bir açının teğetini hesaplar (radyan cinsinden). Sonuç, negatif sonsuzluk(-∞) ile (∞)sonsuzluk arasında olacak. radyan float olmalı. (x=tan(y) //y ise double olmalı)

Karakterler

• isAlphaNumeric(karakter)
• isAlpha(karakter)
• isAscii(karakter)
• isWhitespace(karakter)
• isControl(karakter)
• isDigit(karakter)
• isGraph(karakter)
• isLowerCase(karakter)
• isPrintable(karakter)
• isPunct(karakter)
• isSpace(karakter)
• isUpperCase(karakter)
• isHexadecimalDigit(karakter)

Bir karakterin alfasayısal olup olmadığını analiz eder.

Copy All Code

 void setup() {  Serial.begin(9600);  //seri iletişimi başlat.  while (!Serial) {    // USB nin seri iletişime bağlanmasını bekleyin.  }  Serial.println("herhangi bir bayt gönderin ve sana her konuda bilgi vereyim");  Serial.println(); }   void loop() {  if (Serial.available() > 0) {    // gelen herhangi bir bayt al:  int thisChar = Serial.read();        // ne gönderildiğini söyleyin:  Serial.print("Beni Gönerdin \'");  Serial.write(thisChar);  Serial.print("\' ASCII Değer: ");  Serial.println(thisChar);   // gönderilenleri analiz et:  if (isAlphaNumeric(thisChar)) {  Serial.println("bu alfanumerik");  }  if (isAlpha(thisChar)) {  Serial.println("bu alfabetik");  }  if (isAscii(thisChar)) {  Serial.println("bu ASCII");  }  if (isWhitespace(thisChar)) {  Serial.println("bu beyazboşluk");  }  if (isControl(thisChar)) {  Serial.println("bu kontrol karakteri");  }  if (isDigit(thisChar)) {  Serial.println("bu rakam");  }  if (isGraph(thisChar)) {  Serial.println("boşluk olmayan yazdırılabilir bir karakterdir");  }  if (isLowerCase(thisChar)) {  Serial.println("bu küçük harf");  }  if (isPrintable(thisChar)) {  Serial.println("bu tazdırabilinir");  }  if (isPunct(thisChar)) {  Serial.println("noktalama işaretidir");  }  if (isSpace(thisChar)) {  Serial.println("bu boşluk karakteri");  }  if (isUpperCase(thisChar)) {  Serial.println("bu büyük harf");  }  if (isHexadecimalDigit(thisChar)) {  Serial.println("geçerli bir onaltılık basamak (i.e. 0 - 9, a - F, or A - F)");  }    // Biraz yer ekleyin ve başka bir bayt isteyin:  Serial.println();  Serial.println("Başka bir bayt ver:");  Serial.println();  }  

Bir karakterin alfa olup olmadığını analiz eder.

Bir karakterin ASCII olup olmadığını analiz eder.

Bir karakterin boşluk olup olmadığını kontrol eder.

Bir karakterin bir kontrol karakteri olup olmadığını analiz eder.

Bir karakterin bir rakam olup olmadığını analiz eder.

Bir karakterin yazdırılabilir bir karakter olup olmadığını analiz eder.

Bir karakterin küçük harfli bir karakter olup olmadığını analiz eder.

Bir karakterin yazdırılabilir bir karakter olup olmadığını analiz eder.

Bir karakterin noktalama işareti olup olmadığını analiz eder.

Bir karakterin bir boşluk karakteri olup olmadığını analiz eder.

Bir karakterin büyük harfli bir karakter olup olmadığını analiz edin.

Bir karakter geçerli bir onaltılık rakam olup olmadığını kontrol eder.

Tüm bu işlevlerin ortak noktası ise sonuç olarak true ya da false döndürür.

Rastgele Sayılar

• randomSeed()
• random()

Rastgele sayı üreticini belli bir başlangıç noktasından (seed) başlatan fonksiyondur. Daha sonrasında çalıştırılacak random() fonksiyonu bu başlangıç noktasına göre rastgele sayı üretecektir. Aynı başlangıç noktası (seed) için üretilen rastgele sayı dizisi her seferinde aynıdır. Eğer oluşturulan program taslağı (sketch) için rastgele üretilen sayı dizisinin aynı olması isteniyorsa randomSeed() ile kullanılacak başlangıç noktası sabit olmalıdır. Diğer yandan, her seferinde değişen rastgele sayı dizisi oluşturulmak isteniyorsa randomSeed() fonksiyonu aşağıdaki gibi kullanılabilir. Bu programda random() fonksiyou, seri monitör her açıldığında farklı bir dizi oluşturur.

Copy All Code

long rastSayi;  int bosPin = 15; //15 numaralı pinin boşta olduğu kabul edilmitir.  void setup (){   Serial.begin(9600);  randomSeed(analogRead(bosPin));  //boşta olan herhangi bir pin kullanılabilir.  }   void loop(){  rastSayi = random(250);  //250 den küçük rastgele sayı dizisi üretir.  Serial.println(rastSayi);  delay(500); } 

Rastgele "analogRead(bosPin)" değeri yerine sabit bir sayı yazılırsa (örn; randomSeed(2) gibi) seri monitör her çalıştırılğında aynı sayı dizisi sırayla ekranda yazdırılır.

Rastgele sayı üreticini belli bir başlangıç noktasından (seed) başlatan fonksiyondur. Daha sonrasında çalıştırılacak random() fonksiyonu bu başlangıç noktasına göre rastgele sayı üretecektir. Aynı başlangıç noktası (seed) için üretilen rastgele sayı dizisi her seferinde aynıdır. Eğer oluşturulan program taslağı (sketch) için rastgele üretilen sayı dizisinin aynı olması isteniyorsa randomSeed() ile kullanılacak başlangıç noktası sabit olmalıdır. Diğer yandan, her seferinde değişen rastgele sayı dizisi oluşturulmak isteniyorsa randomSeed() fonksiyonu aşağıdaki gibi kullanılabilir. Bu programda random() fonksiyou, seri monitör her açıldığında farklı bir dizi oluşturur.

Copy All Code

long rastSayi;  int bosPin = 15; //15 numaralı pinin boşta olduğu kabul edilmitir.  void setup (){   Serial.begin(9600);  randomSeed(analogRead(bosPin));  //boşta olan herhangi bir pin kullanılabilir.  }   void loop(){  rastSayi = random(250);  //250 den küçük rastgele sayı dizisi üretir.  Serial.println(rastSayi);  delay(500); } 

Rastgele "analogRead(bosPin)" değeri yerine sabit bir sayı yazılırsa (örn; randomSeed(2) gibi) seri monitör her çalıştırılğında aynı sayı dizisi sırayla ekranda yazdırılır.

Bit ve Baytlar

• lowByte(x)
• highByte(x)
• bitRead(x,n)
• bitWrite(x,n,b)
• bitSet(x,n)
• bitClear(x,n)
• bit(n)

Bir değişkenin (örneğin bir sözcük) düşük sıralı (en sağdaki) baytını çıkarır.
x: herhangi bir türe ait bir değer

Bir kelimenin üstteki (en soldaki) baytını (veya daha büyük bir veri türünün en düşük ikinci baytı) ayıklar.
x: herhangi bir türe ait bir değer

Sayısal bir değişkenin bitini okur.
x: okunacak numara
n: hangi bit, en az anlamlı (en sağdaki) bit için 0’dan.

Kesmeler

• interrupts()
• nointerrupts()

Kesmeleri yeniden etkinleştirir (noInterrupts() tarafından devre dışı bırakıldıktan sonra). Kesmeler, bazı önemli görevlerin arka planda olmasını sağlar ve varsayılan olarak etkindir. Bazı işlevler kesmeler devre dışı bırakılırken çalışmaz ve gelen iletişim yok sayılabilir. Bununla birlikte, kesmeler kod zamanlamasını hafifçe bozabilir ve kodun özellikle kritik bölümleri için devre dışı bırakılabilir.

Kesmeleri devre dışı bırakır (interrupts() yeniden etkinleştirebilirsiniz).

Dış Kesmeler

• attachInterrupt()
• detachInterrupt()

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.

Aşağıdaki tabloda Arduino türlerine göre dış kesme özelliğine sahip pinler gösterilmiştir.

Kart	Kesme İçin Dijital Pin
Uno, Nano, Mini, ve diğer 328 tabanlılar	2, 3
Mega, Mega2560, MegaADK	2, 3, 18, 19, 20, 21
Micro, Leonardo, other 32u4-tabanlılar	0, 1, 2, 3, 7
Zero	4. pin hariç tüm dijital pinler.
MKR1000 Rev.1	0, 1, 4, 5, 6, 7, 8, 9, A1, A2
Due	Tüm dijital pinlar
101	Tüm dijital pinlar

Söz dizimi (Syntax)
attachInterrupt (Dijital kesme pini (pin), ISR, mode); (Tavsiye edilen)
attachInterrupt (interrupt, ISR, mode); (Tavsiye edilmez)
attachInterrupt (pin, ISR, mode); (Sadece Arduino Due, Zero, MKR1000, 101 için önerilmez)

interrupt: Kesme numarası (int)

pin: Pin Numarası (sadece Arduino Due, Zero, MKR1000)

ISR: Kesme oluştuğunda ISR çağırır; Bu işlev parametre almayacak ve hiçbir şey döndürmemelidir.

Bu işlev bazen bir kesme hizmeti rutini olarak da adlandırılır.

mode: 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.
HIGH: Pindeki voltaj 5 volt ise kesme oluşturur. (Sadece Arduino Due, Zero, MKR1000 )

Verilen kesmeyi kapatır.Sözdizimi ve Parametlereler:

detachInterrupt(interrupt)
detachInterrupt(Dijital kesme numarası(pin));
detachInterrupt(pin) (Sadece Arduino Due, Zero )

interrupt: devre dışı bırakılacak kesme sayısı.

pin: devre dışı bırakılacak kesimin pin numarası. (sadece Arduino Due)

İletişim

• Serial
• Stream

Pinlerin seri iletişimi TX / RX, TTL mantık düzeylerini kullanır (karta bağlı olarak 5V veya 3.3V).Bu pinleri bir RS232 seri portuna doğrudan bağlamayın; +/- 12V’de çalışırlar ve Arduino kartınıza zarar verebilirler.

Seri, Arduino kartı ile bir bilgisayar veya diğer cihazlar arasındaki iletişim için kullanılır.Tüm Arduino kartlarında en az bir seri bağlantı noktası (UART veya USART olarak da bilinir) vardır:

Seri, Dijital pin 0 (RX) ve 1 (TX) üzerinden ve ayrıca bilgisayar üzerinden USB üzerinden iletişim kurar. Bu nedenle, bu işlevleri kullanırsanız, dijital giriş veya çıkış için 0 ve 1 numaralı pinleri kullanamazsınız.

Bir Arduino kartıyla iletişim kurmak için Arduino ortamının dahili seri monitörünü kullanabilirsiniz. Araç çubuğundaki seri monitör düğmesini tıklayın ve begin() çağrısında kullanılan aynı baud hızını seçin.

Arduino Mega‘nın üç ek seri portu vardır: Pin 19(RX) ve 18(TX) üzerindeki Serial1, 17(RX) ve 16(TX) pinlerdeki Serial2, 15(RX) ve 14(TX) pinlerdeki Serial3. Bu pinleri kişisel bilgisayarınızla iletişim kurmak için, Mega’nın USB-to-serial adaptörüne bağlı olmadığından ek bir USB-to-seri adaptöre ihtiyaç duyacaksınız. Bunları harici bir TTL seri cihazla iletişim kurmak için kullanmak için, TX pinini cihazınızın RX pimine, RX’i cihazınızın TX pinine ve Mega’nuzun zemini cihazınızın zemine bağlayın.

Arduino Due‘nun üç ilave 3.3V TTL seri portu vardır: 19(RX) ve 18(TX) pinlerdeki Serial1; 15(RX) ve 14 (TX) pinlerdeki Serial2. 17(RX) ve 16(TX), Seri3. Pin 0 ve 1 ayrıca USB hata ayıklama bağlantı noktasına bağlı olan ATmega16U2 USB-to-TTL

Seri yongasının ilgili pinlerine bağlanır. Ayrıca, SAM3X yongasında SerialUSB olan yerli bir USB seri bağlantı noktası da var. Arduino Leonardo kartı, 0(RX) ve 1(TX) pimlerde TTL(5V) seri ile iletişim kurmak için Serial1‘i kullanıyor. Seri USB CDC iletişimi için ayrılmıştır. Daha fazla bilgi için, Leonardo başlama sayfası ve donanım sayfasına bakın.


Fonksiyonları:
if(Serial)
Belirlenen Seri Portun hazır olup olmadığını kontrol etmemize yarar. Serial nesnelerinin mantıksal bir alan alanda kullanılması durumunda eğer belirtilen Seri Port hazır ise; true eğer belirtilen Seri Port hazır değilse false değeri dönecektir.

available()
Serial Port’tan okuma yapmak için kullanılabilir byte( karakter )’in olup olmadığını kontrol etmemize yarar.
Gönderilmiş olan veriyi byte byte değerlendirir.

begin()
Arduino’dan bilgisayarımıza veya seri haberleşme portunu kullanan diğer cihazlara gönderilecek verinin hızını saniyede bit ( bit / saniye ) cinsinden ayarlar. Bir cihaz ile birlikte kullanıldığında hem Arduino’muzun hemde diğer cihazımızın veri transfer hızları aynı olmalıdır.

Kullanım Şekli:

Serial.begin(speed)
Serial.begin(speed, config)

begin() fonksiyonu bir hız parametresi ve isteğe bağlı ikinci bir parametre olarak parity veya stop biti alabilir.

Arduino’muz ile bilgisayarımız arasında bir seri haberleşme gerçekleştirmek istediğimizde hız parametresi olarak

300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, 115200, 230400 veya 250000 seçilir.

Bilgisayarımızın varsayılan hızı 9600’dür. Bu hızı değiştirmek için Arduino yazılımında yukarıda nasıl erişileceğinden

bahsedilen Serial Port Ekranından aşağıdaki resimdeki gibi değiştirebilirsiniz.

Kartınızın ve bilgisayarınızın hızlarının aynı olması gerektiğini unutmayınız.

end()
Serial Portun çalışmasını devre dışı bırakır. Daha önce belirttiğimiz gibi TX ve RX pinlerini Serial Portu kullandığımızda

giriş çıkış işlemleri için kullanamıyoruz. end() ile Serial Port devre dışı bırakıldıktan sorna TX ve RX pinlerini giriş

çıkış işlemleri için tekrar kullanabiliriz. Serial Portu tekrar devreye almak istersek begin() fonksiyonunu kullanabiliriz.

find()
Find fonksiyonu ile Serial Port üzerinden gönderilen değer içerisinde arama işleme yapılır. Eğer aranan değer gönderilen değer içerisinde varsa true, yoksa false değeri döndürür.

parseFloat() ve parseInt()parseFloat() ve parseIn() fonksiyonları Seri Porta gönderilen veri dizisi içerisindeki ondalıklı ve tam sayıları almamızı sağlar. Bu işlemi yaparken gelen veri dizisinde değişikliklerde oluşur.

print() ve println()Her iki fonksiyonda seri haberleşmede gönderilen parametreleri ASCII‘ye uygun olarak yazdırma işlemi yapar. Diğer programlama dillerinden de alışık olduğumuz şekilde print fonksiyonu yazma işlemini gerçekleştirdikten sonra imleci yazma işleminin bittiği noktada bırakırken, println fonksiyonu yazma işlemi bittikten sonra imleci bir alt satırın başına getirir ve daha sonraki yazmaların bir alt satırdan olmasını sağlar.

Kullanım şekilleri:

Serial.print(val) , Serial.println(val)
Serial.print(val, format) , Serial.println(val, format)

Parametre olarak aldıkları veriyi seri monitor ekranına yazarlar.

C gibi dillerde kullanılan kaçış karakterleri ( \t, \n vs. ) bu fonksiyonlar içinde geçerlidir.

Ondalıklı sayılar yazdırıldığın da varsayılan hassasiyet olan virgülden sonraki 2 basamağı yazdırılır.

İkinci parametre olarak alınan format değişkeni ile yazdırma hassasiyeti veya yazdırılan sayının hangi taban

aritmetiğinde olması istendiği ayarlanabilir.Serial.println(1.23456) şekildeki kullanımda ekrana onluk tabanda 1.23 yazdırılır.

Serial.println(1.23456, 3) şeklindeki bir kullanımda ekrana 1.234 çıktısını yani, virgülden sonra üç basamağı yazdırılır.

Daha farklı hassasiyetler için örnekteki 3 rakamını değiştirebiliriz.
Serial.println(123, format) kullanımında format değişkeni değer olarak

BIN ( ikilik ), OCT ( sekizlik ), DEC ( ondalık), HEX ( on altılık ) değerlerini alır ve bu aldığı değerlere uygun tabanda
sayı formatlandırılarak yazdırılır.Not: Bu kullanım şekli ondalıklı sayılar için geçerli değildir.

read()
Seri Porttan gelen veriyi ilk byte ile başlayarak sırayla okuma işlemini gerçekleştirir ve okuduğu her değerin int karşılığını döndürür. Bu int değer tip dönüşümü yapılarak istenilen formda kullanılabilir. Eğer okunacak veri yoksa -1 değerini döndürür.

readBytes()
readBytes fonksiyonu Serial Porttan gelen veriyi istenilen byte adedinde okuyarak char veya byte tipinde

bir diziye yazma işlemini gerçekleştirir. Bu işlemi gerçekleştirirken geriye kaç byte lık işlem yaptığını int tipinde döndürür.

Serial.readBytes(buffer, length)

buffer : char veya byte tipinde bir dizi

length : int tipinde kaç byte lık okuma yapılacağı

readBytesUntil()Bu fonksiyon readBytes fonksiyonundan farklı olarak bir char parametre daha alır ve bu aldığı char parametre gelen veri dizisi içerisinde varsa okuma işlemini sonlandırır.

Serial.readBytesUntil(character,buffer, length)

character : aramak için char tipinde karakter

buffer : char veya byte tipinde bir dizi

length : in tipinde kaç byte lık okuma yapılacağı

readString()
Bu fonksiyon Serial Porta gelen girdi dizisini satır sonuna kadar okuyarak okunan değeri String formunda geri döndürür.

readStringUntil()Bu fonksiyon readString fonksiyonundan farklı olarak bir char parametre daha alır ve bu aldığı char parametre gelen veri dizisi içerisinde varsa okuma işlemini sonlandırır.

setTimeout()Bu fonksiyon ile Seri Porttan gelecek olan verinin maksimum ne kadar bekleneceği mili saniye cinsinden ayarlanır.

readBytes, readBytesUntil, parseFloat veya parseInt gibi fonksiyonların varsayılan bekleme süreleri 1000 ms’dir.

write()Bu fonksiyon print fonksiyonuna benzer bir işlev görür. Tek byte büyüklüğündeki değerleri yazdırmakta, String değerler ve char veya byte tipinde dizileri yazdırmakta kullanılır. Alacağı ikinci bir parametre ile de yazdırılan String veya dizinin kaç elemanının yazdırılacağı ayarlanabilir. Ayrıca write fonksiyonu geri dönüş değeri olarak üzerinde işlem yapılan byte sayısı döndürür.

findUntil()

flush()

availableForWrite()

peek()

serialEvent()

Stream (akış) aşağıdaki kütüphaneleri içeririr. Doğrudan çağrılmaz. Streama bağlı kütüphaneler çağrılarak işlevini yerine getirir.

Serial
Wire
Ethernet Client
Ethernet Server
SD

USB (32u4 tabanlı kart ve Due/Zero)

• Keyboard
• Mouse

Fare veya Klavye kütüphanesini kullanırken, önce Serial.print () kullanarak çıktısını test etmek en iyisi olabilir. Bu şekilde, hangi değerlerin bildirildiğini bildiğinizden emin olabilirsiniz.

Klavye işlevleri, bir Leonardo, Micro veya Due'nun bağlı bir bilgisayara tuş vuruşlarını göndermesini sağlar.

Not: Olası ASCII karakterleri, özellikle yazdırılmayan ASCII karakterleri, Klavye kütüphanesi ile gönderilemez . Kütüphane, değiştirici tuşların kullanılmasını destekler. Değiştirici tuşlar aynı anda basıldığında başka bir tuşun davranışını değiştirir. Desteklenen tuşları ve kullanımları ile ilgili ek bilgi için. Buraya bakın 

Başlıca Fonksiyonları şunlardır;
Keyboard.begin ()
Keyboard.end ()
Keyboard.press ()
Keyboard.print ()
Keyboard.println ()
Keyboard.release ()
Keyboard.releaseAll ()
Keyboard.write ()

Fare işlevleri, bir Leonardo, Micro veya Due bağlantılı bir bilgisayardaki imlecin hareketini kontrol etmeyi sağlar.

Başlıca Fonksiyonları şunlardır;
Mouse.begin ()
Mouse.click ()
Mouse.end ();
Mouse.move ()
Mouse.press ()
Mouse.release ()
Mouse.isPressed ()

ARDUİNO PİNOUT DİAGRAM