myduration buttonDuration();
myduration.add(after1, 1);
myduration.add(after3, 3);
myduration.add(after8, 8);

#include "mbed.h"
 
DigitalOut led1(LED1);
DigitalOut led2(LED2);
DigitalOut led3(LED3);
DigitalOut led4(LED4);

Serial pc(USBTX, USBRX);
Ticker ticker;
 
InterruptIn pb(p17);

void state1(void){
 led2 = !led2;
 }
 
 void state2(void){
 led3 = !led3;
 }
 
 void state3(void){
 led4 = !led4;
 }
 
 
// Global count variable
int volatile counter = 0;
int volatile STATE = 0;

void countCallback(void) {
    counter = counter + 1;
}
void stateEval(void) {
    if(counter >=1 && counter <=3){
        STATE = 1; 
        state1();
        }
    if (counter >= 4 && counter <=7){
        STATE = 2;
        state2();
        }
    if (counter >=8 && counter <=10){ö
        STATE = 3;
        state3();
        }
    pc.printf("STATE %d \n", STATE);
}
 
// pb Interrupt routine - is interrupt activated by a falling edge of pb input
void pb_hit_interrupt (void) {
    ticker.attach(countCallback, 1);
    counter = 0;         
}

void pb_release_interrupt (void) {
    ticker.detach();
    stateEval();
    counter = 0;
    STATE = 0;
   // pc.printf("Counter: %d \n", counter);
}

int main() {
    // Use internal pullup for pushbutton
    pb.mode(PullUp);
    // Delay for initial pullup to take effect
    wait(.01);
    // Attach the address of the interrupt handler routine for pushbutton
    pb.rise(&pb_release_interrupt);
    pb.fall(&pb_hit_interrupt);
    // Blink led1 in main routine forever while responding to pb changes
    // via interrupts that activate pb_hit_interrupt routine
    while (1) {
        led1 = !led1;
        wait(.5);
    }
}

#include "mbed.h"

Serial pc(USBTX, USBRX);

struct action
{
    int counter_limit;
    void (*transition)(void);
};

struct action_list
{
    size_t size;
    const action *table;
};

class ButtonHandler {
public:

    ButtonHandler(std::size_t table_size, const action* begin, PinName pin, float seconds ): buttonPin(pin) {
        mTable.size = table_size;
        mTable.table = begin;
       // buttonPin(pin);
        intervalInSeconds = seconds;
        pc.printf("class initialized \n");
    }

    void react(int counter) const {
        const action *a = mTable.table;
        for (std::size_t i=mTable.size; i; --i, ++a) {
            if (counter < a->counter_limit) {
                a->transition();
                return;
            }
        }
    }
   void enable() {
       buttonPin.mode(PullDown);
       wait(0.01);
       buttonPin.rise(this, &ButtonHandler::release);
       buttonPin.fall(this, &ButtonHandler::press);
       buttonPin.enable_irq();
        pc.printf("enable() function executed\n");
    }
    void disable() {
        buttonPin.disable_irq();
        ticker.detach();
    }
    virtual ~ButtonHandler() {
        disable();
    }
protected:
    
    void press() {
        pc.printf("button 1 pressed\n");
        counter = 0;
        ticker.attach(this, &ButtonHandler::secondsCount, intervalInSeconds);
        
    }
    void secondsCount() {
        ++counter;
    }
    void release() {
        ticker.detach();
        react(counter);
        counter = 0;
    }
private:
    volatile unsigned counter;
    InterruptIn buttonPin;
    float intervalInSeconds;
    action_list mTable;
    Ticker ticker;
};

void state1() {
    //std::cout << __func__;
    pc.printf("state1");
}
void state4() {
    //std::cout << __func__;
    pc.printf("state4");
}
void state8() {
    //std::cout << __func__;
    pc.printf("state8");
}


const action action_table[] =
{
    { 4, state1 },
    { 8, state4 },
    { 11, state8 },
};

int main()
{
    ButtonHandler green(
            sizeof(action_table)/sizeof(action_table[0]),
            action_table,
            p17,
            1
    );
    green.enable();

    while(1){
        printf("alive\n");
        wait(5);
     }
}