Diese Datei ist der Dirigent des Projekts. Sie schreibt selbst fast keine Hardware an, sondern ruft die drei Module in der richtigen Reihenfolge auf und sorgt mit einer Endlosschleife dafür, dass das System dauerhaft auf den Joystick reagiert.

Hardware-Kontext: ATmega32, 8 MHz. Ziel: Du sollst nicht nur wissen dass die Schleife läuft, sondern warum sie genau so aufgebaut ist — besonders die Änderungserkennung.

1. Die Grundidee in einem Satz

2. Includes und globale Variablen (Kopf der Datei)

#define DELAY 100

int tmpcontroller = -1;
int frequency[AUDIO_NUM_FREQ][AUDIO_NUM_AMP][AUDIO_NUM_WAVE];

3. main() — Setup-Phase

int main() {
  setup_audio();
  setup_controller();
  setup_display();
  ...

Drei einmalige Initialisierungen, jede in ihrem eigenen Modul:

1. setup_audio() — Lautsprecher-Pins als Ausgang, Timer1 für die Tonerzeugung vorbereiten.
2. setup_controller() — USART (Debug), ADC im Free-Running-Modus, Joystick-Taster, und sei() (globale Interrupts ein). Ab hier laufen die ADC- und USART-Interrupts.
3. setup_display() — SPI + OLED initialisieren und das Startbild zeichnen.

4. Die Hauptschleife while(1) — Schritt für Schritt

4.1 Diagnose-Werte lesen (Debug)

int8_t x = adcLastRead(0);              // X-Achse, skaliert [-16, +16]
int8_t y = adcLastRead(1);              // Y-Achse, skaliert [-16, +16]
int8_t z = (PINA & (1 << 2)) ? 0 : 1;   // Taster: PA2, Low-aktiv
int controller = controller_status();   // fertige Richtung 0–5

x, y, z werden hier nur für die Debug-Ausgabe roh ausgelesen. Die eigentliche Auswertung steckt in controller_status(), das daraus eine einzelne Zahl macht:

0 = Mitte · 1 = Oben · 2 = Unten · 3 = Links · 4 = Rechts · 5 = Taster

4.2 Debug-Zeile über die serielle Schnittstelle senden

char buf[40];
snprintf(buf, sizeof(buf), "x=%d y=%d z=%d s=%d\r\n", x, y, z, controller);
usartWriteString(buf);

snprintf baut sicher (mit Längenbegrenzung) einen String wie x=3 y=-12 z=0 s=2 und schickt ihn per USART (9600 Baud) an den PC. Das ist reines Werkzeug zum Fehlersuchen.

4.3 Das Herzstück: Änderungserkennung (tmpcontroller)

if (controller == tmpcontroller) {
    _delay_ms(DELAY);
    continue;                 // nichts hat sich geändert -> nichts tun
} else {
    tmpcontroller = controller;
    update_display(controller, frequency);   // erst Display + Array
    update_audio(frequency);                 // dann Ton
}
_delay_ms(DELAY);

Das ist die wichtigste Stelle der Datei. Sie vergleicht die aktuelle Richtung mit der vom letzten Durchlauf:

— Gleich (controller == tmpcontroller) → continue: 100 ms warten und von vorne. Display und Audio werden nicht angefasst.
— Verschieden → neue Richtung merken, dann update_display(...) und update_audio(...).

5. Die zwei Ebenen der Flankenerkennung (Prüfungsklassiker!)

Es gibt im Projekt zwei unabhängige Mechanismen, die verhindern, dass ein gehaltener Joystick endlos weiterzählt.

6. Ablauf als Bild

 ┌─────────────────────────────────────────────────────────────┐
 │  setup_audio()  setup_controller()  setup_display()          │  einmalig
 └─────────────────────────────────────────────────────────────┘
                              │
                  ┌───────────▼───────────┐
                  │   while(1)  (alle 100ms) │
                  └───────────┬───────────┘
                              ▼
              controller = controller_status()        (0–5)
                              │
              Debug: "x=.. y=.. z=.. s=.."  → USART
                              │
                 controller == tmpcontroller ?
                   ┌──── ja ──┴── nein ────┐
                   ▼                       ▼
              100 ms warten        tmpcontroller = controller
              (nichts tun)         update_display(controller, frequency)
                   │               update_audio(frequency)
                   └───────────┬───────────────────────┘
                               ▼
                          100 ms warten → zurück nach oben

7. Typische Prüfungsfragen (Selbsttest)

Diese Datei erklärt den Teil des Projekts, der den Joystick und den Taster ausliest: src/controller.c, include/controller.h sowie die ADC-Hilfsfunktionen in src/adc.c / include/adc.h.

Was macht das Controller-Modul?

Der Joystick gibt zwei analoge Spannungen aus (X-Achse und Y-Achse) und hat zusätzlich einen digitalen Taster (Z-Achse, „drücken"). Das Modul liest diese drei Eingaben aus und liefert einen einzigen Zahlenwert (0–5), der angibt, was der Benutzer gerade tut:

Hardware-Anschlüsse

Joystick-Pin   → ATmega32-Pin   Funktion
─────────────────────────────────────────
VRx  (X-Achse) →  PA0 / ADC0    Analoge Spannung 0–5 V
VRy  (Y-Achse) →  PA1 / ADC1    Analoge Spannung 0–5 V
SW   (Taster)  →  PA2            Digitaler Eingang (Low-aktiv)

ADC — Was ist das und wie funktioniert Free-Running?

Der ADC (Analog-Digital-Converter) wandelt eine Spannung (analog, 0–5 V) in eine Zahl um. Beim ATmega32 liefert er Werte von 0 bis 1023 (10 Bit):

  0 V  →   0
  2,5 V →  511
  5 V  → 1023

Im Free-Running-Modus läuft der ADC kontinuierlich: Er wandelt Kanal 0 (X), dann Kanal 1 (Y), dann wieder Kanal 0, usw. – automatisch und im Hintergrund. Sobald eine Wandlung fertig ist, springt der Prozessor kurz in die ISR (ISR(ADC_vect) in adc.c), speichert den Wert, und kehrt dann zum Hauptprogramm zurück.

Warum Prescaler /32?

Der ADC-Takt muss laut Datenblatt zwischen 50 kHz und 200 kHz liegen für volle 10-Bit-Genauigkeit. Da wir nur 33 Stufen (−16 bis +16, also ~5 Bit) brauchen, darf der Takt höher sein.

CPU-Takt: 8 MHz
Prescaler /32 → ADC-Takt: 250 kHz → eine Wandlung dauert ~52 µs

Kalibrierung: ADC_X_CENTER_RAW und ADC_Y_CENTER_RAW

Im Ruhezustand sollte der ADC theoretisch 512 liefern (Mitte von 0–1023). In der Praxis weicht das ab, weil der Joystick mechanisch nicht perfekt mittig ist.

Durch Messen wurde festgestellt:

— X-Achse im Ruhezustand: ca. 687 statt 512
— Y-Achse im Ruhezustand: ca. 495 statt 512

#define ADC_X_CENTER_RAW 687
#define ADC_Y_CENTER_RAW 495

adcScale() — Rohwert auf [−16, +16] umrechnen

Die Funktion adcScale(raw, center) in adc.c rechnet den ADC-Rohwert (0–1023) in einen skalierten Wert (−16 bis +16) um, wobei der gemessene Ruhewert (center) als Nullpunkt gilt.

  raw < center → linke Seite:  -(center - raw) × 16 / center
  raw > center → rechte Seite:  (raw - center) × 16 / (1023 - center)

Beispiel für X-Achse (center = 687):

  raw =   0 → -(687 -   0) × 16 / 687 = -16  (voller Ausschlag links)
  raw = 687 → 0                              (Ruhelage)
  raw = 1023 → (1023 - 687) × 16 / 336 = +16  (voller Ausschlag rechts)

setup_controller() — Initialisierung

void setup_controller(void)

Diese Funktion wird einmal beim Start in main.c aufgerufen. Sie:

1. Richtet die USART-Schnittstelle ein (9600 Baud, 8N1) → für Debug-Ausgaben
2. Startet den ADC im Free-Running-Modus → X/Y werden ab jetzt dauerhaft gemessen
3. Konfiguriert PA2 als Eingang mit internem Pull-up → für den Joystick-Taster
4. Schaltet mit sei() die globalen Interrupts frei → ISRs können jetzt laufen

controller_status() — Joystick auswerten

int controller_status(void)

Diese Funktion wird im Hauptprogramm regelmäßig aufgerufen (alle 100 ms).

Schritt 1: Werte lesen

int8_t x = adcLastRead(0);  // X-Achse: -16 (links) bis +16 (rechts)
int8_t y = adcLastRead(1);  // Y-Achse: -16 (unten) bis +16 (oben)
int8_t z = (PINA & Bit(2)) ? 0 : 1;  // Taster: 0 = offen, 1 = gedrückt

Schritt 2: Taster hat Vorrang

if (z == 1) return 5;

Schritt 3: Richtungserkennung

Die Schwelle von ±10 sorgt dafür, dass kleine Wackler in der Mitte nicht als Richtung gezählt werden. Die Bedingung auf der Gegenachse (±6) verhindert, dass Diagonalbewegungen als zwei Richtungen erkannt werden:

  x ≥ +10  und  |y| ≤ 6  → Rechts (4)
  x ≤ -10  und  |y| ≤ 6  → Links  (3)
  y ≤ -10  und  |x| ≤ 6  → Unten  (2)
  y ≥ +10  und  |x| ≤ 6  → Oben   (1)
  sonst                   → Mitte  (0)

Visualisierung der Schwellwerte:

         y ≥ +10
         ↑ Oben (1)
         |
x ≤ -10 ← ·Mitte· → x ≥ +10
 Links(3)  |          Rechts(4)
           ↓
         y ≤ -10
         Unten (2)

Zusammenspiel mit dem Rest des Projekts

main.c
  │
  ├── setup_controller()   → initialisiert ADC + USART + Taster
  │
  └── (Loop alle 100 ms)
        │
        ├── controller_status()  → liefert 0–5
        │
        ├── update_display(status, ...)   → display.c: ändert Frequenz/Amplitude/Waveform
        └── update_audio(frequency[...]) → audio.c:   spielt Ton ab

Dieses Dokument erklärt die audio.c Zeile für Zeile bzw. abschnittsweise. Hardware-Kontext: ATmega32, 8 MHz Takt. Tonerzeugung läuft komplett über Timer1 als Hardware-PWM. Die CPU muss im laufenden Betrieb nichts tun — der Timer schaltet die Lautsprecher-Pins selbstständig im richtigen Takt.

1. Die Grundidee

Ein Lautsprecher macht ein Geräusch, wenn sich die Spannung an ihm schnell ändert. Schalten wir einen Pin sehr schnell zwischen high (5 V) und low (0 V) um, entsteht ein Pulssignal:

Spannung
 5V  ┌────┐    ┌────┐    ┌────┐
     │    │    │    │    │    │
 0V ─┘    └────┘    └────┘    └──   →  Zeit
     <-T-> = eine Periode = 1 / Frequenz

— Schnelles Umschalten → hoher Ton.
— Langsames Umschalten → tiefer Ton.
Das ist die erste Stellschraube: die Frequenz. Die zweite Stellschraube ist die Pulsweite (das Tastverhältnis) — wie lange der Pin pro Periode high gegenüber low bleibt. Sie ändert nicht die Tonhöhe, sondern den Obertongehalt und damit die Klangfarbe.

2. Die #define-Konstanten

#define F_CPU      8000000UL
#define PRESCALER  8UL

#include "note.h"   // liefert NOTE_NONE = 5000

Ein Sondersignal: Wenn in einer Zelle der Wert 5000 steht, bedeutet das „kein Ton / Pause". Das UL hinter Zahlen in den Formeln weiter unten heißt Unsigned Long — es zwingt den Compiler, mit großen vorzeichenlosen 32-Bit-Zahlen zu rechnen.

3. Das Datenmodell (frequency[7][11][3])

int frequency[AUDIO_NUM_FREQ][AUDIO_NUM_AMP][AUDIO_NUM_WAVE];
//                  7              11             3

4. setup_audio() — die einmalige Einrichtung

4.1 Pins auf Ausgang schalten

AUDIO_SPK1_DDR |= (1 << AUDIO_SPK1_PIN);
AUDIO_SPK2_DDR |= (1 << AUDIO_SPK2_PIN);

DDRx = Data Direction Register. Ein Bit auf 1 = der Pin ist ein Ausgang. (1 << PIN) erzeugt eine Maske mit genau dem einen gesetzten Bit, |= setzt dieses Bit ohne die anderen Pins zu verändern.

4.2 Timer1 konfigurieren

TCCR1A = (1 << WGM11);
TCCR1B = (1 << WGM13) | (1 << WGM12) | (1 << CS11);

5. update_audio() — der eigentliche Ablauf

Diese Funktion arbeitet in 5 logischen Schritten:

Schritt 1 — Aktive Zelle suchen

for (uint8_t f = 0; f < AUDIO_NUM_FREQ; f++)
  for (uint8_t a = 0; a < AUDIO_NUM_AMP; a++)
    for (uint8_t w = 0; w < AUDIO_NUM_WAVE; w++)
      if (frequency[f][a][w] != 0) {
          active_f = f; active_a = a; active_w = w;
          note_tenth_hz = frequency[f][a][w];
          goto cell_found;
      }
cell_found:

Schritt 2 — Stumm-Fälle abfangen

if (note_tenth_hz == 0
    || active_a == 0
    || note_tenth_hz == NOTE_NONE) {
    TCCR1A &= ~((1 << COM1A1) | (1 << COM1B1));
    AUDIO_SPK1_PORT &= ~(1 << AUDIO_SPK1_PIN);
    AUDIO_SPK2_PORT &= ~(1 << AUDIO_SPK2_PIN);
    return;
}

In drei Fällen soll es still bleiben: kein aktive Zelle gefunden, Amplitude ist null, oder das „kein Ton"-Sondersignal (5000).

Schritt 3 — Tonhöhe → TOP-Wert ICR1

uint16_t top = (uint16_t)((F_CPU * 10UL)
                   / (PRESCALER * (uint32_t)note_tenth_hz) - 1UL);
ICR1 = top;

Grundformel mit echter Frequenz f:

       F_CPU
ICR1 = ───────────── − 1
       PRESCALER · f

Setzt man f = note_tenth_hz / 10 ein, wandert die 10 in den Zähler:

             F_CPU · 10
ICR1 = ───────────────────────── − 1
        PRESCALER · note_tenth_hz

Rechenbeispiel für 440,0 Hz (note_tenth_hz = 4400):

ICR1 = (8 000 000 · 10) / (8 · 4400) − 1
     = 80 000 000 / 35 200 − 1
     ≈ 2272 − 1 = 2271

Schritt 4 — Wellenform

uint8_t duty_shift;
switch (active_w) {
    case AUDIO_WAVE_SIN:    duty_shift = 1; break;  // 50%
    case AUDIO_WAVE_SQUARE: duty_shift = 2; break;  // 25%
    case AUDIO_WAVE_SAW:    duty_shift = 3; break;  // 12,5%
    default:                duty_shift = 1; break;
}
uint16_t duty = (uint16_t)((top + 1U) >> duty_shift);
OCR1A = duty;
OCR1B = duty;

TCCR1A |= (1 << COM1A1);

Schritt 5 — Lautstärke über Anzahl der Lautsprecher

if (active_a >= 6) {
    TCCR1A |= (1 << COM1B1);          // Speaker 2 dazuschalten
} else {
    TCCR1A &= ~(1 << COM1B1);         // Speaker 2 aus
    AUDIO_SPK2_PORT &= ~(1 << AUDIO_SPK2_PIN);
}

6. Zusammenfassung des Datenflusses

  3D-Array frequency[f][a][w]   (genau eine Zelle ≠ 0)
              │
              ▼
   update_audio()
   ├─ 1. aktive Zelle suchen        →  note_tenth_hz, active_a, active_w
   ├─ 2. stumm?  ── ja ──► Timer-Ausgänge aus, Pins low, return
   │        │ nein
   ├─ 3. ICR1 = Frequenz (TOP)       →  bestimmt Tonhöhe
   ├─ 4. switch(wave)                →  OCR1A/OCR1B = Tastverhältnis (Duty)
   └─ 5. amplitude ≥ 6 ?             →  Speaker 2 dazu (lauter)
              │
              ▼
   Timer1 erzeugt Pulssignal an PD5 (+ ggf. PD4) autonom  →  hörbarer Ton

7. Typische Prüfungsfragen (Selbsttest)

Dieses Modul ist das größte des Projekts. Es hat zwei Jobs:

1. Das OLED ansteuern — einen SH1106-Controller über SPI mit Bildinhalt füttern.
2. Den App-Zustand verwalten — sich merken, welche Tonhöhe/Lautstärke/Wellenform eingestellt ist, diesen Zustand auf Joystick-Eingaben verändern und ihn in das gemeinsame frequency-Array für audio.c schreiben.

Hardware: ATmega32, 8 MHz, OLED-Controller SH1106, 128×64 Pixel.

1. Pin-Belegung

#define DISPLAY_RESET_PIN     PB3   // RES  -> Display sauber zurücksetzen
#define DISPLAY_DATA_CMD_PIN  PB4   // D/C  -> LOW=Befehl, HIGH=Pixeldaten
#define DISPLAY_SPI_MOSI_PIN  PB5   // DIN  -> SPI-Daten (Master Out)
#define DISPLAY_SPI_MISO_PIN  PB6   // (unbenutzt, nur Eingang)
#define DISPLAY_SPI_SCK_PIN   PB7   // CLK  -> SPI-Takt
// CS liegt fest auf GND -> kein eigener Pin nötig

2. SPI — wie ein Byte zum Display kommt

static void display_spi_setup(void) {
    DDRB |= (1 << MOSI) | (1 << SCK);   // MOSI + SCK = Ausgang
    DDRB &= ~(1 << MISO);               // MISO = Eingang
    SPCR = (1 << SPE) | (1 << MSTR);    // SPI an, Master
    SPSR = (1 << SPI2X);                // doppelte Geschwindigkeit -> 4 MHz
}

SPI schiebt Daten bitweise synchron zum Takt SCK hinaus. Bei F_CPU = 8 MHz und SPI2X ergibt sich 4 MHz SPI-Takt (Mode 0, MSB first).

static uint8_t display_spi_transfer_byte(uint8_t data) {
    SPDR = data;                          // Schreiben startet die Übertragung
    while (!(SPSR & (1 << SPIF))) { }     // warten bis Hardware fertig (SPIF)
    return SPDR;
}

3. Der SH1106 in „Pages" — wie das Display organisiert ist

Eine Page = 8 Pixel HOCH, 132 Spalten breit.
page 0 -> y 0..7      page 4 -> y 32..39
page 1 -> y 8..15     page 5 -> y 40..47
page 2 -> y 16..23    page 6 -> y 48..55
page 3 -> y 24..31    page 7 -> y 56..63

Ein Datenbyte beschreibt 8 senkrecht übereinanderliegende Pixel einer Page (Bit 0 oben, Bit 7 unten).

4. Der Framebuffer — und der clevere Bit-Trick (Prüfungs-Highlight!)

static uint64_t display_frame_buffer[DISPLAY_PIXEL_WIDTH];  // 128 Spalten

Wir zeichnen nicht direkt aufs Display, sondern erst in diesen RAM-Puffer:

— Ein uint64_t = eine komplette senkrechte Spalte mit 64 Pixeln.
— Bit y = Pixel (x, y). Also: display_frame_buffer[x] |= 1ULL << y; setzt den Pixel bei Spalte x, Zeile y.

Wie wird daraus eine Page für den SH1106?

uint8_t *first_page_column = ((uint8_t *)display_frame_buffer) + page;
for (uint8_t x = 0; x < DISPLAY_PIXEL_WIDTH; x++) {
    display_spi_transfer_byte(*(first_page_column + DISPLAY_PAGES * x));
}

Der Puffer ist uint64_t[128] — wir betrachten ihn als Byte-Array ((uint8_t *)). Jede Spalte belegt 8 Bytes. Für Spalte x liegen die Bytes 8·x … 8·x+7. Der Code liest für eine bestimmte Page das Byte an Index 8·x + page.

uint64_t einer Spalte x:   Bits  0..7   8..15  16..23 ... 56..63
                            └ Byte 0 ┘ └ Byte 1 ┘ ...   └ Byte 7 ┘
y-Pixel:                    y0..y7     y8..y15        ...  y56..y63
SH1106-Page:               Page 0     Page 1         ...  Page 7

5. Zeichen-Primitive

display_draw_pixel(x, y);                  // Bit in fb[x] setzen (+ Bereichscheck)
display_draw_vertical_line(x, y1, y2);     // y1,y2 sortieren, dann Bits setzen
display_draw_horizontal_line(x1, x2, y);   // x1,x2 sortieren, dann zeichnen
display_clear_buffer();                    // alle 128 Spalten = 0

Alle Zeichenoperationen verändern nur den RAM-Puffer. Erst display_update_hardware() macht sie auf dem echten OLED sichtbar.

6. Die Wellenform zeichnen

6.1 Sample → Y-Pixel

static uint8_t display_sample_to_y(int16_t sample) {       // sample: -127..+127
    int16_t pixel_amplitude =
        (DISPLAY_MAX_WAVE_AMPLITUDE * display_state.amplitude_index) / DISPLAY_MAX_AMPLITUDE_INDEX;
    int16_t y = DISPLAY_CENTER_Y - ((sample * pixel_amplitude) / 127);
    return display_clamp_y(y);             // auf [WAVE_TOP=16 .. WAVE_BOTTOM=60] begrenzen
}

Wichtige Konstanten: CENTER_Y = (16+60)/2 = 38, MAX_WAVE_AMPLITUDE = (60−16)/2 = 22, MAX_AMPLITUDE_INDEX = 10.

6.2 Die drei Wellenformen (rein optisch)

case AUDIO_WAVE_SIN:    sample = display_sine_lut[x % 32];                 break;
case AUDIO_WAVE_SQUARE: sample = ((x % 32) < 16) ? 127 : -127;            break;
case AUDIO_WAVE_SAW:    sample = ((int16_t)((x % 32) * 255) / 31) - 127;  break;

7. Die Mini-Schrift (3×5-Font) für die Statuszeile

Oben am Display steht z.B. SIN A:5 F:349. Dafür gibt es einen winzigen 3 Pixel breiten, 5 Pixel hohen Font. display_draw_uint() zerlegt eine Zahl rückwärts in Ziffern (über % 10 und / 10) und zeichnet sie dann wieder vorwärts.

8. Der komplette Bildaufbau

static void display_render_current_state(void) {
    display_generate_waveform_pixels();   // 1. Y-Werte der Kurve berechnen
    display_clear_buffer();               // 2. Puffer leeren
    display_draw_status();                // 3. Statuszeile oben
    display_draw_horizontal_line(0, 127, DISPLAY_STATUS_HEIGHT);  // 4. Trennlinie bei y=12
    display_draw_waveform();              // 5. Kurve
    display_update_hardware();            // 6. alles ans OLED schicken
}

Jedes Bild wird komplett neu gebaut (kein teilweises Update). Bei 128×64 Pixeln ist das schnell genug.

9. Zustand & Eingabe-Logik

9.1 Der gemerkte Zustand

typedef struct {
    uint8_t frequency_index;   // 0..6  -> welche Tonhöhe aus display_notes_tenth_hz[]
    uint8_t amplitude_index;   // 0..10 -> Lautstärke (0 = stumm)
    uint8_t waveform_index;    // 0=Sin, 1=Rechteck, 2=Säge
} DisplayState;
// Startwerte: frequency_index=3, amplitude_index=5, waveform_index=0 (Sinus)

Die 7 Tonhöhen (in 1/10 Hz):

display_notes_tenth_hz[7] = { 2616, 2937, 3296, 3492, 3920, 4400, 4939 };
//   Index:                    C4    D4    E4    F4    G4    A4    B4

9.2 Eingabe → Zustandsänderung (display_step_state())

case UP:    if (amplitude_index < 10) amplitude_index++;          break;  // lauter
case DOWN:  if (amplitude_index > 0)  amplitude_index--;          break;  // leiser (0=stumm)
case LEFT:  frequency_index = (frequency_index==0) ? 6 : frequency_index-1;  break;
case RIGHT: frequency_index++; if (frequency_index>=7) frequency_index=0;    break;
case SELECT:waveform_index++;  if (waveform_index>=3) waveform_index=0;      break;

— Hoch/Runter → Lautstärke (mit Grenzen 0 und 10, kein Umlauf).
— Links/Rechts → Tonhöhe (mit Umlauf: nach dem letzten Slot wieder zum ersten).
— Taster (SELECT) → Wellenform durchschalten (0→1→2→0).

9.3 update_display() — der Einstieg aus main.c

void update_display(int controller, int frequency[7][11][3]) {
    DisplayInput input = display_is_valid_input(controller) ? (DisplayInput)controller : CENTER;

    if (input != CENTER && input != last_input)   // Flankenerkennung im Modul
        display_step_state(input);
    last_input = input;

    display_apply_state(frequency);   // Zustand -> One-Hot-Array (Nachricht an Audio)
    display_render_current_state();   // OLED neu zeichnen
}

9.4 Das One-Hot-Array bauen

static void display_apply_state(DisplayFrequencyTable frequency) {
    display_clear_frequency(frequency);                 // ALLES auf 0
    frequency[frequency_index][amplitude_index][waveform_index]
        = display_notes_tenth_hz[frequency_index];      // genau EINE Zelle setzen
}

10. Initialisierung setup_display()

display_spi_setup();
DDRB |= (1<<RESET) | (1<<DATA_CMD);
display_reset();
display_send_command(SET_DISPLAY_OFF);
display_set_contrast(128);
display_send_command(CHARGEPUMP); display_send_command(0x14);  // interne Hochspannung AN
display_clear_buffer(); display_update_hardware();
display_send_command(SET_DISPLAY_ON);

12. Typische Prüfungsfragen (Selbsttest)