RTOS-Konzepte —
interaktive Lernplattform

Threads / Tasks

Ein Thread fragt die Tastatur ab (T1), ein zweiter berechnet die Physik der Welt (T2), ein dritter lädt im Hintergrund neue Texturen von der Festplatte (T3). Ohne Threads würde das Spiel einfrieren, sobald man ein neues Level betritt — weil eine einzige Aufgabe alles blockieren würde.

static void task_1_loop() {
  bool on = false;
  while (true) {
    int period_ms = slider1.get_value();
    on = !on;
    if (on) led1.on(0x0d, 0x6e, 0xfd); // blau
    else    led1.off();

    // Task blockiert für period_ms → gibt CPU frei
    pw::this_thread::sleep_for(
      pw::chrono::SystemClock::for_at_least(
        std::chrono::milliseconds(period_ms)));
  }
}

Binäre Semaphore

Die Läufer (Tasks) warten blockiert an der Linie. Sobald der Schiedsrichter die Pistole abfeuert (Signal geben), dürfen sie losrennen. Es geht nicht um den Schutz einer Ressource, sondern um das Warten auf ein Ereignis. Ein Producer signalisiert, ein Consumer wartet.

static void producer_loop() {
  while (true) {
    sleep_for(slider_period.get_value());

    // Signal an Consumer senden
    semaphore.release();

    led_producer.on(0x0d,0x6e,0xfd); // blau
    sleep_for(100ms);
    led_producer.off();
  }
}

static void consumer_loop() {
  while (true) {
    // blockiert, bis release() kommt
    semaphore.acquire();

    // Signal empfangen → LED an
    led_consumer.on(0x1a,0xc2,0x55); // grün
    sleep_for(150ms);
    led_consumer.off();
  }
}

Mutex

Es gibt nur einen Schlüssel. Wer ihn hat, darf rein — alle anderen warten vor der Tür. Erst wenn der Vorgänger den Schlüssel zurückgibt, kann der Nächste die Ressource (Toilette) nutzen. Das verhindert, dass zwei Leute gleichzeitig denselben Raum nutzen und Chaos entsteht. Besitzprinzip: nur wer sperrt, gibt frei.

static void task1_loop() {
  while (true) {
    sleep_for(slider1.get_value());
    {
      // Mutex sperren (RAII)
      std::lock_guard lock(mutex);

      led1.on(0x0d,0x6e,0xfd);
      shared_counter = (shared_counter + 1) % 201;
      counter_bar.set_value(shared_counter);
      sleep_for(80ms); // Arbeit im Abschnitt
      led1.off();
    } // Mutex hier automatisch frei
  }
}

Counting Semaphore

Jeder Student, der ein Rad nimmt, verringert den Zähler. Sind alle 10 Räder weg (Zähler = 0), muss der Nächste warten. Sobald jemand ein Rad zurückbringt, wird der Zähler erhöht und die nächste wartende Person darf losfahren. Die Semaphore verwaltet also einen Pool identischer Ressourcen.

static void producer_loop() {
  while (true) {
    sleep_for(slider_produce.get_value());

    if (available_slots.load() < kSlots) {
      semaphore.release();
      int slots = available_slots.fetch_add(1)+1;
      slots_bar.set_value(slots);
      led_producer.on(0x0d,0x6e,0xfd);
    }
  }
}

static void consumer_loop() {
  while (true) {
    // blockiert, bis ≥ 1 Slot frei
    semaphore.acquire();

    int slots = available_slots.fetch_sub(1)-1;
    slots_bar.set_value(slots);
    led_consumer.on(0x1a,0xc2,0x55);
    sleep_for(slider_consume.get_value());
  }
}