basicKeypadScan.cpp

// ARDUINO MEGA, NOT UNO!

const byte ROWS = 4; // four rows
const byte COLS = 4; // four columns
byte c = 0;
char curChar = 0;

bool validISR = false;
bool buttonReleased = false;

unsigned long lastRegisteredPress, durationBetweenPress;

#define _IO_Mem_reg(address) *((volatile byte*) (address))

#define DataDirReg_D _IO_Mem_reg(0x2A)
#define DataDirReg_H _IO_Mem_reg(0x101)
#define DataDirReg_J _IO_Mem_reg(0x104)

// Pins 18-21
#define PORT_D_REG _IO_Mem_reg(0x2B)
// PORT is for outputs. PIN is for reading inputs!
#define PIN_D_REG _IO_Mem_reg(0x29)
// Pins 16-17
#define PORT_H_REG _IO_Mem_reg(0x102)
#define PIN_H_REG _IO_Mem_reg(0x100)
// Pins 14-15
#define PORT_J_REG _IO_Mem_reg(0x105)
#define PIN_J_REG _IO_Mem_reg(0x103)

// The compiler actually doesn't allow these addresses. Interesting
// Must use the predefined macros
// #define Extern_Inp_Ctrl_Reg(0x69)
// #define Extern_Inp_Mask_Reg(0x3D)

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

/*
    MEGA2560 Interrupt pins:  
      18–21
*/

void setup() {

  /*
    Since columns are interrupts, set them to be INPUT_PULLUP
  */
  /*
    We want to set pins 18–21 to INPUT_PULLUP;
    INPUT_PULLUP is 0x2, and this is because the DDR should
    be set to 0, and the PORT should be set to 1

    X &= ~0x0F <=> X & 0xF0 = left four bits are preserved, right
    four bits are set to 0
  */
  DataDirReg_D &= ~0x0F;
  // Set PD0-3 as 1
  PORT_D_REG |= 0x0F;

  // Set DDR[H/J] bits 0-1 to 1
  DataDirReg_H |= 0x03;
  DataDirReg_J |= 0x03;

  // Set ports to 0 for Output LOW
  PORT_H_REG &= ~0x03;
  PORT_J_REG &= ~0x03;

  // // We want rising edge, so both ISC bits should be 1 for each interrupt pin.
  // // Since we're using INT0-4, set all bits to 1
  // EICRA = 0xFF;
  /*
    Wrong! The colums are PULLUP, so they are default HIGH. If there is a key
    press, they switch from HIGH to LOW, which is FALLING edge, not RISING!
  */
  EICRA = 0xAA; // 0b10101010 -> Falling edge for INT0-INT3

  // We only want to enable INT0-4, not all 8
  EIMSK |= 0x0F; 

  lastRegisteredPress = micros();

  Serial.begin(9600);
}

