Toetsenblok

Toetsenblokken ("keypads")

Zeg je 3 × 4 of 4 × 3 keypad?
Beide vormen worden gebruikt. Ik houd het bij: aantal rijen × aantal kolommen. Het staat iedereen vrij om dit anders te doen!

Toetsenblokken zijn toetsenborden, maar dan met weinig toetsen. Vaak zijn dat vooral numerieke toetsen. Ik beperk me op deze pagina tot de heel simpele toetsenblokken, zonder ingebouwde diodes of andere elektronica. Je kunt zo'n toetsenblok ook zelf maken, daarover later meer. Het meest bekende toetsenblok is een 4 × 4 membraan toetsenblok met 10 cijfers en nog A, B, C en D erop. Een ander bekend toetsenblok is het 5 × 4 membraan toetsenblok met naast de numerieke toetsen ook twee functietoetsen, pijltjes in vier richtingen en Esc(cape) en Ent(er). Bedenk wel dat een numerieke toets precies hetzelfde is als elke ander toets (alleen het opschrift is dan een cijfer). Het staat je als Arduino programmeur helemaal vrij welke betekenis je aan elke toets geeft. Het is voor de gebruiker wel fijn als het opschrift klopt met de werkelijke functies, dus plak eventueel andere labels op de toetsen.

Toetsenblok met 4 × 4 toetsen

Membraan toetsenblok met aansluitingen aangegeven

Klik-toetsenblok in werking

Het membraan toetsenblok (zie foto) heeft aan de onderzijde een flatcable waarin je duidelijk twee soorten draden kunt zien. De linker 4 aansluitingen (met onder een zwarte vlakje) associeer ik met de kolommen en de rechtse vier met de rijen. Bij het klik-toetsenblok is dat precies andersom. Sluit het toetsenblok zo aan dat alle pinnen van de flatcable verbonden zijn met digitale pinnen 4 t/m 7 en 8 t/m 11 (deze volgorde correspondeert met de pinnen van het toesenblok van rechts naar links). Als je alle pinnen wilt verschuiven zet dan in het programma in StartRij en StartKol het nummer van de Arduino pin die je voor de meest rechtse rij resp. kolom gebruikt. Als je het toetsenblok helemaal anders wilt aansluiten dan moet je een eigen functie maken. Het klik-toetsenblok heeft 10 pinnen, maar daarvan sluit je alleen de middelste 8 aan. Omdat de kolommen en rijen zijn omgewisseld wissel je de getallen bij StartKol en StartRij ook om, zie het testprogramma.

Klik hier om het testprogramma te zien

// Testprogramma voor 4 x 4 toetsen keypad
// c(2018) Th.M. Hupkens
#define StartRij 8 // Bij membraan: 8; bij toetsenblok met kliktoetsen: 4
#define StartKol 4 // Bij membraan: 4; bij toetsenblok met kliktoetsen: 8
String ToetsNaam[][4] = {
  {"1", "2", "3", "A"},
  {"4", "5", "6", "B"},
  {"7", "8", "9", "C"},
  {"*", "0", "#", "D"}
};

struct ToetsSoort {
  byte rij;
  byte kol;
};

ToetsSoort Toets;

void setup() {
  for (byte rij = StartRij; rij < StartRij + 4; rij++) {
    pinMode(rij, OUTPUT);
    digitalWrite(rij, LOW);
  }
  for (byte kol = StartKol; kol < StartKol + 4; kol++) pinMode(kol, INPUT_PULLUP);
  Serial.begin(9600);
}

void rijHoog() {
  for (byte rij = 0; rij < 4; rij++) digitalWrite(StartRij + rij, HIGH);
}

bool ToetsIn() {
  for (byte rij = 0; rij < 4; rij++) {
    rijHoog();
    digitalWrite(StartRij + rij, LOW);
    for (byte kol = 0; kol < 4; kol++)
      if (digitalRead(StartKol + kol) == LOW) {
        Toets.rij = 3 - rij; Toets.kol = 3 - kol;
        while (digitalRead(StartKol + kol) == LOW); // Voorkom dubbele aanslag
        return true;
      }
  }
  return false;
}

