.. note::

    Hallo und willkommen in der SunFounder Raspberry Pi & Arduino & ESP32 Enthusiasten-Gemeinschaft auf Facebook! Tauchen Sie tiefer ein in die Welt von Raspberry Pi, Arduino und ESP32 mit anderen Enthusiasten.

    **Warum beitreten?**

    - **Expertenunterstützung**: Lösen Sie Nachverkaufsprobleme und technische Herausforderungen mit Hilfe unserer Gemeinschaft und unseres Teams.
    - **Lernen & Teilen**: Tauschen Sie Tipps und Anleitungen aus, um Ihre Fähigkeiten zu verbessern.
    - **Exklusive Vorschauen**: Erhalten Sie frühzeitigen Zugang zu neuen Produktankündigungen und exklusiven Einblicken.
    - **Spezialrabatte**: Genießen Sie exklusive Rabatte auf unsere neuesten Produkte.
    - **Festliche Aktionen und Gewinnspiele**: Nehmen Sie an Gewinnspielen und Feiertagsaktionen teil.

    👉 Sind Sie bereit, mit uns zu erkunden und zu erschaffen? Klicken Sie auf [|link_sf_facebook|] und treten Sie heute bei!

.. _c_keypad:

2.1.5 Tastatur
==================

Einführung
------------

Eine Tastatur ist eine rechteckige Anordnung von Schaltflächen. In diesem Projekt werden wir Eingabezeichen verwenden.

Komponenten
-----------------

.. image:: ../img/list_2.1.5_keypad.png


Prinzip
---------

**Tastenfeld**

Eine Tastatur ist eine rechteckige Anordnung von 12 oder 16 AUS- (EIN) Tasten. 
Der Zugriff auf ihre Kontakte erfolgt über einen Header, 
der zum Anschluss mit einem Flachbandkabel oder zum Einsetzen in eine Leiterplatte geeignet ist. 
Bei einigen Tastaturen ist jede Taste mit einem separaten Kontakt in der Kopfzeile verbunden, 
während alle Tasten eine gemeinsame Masse haben.

.. image:: ../img/image314.png


Häufiger sind die Tasten Matrix kodiert, was bedeutet, 
dass jede von ihnen ein eindeutiges Leiterpaar in einer Matrix überbrückt. 
Diese Konfiguration eignet sich zum Abfragen durch einen Mikrocontroller, 
der so programmiert werden kann, 
dass er nacheinander einen Ausgangsimpuls an jeden der vier horizontalen Drähte sendet. 
Während jedes Impulses werden die verbleibenden vier vertikalen Drähte nacheinander überprüft, 
um festzustellen, welcher, falls vorhanden, ein Signal führt. 
Pullup- oder Pulldown-Widerstände sollten zu den Eingangsleitungen hinzugefügt werden, 
um zu verhindern, dass sich die Eingänge des Mikrocontrollers unvorhersehbar verhalten, 
wenn kein Signal vorhanden ist.

Schematische Darstellung
-----------------------------------------

.. image:: ../img/image315.png


.. image:: ../img/image316.png


Experimentelle Verfahren
--------------------------------

Schritt 1: Bauen Sie die Schaltung auf.

.. image:: ../img/image186.png
    :width: 800

Schritt 2: Öffnen Sie die Kodedatei.

.. raw:: html

   <run></run>

.. code-block::

    cd ~/davinci-kit-for-raspberry-pi/c/2.1.5/

Schritt 3: Kompilieren Sie die Kode.

.. raw:: html

   <run></run>

.. code-block::

    gcc 2.1.5_Keypad.cpp -lwiringPi

Schritt 4: Ausführen.

.. raw:: html

   <run></run>

.. code-block::

    sudo ./a.out

Nachdem die Kode ausgeführt wurde, 
werden die Werte der gedrückten Tasten auf der Tastatur (Tastenwert) auf dem Bildschirm gedruckt.

**Code**

