Wie Tasks reden, warten & reagieren

Rückblick — was bisher geschah

Teil 2 baut auf den früheren Terminen auf. Klapp die Themen auf, die du auffrischen möchtest — dann geht es weiter mit den neuen Konzepten.

Teil 2 im Überblick

Vier neue Konzepte — jeweils mit ihrer nativen FreeRTOS-API und der typsicheren Pigweed-Abstraktion, die im Simulator verwendet wird.

Queues / Messaging

Sicherer Datenaustausch zwischen Tasks — ein Task legt Nachrichten ab, ein anderer liest sie aus.

Eine Queue (Warteschlange) ist ein Puffer, durch den zwei Tasks Nachrichten austauschen, ohne sich direkt zu kennen. Sie arbeitet nach dem FIFO-Prinzip: First In, First Out — was zuerst hineinkommt, geht zuerst wieder heraus.

Der Producer schreibt, der Consumer liest. Der Puffer entkoppelt beide: ist der Consumer kurz langsamer, füllt sich die Queue, statt dass Daten verloren gehen.

Ein Roboter legt Bauteile aufs Band, ein anderer nimmt sie am Ende ab. Das Band puffert, wenn der Verpacker kurz langsamer ist.

Der Code — Schritt für Schritt

static constexpr size_t kQueueCapacity = 8;

struct Message {
  int value;
  uint32_t seq;      // fortlaufende Nummer
};

static pw::InlineQueue<Message, kQueueCapacity> message_queue;
static pw::sync::Mutex           queue_mutex;   // schützt die Queue
static pw::sync::BinarySemaphore data_ready;    // Ereignis-Signal

while (true) {
  // 1) warten (Sende-Periode aus dem Slider)
  pw::this_thread::sleep_for(
    pw::chrono::SystemClock::for_at_least(
      std::chrono::milliseconds(slider_produce.get_value())));

  value = (value + 13) % 101;      // Pseudowert 0..100

  // 2) unter Mutex-Schutz in die Queue legen
  {
    std::lock_guard lock(queue_mutex);
    if (!message_queue.full()) {
      message_queue.push(Message{value, seq++});
      queue_fill_bar.set_value(message_queue.size());
    }
  }

  data_ready.release();            // 3) Consumer wecken
  led_producer.on(0x0d, 0x6e, 0xfd);   // blau leuchten
}

while (true) {
  data_ready.acquire();            // 1) auf Signal warten (blockiert)

  Message msg{};
  bool got = false;
  {
    std::lock_guard lock(queue_mutex);
    if (!message_queue.empty()) {
      msg = message_queue.front();  // 2) ältestes Element (FIFO)
      message_queue.pop();
      got = true;
      queue_fill_bar.set_value(message_queue.size());
    }
  }

  if (got) {
    led_consumer.on(0x1a, 0xc2, 0x55);   // grün
    value_bar.set_value(msg.value);      // 3) anzeigen
  }
}

// Producer: höhere Priorität (2), Consumer: niedriger (1)
prod_opts.set_name("Producer").set_priority(2);
cons_opts.set_name("Consumer").set_priority(1);

pw::thread::DetachedThread(prod_opts, [] { producer_loop(); });
pw::thread::DetachedThread(cons_opts, [] { consumer_loop(); });

vTaskStartScheduler();   // ab hier übernimmt der Scheduler

Timeouts / Delay

Zeitgesteuert pausieren — und begrenzt warten: „Ich warte eine Weile, aber nicht ewig.“

Delay (sleep_for): Ein Task legt sich für eine feste Zeit schlafen und gibt die CPU frei — kein „Busy Waiting“, das Rechenzeit verschwendet.

Timeout (try_acquire_for): Ein Task wartet auf ein Signal — aber höchstens eine gewählte Zeit. Kommt es rechtzeitig → weiter. Sonst → Timeout-Reaktion (z. B. Alarm).

Ein Herzschlag-Monitor schlägt Alarm, wenn nicht rechtzeitig ein Signal kommt. Oder: die Kaffeemaschine, die nach Inaktivität in den Standby wechselt.

Der Code — Schritt für Schritt

while (true) {
  // warten (Delay aus dem Slider) — CPU wird freigegeben
  pw::this_thread::sleep_for(
    pw::chrono::SystemClock::for_at_least(
      std::chrono::milliseconds(slider_delay.get_value())));

  signal.release();                 // Semaphore 0 -> 1
  led_sender.on(0x0d, 0x6e, 0xfd);  // blau
}