void loop() {
  while (!ToetsIn());
  Serial.print("Toets: "); Serial.println(ToetsNaam[Toets.rij][Toets.kol]);
}

Omdat er geen standaard bestaat voor het bedraden van matrix keypads, kan het zijn dat je ondanks een goede aansluiting toch foutieve toetsnamen te zien krijgt. Het makkelijkst is dan om alle toetsen een keer in te drukken en de naam in ToetsNaam aan te passen. Als je meerdere soorten toetsenblokken door elkaar gebruikt is dat niet handig. Daarom deze richtlijn: als rijen en kolommen verwisseld zijn verwissel je de getallen bij StartRij en StartKol; als de toetsen gespiegeld zijn vervang je Toets.kol = 3 - kol; door Toets.kol = kol; als boven en onder verwisseld zijn vervang je Toets.rij = 3 - rij; door Toets.rij = rij; .
Ik heb ook nog een 4×4 toetsenblok getest met alleen drukknoppen zonder bijschrift.
Daarbij maakt het niet uit wat je rij en kolom noemt en ook niet hoe de toetsen heten. Meestal geeft men in zo'n geval de ingedrukte toets weer als een getal van 0 tot 15 of van 1 to 16 (een voorbeeld zie je in het testprogramma bij het zelfbouw toetsenblok).

Toetsenblok met 5 × 4 toetsen

Toetsenblok

Dit toetsenblok heeft vijf rijen van vier toetsen. Om het toetsenblok te kunnen gebruiken heb je 9 pinnen van de Arduino nodig. Door de transparante aansluitkabel ("flatcable") van dit toetsenblok kun je goed zien dat er een groepje van 5 en een groepje van 4 aansluitingen is. Dat correspondeert met de rijen en kolommen van de toetsen. Als je het testprogramma ongewijzigd wilt gebruiken dan moet je de flatcable aansluiten (van rechts naar links) op de pinnen 2 t/m 10. Mocht je andere pinnen willen gebruiken, dan kun je de StartRij en Startkolom aanpassen. In de testprogramma's heb ik een zogenaamde struct gebruikt, zodat je makkelijk ( via een Serial.print(Toets.rij) of Serial.print(Toets.kol) ) kunt zien in welke rij of kolom de ingedrukte toets zich bevindt.
Er zijn toetsenblokken waarbij de rijen en kolommen anders zijn aangesloten. Met dit testprogramma kun je gemakkelijk nagaan hoe dat is en kun je zonodig de code of de namen aanpassen.

Klik hier om het testprogramma te zien

// Testprogramma voor 5 x 4 toetsen keypad
#define StartRij 2
#define StartKol 7
String ToetsNaam[][4] = {
  {"F1", "F2", "#", "*"},
  {"1", "2", "3", "Omhoog"},
  {"4", "5", "6", "Omlaag"},
  {"7", "8", "9", "Esc"},
  {"Links", "0", "Rechts", "Enter"}
};

struct ToetsSoort {
  byte rij;
  byte kol;
};

ToetsSoort Toets;

void setup() {
  for (byte rij = StartRij; rij < StartRij + 5; rij++) {
    pinMode(rij, OUTPUT);
    digitalWrite(rij, LOW);
  }
  for (byte kol = StartKol; kol < StartKol + 4; kol++) pinMode(kol, INPUT_PULLUP);
  Serial.begin(9600);
}

void rijHoog() {
  for (byte rij = 0; rij < 5; rij++) digitalWrite(StartRij + rij, HIGH);
}

bool ToetsIn() {
  for (byte rij = 0; rij < 5; rij++) {
    rijHoog();
    digitalWrite(StartRij + rij, LOW);
    for (byte kol = 0; kol < 4; kol++)
      if (digitalRead(StartKol + kol) == LOW) {
        Toets.rij = rij; Toets.kol = 3 - kol;
        while (digitalRead(StartKol + kol) == LOW); // Voorkom dubbele aanslag
        return true;
      }
  }
  return false;
}

void loop() {
  while (!ToetsIn()); 
  Serial.print("Toets: "); Serial.println(ToetsNaam[Toets.rij][Toets.kol]);
}

Toetsenblok met 4 × 3 toetsen

Membraan 4 × 3 toetsenblok

