Gammon Forum

const byte rowPins[ROWS] = { 8, 7, 6, 5 };    // connect to the row pinouts of the keypad
const byte colPins[COLS] = { 12, 11, 10, 9 }; // connect to the column pinouts of the keypad

  case K1 | K2 | K5 | K8 | K9:
     // do something
  break;

/*

Author: Nick Gammon
Date: 21 July 2023

  This version is designed to easily allow for multiple simultaneous presses.
  When keys are pressed they are registered (remembered) as forming part of the key group.
  When ALL keys are released then the keys pressed during this session are then combined
  to make the final keypress group. EG. Press 1, then 2, then 3, then release all of them
  gives the group 1/2/3, regardless of the order they are pressed or released.

  Thus, nothing happens when you press a key, it all happens when ALL keys are released.
  While at least one key is down you can add other keys, so for example 1-2-3-4 would be a
  valid combination. You would detect that in the switch statement further down by testing
  for case K1|K2|K3|K4.

  Idea based on the stenography machines, and in particular the "plover" software:

    https://github.com/openstenoproject/plover

  However all the code here is mine, it was just the ideas I used.

  Keypad library: https://github.com/nickgammon/Keypad_Matrix

  Mouse and Keyboard libraries from the Arduino distribution.


  ERROR_LED_PIN (currently A1) is the pin number of an LED you have hooked up (via a resistor in series, say 220 ohms.

  This lights for 300 ms if an unknown sequence is typed.

  For sending text to the PC, characters are spaced apart by DELAY_BETWEEN_KEYS ms,
  to give the receiver a chance to process them (currently 15 ms).


 */


#include <Keyboard.h>
#include <Keypad_Matrix.h>

const unsigned long DELAY_BETWEEN_KEYS = 15;  // milliseconds
const byte ERROR_LED_PIN = A1;

// make true to type out unknown key combinations, false otherwise
#define ECHO_UNKNOWN_COMBINATION true

// make true to flash an LED if an invalid combination is pressed
#define FLASH_ERROR_LED true

// type for storing bit patterns: make uint16_t for up to 16 keys
// and uint32_t for 17 to 32 keys.
// (Using uint16_t saves a small amount of program memory).

typedef uint16_t bitMaskType;

const byte ROWS = 4;
const byte COLS = 4;
const byte TOTAL_KEYS = ROWS * COLS;
char       keys[ROWS][COLS] = {
  { '1', '2', '3', 'A' },
  { '4', '5', '6', 'B' },
  { '7', '8', '9', 'C' },
  { '*', '0', '#', 'D' },
};

const byte rowPins[ROWS] = {  8,  7,  6, 5 }; // connect to the row pinouts of the keypad
const byte colPins[COLS] = { 12, 11, 10, 9 }; // connect to the column pinouts of the keypad

// A bit is assigned to each of the TOTAL_KEYS keys. If that key was pressed during a keydown/keyup
// session then that bit will be set in "combinedKeys".

const bitMaskType K0   = 1L <<  0;   // "0"
const bitMaskType K1   = 1L <<  1;   // "1"
const bitMaskType K2   = 1L <<  2;   // "2"
const bitMaskType K3   = 1L <<  3;   // "3"
const bitMaskType K4   = 1L <<  4;   // "4"
const bitMaskType K5   = 1L <<  5;   // "5"
const bitMaskType K6   = 1L <<  6;   // "6"
const bitMaskType K7   = 1L <<  7;   // "7"
const bitMaskType K8   = 1L <<  8;   // "8"
const bitMaskType K9   = 1L <<  9;   // "9"
const bitMaskType KA   = 1L << 10;   // "A"
const bitMaskType KB   = 1L << 11;   // "B"
const bitMaskType KC   = 1L << 12;   // "C"
const bitMaskType KD   = 1L << 13;   // "D"
const bitMaskType KAST = 1L << 14;   // "*"
const bitMaskType KHSH = 1L << 15;   // "#"

// for translating bit patterns back to key names
// these names should be the same as in the "keys" array above
// and in the same order as the bit mappings directly above

const char reverseLookup [TOTAL_KEYS] = "0123456789ABCD*#";  // same order as above bitmap

bitMaskType combinedKeys = 0;      // set a bit for each key pressed
bitMaskType keysCurrentlyDown = 0; // remember which keys are currently pressed