while (true) {
  const auto timeout = pw::chrono::SystemClock::for_at_least(
      std::chrono::milliseconds(slider_timeout.get_value()));

  const bool acquired = signal.try_acquire_for(timeout);

  if (acquired) {
    led_watcher.on(0x1a, 0xc2, 0x55);   // grün: rechtzeitig
  } else {
    led_watcher.on(0xe5, 0x39, 0x35);   // rot: Timeout
  }
}

Interrupts

Sofort auf externe Ereignisse reagieren — die Hardware unterbricht die CPU, ohne dass ständig „nachgefragt“ werden muss.

Statt in einer Schleife immer wieder zu fragen „Ist schon was passiert?“ (Polling) meldet sich die Hardware selbst. Ein Interrupt unterbricht sofort den laufenden Code und springt in eine ISR (Interrupt Service Routine).

Die goldene Regel: eine ISR muss extrem kurz sein. Sie erledigt nur das Nötigste und delegiert die eigentliche Arbeit an einen normalen Task — über eine Semaphore (…FromISR()).

Du liest ein Buch. Das Telefon klingelt — du merkst dir die Seite (Kontext sichern), gehst kurz ran (ISR), legst auf und liest weiter. Die lange Aufgabe („zurückrufen & plaudern“) machst du später in Ruhe.

Der Code — Schritt für Schritt

// Läuft im Interrupt-Kontext — MUSS extrem kurz sein!
void OnButtonInterrupt() {
  BaseType_t higher_prio_woken = pdFALSE;

  // NUR signalisieren — keine langen Berechnungen hier!
  xSemaphoreGiveFromISR(event_signal, &higher_prio_woken);

  // Falls ein wichtigerer Task geweckt wurde: sofort umschalten
  portYIELD_FROM_ISR(higher_prio_woken);
}

while (true) {
  // Blockiert, bis die ISR das Signal gibt (0 % CPU beim Warten)
  event_signal.acquire();

  // Ab hier: normaler Task-Kontext — hier darf es dauern
  led_handler.on(0x12, 0xa1, 0x50);
  process_event();             // lange Berechnung ist ok
}

Software Timer

Eine Funktion (Callback) nach Ablauf einer Zeit ausführen — ohne dafür einen ganzen Task zu blockieren.

Ein Software Timer ruft nach Ablauf einer Frist automatisch einen Callback auf. Der Clou: es läuft keine eigene Warteschleife — der Timer-Dienst des Kernels verwaltet viele Timer effizient gemeinsam.

Der große Vorteil: dein Task kann in der Zwischenzeit etwas völlig anderes tun (oder schlafen) — die CPU ist frei.

Der Code — Schritt für Schritt

// Der Callback — wird vom Timer-Dienst aufgerufen
void OnTimerExpired(pw::chrono::SystemClock::time_point) {
  fire_count++;
  led_callback.toggle();          // z.B. LED umschalten
}

// Timer anlegen (SystemTimer bindet den Callback)
pw::chrono::SystemTimer timer(OnTimerExpired);

// EINMALIG nach 2 s feuern (One-Shot):
timer.InvokeAfter(std::chrono::milliseconds(2000));

// Für periodisches Verhalten: im Callback neu planen
void OnTick(pw::chrono::SystemClock::time_point) {
  do_periodic_work();
  timer.InvokeAfter(kPeriod);   // sich selbst neu einplanen
}

// Laufenden Timer vorzeitig abbrechen:
timer.Cancel();

Tracing & Perfetto

Was passiert wirklich zur Laufzeit? Mit Tracing zeichnest du Task-Wechsel & Ereignisse auf und analysierst sie auf einer Zeitachse.

Fachwort-Glossar

Englischer Fachbegriff, deutsche Übersetzung und eine kurze Erklärung. Durchsuch- und filterbar.

Quiz

Antwort wählen, prüfen — du bekommst sofort richtig/falsch mit Erklärung.

Offene Fragen

Formuliere zuerst selbst eine Antwort — dann decke die Musterlösung auf und vergleiche. Ideal fürs Klausurtraining.

Übungsaufgaben

Der Übungszettel zu Teil 2 — implementiere die Konzepte selbst im RTOS-Simulator und analysiere sie mit Perfetto.

Queues, Timeouts, Interrupts und Software Timer — mit Simulationen, Code und Quiz. Für die Klausur: geh das Quiz und die offenen Fragen so oft durch, bis du dir sicher bist.