2.1.5 Keypad

Introduction

In this beginner-friendly project, you’ll learn how to use a keypad to input numbers and characters into your Raspberry Pi. Think of it like a mini keyboard or the number pad on a phone - press a button and your program knows which one you pressed!

Components

What is a Keypad?

A keypad is like a mini keyboard with buttons arranged in a rectangular grid. Most keypads have either 12 buttons (like a phone) or 16 buttons (4x4 grid). Each button is a simple switch that can be pressed to send a signal.

How does a keypad work?

Instead of having separate wires for each button (which would need 12 or 16 wires!), keypads use a clever trick called “matrix scanning”:

The Smart Design: - Rows and Columns: The buttons are arranged in a grid with 4 horizontal wires (rows) and 4 vertical wires (columns) - Only 8 wires needed: Instead of 16 separate wires, we only need 8 wires total (4 + 4) - Unique combinations: Each button connects a specific row wire to a specific column wire

How we detect button presses:

Send signals: The Raspberry Pi sends a signal to one row at a time
Listen for response: While sending to that row, it checks all the column wires
Find the match: If a button is pressed, the signal travels from the row wire to the column wire
Identify the button: The combination of row and column tells us exactly which button was pressed

Why this matters for beginners: - Fewer wires: Much simpler wiring than individual buttons - Easy programming: Your code just needs to scan rows and check columns - Reliable detection: Each button has a unique “address” in the grid - Cost effective: One keypad replaces many individual buttons

Connect

Code

For C Language User

Go to the code folder compile and run.

cd ~/super-starter-kit-for-raspberry-pi/c/2.1.5/

g++ 2.1.5_Keypad.cpp -lwiringPi

sudo ./a.out

After the code runs, the values of pressed buttons on keypad (button Value) will be printed on the screen.

This is the complete code

#include <wiringPi.h>
#include <stdio.h>
#include <vector>
#include <string>
#include <iostream>
#include <stdlib.h> // Required for exit()

// Define the layout of the keypad.
const int NUM_ROWS = 4;
const int NUM_COLS = 4;

// Define a class to encapsulate all keypad functionality.
class Keypad {
public:
   // Constructor: Initializes the keypad with specified pins and key map.
   Keypad(const int* rowPins, const int* colPins, const char* keyMap);

   // Scans the keypad and returns a vector of currently pressed keys.
   std::vector<char> getPressedKeys();

private:
   // Initializes GPIO pins.
   void initialize_pins();

   const int* row_pins;
   const int* col_pins;
   const char* key_map;
   std::vector<char> last_pressed_keys;
};

Keypad::Keypad(const int* rowPins, const int* colPins, const char* keyMap)
   : row_pins(rowPins), col_pins(colPins), key_map(keyMap) {
   if (wiringPiSetup() == -1) {
      printf("Failed to setup wiringPi!\n");
      exit(1);
   }
   initialize_pins();
}

void Keypad::initialize_pins() {
   for (int i = 0; i < NUM_ROWS; ++i) {
      pinMode(row_pins[i], OUTPUT);
      digitalWrite(row_pins[i], LOW); // Set rows low initially.
   }
   for (int i = 0; i < NUM_COLS; ++i) {
      pinMode(col_pins[i], INPUT);
      pullUpDnControl(col_pins[i], PUD_DOWN); // Use internal pull-down resistors.
   }
}

std::vector<char> Keypad::getPressedKeys() {
   std::vector<char> pressed_keys;
   for (int r = 0; r < NUM_ROWS; ++r) {
      // Activate one row at a time.
      digitalWrite(row_pins[r], HIGH);

      // Scan all columns for this active row.
      for (int c = 0; c < NUM_COLS; ++c) {
            if (digitalRead(col_pins[c]) == HIGH) {
               pressed_keys.push_back(key_map[r * NUM_COLS + c]);
            }
      }

      // Deactivate the row before moving to the next one.
      digitalWrite(row_pins[r], LOW);
   }
   return pressed_keys;
}

// --- Main Application ---

// Define the physical pin connections.
const int ROW_PINS[NUM_ROWS] = {1, 4, 5, 6};
const int COL_PINS[NUM_COLS] = {12, 3, 2, 0};

// Define the character map for the keys.
const char KEY_MAP[NUM_ROWS * NUM_COLS] = {
   '1', '2', '3', 'A',
   '4', '5', '6', 'B',
   '7', '8', '9', 'C',
   '*', '0', '#', 'D'
};

/**
* @brief Prints the currently pressed keys to the console.
* @param keys A vector of characters representing the pressed keys.
*/
void print_keys(const std::vector<char>& keys) {
   if (keys.empty()) {
      std::cout << "No key pressed" << std::endl;
   } else {
      std::cout << "Pressed: ";
      for (size_t i = 0; i < keys.size(); ++i) {
            std::cout << keys[i] << (i == keys.size() - 1 ? "" : ", ");
      }
      std::cout << std::endl;
   }
}

/**
* @brief Main function.
* @return Integer status code.
*/
int main(void) {
   Keypad keypad(ROW_PINS, COL_PINS, KEY_MAP);
   std::vector<char> last_pressed;

   printf("Keypad scanner initialized. Press any key.\n");

   while (1) {
      std::vector<char> currently_pressed = keypad.getPressedKeys();

      // Only print if the state has changed.
      if (currently_pressed != last_pressed) {
            print_keys(currently_pressed);
            last_pressed = currently_pressed;
      }

      delay(100); // Poll every 100ms.
   }

   return 0; // Unreachable.
}

For Python Language User

Go to the code folder and run.

cd ~/super-starter-kit-for-raspberry-pi/python

python 2.1.5_Keypad.py