Flip flop schakeling

loop () 
{
  if (is_pressed (KNOPA) || 
      is_pressed (KNOPB)) {
     if (ispressed (KNOPA)) {led1 = LEDA; led2 = LEDB}
     else                   {led1 = LEDB; led2 = LEDA}
     start = time_millis ();
     // bereken stop. 
     while (time_millis () < stop) {
       LED (led1, ON);
       delay_ms (thedelay);
       LED (led1, OFF);
       LED (led2, ON);
       delay_ms (thedelay);
       LED (led2, OFF);
     } 
  }
}

const int ledPinA = 2;      // Pin voor LED A
const int ledPinB = 3;      // Pin voor LED B
const int buttonPinA = 4;   // Pin voor drukknop A
const int buttonPinB = 5;   // Pin voor drukknop B
const int buttonReset = 6;  // Pin voor reset drukknop
const int buttonHold = 7;   // Pin voor hold drukknop

enum State {
  STATE_A,
  STATE_B,
  STATE_HOLD,
};

State currentState = STATE_A; // Huidige staat van de flip-flop
int buttonStateA = 0;         // Huidige staat van drukknop A
int buttonStateB = 0;         // Huidige staat van drukknop B
int buttonStateReset = 0;     // Huidige staat van de reset drukknop
int buttonStateHold = 0;      // Huidige staat van de hold drukknop

void setup() {
  pinMode(ledPinA, OUTPUT);
  pinMode(ledPinB, OUTPUT);
  pinMode(buttonPinA, INPUT);
  pinMode(buttonPinB, INPUT);
  pinMode(buttonReset, INPUT);
  pinMode(buttonHold, INPUT);

  initializeFlipFlop();
}

void loop() {
  readButtonStates();

  if (buttonStateReset == HIGH) {
    resetFlipFlop();
  }

  flipFlop();

  // Wacht een korte periode om het flip-floppen regelbaar te maken
  delay(100);
}

void initializeFlipFlop() {
  currentState = STATE_A;
  digitalWrite(ledPinA, HIGH);
  digitalWrite(ledPinB, LOW);
}

void readButtonStates() {
  buttonStateA = digitalRead(buttonPinA);
  buttonStateB = digitalRead(buttonPinB);
  buttonStateReset = digitalRead(buttonReset);
  buttonStateHold = digitalRead(buttonHold);
}

void resetFlipFlop() {
  initializeFlipFlop();
}

void flipFlop() {
  switch (currentState) {
    case STATE_A:
      flipFlopStateA();
      break;

    case STATE_B:
      flipFlopStateB();
      break;

    case STATE_HOLD:
      flipFlopStateHold();
      break;
  }
}

void flipFlopStateA() {
  digitalWrite(ledPinA, HIGH);
  digitalWrite(ledPinB, LOW);

  if (buttonStateA == HIGH) {
    currentState = STATE_B;
  }

  if (buttonStateB == HIGH && buttonStateHold == LOW) {
    currentState = STATE_HOLD;
  }
}

void flipFlopStateB() {
  digitalWrite(ledPinA, LOW);
  digitalWrite(ledPinB, HIGH);

  if (buttonStateB == HIGH) {
    currentState = STATE_A;
  }

  if (buttonStateA == HIGH && buttonStateHold == LOW) {
    currentState = STATE_HOLD;
  }
}

void flipFlopStateHold() {
  if ((buttonStateA == HIGH && buttonStateHold == HIGH) || (buttonStateB == HIGH && buttonStateHold == HIGH)) {
    if (buttonStateA == HIGH) {
      digitalWrite(ledPinA, HIGH);
      digitalWrite(ledPinB, LOW);
    } else if (buttonStateB == HIGH) {
      digitalWrite(ledPinA, LOW);
      digitalWrite(ledPinB, HIGH);
    }
  }
}

/*
 * FlipFlopLed.cpp
 *
 * Created  : 2023-11-10
 * Author   : deKees
 * Purpose  : FlipFlopLed
 */

#include <avr/io.h>

// ================================================================================================

const int FlipTime = 20000;

// ================================================================================================

class PinHandler
{
public:
   PinHandler(uint8_t PinNr)
   {  MyPin = (1 << PinNr);
   }

protected:
   uint8_t MyPin;
};

// ================================================================================================

class Led : public PinHandler
{
public:
   Led(uint8_t PinNr) : PinHandler(PinNr)
   {  DDRB  |=  MyPin;   // Output
   }

   void On()
   {  PORTB |=  MyPin;   // High is on
   }

   void Off()
   {  PORTB &= ~MyPin;   // Low is Off
   }
};

// ================================================================================================

class Button : public PinHandler
{
public:
   Button(uint8_t PinNr) : PinHandler(PinNr)
   {  DDRB  &= ~MyPin;  // Input
      PORTB |=  MyPin;  // Pullup aktief
   }