Dit toetsenblok is vooral goed bruikbaar om menukeuzes te maken, niet zozeer voor spelbesturingen omdat er geen pijltjestoetsen zijn. Ik heb in dit geval een voorbeeld dat je zelf makkelijk kunt aanpassen om aan elke toets een bepaalde functie te koppelen. Tegelijk kun je er de aansluitingen mee testen. Sluit de drie rechtse connectors aan op pin 2 t/m 4 van de Arduino en de vier linkse op pin 5 t/m 8 van de Arduino. Dit toetsenbord werkt erg goed!

Klik hier om het voorbeeld te zien

// Programma voor 4 x 3 membraan toetsenblok
// c(2018) Th.M. Hupkens
#define StartKol 2 // De drie aansluitingen rechts gaan naar de pinnen 2 t/m 4
#define StartRij 5 // De vier aansluitingen links gaan naar de pinnen 5 t/m 8
#define Ster 11    // Zo kun je het programma leesbaar houden, 
#define Hekje 12   // zonder dat dat extra geheugen kost
byte ToetsNaam[][4] = { {1, 2, 3},  {4, 5, 6},  {7, 8, 9},  {Ster, 0, Hekje} };

struct ToetsSoort { // Alle gegevens van de toets staan hier bij elkaar
  byte rij;
  byte kol;
  byte Naam;
};

ToetsSoort Toets;

void setup() {
  for (byte rij = StartRij; rij < StartRij + 4; rij++) {
    pinMode(rij, OUTPUT);
    digitalWrite(rij, LOW);
  }
  for (byte kol = StartKol; kol < StartKol + 3; kol++) pinMode(kol, INPUT_PULLUP);
  Serial.begin(9600);
  Serial.println("Druk een toets in");
}

void rijHoog() {
  for (byte rij = 0; rij < 4; rij++) digitalWrite(StartRij + rij, HIGH);
}

bool ToetsIn() {
  for (byte rij = 0; rij < 4; rij++) {
    rijHoog();
    digitalWrite(StartRij + rij, LOW);
    for (byte kol = 0; kol < 3; kol++)
      if (digitalRead(StartKol + kol) == LOW) {
        Toets.rij = 3 - rij; Toets.kol = 2 - kol;
        while (digitalRead(StartKol + kol) == LOW); // Voorkom dubbele aanslag
        return true;
      }
  }
  return false;
}

void loop() {
  while (!ToetsIn()); // Wacht tot er een toets wordt ingedrukt
  Toets.Naam = ToetsNaam[Toets.rij][Toets.kol];
  switch (Toets.Naam) { // Zolang een functie actief is worden geen toetsen uitgelezen!
    case 0: Serial.println("Er is nog geen functie die bij toets 0 hoort"); break;
    case 1: Serial.println("Er is nog geen functie die bij toets 1 hoort"); break;
    case 2: Serial.println("Er is nog geen functie die bij toets 2 hoort"); break;
    case 3: Serial.println("Er is nog geen functie die bij toets 3 hoort"); break;
    case 4: Serial.println("Er is nog geen functie die bij toets 4 hoort"); break;
    case 5: Serial.println("Er is nog geen functie die bij toets 5 hoort"); break;
    case 6: Serial.println("Er is nog geen functie die bij toets 6 hoort"); break;
    case 7: Serial.println("Er is nog geen functie die bij toets 7 hoort"); break;
    case 8: Serial.println("Er is nog geen functie die bij toets 8 hoort"); break;
    case 9: Serial.println("Er is nog geen functie die bij toets 9 hoort"); break;
    case Ster: DoeSter(); break; // Een voorbeeld van een functie-aanroep
    case Hekje: DoeHekje(); break;
  }
}

void DoeSter() {
  Serial.println("Ik voer nu de functie DoeSter() uit");
}

void DoeHekje() {
  Serial.println("Ik voer nu de functie DoeHekje() uit");
}

Zelfbouw toetenblok

Je kunt vrij eenvoudig een eigen toetsenblok maken. Voor het geld kun je het beter niet doen, want de materialen zijn al snel duurder dan een kant en klaar toetsenblok. Maar er zijn een aantal voordelen van een eigen toetsenblok:

