Kalkulator Arduino: Empat Operasi dengan Keypad 4x4 dan LCD I2C
Buat kalkulator Arduino dengan keypad 4x4 dan LCD I2C: pengkabelan, pemetaan tombol, input angka multi-digit, empat operasi, cek pembagian dengan nol, plus kode untuk Uno, ESP32, dan Pico.
Kalkulator Arduino adalah proyek yang bisa kamu buat dengan keypad 4x4, LCD I2C 16x2, dan beberapa kabel jumper. Proyek ini seru sekaligus cara yang bagus untuk benar-benar belajar pemrograman. Kamu mengetik angka lewat tombol, memilih penjumlahan, pengurangan, perkalian, atau pembagian dengan tombol A, B, C, dan D, melihat hasilnya di layar dengan tombol #, dan tombol * menghapus semuanya. Di panduan ini kamu akan belajar langkah demi langkah cara merakit rangkaian, memetakan tombol ke operasi, menyusun angka multi-digit dari tombol yang ditekan, menangkap error seperti pembagian dengan nol, dan memindahkan proyek yang sama ke ESP32 dan Raspberry Pi Pico.
Walaupun kalkulator terlihat seperti proyek kecil, di dalamnya ada hampir semua dasar software embedded: membaca input dengan pemindaian matriks, menyimpan status di variabel, struktur keputusan, batas bilangan floating-point, dan memberi umpan balik yang jelas ke pengguna. Karena itu proyek ini sangat populer untuk proyek sekolah, lomba sains, dan kelas coding. Aku akan menjelaskan setiap baris penting di kodenya; di akhir tulisan kamu sudah bisa menambahkan fitur sendiri seperti titik desimal, tombol memori, atau bunyi tombol.

Bagaimana cara kerja kalkulator Arduino?
Membagi proyek menjadi tiga bagian membuatnya jauh lebih mudah. Di sisi input, keypad melaporkan tombol mana yang ditekan sebagai satu karakter (misalnya '7', 'A', '#'). Di sisi pemrosesan, Arduino menyimpan angka yang sedang diketik, angka pertama (atau hasil sementara), dan operasi yang dipilih di variabel. Di sisi output, LCD I2C menampilkan angka pertama dan operasinya di baris atas, serta angka yang sedang kamu ketik atau hasilnya di baris bawah. Kalkulator saku sungguhan bekerja persis seperti ini: setiap tombol mengubah sebuah status kecil di dalam mesin, dan layar menampilkan status yang sedang berlaku.
| Komponen | Jumlah | Fungsi |
|---|---|---|
| Arduino Uno (atau Nano) | 1 | Membaca tombol, menghitung, dan mengendalikan layar |
| Keypad membran 4x4 | 1 | Angka 0–9, empat operasi, tombol sama dengan dan hapus |
| LCD 16x2 + modul I2C (PCF8574) | 1 | Menampilkan operasi dan hasil; cuma 2 kabel data |
| Kabel jumper male-to-male | 12 | 8 koneksi keypad + 4 koneksi LCD |
| Kabel USB | 1 | Upload kode dan daya |
Bagaimana keypad dibaca? Pemindaian baris-kolom
Keypad 4x4 punya 16 tombol terpisah, tapi hanya 8 pin. Tombol-tombolnya tersusun dalam kisi 4 baris dan 4 kolom; ketika ditekan, setiap tombol menghubungkan satu jalur baris ke satu jalur kolom. Library Keypad mengatur pin baris sebagai input dengan pull-up internal, menarik kolom ke LOW satu per satu, lalu mengecek baris mana yang terbaca LOW. Misalnya, kalau baris 3 juga terbaca LOW ketika kolom 2 LOW, tombol yang ditekan adalah '8' di baris 3, kolom 2. Pemindaian ini berjalan ratusan kali per detik, jadi kamu tidak akan merasakan jeda sama sekali. Library ini juga menerapkan debounce bawaan sekitar 10 ms, sehingga satu tekanan tidak terhitung dua kali. Detail pemindaiannya bisa kamu baca di Cara Memakai Keypad.
| Tombol | Fungsi di kalkulator |
|---|---|
| 0–9 | Input angka; angka bertambah digit demi digit |
| A | Penjumlahan (+) |
| B | Pengurangan (-) |
| C | Perkalian (*) |
| D | Pembagian (/) |
| # | Sama dengan (=), menampilkan hasil |
| * | Hapus (C), mereset semuanya |

