Last Updated: 

4x4 External Keypad with Raspberry Pi Pico W in C (No MicroPython)

In the world of embedded systems, input devices play a crucial role in interacting with the user. A 4x4 external keypad is a popular choice for applications where a simple and compact input mechanism is required. The Raspberry Pi Pico W, with its powerful ARM Cortex-M0+ processor, provides an excellent platform to interface with such a keypad. This blog post aims to guide you through the process of using a 4x4 external keypad with the Raspberry Pi Pico W using the C programming language, without relying on MicroPython.

Table of Contents#

  1. Fundamental Concepts
  2. Usage Methods
  3. Common Practices
  4. Best Practices
  5. Code Example
  6. Conclusion
  7. References

Fundamental Concepts#

4x4 External Keypad#

A 4x4 external keypad consists of 16 keys arranged in a 4 - row by 4 - column matrix. Each key is connected to a specific row and column. To detect which key is pressed, we use a technique called "scanning". The basic idea is to set each row as an output and each column as an input. By sequentially setting each row to a low voltage level and checking the voltage levels of the columns, we can determine which key is pressed.

Raspberry Pi Pico W#

The Raspberry Pi Pico W is a microcontroller board based on the RP2040 chip. It has a dual - core ARM Cortex-M0+ processor running at up to 133 MHz and comes with Wi-Fi capabilities. It provides a wide range of GPIO (General - Purpose Input/Output) pins that can be used to interface with external devices like the 4x4 keypad.

C Programming for Raspberry Pi Pico W#

When programming the Raspberry Pi Pico W in C, we use the Pico SDK. The Pico SDK provides a set of libraries and tools that simplify the process of writing code for the Pico. It includes functions for configuring GPIO pins, handling interrupts, and communicating with other devices.

Usage Methods#

Hardware Connection#

To connect a 4x4 keypad to the Raspberry Pi Pico W, we need to connect the rows and columns of the keypad to the GPIO pins of the Pico. Typically, we connect the 4 rows to 4 GPIO output pins and the 4 columns to 4 GPIO input pins.

Software Implementation#

The software implementation involves the following steps:

  1. Initialization: Configure the GPIO pins for the rows as outputs and the columns as inputs.
  2. Scanning: Sequentially set each row to a low voltage level and read the state of the columns.
  3. Key Detection: If a key is pressed, the corresponding column will read a low voltage level.

Common Practices#

Debouncing#

When a key is pressed, the electrical contact may bounce, causing multiple readings of the key press. To avoid this, we can implement a debounce algorithm. One simple way is to introduce a small delay (e.g., 20 ms) after detecting a key press and then check the key state again.

Error Handling#

It's important to handle errors in case of incorrect key readings or hardware failures. For example, if a key press is detected but the corresponding row and column combination is invalid, we can ignore the reading.

Best Practices#

Modular Code#

Write modular code by separating the keypad scanning and key detection functions into separate functions. This makes the code more readable and easier to maintain.

Interrupt-Based Scanning#

Instead of continuously scanning the keypad, we can use interrupts to detect key presses. This reduces the CPU load and improves the efficiency of the system.

Code Example#

#include "pico/stdlib.h"
 
// Define the GPIO pins for rows and columns
const uint row_pins[4] = {0, 1, 2, 3};
const uint col_pins[4] = {4, 5, 6, 7};
 
// Keypad layout
const char keypad[4][4] = {
    {'1', '2', '3', 'A'},
    {'4', '5', '6', 'B'},
    {'7', '8', '9', 'C'},
    {'*', '0', '#', 'D'}
};
 
// Function to initialize the keypad
void keypad_init() {
    for (int i = 0; i < 4; i++) {
        gpio_init(row_pins[i]);
        gpio_set_dir(row_pins[i], GPIO_OUT);
        gpio_put(row_pins[i], 1);
 
        gpio_init(col_pins[i]);
        gpio_set_dir(col_pins[i], GPIO_IN);
        gpio_pull_up(col_pins[i]);
    }
}
 
// Function to scan the keypad
char keypad_scan() {
    for (int row = 0; row < 4; row++) {
        gpio_put(row_pins[row], 0);
        for (int col = 0; col < 4; col++) {
            if (gpio_get(col_pins[col]) == 0) {
                sleep_ms(20); // Debounce
                if (gpio_get(col_pins[col]) == 0) {
                    while (gpio_get(col_pins[col]) == 0); // Wait for key release
                    return keypad[row][col];
                }
            }
        }
        gpio_put(row_pins[row], 1);
    }
    return '\0';
}
 
int main() {
    stdio_init_all();
    keypad_init();
 
    while (1) {
        char key = keypad_scan();
        if (key != '\0') {
            printf("Key pressed: %c\n", key);
        }
    }
    return 0;
}

Conclusion#

Using a 4x4 external keypad with the Raspberry Pi Pico W in C provides a powerful and efficient way to add input functionality to your embedded projects. By understanding the fundamental concepts, following the usage methods, common practices, and best practices, you can create robust and reliable applications. The code example provided in this blog can serve as a starting point for your own projects.

References#

2025-10