Arduino Nesso N1 Tutorial: Touch-Zahlenfeld & PIN-Abfrage

In diesem Beitrag zeige ich dir, wie du auf dem Arduino Nesso N1 ein eigenes Touch-Zahlenfeld mit PIN-Abfrage programmierst. Das kleine Projekt ist nicht nur ein idealer Einstieg in die Touch-Programmierung auf dem Nesso N1, sondern lässt sich später auch extrem flexibel erweitern – etwa um Bluetooth-, WiFi- oder sogar LoRa-Funktionen, um damit Geräte oder Aktionen sicher freizuschalten.

Im ersten Teil konzentrieren wir uns auf die Grundlagen:

• Wie funktioniert das Touch-Display des Nesso N1?
• Wie zeichnen wir ein Zahlenfeld (0–9)?
• Wie wird eine PIN eingegeben, überprüft und visuell dargestellt?
• Und wie nutzen wir die beiden Hardware-Tasten sinnvoll für „Bestätigen“ und „Löschen“?

Damit legen wir die Basis für spätere, anspruchsvollere Projekte wie Zugangssysteme, Menüoberflächen, Einstellungsseiten oder Authentifizierungsfunktionen über Funk.

Los geht’s mit der Touch-UI auf dem Arduino Nesso N1!

Inhaltsverzeichnis

• Materialliste
• Das 1,14″ Touch-Display des Arduino Nesso N1 verstehen
• Die Touch-Funktion im Überblick
• Aufbau des Quellcodes für die PIN-Abfrage
  • 1. Globale Variablen & Einstellungen
  • 2. Die Oberfläche: Zahlenfeld, Eingabezeile und OK-Button
  • 3. Eingabe verwalten: Ziffern hinzufügen & PIN zurücksetzen
  • 4. Die Touch-Auswertung: Welche Taste wurde gedrückt?
  • 5. PIN prüfen und Rückmeldung geben
• Fazit & Ausblick
• FAQ – Häufige Fragen zur PIN-Abfrage auf dem Arduino Nesso N1

Materialliste

Für dieses Projekt brauchst du erfreulich wenig Hardware – der Arduino Nesso N1 bringt bereits alles mit, was wir benötigen: Touch-Display, zwei Taster, Buzzer und ausreichend Rechenleistung.
Lediglich für die Bedienung gibt es einen kleinen Komforttipp.

• Arduino Nesso N1
  Der Mikrocontroller enthält bereits das 1,14″ Touch-Display, die Taster sowie alle benötigten Schnittstellen.
• USB-C Kabel*
  Zum Programmieren und zur Stromversorgung.
• Eingabestift für Touch-Displays*
  Das 1,14″ Touch-Display ist relativ klein.
  Mit dem Finger funktioniert die Eingabe zwar, ist aber etwas fummelig – ein kleiner Eingabestift macht die Bedienung deutlich präziser.

Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Das 1,14″ Touch-Display des Arduino Nesso N1 verstehen

Bevor wir in die Programmierung einsteigen, lohnt sich ein kurzer Blick auf das integrierte Display des Arduino Nesso N1.
Der kleine Mikrocontroller bringt ein 1,14″ IPS-Farbdisplay mit einer Auflösung von 135 × 240 Pixel mit – scharf, farbstark und überraschend schnell.
Das Highlight: Das Display ist berührungsempfindlich (Touch) und reagiert sehr präzise, auch bei kleinen UI-Elementen wie Tasten oder Zahlenfeldern.

Damit eignet sich der Nesso N1 perfekt für:

• kleine Benutzeroberflächen
• interaktive Menüs
• PIN-Eingaben
• Mini-Dashboards
• Icons, Animationen oder Statusanzeigen

Gerade für kompakte Projekte ist ein integrierter Touchscreen ein echter Vorteil – man spart Bauteile, Kabel und Platz.

Die Touch-Funktion im Überblick

Die Touch-Abfrage ist beim Nesso N1 extrem einfach gehalten:

• Jede Berührung liefert X- und Y-Koordinaten zurück
• Die Auflösung reicht aus, um präzise UI-Elemente zu platzieren
• Mit der Display-Bibliothek M5GFX lässt sich Touch direkt auslesen
• Das gesamte Display fungiert als Touchfläche – keine „Buttons“ im klassischen Sinn

