ESP32

In diesem Beitrag zeigen wir, wie sich ein einfaches Projekt – eine Temperaturanzeige mit LED-Ausgabe – über die letzten zwei Jahrzehnte entwickelt hat. Dabei geht es nicht nur um die Programmierung, sondern auch um die rasante Entwicklung der Hardware: Vom großen DIP-AVR mit externem Programmer bis hin zu kompakten All-in-One-Boards wie dem ESP8266 oder ESP32.

Was macht das Projekt?

Ein DHT11-Sensor misst die Temperatur. Zwei LEDs zeigen den Wert an – entweder in Helligkeitsstufen oder als An/Aus-Anzeige. Die Helligkeit wird per PWM geregelt, sodass die Temperatur visuell erkennbar ist.

Variante 1: AVR-C auf dem Pollin ATmega32-Board

Technikstand: ca. 2000–2005
Diese Variante kommt ohne Bibliotheken aus und verwendet direkte Registerzugriffe. Die PWM wird über Timer0 realisiert, der DHT11 per Bit-Banging abgefragt.

Hardware: Pollin ATmega32 Evaluationsboard mit 16 MHz Quarz, DHT11 an PC0, LED an PD6 (OC0)

#define F_CPU 16000000UL

#include <avr/io.h>
#include <util/delay.h>
#include <stdint.h>
#include <stdbool.h>

#define DHT_DDR  DDRC
#define DHT_PORT PORTC
#define DHT_PIN  PINC
#define DHT_INPUTPIN PC0

uint8_t read_dht11(uint8_t *temperature) {
    uint8_t bits[5] = {0};
    uint8_t i, j;

    // Start signal
    DHT_DDR |= (1 << DHT_INPUTPIN);
    DHT_PORT &= ~(1 << DHT_INPUTPIN);
    _delay_ms(20); // >18ms
    DHT_PORT |= (1 << DHT_INPUTPIN);
    _delay_us(40);
    DHT_DDR &= ~(1 << DHT_INPUTPIN);

    // Wait for DHT11 response
    _delay_us(80);
    if (DHT_PIN & (1 << DHT_INPUTPIN)) return 1;
    _delay_us(80);
    if (!(DHT_PIN & (1 << DHT_INPUTPIN))) return 2;

    // Read 5 bytes
    for (j = 0; j < 5; j++) {
        for (i = 0; i < 8; i++) {
            while (!(DHT_PIN & (1 << DHT_INPUTPIN))); // wait for high
            _delay_us(30);
            if (DHT_PIN & (1 << DHT_INPUTPIN))
                bits[j] |= (1 << (7 - i));
            while (DHT_PIN & (1 << DHT_INPUTPIN)); // wait for low
        }
    }

    // Checksum
    if ((uint8_t)(bits[0] + bits[1] + bits[2] + bits[3]) != bits[4]) return 3;

    *temperature = bits[2]; // whole °C from byte 3
    return 0;
}

void init_pwm_timer0(void) {
    DDRD |= (1 << PD6);               // OC0 (PD6) als Ausgang
    TCCR0 = (1 << WGM00) | (1 << WGM01) // Fast PWM
          | (1 << COM01);              // Non-inverting
    TCCR0 |= (1 << CS01);              // Prescaler 8 → 16MHz/8 = 2MHz
}

int main(void) {
    uint8_t temp = 0;

    init_pwm_timer0();

    while (1) {
        if (read_dht11(&temp) == 0) {
            // Begrenzung des Temperaturbereichs auf 20–30°C
            if (temp < 20) temp = 20;
            if (temp > 30) temp = 30;

            // Mapping 20°C–30°C auf PWM 0–255
            OCR0 = (temp - 20) * 25;
        } else {
            OCR0 = 0; // Fehler → LED aus
        }

        _delay_ms(1000); // Messrate ca. 1 Hz
    }
}

Diese Art der Mikrocontroller-Programmierung war damals Standard und bot maximale Kontrolle bei minimaler Abstraktion. Externe Programmer wie LPT-Adapter waren damals die einzige Option – der heute beliebte USBasp kam erst später auf den Markt, ab etwa 2005. In den frühen 2000ern wurden oft selbst gelötete Parallelport-Programmieradapter eingesetzt, die direkt über PonyProg oder einfache Bit-Banging-Tools angesteuert wurden., um den Code überhaupt auf den Chip zu bekommen. Komfort: Fehlanzeige.

Variante 2: ESP8266 mit Arduino-C++

Technikstand: 2015 bis heute
Hier nutzen wir moderne Bibliotheken wie DHT.h von Adafruit, komfortable Methoden wie analogWrite() und deutlich mehr Rechenleistung.

Hardware: ESP8266 (z. B. NodeMCU oder Wemos D1 Mini), DHT11 an D4 (GPIO2), LED an D5 (GPIO14)

#include <DHT.h>

#define DHTPIN D4      // GPIO2
#define LEDPIN D5      // GPIO14
#define DHTTYPE DHT11

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  pinMode(LEDPIN, OUTPUT);
  analogWriteRange(255);  // Standard für PWM auf ESP8266
  dht.begin();
}

void loop() {
  float temp = dht.readTemperature();

  if (!isnan(temp)) {
    // Mapping 20–30°C → 0–255 PWM
    int pwm = constrain((temp - 20) * 25, 0, 255);
    analogWrite(LEDPIN, pwm);
  } else {
    analogWrite(LEDPIN, 0); // Sensorfehler → LED aus
  }

  delay(1000);
}

Die Programmierung erfolgt per USB, ohne externen Programmer. Flashen, Debuggen und sogar OTA-Updates (Over The Air) sind möglich.

Variante 3: ESP8266 mit MicroPython