Je kunt ze maken voor elk gewenst aantal toetsen.
Je kunt de toetsen zo plaatsen als jij zelf wilt: ver uit elkaar, in een cirkel,...
Als je de toetsen niet in een rechthoek rangschikt dan hebben de termen rij en kolom geen betekenis meer, maar je moet ze dan toch zo aansluiten als of ze in een rechthoek staan; het programma verandert dan niet en ook het benodigd aantal pinnen niet.
Je kunt heel mooie knoppen gebruiken voor de toetsen

Om een toetsenblok te maken moet je eerst bepalen hoeveel rijen en kolommen je nodig hebt. Pas vanaf 6 toetsen is het zinvol om deze methode te gebruiken; een minder aantal toetsen kun je gewoon per toets aansluiten. Gebruikt bij een groter aantallen toetsen eventueel onderstaande tabel. In deze tabel staan de rijen en kolommen waarbij je zo weinig mogelijk pinnen nodig hebt. Sommige aantallen kun je op meerdere manieren maken.

Aantal toetsen	rijen en kolommen	Aantal pinnen
6	2, 3	5
7	2, 3 en de overgebleven toets op zijn eigen pin	6
8	2, 4 of 3, 3	6
9	3, 3	6
10	2, 5	7
10 t/m 12	3, 4	7
13 t/m 16	4, 4	8
17 t/m 20	4, 5	9
21	3, 7	10
21 t/m 25	5, 5	10

Zelfbouw toetsenblok

Schema 2×3 keypad

Je gaat als volgt te werk: gebruik voor elke toets een drukknop. Van de knoppen die naast elkaar in een rij komen verbind je steeds dezelfde kant met elkaar (zie ook het schema). Doe dat voor elke rij en sluit dit per rij aan op een connector of maak er een jumperkabeltjes aan vast. Doe hetzelfde voor de kolommen, maar neem nu de ander kant van elke knop. Verbind deze ook met de connector of met jumperkabeltjes. Ik heb dit getest door een 5 × 5 toetsenblok te maken. Omdat ik geen bijschriften bij de knoppen heb staan geef ik in het testprogramma een nummer van de toets weer, met daarnaast de rij en kolom. Voor mijn toetsenblok klopt dit, als ik het rechtop houdt (met de connector naar beneden), maar jij moet misschien enkele aanpsssingen doen als je het toetsenblok anders bedraad hebt of anders neerlegt dan ik. Het programma is gemakkelijk aan te passen voor een ander aantal toetsen door R en K te veranderen, maar dat heb ik nog niet goed getest.

Klik hier om het testprogramma te zien

// Testprogramma voor zelfgemaakt toetsenblok
// c(2018) Th.M. Hupkens
#define StartRij 7 // Waar beginnen de rijen?
#define R 5        // Hoeveel rijen heb je?
#define StartKol 2 // Waar beginnen de kolommen
#define K 5        // Hoeveel kolommen heb je?

struct ToetsSoort {
  byte rij;
  byte kol;
};

ToetsSoort Toets;

void setup() {
  for (byte rij = StartRij; rij < StartRij + R; rij++) {
    pinMode(rij, OUTPUT);
    digitalWrite(rij, LOW);
  }
  for (byte kol = StartKol; kol < StartKol + K; kol++) pinMode(kol, INPUT_PULLUP);
  Serial.begin(9600);
}

void rijHoog() {
  for (byte rij = 0; rij < R; rij++) digitalWrite(StartRij + rij, HIGH);
}

bool ToetsIn() {
  for (byte rij = 0; rij < R; rij++) {
    rijHoog();
    digitalWrite(StartRij + rij, LOW);
    for (byte kol = 0; kol < K; kol++)
      if (digitalRead(StartKol + kol) == LOW) {
        Toets.rij = R - rij; Toets.kol = K - kol;
        while (digitalRead(StartKol + kol) == LOW); // Voorkom dubbele aanslag
        return true;
      }
  }
  return false;
}

void loop() {
  while (!ToetsIn());
  Serial.print("Toets: "); Serial.print(1 + (Toets.rij - 1) * R + Toets.kol - 1);
  Serial.print("\trij "); Serial.print(Toets.rij); Serial.print("\tkolom "); Serial.println(Toets.kol);
}