void setup(){
  Serial.begin(9600);
  button_Setup();
}
void loop(){
  button_Loop();
  printPushes();
}

// Module ButtonControl

// --- Configuration -----------
const byte NR_OF_BUTTONS = 3;

// --- States -----------
const byte BUTTON_STATE_RELEASED = 1;
const byte BUTTON_STATE_CHECK_PRESSED = 2;
const byte BUTTON_STATE_PRESSED = 3;
const byte BUTTON_STATE_CHECK_RELEASED = 4;

// Current state
byte button_State[NR_OF_BUTTONS];

// Timer
const int BUTTON_INTERVAL = 10;
unsigned long buttonPreviousMillis[NR_OF_BUTTONS];

// Boolean
boolean boolButtonPressed[NR_OF_BUTTONS];

// --- Setup -------------------
void button_Setup() {
  // Hardware
  buttonHardware_Setup(NR_OF_BUTTONS);

  for (byte buttonNumber = 0; buttonNumber < NR_OF_BUTTONS; buttonNumber++) {
    // Timer
    buttonPreviousMillis[buttonNumber] = 0 - BUTTON_INTERVAL;

    // Boolean
    boolButtonPressed[buttonNumber] = false;

    // Start state
    button_State[buttonNumber] = BUTTON_STATE_RELEASED;
    button_Released_Entry(buttonNumber);
  }
}

// --- Loop --------------------
void button_Loop() {
  for (byte buttonNumber = 0; buttonNumber < NR_OF_BUTTONS; buttonNumber++) {
    button_Switch(buttonNumber);
  }
}

// --- Switch --------------------
void button_Switch(byte buttonNumber) {
  switch (button_State[buttonNumber])
  {
    case BUTTON_STATE_RELEASED:
      {
        button_Released_Do(buttonNumber);
        if (getButtonHardwareDown(buttonNumber)) { // Button down
          button_Released_Exit(buttonNumber);
          button_State[buttonNumber] = BUTTON_STATE_CHECK_PRESSED;
          button_Check_Pressed_Entry(buttonNumber);
        }
        break;
      }
    case BUTTON_STATE_CHECK_PRESSED:
      {
        button_Check_Pressed_Do(buttonNumber);
        if (getButtonHardwareUp(buttonNumber)) {
          button_Check_Pressed_Exit(buttonNumber);
          button_State[buttonNumber] = BUTTON_STATE_RELEASED;
          button_Released_Entry(buttonNumber);
        }
        else if ((getButtonHardwareDown(buttonNumber)) && (millis() - BUTTON_INTERVAL >= buttonPreviousMillis[buttonNumber])) { // Button down && interval over
          button_Check_Pressed_Exit(buttonNumber);
          button_State[buttonNumber] = BUTTON_STATE_PRESSED;
          button_Pressed_Entry(buttonNumber);
        }
        break;
      }
    case BUTTON_STATE_PRESSED:
      {
        button_Pressed_Do(buttonNumber);
        if (getButtonHardwareUp(buttonNumber)) { // Button up
          button_Pressed_Exit(buttonNumber);
          button_State[buttonNumber] = BUTTON_STATE_CHECK_RELEASED;
          button_Check_Released_Entry(buttonNumber);
        }
        break;
      }
    case BUTTON_STATE_CHECK_RELEASED:
      {
        button_Check_Released_Do(buttonNumber);
        if (getButtonHardwareDown(buttonNumber)) {
          button_Check_Released_Exit(buttonNumber);
          button_State[buttonNumber] = BUTTON_STATE_PRESSED;
          button_Pressed_Entry(buttonNumber);
        }
        else if ((getButtonHardwareUp(buttonNumber)) && (millis() - BUTTON_INTERVAL >= buttonPreviousMillis[buttonNumber])) { // Button up && interval over
          button_Check_Released_Exit(buttonNumber);
          button_State[buttonNumber] = BUTTON_STATE_RELEASED;
          button_Released_Entry(buttonNumber);
        }
        break;
      }
  }
}

// --- BUTTON_STATE_RELEASED -----------
void button_Released_Entry(byte buttonNumber) {
  // <nothing>
}

void button_Released_Do(byte buttonNumber) {
  // <nothing>
}

void button_Released_Exit(byte buttonNumber) {
  // <nothing>
}

// --- BUTTON_STATE_CHECK_PRESSED -----------
void button_Check_Pressed_Entry(byte buttonNumber) {
  buttonPreviousMillis[buttonNumber] = millis(); // Reset button timer
}

void button_Check_Pressed_Do(byte buttonNumber) {
  // <nothing>
}

void button_Check_Pressed_Exit(byte buttonNumber) {
  // <nothing>
}

// --- BUTTON_STATE_PRESSED -----------
void button_Pressed_Entry(byte buttonNumber) {
  // <nothing>
}

void button_Pressed_Do(byte buttonNumber) {
  // <nothing>
}

void button_Pressed_Exit(byte buttonNumber) {
  // <nothing>
}

// --- BUTTON_STATE_CHECK_RELEASED -----------
void button_Check_Released_Entry(byte buttonNumber) {
  buttonPreviousMillis[buttonNumber] = millis(); // Reset button timer
}

void button_Check_Released_Do(byte buttonNumber) {
  // <nothing>
}

void button_Check_Released_Exit(byte buttonNumber) {
  boolButtonPressed[buttonNumber] = true; // Button is pressed
}

// --- Event -----------
boolean buttonPressed(byte buttonNumber) { // Returns true if button is pressed && resets button
  if (boolButtonPressed[buttonNumber]) {
    boolButtonPressed[buttonNumber] = false;
    return true;
  }
  else return false;
}

const int BUTTON_PINS[] = {A5, A4, A3};
const int MAX_AANTAL = 3;
int aantalKnoppen = 0;

void buttonHardware_Setup(int aantal) {
  if (aantal <= MAX_AANTAL) {
    for(int knopNummer = 0; knopNummer < aantal; knopNummer++){
      pinMode(BUTTON_PINS[knopNummer], INPUT);
    }
    aantalKnoppen = aantal;
  }
}

bool getButtonHardwareDown(int buttonNumber) {
  if (buttonNumber >= 0 && buttonNumber < aantalKnoppen) {
    return (digitalRead(BUTTON_PINS[buttonNumber]) == LOW);
  }
}

bool getButtonHardwareUp(int buttonNumber) {
  if (buttonNumber >= 0 && buttonNumber < aantalKnoppen) {
    return !getButtonHardwareDown(buttonNumber);
  }
}

void printPushes() {
  if (buttonPressed(0)==true)
    Serial.println("RIGHT");
  if (buttonPressed(1)==true)
    Serial.println("LEFT");
  if (buttonPressed(2)==true)
    Serial.println("MIDDLE");
}