Rehberler · 8 dk okuma

Arduino Hesap Makinesi: 4x4 Keypad ve I2C LCD ile Dört İşlem

Arduino hesap makinesi yapımı: 4x4 keypad ve I2C LCD bağlantısı, tuş eşleme, sayı biriktirme, dört işlem, sıfıra bölme kontrolü, Uno, ESP32 ve Pico kodları.

Arduino hesap makinesi, bir 4x4 keypad (tuş takımı), 16x2 I2C LCD ekran ve birkaç jumper kabloyla yapabileceğin, hem eğlenceli hem de programlamayı gerçekten öğreten bir projedir. Tuşlara basarak sayı girersin, A, B, C ve D tuşlarıyla toplama, çıkarma, çarpma ya da bölme seçersin, # tuşuyla sonucu ekranda görürsün; * tuşu ise her şeyi temizler. Bu rehberde devreyi kurmayı, tuşları işlemlere eşlemeyi, basılan rakamlardan çok haneli bir sayı oluşturmayı, sıfıra bölme gibi hataları yakalamayı ve aynı projeyi ESP32 ile Raspberry Pi Pico'ya taşımayı adım adım öğreneceksin.

Hesap makinesi küçük bir proje gibi görünse de içinde gömülü yazılımın temel konularının neredeyse hepsi var: matris tarama ile giriş okuma, değişkenlerle durum tutma, karar yapıları, kayan noktalı sayıların sınırları ve kullanıcıya anlamlı geri bildirim vermek. Bu yüzden okul projelerinde, bilim fuarlarında ve kodlama derslerinde sıkça tercih edilir. Kodun her önemli satırını açıklayacağım; yazının sonunda ondalık nokta, hafıza tuşu ya da tuş sesi gibi kendi eklemelerini yapabilecek seviyeye geleceksin.

4x4 membran keypad tuş takımı
4x4 membran keypad: 16 tuş, 8 pin (4 satır + 4 sütun). Hesap makinesinin giriş birimi.

Arduino hesap makinesi nasıl çalışır?

Projeyi üç parçaya ayırmak işini çok kolaylaştırır. Giriş tarafında keypad, hangi tuşa basıldığını tek bir karakter olarak ('7', 'A', '#' gibi) verir. İşlem tarafında Arduino; yazılmakta olan sayıyı, ilk sayıyı (ya da ara sonucu) ve seçilen işlemi değişkenlerde tutar. Çıkış tarafında I2C LCD, üst satırda ilk sayıyla işlemi, alt satırda yazmakta olduğun sayıyı ya da sonucu gösterir. Gerçek cep hesap makineleri de tam olarak böyle çalışır: her tuş, makinenin içindeki küçük bir durumu değiştirir ve ekran bu durumun o anki halini yansıtır.

ParçaAdetGörevi
Arduino Uno (ya da Nano)1Tuşları okur, hesabı yapar, ekranı sürer
4x4 membran keypad10–9 rakamları, dört işlem, eşittir ve temizle tuşları
16x2 LCD + I2C modülü (PCF8574)1İşlemi ve sonucu gösterir; yalnızca 2 veri kablosu
Erkek-erkek jumper kablo128 keypad + 4 LCD bağlantısı
USB kablo1Kod yükleme ve besleme

Keypad nasıl okunur? Satır-sütun taraması

4x4 keypad'in içinde 16 ayrı buton vardır ama yalnızca 8 pini bulunur. Butonlar 4 satır ve 4 sütundan oluşan bir ızgaraya dizilmiştir; her tuş, basıldığında bir satır hattını bir sütun hattına bağlar. Keypad kütüphanesi satır pinlerini dahili pull-up dirençli giriş yapar, sütunları sırayla LOW'a çeker ve hangi satırın LOW okunduğuna bakar. Örneğin 2. sütun LOW iken 3. satır da LOW okunuyorsa basılan tuş, 3. satır 2. sütundaki '8' tuşudur. Bu tarama saniyede yüzlerce kez yapıldığı için hiçbir gecikme hissetmezsin. Kütüphane ayrıca yaklaşık 10 ms'lik dahili debounce (titreşim süzme) uygular; böylece tek bir basış iki kez sayılmaz. Taramanın ayrıntılarını Keypad (Tuş Takımı) Kullanımı yazısında bulabilirsin.