Skema pengkabelan: pin Uno, ESP32, dan Pico
| Koneksi | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Keypad R1 | D9 | GPIO 13 | GP6 |
| Keypad R2 | D8 | GPIO 14 | GP7 |
| Keypad R3 | D7 | GPIO 27 | GP8 |
| Keypad R4 | D6 | GPIO 26 | GP9 |
| Keypad C1 | D5 | GPIO 25 | GP10 |
| Keypad C2 | D4 | GPIO 33 | GP11 |
| Keypad C3 | D3 | GPIO 32 | GP12 |
| Keypad C4 | D2 | GPIO 4 | GP13 |
| LCD GND | GND | GND | GND |
| LCD VCC | 5V | VIN (5 V) | VBUS (5 V, dari USB) |
| LCD SDA | A4 | GPIO 21 | GP4 |
| LCD SCL | A5 | GPIO 22 | GP5 |
Modul LCD I2C hanya punya empat kabel: GND, VCC, SDA, dan SCL. Di Uno, SDA ke A4 dan SCL ke A5. Kebanyakan modul memakai alamat 0x27; yang memakai chip PCF8574A memakai 0x3F. Kalau lampu latarnya menyala tapi tidak ada teks, putar dulu potensiometer kontras biru di belakang modul dengan obeng kecil. Kalau kamu tidak yakin alamatnya, jalankan kode scanner I2C di Cara Memakai Layar LCD I2C; kalau kamu penasaran bagaimana dua kabel bisa membawa begitu banyak perangkat, Apa Itu I2C adalah titik awal yang bagus.
Pemasangan langkah demi langkah
- Buka Library Manager di Arduino IDE lalu instal library Keypad (Mark Stanley, Alexander Brevig) dan LiquidCrystal I2C (Frank de Brabander). Kalau belum tahu caranya, lihat cara instal library.
- Hubungkan 8 pin keypad ke pin digital Uno dari D9 sampai D2, sesuai urutan di tabel.
- Hubungkan GND dan VCC modul LCD ke GND dan 5V Uno, SDA ke A4, dan SCL ke A5.
- Upload kode di bawah; ketika menyala, kamu seharusnya melihat “Hesap Makinesi” (bahasa Turki untuk “Kalkulator”) di layar.
- Tekan 1, 2, A, 5, dan # secara berurutan; kalau layar menampilkan hasil 17, rangkaian dan kodenya bekerja dengan benar.
- Kalau tidak ada teks, atur kontras dan coba alamat 0x3F; kalau tombolnya tertukar, cek array pinnya.
Kode kalkulator Arduino Uno
Kode ini menyusun angka yang diketik bukan sebagai teks (String), melainkan langsung sebagai bilangan bulat long; cara ini cepat dan tidak membebani RAM Uno yang cuma 2 KB. Angka pertama dan hasil disimpan dalam tipe yang kita sebut Number (float di Uno) agar bisa membawa bagian desimal. Kami menulis fungsi terpisah untuk setiap jenis tombol, jadi loop() tetap menjadi pembagi tugas singkat yang hanya meneruskan tombol yang ditekan ke fungsi yang tepat, dan kodenya mudah dibaca.
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}Bagaimana kode ini bekerja?
| Fungsi / variabel | Fungsinya apa |
|---|---|
| entry, digits | Angka yang sedang diketik dan jumlah digitnya; maksimal 7 digit di Uno |
| first, hasFirst | Angka pertama, atau hasil sementara pada operasi berantai |
| op | Operasi yang dipilih: '+', '-', '*', '/' atau 0 (tidak ada) |
| handleDigit() | Menambahkan digit ke belakang angka: entry = entry × 10 + digit |
| handleOperator() | Memindahkan angka ke first, menjalankan operasi yang tertunda jika ada, lalu menyimpan operasi baru |
| applyOp() | Menjalankan empat operasi; memberi error pada pembagian dengan nol dan overflow |
| handleEquals() | Menghitung hasil dan menampilkannya di baris bawah |
| clearAll() | Tombol *: mereset semua variabel dan membersihkan layar |
Rahasia menyusun angka ada di satu rumus: entry = entry × 10 + digit. Bayangkan kamu menekan 4, 7, lalu 2. Pada tekanan pertama entry menjadi 0 × 10 + 4 = 4, pada tekanan kedua 4 × 10 + 7 = 47, pada tekanan ketiga 47 × 10 + 2 = 472. Untuk mengubah karakter yang ditekan menjadi angka, kita memakai ekspresi k - '0': di tabel ASCII kode '0' adalah 48 dan kode '7' adalah 55, dan selisihnya tepat 7. Agar nol di depan tidak menghabiskan batas digit, penghitung digit direset selama entry bernilai 0; mengetik 0, 0, 5 menghasilkan angka 5 dan dihitung satu digit. Alasan batas 7 digit adalah presisi float yang akan kita bahas di bagian berikutnya.
Bagian paling cerdas dari kode ini adalah operasi berantai. Kalau kamu mengetik 5 + 3 lalu menekan B (pengurangan) alih-alih #, handleOperator() lebih dulu menjalankan penjumlahan yang tertunda, menulis hasil sementara 8 ke first, lalu menyimpan operasi pengurangan; jadi 5 + 3 - 2 dihitung dari kiri ke kanan persis seperti di kalkulator saku dan menghasilkan 6. Ingat, tidak ada prioritas operasi: 2 + 3 × 4 menghasilkan 20, bukan 14, dan kebanyakan kalkulator sederhana juga berperilaku sama. Kalau kamu menekan tombol operasi setelah hasil ditampilkan, hasil itu menjadi angka pertama dan kamu bisa melanjutkan hitungan; kalau kamu menekan tombol angka, hitungan baru dimulai. Flag justCalculated yang mengatur perilaku ini sebenarnya adalah state machine kecil; untuk belajar lebih jauh, lihat state machine Arduino.
Cek pembagian dengan nol dan overflow
Membagi angka dengan nol tidak terdefinisi dalam matematika, dan Arduino tidak mencegahnya dengan sendirinya: pada pembagian float, angka positif dibagi nol menghasilkan inf (tak hingga) dan nol dibagi nol menghasilkan nan (bukan angka), lalu nilai tak bermakna tercetak di layar. Karena itu applyOp() mengecek apakah pembaginya nol sebelum membagi; kalau iya, pesan “Sifira bolunmez” (bahasa Turki untuk “Tidak bisa dibagi nol”) ditampilkan selama 1,5 detik dan kalkulator direset. Pengaman kedua adalah untuk overflow. Di Uno, float berukuran 32-bit dan memberi presisi sekitar 6–7 digit signifikan; bilangan bulat di atas 16.777.216 tidak lagi bisa disimpan dengan tepat dan digit terakhirnya bisa dibulatkan. Fungsi print Arduino juga mencetak nilai float di atas sekitar 4,29 miliar sebagai “ovf”. Kode ini memberi error “Tasma” (overflow) kalau nilai absolut hasilnya melebihi 99.999.999, jadi pengguna tidak pernah melihat hasil yang tidak muat di layar 16 karakter atau tidak bisa dipercaya.
Kalkulator dengan ESP32
Kode yang sama jalan di ESP32; yang perlu kamu ubah hanya array pin dan, kalau mau, tipe angkanya. Untuk LCD dipakai pin I2C default ESP32, yaitu GPIO 21 (SDA) dan GPIO 22 (SCL); library LiquidCrystal I2C memulai Wire dengan pin ini sendiri. Ada satu keuntungan lagi: di ESP32, double benar-benar 64-bit dan memberi sekitar 15 digit signifikan. Kalau kamu membuat Number menjadi double, batas digit bisa dinaikkan ke 9 dan perkalian besar terhitung benar sampai digit terakhir. Di Uno, double dan float adalah tipe 32-bit yang sama, jadi perubahan ini tidak ada bedanya di sana. Kalau kamu baru pertama kali memakai ESP32, pengaturan board-nya sudah kami bahas di Apa Itu ESP32?.
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)Kalkulator dengan Raspberry Pi Pico dan MicroPython
Di Pico, kita menulis pemindaiannya sendiri sebagai pengganti library Keypad Arduino; ini latihan yang bagus untuk benar-benar memahami pemindaian matriks. Baris dihubungkan ke GP6–GP9 sebagai input dengan pull-up, kolom ke GP10–GP13 sebagai output, dan setiap kolom dibuat LOW bergiliran. Karena MicroPython tidak punya modul LCD siap pakai, kamu perlu menyalin file driver lcd_api.py dan pico_i2c_lcd.py ke Pico dengan Thonny. Di Pico float juga 32-bit, jadi batas digitnya tetap 7; tapi di Python sangat mudah menyusun angka sebagai teks lalu mengubahnya dengan float(). Peringatan 5 V yang kami berikan untuk ESP32 juga berlaku untuk Pico. Kalau kamu baru mengenal Pico, lihat Apa Itu Raspberry Pi Pico? dan dasar-dasar 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()Ide untuk mengembangkan kalkulator
- Titik desimal: Jadikan kombinasi tombol yang tidak terpakai sebagai titik desimal; tambahkan setiap digit setelah titik ke angka dengan pengali yang makin kecil seperti 0,1, 0,01.
- Tombol memori (M+, MR): Tulis hasilnya ke EEPROM; hasil terakhir tidak hilang walaupun Arduino dimatikan.
- Bunyi tombol: Tambahkan buzzer untuk bunyi bip pendek di setiap tekanan; untuk buzzer di D10, baris tone(10, 2000, 30) sudah cukup.
- Mode ilmiah: Tambahkan akar kuadrat (sqrt), pangkat (pow), dan persentase dengan lapisan tombol kedua.
- Layar lebih besar: Pakai layar OLED sebagai pengganti LCD 16x2 dan tampilkan riwayat hitungan baris demi baris.
- Catatan hitungan: Cetak juga setiap hasil ke Serial Monitor untuk menyimpan riwayat hitungan di komputermu.
- Kunci kode: Buat kunci pintu dengan keypad memakai keypad dan LCD yang sama; logika penyusunan angka bekerja sama persis di sana.
Kesalahan umum dan cara memperbaikinya
| Masalah | Kemungkinan penyebab | Solusi |
|---|---|---|
| LCD menyala tapi tidak ada teks | Kontras belum diatur atau alamat I2C salah | Putar potensiometer di belakang; coba 0x3F sebagai ganti 0x27 |
| Kotak hitam di baris atas | LCD belum diinisialisasi atau jalur I2C putus | Pastikan lcd.init() dipanggil dan SDA/SCL ada di A4/A5 |
| Tombol memberi karakter yang salah | Pin baris dan kolom tertukar | Tukar atau balik urutan array rowPins dan colPins |
| Satu tombol terhitung dua kali | Pantulan kontak | Naikkan waktu debounce dengan keypad.setDebounceTime(50) |
| Tidak ada tombol yang berfungsi | Memakai pin 0/1 di Uno atau GPIO 34–39 di ESP32 | Pakai pin yang ada di tabel |
| Digit terakhir salah pada perkalian besar | Float di Uno hanya menampung 6–7 digit | Pertahankan batas digit atau pakai double di ESP32 |
| Hasil pembagian tanpa desimal | Operasinya dilakukan dengan dua bilangan bulat (int/long) | Ubah minimal satu sisi ke float; di kode ini first sudah bertipe Number |
Kalkulator yang kamu buat dengan keypad dan LCD I2C ini menggabungkan pembacaan input, penyimpanan status, penanganan error, dan batas memori angka dalam satu proyek. Logika yang sama akan kamu pakai berulang kali di kunci kode, penghitung, dan sistem menu. Di aplikasi BlueGrays kamu bisa menjelajahi proyek seperti kalkulator I2C, aplikasi password dengan keypad 4x4 dan LCD, serta brankas elektronik pintar, lengkap dengan skema rangkaian langkah demi langkah dan kode siap pakai, lalu membuat versimu sendiri.
Pertanyaan umum
Bagaimana cara membuat kalkulator dengan Arduino?
Cukup Arduino Uno, keypad 4x4, dan LCD I2C 16x2. 8 pin keypad dihubungkan ke pin digital, sedangkan SDA dan SCL LCD ke A4 dan A5. Dengan library Keypad dan LiquidCrystal I2C kamu membaca tombol, menyusun angka dengan rumus entry = entry × 10 + digit, dan menjalankan operasi yang dipilih dengan tombol #.
Berapa pin yang dipakai keypad 4x4?
Keypad 4x4 memakai total 8 pin digital, untuk 4 baris dan 4 kolom. Di Arduino Uno biasanya dipilih pin D2–D9, karena D0 dan D1 dipakai untuk komunikasi serial. Kalau pinmu kurang, modul keypad I2C berbasis PCF8574 bisa memangkas koneksinya menjadi dua kabel data.
Bagaimana menampilkan hasil desimal di kalkulator Arduino?
Simpan hasilnya di variabel float dan tentukan jumlah angka desimal sebagai parameter kedua, misalnya lcd.print(result, 3). Ketika kamu membagi dua bilangan bulat (int atau long), bagian desimalnya hilang; 7 / 2 menghasilkan 3. Kalau minimal satu angka diubah ke float sebelum dibagi, kamu mendapat 3,5.
Apa yang terjadi kalau membagi dengan nol di Arduino?
Pembagian dengan nol pada bilangan bulat tidak terdefinisi dan bisa menghasilkan nilai yang tidak konsisten; pada pembagian float hasilnya inf atau nan. Arduino tetap berjalan, tapi kamu melihat nilai tak bermakna di layar. Jadi sebelum membagi, cek dengan if apakah pembaginya nol dan tampilkan pesan error ke pengguna.
Kenapa LCD I2C-ku tidak menampilkan teks?
Dua penyebab paling umum adalah kontras yang belum diatur dan alamat I2C yang salah. Putar potensiometer di belakang modul untuk mengatur kontras, lalu coba alamat 0x27 dan 0x3F. Kalau masih bermasalah, pakai sketch scanner I2C untuk mengecek apakah modulnya terdeteksi di bus.
Apakah kalkulator Arduino mengikuti prioritas operasi?
Kode di panduan ini, seperti kebanyakan kalkulator saku, menjalankan operasi dari kiri ke kanan; 2 + 3 × 4 menghasilkan 20. Untuk prioritas operasi, kamu perlu menulis parser yang menyimpan ekspresinya dulu di sebuah array lalu menghitung perkalian dan pembagian sebelum penjumlahan dan pengurangan. Ini latihan pemrograman yang bagus untuk level berikutnya.
Proyek untuk dibuat setelah membaca ini
Lihat semua proyek
Kalkulator I2C Arduino
Proyek kalkulator berbasis Arduino yang melakukan penjumlahan, pengurangan, perkalian, dan pembagian memakai keypad membran 4x4 dan layar LCD I2C 16x2. Berkat I2C, sambungan layar hanya butuh 2 kabel, sehingga kabel tidak semrawut dan lebih banyak pin tetap bebas dipakai. Kalkulator ini juga mendukung input bilangan desimal dan bilangan negatif.

