{"id":52277,"date":"2026-11-01T10:50:50","date_gmt":"2026-11-01T10:50:50","guid":{"rendered":"http:\/\/siratek.net\/index.php\/tutorials\/keypad-4x4\/"},"modified":"2026-11-01T10:50:50","modified_gmt":"2026-11-01T10:50:50","slug":"keypad-4x4","status":"publish","type":"siratek_tutorial","link":"https:\/\/siratek.net\/index.php\/tutorials\/keypad-4x4\/","title":{"rendered":"Reading a 4×4 Matrix Keypad"},"content":{"rendered":"

<\/p>\n

What it does<\/h2>\n

Sixteen keys on a thin adhesive-backed membrane: digits 0 to 9, *<\/code>, #<\/code>, and A<\/code> to D<\/code>. It is how a project asks for a PIN, a temperature, a menu choice, anything that needs more than a button or two.<\/p>\n

Sixteen buttons would ordinarily need sixteen pins. This needs eight<\/strong>, because the keys are wired as a grid: four rows crossing four columns, with a switch at each crossing. That matrix arrangement is the thing worth understanding, and it is the same idea that lets a computer keyboard put a hundred keys on far fewer wires.<\/p>\n

Before you begin<\/h2>\n

Required parts and tools<\/h3>\n
    \n
  • An Arduino Uno or compatible board.<\/li>\n
  • One 4\u00d74 membrane keypad. This is Siratek product 5796.<\/li>\n
  • Eight female-to-male jumper wires, or a breadboard.<\/li>\n<\/ul>\n

    What you are actually holding<\/h3>\n

    There are no electronics in it at all<\/strong>. No chip, no resistors, nothing. It is sixteen momentary switches printed on plastic film, with eight tracks running down a ribbon tail to a single row of eight male pins.<\/p>\n

    That matters because everything clever has to happen in your sketch, and because there is nothing in the keypad that can be at fault. If a key does not work, it is the connection, the pin assignment or the film itself.<\/p>\n

    Which pin is which<\/h3>\n

    Eight pins in one row. With the keypad face up and the tail toward you, they are conventionally rows 1 to 4, then columns 1 to 4<\/strong>, left to right.<\/p>\n

    Conventionally. Some keypads reverse it, and there is no silkscreen to check.<\/p>\n

    Fortunately the cost of getting it wrong is zero: nothing can be damaged, because these are just switches. If the keys come out scrambled, the fix is to swap the two arrays in your sketch. The test sketch below is designed to make that obvious in a few seconds.<\/p>\n

    How the matrix is read<\/h3>\n

    The library does this for you, but it is worth knowing, because it explains the pull-up requirement and a limitation you will eventually meet.<\/p>\n

    One column at a time is driven low while the others are left high. Each row is then read: a row that reads low must be connected to the driven column through a closed switch, which identifies exactly one key. Repeat for the four columns and you have scanned all sixteen in four steps, hundreds of times a second.<\/p>\n

    The rows need pull-up resistors so they sit high when no key is pressed, otherwise they float and read nonsense. The library uses the ATmega328P\u2019s internal pull-ups, which is why no external resistors appear in the parts list. This is the same INPUT_PULLUP<\/code> idea from Read a Push Button<\/em>, applied four times.<\/p>\n

    Two keys at once<\/h3>\n

    Hold two keys in the same row or column and the scan still works. Hold three that form a rectangle on the grid and the matrix cannot tell which three of the four corners are pressed, so it may report a key you are not touching. This is called ghosting.<\/p>\n

    Proper keyboards fit a diode at every key to prevent it. This keypad has none, so treat it as one key at a time<\/strong>. For a PIN pad or a menu that is no limitation at all.<\/p>\n

    Pin reference<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n
    Keypad pin<\/th>\nConnect to<\/th>\nPurpose<\/th>\n<\/tr>\n<\/thead>\n
    1<\/td>\nUno D9<\/code><\/td>\nRow 1<\/td>\n<\/tr>\n
    2<\/td>\nUno D8<\/code><\/td>\nRow 2<\/td>\n<\/tr>\n
    3<\/td>\nUno D7<\/code><\/td>\nRow 3<\/td>\n<\/tr>\n
    4<\/td>\nUno D6<\/code><\/td>\nRow 4<\/td>\n<\/tr>\n
    5<\/td>\nUno D5<\/code><\/td>\nColumn 1<\/td>\n<\/tr>\n
    6<\/td>\nUno D4<\/code><\/td>\nColumn 2<\/td>\n<\/tr>\n
    7<\/td>\nUno D3<\/code><\/td>\nColumn 3<\/td>\n<\/tr>\n
    8<\/td>\nUno D2<\/code><\/td>\nColumn 4<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

    No power and no ground. A passive grid of switches needs neither.<\/p>\n

    \"A
    Sixteen keys on eight pins. There is nothing inside but switches.<\/figcaption><\/figure>\n

    Wiring steps<\/h2>\n
      \n
    1. Unplug the USB cable.<\/li>\n
    2. Plug the eight-pin tail into a breadboard, or use female-to-male leads directly.<\/li>\n
    3. Working left to right with the keypad face up, connect its pins to D9<\/code>, D8<\/code>, D7<\/code>, D6<\/code>, D5<\/code>, D4<\/code>, D3<\/code>, D2<\/code> in that order.<\/li>\n
    4. Plug the USB cable back in.<\/li>\n<\/ol>\n

      Descending pin numbers look odd and keep the ribbon flat instead of crossed. Any eight digital pins work; only the sketch needs to agree with the wiring.<\/p>\n

      Software and libraries<\/h2>\n

      Install Keypad<\/strong> by Mark Stanley and Alexander Brevig through Library Manager. It handles the scanning, the pull-ups and the debouncing.<\/p>\n

      Writing the scan by hand is a good exercise but a poor starting point, because a bug in it looks exactly like a wiring fault.<\/p>\n

      Minimal working example<\/h2>\n
      \/\/ Siratek: reading a 4x4 membrane keypad.\n\n#include <Keypad.h>\n\nconst byte ROWS = 4;\nconst byte COLS = 4;\n\nchar keys[ROWS][COLS] = {\n  {'1', '2', '3', 'A'},\n  {'4', '5', '6', 'B'},\n  {'7', '8', '9', 'C'},\n  {'*', '0', '#', 'D'}\n};\n\nbyte rowPins[ROWS] = {9, 8, 7, 6};\nbyte colPins[COLS] = {5, 4, 3, 2};\n\nKeypad pad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);\n\nvoid setup() {\n  Serial.begin(9600);\n  Serial.println(\"Siratek: press keys, starting with 1.\");\n}\n\nvoid loop() {\n  char key = pad.getKey();\n\n  if (key) {\n    Serial.print(\"key: \");\n    Serial.println(key);\n  }\n}<\/code><\/pre>\n
      Press 1<\/code> first. If 1<\/code> appears, the wiring is right and you can stop thinking about it.<\/p>\n
      If something else appears, read what it was:<\/p>\n
        \n
      • A key from the right row but the wrong column:<\/strong> colPins<\/code> is reversed. Swap it end for end.<\/li>\n
      • A key from the right column but the wrong row:<\/strong> rowPins<\/code> is reversed.<\/li>\n
      • The transpose, so pressing 1<\/code> gives 1<\/code> but 2<\/code> gives 4<\/code>:<\/strong> the keypad\u2019s eight pins are columns-then-rows rather than rows-then-columns. Swap the two arrays.<\/li>\n<\/ul>\n
        getKey()<\/code> returns 0<\/code> when nothing is pressed, which is why the if (key)<\/code> guard is there. It also only reports a key once per press, not continuously, so no edge detection is needed.<\/p>\n
        Collecting a number<\/h3>\n
        A single character is rarely what you want. Gathering digits until #<\/code> is the standard pattern.<\/p>\n
        \/\/ Siratek: entering a number, with * to clear and # to accept.\n\n#include <Keypad.h>\n\nconst byte ROWS = 4;\nconst byte COLS = 4;\n\nchar keys[ROWS][COLS] = {\n  {'1', '2', '3', 'A'},\n  {'4', '5', '6', 'B'},\n  {'7', '8', '9', 'C'},\n  {'*', '0', '#', 'D'}\n};\n\nbyte rowPins[ROWS] = {9, 8, 7, 6};\nbyte colPins[COLS] = {5, 4, 3, 2};\n\nKeypad pad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);\n\nchar entry[9];\nbyte length = 0;\n\nvoid setup() {\n  Serial.begin(9600);\n  Serial.println(\"Siratek: type digits, # to accept, * to clear.\");\n}\n\nvoid loop() {\n  char key = pad.getKey();\n  if (!key) {\n    return;\n  }\n\n  if (key >= '0' && key <= '9') {\n    if (length < sizeof(entry) - 1) {\n      entry[length++] = key;\n      entry[length] = '\\0';\n      Serial.println(entry);\n    }\n  } else if (key == '*') {\n    length = 0;\n    entry[0] = '\\0';\n    Serial.println(\"cleared\");\n  } else if (key == '#') {\n    Serial.print(\"entered: \");\n    Serial.println(atoi(entry));\n    length = 0;\n    entry[0] = '\\0';\n  }\n}<\/code><\/pre>\n
        The length check before writing into entry<\/code> is not decoration. Without it, holding a key down long enough writes past the end of the array, which on an Arduino corrupts whatever variable happens to live next in memory. The symptom is a sketch that works for a minute and then behaves strangely, and it is among the hardest faults to find. Always bound the index.<\/p>\n
        On storing a PIN<\/h3>\n
        If you go on to build a door lock, resist comparing against a PIN typed into the sketch as plain text. Anyone who can read the source, or dump the flash, can read the PIN.<\/p>\n
        It is beyond this page to do properly, but the shape of the answer is: store a hash of the PIN rather than the PIN, compare hashes, and accept that a hobby microcontroller is not a security device. A keypad on a drawer is fine. A keypad as the only thing between someone and your house is not.<\/p>\n
        Expected result<\/h2>\n
        One line per key press, matching the key you pressed, with no repeats and no missed presses.<\/p>\n
        Membrane keys need a deliberate press. A light touch near the edge of a key often does not close the contact, and that is the membrane rather than your code.<\/p>\n
        Troubleshooting<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
        Symptom<\/th>\nLikely cause<\/th>\nCheck or fix<\/th>\n<\/tr>\n<\/thead>\n
        Nothing at all<\/td>\nPin order wrong in both arrays<\/td>\nCheck the wiring against the sketch<\/td>\n<\/tr>\n
        Wrong column reported<\/td>\ncolPins<\/code> reversed<\/td>\nSwap it end for end<\/td>\n<\/tr>\n
        Wrong row reported<\/td>\nrowPins<\/code> reversed<\/td>\nSame<\/td>\n<\/tr>\n
        Keys transposed<\/td>\nKeypad is columns-then-rows<\/td>\nSwap the two arrays<\/td>\n<\/tr>\n
        One row dead<\/td>\nA lead not seated<\/td>\nReseat; the tail pins are fragile<\/td>\n<\/tr>\n
        One key dead, others fine<\/td>\nMembrane worn or creased<\/td>\nNothing to repair; replace the keypad<\/td>\n<\/tr>\n
        Repeated characters<\/td>\nNot using getKey()<\/code><\/td>\ngetKey()<\/code> already reports once per press<\/td>\n<\/tr>\n
        Keys need a hard press<\/td>\nNormal for membrane<\/td>\nPress squarely in the middle<\/td>\n<\/tr>\n
        Odd key reported with several held<\/td>\nGhosting, no diodes<\/td>\nUse one key at a time<\/td>\n<\/tr>\n
        Sketch misbehaves after long input<\/td>\nWriting past the array<\/td>\nBound the index<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
        Next steps<\/h2>\n
          \n
        • Easier first:<\/strong> Making a Button Behave<\/em>, for the debouncing this library hides.<\/li>\n
        • Related products:<\/strong> a 16\u00d72 LCD to show what is being typed, and a relay or servo to act on it.<\/li>\n
        • Next project:<\/strong> an RFID door lock with a keypad as the fallback, built on a drawer rather than a front door.<\/li>\n<\/ul>\n
          Sources and attribution<\/h2>\n
          All text, wiring guidance and code in this tutorial are original Siratek work.<\/p>\n
            \n
          • The sixteen-key layout and the eight-pin single-row tail were read from the Siratek product photographs for item 5796.<\/li>\n
          • Keypad library documentation for the calls used.<\/li>\n<\/ul>\n
            Row and column pin order is conventional rather than guaranteed and carries no risk of damage, so this tutorial gives a diagnostic procedure instead of asserting one. No third-party tutorial text, diagrams, photographs or code has been reproduced here.<\/p>\n
            <\/p>\n<\/body>","protected":false},"excerpt":{"rendered":"
            Sixteen keys on a thin adhesive-backed membrane: digits 0 to 9, *, #, and A to D. It is how a project asks for a PIN, a temperature, a menu choice, anything that needs more than a button or two.<\/p>\n","protected":false},"featured_media":0,"template":"","siratek_tutorial_level":[],"class_list":["post-52277","siratek_tutorial","type-siratek_tutorial","status-publish","hentry"],"yoast_head":"\nReading a 4x4 Matrix Keypad - siratek<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"http:\/\/siratek.net\/index.php\/tutorials\/keypad-4x4\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Reading a 4x4 Matrix Keypad - siratek\" \/>\n<meta property=\"og:description\" content=\"Sixteen keys on a thin adhesive-backed membrane: digits 0 to 9, *, #, and A to D. It is how a project asks for a PIN, a temperature, a menu choice, anything that needs more than a button or two.\" \/>\n<meta property=\"og:url\" content=\"http:\/\/siratek.net\/index.php\/tutorials\/keypad-4x4\/\" \/>\n<meta property=\"og:site_name\" content=\"siratek\" \/>\n<meta property=\"og:image\" content=\"http:\/\/siratek.net\/wp-content\/uploads\/2026\/11\/keypad-4x4-wiring.svg\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data1\" content=\"7 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"http:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/keypad-4x4\\\/\",\"url\":\"http:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/keypad-4x4\\\/\",\"name\":\"Reading a 4x4 Matrix Keypad - siratek\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/siratek.net\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"http:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/keypad-4x4\\\/#primaryimage\"},\"image\":{\"@id\":\"http:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/keypad-4x4\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/siratek.net\\\/wp-content\\\/uploads\\\/2026\\\/11\\\/keypad-4x4-wiring.svg\",\"datePublished\":\"2026-11-01T10:50:50+00:00\",\"breadcrumb\":{\"@id\":\"http:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/keypad-4x4\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"http:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/keypad-4x4\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"http:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/keypad-4x4\\\/#primaryimage\",\"url\":\"https:\\\/\\\/siratek.net\\\/wp-content\\\/uploads\\\/2026\\\/11\\\/keypad-4x4-wiring.svg\",\"contentUrl\":\"https:\\\/\\\/siratek.net\\\/wp-content\\\/uploads\\\/2026\\\/11\\\/keypad-4x4-wiring.svg\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"http:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/keypad-4x4\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/siratek.net\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Tutorials\",\"item\":\"https:\\\/\\\/siratek.net\\\/index.php\\\/tutorials\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Reading a 4×4 Matrix Keypad\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/siratek.net\\\/#website\",\"url\":\"https:\\\/\\\/siratek.net\\\/\",\"name\":\"siratek\",\"description\":\"Your Best Electronic Retail Shop\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/siratek.net\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Reading a 4x4 Matrix Keypad - siratek","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"http:\/\/siratek.net\/index.php\/tutorials\/keypad-4x4\/","og_locale":"en_US","og_type":"article","og_title":"Reading a 4x4 Matrix Keypad - siratek","og_description":"Sixteen keys on a thin adhesive-backed membrane: digits 0 to 9, *, #, and A to D. It is how a project asks for a PIN, a temperature, a menu choice, anything that needs more than a button or two.","og_url":"http:\/\/siratek.net\/index.php\/tutorials\/keypad-4x4\/","og_site_name":"siratek","og_image":[{"url":"http:\/\/siratek.net\/wp-content\/uploads\/2026\/11\/keypad-4x4-wiring.svg","type":"","width":"","height":""}],"twitter_card":"summary_large_image","twitter_misc":{"Est. reading time":"7 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"http:\/\/siratek.net\/index.php\/tutorials\/keypad-4x4\/","url":"http:\/\/siratek.net\/index.php\/tutorials\/keypad-4x4\/","name":"Reading a 4x4 Matrix Keypad - siratek","isPartOf":{"@id":"https:\/\/siratek.net\/#website"},"primaryImageOfPage":{"@id":"http:\/\/siratek.net\/index.php\/tutorials\/keypad-4x4\/#primaryimage"},"image":{"@id":"http:\/\/siratek.net\/index.php\/tutorials\/keypad-4x4\/#primaryimage"},"thumbnailUrl":"http:\/\/siratek.net\/wp-content\/uploads\/2026\/11\/keypad-4x4-wiring.svg","datePublished":"2026-11-01T10:50:50+00:00","breadcrumb":{"@id":"http:\/\/siratek.net\/index.php\/tutorials\/keypad-4x4\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["http:\/\/siratek.net\/index.php\/tutorials\/keypad-4x4\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"http:\/\/siratek.net\/index.php\/tutorials\/keypad-4x4\/#primaryimage","url":"https:\/\/siratek.net\/wp-content\/uploads\/2026\/11\/keypad-4x4-wiring.svg","contentUrl":"https:\/\/siratek.net\/wp-content\/uploads\/2026\/11\/keypad-4x4-wiring.svg"},{"@type":"BreadcrumbList","@id":"http:\/\/siratek.net\/index.php\/tutorials\/keypad-4x4\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/siratek.net\/"},{"@type":"ListItem","position":2,"name":"Tutorials","item":"https:\/\/siratek.net\/index.php\/tutorials\/"},{"@type":"ListItem","position":3,"name":"Reading a 4×4 Matrix Keypad"}]},{"@type":"WebSite","@id":"https:\/\/siratek.net\/#website","url":"https:\/\/siratek.net\/","name":"siratek","description":"Your Best Electronic Retail Shop","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/siratek.net\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"}]}},"jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/siratek.net\/index.php\/wp-json\/wp\/v2\/siratek_tutorial\/52277","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/siratek.net\/index.php\/wp-json\/wp\/v2\/siratek_tutorial"}],"about":[{"href":"https:\/\/siratek.net\/index.php\/wp-json\/wp\/v2\/types\/siratek_tutorial"}],"version-history":[{"count":0,"href":"https:\/\/siratek.net\/index.php\/wp-json\/wp\/v2\/siratek_tutorial\/52277\/revisions"}],"wp:attachment":[{"href":"https:\/\/siratek.net\/index.php\/wp-json\/wp\/v2\/media?parent=52277"}],"wp:term":[{"taxonomy":"siratek_tutorial_level","embeddable":true,"href":"https:\/\/siratek.net\/index.php\/wp-json\/wp\/v2\/siratek_tutorial_level?post=52277"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}