TuşHesap makinesindeki görevi
0–9Rakam girişi; sayı hane hane büyür
AToplama (+)
BÇıkarma (-)
CÇarpma (*)
DBölme (/)
#Eşittir (=), sonucu gösterir
*Temizle (C), her şeyi sıfırlar
I2C 2x16 LCD ekran
Arkasına PCF8574 I2C modülü lehimlenmiş 16x2 LCD: işlem üst satırda, sayı ve sonuç alt satırda görünür.

Bağlantı şeması: Uno, ESP32 ve Pico pinleri

BağlantıArduino UnoESP32Raspberry Pi Pico
Keypad R1D9GPIO 13GP6
Keypad R2D8GPIO 14GP7
Keypad R3D7GPIO 27GP8
Keypad R4D6GPIO 26GP9
Keypad C1D5GPIO 25GP10
Keypad C2D4GPIO 33GP11
Keypad C3D3GPIO 32GP12
Keypad C4D2GPIO 4GP13
LCD GNDGNDGNDGND
LCD VCC5VVIN (5 V)VBUS (5 V, USB'den)
LCD SDAA4GPIO 21GP4
LCD SCLA5GPIO 22GP5
Membran keypad'lerin çoğunda 8 pin soldan sağa R1, R2, R3, R4, C1, C2, C3, C4 sırasındadır, ancak bazı modellerde sıra farklıdır. '1' tuşuna bastığında ekranda '4', 'A' ya da 'D' görüyorsan satır ve sütun dizileri yer değiştirmiş ya da ters sıradadır; kabloları sökmek yerine koddaki rowPins ve colPins dizilerini düzelt. Uno'da 0 ve 1 numaralı pinleri kullanma; bu pinler USB seri haberleşmesine ayrılmıştır ve kod yüklemeyi engeller.

I2C LCD modülünde yalnızca dört kablo vardır: GND, VCC, SDA ve SCL. Uno'da SDA A4'e, SCL A5'e bağlanır. Modüllerin çoğu 0x27 adresini kullanır; PCF8574A yongalı olanlar ise 0x3F adresindedir. Ekranın arka ışığı yanıyor ama yazı görünmüyorsa önce modülün arkasındaki mavi kontrast potansiyometresini küçük bir tornavidayla çevir. Adresten emin değilsen I2C LCD Ekran Kullanımı yazısındaki I2C tarayıcı kodunu çalıştır; iki kablonun nasıl bu kadar çok cihazı taşıdığını merak ediyorsan I2C nedir yazısı iyi bir başlangıçtır.

Adım adım kurulum

  1. Arduino IDE'de Kütüphane Yöneticisi'ni aç; Keypad (Mark Stanley, Alexander Brevig) ve LiquidCrystal I2C (Frank de Brabander) kütüphanelerini kur. Yöntemi bilmiyorsan kütüphane ekleme yazısına bak.
  2. Keypad'in 8 pinini tablodaki sırayla Uno'nun D9'dan D2'ye kadar olan dijital pinlerine bağla.
  3. LCD modülünün GND ve VCC pinlerini Uno'nun GND ve 5V pinlerine, SDA'yı A4'e, SCL'yi A5'e bağla.
  4. Aşağıdaki kodu yükle; açılışta ekranda "Hesap Makinesi" yazısını görmelisin.
  5. Sırasıyla 1, 2, A, 5 ve # tuşlarına bas; ekranda sonuç olarak 17 görünüyorsa devre ve kod doğru çalışıyor demektir.
  6. Yazı görünmüyorsa kontrastı ayarla ve adresi 0x3F olarak dene; tuşlar karışıksa pin dizilerini kontrol et.

Arduino Uno hesap makinesi kodu

Kod, yazılan sayıyı metin (String) olarak değil, doğrudan long türünde bir tam sayı olarak biriktirir; bu hem hızlıdır hem de Uno'nun 2 KB'lık RAM'ini yormaz. İlk sayı ve sonuçlar ise ondalık kısım taşıyabilsin diye Number adını verdiğimiz bir türde (Uno'da float) tutulur. Her tuş türü için ayrı bir fonksiyon yazdık; böylece loop() yalnızca basılan tuşu doğru fonksiyona yönlendiren kısa bir dağıtıcı olarak kalır ve kod kolayca okunur.

