Lernzettel IT Hardware

01 PWM – Pulsweitenmodulation

Pseudo-analoge Ausgabe mit nur einem digitalen Pin. Wird verwendet, um z. B. LEDs zu dimmen, Motoren in der Drehzahl zu regeln oder Servos anzusteuern.

Theorie: Grundidee

Ein Mikrocontroller-Pin kann nur zwei Zustände ausgeben: HIGH (3,3 V) oder LOW (0 V). Trotzdem will man oft eine Spannung dazwischen erzeugen, z. B. um eine LED auf 50 % Helligkeit zu dimmen. Lösung: Der Pin wird so schnell zwischen HIGH und LOW umgeschaltet, dass am Verbraucher im zeitlichen Mittel die gewünschte Leistung ankommt. Das menschliche Auge oder die Trägheit des Motors sieht/spürt nur den Mittelwert.

Wichtige Begriffe

Wichtige Formeln

Visualisierung des Tastgrads

(Werte für U_max = 3,3 V)

Frequenzwahl: warum so hoch?

Die Frequenz muss hoch genug sein, damit der Verbraucher den Wechsel nicht mehr wahrnimmt:

• LEDs: ab ca. 200 Hz nimmt das Auge kein Flackern mehr wahr
• Motoren: typisch im kHz-Bereich, sonst pfeift der Motor hörbar
• Servos: brauchen genau 50 Hz (das Steuerprotokoll fordert das)

Tastgrad ≠ Frequenz

Wichtig zu unterscheiden:

• Der Tastgrad verändert die mittlere Leistung (Helligkeit, Drehzahl)
• Die Frequenz bestimmt nur, wie schnell geschaltet wird, nicht wie hell die LED ist

Programmierung am STM32 (Arduino)

Beispiel: LED dimmen mit Potentiometer

#define POTI PA0
#define LED  PC6

void setup() {
  analogReadResolution(8);          // ADC: 0..255
  analogWriteFrequency(200);        // 200 Hz, kein Flackern
  pinMode(LED, OUTPUT);
}

void loop() {
  int wert = analogRead(POTI);      // Poti einlesen, 0..255
  analogWrite(LED, wert);           // direkt als Tastgrad
  delay(500);
}

Beispiel: festen Tastgrad ausgeben

analogWriteFrequency(1000);   // 1 kHz
analogWrite(PC6, 64);          // 64/255 ≈ 25 % Tastgrad

Vorteile / Nachteile

02 ADC – Analog Digital Converter

Wandelt analoge Spannungen (z. B. von Sensoren oder Potentiometern) in digitale Werte um, mit denen der Mikrocontroller rechnen kann. Gegenstück: DAC.

Theorie: Warum digital?

Funktionsprinzip

Die Wandlung läuft in zwei Schritten ab:

1. Abtastung (Sampling): in regelmäßigen Abständen wird der Spannungswert stichprobenartig gemessen
2. Digitalisierung (Quantisierung): dem gemessenen Spannungswert wird ein digitaler Wert zugeordnet

Shannon-Abtasttheorem

Das Theorem gibt vor, mit welcher Frequenz mindestens abgetastet werden muss, damit das analoge Signal später wieder rekonstruiert werden kann:

f_max ist die höchste Frequenz, die im analogen Signal vorkommt. Wird zu langsam abgetastet, geht Information verloren (Aliasing).

Auflösung

Die Auflösung gibt an, in wie vielen Stufen der ADC die Spannung abbildet. Mehr Bit = feinere Auflösung = genauere Messung.

Wichtige Formeln

ΔU ist die Spannungsauflösung, also der Abstand zwischen zwei benachbarten Stufen. n ist die Bit-Auflösung des ADC.

Damit lässt sich aus dem digitalen ADC-Wert die ursprüngliche Spannung zurückrechnen.

Beispiel-Rechnungen

Wägeverfahren (sukzessive Approximation)

Der STM32-ADC arbeitet nach dem Wägeverfahren. Ein internes Register (SAR = Successive Approximation Register) wird Bit für Bit gefüllt, beginnend mit dem MSB:

1. Alle Bits werden auf 0 gesetzt
2. Das MSB wird auf 1 gesetzt, ein interner DAC erzeugt die entsprechende Spannung
3. Komparator vergleicht: Ist DAC-Spannung < Eingangsspannung → Bit bleibt 1, sonst wird es zurückgesetzt
4. Verfahren wird mit dem nächsten Bit wiederholt, bis das LSB erreicht ist

Bei jedem Takt wird ein Bit angenähert. Bei 12 Bit braucht der ADC also 12 Takte plus etwas Overhead.

ADC am STM32L152RE

• 12-Bit-Auflösung, sukzessive Approximation
• bis zu 42 Kanäle (40 extern, 2 intern)
• Wandlungszeit: 1 µs (max. Speed) bis 4 µs (low Speed)
• Referenzspannung U_ref = 3,3 V

Analog-fähige Pins (Nucleo L152RE):

• PA0 – PA7
• PB0, PB1, PB12 – PB15
• PC0 – PC5

Programmierung

Beispiel: Potentiometer einlesen

#define POTI    PA0
#define U_MAX   3.3
#define ADC_MAX 4095

void setup() {
  analogReadResolution(12);
}

void loop() {
  int adc_wert = analogRead(POTI);
  float U = (float) adc_wert * U_MAX / ADC_MAX;
  // adc_wert: 0..4095
  // U: 0..3,3 V
}

Beispiel: ADC mit Hardware-Timer (Übungsaufgabe)