Menggunakan Keypad 4x4
Di keypad 4x4, yang mirip sekali dengan tombol telepon, Arduino langsung tahu tombol mana yang kamu tekan dan menuliskannya ke layar komputermu.

Kunci Sandi dengan Keypad 4x4 dan LCD
Kunci pintu elektronik kecil yang menahan siapa pun yang tidak tahu kodenya. Kamu menekan tombol pagar lalu mengetik kodenya di keypad; jika benar, layar menulis akses diberikan, LED hijau menyala…

Menggunakan Keypad 3x4
Arduino langsung tahu tombol mana yang kamu tekan di keypad 12 tombol yang mirip tombol telepon, lalu menuliskannya di layar komputermu.

Kendali LED dengan Keypad 3x4
Dengan keypad seperti di telepon, kamu mengendalikan tiga lampu terpisah. Tombol 1, 2, dan 3 menyalakan LED hijau, biru, dan kuning, tombol 4, 5, dan 6 mematikan lampu yang sama, tombol bintang…

Menggunakan Layar LCD dengan I2C
Beri Arduino-mu layar sendiri dan buat ia menulis pesan pertamanya. Layar LCD dua baris tersambung hanya dengan beberapa kabel; sapaan muncul di baris atas, lalu pesan kedua di baris bawah, layar…