C++ (Arduino IDE)
1#include <Wire.h>
2#include <LiquidCrystal_I2C.h>
3#include <Keypad.h>
4
5using Number = float;                 // ESP32'de double yapılabilir / can be double on ESP32
6const byte MAX_DIGITS = 7;            // float ~7 basamak / float ~7 digits
7const Number LIMIT = 99999999.0;      // taşma sınırı / overflow limit
8
9const byte ROWS = 4;
10const byte COLS = 4;
11char keys[ROWS][COLS] = {
12  {'1', '2', '3', 'A'},
13  {'4', '5', '6', 'B'},
14  {'7', '8', '9', 'C'},
15  {'*', '0', '#', 'D'}
16};
17byte rowPins[ROWS] = {9, 8, 7, 6};    // R1-R4
18byte colPins[COLS] = {5, 4, 3, 2};    // C1-C4
19
20Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);
21LiquidCrystal_I2C lcd(0x27, 16, 2);   // adres 0x27 ya da 0x3F / address 0x27 or 0x3F
22
23long entry = 0;                       // yazılan sayı / number being typed
24byte digits = 0;                      // girilen hane / digits typed
25Number first = 0;                     // ilk sayı ya da ara sonuç / first operand or running result
26bool hasFirst = false;
27char op = 0;                          // '+', '-', '*', '/' ya da 0 / or 0
28bool justCalculated = false;          // sonuç ekranda mı? / is a result shown?
29
30void printNumber(Number v) {
31  long n = (long)(v >= 0 ? v + 0.5 : v - 0.5);
32  if (fabs(v - n) < 0.0005) lcd.print(n);   // tam sayı / whole number
33  else lcd.print(v, 3);                     // 3 ondalık / 3 decimals
34}
35
36void showScreen() {
37  lcd.clear();
38  if (hasFirst) {                     // üst satır: ilk sayı ve işlem / top row: first operand and operator
39    printNumber(first);
40    if (op) {
41      lcd.print(' ');
42      lcd.print(op);
43    }
44  }
45  lcd.setCursor(0, 1);                // alt satır: yazılan sayı / bottom row: number being typed
46  if (digits > 0) lcd.print(entry);
47  else if (!hasFirst) lcd.print('0');
48}
49
50void clearState() {
51  entry = 0;
52  digits = 0;
53  first = 0;
54  hasFirst = false;
55  op = 0;
56  justCalculated = false;
57}
58
59void clearAll() {
60  clearState();
61  showScreen();
62}
63
64void showError(const char *msg) {
65  lcd.clear();
66  lcd.print("Hata / Error");
67  lcd.setCursor(0, 1);
68  lcd.print(msg);
69  delay(1500);
70  clearAll();
71}
72
73bool applyOp(Number b) {              // first = first (op) b
74  if (op == '/' && b == 0) {
75    showError("Sifira bolunmez");     // sıfıra bölme / division by zero
76    return false;
77  }
78  Number r;
79  switch (op) {
80    case '+': r = first + b; break;
81    case '-': r = first - b; break;
82    case '*': r = first * b; break;
83    case '/': r = first / b; break;
84    default:  r = b; break;
85  }
86  if (fabs(r) > LIMIT) {
87    showError("Tasma");               // taşma / overflow
88    return false;
89  }
90  first = r;
91  return true;
92}
93
94void handleDigit(char k) {
95  if (justCalculated) clearState();   // yeni hesap / new calculation
96  if (entry == 0) digits = 0;         // baştaki sıfırları sayma / ignore leading zeros
97  if (digits >= MAX_DIGITS) return;
98  entry = entry * 10 + (k - '0');     // sayı biriktirme / build the number
99  digits++;
100  showScreen();
101}
102
103void handleOperator(char newOp) {
104  if (digits > 0) {
105    if (!hasFirst) {
106      first = entry;
107      hasFirst = true;
108    } else if (!applyOp(entry)) {
109      return;                         // hata oldu / an error occurred
110    }
111    entry = 0;
112    digits = 0;
113  } else if (!hasFirst) {
114    return;                           // henüz sayı yok / no number yet
115  }
116  op = newOp;
117  justCalculated = false;
118  showScreen();
119}
120
121void handleEquals() {
122  if (!hasFirst || op == 0 || digits == 0) return;   // eksik işlem / incomplete operation
123  if (!applyOp(entry)) return;
124  entry = 0;
125  digits = 0;
126  op = 0;
127  justCalculated = true;
128  lcd.clear();
129  lcd.print("Sonuc:");
130  lcd.setCursor(0, 1);
131  printNumber(first);
132}
133
134void setup() {
135  lcd.init();
136  lcd.backlight();
137  lcd.print("Hesap Makinesi");
138  lcd.setCursor(0, 1);
139  lcd.print("BlueGrays");
140  delay(1500);
141  clearAll();
142}
143
144void loop() {
145  char k = keypad.getKey();
146  if (!k) return;                     // tuş yok / no key
147  if (k >= '0' && k <= '9') handleDigit(k);
148  else if (k == 'A') handleOperator('+');
149  else if (k == 'B') handleOperator('-');
150  else if (k == 'C') handleOperator('*');
151  else if (k == 'D') handleOperator('/');
152  else if (k == '#') handleEquals();
153  else if (k == '*') clearAll();
154}

