Bolg -Arduino – Tastatura 4×3 ( KeyPad 4×3 )

Arduino – Tastatura 4×3 ( KeyPad 4×3 )

Postat de pe data de 13 mai 2020 in categoria Arduino

image_pdfimage_print

În acest articol vă voi arăta cum folosim o tastatură 4×3 conectată la o placă Arduino. De ce o tastatură 4×3?, pentru că asta am momentan :). Principiul este asemănător indiferent de tastatură.

Tastatura folosită este cea din figura de mai jos :

De obicei o tastatură este construită sub formă de matrice. Sub fiecare tastă se află fire verticale și orizontale, iar când o tastă este apăsată aceste fire se conectează.

Un exemplu de matrice :

\( \begin{bmatrix} 1 &2&3\\ 4&5&6\\ 7&8&9\\ 10&11&12 \end{bmatrix} \Longrightarrow \) în loc de numere punem notațiile de pe tastatura noastră și vom obține \( \begin{bmatrix} 1 &2&3\\ 4&5&6\\ 7&8&9\\ \ast&0&\# \end{bmatrix} \) , după cum vedeți rezultatul arată ca și tastatura noastră.

După cum știți matricea este formată din linii și coloane :

\( \begin{matrix} Col0&Col1&Col2\\ \downarrow&\downarrow&\downarrow\\ 1 & 2 & 3&\rightarrow&linia0\\ a & b & c&\rightarrow&linia1\\ 7&8&9&\rightarrow&linia2\\ \ast&0&\#&\rightarrow&linia3 \end{matrix} \)

Concluzia este următoarea: când vrem să folosim cifra 1 de fapt accesăm matricea la poziția (linia 0, coloana 0), pentru cifra 9 accesăm matricea la poziția ( linia2, col2 ), pentru simbolul * accesăm matricea la poziția ( linia3 , col0 ), și așa mai departe.

Din punct de vedere electronic, schema tastaturii arată astfel :

Dacă facem o comparație vizuală între cele două ( matricea și schema electronică ) vom observa asemănările :

\( \begin{matrix} Col0&Col1&Col2\\ \downarrow&\downarrow&\downarrow\\ 1 & 2 & 3&\rightarrow&linia0\\ a & b & c&\rightarrow&linia1\\ 7&8&9&\rightarrow&linia2\\ \ast&0&\#&\rightarrow&linia3 \end{matrix} \)

Revenind la treburile noastre, în imaginea de mai jos avem tastatura cu configurația pinilor :

Ce se întâmplă la apăsarea tastelor :

  • dacă se pasă tasta 1 \( \rightarrow \) pin 2 + pin 3 = scurt
  • dacă se pasă tasta 2 \( \rightarrow \) pin 2 + pin 1 = scurt
  • dacă se pasă tasta 3 \( \rightarrow \) pin 2 + pin 5 = scurt
  • dacă se pasă tasta 4 \( \rightarrow \) pin 7 + pin 3 = scurt
  • dacă se pasă tasta 5 \( \rightarrow \) pin 7 + pin 1 = scurt
  • dacă se pasă tasta 6 \( \rightarrow \) pin 7 + pin 5 = scurt
  • dacă se pasă tasta 7 \( \rightarrow \) pin 6 + pin 3 = scurt
  • dacă se pasă tasta 8 \( \rightarrow \) pin 6 + pin 1 = scurt
  • dacă se pasă tasta 9 \( \rightarrow \) pin 6 + pin 5 = scurt
  • dacă se pasă tasta * \( \rightarrow \) pin 4 + pin 3 = scurt
  • dacă se pasă tasta 0 \( \rightarrow \) pin 4 + pin 1 = scurt
  • dacă se pasă tasta # \( \rightarrow \) pin 4 + pin 5 = scurt

În concluzie, la apăsarea unei taste , o linie și o coloană vor fi în scurt circuit, de aceea o variantă de depistare a tastei apăsate este următoarea :

  • setăm una din coloane pe starea LOW, iar celelalte coloane le lăsăm pe starea HIGH. Dacă una din linii trece pe starea LOW atunci tasta apăsată este cea în dreptul căreia se încrucișează liniile HIGH.

Mai jos vă prezint un exemplu de program pentru controlul tastaturii.

Rezultatul este afișat la terminalul serial, care pentru a fi accesat se dă click pe : Tools \( \rightarrow \) Serial Monitor

Schema electronică :

Codul sursă:

const int linii = 4; // tastatura are 4 linii
const int coloane = 3; // tastatura are 3 coloane
char taste[linii][coloane] = {
     {'1','2','3'},
     {'4','5','6'},
     {'7','8','9'},
     {'*','0','#'}
}; // am declarat tastele sub formă de matrice
 
byte PinLinii[linii] = {11, 6, 7, 9}; //se declară pinii la care sunt conectate liniile tastaturii ( r0, r1, r2, r3 ).
byte PinCol[coloane] = {10, 12, 8}; //se declară pinii la care sunt conectate coloanele tastaturii ( c0, c1, c2 ).

 const char niciotasta='n';
 unsigned int TimpUltimaApasare;
 unsigned int TimpApasare=30;
 
void setup() {
     Serial.begin(9600);
     TimpUltimaApasare=millis();

// se setează fiecare pin conectat la liniile tastaturii ca fiind de intrare și având starea HIGH. Activează pull up resistor.
    
   for(int i=0;i<linii;i++)
     {
      pinMode(PinLinii[i],INPUT);
      digitalWrite(PinLinii[i],HIGH);
     }
     for(int j=0;j<coloane;j++)
     {
      pinMode(PinCol[j],INPUT);
     }
}
 
void loop(){
     char tasta = apasaTasta();
     
     if (tasta != niciotasta){
           Serial.println(tasta);
     }
  delay(100);
}

char apasaTasta()
{
  char tastaGasita=niciotasta;

// verifică dacă diferența dintre timpul de funcționare măsurat de instrucțiunea millis() și timpul de la ultima apăsare 
//este de peste 30ms. După cum se vede, în loop() se apelează funcția apasaTasta() odată la 100ms

  if((millis()-TimpUltimaApasare)>TimpApasare)
  {
    for(int c=0;c<coloane;c++)
    {
//trece coloana curentă la starea LOW, celelalte rămânând în starea HIGH apoi vom trece la linii și vom verifica 
//ce linie este apăsată, iar tasta este luată din matricea noastră având poziția ( l, c ). Apoi vom trece 
//coloana în modul INPUT pentru a nu interfera cu alte citiri.

      pinMode(PinCol[c],OUTPUT);
      digitalWrite(PinCol[c],LOW);
      for(int l=0;l<linii;l++)
      {
        if(digitalRead(PinLinii[l])==LOW)
        {
          tastaGasita=taste[l][c];
        }
      }
      digitalWrite(PinCol[c],HIGH);
      pinMode(PinCol[c],INPUT);
      if(tastaGasita!=niciotasta)
      {
        break;
      }
    }
    TimpUltimaApasare=millis();
  }
  return tastaGasita;
}

După cum ați văzut nu am apelat nici o librărie, iar acest lucru a dus la un program destul de lung. Pe internet sunt o mulțime de librarii pentru tastaturi pe care le putem folosi.

O librărie bună o găsiți aici. O instalați și scrieți următorul cod de program ( schema este aceiași )

Cod program ce folosește librărie:

#include <Keypad.h>
 
const byte linii = 4; //four rows
const byte coloane = 3; //three columns
char keys[linii][coloane] = {
     {'1','2','3'},
     {'4','5','6'},
     {'7','8','9'},
     {'*','0','#'}
};
 
byte pinLinii[linii] = {11, 6, 7, 9}; //se declară pinii la care sunt conectate liniile tastaturii ( r0, r1, r2, r3 ).
byte pinCol[coloane] = {10, 12, 8}; //se declară pinii la care sunt conectate coloanele tastaturii ( c0, c1, c2 ).
 
Keypad keypad = Keypad( makeKeymap(keys), pinLinii, pinCol, linii, coloane );
 
void setup() {
     Serial.begin(9600);
}
 
void loop(){
     char tasta = keypad.getKey();
     
     if (tasta != NO_KEY){
           Serial.println(tasta);
     }
}

Observați diferența de cod!!!!

În continuare adăugăm un ecran LCD 16×2 la schema noastră inițială:


#include<LiquidCrystal.h> 
const int linii = 4; //four rows
const int coloane = 3; //three columns
char taste[linii][coloane] = {
     {'1','2','3'},
     {'4','5','6'},
     {'7','8','9'},
     {'*','0','#'}
};
 
byte PinLinii[linii] = {7, 6, 5, 4}; 
byte PinCol[coloane] = {3, 2, 1}; 

 const char niciotasta='n';
 unsigned int TimpUltimaApasare;
 unsigned int TimpApasare=30;
 

LiquidCrystal lcd(13,12,11,10,9,8); 
void setup() {
     
     lcd.begin(16 , 2);     //Configurare LCD 16x2   
     lcd.clear();  //Sterge continutul de pe ecranul LCD
     TimpUltimaApasare=millis();
     for(int i=0;i<linii;i++)
     {
      pinMode(PinLinii[i],INPUT);
      digitalWrite(PinLinii[i],HIGH);
     }
     for(int j=0;j<coloane;j++)
     {
      pinMode(PinCol[j],INPUT);
     }
}
 
void loop(){
     char tasta = apasaTasta();
     lcd.setCursor(0, 0);
     if (tasta != niciotasta){
           lcd.clear();lcd.print(tasta);
     }
  delay(100);
}

char apasaTasta()
{
  char tastaGasita=niciotasta;
  if((millis()-TimpUltimaApasare)>TimpApasare)
  {
    for(int c=0;c<coloane;c++)
    {
      pinMode(PinCol[c],OUTPUT);
      digitalWrite(PinCol[c],LOW);
      for(int l=0;l<linii;l++)
      {
        if(digitalRead(PinLinii[l])==LOW)
        {
          tastaGasita=taste[l][c];
        }
      }
      digitalWrite(PinCol[c],HIGH);
      pinMode(PinCol[c],INPUT);
      if(tastaGasita!=niciotasta)
      {

Imagini si două filmulețe cu cele doua aplicații de mai sus. Schemele si codurile de program sunt testate și simulate cu proteus și vă asigur că vor funcționa și în practică.

Lasă un răspuns

Adresa ta de email nu va fi publicată. Câmpurile obligatorii sunt marcate cu *

Acest sit folosește Akismet pentru a reduce spamul. Află cum sunt procesate datele comentariilor tale.



Insert math as
Block
Inline
Additional settings
Formula color
Text color
#333333
Type math using LaTeX
Preview
\({}\)
Nothing to preview
Insert