   bool Pressed()
   {  return (PINB & MyPin) == 0 ? true : false;  // Low is On
   }
};

// ================================================================================================

class Timer
{
public:

   Timer()
   {  // Startup delay
      Counter = 100000;
      while(Counter)
      {  Counter -= 1;
      }
   }

   void Tick()
   {  Counter += 1;

      if(Counter >= FlipTime)
      {  Counter  = 0;
         Toggle   = !Toggle;
      }
   }

   bool FlipFlop()
   {  return Toggle;
   }

private:
   uint32_t Counter = 0;
   bool     Toggle  = true;
};

// ================================================================================================

Led     LedA(PB4);
Led     LedB(PB3);

Button  ButtonA(PB2);
Button  ButtonB(PB1);
Button  ButtonC(PB0);

Timer   T1;

int main(void)
{
   uint8_t  State = 1;

   for ( ;; )  //< EndLess loop
   {
      T1.Tick();

      switch(State)
      {
         default:
         case 1:
         {  // - Check Buttons.
            if(ButtonA.Pressed())
            {  State = ButtonC.Pressed() ? 4 : 2;
            }

            if(ButtonB.Pressed())
            {  State = ButtonC.Pressed() ? 5 : 3;
            }

            // - Both leds blinking.
            if(T1.FlipFlop())
            {  LedA.On();
               LedB.Off();
            }
            else
            {  LedA.Off();
               LedB.On();
            }
            break;
         }

         case 2:
         {  // Led A blinking
            if(T1.FlipFlop())
            {  LedA.On();
               LedB.Off();
            }
            else
            {  LedA.Off();
               LedB.Off();
            }
            break;
         }

         case 3:
         {  // Led B blinking
            if(T1.FlipFlop())
            {  LedA.Off();
               LedB.On();
            }
            else
            {  LedA.Off();
               LedB.Off();
            }
            break;
         }

         case 4:
         {  // Led A steady
            LedA.On();
            LedB.Off();
            break;
         }

         case 5:
         {  // Led B steady
            LedA.Off();
            LedB.On();
            break;
         }
      }
   }
}

/*
 * FlipFlopLed.cpp
 *
 * Created  : 2023-11-11
 * Author   : deKees
 * Purpose  : FlipFlopLed
 */

#include <avr/io.h>

// ================================================================================================

const int FlipTime = 20000;

// ================================================================================================

class PinHandler
{
public:
   PinHandler(uint8_t PinNr)
   {  MyPin = (1 << PinNr);
   }

protected:
   uint8_t MyPin;
};

// ================================================================================================

class Led : public PinHandler
{
public:
   Led(uint8_t PinNr) : PinHandler(PinNr)
   {  DDRB  |=  MyPin;   // Output
   }

   void On()
   {  PORTB |=  MyPin;   // High is on
   }

   void Off()
   {  PORTB &= ~MyPin;   // Low is Off
   }
};

// ================================================================================================

class Button : public PinHandler
{
public:
   Button(uint8_t PinNr) : PinHandler(PinNr)
   {  DDRB  &= ~MyPin;  // Input
      PORTB |=  MyPin;  // Pullup aktief
   }

   bool Pressed()
   {  return (PINB & MyPin) == 0 ? true : false;  // Low is On
   }
};

// ================================================================================================

class Timer
{
public:

   Timer()
   {  // Startup delay
      Counter = 100000;
      while(Counter)
      {  Counter -= 1;
      }
   }

   void Tick()
   {  Counter += 1;

      if(Counter >= FlipTime)
      {  Counter  = 0;
         Toggle   = !Toggle;
      }
   }

   bool FlipFlop()
   {  return Toggle;
   }

private:
   uint32_t Counter = 0;
   bool     Toggle  = true;
};

// ================================================================================================

Led     LedA(PB4);
Led     LedB(PB3);

Button  ButtonA(PB2);
Button  ButtonB(PB1);
Button  ButtonC(PB0);

Timer   T1;

int main(void)
{
   uint8_t  State = 1;

   for ( ;; )  //< EndLess loop
   {
      T1.Tick();

      switch(State)
      {
         default:
         case 1:
         {  // - Check Buttons.
            if(ButtonA.Pressed())
            {  State = ButtonC.Pressed() ? 4 : 5;
            }

            if(ButtonB.Pressed())
            {  State = ButtonC.Pressed() ? 5 : 4;
            }

            // - Both leds blinking.
            if(T1.FlipFlop())
            {  LedA.On();
               LedB.Off();
            }
            else
            {  LedA.Off();
               LedB.On();
            }
            break;
         }

         case 4:
         {  // Led A steady
            LedA.On();
            LedB.Off();
            break;
         }

         case 5:
         {  // Led B steady
            LedA.Off();
            LedB.On();
            break;
         }
      }
   }
}