Kod nasıl çalışır?

Fonksiyon / değişkenNe yapar?
entry, digitsYazılmakta olan sayı ve hane sayısı; Uno'da en fazla 7 hane
first, hasFirstİlk sayı ya da zincirleme işlemlerdeki ara sonuç
opSeçilen işlem: '+', '-', '*', '/' ya da 0 (işlem yok)
handleDigit()Rakamı sayının sonuna ekler: entry = entry × 10 + rakam
handleOperator()Sayıyı first'e aktarır, gerekirse bekleyen işlemi uygular, yeni işlemi kaydeder
applyOp()Dört işlemi yapar; sıfıra bölmede ve taşmada hata verir
handleEquals()Sonucu hesaplar ve alt satırda gösterir
clearAll()* tuşu: tüm değişkenleri sıfırlar, ekranı temizler

Sayı biriktirmenin sırrı tek bir formüldür: entry = entry × 10 + rakam. Sırasıyla 4, 7 ve 2'ye bastığını düşün. İlk basışta entry 0 × 10 + 4 = 4 olur, ikincide 4 × 10 + 7 = 47, üçüncüde 47 × 10 + 2 = 472. Basılan karakteri sayıya çevirmek için k - '0' ifadesini kullanırız: ASCII tablosunda '0' karakterinin kodu 48, '7' karakterinin kodu 55'tir ve farkları tam olarak 7 eder. Baştaki sıfırlar hane sınırını boşa harcamasın diye entry 0 iken hane sayacı sıfırlanır; böylece 0, 0, 5 yazdığında sayı 5 olur ve tek hane sayılır. Sınırı 7 hane koymamızın nedeni ise bir sonraki bölümde anlatacağımız float hassasiyetidir.

Kodun en akıllıca kısmı zincirleme işlemlerdir. 5 + 3 yazıp # yerine doğrudan B (çıkarma) tuşuna basarsan handleOperator() önce bekleyen toplamayı yapar, ara sonuç 8'i first değişkenine yazar ve ardından çıkarmayı kaydeder; yani 5 + 3 - 2 işlemi tıpkı cep hesap makinesindeki gibi soldan sağa hesaplanır ve 6 sonucunu verir. İşlem önceliği olmadığını unutma: 2 + 3 × 4 sonucu 14 değil 20 çıkar, basit hesap makinelerinin çoğu da böyle davranır. Sonuç gösterildikten sonra bir işlem tuşuna basarsan sonuç ilk sayı olur ve hesaba devam edersin; rakam tuşuna basarsan yeni bir hesap başlar. Bu davranışı yöneten justCalculated bayrağı aslında küçük bir durum makinesidir; konuyu derinlemesine öğrenmek için Arduino'da durum makinesi yazısına göz at.

Sıfıra bölme ve taşma kontrolü

Bir sayıyı sıfıra bölmek matematikte tanımsızdır ve Arduino bunu kendiliğinden engellemez: float bölmede pozitif bir sayıyı sıfıra bölmek inf (sonsuz), sıfırı sıfıra bölmek ise nan (sayı değil) sonucunu verir ve ekrana anlamsız bir değer basılır. Bu yüzden applyOp() bölmeden önce bölenin sıfır olup olmadığına bakar; sıfırsa "Sifira bolunmez" mesajını 1,5 saniye gösterir ve hesap makinesini sıfırlar. İkinci koruma taşmaya karşıdır. Uno'da float 32 bittir ve yaklaşık 6–7 anlamlı basamak hassasiyet verir; 16.777.216'nın üzerindeki tam sayılar artık tam olarak saklanamaz ve son basamak yuvarlanabilir. Ayrıca Arduino'nun print fonksiyonu yaklaşık 4,29 milyarın üzerindeki float değerleri "ovf" olarak yazar. Kod, sonucun mutlak değeri 99.999.999'u geçerse "Tasma" hatası verir; böylece 16 karakterlik ekrana sığmayan ya da güvenilmeyecek sonuçları kullanıcıya hiç göstermez.