Der Workflow sieht so aus:

1. Touch prüfen → display.getTouch(&tp)
2. Koordinaten auslesen → tp.x & tp.y
3. Auf Basis dieser Koordinaten entscheiden, welcher Button gedrückt wurde

Du kannst damit interaktive Flächen komplett frei definieren – egal ob Tasten, Felder, Slider oder Zeichenbereiche.

#include <M5GFX.h>

M5GFX display;

void setup() {
  display.begin();
  display.setRotation(1); // Set to landscape mode
  display.fillScreen(TFT_BLACK);

  // Set text properties that will be used for all text in this sketch
  display.setTextDatum(MC_DATUM); // Middle-Center datum for text alignment
  display.setTextColor(TFT_WHITE);
  display.setTextSize(2);

  // Display the initial message centered on the screen
  display.drawString("Touch the screen", display.width() / 2, display.height() / 2);
}

void loop() {
  // Create a structure to hold touch data
  lgfx::touch_point_t tp;

  // Check if the screen is being touched
  if (display.getTouch(&tp)) {
    // Clear the screen to update both the circle and the text
    display.fillScreen(TFT_BLACK);
    
    // Draw a white circle at the current touch coordinates
    display.fillCircle(tp.x, tp.y, 5, TFT_WHITE);

    // Create a string with the updated coordinates
    String coords = "X:" + String(tp.x) + " Y:" + String(tp.y);

    // Draw the coordinates string at the FIXED center of the screen
    display.drawString(coords, display.width() / 2, display.height() / 2);
  }
  
  delay(20); // Small delay for responsiveness
}

Das obigte Beispiel habe ich aus der offiziellen technischen Dokumentation zum Arduino Nesso N1 entnommen.

Aufbau des Quellcodes für die PIN-Abfrage

Bevor wir uns den kompletten Sketch anschauen, lohnt es sich, den Aufbau Schritt für Schritt zu verstehen.
Die PIN-Abfrage besteht im Kern aus vier Bausteinen:

1. Globale Variablen & Einstellungen
2. Zeichnen der Benutzeroberfläche (Tasten & Eingabefeld)
3. Verarbeiten der Touch-Eingaben
4. Prüfen des PIN-Codes

Dadurch bleibt der Code übersichtlich, gut erweiterbar und auch für Einsteiger gut nachvollziehbar.

/************************************************************
 * Projekt: Touch-Zahlenfeld & PIN-Abfrage auf dem Arduino Nesso N1
 *
 * Beschreibung:
 *   Dieses Programm zeigt auf dem 1,14" Display des Arduino Nesso N1
 *   ein Zahlenfeld von 0 bis 9 (in zwei Reihen) sowie ein Eingabefeld
 *   und einen OK-Button an. Der Benutzer kann per Touch einen
 *   vierstelligen PIN eingeben. Nach Drücken von "OK" wird der PIN
 *   mit einem vordefinierten Code verglichen.
 *
 *   - Bei korrektem PIN: Ausgabe "Zugang erlaubt" + akustisches Signal
 *   - Bei falschem PIN:  Ausgabe "Falscher PIN"   + anderes Signal
 *
 *   Der Code ist bewusst möglichst einfach gehalten und eignet sich
 *   sehr gut als Einstieg in die Touch-Programmierung mit M5GFX
 *   auf dem Arduino Nesso N1.
 *
 * Hardware:
 *   - Arduino Nesso N1
 *   - Integriertes 1,14" IPS-Touchdisplay
 *   - Integrierter Buzzer (BEEP_PIN muss zum Board passen)
 *
 * Weitere Infos & Tutorial:
 *   https://draeger-it.blog/arduino-nesso-n1-tutorial-touch-zahlenfeld-pin-abfrage/
 *
 * Autor:
 *   Stefan Draeger (draeger-it.blog)
 ************************************************************/

#include <M5GFX.h>  // Display- und Touch-Bibliothek für den Nesso N1

