Arduino Taschenrechner: 4x4 Keypad und I2C LCD bauen
Arduino Taschenrechner bauen: 4x4 Keypad und I2C-LCD anschließen, Tasten belegen, Grundrechenarten, Division durch Null, Code für Uno, ESP32, Pico.
Ein Arduino Taschenrechner ist ein Projekt mit einem 4x4 Keypad (Tastenfeld), einem 16x2 I2C-LCD und ein paar Jumperkabeln, das Spaß macht und dir wirklich Programmieren beibringt. Du tippst Zahlen ein, wählst mit den Tasten A, B, C und D Addition, Subtraktion, Multiplikation oder Division, siehst mit # das Ergebnis auf dem Display, und mit * löschst du alles. In dieser Anleitung lernst du Schritt für Schritt, wie du die Schaltung aufbaust, Tasten Rechenoperationen zuordnest, aus gedrückten Ziffern eine mehrstellige Zahl bildest, Fehler wie die Division durch Null abfängst und das Projekt auf ESP32 und Raspberry Pi Pico überträgst.
Auch wenn ein Taschenrechner wie ein kleines Projekt aussieht, steckt fast alles Grundlegende der Embedded-Programmierung darin: Eingaben per Matrixabtastung einlesen, Zustände in Variablen speichern, Verzweigungen, die Grenzen von Gleitkommazahlen und sinnvolle Rückmeldungen für den Nutzer. Deshalb eignet er sich gut für Schulprojekte, Wissenschaftsmessen und Programmierkurse. Ich erkläre dir jede wichtige Codezeile; am Ende kannst du eigene Erweiterungen wie Dezimalpunkt, Speichertaste oder Tastenton selbst einbauen.

Wie funktioniert ein Arduino Taschenrechner?
Es hilft, das Projekt in drei Teile zu gliedern. Auf der Eingabeseite liefert das Keypad die gedrückte Taste als einzelnes Zeichen (zum Beispiel '7', 'A', '#'). Bei der Verarbeitung speichert der Arduino in Variablen die Zahl, die gerade getippt wird, die erste Zahl (oder das Zwischenergebnis) und die gewählte Operation. Auf der Ausgabeseite zeigt das I2C-LCD in der oberen Zeile die erste Zahl mit Operator und in der unteren Zeile die aktuelle Eingabe oder das Ergebnis. Echte Taschenrechner arbeiten genau so: Jede Taste ändert einen kleinen Zustand im Gerät, und das Display zeigt den aktuellen Zustand.
| Bauteil | Anzahl | Aufgabe |
|---|---|---|
| Arduino Uno (oder Nano) | 1 | Liest Tasten, rechnet, steuert das Display |
| 4x4 Folien-Keypad | 1 | Ziffern 0–9, Grundrechenarten, Gleich- und Löschtaste |
| 16x2 LCD + I2C-Modul (PCF8574) | 1 | Zeigt Rechnung und Ergebnis; nur 2 Datenleitungen |
| Jumperkabel Stecker-Stecker | 12 | 8 Keypad- + 4 LCD-Anschlüsse |
| USB-Kabel | 1 | Code hochladen und Stromversorgung |
Wie liest man ein Keypad aus? Zeilen-Spalten-Abtastung
In einem 4x4 Keypad stecken 16 einzelne Taster, aber es hat nur 8 Pins. Die Taster sind in einem Raster aus 4 Zeilen und 4 Spalten angeordnet; beim Drücken verbindet jede Taste eine Zeilenleitung mit einer Spaltenleitung. Die Keypad-Bibliothek schaltet die Zeilenpins als Eingänge mit internem Pull-up-Widerstand, setzt die Spalten nacheinander auf LOW und prüft, welche Zeile LOW liest. Liest zum Beispiel bei LOW auf Spalte 2 auch Zeile 3 LOW, ist die gedrückte Taste die '8' in Zeile 3, Spalte 2. Da diese Abtastung hunderte Male pro Sekunde läuft, merkst du keine Verzögerung. Die Bibliothek wendet außerdem eine interne Entprellung von etwa 10 ms an, damit ein einzelner Druck nicht doppelt gezählt wird. Details zur Abtastung findest du im Beitrag Keypad (Tastenfeld) verwenden.
| Taste | Funktion im Taschenrechner |
|---|---|
| 0–9 | Ziffern eingeben; die Zahl wächst Stelle für Stelle |
| A | Addition (+) |
| B | Subtraktion (-) |
| C | Multiplikation (*) |
| D | Division (/) |
| # | Gleich (=), zeigt das Ergebnis |
| * | Löschen (C), setzt alles zurück |