LCD'nin karakter tablosunda ş, ı, ğ gibi Türkçe harfler yoktur; bu yüzden ekrana giden mesajlar "Sonuc" ve "Sifira bolunmez" gibi ASCII karakterlerle yazıldı. Türkçe harf istiyorsan createChar() ile en fazla 8 özel karakter tanımlayabilirsin. Ekranda titreme fark edersen her tuşta lcd.clear() yerine yalnızca değişen satırı güncelle; clear() komutu yaklaşık 2 ms sürer ve görüntüyü bir anlığına siler.

ESP32 ile hesap makinesi

Aynı kod ESP32'de de çalışır; değiştirmen gereken tek şey pin dizileri ve isteğe bağlı olarak sayı türüdür. LCD için ESP32'nin varsayılan I2C pinleri GPIO 21 (SDA) ve GPIO 22 (SCL) kullanılır; LiquidCrystal I2C kütüphanesi Wire'ı bu pinlerle kendisi başlatır. Bir avantaj daha var: ESP32'de double gerçekten 64 bittir ve yaklaşık 15 anlamlı basamak sunar. Number türünü double yaparsan hane sınırını 9'a çıkarabilir, büyük çarpmaları son basamağına kadar doğru hesaplayabilirsin. Uno'da double ile float aynı 32 bitlik türdür, bu yüzden orada bu değişiklik bir fark yaratmaz. ESP32'yi ilk kez kullanıyorsan kart kurulumunu ESP32 Nedir? yazısında anlattık.

C++ (Arduino IDE)
1// ESP32: Uno kodunda yalnız bu satırları değiştir / change only these lines in the Uno code
2using Number = double;                  // 64 bit, ~15 basamak / 64-bit, ~15 digits
3const byte MAX_DIGITS = 9;              // 9 haneli giriş / 9-digit input
4const Number LIMIT = 999999999.0;       // long sınırına sığar / fits in a long
5
6byte rowPins[ROWS] = {13, 14, 27, 26};  // R1-R4
7byte colPins[COLS] = {25, 33, 32, 4};   // C1-C4
8// LCD: SDA = GPIO 21, SCL = GPIO 22 (Wire varsayılanı / Wire default)
ESP32'nin pinleri 3,3 V ile çalışır ve resmi olarak 5 V'a dayanıklı değildir. LCD modülünü VIN (5 V) pininden beslediğinde PCF8574 kartındaki pull-up dirençleri SDA ve SCL hatlarını 5 V'a çeker. Kısa denemelerde çoğu zaman sorun çıkmasa da kalıcı bir cihazda araya bir lojik seviye dönüştürücü koy. Keypad için GPIO 34–39'u kullanma: bu pinler yalnızca giriştir ve dahili pull-up dirençleri yoktur. Açılışta kartın davranışını etkileyen GPIO 0, 2, 12 ve 15 gibi strapping pinlerinden de uzak durmak en güvenlisidir.

Raspberry Pi Pico ve MicroPython ile hesap makinesi

Pico'da Arduino'daki Keypad kütüphanesinin yerine taramayı kendimiz yazıyoruz; bu, matris taramayı gerçekten anlamak için harika bir alıştırmadır. Satırlar GP6–GP9'a pull-up'lı giriş, sütunlar GP10–GP13'e çıkış olarak bağlanır ve her sütun sırayla LOW yapılır. MicroPython'da hazır bir LCD modülü olmadığı için lcd_api.py ve pico_i2c_lcd.py sürücü dosyalarını Thonny ile Pico'ya kopyalaman gerekir. Pico'da da float 32 bittir, bu yüzden hane sınırı yine 7'dir; ancak Python'da sayıyı metin olarak biriktirip float() ile çevirmek çok kolaydır. ESP32 için verdiğimiz 5 V uyarısı Pico için de geçerlidir. Pico'yu yeni tanıyorsan Raspberry Pi Pico Nedir? ve MicroPython temelleri yazılarına göz at.