M5GFX display;  // Display-Objekt für alle Zeichen- und Touch-Operationen

// PIN, den wir abfragen wollen (hier: 1234)
// Dieser Code kann nach Belieben angepasst werden.
const char CORRECT_PIN[] = "1234";

// Hier speichern wir die Eingabe des Benutzers.
// Maximale Länge: 4 Stellen + Terminator ('\0') = 5 Zeichen.
char enteredPin[5] = "";
int pinLen = 0;  // Anzahl aktuell eingegebener Stellen

// Bildschirmgröße im Querformat (Rotation 1)
// Beim Nesso N1: 240 x 135 Pixel (Breite x Höhe)
const int SCREEN_W = 240;
const int SCREEN_H = 135;

/************************************************************
 * Funktion: drawScreen()
 * Aufgabe:
 *   Zeichnet die komplette Benutzeroberfläche neu:
 *   - Zahlen-Tasten 0–9 (oben und mittig)
 *   - Eingabefeld für den PIN
 *   - OK-Button unten rechts
 ************************************************************/
void drawScreen() {
  // Gesamten Bildschirm mit Schwarz füllen
  display.fillScreen(TFT_BLACK);

  // Textfarbe und Hintergrundfarbe für allgemeine Texte setzen
  display.setTextColor(TFT_WHITE, TFT_BLACK);

  // Breite und Höhe der Ziffern-Tasten berechnen
  int buttonWidth = SCREEN_W / 5;  // 240 / 5 = 48 Pixel pro Taste
  int buttonHeight = 35;           // Höhe einer Taste

  // Schriftgröße für die Zahlen
  display.setTextSize(2);

  // Erste Reihe: Zahlen 0–4
  int y1 = 15;  // Y-Position der oberen Tastenreihe
  for (int i = 0; i < 5; i++) {
    int x = i * buttonWidth;  // X-Position der linken oberen Ecke der Zelle

    // Rechteck für die Taste zeichnen
    display.drawRect(x + 2, y1, buttonWidth - 4, buttonHeight, TFT_DARKGREY);

    // Textausrichtung: Mittelpunkt der Taste
    display.setTextDatum(MC_DATUM);

    // Ziffer (0–4) auf der Taste zeichnen
    display.drawString(String(i), x + buttonWidth / 2, y1 + buttonHeight / 2);
  }

  // Zweite Reihe: Zahlen 5–9
  int y2 = 15 + buttonHeight + 10;  // Y-Position der unteren Tastenreihe
  for (int i = 0; i < 5; i++) {
    int x = i * buttonWidth;
    int num = i + 5;  // Zahlen 5–9

    // Rechteck für die Taste zeichnen
    display.drawRect(x + 2, y2, buttonWidth - 4, buttonHeight, TFT_DARKGREY);

    // Textausrichtung: Mittelpunkt
    display.setTextDatum(MC_DATUM);

    // Ziffer (5–9) auf der Taste zeichnen
    display.drawString(String(num), x + buttonWidth / 2, y2 + buttonHeight / 2);
  }

  // Eingabefeld links unten:
  // Rechteck, in dem der eingegebene PIN angezeigt wird.
  display.setTextDatum(ML_DATUM);  // Textausrichtung: Mitte-Links
  display.drawRect(2, SCREEN_H - 35, 140, 25, TFT_DARKGREY);

  // Textfarbe für den PIN (Cyan, gut sichtbar auf Schwarz)
  display.setTextColor(TFT_CYAN, TFT_BLACK);

  // Aktuell eingegebener PIN im Eingabefeld anzeigen
  display.drawString(String(enteredPin), 15, SCREEN_H - 23);

  // OK-Button unten rechts
  int okW = 60;                   // Breite des OK-Buttons
  int okH = 25;                   // Höhe des OK-Buttons
  int okX = SCREEN_W - okW - 10;  // X-Position (10 px vom Rand)
  int okY = SCREEN_H - okH - 10;  // Y-Position (10 px vom Rand)

  // Gefülltes Rechteck als Button-Hintergrund
  display.fillRect(okX, okY, okW, okH, TFT_DARKGREEN);

  // Textfarbe Schwarz auf grünem Button
  display.setTextColor(TFT_BLACK, TFT_DARKGREEN);
  display.setTextDatum(MC_DATUM);

  // "OK"-Beschriftung in die Mitte des Buttons zeichnen
  display.drawString("OK", okX + okW / 2, okY + okH / 2);
}

