Ratgeber · 9 Min. Lesezeit

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.

4x4 Folientastatur (Keypad)
4x4 Folien-Keypad: 16 Tasten, 8 Pins (4 Zeilen + 4 Spalten). Die Eingabeeinheit des Taschenrechners.

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.

BauteilAnzahlAufgabe
Arduino Uno (oder Nano)1Liest Tasten, rechnet, steuert das Display
4x4 Folien-Keypad1Ziffern 0–9, Grundrechenarten, Gleich- und Löschtaste
16x2 LCD + I2C-Modul (PCF8574)1Zeigt Rechnung und Ergebnis; nur 2 Datenleitungen
Jumperkabel Stecker-Stecker128 Keypad- + 4 LCD-Anschlüsse
USB-Kabel1Code 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.

TasteFunktion im Taschenrechner
0–9Ziffern eingeben; die Zahl wächst Stelle für Stelle
AAddition (+)
BSubtraktion (-)
CMultiplikation (*)
DDivision (/)
#Gleich (=), zeigt das Ergebnis
*Löschen (C), setzt alles zurück
I2C 2x16 LCD-Display
16x2 LCD mit angelötetem PCF8574-I2C-Modul: Die Operation steht oben, Zahl und Ergebnis unten.

Schaltplan: Pins für Uno, ESP32 und Pico

AnschlussArduino 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, vom USB)
LCD SDAA4GPIO 21GP4
LCD SCLA5GPIO 22GP5
Bei den meisten Folien-Keypads liegen die 8 Pins von links nach rechts in der Reihenfolge R1, R2, R3, R4, C1, C2, C3, C4, bei manchen Modellen ist die Reihenfolge aber anders. Siehst du beim Druck auf '1' auf dem Display '4', 'A' oder 'D', sind Zeilen und Spalten vertauscht oder umgekehrt; korrigiere dann die Arrays rowPins und colPins im Code, statt die Kabel umzustecken. Benutze beim Uno nicht die Pins 0 und 1; sie sind für die serielle USB-Kommunikation reserviert und blockieren das Hochladen.

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

  1. Ö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.
  2. Verbinde die 8 Pins des Keypads in der Reihenfolge der Tabelle mit den Digitalpins D9 bis D2 des Uno.
  3. Verbinde GND und VCC des LCD-Moduls mit GND und 5V des Uno, SDA mit A4 und SCL mit A5.
  4. Lade den folgenden Code hoch; beim Start solltest du auf dem Display "Hesap Makinesi" sehen.
  5. Drücke nacheinander 1, 2, A, 5 und #; zeigt das Display 17 als Ergebnis, funktionieren Schaltung und Code.
  6. 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.

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}

Wie funktioniert der Code?

Funktion / VariableWas sie tut
entry, digitsDie gerade getippte Zahl und ihre Stellenzahl; beim Uno höchstens 7 Stellen
first, hasFirstErste Zahl oder Zwischenergebnis bei verketteten Rechnungen
opGewä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.

Im Zeichensatz des LCD fehlen türkische Buchstaben wie ş, ı, ğ; deshalb sind die Meldungen mit ASCII-Zeichen geschrieben, etwa "Sonuc" und "Sifira bolunmez". Willst du Sonderzeichen, kannst du mit createChar() bis zu 8 eigene Zeichen definieren. Flackert das Display, aktualisiere bei jeder Taste nur die geänderte Zeile statt lcd.clear(); der Befehl clear() dauert etwa 2 ms und löscht das Bild kurz.

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?.

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)
Die Pins des ESP32 arbeiten mit 3,3 V und sind offiziell nicht 5-V-tolerant. Wenn du das LCD-Modul über VIN (5 V) versorgst, ziehen die Pull-up-Widerstände auf der PCF8574-Platine SDA und SCL auf 5 V hoch. Bei kurzen Tests geht das oft gut, aber bei einem Dauereinsatz solltest du einen Logikpegelwandler einbauen. Nutze für das Keypad nicht die GPIO 34–39: Diese Pins sind reine Eingänge und haben keine internen Pull-up-Widerstände. Am sichersten meidest du außerdem Strapping-Pins wie GPIO 0, 2, 12 und 15, die das Startverhalten des Boards beeinflussen.

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.

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

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

ProblemMögliche UrsacheLösung
LCD leuchtet, aber kein TextKontrast falsch eingestellt oder I2C-Adresse falschPotentiometer auf der Rückseite drehen; 0x3F statt 0x27 probieren
Schwarze Kästchen in der oberen ZeileLCD nicht initialisiert oder I2C-Leitung unterbrochenPrüfen, ob lcd.init() aufgerufen wird und SDA/SCL an A4/A5 hängen
Tasten liefern falsche ZeichenZeilen- und Spaltenpins vertauschtDie Arrays rowPins und colPins tauschen oder umkehren
Eine Taste wird doppelt gezähltKontaktprellenEntprellzeit mit keypad.setDebounceTime(50) erhöhen
Keine Taste funktioniertBeim Uno Pins 0/1 oder beim ESP32 GPIO 34–39 benutztDie Pins aus der Tabelle verwenden
Bei großen Produkten ist die letzte Stelle falschBeim Uno trägt float nur 6–7 StellenStellenlimit beibehalten oder auf dem ESP32 double verwenden
Divisionsergebnis ohne NachkommastellenRechnung mit zwei Ganzzahlen (int/long)Mindestens eine Seite in float umwandeln; in diesem Code ist first schon vom Typ Number
Teste bei der Fehlersuche den Code Stück für Stück: Gib zuerst nur mit keypad.getKey() die gedrückte Taste im Serial Monitor aus, dann sende nur einen festen Text ans LCD. Funktionieren beide Teile einzeln, liegt der Fehler in der Rechenlogik; beobachte dann mit Serial.print bei jeder Taste die Werte von entry, first und op, und du findest den Fehler leicht.

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.

Alle Projekte ansehen
Arduino I2C-Rechner
AR-94Mittel
Premium

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.

5.0(31)
43
4x4-Tastenfeld verwenden
AR-63Anfänger
Premium

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.

4.5(27)
35
Passwortschloss mit 4x4-Tastenfeld und LCD
AR-64Fortgeschritten
Premium

Passwortschloss mit 4x4-Tastenfeld und LCD

Ein kleines elektronisches Türschloss, das niemanden ohne den richtigen Code hereinlässt.

4.8(59)
75
3x4-Tastenfeld verwenden
AR-61Anfänger

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.

4.5(24)
32
LED-Steuerung mit 3x4-Tastenfeld
AR-62Mittel
Premium

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…

4.6(29)
38
Verwendung des LCD-Bildschirms mit I2C
AR-32Anfänger
Premium

Verwendung des LCD-Bildschirms mit I2C

Gib deinem Arduino ein eigenes Display und lass es seine erste Nachricht schreiben.

4.8(53)
70
Intelligenter elektronischer Safe
AR-92Fortgeschritten
Premium

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…

4.7(42)
63
ESP32 I2C-LCD-Display (16×2)
ES-17Mittel
Premium

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).

4.9(23)
40