Der Code basiert auf einem UNO R3 ATmega328p Board und der C++-Sprache unter Verwendung der Arduino IDE App.

Benötigte Bibliotheken: 
- Keypad (von Mark Stanley, Alexander Brevig)

Code:

/*
 * 4x5 Matrix Tastatur (20 Tasten) – Membran Keypad
 * Board: Arduino UNO R3 (ATmega328p)
 * 
 * Pinbelegung (4 Zeilen x 5 Spalten):
 * Zeilen (Rows):   Pin 9, 8, 7, 6
 * Spalten (Cols):  Pin 5, 4, 3, 2, 1
 * 
 * Funktionen:
 * - Tastendruck erkennen und ausgeben
 * - PIN-Eingabe (4-stelliger Code)
 * - Passwort-Überprüfung
 * - Text-Eingabe über Tastatur
 * - Kalibrierungsmodus
 */

#include <Keypad.h>

// Pin-Definitionen für 4x5 Matrix
const byte ROWS = 4;    // 4 Zeilen
const byte COLS = 5;    // 5 Spalten

// Pins für Zeilen (Rows)
byte rowPins[ROWS] = {9, 8, 7, 6};

// Pins für Spalten (Cols)
byte colPins[COLS] = {5, 4, 3, 2, 1};

// Tastenbelegung (4x5 Layout)
char keys[ROWS][COLS] = {
  {'1', '2', '3', 'A', 'B'},
  {'4', '5', '6', 'C', 'D'},
  {'7', '8', '9', 'E', 'F'},
  {'*', '0', '#', 'G', 'H'}
};

// Keypad-Objekt erstellen
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);

// Variablen für PIN-Eingabe
String pinEingabe = "";
const String RICHTIGER_PIN = "1234";
bool pinVerifiziert = false;

// Variablen für Text-Eingabe
String textEingabe = "";
bool textModus = false;
int cursorPosition = 0;

// Status-Anzeige
enum Modus {
  HAUPTMENU,
  PIN_MODUS,
  TEXT_MODUS,
  KALIBRIERUNG
};
Modus aktuellerModus = HAUPTMENU;

void setup() {
  // Serielle Kommunikation starten
  Serial.begin(9600);
  
  Serial.println("==========================================");
  Serial.println("4x5 Matrix Tastatur (20 Tasten)");
  Serial.println("Board: Arduino UNO R3");
  Serial.println("==========================================");
  Serial.println();
  
  // Hauptmenü anzeigen
  hauptMenuAnzeigen();
}

void loop() {
  // Tastendruck abfragen
  char taste = keypad.getKey();
  
  // Wenn eine Taste gedrückt wurde
  if (taste) {
    // Taste im seriellen Monitor ausgeben
    Serial.print("Taste gedrückt: ");
    Serial.println(taste);
    
    // Je nach Modus verarbeiten
    switch (aktuellerModus) {
      case HAUPTMENU:
        hauptMenuVerarbeitung(taste);
        break;
        
      case PIN_MODUS:
        pinVerarbeitung(taste);
        break;
        
      case TEXT_MODUS:
        textVerarbeitung(taste);
        break;
        
      case KALIBRIERUNG:
        kalibrierungVerarbeitung(taste);
        break;
    }
  }
  
  // Keypad-Events verarbeiten (für Halten und Loslassen)
  // Optional: keypad.addEventListener(keypadEvent);
}

/*
 * ========================================
 * HAUPTMENU
 * ========================================
 */
void hauptMenuAnzeigen() {
  Serial.println();
  Serial.println("========== HAUPTMENU ==========");
  Serial.println("1 - PIN-Eingabe Modus");
  Serial.println("2 - Text-Eingabe Modus");
  Serial.println("3 - Kalibrierung");
  Serial.println("4 - Tastatur-Test");
  Serial.println("5 - Info");
  Serial.println("================================");
  Serial.println("Wähle eine Option (1-5):");
}