MicroPython
1from machine import Pin, I2C
2import time
3from pico_i2c_lcd import I2cLcd          # lcd_api.py + pico_i2c_lcd.py Pico'da olmalı / must be on the Pico
4
5KEYS = [["1", "2", "3", "A"],
6        ["4", "5", "6", "B"],
7        ["7", "8", "9", "C"],
8        ["*", "0", "#", "D"]]
9OPS = {"A": "+", "B": "-", "C": "*", "D": "/"}
10
11rows = [Pin(p, Pin.IN, Pin.PULL_UP) for p in (6, 7, 8, 9)]     # R1-R4
12cols = [Pin(p, Pin.OUT, value=1) for p in (10, 11, 12, 13)]    # C1-C4
13
14i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=100000)
15lcd = I2cLcd(i2c, 0x27, 2, 16)           # adres, satır, sütun / address, rows, columns
16
17def get_key():
18    for c, col in enumerate(cols):
19        col.value(0)                     # bu sütunu LOW yap / drive this column LOW
20        for r, row in enumerate(rows):
21            if row.value() == 0:
22                time.sleep_ms(20)        # debounce
23                if row.value() == 0:
24                    while row.value() == 0:   # bırakılmasını bekle / wait for release
25                        time.sleep_ms(5)
26                    col.value(1)
27                    return KEYS[r][c]
28        col.value(1)
29    return None
30
31def fmt(x):
32    if abs(x - round(x)) < 0.0005:
33        return str(int(round(x)))        # tam sayı / whole number
34    return "{:.3f}".format(x)            # 3 ondalık / 3 decimals
35
36def show(top, bottom):
37    lcd.clear()
38    lcd.putstr(top[:16])
39    lcd.move_to(0, 1)
40    lcd.putstr(bottom[:16])
41
42def calc(a, o, b):
43    if o == "+":
44        r = a + b
45    elif o == "-":
46        r = a - b
47    elif o == "*":
48        r = a * b
49    else:
50        if b == 0:
51            raise ValueError("Sifira bolunmez")   # sıfıra bölme / division by zero
52        r = a / b
53    if abs(r) > 99999999:
54        raise ValueError("Tasma")                  # taşma / overflow
55    return r
56
57def screen():
58    top = ""
59    if first is not None:
60        top = fmt(first) + (" " + op if op else "")
61    show(top, entry or ("0" if first is None else ""))
62
63first, op, entry, done = None, None, "", False
64show("Hesap Makinesi", "Pico hazir")
65time.sleep(1.5)
66screen()
67
68while True:
69    k = get_key()
70    if k is None:
71        time.sleep_ms(10)
72        continue
73    try:
74        if k == "*":                     # temizle / clear
75            first, op, entry, done = None, None, "", False
76        elif k.isdigit():
77            if done:                     # yeni hesap / new calculation
78                first, op, done = None, None, False
79            if entry == "0":
80                entry = ""               # baştaki sıfırı at / drop leading zero
81            if len(entry) < 7:
82                entry += k
83        elif k in OPS:
84            if entry:
85                b = float(entry)
86                first = b if (first is None or op is None) else calc(first, op, b)
87                entry = ""
88            if first is not None:
89                op = OPS[k]
90                done = False
91        elif k == "#" and first is not None and op and entry:
92            first = calc(first, op, float(entry))
93            entry, op, done = "", None, True
94    except ValueError as e:
95        show("Hata / Error", str(e))
96        time.sleep(1.5)
97        first, op, entry, done = None, None, "", False
98    if done:
99        show("Sonuc:", fmt(first))
100    else:
101        screen()

Hesap makinesini geliştirme fikirleri

  • Ondalık nokta: Kullanılmayan bir tuş kombinasyonunu ondalık nokta yap; noktadan sonraki her rakamı 0,1, 0,01 gibi azalan çarpanlarla sayıya ekle.
  • Hafıza tuşları (M+, MR): Sonucu EEPROM'a yaz; Arduino kapansa bile son sonuç kaybolmaz.
  • Tuş sesi: Her basışta kısa bir bip için bir buzzer ekle; D10'a bağlı bir buzzer için tone(10, 2000, 30) satırı yeterlidir.
  • Bilimsel mod: Karekök (sqrt), üs alma (pow) ve yüzde hesabını ikinci bir tuş katmanıyla ekle.
  • Daha büyük ekran: 16x2 LCD yerine bir OLED ekran kullanıp işlem geçmişini satır satır göster.
  • Hesap kaydı: Her sonucu Serial Monitor'e de yazdırarak bilgisayarda bir hesap geçmişi tut.
  • Şifreli kilit: Aynı keypad ve LCD ile bir şifreli kapı kilidi yap; sayı biriktirme mantığı orada da aynen işe yarar.

Sık yapılan hatalar ve çözümleri

