[28] Arduino - Klawiatura membranowa

Ten post chciałbym poświęcić na przygotowanie programu obsługującego klawiaturę membranową w formacie 4x4, która posiada 16 klawiszy. Jej wygląd przedstawiłem poniżej na rysunku 1. 

Rys. 1. Klawiatura matrycowa [elektroda.pl]

Poniżej przedstawię programy, które zostały oparte o bibliotekę Keypad.

Jeśli chodzi o podłączenie to wiersze są podpięte do pinów 2, 3, 4, 5 natomiast kolumny do pinów 6,  7, 8, 9.

Sama obsługa jest w zasadzie dosyć prosta, skanuje się kolumny bądź linie w poszukiwaniu stanu wysokiego. Gdy zostanie on znaleziony, przeszukiwane są znowu kolumny lub wiersze, w zależności co było pierwsze. Gdy zostanie wykryty stan wysoki to wciśnięty jest przycisk na przecięciu obu linii.

Program biblioteka Keypad

Na samym początku należy zdeklarować ilość wierszy oraz kolumn:

1. #include <Keypad.h>
3. const byte Wiersze = 4;
4. const byte Kolumny = 4;
6. byte Piny_Wiersze[Wiersze] = {2, 3, 4, 5};
7. byte Piny_Kolumny[Kolumny] = {6, 7, 8, 9};

Kolejnym etapem jest odpowiednie zmapowanie klawiszy, dla przesyłania ich prze UART;

1. char keys[Wiersze][Kolumny] = { {'1','2','3','A'},
2.                                 {'4','5','6','B'},
3.                                 {'7','8','9','C'},
4.                                 {'*','0','#','D'}   };

Teraz kolejnym elementem jest włączenie biblioteki poprzez odpowiednie zainicjalizowanie zmiennej strukturalnej przygotowanymi danymi:

Keypad Membran_Klaw = Keypad( makeKeymap(keys), Piny_Wiersze, Piny_Kolumny, Wiersze, Kolumny );

Dalsza część programu zależy głównie od naszej wyobraźni i tego co finalnie chcemy przekazać. Ja przygotuje dwa różne programy jeden z nich będzie wyświetlał to co aktualnie zostało kliknięte. Drugi natomiast będzie oczekiwał na serię znaków zakończonych #. Jeśli będzie ona poprawna to nastąpi "odblokowanie" zamka. Czyli prosty zamek z szyfrem:

Pierwszy program jak już wspomniałem wcześniej będzie miał za zadanie wyświetlanie znaków oraz zliczania ilości wciśniętych klawiszy:

1. uint16_t Licznik_Wcis = 0;
3. void setup()
4. {
5.   Serial.begin(9600); //Transmisja po uarcie
6. }
8. void loop()
9. {
10.   char jaki_klawisz = Membran_Klaw.getKey();
12.   if (jaki_klawisz)
13.   {
14.     Licznik_Wcis++;
15.     Serial.println("Klawisz: ");
16.     Serial.println(jaki_klawisz);
17.     Serial.print("Wcisniecie numer: ");
18.     Serial.println(Licznik_Wcis);
19.   }
20. }

Do tego programu można jeszcze dołożyć buzzer, sterowany albo bezpośrednio z nogi, lub z tranzystora. Ja podłączyłem buzzer pod pin 10, który jest sterowany sygnałem PWM. Po kliknięciu wywoływany jest na nim dźwięk. Co pozwala na dużo łatwiejszą identyfikacje czy dany klawisz został rzeczywiście wciśnięty.

1. #include <Keypad.h>
3. const byte Wiersze = 4;
4. const byte Kolumny = 4;
6. byte Piny_Wiersze[Wiersze] = {2, 3, 4, 5};
7. byte Piny_Kolumny[Kolumny] = {6, 7, 8, 9};
9. char keys[Wiersze][Kolumny] = { {'1','2','3','A'},
10.                                 {'4','5','6','B'},
11.                                 {'7','8','9','C'},
12.                                 {'*','0','#','D'}   };
14. Keypad Membran_Klaw = Keypad( makeKeymap(keys), Piny_Wiersze, Piny_Kolumny, Wiersze, Kolumny );
16. uint16_t Licznik_Wcis = 0;
18. void setup()
19. {
20.   Serial.begin(9600); //Transmisja po uarcie
21.   pinMode(10, OUTPUT); //10 jako wyjście do generowania PWM
22. }
24. void loop()
25. {
26.   char jaki_klawisz = Membran_Klaw.getKey();
28.   if (jaki_klawisz)
29.   {
30.     analogWrite(10, 184);
31.     delay(200);
32.     analogWrite(10, 0);
33.     Licznik_Wcis++;
34.     Serial.print(jaki_klawisz);
35.     Serial.print(" ");
36.     Serial.print("Wcisniecie numer: ");
37.     Serial.println(Licznik_Wcis);
38.   }
39. }

