Pi with a keypad matrix

 Pi with a keypad matrix

Today we will see how to interfacing the Raspberry Pi with a matrix keypad usingRpi-hw library.

Matrix keypad interfacing – Video

The library provides the class keypad::matrix↱, defined in “rpi-hw/keypad/matrix.hpp”↱, with which it is possible to manage keypads of any size.

Its constructor method takes two ordered lists containing the GPIO pins used by the device:

  1. keypad::matrix(
  2. { COL0, COL1, COL2, … }, // Column pins
  3. { ROW0, ROW1, ROW2, … } // Rows pins
  4. )

Let’s take an example. The following image shows how to connect the Raspberry Piwith a standard 12-key keypad:

Matrix keypad interfacing - Circuit

Matrix keypad interfacing – Circuit

We used the following GPIO pins: 21, 10, and 4 for columns; 22, 14, 15, and 17 for rows. This is the internal circuit diagram of the keypad (where pin names refer to the keypad connector):

Matrix keypad interfacing - Internal circuit

Matrix keypad interfacing – Internal circuit

The instance of keypad::matrix will check periodically which buttons are pressed, looking for connection between rows and columns. The control algorithm can be summarized as follows:

  1. Set all GPIOs of rows as input.
  2. Set all GPIOs of columns as output (low).
  3. Set a column pin to high.
  4. If one of rows reads a high value, then the button between those column and row is pressed.
  5. Set the previous column to low.
  6. Repeat from line #3 with another column, until there are no more.
Matrix keypad interfacing - Possible connections

Matrix keypad interfacing – Possible connections

And finally, here is a sample code that shows you how to read the state of some buttons in the 12-key keypad:

  1. #include <iostream>
  3. // Include Rpi-hw headers
  4. #include <rpi-hw.hpp>
  5. #include <rpi-hw/time.hpp>
  6. #include <rpi-hw/keypad/matrix.hpp>
  8. // Use Rpi-hw namespace
  9. using namespace rpihw;
  11. int
  12. main( int argc, char *args[] ) {
  14. // Matrix keypad controller
  15. keypad::matrix dev( { 21, 10, 4 }, { 22, 14, 15, 17 } );
  17. // Main loop
  18. for ( ;; ) {
  20. // Check some keys state
  21. if ( dev.pressed(0) )
  22. std::cout << “You have pressed button 0!\n”;
  24. if ( dev.released(2) )
  25. std::cout << “You have released button 2!\n”;
  27. if ( dev.pressed(1) && dev.pressed(4) )
  28. std::cout << “You have pressed buttons 1 and 4!\n”;
  30. // Wait some time
  31. time::msleep( 100 );
  32. }
  34. return 0;
  35. }

To compile it (or any other programs using the library) use the command:

  1. g++ `pkg-config –libs –cflags rpi-hw` <SOURCE> -o <TARGET>

A more realistic example that uses an Event Listener to handle a 16-keys keypad is the following:

  1. #include <iostream>
  2. #include <memory>
  4. // Include Rpi-hw headers
  5. #include <rpi-hw.hpp>
  6. #include <rpi-hw/time.hpp>
  7. #include <rpi-hw/keypad/matrix.hpp>
  9. // Use the Rpi-hw namespace
  10. using namespace rpihw;
  12. /*
  13. (14, 15, 18, 23) colums = 4
  14. ||||
  15. ———————-
  16. | (1) (2) (3) (A) |
  17. | |
  18. | (4) (5) (6) (B) |
  19. | |
  20. | (7) (8) (9) (C) |
  21. | |
  22. | (*) (0) (#) (D) |
  23. ———————-
  24. ||||
  25. (24, 25, 8, 7) rows = 4
  26. */
  28. /** The class of my application **/
  29. class MyApp {
  31. public:
  33. // Define the keymap
  34. std::vector< uint8_t > keymap = {
  36. ’1′, ’2′, ’3′, ‘A’,
  37. ’4′, ’5′, ’6′, ‘B’,
  38. ’7′, ’8′, ’9′, ‘C’,
  39. ‘*’, ’0′, ‘#’, ‘D’
  40. };
  42. /** Constructor method **/
  43. MyApp() : m_keypad( new keypad::matrix( { 14, 15, 18, 23 }, { 24, 25, 8, 7 }, keymap ) ) {
  45. keypad::T_EventListener listener = std::bind( &MyApp::eventListener, this, std::placeholders::_1 );
  47. // Add the keypad event listener
  48. m_keypad->addEventListener( listener );
  49. }
  51. /** Destructor method **/
  52. ~MyApp() {}
  54. /** A simple keypad event listener **/
  55. void eventListener( keypad::base &dev ) {
  57. const std::vector< uint8_t > &keystate = dev.keyState();
  59. for ( uint8_t c : keystate )
  60. std::cout << (char) c << std::flush;
  61. }
  63. /** Main loop **/
  64. void run() {
  66. for ( ;; ) {
  68. /* … */
  69. }
  70. }
  72. private:
  74. //! The keypad instance.
  75. std::unique_ptr< keypad::matrix > m_keypad;
  76. };
  79. int
  80. main( int argc, char *args[] ) {
  82. MyApp app;
  84. app.run();
  86. return 0;
  87. }

In this manner the keypad instance will call the method MyApp::eventListener to handle the input data.

You can find more information on the reference manual and on the wiki.

That’s all! Feel free to comment my work!

[Updated on 2013-10-22]

Did you find this article helpful?

0 comments

Add a new comment

 

 

 

Please insert the result of the arithmetical operation from the following image:

Please insert the result of the arithmetical operation from this image. = 

I2C Bus, Keypad, Python, Raspberry Pi , ,