/************************************************************
 * Funktion: resetPin()
 * Aufgabe:
 *   Setzt die PIN-Eingabe zurück und leert den Buffer.
 ************************************************************/
void resetPin() {
  pinLen = 0;            // Anzahl der Stellen zurücksetzen
  enteredPin[0] = '\0';  // String terminieren (leer)
}

/************************************************************
 * Funktion: beep(bool ok)
 * Aufgabe:
 *   Gibt ein akustisches Signal über den Buzzer aus.
 *
 * Parameter:
 *   ok == true  -> Tonfolge für "korrekter PIN"
 *   ok == false -> Tonfolge für "falscher PIN"
 ************************************************************/
void beep(bool ok) {
  // Mehrfach kurzer Ton in Folge
  for (int i = 0; i < 6; i++) {
    // tone(Pin, Frequenz, Dauer in ms)
    // ok ? 850 Hz : 600 Hz
    tone(BEEP_PIN, ok ? 850 : 600, 500);
    delay(125);  // kleine Pause zwischen den Tönen
  }
}

/************************************************************
 * Funktion: checkPin()
 * Aufgabe:
 *   Prüft, ob der eingegebene PIN korrekt ist und
 *   zeigt eine entsprechende Meldung an.
 ************************************************************/
void checkPin() {
  display.setTextDatum(MC_DATUM);
  display.setTextSize(2);

  // PIN ist gültig, wenn:
  // - genau 4 Stellen eingegeben wurden
  // - und der String mit CORRECT_PIN übereinstimmt
  if (pinLen == 4 && strcmp(enteredPin, CORRECT_PIN) == 0) {
    // Erfolgsmeldung
    display.setTextColor(TFT_GREEN, TFT_BLACK);
    display.drawString("Zugang erlaubt", SCREEN_W / 2, SCREEN_H / 2);
    beep(true);   // akustisches "OK"-Signal
    delay(2000);  // Meldung kurz stehen lassen
  } else {
    // Fehlermeldung
    display.setTextColor(TFT_RED, TFT_BLACK);
    display.drawString("Falscher PIN", SCREEN_W / 2, SCREEN_H / 2);
    beep(false);  // akustisches Fehlersignal
    delay(2000);  // Meldung kurz stehen lassen
  }

  // Nach der Ausgabe:
  // PIN zurücksetzen und Oberfläche neu zeichnen
  delay(1000);
  resetPin();
  drawScreen();
}

/************************************************************
 * Funktion: addDigit(int digit)
 * Aufgabe:
 *   Fügt eine Ziffer (0–9) zur aktuellen PIN-Eingabe hinzu,
 *   solange noch nicht mehr als 4 Stellen eingegeben wurden.
 ************************************************************/
void addDigit(int digit) {
  // Maximal 4 Stellen erlaubt
  if (pinLen >= 4) {
    return;
  }

  // Ziffer in das PIN-Array eintragen:
  // '0' + digit wandelt z.B. 3 -> '3'
  enteredPin[pinLen] = '0' + digit;
  pinLen++;

  // String am Ende terminieren
  enteredPin[pinLen] = '\0';

  // Nur das Eingabefeld neu zeichnen (nicht den ganzen Screen)
  display.setTextDatum(ML_DATUM);
  display.setTextColor(TFT_CYAN, TFT_BLACK);

  // Eingabefeldbereich löschen
  display.fillRect(11, SCREEN_H - 34, 118, 23, TFT_BLACK);

  // Aktuellen PIN anzeigen
  display.drawString(String(enteredPin), 15, SCREEN_H - 23);
}

/************************************************************
 * Funktion: setup()
 * Aufgabe:
 *   Initialisierung von Display und erster Bildaufbau.
 ************************************************************/
void setup() {
  display.begin();         // Display initialisieren
  display.setRotation(1);  // Querformat einstellen
  drawScreen();            // Benutzeroberfläche zeichnen
}