Schaltplan: Pins für Uno, ESP32 und Pico
| Anschluss | 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, vom USB) |
| LCD SDA | A4 | GPIO 21 | GP4 |
| LCD SCL | A5 | GPIO 22 | GP5 |
Das I2C-LCD-Modul hat nur vier Leitungen: GND, VCC, SDA und SCL. Beim Uno kommt SDA an A4 und SCL an A5. Die meisten Module nutzen die Adresse 0x27; Module mit PCF8574A-Chip liegen auf 0x3F. Leuchtet die Hintergrundbeleuchtung, aber du siehst keinen Text, drehst du zuerst mit einem kleinen Schraubendreher am blauen Kontrast-Potentiometer auf der Rückseite. Bist du bei der Adresse unsicher, lade den I2C-Scanner-Code aus dem Beitrag I2C-LCD-Display verwenden hoch; wie zwei Leitungen so viele Geräte bedienen können, erfährst du in Was ist I2C?.
Aufbau Schritt für Schritt
- Öffne in der Arduino IDE den Bibliotheksverwalter und installiere die Bibliotheken Keypad (Mark Stanley, Alexander Brevig) und LiquidCrystal I2C (Frank de Brabander). Wenn du nicht weißt, wie das geht, lies Bibliothek hinzufügen.
- Verbinde die 8 Pins des Keypads in der Reihenfolge der Tabelle mit den Digitalpins D9 bis D2 des Uno.
- Verbinde GND und VCC des LCD-Moduls mit GND und 5V des Uno, SDA mit A4 und SCL mit A5.
- Lade den folgenden Code hoch; beim Start solltest du auf dem Display "Hesap Makinesi" sehen.
- Drücke nacheinander 1, 2, A, 5 und #; zeigt das Display 17 als Ergebnis, funktionieren Schaltung und Code.
- Siehst du keinen Text, stelle den Kontrast ein und probiere die Adresse 0x3F; sind die Tasten vertauscht, prüfe die Pin-Arrays.
Arduino-Uno-Taschenrechner-Code
Der Code sammelt die eingegebene Zahl nicht als Text (String), sondern direkt als Ganzzahl vom Typ long; das ist schnell und schont die 2 KB RAM des Uno. Die erste Zahl und die Ergebnisse werden in einem Typ namens Number gespeichert (beim Uno float), damit sie Nachkommastellen haben können. Für jede Tastenart gibt es eine eigene Funktion; so bleibt loop() ein kurzer Verteiler, der die gedrückte Taste an die richtige Funktion weitergibt, und der Code ist gut lesbar.
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}Wie funktioniert der Code?
| Funktion / Variable | Was sie tut |
|---|---|
| entry, digits | Die gerade getippte Zahl und ihre Stellenzahl; beim Uno höchstens 7 Stellen |
| first, hasFirst | Erste Zahl oder Zwischenergebnis bei verketteten Rechnungen |
| op | Gewählte Operation: '+', '-', '*', '/' oder 0 (keine Operation) |
| handleDigit() | Hängt die Ziffer ans Ende der Zahl: entry = entry × 10 + Ziffer |
| handleOperator() | Überträgt die Zahl nach first, führt bei Bedarf die offene Operation aus und merkt sich die neue |
| applyOp() | Führt die vier Grundrechenarten aus; meldet Fehler bei Division durch Null und Überlauf |
| handleEquals() | Berechnet das Ergebnis und zeigt es in der unteren Zeile |
| clearAll() | Taste *: setzt alle Variablen zurück und löscht das Display |
Das Geheimnis des Zahlenaufbaus ist eine einzige Formel: entry = entry × 10 + Ziffer. Stell dir vor, du drückst nacheinander 4, 7 und 2. Beim ersten Druck wird entry zu 0 × 10 + 4 = 4, beim zweiten 4 × 10 + 7 = 47, beim dritten 47 × 10 + 2 = 472. Um das gedrückte Zeichen in eine Zahl umzuwandeln, verwenden wir den Ausdruck k - '0': In der ASCII-Tabelle hat das Zeichen '0' den Code 48 und '7' den Code 55, die Differenz beträgt genau 7. Damit führende Nullen das Stellenlimit nicht verbrauchen, wird der Stellenzähler zurückgesetzt, solange entry 0 ist; tippst du also 0, 0, 5, ergibt das die Zahl 5 und zählt als eine Stelle. Warum wir das Limit auf 7 Stellen setzen, erkläre ich im nächsten Abschnitt über die float-Genauigkeit.
Der cleverste Teil des Codes sind die verketteten Rechnungen. Tippst du 5 + 3 und drückst statt # direkt B (Subtraktion), führt handleOperator() zuerst die offene Addition aus, schreibt das Zwischenergebnis 8 in die Variable first und merkt sich dann die Subtraktion; 5 + 3 - 2 wird also wie beim Taschenrechner von links nach rechts berechnet und ergibt 6. Denk daran, dass es keine Punkt-vor-Strich-Regel gibt: 2 + 3 × 4 ergibt 20 statt 14, so verhalten sich die meisten einfachen Taschenrechner auch. Drückst du nach der Ergebnisanzeige eine Operationstaste, wird das Ergebnis zur ersten Zahl und du rechnest weiter; drückst du eine Ziffer, beginnt eine neue Rechnung. Das Flag justCalculated, das dieses Verhalten steuert, ist im Grunde eine kleine Zustandsmaschine; mehr dazu findest du im Beitrag Zustandsmaschine mit Arduino.
Division durch Null und Überlauf abfangen
Eine Zahl durch Null zu teilen ist in der Mathematik nicht definiert, und der Arduino verhindert das nicht von selbst: Bei der float-Division ergibt eine positive Zahl durch Null inf (unendlich), Null durch Null ergibt nan (keine Zahl), und auf dem Display erscheint ein sinnloser Wert. Deshalb prüft applyOp() vor der Division, ob der Divisor Null ist; falls ja, zeigt es 1,5 Sekunden lang die Meldung "Sifira bolunmez" und setzt den Taschenrechner zurück. Der zweite Schutz gilt dem Überlauf. Beim Uno ist float 32 Bit breit und liefert etwa 6–7 signifikante Stellen; Ganzzahlen über 16.777.216 lassen sich nicht mehr exakt speichern, und die letzte Stelle kann gerundet werden. Außerdem gibt die print-Funktion des Arduino float-Werte über etwa 4,29 Milliarden als "ovf" aus. Der Code meldet "Tasma" (Überlauf), wenn der Betrag des Ergebnisses 99.999.999 überschreitet; so zeigt er nie Ergebnisse, die nicht auf das 16-stellige Display passen oder nicht verlässlich sind.
Taschenrechner mit dem ESP32
Derselbe Code läuft auch auf dem ESP32; du musst nur die Pin-Arrays und optional den Zahlentyp ändern. Für das LCD werden die Standard-I2C-Pins des ESP32 verwendet: GPIO 21 (SDA) und GPIO 22 (SCL); die Bibliothek LiquidCrystal I2C startet Wire selbst mit diesen Pins. Ein weiterer Vorteil: Beim ESP32 ist double wirklich 64 Bit breit und bietet etwa 15 signifikante Stellen. Machst du Number zu double, kannst du das Stellenlimit auf 9 erhöhen und große Multiplikationen bis zur letzten Stelle genau berechnen. Beim Uno sind double und float derselbe 32-Bit-Typ, dort bringt die Änderung nichts. Wenn du den ESP32 zum ersten Mal benutzt, findest du die Board-Einrichtung im Beitrag Was ist der 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)Taschenrechner mit Raspberry Pi Pico und MicroPython
Auf dem Pico ersetzen wir die Keypad-Bibliothek von Arduino durch eine selbst geschriebene Abtastung; das ist eine tolle Übung, um die Matrixabtastung wirklich zu verstehen. Die Zeilen kommen als Eingänge mit Pull-up an GP6–GP9, die Spalten als Ausgänge an GP10–GP13, und jede Spalte wird nacheinander auf LOW gesetzt. Da es in MicroPython kein fertiges LCD-Modul gibt, musst du die Treiberdateien lcd_api.py und pico_i2c_lcd.py mit Thonny auf den Pico kopieren. Auch beim Pico ist float 32 Bit breit, das Stellenlimit bleibt also bei 7; in Python ist es aber sehr einfach, die Zahl als Text zu sammeln und mit float() umzuwandeln. Der 5-V-Hinweis für den ESP32 gilt auch für den Pico. Bist du neu beim Pico, lies Was ist der Raspberry Pi Pico? und MicroPython-Grundlagen.
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()Ideen zum Erweitern des Taschenrechners
- Dezimalpunkt: Belege eine ungenutzte Tastenkombination mit dem Dezimalpunkt; jede Ziffer nach dem Punkt addierst du mit fallenden Faktoren wie 0,1, 0,01 zur Zahl.
- Speichertasten (M+, MR): Schreibe das Ergebnis ins EEPROM; das letzte Ergebnis geht auch nach dem Ausschalten nicht verloren.
- Tastenton: Füge für einen kurzen Piepton bei jedem Druck einen Buzzer hinzu; für einen Buzzer an D10 genügt die Zeile tone(10, 2000, 30).
- Wissenschaftlicher Modus: Ergänze Wurzel (sqrt), Potenz (pow) und Prozentrechnung mit einer zweiten Tastenebene.
- Größeres Display: Nimm statt des 16x2-LCD ein OLED-Display und zeige den Rechenverlauf Zeile für Zeile an.
- Rechenprotokoll: Gib jedes Ergebnis auch im Serial Monitor aus und führe so am Computer einen Rechenverlauf.
- Zahlenschloss: Baue mit demselben Keypad und LCD ein Türschloss mit Code; die Logik zum Zahlenaufbau funktioniert dort genauso.
Häufige Fehler und Lösungen
| Problem | Mögliche Ursache | Lösung |
|---|---|---|
| LCD leuchtet, aber kein Text | Kontrast falsch eingestellt oder I2C-Adresse falsch | Potentiometer auf der Rückseite drehen; 0x3F statt 0x27 probieren |
| Schwarze Kästchen in der oberen Zeile | LCD nicht initialisiert oder I2C-Leitung unterbrochen | Prüfen, ob lcd.init() aufgerufen wird und SDA/SCL an A4/A5 hängen |
| Tasten liefern falsche Zeichen | Zeilen- und Spaltenpins vertauscht | Die Arrays rowPins und colPins tauschen oder umkehren |
| Eine Taste wird doppelt gezählt | Kontaktprellen | Entprellzeit mit keypad.setDebounceTime(50) erhöhen |
| Keine Taste funktioniert | Beim Uno Pins 0/1 oder beim ESP32 GPIO 34–39 benutzt | Die Pins aus der Tabelle verwenden |
| Bei großen Produkten ist die letzte Stelle falsch | Beim Uno trägt float nur 6–7 Stellen | Stellenlimit beibehalten oder auf dem ESP32 double verwenden |
| Divisionsergebnis ohne Nachkommastellen | Rechnung mit zwei Ganzzahlen (int/long) | Mindestens eine Seite in float umwandeln; in diesem Code ist first schon vom Typ Number |
Dieser Taschenrechner mit Keypad und I2C-LCD vereint Eingabe einlesen, Zustände speichern, Fehlerbehandlung und die Grenzen von Zahlen im Speicher in einem einzigen Projekt. Dieselbe Logik wirst du immer wieder bei Codeschlössern, Zählern und Menüsystemen einsetzen. In der BlueGrays-App findest du Projekte wie den I2C-Taschenrechner, eine LCD-Code-Anwendung mit 4x4 Keypad und einen smarten Elektroniksafe mit Schaltplan und fertigem Code Schritt für Schritt und kannst eine eigene Version entwickeln.
Häufige Fragen
Wie baut man einen Taschenrechner mit Arduino?
Ein Arduino Uno, ein 4x4 Keypad und ein I2C-16x2-LCD genügen. Die 8 Pins des Keypads kommen an Digitalpins, SDA und SCL des LCD an A4 und A5. Mit den Bibliotheken Keypad und LiquidCrystal I2C liest du die Tasten, baust Zahlen mit der Formel entry = entry × 10 + Ziffer auf und führst die gewählte Operation mit der Taste # aus.
Wie viele Pins braucht ein 4x4 Keypad?
Ein 4x4 Keypad braucht für 4 Zeilen und 4 Spalten insgesamt 8 Digitalpins. Beim Arduino Uno nimmt man meist D2–D9, weil D0 und D1 für die serielle Kommunikation reserviert sind. Reichen die Pins nicht, kannst du mit einem I2C-Keypad-Modul auf PCF8574-Basis den Anschluss auf zwei Datenleitungen reduzieren.
Wie zeigt man beim Arduino-Taschenrechner Dezimalzahlen an?
Speichere das Ergebnis in einer float-Variablen und gib mit einem zweiten Parameter wie lcd.print(ergebnis, 3) die Anzahl der Nachkommastellen an. Teilst du zwei Ganzzahlen (int oder long), geht der Nachkommateil verloren; 7 / 2 ergibt 3. Wandelst du vor der Division mindestens eine Zahl in float um, erhältst du 3,5.
Was passiert beim Arduino bei Division durch Null?
Bei Ganzzahlen ist das Ergebnis der Division durch Null nicht definiert und kann unterschiedliche Werte liefern; bei der float-Division ergibt sich inf oder nan. Der Arduino läuft weiter, aber du siehst einen sinnlosen Wert auf dem Display. Prüfe deshalb vor der Division mit if, ob der Divisor Null ist, und zeige eine Fehlermeldung an.
Warum zeigt mein I2C-LCD keinen Text an?
Die häufigsten Ursachen sind ein falsch eingestellter Kontrast und eine falsche I2C-Adresse. Stelle den Kontrast mit dem Potentiometer auf der Modulrückseite ein und probiere dann die Adressen 0x27 und 0x3F. Hilft das nicht, prüfe mit dem I2C-Scanner-Code, ob das Modul am Bus erscheint.
Beachtet der Arduino-Taschenrechner Punkt-vor-Strich?
Der Code in dieser Anleitung rechnet wie die meisten Taschenrechner von links nach rechts; 2 + 3 × 4 ergibt 20. Für die Rechenreihenfolge musst du einen Parser schreiben, der den Ausdruck zuerst in einem Array speichert und Multiplikation und Division vor Addition und Subtraktion berechnet. Das ist eine schöne Programmierübung für die nächste Stufe.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Arduino I2C-Rechner
Es handelt sich um ein Arduino-basiertes Taschenrechnerprojekt, das Addition, Subtraktion, Multiplikation und Division mit einer 4x4-Folientastatur und einem 16x2 I2C-LCD-Display durchführt. Dank I2C ist der Anschluss des Displays mit nur 2 Kabeln möglich, was den Kabelsalat reduziert und mehr Pins für die Verwendung offen hält. Die Eingabe von Dezimalzahlen und die Unterstützung negativer Zahlen sind ebenfalls möglich.