Technikstand: Minimalismus trifft Moderne
In nur wenigen Zeilen Python erreichen wir dasselbe Ergebnis. Ideal für alle, die lieber in Skriptsprachen arbeiten. Die MicroPython-Firmware wird per USB oder OTA aufgespielt und kann direkt über REPL oder Webinterface gesteuert werden.

Hardware: wie Variante 2

import dht
import machine
import time

sensor = dht.DHT11(machine.Pin(2))  # GPIO2 = D4
led = machine.PWM(machine.Pin(14))  # GPIO14 = D5
led.freq(1000)

while True:
    try:
        sensor.measure()
        temp = sensor.temperature()

        pwm = int((temp - 20) * 25)
        pwm = max(0, min(255, pwm))

        led.duty(pwm)
    except OSError:
        led.duty(0)  # Fehler → LED aus

    time.sleep(1)

Lesbarkeit und Einfachheit stehen hier im Vordergrund. Mehr zur MicroPython-Umgebung auf der offiziellen Seite: micropython.org

Variante 4: Assembler auf dem ATmega32

Technikstand: Nerd-Level over 9000
Wer maximale Kontrolle will (und den Schmerz nicht scheut), kann das Ganze auch in Assembler schreiben. Hier definieren wir die Bitmuster für Timer, LED und Sensorzugriff direkt.

.include "m32def.inc"     ; Register-Definitionen für ATmega32

; --------------------------------------------------------
; OC0 (PD6) = PWM-Ausgang für LED
; --------------------------------------------------------

        .org 0x00
        rjmp RESET

; --------------------------------------------------------
; Reset-Vektor
; --------------------------------------------------------

RESET:
        ; Stackpointer setzen
        ldi r16, high(RAMEND)
        out SPH, r16
        ldi r16, low(RAMEND)
        out SPL, r16

        ; PD6 (OC0) als Ausgang
        sbi DDRD, PD6

        ; Timer0: Fast PWM, non-inverting, prescaler 64
        ldi r16, (1<<WGM00)|(1<<WGM01)|(1<<COM01)|(1<<CS01)|(1<<CS00)
        out TCCR0, r16

        ; Initiale Helligkeit
        ldi r16, 0
        out OCR0, r16

MAIN:
        ; Erhöhe PWM-Wert langsam
        ldi r17, 0        ; Zähler

LOOP:
        mov r16, r17
        out OCR0, r16     ; PWM-Wert setzen

        rcall DELAY

        inc r17
        cpi r17, 255
        brne LOOP

        rjmp MAIN

; --------------------------------------------------------
; Einfache Delay-Routine (Software-Delay)
; --------------------------------------------------------

DELAY:
        ldi r18, 20
DELAY1: ldi r19, 255
DELAY2: dec r19
        brne DELAY2
        dec r18
        brne DELAY1
        ret

Diese Variante ist nichts für Einsteiger, aber hervorragend geeignet, um zu verstehen, wie Mikrocontroller intern arbeiten. Eine gute Referenz für Assembler-Einsteiger bietet AVR Freaks und die Original-Datenblätter vom Microchip.

BONUS: DHT11 in Assembler auslesen (Hardcore)

Ein kompletter DHT11-Bit-Banging-Reader in Assembler erfordert feingranulare Kontrolle von Mikrosekunden-Timing, Schleifen mit Timeout und Bitmanipulation. Die Umsetzung wäre ein eigener Beitrag für sich. Wer es wagen will, braucht:

• Zyklenexakte WAIT_US-Schleifen
• Schleifen zur HIGH-Phasen-Messung (für 0 vs. 1)
• 5 Bytes Speicher (40 Bit) zum Zusammenbauen

Tipp: DHT11-Datenblatt genau studieren, dort stehen alle Timings. Wer sich daran wagt, verdient das Nerdabzeichen mit Goldrand.

Von der Backstein-Platine zum All-in-One-Modul

Der ursprüngliche ATmega32 war ein echter Brocken: 40 Pins, DIP-Gehäuse, externe Taktquelle, externer Programmer, keine Kommunikation ohne zusätzliche Schaltung. Im Kontrast dazu stehen moderne Boards wie der ESP32-S3 DevKit (bezahlter Link), die WLAN, Bluetooth, USB-OTG, mehrere ADCs, DACs und SPI-/I2C-Interfaces auf kleinstem Raum vereinen – oft in der Größe eines USB-Sticks. Manche Boards, wie der LilyGO T-Display, haben sogar ein OLED- oder TFT-Display direkt mit auf dem PCB.

Was früher ein großes Steckbrett voller Kabel war, ist heute ein einziges Modul mit USB-C-Anschluss. Plug-and-play statt Kabelsalat.

Fazit: Vier Wege zur Temperaturanzeige

Ob du lieber klassisch mit direktem Registerzugriff arbeitest oder moderne Skriptsprachen bevorzugst – dieses Projekt zeigt, wie vielseitig Mikrocontroller heute einsetzbar sind. Und wer die Technik von damals noch kennt, weiß die heutigen Komfortfunktionen umso mehr zu schätzen. Aber weißt du, was noch älter als diese Schreibweise ist? XML und XSLT – ein Relikt aus der Zeit, als man Webseiten noch mit Stylesheets statt mit JavaScript animieren wollte. Wenn du denkst, Assembler sei archaisch, warte ab, bis du versuchst, eine Tabelle mit XSLT zu formatieren.

Und du?

Hast du selbst noch alte AVR-Boards in der Schublade? Oder bastelst du schon mit ESP32 und OLED direkt am Gerät?
Lass es mich wissen – kommentiere unter dem Beitrag oder schick mir deinen Aufbau per Mastodon oder E-Mail!

💬 Diskutiere mit auf nerdculture.de/@prokrastinerd