Ein analoger Sensor an PA0 wird alle 2 Sekunden mit einem Timer abgefragt, abhängig vom Wert wird ein LED-Muster ausgegeben:

#include <Arduino.h>
#include <HardwareTimer.h>

#define SENSOR PA0
#define GRENZE_40  1638   // 40 % von 4095
#define GRENZE_60  2457   // 60 % von 4095

HardwareTimer *timer = new HardwareTimer(TIM6);
volatile bool messen = false;

void timer_isr() { messen = true; }

void setup() {
  for (int i = 0; i < 8; i++) pinMode(PC0 + i, OUTPUT);
  analogReadResolution(12);

  timer->setOverflow(2000000, MICROSEC_FORMAT);  // alle 2 s
  timer->attachInterrupt(timer_isr);
  timer->resume();
}

void loop() {
  if (messen) {
    messen = false;
    int wert = analogRead(SENSOR);

    unsigned char muster;
    if (wert < GRENZE_40)       muster = 0x01;
    else if (wert < GRENZE_60)  muster = 0x81;
    else                        muster = 0xff;

    GPIOC->ODR = (GPIOC->ODR & 0xFF00) | muster;
  }
}

03 I2C – Inter Integrated Circuit

Synchroner 2-Draht-Bus mit Adressierung. Ideal, wenn man mehrere Sensoren oder Module mit wenigen Leitungen anschließen will.

Theorie: Grundprinzip

I2C wurde 1982 von Philips entwickelt und ist ein synchroner serieller 2-Draht-Bus. Mehrere Bausteine teilen sich dieselben zwei Leitungen. Master-Slave-Prinzip (neu: Controller / Target). Halbduplex – die beiden Seiten können nicht gleichzeitig senden.

Leitungen

Open Drain und Pull-Ups

Beide Leitungen sind Open Drain. Das heißt: jeder Teilnehmer kann die Leitung nur auf 0 V (LOW) ziehen, nicht aktiv auf HIGH treiben. Damit die Leitung im Ruhezustand HIGH ist, brauchen SDA und SCL jeweils einen Pull-Up-Widerstand.

• Typische Werte: 4,3 kΩ bis 10 kΩ bei 5 V Betriebsspannung
• Viele Module bringen die Pull-Ups schon mit
• Zu viele parallel geschaltete Pull-Ups → Gesamtwiderstand sinkt → Bus wird überlastet

Geschwindigkeiten

Reichweite: typischerweise nur Platinengröße (ca. 50 cm).

Adressierung

Jeder Slave hat eine 7-Bit-Adresse. Die oberen 4 Bit sind oft vom Hersteller fest, die unteren 3 Bit am Baustein über Pins (A0, A1, A2) einstellbar. Damit lassen sich z. B. bis zu 8 PCF8574 am selben Bus betreiben.

Adressbyte

• R/W = 0 → schreiben (Master sendet an Slave)
• R/W = 1 → lesen (Slave sendet an Master)

Frame-Aufbau

Ein I2C-Frame zum Schreiben sieht so aus:

1. START: Master zieht SDA auf LOW, während SCL HIGH ist
2. Adresse + R/W-Bit: 7 Adress-Bits + 1 Richtungsbit
3. ACK: Slave bestätigt mit 0, dass er angesprochen wurde
4. Datenbytes: jeweils mit ACK des Empfängers
5. STOP: Master zieht SDA von LOW auf HIGH, während SCL HIGH ist

Ablauf: Schreiben (Output mode)

Beispiel mit dem PCF8574 (Port-Expander):

1. Master sendet START + Adresse + R/W = 0
2. Slave sendet ACK
3. Master sendet Datenbyte (z. B. das LED-Muster)
4. Slave sendet ACK und schaltet seine Pins entsprechend
5. Master sendet STOP

Ablauf: Lesen (Input mode)

1. Master sendet START + Adresse + R/W = 1
2. Slave sendet ACK
3. Slave sendet Datenbyte
4. Master sendet ACK (für weiter lesen) oder NACK (Schluss)
5. Master sendet STOP

I2C-Pins am Nucleo L152RE

Programmierung mit Wire-Library

Beispiel: Daten an einen Slave senden

#include <Arduino.h>
#include <Wire.h>

#define SENSOR_ADDRESS 0x4A

void setup() {
  Wire.begin();
}

void loop() {
  // Ein Byte senden
  Wire.beginTransmission(SENSOR_ADDRESS);
  Wire.write(0x9f);
  Wire.endTransmission();

  // Zwei Bytes lesen
  Wire.requestFrom(SENSOR_ADDRESS, 2);
  unsigned char b1 = Wire.read();
  unsigned char b2 = Wire.read();
}

Beispiel: PCF8574 Lauflicht

#define PCF1_ADDRESS 0x22

unsigned char muster[6] = {0x07, 0x0E, 0x1C, 0x38, 0x70, 0xE0};

void loop() {
  for (int i = 0; i < 6; i++) {
    Wire.beginTransmission(PCF1_ADDRESS);
    Wire.write(~muster[i]);   // invertieren, weil LEDs low-aktiv
    Wire.endTransmission();
    delay(200);
  }
}

I2C-Bus-Scanner

Praktisch, um die Adresse unbekannter Bausteine zu finden. Man geht alle Adressen 1 bis 127 durch und prüft, ob endTransmission() 0 (= erfolgreich) zurückgibt:

for (int addr = 1; addr < 128; addr++) {
  Wire.beginTransmission(addr);
  Wire.write(0x00);
  if (Wire.endTransmission() == 0) {
    // Baustein an dieser Adresse gefunden
    lcd.printf("0x%2X gefunden", addr);
  }
}

Vorteile / Nachteile