keypad repeat button problem

Hi I have used keypad for several years on the remote controls I make for scoreboards, but suddenly cannot press the same button twice ! for example, one button is for updating the score, it will do it once, but the next time you press the button it sends 0, unless I press another button between pushes.

I have dug out an old remote and that works fine, but I cannot find the sketch for it.

I have trimmed down the sketch to basics for testing as below and the second press gives a 0 until another is pressed ?

Any clues ? I am using 2 schottky diodes between the int pin 2 and each of the rows .

#include <Keypad.h>         // Matrix Keypad library
#include <avr/sleep.h>      // powerdown library
#include <avr/interrupt.h>  // interrupts library

int pin2 = 2;               // Int0 interrupt pin

// set up the Keypad
const byte ROWS = 2; // two rows
const byte COLS = 3; // three columns
// Define the Keymap
char keys[ROWS][COLS] = 
{ {'A','B','E' } ,  // row 1   //  
  {'D','C' , 'F'}    ,  // row 2    
byte rowPins[ROWS] = { 
  16,17  };  // Keypad uses internal pullups? No externals supplied
byte colPins[COLS] = { 
// Create the Keypad
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
// *  Name:        pin2Interrupt, "ISR" to run when interrupted in Sleep Mode
void pin2Interrupt()
  /* This brings us back from sleep. */
// *  Name:        enterSleep
void enterSleep()
  /* Setup pin2 as an interrupt and attach handler. */
  attachInterrupt(0, pin2Interrupt, FALLING);
  delay(50); // need this?   garbled comments on monitor if commented out
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);  // setting up for sleep ...
  sleep_enable();                       // setting up for sleep ...
  ADCSRA &= ~(1 << ADEN);
  PRR = 0xFF;
  sleep_mode();                         // now goes to Sleep and waits for the interrupt
  /* The program will continue from here after the interrupt. */
  detachInterrupt(0);                 //disable interrupts while we get ready to read the keypad 
  PRR = 0x00;
  /* First thing to do is disable sleep. */

  // set all the keypad columns back high so can read keypad presses again
  digitalWrite(19, HIGH);
  digitalWrite(18, HIGH); 
  digitalWrite(13, HIGH);

//**************************************************************************  LOOP
void setup()
  pinMode(pin2, INPUT);                 // our sleep interrupt pin
  digitalWrite(pin2, HIGH);  // set pull up res
  Serial.println("set up"); 
// *************************************************************************end of void Setup()  

void loop()
    Serial.println("Sleep");               // for debug only

      digitalWrite(18, LOW);// set the columns low before sleeping, otherwise Keypad leaves them high and Rows have nothing to pull low.
      digitalWrite(13, LOW);
     enterSleep();                             // call Sleep function to put us out
    //  THE PROGRAM CONTINUEs FROM HERE after waking up in enterSleep()
//Serial.print("key  at wakeup =");   Serial.println(int (key));
  char key = keypad.getKey();                 // reading the keypad
// if(key)  {                                   // same as if(key != NO_KEY)- did something change?
     Serial.print("key read =");   Serial.println(int (key));         
Serial.print("key at end loop =");   Serial.println(int (key));
} // end of void loop

I found an older version that I had been using before and I had put in a loop counter, to let the loop run 100 times before sleeping, in case it missed a keypress

  if (sleep_count>100){                      // check if we should go to sleep because of "time" --> Try shorter versions of this
    sleep_count=0;                           // turn it off for when we wake up   
      Serial.println("Sleep");               // for debug only
    sleep_count = 0;                          // reset count up to sleep if transmitted a key press
    } //                                           // end of if(key) & transmitting a character
 sleep_count ++;

I had removed this function when I made the new current version, relying on the interrupt just running the loop once.