/************************************************************
 * Funktion: loop()
 * Aufgabe:
 *   - Touch-Eingaben auswerten
 *   - Zahlenfelder und OK-Button auf Berührung prüfen
 *   - Bei Bedarf PIN ergänzen oder Prüfung auslösen
 ************************************************************/
void loop() {
  lgfx::touch_point_t tp;  // Struktur für Touch-Daten

  // Prüfen, ob der Bildschirm berührt wird
  if (display.getTouch(&tp)) {
    int x = tp.x;  // X-Koordinate der Berührung
    int y = tp.y;  // Y-Koordinate der Berührung

    int buttonWidth = SCREEN_W / 5;
    int buttonHeight = 40;

    // OK-Button-Koordinaten berechnen (müssen zur Zeichnung passen)
    int okW = 60;
    int okH = 25;
    int okX = SCREEN_W - okW - 10;
    int okY = SCREEN_H - okH - 10;

    // 1) Prüfen, ob der OK-Button berührt wurde
    if (x >= okX && x <= okX + okW && y >= okY && y <= okY + okH) {
      checkPin();  // PIN prüfen
      delay(200);  // einfache Entprellung, damit nicht sofort erneut ausgelöst wird
      return;      // loop() hier vorzeitig verlassen
    }

    // 2) Erste Zahlenreihe (0–4):
    //    Y-Bereich: ungefähr dort, wo die erste Reihe gezeichnet wurde
    if (y >= 30 && y <= 30 + buttonHeight) {
      int col = x / buttonWidth;  // Spalte 0..4 anhand der X-Koordinate
      if (col >= 0 && col <= 4) {
        int digit = col;  // Ziffer 0..4
        addDigit(digit);
      }
    }

    // 3) Zweite Zahlenreihe (5–9):
    int y2 = 30 + buttonHeight + 10;  // Y-Position der zweiten Reihe
    if (y >= y2 && y <= y2 + buttonHeight) {
      int col = x / buttonWidth;  // Spalte 0..4
      if (col >= 0 && col <= 4) {
        int digit = col + 5;  // Ziffer 5..9
        addDigit(digit);
      }
    }

    // Einfache Touch-Entprellung:
    // Kleine Pause, damit ein längerer Touch nicht mehrfach ausgelöst wird.
    delay(200);
  }

  // Kurze Pause, um die CPU etwas zu entlasten
  delay(10);
}

1. Globale Variablen & Einstellungen

Ganz oben im Sketch legen wir fest:

• welches Display-Objekt wir verwenden
• wie lang der PIN sein darf
• welcher PIN als „korrekt“ gilt
• und wie groß unser Bildschirm ist

#include <M5GFX.h>

M5GFX display;

// PIN, den wir abfragen wollen
const char CORRECT_PIN[] = "1234";


// Hier speichern wir, was der Benutzer eingibt (max. 4 Stellen + '\0')
char enteredPin[5] = "";
int pinLen = 0;

// Bildschirmgröße (bei setRotation(1))
const int SCREEN_W = 240;
const int SCREEN_H = 135;

int buttonWidth = SCREEN_W / 5;  // 240 / 5 = 48
int buttonHeight = 35;

void setup() {
  display.begin();
  display.setRotation(1);  // Querformat
  drawScreen();
}

So ist direkt ersichtlich:
Wenn du später den PIN ändern willst, reicht es, CORRECT_PIN anzupassen.

2. Die Oberfläche: Zahlenfeld, Eingabezeile und OK-Button

Damit der Benutzer überhaupt etwas bedienen kann, zeichnen wir in einer eigenen Funktion die komplette Oberfläche. Das hat den Vorteil, dass wir die UI jederzeit neu aufbauen können, ohne jede einzelne Zeile im loop() anfassen zu müssen.

