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