.. code-block:: c

    #include <wiringPi.h>
    #include <stdio.h>

    #define ROWS  4 
    #define COLS  4
    #define BUTTON_NUM (ROWS * COLS)

    unsigned char KEYS[BUTTON_NUM] {  
    '1','2','3','A',
    '4','5','6','B',
    '7','8','9','C',
    '*','0','#','D'};

    unsigned char rowPins[ROWS] = {1, 4, 5, 6}; 
    unsigned char colPins[COLS] = {12, 3, 2, 0};

    void keyRead(unsigned char* result);
    bool keyCompare(unsigned char* a, unsigned char* b);
    void keyCopy(unsigned char* a, unsigned char* b);
    void keyPrint(unsigned char* a);
    void keyClear(unsigned char* a);
    int keyIndexOf(const char value);

    void init(void) {
        for(int i=0 ; i<4 ; i++) {
            pinMode(rowPins[i], OUTPUT);
            pinMode(colPins[i], INPUT);
        }
    }

    int main(void){
        unsigned char pressed_keys[BUTTON_NUM];
        unsigned char last_key_pressed[BUTTON_NUM];

        if(wiringPiSetup() == -1){ //when initialize wiring failed,print message to screen
            printf("setup wiringPi failed !");
            return 1; 
        }
        init();
        while(1){
            keyRead(pressed_keys);
            bool comp = keyCompare(pressed_keys, last_key_pressed);
            if (!comp){
                keyPrint(pressed_keys);
                keyCopy(last_key_pressed, pressed_keys);
            }
            delay(100);
        }
        return 0;  
    }

    void keyRead(unsigned char* result){
        int index;
        int count = 0;
        keyClear(result);
        for(int i=0 ; i<ROWS ; i++ ){
            digitalWrite(rowPins[i], HIGH);
            for(int j =0 ; j < COLS ; j++){
                index = i * ROWS + j;
                if(digitalRead(colPins[j]) == 1){
                    result[count]=KEYS[index];
                    count += 1;
                }
            }
            delay(1);
            digitalWrite(rowPins[i], LOW);
        }
    }

    bool keyCompare(unsigned char* a, unsigned char* b){
        for (int i=0; i<BUTTON_NUM; i++){
            if (a[i] != b[i]){
                return false;
            }
        }
        return true;
    }

    void keyCopy(unsigned char* a, unsigned char* b){
        for (int i=0; i<BUTTON_NUM; i++){
            a[i] = b[i];
        }
    }

    void keyPrint(unsigned char* a){
        if (a[0] != 0){
            printf("%c",a[0]);
        }
        for (int i=1; i<BUTTON_NUM; i++){
            if (a[i] != 0){
                printf(", %c",a[i]);
            }
        }
        printf("\n");
    }

    void keyClear(unsigned char* a){
        for (int i=0; i<BUTTON_NUM; i++){
            a[i] = 0;
        }
    }

    int keyIndexOf(const char value){
        for (int i=0; i<BUTTON_NUM; i++){
            if ((const char)KEYS[i] == value){
                return i;
            }
        }
        return -1;
    }

**Code Erklärung**

.. code-block:: c

    unsigned char KEYS[BUTTON_NUM] {  
    '1','2','3','A',
    '4','5','6','B',
    '7','8','9','C',
    '*','0','#','D'};

    unsigned char rowPins[ROWS] = {1, 4, 5, 6}; 
    unsigned char colPins[COLS] = {12, 3, 2, 0};

Deklarieren Sie jede Taste der Matrixtastatur zu den Array- ``keys[]`` und definieren Sie die Pins für jede Zeile und Spalte.

.. code-block:: c

    while(1){
            keyRead(pressed_keys);
            bool comp = keyCompare(pressed_keys, last_key_pressed);
            if (!comp){
                keyPrint(pressed_keys);
                keyCopy(last_key_pressed, pressed_keys);
            }
            delay(100);
        }

Dies ist der Teil der Hauptfunktion, der den Tastenwert liest und druckt.

Die Funktion ``keys[]`` liest den Status jeder Taste.

Mit ``KeyCompare()`` und ``keyCopy()`` wird beurteilt, ob sich der Status einer Schaltfläche geändert hat (dh eine Schaltfläche wurde gedrückt oder losgelassen).