// Hilfsfunktion: gesamte Oberfläche neu zeichnen
void drawScreen() {
  display.fillScreen(TFT_BLACK);

  // Zahlen-Tasten zeichnen (0-4 oben, 5-9 unten)
  display.setTextColor(TFT_WHITE, TFT_BLACK);
  display.setTextSize(1);
 
  // Zahlen-Tasten zeichnen (0-4 oben)
  display.setTextColor(TFT_WHITE, TFT_BLACK);
  display.setTextSize(2); 

  // Erste Reihe: 0-4
  int y1 = 15;
  for (int i = 0; i < 5; i++) {
    int x = i * buttonWidth;
    display.drawRect(x + 2, y1, buttonWidth - 4, buttonHeight, TFT_DARKGREY);

    display.setTextDatum(MC_DATUM);
    display.drawString(String(i), x + buttonWidth / 2, y1 + buttonHeight / 2);
  }

  // Zweite Reihe: 5-9
  int y2 = 15 + buttonHeight + 10;
  for (int i = 0; i < 5; i++) {
    int x = i * buttonWidth;
    int num = i + 5;

    display.drawRect(x + 2, y2, buttonWidth - 4, buttonHeight, TFT_DARKGREY);

    display.setTextDatum(MC_DATUM);
    display.drawString(String(num), x + buttonWidth / 2, y2 + buttonHeight / 2);
  }


  // Eingabe-Feld links unten
  display.setTextDatum(ML_DATUM);
  display.drawRect(2, SCREEN_H - 35, 140, 25, TFT_DARKGREY);
  display.setTextColor(TFT_CYAN, TFT_BLACK);
  display.drawString(String(enteredPin), 15, SCREEN_H - 23);

  // OK-Button rechts unten
  int okW = 60;
  int okH = 25;
  int okX = SCREEN_W - okW - 10;
  int okY = SCREEN_H - okH - 10;

  display.fillRect(okX, okY, okW, okH, TFT_DARKGREEN);
  display.setTextColor(TFT_BLACK, TFT_DARKGREEN);
  display.setTextDatum(MC_DATUM);
  display.drawString("OK", okX + okW / 2, okY + okH / 2);
}

In dieser Funktion:

• berechnen wir die Breite der Tasten (buttonWidth = SCREEN_W / 5)
• zeichnen oben die Zahlen 0–4 in einer Reihe
• darunter die Zahlen 5–9
• links unten eine Box für die aktuelle Eingabe
• rechts unten den OK-Button

Die Logik dahinter ist bewusst simpel gehalten:
Wir nutzen das Display wie ein Raster und ordnen die Tasten anhand ihrer Spalte (0–4) und Zeile (oben/unten) zu.

3. Eingabe verwalten: Ziffern hinzufügen & PIN zurücksetzen

Damit wir nicht überall im Code mit Strings hantieren müssen, kapseln wir die Eingabe in zwei kleine Hilfsfunktionen:

// Hilfsfunktion: PIN zurücksetzen
void resetPin() {
  pinLen = 0;
  enteredPin[0] = '\0';
}


// Zahl zur Eingabe hinzufügen
void addDigit(int digit) {
  if (pinLen >= 4) {
    return;  // maximal 4 Stellen
  }

  enteredPin[pinLen] = '0' + digit;
  pinLen++;
  enteredPin[pinLen] = '\0';

  // Nur das Eingabefeld neu zeichnen
  display.setTextDatum(ML_DATUM);
  display.setTextColor(TFT_CYAN, TFT_BLACK);
  display.fillRect(11, SCREEN_H - 34, 118, 23, TFT_BLACK);  // Feld leeren
  display.drawString(String(enteredPin), 15, SCREEN_H - 23);
}

• resetPin() setzt die Eingabe zurück
• addDigit() fügt eine neue Ziffer hinzu, solange noch Platz ist

Dadurch bleibt das loop() später sehr aufgeräumt:
Statt dort direkt Zeichenketten zu manipulieren, rufen wir nur addDigit() auf.

4. Die Touch-Auswertung: Welche Taste wurde gedrückt?

Im loop() passiert das eigentliche „Magie“-Stück: Wir fragen den Touchscreen ab und entscheiden anhand der Koordinaten, welche Taste getroffen wurde.