SorunOlası nedenÇözüm
LCD yanıyor ama yazı yokKontrast ayarsız ya da I2C adresi yanlışArkadaki potansiyometreyi çevir; 0x27 yerine 0x3F dene
Üst satırda siyah kareler varLCD başlatılmamış ya da I2C hattı kopuklcd.init() çağrıldığından ve SDA/SCL'nin A4/A5'te olduğundan emin ol
Tuşlar yanlış karakter veriyorSatır ve sütun pinleri karışıkrowPins ve colPins dizilerini yer değiştir ya da ters çevir
Bir tuş iki kez sayılıyorKontak titreşimikeypad.setDebounceTime(50) ile süzme süresini artır
Hiçbir tuş çalışmıyorUno'da 0/1 pinleri ya da ESP32'de GPIO 34–39 kullanılmışTablodaki pinleri kullan
Büyük çarpımda son basamak yanlışUno'da float yalnızca 6–7 basamak taşırHane sınırını koru ya da ESP32'de double kullan
Bölme sonucu küsuratsız çıkıyorİşlem iki tam sayı (int/long) ile yapılmışEn az bir tarafı float'a çevir; bu kodda first zaten Number türünde
Hata ararken kodu parça parça test et: önce yalnızca keypad.getKey() ile basılan tuşu Serial Monitor'e yazdır, sonra yalnızca LCD'ye sabit bir yazı gönder. İki parça ayrı ayrı çalışıyorsa sorun hesap mantığındadır; Serial.print ile entry, first ve op değişkenlerinin değerlerini her tuşta izleyerek hatayı kolayca bulursun.

Keypad ve I2C LCD ile yaptığın bu hesap makinesi; giriş okuma, durum tutma, hata yönetimi ve sayıların bellekteki sınırları gibi konuları tek bir projede bir araya getiriyor. Aynı mantığı şifreli kilitlerde, sayaçlarda ve menü sistemlerinde tekrar tekrar kullanacaksın. BlueGrays uygulamasında I2C hesap makinesi, 4x4 keypad ile LCD şifre uygulaması ve akıllı elektronik kasa gibi projeleri adım adım devre şeması ve hazır koduyla inceleyip kendi sürümünü geliştirebilirsin.

Sıkça sorulan sorular

Arduino ile hesap makinesi nasıl yapılır?

Bir Arduino Uno, 4x4 keypad ve I2C 16x2 LCD yeterlidir. Keypad'in 8 pini dijital pinlere, LCD'nin SDA ve SCL pinleri A4 ve A5'e bağlanır. Keypad ve LiquidCrystal I2C kütüphaneleriyle tuşlar okunur, sayılar entry = entry × 10 + rakam formülüyle biriktirilir ve seçilen işlem # tuşuyla uygulanır.

4x4 keypad kaç pin kullanır?

4x4 keypad, 4 satır ve 4 sütun için toplam 8 dijital pin kullanır. Arduino Uno'da genellikle D2–D9 arası pinler tercih edilir, çünkü D0 ve D1 seri haberleşmeye ayrılmıştır. Pin sayısı yetmiyorsa PCF8574 tabanlı bir I2C keypad modülüyle bağlantıyı iki veri kablosuna indirebilirsin.

Arduino hesap makinesinde ondalıklı sonuç nasıl gösterilir?

Sonucu float değişkende tut ve lcd.print(sonuc, 3) gibi ikinci parametreyle ondalık basamak sayısını belirt. İki tam sayıyı (int ya da long) böldüğünde ondalık kısım kaybolur; 7 / 2 işlemi 3 verir. Bölmeden önce en az bir sayıyı float'a çevirirsen 3,5 sonucunu alırsın.

Arduino'da sıfıra bölünce ne olur?

Tam sayılarla sıfıra bölmenin sonucu tanımsızdır ve tutarsız değerler üretebilir; float bölmede ise sonuç inf ya da nan olur. Arduino çalışmayı sürdürür ama ekranda anlamsız bir değer görürsün. Bu yüzden bölmeden önce bölenin sıfır olup olmadığını if ile kontrol edip kullanıcıya bir hata mesajı göstermelisin.

I2C LCD ekranda neden yazı görünmüyor?

En sık iki sebep kontrastın ayarsız olması ve I2C adresinin yanlış girilmesidir. Modülün arkasındaki potansiyometreyi çevirerek kontrastı ayarla, ardından adresi 0x27 ve 0x3F olarak dene. Hâlâ sorun varsa I2C tarayıcı koduyla modülün hatta görünüp görünmediğini kontrol et.

