leds Steuern mit verschiedenen Tastern

Hallo ich hätte mal eine Frage als Neuling (habe noch nicht viel Erfahrung mit dem Arduino).
Ich würde gerne meine LED Lichsignale für die Eisenbahn mit Tastern steuern.
Und zwar:
Taster 1 drücken, die grüne LED des Signals soll für 9 Sekunden angehen.
Danach soll die grüne LED wieder ausgehen und die rote wieder an dauerhaft.

Drückt man Taster 2, dann soll die rote led ausgehen und die grüne und gelbe led angehen wieder für 9 Sekunden.

Bis dahin habe ich es geschafft aber jetzt kommt die Frage.
Wie kann ich den Sketch so umformulieren, dass wenn ich Taster 1 gedrückt hab und ich innerhalb der 9 Sekunden Taster 2 drücke, dass dann auch das Programm vom Taster 2 anfängt zu laufen und danach dann wieder nur die rote led leuchtet.

Zudem habe ich noch eine Zusatzfrage.

Könnte man mehrere Signale gleichzeitig steuern? Also das Signal 1 mit den Tastern 1&2 steuern und gleichzeitig das Signal 2 mit den selben Funktionen mit den Tastern 3&4, auch wenn ich Taster 1 gedrückt hab und eine Sekunde später drücke ich Taster 3 um das Signal 2 zu ändern?

Ich glaube, du möchtest eine ganzes Nest an endlichen Automaten bauen!

Zum Thema "gleichzeitig" kann ich wenig sagen...
Aber "quasi gleichzeitig", ist problemlos möglich.


Ablaufsteuerung
Meine Standardantwort zu Ablaufsteuerungen:

Eine Stichworte Sammlung für Google Suchen:
Endlicher Automat,
State Machine,
Multitasking,
Coroutinen,
Ablaufsteuerung,
Schrittkette,
BlinkWithoutDelay,

Blink Without Delay
Der Wachmann

Multitasking Macros
Intervall Macro

Basti2499:
Könnte man mehrere Signale gleichzeitig steuern?

Ein ausbaufähiges Testprogramm, basierend auf einer Idee von combie, mit "schnell nacheinander" könnte so aussehen:

const unsigned long gruen_an = 9000; // in Millisekunden
const unsigned long gelb_an = 9000; // in Millisekunden
unsigned long jetzt;                     // Variable für den aktuellen Zeitpunkt
enum {ROT, GELBGRUEN, GRUEN};

struct Signal {
  Signal(const byte taster_pin_gn,  const byte taster_pin_ge,  const byte led_pin_rt,  const byte led_pin_ge,  const byte led_pin_gn  ):
    taster_pin_gn(taster_pin_gn),  taster_pin_ge(taster_pin_ge),  led_pin_rt(led_pin_rt),  led_pin_ge(led_pin_ge),  led_pin_gn(led_pin_gn),
    aktZustand_gn(0), altZustand_gn(0), aktZustand_ge(0), altZustand_ge(0), vorhin_gn(0), vorhin_ge(0), entprellMillis_gn(0), entprellMillis_ge(0), signalZustand(ROT) {}

  void init()
  {
    pinMode(taster_pin_gn, INPUT_PULLUP);
    pinMode(taster_pin_ge, INPUT_PULLUP);
    pinMode(led_pin_rt, OUTPUT);
    pinMode(led_pin_ge, OUTPUT);
    pinMode(led_pin_gn, OUTPUT);
    aktZustand_gn = digitalRead(taster_pin_gn);
    altZustand_gn = aktZustand_gn;
    aktZustand_ge = digitalRead(taster_pin_ge);
    altZustand_ge = aktZustand_ge;
    digitalWrite(led_pin_rt, HIGH);
    digitalWrite(led_pin_ge, LOW);
    digitalWrite(led_pin_gn, LOW);
  }

  void run()
  {
    aktualisieren();
    if (fallend_ge())
    {
      vorhin_ge = jetzt;
      signalZustand = GELBGRUEN;
      ausgabe(LOW, HIGH, HIGH);
    }
    if (fallend_gn())
    {
      vorhin_gn = jetzt;
      signalZustand = GRUEN;
      ausgabe(LOW, LOW, HIGH);
    }
    if ((jetzt - vorhin_ge >= gelb_an) && (signalZustand == GELBGRUEN))
    {
      signalZustand = ROT;
      ausgabe(HIGH, LOW, LOW);
    }
    if ((jetzt - vorhin_gn >= gruen_an) && (signalZustand == GRUEN))
    {
      signalZustand = ROT;
      ausgabe(HIGH, LOW, LOW);
    }
  }

  void ausgabe(bool rt, bool ge, bool gn)
  {
    digitalWrite(led_pin_rt, rt);
    digitalWrite(led_pin_ge, ge);
    digitalWrite(led_pin_gn, gn);
  }

  void aktualisieren()
  {
    altZustand_gn = aktZustand_gn;
    if (jetzt - entprellMillis_gn >= 20)
    {
      aktZustand_gn = digitalRead(taster_pin_gn);
      if (altZustand_gn != aktZustand_gn)
      {
        entprellMillis_gn = jetzt;
      }
    }
    altZustand_ge = aktZustand_ge;
    if (jetzt - entprellMillis_ge >= 20)
    {
      aktZustand_ge = digitalRead(taster_pin_ge);
      if (altZustand_ge != aktZustand_ge)
      {
        entprellMillis_ge = jetzt;
      }
    }
  }

  bool fallend_gn()
  {
    return (altZustand_gn && !aktZustand_gn);
  }

  bool fallend_ge()
  {
    return (altZustand_ge && !aktZustand_ge);
  }

  const byte taster_pin_gn, taster_pin_ge, led_pin_rt, led_pin_ge, led_pin_gn;
  bool aktZustand_gn, altZustand_gn, aktZustand_ge, altZustand_ge;
  unsigned long vorhin_gn, vorhin_ge, entprellMillis_gn, entprellMillis_ge;
  byte signalZustand;
};

Signal signal[] {
  // Tasterpin gruen, Tasterpin gelb/gruen, LEDpin rot, LEDpin gelb, LEDpin gruen
  {2, 3, 6, 7, 8},    // Signal 1
  {4, 5, 9, 10, 11}   // Signal 2
};

void setup() {
  for (Signal &s : signal) s.init();
}

void loop() {
  jetzt = millis();                      // aktuelen Zeitwert merken
  for (Signal &s : signal) s.run();
}

Bei einem UNO werden Dir schnell die Pins ausgehen, weshalb Du dann über Alternativen wie Mega2560 oder MCP23017 nachdenken müßtest. Auf einer Modellanlage könnte sich ein Datenbus mit verteilter "Intelligenz" anbieten.