void loop() {
  lgfx::touch_point_t tp;

  if (display.getTouch(&tp)) {
    int x = tp.x;
    int y = tp.y;

    // OK-Button-Koordinaten berechnen
    int okW = 60;
    int okH = 25;
    int okX = SCREEN_W - okW - 10;
    int okY = SCREEN_H - okH - 10;

    // Wurde der OK-Button gedrückt?
    if (x >= okX && x <= okX + okW && y >= okY && y <= okY + okH) {
      checkPin();
      delay(200);  // einfache Entprellung
      return;
    }

    // Erste Zahlenreihe (0-4): y zwischen 30 und 30+buttonHeight
    if (y >= 30 && y <= 30 + buttonHeight) {
      int col = x / buttonWidth;  // 0..4
      if (col >= 0 && col <= 4) {
        int digit = col;  // 0..4
        addDigit(digit);
      }
    }

    // Zweite Zahlenreihe (5-9): y zwischen y2 und y2+buttonHeight
    int y2 = 30 + buttonHeight + 10;
    if (y >= y2 && y <= y2 + buttonHeight) {
      int col = x / buttonWidth;  // 0..4
      if (col >= 0 && col <= 4) {
        int digit = col + 5;  // 5..9
        addDigit(digit);
      }
    }

    // einfache Touch-Entprellung
    delay(200);
  }

  delay(10);
}

Das Prinzip:

• Wir prüfen zuerst: Liegt der Touch in der OK-Button-Zone?
• Wenn nicht: Prüfen wir, ob die Touch-Koordinaten in der oberen oder unteren Zahlenreihe liegen.
• Über col = x / buttonWidth ermitteln wir, in welcher Spalte der Touch war – und daraus ergibt sich direkt die gedrückte Zahl.

5. PIN prüfen und Rückmeldung geben

Zum Schluss fehlt nur noch die Funktion, die den eingegebenen PIN mit dem erwarteten PIN vergleicht:

// Prüfen, ob PIN korrekt ist
void checkPin() {
  display.setTextDatum(MC_DATUM);
  display.setTextSize(2);

  if (pinLen == 4 && strcmp(enteredPin, CORRECT_PIN) == 0) {
    display.setTextColor(TFT_GREEN, TFT_BLACK);
    display.drawString("Zugang erlaubt", SCREEN_W / 2, SCREEN_H / 2);
    beep(true);
    delay(2000);
  } else {
    display.setTextColor(TFT_RED, TFT_BLACK);
    display.drawString("Falscher PIN", SCREEN_W / 2, SCREEN_H / 2);
    beep(false);
    delay(2000);
  }

  delay(1000);
  resetPin();
  drawScreen();
}

void beep(bool ok) {
  for (int i = 0; i < 6; i++) {
    tone(BEEP_PIN, ok ? 850 : 600, 500);
    delay(125);
  }
}

• Wenn die Länge passt und der PIN übereinstimmt → Erfolgsmeldung
• Andernfalls → Fehlermeldung
• Danach wird der PIN zurückgesetzt und die Oberfläche neu aufgebaut

Diese Funktion ist später der ideale Einstiegspunkt, um weitere Aktionen einzubauen – zum Beispiel:

• ein Relais schalten
• per Bluetooth oder WiFi einen Befehl senden
• LoRa-Nachrichten verschicken

Fazit & Ausblick

Mit nur wenigen Zeilen Code haben wir auf dem Arduino Nesso N1 ein voll funktionsfähiges Touch-Zahlenfeld mit PIN-Abfrage umgesetzt.

Du hast in diesem Projekt gesehen:

• wie das 1,14″ Touch-Display angesprochen wird
• wie du Bereiche auf dem Display in „Tasten“ verwandelst
• wie sich eine einfache PIN-Logik umsetzen lässt

Im nächsten Schritt kannst du die PIN-Abfrage als „Gate“ verwenden, um:

• ein Relais freizugeben
• eine Aktion über WiFi oder Bluetooth auszulösen
• LoRa-Nachrichten nur nach korrekter Authentifizierung zu senden

Damit wird aus diesem kleinen Beispiel schnell ein echtes Zugangssystem für deine eigenen Projekte.

FAQ – Häufige Fragen zur PIN-Abfrage auf dem Arduino Nesso N1

Letzte Aktualisierung am: 01. Dezember 2025