KeyscanSecurity.cpp

// ARDUINO MEGA, NOT UNO!

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

bool keyPressDetected = false;

unsigned long alarmCurWaitTime, alarmLastSentTime;

unsigned long keyStartHoldTime, keyCurHoldTime;
const short armedDetectionTime_ms = 2000;

bool armed = false;
bool alarm = false;

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

// B is for the onboard LED
#define DataDirReg_B _IO_Mem_reg(0x24)
#define DataDirReg_D _IO_Mem_reg(0x2A)
#define DataDirReg_H _IO_Mem_reg(0x101)
#define DataDirReg_J _IO_Mem_reg(0x104)

#define PORT_B_REG _IO_Mem_reg(0x25)
// 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'}
};

char silentAlarmCode[] = {'*','8','6','A'};
byte alarmCodeCounter = 0;

/*
    MEGA2560 Interrupt pins:  
      18–21
*/

void setup() {

  // DataDirReg_B |= (1 << 7); // Same thing
  DataDirReg_B |= 0x80;
  // Default LED OFF
  PORT_B_REG &= ~0x80;

  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;

  EICRA = 0xAA; // 0b10101010 -> Falling edge for INT0-INT3

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


  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)
  */
  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;
    keyPressDetected = 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;
    keyPressDetected = 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;
    keyPressDetected = 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;
    keyPressDetected = 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));
  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;
    keyPressDetected = 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;
    keyPressDetected = 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;
    keyPressDetected = 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;
    keyPressDetected = true;
    return;
  }
  curChar = 0;
}

ISR(INT2_vect) {
  // Serial.println("Something happened!" + (String)c + (String)(3-c));
  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;
    keyPressDetected = 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;
    keyPressDetected = 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;
    keyPressDetected = 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;
    keyPressDetected = true;
    return;
  }
  curChar = 0;
}

ISR(INT3_vect) {
  // Serial.println("Something happened!" + (String)c + (String)(3-c));
  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;
    keyPressDetected = 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;
    keyPressDetected = 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;
    keyPressDetected = 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;
    keyPressDetected = true;
    return;
  }
}

void trip_alarm() {

  alarmCurWaitTime = millis();

  if (alarmCurWaitTime-alarmLastSentTime >= 200) {
    Serial.println("ALARM");
    PORT_B_REG ^= (1 << 7); // Trigger LED state
    alarmLastSentTime = alarmCurWaitTime;
  }

  // PORT_B_REG |= (1 << 7); // Keep it on at the end

  if (curChar == 'D') {
    alarm = false;
    Serial.println("\nALARM OFF.\n");
    // A security system would want redundancy in setting armed states
    PORT_B_REG |= 0x80;
    armed = true;
    Serial.print("BACK TO ARMED STATE\n");
  }

}

void loop() {
  
  if (alarm) {
    trip_alarm();
  }

  // If all PULLUP pins are HIGH, no button is being pressed
  // This is how we detect holds; much better than timing
  if ((PIN_D_REG & 0x0F) == 0x0F) {
    keyStartHoldTime = millis(); 
  } else { // Any pin is low, means button is actively pressed
    if (!alarm && !armed && curChar == 'A') {
      if (millis() - keyStartHoldTime >= armedDetectionTime_ms) {
        PORT_B_REG |= 0x80;
        armed = true;
        Serial.println("\nARMED\n");
        // Update the timer so we don't trigger this again until released
        keyStartHoldTime = millis(); 
      }
    }
  }

  if (keyPressDetected) { // Key was either pressed or being held down
    keyPressDetected = false;
    if (alarm) {
      if (curChar == 'D') {
        alarm = false;
        Serial.println("\nALARM OFF.\n");
        // A security system would want redundancy in setting armed states
        PORT_B_REG |= 0x80;
        armed = true;
        Serial.print("BACK TO ARMED STATE\n");
      }
    } else { // Alarm is not on, check for secret security code
      if (curChar == silentAlarmCode[alarmCodeCounter]) {
        ++alarmCodeCounter;
        if (curChar == silentAlarmCode[(sizeof(silentAlarmCode)/sizeof(silentAlarmCode[0]))-1]) {
          alarm = true;
          armed = true;
          alarmCodeCounter = 0;
          trip_alarm();
        }
      } else { // Incorrect character in sequence
        // For security purposes, always start over, even if the key pressed was the start of the sequence
        alarmCodeCounter = 0;
      }
    }

    if (!alarm && armed && curChar == 'C') {
      PORT_B_REG &= ~0x80;
      armed = false;
      Serial.println("\nIDLE\n");
    }

    //      Printing pressed key
    PRINT_KEY:
    Serial.println(curChar);
  }
}