void hauptMenuVerarbeitung(char taste) {
  switch (taste) {
    case '1':
      aktuellerModus = PIN_MODUS;
      pinEingabe = "";
      Serial.println();
      Serial.println("========== PIN-EINGABE ==========");
      Serial.println("Gib einen 4-stelligen PIN ein:");
      Serial.println("(mit # bestätigen, * löscht letzte Ziffer)");
      Serial.println("PIN: ");
      break;
      
    case '2':
      aktuellerModus = TEXT_MODUS;
      textEingabe = "";
      cursorPosition = 0;
      Serial.println();
      Serial.println("========== TEXT-EINGABE ==========");
      Serial.println("Gib Text ein (max. 20 Zeichen):");
      Serial.println("(A-H für Buchstaben, # für Leerzeichen, * löscht)");
      Serial.println("Text: ");
      break;
      
    case '3':
      aktuellerModus = KALIBRIERUNG;
      Serial.println();
      Serial.println("========== KALIBRIERUNG ==========");
      Serial.println("Drücke jede Taste nacheinander:");
      Serial.println("(Taste wird angezeigt wenn erkannt)");
      break;
      
    case '4':
      Serial.println();
      Serial.println("========== TASTATUR-TEST ==========");
      Serial.println("Drücke beliebige Tasten:");
      Serial.println("(Drücke '#' für Hauptmenü)");
      Serial.println("------------------------------------");
      // Bleibt im Hauptmenü, aber zeigt alle Tasten an
      break;
      
    case '5':
      Serial.println();
      Serial.println("========== INFO ==========");
      Serial.println("4x5 Matrix Tastatur");
      Serial.println("20 Tasten Membran Keypad");
      Serial.println("Pins: Rows 9-6, Cols 5-1");
      Serial.println("==========================");
      hauptMenuAnzeigen();
      break;
      
    case '#':
      // Zurück zum Hauptmenü
      aktuellerModus = HAUPTMENU;
      hauptMenuAnzeigen();
      break;
      
    default:
      // Im Test-Modus alle Tasten anzeigen
      if (taste != '*' && taste != '#') {
        Serial.print("Taste: ");
        Serial.println(taste);
      }
      break;
  }
}

/*
 * ========================================
 * PIN-EINGABE MODUS
 * ========================================
 */
void pinVerarbeitung(char taste) {
  if (taste == '#') {
    // PIN bestätigen
    Serial.println(); // Neue Zeile
    
    if (pinEingabe.length() == 4) {
      Serial.print("Eingegebener PIN: ");
      Serial.println(pinEingabe);
      
      if (pinEingabe == RICHTIGER_PIN) {
        Serial.println("✅ PIN KORREKT! Zugriff gewährt!");
        pinVerifiziert = true;
      } else {
        Serial.println("❌ PIN FALSCH! Zugriff verweigert!");
        pinVerifiziert = false;
      }
      
      // PIN zurücksetzen für nächsten Versuch
      pinEingabe = "";
      Serial.println();
      Serial.println("Neuer PIN-Versuch (oder # für Hauptmenü):");
      Serial.print("PIN: ");
    } else {
      Serial.println();
      Serial.println("❌ PIN muss genau 4 Ziffern haben!");
      Serial.print("Aktuell: ");
      Serial.println(pinEingabe);
      Serial.print("PIN: ");
    }
    
  } else if (taste == '*') {
    // Letzte Ziffer löschen
    if (pinEingabe.length() > 0) {
      pinEingabe.remove(pinEingabe.length() - 1);
      Serial.print("\b \b"); // Rückwärts löschen (nur optisch)
    }
    
  } else if (taste >= '0' && taste <= '9') {
    // Ziffer hinzufügen (max. 4 Stellen)
    if (pinEingabe.length() < 4) {
      pinEingabe += taste;
      Serial.print(taste); // Ziffer anzeigen
    } else {
      Serial.println();
      Serial.println("❌ Maximal 4 Ziffern erlaubt!");
      Serial.print("PIN: ");
    }
    
  } else if (taste == 'A' || taste == 'B' || taste == 'C' || 
             taste == 'D' || taste == 'E' || taste == 'F' ||
             taste == 'G' || taste == 'H') {
    // Buchstaben im PIN-Modus nicht erlaubt
    Serial.println();
    Serial.println("❌ Nur Ziffern erlaubt! (0-9)");
    Serial.print("PIN: ");
  }
}

/*
 * ========================================
 * TEXT-EINGABE MODUS
 * ========================================
 */