Arduino hesap makinesi işlem önceliğine uyar mı?

Bu rehberdeki kod, cep hesap makinelerinin çoğu gibi işlemleri soldan sağa yapar; 2 + 3 × 4 sonucu 20 çıkar. İşlem önceliği için ifadeyi önce bir diziye kaydedip çarpma ve bölmeyi toplama ile çıkarmadan önce hesaplayan bir ayrıştırıcı yazman gerekir. Bu, bir sonraki seviye için güzel bir programlama alıştırmasıdır.

Tüm projeleri gör
Arduino I2C Hesap Makinesi
AR-94Orta
Premium

Arduino I2C Hesap Makinesi

4x4 membran tuş takımı ve 16x2 I2C LCD ekran kullanarak toplama, çıkarma, çarpma ve bölme işlemlerini gerçekleştiren Arduino tabanlı bir hesap makinesi projesidir. I2C sayesinde sadece 2 kablo ile ekran bağlantısı sağlanır, böylece kablo karmaşası azalır ve daha fazla pin kullanıma açık kalır. Ondalıklı sayı girişi ve negatif sayı desteği de bulunmaktadır.

5.0(31)
43
4x4 Keypad Kullanım
AR-63Başlangıç
Premium

4x4 Keypad Kullanım

Telefon tuşlarına benzeyen 4x4 tuş takımında hangi tuşa bastığını Arduino anında anlar ve bilgisayar ekranına yazar. Rakamların yanında A, B, C, D harfleri ile yıldız ve kare tuşları da tanınır.

4.5(27)
35
4x4 Keypad LCD Ekran Şifre Uygulaması
AR-64İleri
Premium

4x4 Keypad LCD Ekran Şifre Uygulaması

Doğru şifreyi bilmeyenin giremediği küçük bir elektronik kapı kilidi. Kare tuşuna basıp şifreyi tuş takımından girersin; şifre doğruysa ekranda giriş izni yazar, yeşil LED yanar ve servo motor kapıyı…

4.8(59)
75
3x4 Keypad Kullanım
AR-61Başlangıç

3x4 Keypad Kullanım

Telefon tuşlarına benzeyen 12 tuşlu bir tuş takımında hangi tuşa bastığını Arduino anında anlar ve bilgisayar ekranına yazar.

4.5(24)
32
3x4 Keypad Led Uygulaması
AR-62Orta
Premium

3x4 Keypad Led Uygulaması

Telefondakine benzeyen tuşlu bir pad ile üç ayrı ışığı kumanda edersin. 1, 2 ve 3 tuşları yeşil, mavi ve sarı LED'i yakar, 4, 5 ve 6 aynı ışıkları söndürür; yıldız tuşu hepsini birden yakar, kare…

4.6(29)
38
I2C İle LCD Ekran Kullanımı
AR-32Başlangıç
Premium

I2C İle LCD Ekran Kullanımı

Arduino'ya kendi ekranını kazandır ve ilk mesajını yazdır. İki satırlık LCD ekran yalnızca birkaç kabloyla bağlanır; önce üst satıra bir selam, ardından alt satıra ikinci bir yazı gelir, ekran…

4.8(53)
70
Akıllı Elektronik Kasa
AR-92İleri
Premium

Akıllı Elektronik Kasa

Değerli eşyalarını saklayabileceğin, şifreyle açılan küçük bir kasa. Tuş takımından dört haneli şifreni girersin; doğruysa servo motor kilidi açar, yeşil ışık yanar ve ekran kasanın durumunu yazar…

4.7(42)
63
ESP32 I2C LCD Ekran (16x2)
ES-17Orta
Premium

ESP32 I2C LCD Ekran (16x2)

Bu projede 16x2 karakter LCD ekranı I2C protokolü üzerinden ESP32'ye bağlayarak metin görüntülüyoruz. I2C sayesinde sadece 2 data pini (SDA ve SCL) ile ekranı kontrol edebiliyoruz; klasik paralel bağlantıdaki 6+ pin israfı ortadan kalkıyor. Kod ilk satıra sabit bir mesaj, ikinci satıra ise her saniye artan bir sayaç yazdırıyor. Ayrıca başlangıçta I2C tarayıcı çalıştırarak ekranın adresini Serial Monitor'a yazdırıyoruz (genelde 0x27 veya 0x3F).

4.9(23)
40