unsigned long ledLit;  // when we turned the error LED on

// helper macros to output strings with "F" macro around them
#define MSG(arg)                \
  do                            \
    myKeyboard.print (F (arg)); \
  while (false)

#define MSGLN(arg)                \
  do                              \
    myKeyboard.println (F (arg)); \
  while (false)

// do a newline easily
#define NEWLINE()          \
  do                       \
    myKeyboard.println (); \
  while (false)

// Create the Keypad
Keypad_Matrix kpd = Keypad_Matrix (makeKeymap (keys), rowPins, colPins, ROWS, COLS);

// class for printing to our keyboard with a delay between each key
class my_Keyboard_class : public Print
{
  public:
  virtual size_t write (uint8_t c);
}; // end of class my_Keyboard_class

size_t my_Keyboard_class::write (uint8_t character)
{
  Keyboard.write (character);
  delay (DELAY_BETWEEN_KEYS);
  return 1;
} // end of my_Keyboard_class::write

my_Keyboard_class myKeyboard;

// each of the possible key codes gets mapped to a unique bit pattern
bitMaskType mapKeycodeToBitCode (const char key)
  {
  for (byte i = 0; i < sizeof (reverseLookup); i++)
    if (key == reverseLookup [i])
      return (bitMaskType) 1 << i;
      
  return 0; // not found, shouldn't happen
  } // end of mapKeycodeToBitCode


void setup ()
{
  // initialize control over the keyboard:
  Keyboard.begin ();

#if FLASH_ERROR_LED
  // set up various pins
  pinMode (ERROR_LED_PIN, OUTPUT);
#endif // FLASH_ERROR_LED

  kpd.begin ();
  kpd.setKeyDownHandler (keyDown);
  kpd.setKeyUpHandler (keyUp);
  
} // end of setup

// Handle key combination once all keys are released

void processKeyCombination (const bitMaskType keys)
  {

  // take some action depending on what key combinations were pressed
  switch (keys)
    {

    // some example actions
    
    // 0
    case K0:
      MSGLN ("Key 0 pressed");
      break;

    // 1
    case K1:
      MSGLN ("Key 1 pressed");
      break;

   // A + 1
    case KA | K1:
      MSGLN ("Keys A and 1 pressed");
      break;

    // *
    case KAST:
      MSGLN ("Hi there!");
      break;

    // ---------------------------------------------------------------------
    // HERE FOR NO MATCH
    // ---------------------------------------------------------------------

    default:

#if FLASH_ERROR_LED    
      // light LED to indicate an error if wanted
      ledLit = millis ();
      digitalWrite (ERROR_LED_PIN, HIGH);
#endif // FLASH_ERROR_LED

#if ECHO_UNKNOWN_COMBINATION
      // echo what combination was pressed if wanted
      MSG ("Unknown key combination: ");
      for (byte i = 0; i < sizeof (reverseLookup); i++)
        if (keys & (1 << i))
          myKeyboard.print (reverseLookup [i]);
      NEWLINE ();
#endif // ECHO_UNKNOWN_COMBINATION

      break;  // end of default handler

    } // end of switching on which key

  } // end of processKeyCombination

// remember this key was pressed
void keyDown (const char which)
{

  bitMaskType bitmap  = mapKeycodeToBitCode (which);
  combinedKeys       |= bitmap;
  keysCurrentlyDown  |= bitmap;
} // end of keyDown


// do action on key-up
void keyUp (const char which)
{

  // this key isn't down any more
  keysCurrentlyDown &= ~mapKeycodeToBitCode (which);

  // do nothing if some keys still down
  if (keysCurrentlyDown)
    return;

  // all keys have been released - process the combination
  processKeyCombination (combinedKeys);

  // clear the combined keys bitmap for next time
  combinedKeys = 0;

} // end of keyUp


void loop ()
{
  kpd.scan ();

#if FLASH_ERROR_LED
  // turn LED off after 300 ms
  if (ledLit)
    {
    if (millis () - ledLit >= 300)
      {
      digitalWrite (ERROR_LED_PIN, LOW);
      ledLit = 0;
      }
    } // end of led being lit
#endif // FLASH_ERROR_LED

  // do other stuff here
  
} // end of loop