4x4-Tastenfeld verwenden
Auf dem 4x4-Tastenfeld, das an die Tasten eines Telefons erinnert, erkennt der Arduino sofort, welche Taste du gedrückt hast, und schreibt sie auf deinen Computerbildschirm.

Passwortschloss mit 4x4-Tastenfeld und LCD
Ein kleines elektronisches Türschloss, das niemanden ohne den richtigen Code hereinlässt.

3x4-Tastenfeld verwenden
Der Arduino erkennt sofort, welche Taste du auf einem 12-Tasten-Feld drückst, das wie eine Telefontastatur aussieht, und schreibt sie auf deinen Computerbildschirm.

LED-Steuerung mit 3x4-Tastenfeld
Mit einem Tastenfeld wie beim Telefon steuerst du drei einzelne Lichter. Die Tasten 1, 2 und 3 schalten die grüne, blaue und gelbe LED ein, 4, 5 und 6 schalten dieselben wieder aus; die Sterntaste…

Verwendung des LCD-Bildschirms mit I2C
Gib deinem Arduino ein eigenes Display und lass es seine erste Nachricht schreiben.

Intelligenter elektronischer Safe
Ein kleiner Tresor für deine Wertsachen, der sich mit einem Code öffnet. Du tippst deinen vierstelligen Code auf dem Tastenfeld ein; stimmt er, öffnet der Servomotor das Schloss, das grüne Licht geht…

ESP32 I2C-LCD-Display (16×2)
In diesem Projekt schließen wir ein 16x2-Zeichen-LCD über I2C an den ESP32 an und zeigen Text an. Dank I2C reichen 2 Datenpins (SDA und SCL) statt der 6+ Pins einer klassischen Parallelverbindung. Der Code schreibt eine feste Nachricht in die erste Zeile und einen sekündlich steigenden Zähler in die zweite. Beim Start gibt ein I2C-Scanner die Adresse des Displays im Serial Monitor aus (meist 0x27 oder 0x3F).
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