Program numer dwa ma część główną niezmienną, Poniżej przedstawię część z funkcją setup oraz pętlą loop wraz z odpowiednio przygotowaną funkcją sprawdzającą wynik:

W tym programie wpisywanie należy rozpocząć od przyciśnięcia klawisza #. Następnie podawany jest kod składający się z czterech cyfr pomieszanych ze znakami (kod: 83C1). Po jego wpisaniu odpowiednio zdefiniowana akcja zostaje wywołana. W moim przypadku będzie to wyświetlanie napisu Otwarte oraz pojedyncze pipnięcie buzzera. 

1. #include <Keypad.h>
3. const byte Wiersze = 4;
4. const byte Kolumny = 4;
6. byte Piny_Wiersze[Wiersze] = {2, 3, 4, 5};
7. byte Piny_Kolumny[Kolumny] = {6, 7, 8, 9};
9. char keys[Wiersze][Kolumny] = { {'1','2','3','A'},
10.                                 {'4','5','6','B'},
11.                                 {'7','8','9','C'},
12.                                 {'*','0','#','D'}   };
14. Keypad Membran_Klaw = Keypad( makeKeymap(keys), Piny_Wiersze, Piny_Kolumny, Wiersze, Kolumny );
16. uint16_t Licznik_Wcis = 0;
17. uint8_t Licznik_do_kodu = 0;
18. uint8_t Zle_Wcisniecia = 0;
20. const char Pin1 = '8';
21. const char Pin2 = '3';
22. const char Pin3 = 'C';
23. const char Pin4 = '1';
25. void setup()
26. {
27.   Serial.begin(9600); //Transmisja po uarcie
28.   pinMode(10, OUTPUT); //10 jako wyjście do generowania PWM
29. }
31. void loop()
32. {
33.   char jaki_klawisz = Membran_Klaw.getKey();
35.   if (jaki_klawisz)
36.   {
37.     if(Licznik_do_kodu == 0 && jaki_klawisz == '#')
38.     {
39.       Serial.println(Licznik_do_kodu);
40.       Licznik_do_kodu++;
41.     }
42.     else if(Licznik_do_kodu == 1 && jaki_klawisz == Pin1)
43.     {
44.       Serial.println(Licznik_do_kodu);
45.       Licznik_do_kodu++;
46.     }
47.     else if(Licznik_do_kodu == 2 && jaki_klawisz == Pin2)
48.     {
49.       Serial.println(Licznik_do_kodu);
50.       Licznik_do_kodu++;
51.     }
52.     else if(Licznik_do_kodu == 3 && jaki_klawisz == Pin3)
53.     {
54.       Serial.println(Licznik_do_kodu);
55.       Licznik_do_kodu++;
56.     }
57.     else if(Licznik_do_kodu == 4 && jaki_klawisz == Pin4)
58.     {
59.       Serial.println(Licznik_do_kodu);
60.       Licznik_do_kodu++;
61.       if(Licznik_do_kodu == 5)
62.       {
63.         Serial.println("Kod Poprawny");
64.         analogWrite(10, 150);
65.         delay(200);
66.         analogWrite(10, 0);
67.       }
68.     }
69.     else
70.     {
71.       Licznik_do_kodu = 0;
72.       Zle_Wcisniecia++;
73.            
74.       analogWrite(10, 200);
75.       delay(200);
76.       analogWrite(10, 0);
77.        
78.       if(Zle_Wcisniecia == 2)
79.       {
80.         Serial.println("Zly kod ALARM!");
81.         analogWrite(10, 100);
82.         delay(5000);
83.         analogWrite(10, 0);
84.       }
85.     }
86.   }
87. }