ISR(INT0_vect) {
  // Serial.println("Something happened!" + (String)c + (String)(3-c));
  /*
    Set ports to 1 for Output HIGH. Now, the pressed column is
    also high, and will only be LOW when the row physically connected
    to the column (i.e. where the press/contact is) is driven low
    (i.e. we should still see HIGH if we drive a row not connected
    to the column to LOW)
  */
  lastRegisteredPress = micros();
  c = 0;
  curChar = 0;
  PORT_H_REG |= 0x03;
  PORT_J_REG |= 0x03;

  // PORT_J_REG &= ~(1 << 1); // Same thing
  PORT_J_REG &= ~0x2;
  /*
    This was the trickiest part. The logic, without this for
    loop, is correct. However, without the for loop, the CPU
    actually runs faster than the pin has time to discharge.

    The pin seems to discharge at approximately the time it takes
    to get to the next row, so it thinks that the preceeding row
    was pressed!

    This for loop is a busy-wait, but necessary for correct row detection

    The reason this works is because PORT_J_REG is a volatile variable.
    If any variable that is not marked volatile is used, this loop will
    be optimized out by the compiler because the state is determined
    and unchanged
  */
  for (int i = 0; i < 1000; i++) { PORT_J_REG = PORT_J_REG; }
  if ( !((PIN_D_REG >> c) & 0x1) ) {
    // 3-c because I want to keep the array mapped with how the
    // physical keypad looks; changing the mapping thru software
    curChar = keyMap[0][3-c];
    PORT_H_REG &= ~0x03;
    PORT_J_REG &= ~0x03;
    // 2. Clear any pending interrupt flags caused by dropping the rows to LOW!
    // Writing 1 to INTF0, INTF1, INTF2, and INTF3 clears them.
    // Also, this MUST happen right after driving the lines low; doing it after
    //  the very next line of code didn't make it work
    EIFR = 0x0F;
    validISR = true;
    return;
  }

  PORT_J_REG &= ~0x1;
  for (int i = 0; i < 1000; i++) { PORT_J_REG = PORT_J_REG; }
  if ( !((PIN_D_REG >> c) & 0x1) ) {
    curChar = keyMap[1][3-c];
    PORT_H_REG &= ~0x03;
    PORT_J_REG &= ~0x03;
    EIFR = 0x0F;
    validISR = true;
    return;
  }

  PORT_H_REG &= ~0x2;
  for (int i = 0; i < 1000; i++) { PORT_J_REG = PORT_J_REG; }
  if ( !((PIN_D_REG >> c) & 0x1) ) {
    curChar = keyMap[2][3-c];
    PORT_H_REG &= ~0x03;
    PORT_J_REG &= ~0x03;
    EIFR = 0x0F;
    validISR = true;
    return;
  }

  PORT_H_REG &= ~0x1;
  for (int i = 0; i < 1000; i++) { PORT_J_REG = PORT_J_REG; }
  if ( !((PIN_D_REG >> c) & 0x1) ) {
    curChar = keyMap[3][3-c];
    PORT_H_REG &= ~0x03;
    PORT_J_REG &= ~0x03;
    EIFR = 0x0F;
    validISR = true;
    return;
  }
  // If we're here, somehow we didn't find a valid key. Don't give one
  curChar = 0;
}

ISR(INT1_vect) {
  // Serial.println("Something happened!" + (String)c + (String)(3-c));
  lastRegisteredPress = micros();
  c = 1;
  curChar = 0;
  PORT_H_REG |= 0x03;
  PORT_J_REG |= 0x03;

  PORT_J_REG &= ~0x2;
  for (int i = 0; i < 1000; i++) { PORT_J_REG = PORT_J_REG; }
  if ( !((PIN_D_REG >> c) & 0x1) ) {
    curChar = keyMap[0][3-c];
    PORT_H_REG &= ~0x03;
    PORT_J_REG &= ~0x03;
    EIFR = 0x0F;
    validISR = true;
    return;
  }
  
  PORT_J_REG &= ~0x1;
  for (int i = 0; i < 1000; i++) { PORT_J_REG = PORT_J_REG; }
  if ( !((PIN_D_REG >> c) & 0x1) ) {
    curChar = keyMap[1][3-c];
    PORT_H_REG &= ~0x03;
    PORT_J_REG &= ~0x03;
    EIFR = 0x0F;
    validISR = true;
    return;
  }

  PORT_H_REG &= ~0x2;
  for (int i = 0; i < 1000; i++) { PORT_J_REG = PORT_J_REG; }
  if ( !((PIN_D_REG >> c) & 0x1) ) {
    curChar = keyMap[2][3-c];
    PORT_H_REG &= ~0x03;
    PORT_J_REG &= ~0x03;
    EIFR = 0x0F;
    validISR = true;
    return;
  }

  PORT_H_REG &= ~0x1;
  for (int i = 0; i < 1000; i++) { PORT_J_REG = PORT_J_REG; }
  if ( !((PIN_D_REG >> c) & 0x1) ) {
    curChar = keyMap[3][3-c];
    PORT_H_REG &= ~0x03;
    PORT_J_REG &= ~0x03;
    EIFR = 0x0F;
    validISR = true;
    return;
  }
  curChar = 0;
}

