MINT lernen

Mikrocontroller programmieren

Wie bringt man einem Chip, kleiner als ein Fingernagel, bei, im richtigen Takt zu blinken?

1

Ein Computer auf einem Chip

Ein Mikrocontroller steckt in Waschmaschine, Fahrradtacho oder Ampel — ein kompletter kleiner Computer auf einem einzigen Chip.

  • Prozessor:führt das Programm Befehl für Befehl aus, im Takt eines Taktgebers.
  • RAM:Arbeitsspeicher für Variablen — verliert seinen Inhalt ohne Strom.
  • Flash:Programmspeicher — das Programm bleibt auch ohne Strom erhalten.
  • Pins:Ein- und Ausgänge; ein digitaler Pin kennt nur HIGH (5 V) und LOW (0 V).
  • Arduino Uno:Platine mit dem Mikrocontroller ATmega328P: 16 MHz Takt, 2 KB RAM, 32 KB Flash (davon 0,5 KB für den Bootloader), 14 digitale Pins, eingebaute LED an Pin 13.
  • Größenvergleich:Ein Laptop mit 16 GB RAM hat rund acht Millionen Mal so viel Arbeitsspeicher.

Ein Arduino-Programm heißt Sketch und wird in C++ geschrieben. Statt main gibt es zwei Funktionen:

C++ · blink.ino
void setup() {
  pinMode(13, OUTPUT);         // Pin 13 als Ausgang
}

void loop() {
  digitalWrite(13, HIGH);      // 5 V an Pin 13: LED an
  delay(200);                  // 200 ms warten
  digitalWrite(13, LOW);       // 0 V: LED aus
  delay(300);                  // 300 ms warten
}
  • setup():läuft einmal nach dem Einschalten oder Reset — hier werden die Pins eingestellt.
  • loop():wird danach endlos immer wieder aufgerufen.
  • pinMode:pinMode(13, OUTPUT) macht Pin 13 zum Ausgang.
  • digitalWrite:HIGH legt 5 V an den Pin, LOW 0 V.
  • delay:delay(200) wartet 200 Millisekunden — in dieser Zeit tut der Controller nichts anderes.
  • Hochladen:Die Arduino-IDE übersetzt den Sketch auf dem PC in Maschinencode für den ATmega328P und überträgt ihn per USB in den Flash. Danach läuft er auch ohne PC.
Merke

Sketch: setup() einmal, dann loop() endlos. Übersetzt wird auf dem PC, ausgeführt auf dem Mikrocontroller.

2

Taster lesen, Takt berechnen

Ein Taster zwischen Pin 2 und GND schaltet die LED — dank INPUT_PULLUP ohne zusätzlichen Widerstand:

C++ · taster.ino
void setup() {
  pinMode(13, OUTPUT);
  pinMode(2, INPUT_PULLUP);    // Taster zwischen Pin 2 und GND
}

void loop() {
  if (digitalRead(2) == LOW) { // gedrückt = LOW
    digitalWrite(13, HIGH);
  } else {
    digitalWrite(13, LOW);
  }
}
  • INPUT_PULLUP:schaltet einen eingebauten Widerstand (etwa 20–50 kΩ) nach 5 V zu — der offene Pin liest sicher HIGH.
  • Gedrückt:Der Taster verbindet Pin 2 mit GND → digitalRead(2) liefert LOW.
  • Losgelassen:Der Widerstand zieht den Pin auf 5 V → HIGH. Die Logik ist also umgedreht.
  • Periode:Beim Blinken wiederholt sich das Muster; eine Wiederholung dauert die Periodendauer \(T\).
  • Frequenz:\(f\) gibt an, wie oft pro Sekunde sich das Muster wiederholt; Einheit Hertz: \(1\,\text{Hz} = 1\,\tfrac{1}{\text{s}}\).
Herleitung:
\(T = t_{\text{an}} + t_{\text{aus}}\)
Periode

Eine Periode = einmal an + einmal aus, danach beginnt loop() von vorn.

\(T = 200\,\text{ms} + 300\,\text{ms} = 500\,\text{ms} = 0{,}5\,\text{s}\)
einsetzen

Werte aus blink.ino oben.

\(n = \dfrac{t}{T} = \dfrac{10\,\text{s}}{0{,}5\,\text{s}} = 20\)
Blinks in 10 s

In \(t = 10\,\text{s}\) passen 20 Perioden — die LED blinkt 20-mal.

\(f = \dfrac{n}{t} = \dfrac{t/T}{t} = \dfrac{1}{T}\)
pro Sekunde

Blinks pro Sekunde: \(t\) kürzt sich weg, übrig bleibt der Kehrwert von \(T\).

\(f = \dfrac{1}{0{,}5\,\text{s}} = 2\,\tfrac{1}{\text{s}} = 2\,\text{Hz}\)
Ergebnis

Die LED blinkt zweimal pro Sekunde.

Lies den Sketch und markiere auf der Zeitleiste jedes 250-ms-Kästchen, in dem die LED leuchtet (Klick oder Enter, Pfeiltasten wandern). Prüfen vergleicht, ▶ spielt 4 Sekunden auf dem Board ab.

Blinkmuster auf der Zeitleiste

C++ · Sketch A
Messwerte
Leuchtzeit tan?
Dunkelzeit taus?
Periodendauer T?
Frequenz f?
Leuchtphasen in 4 s?

Die Werte erscheinen, sobald deine Zeitleiste stimmt.

Halte fest: Eine Periode ist ein kompletter Durchlauf von loop() — T ist die Summe aller Wartezeiten darin. A und B haben dieselbe Periode (1 s, f = 1 Hz), nur das Verhältnis von an zu aus unterscheidet sich; C blitzt zweimal pro Periode und hat T = 2 s.

Merke

Blinktakt: \(T = t_{ ext{an}} + t_{ ext{aus}}\) (Summe aller Wartezeiten in loop()), \(f = \dfrac{1}{T}\) in Hz. Taster mit INPUT_PULLUP: gedrückt = LOW.

3

Allgemeine Hinweise

Letztes delay nicht vergessen

Fehlt nach digitalWrite(13, LOW); das delay, springt loop() sofort wieder auf HIGH — die LED scheint dauernd zu leuchten.

Gedrückt heißt LOW

Mit INPUT_PULLUP ist die Logik umgedreht. Nur INPUT ohne Widerstand liefert bei offenem Taster zufällige Werte.

delay blockiert

Während delay(1000) reagiert der Controller auf keinen Taster. Wer gleichzeitig blinken und lesen will, nutzt später millis() (Millisekunden seit dem Start).

Videos