void textVerarbeitung(char taste) {
  if (taste == '#') {
    // Text abschließen
    Serial.println();
    Serial.println("====================================");
    Serial.print("Eingegebener Text: ");
    Serial.println(textEingabe);
    Serial.println("Textlänge: " + String(textEingabe.length()) + " Zeichen");
    
    // Text-Analyse
    Serial.println("------------------------------------");
    Serial.print("Anzahl Buchstaben: ");
    int buchstaben = 0;
    int zahlen = 0;
    int sonstige = 0;
    
    for (int i = 0; i < textEingabe.length(); i++) {
      char c = textEingabe[i];
      if (isAlpha(c)) buchstaben++;
      else if (isDigit(c)) zahlen++;
      else sonstige++;
    }
    Serial.println(buchstaben);
    Serial.print("Anzahl Zahlen: ");
    Serial.println(zahlen);
    Serial.print("Anzahl Sonderzeichen: ");
    Serial.println(sonstige);
    
    Serial.println("====================================");
    textEingabe = "";
    
    // Rückfrage für neue Eingabe
    Serial.println();
    Serial.println("Neue Text-Eingabe (oder # für Hauptmenü):");
    Serial.print("Text: ");
    
  } else if (taste == '*') {
    // Letztes Zeichen löschen
    if (textEingabe.length() > 0) {
      textEingabe.remove(textEingabe.length() - 1);
      Serial.print("\b \b"); // Rückwärts löschen
    }
    
  } else if (taste >= '0' && taste <= '9') {
    // Zahlen hinzufügen
    if (textEingabe.length() < 20) {
      textEingabe += taste;
      Serial.print(taste);
    } else {
      Serial.println();
      Serial.println("❌ Maximal 20 Zeichen erlaubt!");
      Serial.print("Text: ");
    }
    
  } else if (taste >= 'A' && taste <= 'H') {
    // Buchstaben hinzufügen (A-H)
    if (textEingabe.length() < 20) {
      textEingabe += taste;
      Serial.print(taste);
    } else {
      Serial.println();
      Serial.println("❌ Maximal 20 Zeichen erlaubt!");
      Serial.print("Text: ");
    }
    
  } else {
    // Andere Tasten als Leerzeichen interpretieren
    if (taste == ' ' || taste == '\n' || taste == '\r') {
      if (textEingabe.length() < 20) {
        textEingabe += ' ';
        Serial.print(' ');
      }
    }
  }
}

/*
 * ========================================
 * KALIBRIERUNGS-MODUS
 * ========================================
 */
void kalibrierungVerarbeitung(char taste) {
  Serial.print("Taste erkannt: ");
  Serial.print(taste);
  
  // Taste auf der Matrix anzeigen
  for (int row = 0; row < ROWS; row++) {
    for (int col = 0; col < COLS; col++) {
      if (keys[row][col] == taste) {
        Serial.print(" (Zeile ");
        Serial.print(row);
        Serial.print(", Spalte ");
        Serial.print(col);
        Serial.println(")");
        break;
      }
    }
  }
  
  // Bei '*' oder '#' Kalibrierung beenden
  if (taste == '*' || taste == '#') {
    Serial.println();
    Serial.println("Kalibrierung beendet.");
    aktuellerModus = HAUPTMENU;
    hauptMenuAnzeigen();
  } else {
    Serial.println("Nächste Taste drücken (oder * oder # zum Beenden):");
  }
}

/*
 * ========================================
 * ERWEITERTE FUNKTIONEN (optional)
 * ========================================
 */

// Funktion: Tasten-Code als Integer ausgeben
int tasteZuInt(char taste) {
  if (taste >= '0' && taste <= '9') {
    return taste - '0';
  }
  return -1; // Keine Zahl
}

// Funktion: Prüfen ob Taste ein Buchstabe ist
bool istBuchstabe(char taste) {
  return (taste >= 'A' && taste <= 'H');
}

// Funktion: Prüfen ob Taste eine Zahl ist
bool istZahl(char taste) {
  return (taste >= '0' && taste <= '9');
}

// Funktion: Alle Tasten ausgeben (für Debug)
void alleTastenAusgeben() {
  Serial.println("Tasten-Übersicht:");
  for (int row = 0; row < ROWS; row++) {
    Serial.print("Zeile ");
    Serial.print(row);
    Serial.print(": ");
    for (int col = 0; col < COLS; col++) {
      Serial.print(keys[row][col]);
      Serial.print(" ");
    }
    Serial.println();
  }
}

// Funktion: Keypad-Events (erweitert)
void keypadEvent(KeypadEvent taste) {
  switch (keypad.getState()) {
    case PRESSED:
      Serial.print("Taste gedrückt: ");
      Serial.println(taste);
      break;
      
    case HOLD:
      Serial.print("Taste gehalten: ");
      Serial.println(taste);
      break;
      
    case RELEASED:
      Serial.print("Taste losgelassen: ");
      Serial.println(taste);
      break;
  }
}