File content as of revision 3:cb87d0442ac1:

#include "mbed.h"

InterruptIn  SW1(p14);  // für den Test ist nur dieser erforderlich
InterruptIn  SW2(p15); 
InterruptIn  SW3(p12); 
InterruptIn  SW4(p16); 

BusOut Leds ( LED1 , LED2, LED3, LED4);

Ticker flipper;             // Ticker für blinken der LED
volatile int blinkCount=0;  // Volatile, damit es nicht auf unterschiedlichen Cores ausgeführt wird

enum State {ST_AUS=0, ST_EIN};
State state;


int LedWert = 3, btnCount = 0;

bool pressed = false;

/*
void flip()                 // 
{
    blinkCount++;           // Variable die hochgezählt wird um die LED 2 mal blinken zu lassen
    Led4 = !Led4;           // umschalten der LED
}
*/
 
void rise(void)
{  
    wait_ms(100);           // Entprellung der Taste, bei mir 100ms da der Taster furchtbar prellt...
    pressed = true;         // Umschalten auf WAHR, es wurde gedrückt
}

bool CheckFlag() 
{
    if (pressed)            // Abfrage ob pressed WAHR ist
    {
        pressed=false;      // Rücksetzen wieder auf Status FALSCH
        return true;        // Rückgabe bei CheckFlag das WAHR ist
    }
    return false;           // Wenn nicht pressed Wahr ist wird CheckFlag als FALSCH zurück gegeben
}


void ST_EIN (void)
{


    
    printf("State: 1 (Aus)");       // Ausgabe auf der seriellen Console
    
//_______________entry____________________\\
    
//_______________do_______________________\\

    while(true) 
    {
             while(true) {
        Leds = LedWert;
    
        if(CheckFlag()) {
            btnCount++;
            if(btnCount >= 3){
                btnCount = 0;
                LedWert++;
                state = ST_AUS;
            
//______________exit_______________________\\

            return;
            }
        }
}


void ST_AUS (void)
{

    printf("State: 2 (Ein)");       // Ausgabe auf der seriellen Console
    
    /*
//____________aufruf um die Led blinken zu lassen____\\
    flipper.attach(&flip, 0.3);     // the address of the function to be attached (flip) and the interval (0,3 seconds)
    
    while(true)                     // Dauerschleife
    {
        if ( blinkCount >= 4) break;// Ausbruch aus der Whileschleife wenn der blinkCount größer gleich 4 ist
    }
        flipper.detach();           // Tiker deaktivieren
        blinkCount=0;               // blinkCount rücksetzen auf 0 damit es wieder von vorne losgehen kann
    */
    
//_____________do______________\\

    while(true) {
        Leds = 0;
    
        if(CheckFlag()) 
        {
            state = ST_EIN;
            
//_______________exit______________\\

            return;
            }
        }
}

void ST_Error (void)
{
    printf("State: ERROR!!!");
    return;
}


void stateMachine()
{
    switch (state)
    {
    case ST_EIN: ST_EIN();
        break;
    case ST_AUS: ST_AUS();
        break;
    default: ST_Error();  // sollte nicht auftreten 
        break;
    }
}


 
int main()
{
    SW1.rise(&rise);      //.fall(&fall);
    Leds = 15;            // damit alle leuchten
    wait_ms(500);         // laut Angabe, eine verzögerung von 500ms
    
    state = ST_EIN;       // wir starten mit diesem Zustand
    while(true)
    {
        stateMachine(); 
    }
}

/*
class IsAnEvent : public InterruptIn {
        volatile int16_t _pressed;
        void _RisingISR(); 
    public:
        IsAnEvent() : InterruptIn(p14) {};
        IsAnEvent(PinName pin) : InterruptIn(pin) {
             rise(callback(this, &IsAnEvent::_RisingISR)); 
            _pressed=0; 
        };
        int CheckFlag();
        void InitIsr();
};

void IsAnEvent::InitIsr() { 
    rise(callback(this, &IsAnEvent::_RisingISR)); 
}

void IsAnEvent::_RisingISR() {
    wait_ms(50);
    if( read() )
        _pressed = true;
}
int IsAnEvent::CheckFlag() {
    if( _pressed ) { 
        _pressed = false; 
        return 1; 
    }
    return 0;
}
*/