``keyPrint()`` druckt den Tastenwert der Taste, deren aktueller Niveau hoch ist (die Taste wird gedrückt).


.. code-block:: c

    void keyRead(unsigned char* result){
        int index;
        int count = 0;
        keyClear(result);
        for(int i=0 ; i<ROWS ; i++ ){
            digitalWrite(rowPins[i], HIGH);
            for(int j =0 ; j < COLS ; j++){
                index = i * ROWS + j;
                if(digitalRead(colPins[j]) == 1){
                    result[count]=KEYS[index];
                    count += 1;
                }
            }
            delay(1);
            digitalWrite(rowPins[i], LOW);
        }
    }

Diese Funktion weist jeder Zeile nacheinander eine hohe Ebene zu, 
und wenn die Taste in der Spalte gedrückt wird, erhält die Spalte, 
in der sich die Taste befindet, eine hohe Ebene. 
Nach der zweischichtigen Schleifenbeurteilung generiert die Schlüsselzustandskompilierung ein Array ( ``reasult[]`` ).

Beim Drücken von Taste 3:

.. image:: ../img/image187.png


``rowPin[0]`` writes in the high level, and ``colPin[2]`` gets the high level.
``colPin[0]`` , ``colPin[1]`` , ``colPin[3]`` get the low level.

This gives us 0,0,1,0. When ``rowPin[1]`` , ``rowPin[2]`` and ``rowPin[3]`` are
written in high level, ``colPin[0]`` ~ ``colPin[4]`` will get low level.

After the loop judgment is completed, an array will be generated:


``rowPin[0]`` schreibt auf der hohen Ebene und ``colPin[2]`` erhält die hohe Ebene. 
``colPin[0]`` , ``colPin[1]`` , ``colPin[3]`` erhalten den niedrigen Wert.

Dies gibt uns 0,0,1,0. 
Wenn ``rowPin[1]`` , ``rowPin[2]`` und ``rowPin[3]`` auf hoher Ebene geschrieben werden, 
wird ``colPin[0]`` ~ ``colPin[4]`` auf niedriger Ebene.

Nach Abschluss der Schleifenbeurteilung wird ein Array generiert:

.. code-block:: c

    result[BUTTON_NUM] {  
    0, 0, 1, 0,
    0, 0, 0, 0,
    0, 0, 0, 0,
    0, 0, 0, 0};

.. code-block:: c

    bool keyCompare(unsigned char* a, unsigned char* b){
        for (int i=0; i<BUTTON_NUM; i++){
            if (a[i] != b[i]){
                return false;
            }
        }
        return true;
    }

    void keyCopy(unsigned char* a, unsigned char* b){
        for (int i=0; i<BUTTON_NUM; i++){
            a[i] = b[i];
        }
    }


Diese beiden Funktionen werden verwendet, um zu beurteilen, 
ob sich der Tastenstatus geändert hat. Wenn Sie beispielsweise Ihre Hand loslassen, 
wenn Sie ‚3‘ oder ‚2‘ drücken, gibt ``keyCompare()`` false zurück.

Mit ``KeyCopy()`` wird der aktuelle Schaltflächenwert für ein Array ( ``last_key_pressed[BUTTON_NUM]`` ) nach 
jedem Vergleich neu geschrieben. So können wir sie beim nächsten Mal vergleichen.

.. code-block:: c

    void keyPrint(unsigned char* a){
    //printf("{");
        if (a[0] != 0){
            printf("%c",a[0]);
        }
        for (int i=1; i<BUTTON_NUM; i++){
            if (a[i] != 0){
                printf(", %c",a[i]);
            }
        }
        printf("\n");
    }

Mit dieser Funktion wird der Wert der aktuell gedrückten Taste gedruckt. Wenn die Taste ‚1‘ gedrückt wird, wird die ‚1‘ gedruckt. Wenn die Taste ‚1‘ gedrückt wird und die Taste ‚3‘ gedrückt wird, wird die ‚1, 3‘ gedruckt.