Brankas Elektronik Pintar
Brankas kecil untuk barang berhargamu yang terbuka dengan kode. Kamu mengetik kode empat digitmu di keypad; jika benar, motor servo membuka kunci, lampu hijau menyala, dan layar menampilkan keadaan…

Layar LCD I2C ESP32 (16x2)
Di proyek ini, kita menampilkan teks dengan menyambungkan layar LCD karakter 16x2 ke ESP32 lewat protokol I2C. Berkat I2C, kita bisa mengendalikan layar hanya dengan dua pin data (SDA dan SCL), sehingga tidak perlu memboroskan 6+ pin seperti pada sambungan paralel klasik. Kode mencetak pesan tetap di baris pertama dan penghitung yang naik setiap detik di baris kedua. Selain itu, kita menjalankan pemindai I2C di awal untuk mencetak alamat layar ke Serial Monitor (biasanya 0x27).
Artikel lainnya
Aplikasi BlueGrays
Rakit rangkaian ini langkah demi langkah di ponselmu
Skema pengkabelan, kode, dan daftar komponen dalam satu layar. 500+ proyek Arduino, ESP32, dan Pico siap dibuat.
Pindai dengan ponselmu
Arahkan kamera ke kode ini dan toko aplikasi di ponselmu akan terbuka.
atau buka toko aplikasi