ISR(INT2_vect) {
  // Serial.println("Something happened!" + (String)c + (String)(3-c));
  lastRegisteredPress = micros();
  c = 2;
  curChar = 0;
  PORT_H_REG |= 0x03;
  PORT_J_REG |= 0x03;

  PORT_J_REG &= ~0x2;
  for (int i = 0; i < 1000; i++) { PORT_J_REG = PORT_J_REG; }
  if ( !((PIN_D_REG >> c) & 0x1) ) {
    curChar = keyMap[0][3-c];
    PORT_H_REG &= ~0x03;
    PORT_J_REG &= ~0x03;
    EIFR = 0x0F;
    validISR = true;
    return;
  }
  
  PORT_J_REG &= ~0x1;
  for (int i = 0; i < 1000; i++) { PORT_J_REG = PORT_J_REG; }
  if ( !((PIN_D_REG >> c) & 0x1) ) {
    curChar = keyMap[1][3-c];
    PORT_H_REG &= ~0x03;
    PORT_J_REG &= ~0x03;
    EIFR = 0x0F;
    validISR = true;
    return;
  }

  PORT_H_REG &= ~0x2;
  for (int i = 0; i < 1000; i++) { PORT_J_REG = PORT_J_REG; }
  if ( !((PIN_D_REG >> c) & 0x1) ) {
    curChar = keyMap[2][3-c];
    PORT_H_REG &= ~0x03;
    PORT_J_REG &= ~0x03;
    EIFR = 0x0F;
    validISR = true;
    return;
  }

  PORT_H_REG &= ~0x1;
  for (int i = 0; i < 1000; i++) { PORT_J_REG = PORT_J_REG; }
  if ( !((PIN_D_REG >> c) & 0x1) ) {
    curChar = keyMap[3][3-c];
    PORT_H_REG &= ~0x03;
    PORT_J_REG &= ~0x03;
    EIFR = 0x0F;
    validISR = true;
    return;
  }
  curChar = 0;
}

ISR(INT3_vect) {
  // Serial.println("Something happened!" + (String)c + (String)(3-c));
  lastRegisteredPress = micros();
  c = 3;
  curChar = 0;
  PORT_H_REG |= 0x03;
  PORT_J_REG |= 0x03;

  PORT_J_REG &= ~0x2;
  for (int i = 0; i < 1000; i++) { PORT_J_REG = PORT_J_REG; }
  if ( !((PIN_D_REG >> c) & 0x1) ) {
    curChar = keyMap[0][3-c];
    PORT_H_REG &= ~0x03;
    PORT_J_REG &= ~0x03;
    EIFR = 0x0F;
    validISR = true;
    return;
  }
  
  PORT_J_REG &= ~0x1;
  for (int i = 0; i < 1000; i++) { PORT_J_REG = PORT_J_REG; }
  if ( !((PIN_D_REG >> c) & 0x1) ) {
    curChar = keyMap[1][3-c];
    PORT_H_REG &= ~0x03;
    PORT_J_REG &= ~0x03;
    EIFR = 0x0F;
    validISR = true;
    return;
  }

  PORT_H_REG &= ~0x2;
  for (int i = 0; i < 1000; i++) { PORT_J_REG = PORT_J_REG; }
  if ( !((PIN_D_REG >> c) & 0x1) ) {
    curChar = keyMap[2][3-c];
    PORT_H_REG &= ~0x03;
    PORT_J_REG &= ~0x03;
    EIFR = 0x0F;
    validISR = true;
    return;
  }

  PORT_H_REG &= ~0x1;
  for (int i = 0; i < 1000; i++) { PORT_J_REG = PORT_J_REG; }
  if ( !((PIN_D_REG >> c) & 0x1) ) {
    curChar = keyMap[3][3-c];
    PORT_H_REG &= ~0x03;
    PORT_J_REG &= ~0x03;
    EIFR = 0x0F;
    validISR = true;
    return;
  }
}

void loop() {
  // prevChar = curChar;
  // curChar = listenForKey();
  // If the printed character changed OR there was a release of the key
  
  if (validISR && buttonReleased && curChar) {
    cli();
    durationBetweenPress = micros()-lastRegisteredPress;
    sei();

    if (durationBetweenPress > 50) {
      // Serial.println("Duration: " + (String)durationBetweenPress);
      Serial.println(curChar);
    }
    
    validISR = buttonReleased = false;
  } else {
    buttonReleased = true;
  }
}