Schaltplan lesen lernen: Symbole, Knoten und Steckbrett-Aufbau

Wie liest man einen Schaltplan? Kurz gesagt: Ein Schaltplan ist eine Karte, die mit genormten Schaltzeichen zeigt, welcher Anschluss elektrisch mit welchem verbunden ist, nicht wie die Bauteile aussehen. Um ihn zu lesen, erkennst du zuerst die Symbole, verfolgst dann jede Linie als Verbindung, unterscheidest Verbindungspunkte von bloßen Kreuzungen, liest Bezeichner und Werte wie R1 oder 220 und findest schließlich heraus, welchen Teil der Schaltung die Symbole VCC und GND versorgen. Diese fünf Fähigkeiten reichen, um jede Zeichnung zu verstehen, von einer einzelnen LED-Schaltung bis zum Schaltplan des Arduino selbst.

In dieser Anleitung fassen wir die häufigsten Schaltzeichen in einer Tabelle zusammen und erklären, wie du die Richtung von Dioden- und Transistorsymbolen liest, was sich kreuzende von verbundenen Leitungen unterscheidet, welche versteckten Verbindungen Netznamen herstellen und worauf du in den Schaltplänen fertiger Module achten musst. Danach machen wir aus dem Schaltplan einer echten Schaltung mit Taster, LED und Summer eine Verbindungsliste (Netzliste), übertragen sie Schritt für Schritt aufs Steckbrett und geben dir Code, mit dem du die fertige Schaltung auf Arduino, ESP32 und Raspberry Pi Pico testest. In den letzten Abschnitten findest du den Unterschied zwischen der Breadboard-Ansicht von Fritzing und einem echten Schaltplan sowie die häufigsten Lesefehler.

Was ist ein Schaltplan und wozu dient er?

Ein Schaltplan (Schaltbild) ist eine Zeichnung, die den elektrischen Aufbau einer elektronischen Schaltung zeigt. Bauteile werden nicht in echter Größe und Lage, sondern als Symbole gezeichnet, und die Linien dazwischen zeigen nicht den tatsächlichen Kabelweg; sie sagen nur, dass beide Enden am selben elektrischen Punkt liegen. Deshalb können zwei im Plan nebeneinander gezeichnete Widerstände auf der Platine weit auseinander liegen, und eine lange Linie im Plan kann auf dem Steckbrett eine einzige Lochreihe sein. Genau darin liegt die Stärke des Schaltplans: Er zeigt auf einen Blick, wie die Schaltung funktioniert, welchen Weg der Strom nimmt und wo du bei einem Fehler suchen musst.

Gut gezeichnete Schaltpläne folgen ein paar gemeinsamen Gewohnheiten: Das Signal fließt meist von links nach rechts (Eingänge links, Ausgänge rechts), höhere Spannungen liegen oben, GND unten. Neben jedem Bauteil stehen ein Bezeichner (R1, C2, Q1) und ein Wert (220, 100n, BC547). ICs und Module werden als Rechtecke mit Pinnummern und Namen gezeichnet. Die folgende Tabelle fasst die Bausteine zusammen, die du in einem Schaltplan siehst:

Die wichtigsten Schaltzeichen im Überblick

Für Schaltzeichen gibt es zwei große Traditionen: die in Europa übliche IEC 60617 (in Deutschland als DIN EN 60617) und die amerikanische ANSI/IEEE 315. Der bekannteste Unterschied ist der Widerstand: Nach IEC ist er ein leeres Rechteck, nach ANSI eine Zickzacklinie. Beide meinen dasselbe Bauteil, und da du in Arduino-Schaltplänen im Netz beides siehst, solltest du beide kennen. Die Tabelle deckt fast alle Symbole ab, die dir in deinen ersten Projekten begegnen:

Richtung bei Dioden-, LED- und Transistorsymbolen lesen

Stell dir das Dreieck im Dioden- oder LED-Symbol als Pfeil vor: Der Strom fließt in die Richtung, in die das Dreieck zeigt, also von der Anode zur Kathode. Der Querstrich an der Spitze ist die Kathode und entspricht dem Ring auf dem Gehäuse einer echten Diode. Bei der LED stehen die zwei kleinen, vom Dreieck wegzeigenden Pfeile für Licht; zeigen die Pfeile nach innen, ist es keine LED, sondern ein lichtempfindliches Bauteil wie eine Fotodiode oder ein Fototransistor. Leuchtet die LED richtig herum nur sehr schwach oder fällt bald aus, prüfe den Vorwiderstand mit dem LED-Vorwiderstand-Rechner.

Beim Transistorsymbol sitzt der Pfeil immer am Emitter und zeigt die technische Stromrichtung. Beim NPN zeigt der Pfeil nach außen: Der Strom fließt vom Kollektor zum Emitter, und der Emitter geht meist an GND. Beim PNP zeigt der Pfeil nach innen, und der Emitter liegt an der positiven Versorgung. Die schräge Leitung ohne Pfeil ist der Kollektor, die Leitung, die rechtwinklig auf den kurzen dicken Strich trifft, die Basis. Hier lauert eine wichtige Falle: Die Buchstaben B, C und E im Schaltplan verraten nicht die Pinreihenfolge des echten Gehäuses. Mit der flachen Seite zu dir sind die Beine des BC547 von links nach rechts C, B, E, beim 2N2222A und S8050 dagegen E, B, C. Prüfe deshalb beim Übertragen vom Plan aufs Steckbrett die Anschlussbelegung jedes Transistors im Datenblatt oder mit dem Transistor-Werkzeug; mehr dazu in Transistor einfach erklärt.

VCC, GND und Versorgungssymbole

Würde man die Versorgungsleitungen zu jedem Bauteil einzeln zeichnen, wäre der Plan unübersichtlich, deshalb gibt es Versorgungssymbole. VCC, +5V oder 3V3 neben einem nach oben zeigenden Pfeil oder einem kurzen waagerechten Strich markieren einen Versorgungspunkt; drei nach unten kürzer werdende waagerechte Striche (in manchen Plänen ein nach unten zeigendes Dreieck) markieren GND, also Masse und Bezugspunkt. Vergiss die Regel nicht: Alle gleichnamigen Versorgungssymbole sind miteinander verbunden, auch ohne Linie dazwischen. Das GND unten rechts im Plan ist derselbe Punkt wie das GND oben links. Deshalb müssen alle GNDs verbunden werden, selbst bei getrennt versorgten Modulen; warum, erklärt Was ist GND? ausführlich.

Die Versorgungsnamen stammen von Transistoranschlüssen: VCC von der Kollektorversorgung bipolarer Transistoren, VDD und VSS von Drain und Source der MOSFETs in CMOS-Schaltungen. In der Praxis bedeuten VCC und VDD die positive Versorgung, VSS und VEE dagegen GND oder eine negative Versorgung. Siehst du AGND (analoge Masse) und DGND (digitale Masse), sind das getrennt gezeichnete Massen, die Störungen fernhalten sollen, am Ende aber meist an einem Punkt zusammenlaufen. Welche Spannung du an den VCC-Pin eines Moduls legen darfst, sagt dir nicht die Beschriftung, sondern der Schaltplan oder das Datenblatt des Moduls.

Kreuzende und verbundene Leitungen: die Punktregel

Am meisten verwirren Einsteiger beim Schaltplanlesen die Stellen, an denen zwei Linien übereinanderliegen. Die Regel ist einfach, aber streng: Ist an der Kreuzung ein ausgefüllter Punkt, sind die Leitungen verbunden; ohne Punkt laufen sie nur übereinander hinweg. Ältere Schaltpläne zeichneten nicht verbundene Kreuzungen als kleinen Halbkreis, mit dem eine Leitung über die andere springt; das siehst du noch in manchen Lehrbüchern. Moderne Zeichenprogramme wie KiCad und EasyEDA setzen den Punkt automatisch, wenn das Ende einer Leitung die Mitte einer anderen berührt.

• T-Verbindung mit Punkt: Drei Leitungen treffen sich an einem Punkt; alle gehören zum selben Netz. Das ist die sicherste und häufigste Darstellung.
• Kreuzung in Plusform ohne Punkt: Zwei Leitungen laufen übereinander, ohne sich zu berühren; zwischen ihnen gibt es keine Verbindung.
• Kreuzung in Plusform mit Punkt: Alle vier Leitungen sind verbunden; weil der Punkt aber in einer Kopie oder auf einem kleinen Bildschirm verloren gehen kann, zeichnen gute Entwickler stattdessen zwei versetzte T-Verbindungen.
• Halbkreisbrücke: alter Stil; eine Leitung springt über die andere, keine Verbindung.
• X am Leitungsende: nicht angeschlossener Pin (NC, no connect); dass dieser Pin frei bleibt, ist Absicht.

Bezeichner, Werte und Netznamen

Der Bauteilbezeichner neben jedem Bauteil besteht aus einem Kennbuchstaben und einer laufenden Nummer: R1, R2, C1, D1, Q1, U1. Der Buchstabe nennt die Bauteilart: R Widerstand, C Kondensator, L Spule, D Diode, Q Transistor, U IC, K Relais, F Sicherung, SW Schalter, J oder P Steckverbinder, Y Quarz, BZ Summer, M Motor. Auf fertigen Platinen sind dieselben Bezeichner im Bestückungsdruck aufgedruckt, so findest du C5 aus dem Plan auch auf der Platine. Werte werden abgekürzt geschrieben: 4k7 heißt 4,7 kΩ, 100n 100 nF und 10u 10 µF; der Buchstabe ersetzt das Komma. Musst du einen Wert aus den Farbringen lesen, hilft dir der Widerstand-Farbcode-Rechner; Details zu den Bauteilfamilien findest du in Elektronische Bauteile: Symbole und Funktionen.

Der eigentliche Trick beim Schaltplanlesen sind Netznamen. Ein Netz ist der elektrische Punkt, den alle miteinander verbundenen Anschlüsse bilden. Weil man in großen Plänen unmöglich jede Verbindung als Linie zeichnen kann, schreibt der Zeichner einen Namen an das Leitungsende: SDA, SCL, LED, TX und so weiter. Zwei Leitungen mit demselben Namen sind verbunden, auch ohne Linie dazwischen. Im offiziellen Schaltplan des Arduino Uno etwa sind die TX- und RX-Leitungen des USB-Seriell-Chips auf diese Weise, über den Namen, mit dem Hauptprozessor verbunden. Ein Name kann in einer Ecke des Blatts stehen und sein Gegenstück in der anderen; solange du sie nicht zugeordnet hast, hast du den Plan nicht wirklich gelesen.

Schaltplan lesen Schritt für Schritt

1. Spannungsquellen finden: Markiere Batterie, USB, VIN oder Netzteileingang sowie alle VCC-, 3V3- und GND-Symbole. Kläre von Anfang an, mit welcher Spannung die Schaltung läuft.
2. Hauptbauteil bestimmen: Arduino, ESP32, Pico oder ein IC ist meist der große Kasten in der Mitte des Plans; alles andere ist darum herum aufgebaut.
3. Stückliste anlegen: Schreib alle Bezeichner und Werte auf (R1 220 Ω, C1 100 nF, Q1 BC547). Diese Liste ist zugleich Einkaufs- und Prüfliste.
4. Schaltung in Blöcke teilen: Rahme Versorgung, Eingang (Taster, Sensor), Verarbeitung (Board) und Ausgang (LED, Summer, Motor) mit dem Stift ein.
5. Jedes Netz einzeln verfolgen: Beginne an einem Pin, folge der Linie bis zu den Punkten und notiere alle Anschlüsse in diesem Netz. Vergiss gleichnamige Netzlabels nicht.
6. Gepolte Bauteile markieren: Hebe im Plan die Kathode der Diode, die Anode der LED, das Plus des Elkos und den Emitter des Transistors hervor.
7. Den Signalweg in einem Satz beschreiben: Kannst du sagen "Beim Drücken des Tasters wird D2 LOW, der Code setzt D8 auf HIGH, Q1 schaltet durch und der Summer piept", dann hast du den Plan wirklich gelesen.

Beispiel: den Schaltplan einer Schaltung mit Taster, LED und Summer lesen

Jetzt wenden wir das Gelernte auf einen echten Schaltplan an. Unsere Schaltung hat sieben Bauteile. Das Netz LED, das vom Pin D9 des Arduino ausgeht, führt über den Widerstand R1 (220 Ω) zur Anode von LED1; die Kathode der LED liegt an GND. Das Netz BTN an Pin D2 geht über den Taster SW1 und den parallel dazu liegenden Kondensator C1 (100 nF) nach GND. Das Netz BZ von Pin D8 erreicht über R2 (1 kΩ) die Basis des Transistors Q1 (BC547); der Emitter von Q1 liegt an GND, sein Kollektor am Minusanschluss des aktiven Summers BZ1, dessen Plusanschluss an +5V hängt. Am zuverlässigsten liest du einen Schaltplan, indem du ihn in eine Verbindungsliste (Netzliste) wie die folgende übersetzt: Jede Zeile ist ein Netz, und alle Anschlüsse dieser Zeile müssen sich auf dem Steckbrett an einem Punkt treffen.

Achte auf zwei Details in der Tabelle. Erstens hat der Taster im Plan keinen Pull-up-Widerstand, weil der Code INPUT_PULLUP nutzt und der Widerstand im Prozessor (beim Uno etwa 20–50 kΩ) diese Aufgabe übernimmt. Gute Schaltpläne vermerken das mit einer kleinen Notiz am Pin. Zweitens ist C1 ein Kondensator zur Hardware-Entprellung, der das Prellen der Tasterkontakte glättet; zusammen mit dem internen Pull-up ergibt er eine RC-Zeitkonstante von etwa 2–5 ms. Die Namen N1, N2 und N3 für die unbenannten Netze haben wir selbst vergeben; Programme wie KiCad benennen sie automatisch. Mehr zum Anschluss von Tastern findest du in Taster am Arduino anschließen.

Vom Schaltplan aufs Steckbrett

1. Druck den Schaltplan aus oder halte ihn auf dem Bildschirm neben dir und leg einen Textmarker bereit; markiere jede Verbindung im Plan, sobald du sie gesteckt hast.
2. Versorgungsschienen vorbereiten: Verbinde 5V des Boards mit der roten (+) und GND mit der blauen (−) Schiene. Prüfe bei langen Steckbrettern, ob die Schienen in der Mitte unterbrochen sind.
3. Große Bauteile platzieren: Setze ICs über den Mittelkanal und stecke Module und den Transistor so, dass ihre Beine in verschiedenen Reihen landen.
4. Jedem Netz eine Reihe zuweisen: Die fünf senkrechten Löcher eines Steckbretts sind bereits verbunden; stecke Beine desselben Netzes in dieselbe Reihe oder verbinde Reihen mit einem Jumperkabel.
5. Gepolte Bauteile mit den Markierungen im Plan abgleichen: das lange Bein der LED an N1, den BC547 mit der flachen Seite zu dir, sodass C, B, E in den richtigen Reihen landen.
6. Eine Regel für Kabelfarben festlegen: rot für Versorgung, schwarz oder blau für GND, andere Farben für Signale. Elektrisch ändert die Farbe nichts, aber sie beschleunigt die Fehlersuche.
7. Vor dem Einschalten messen: Stell das Multimeter auf Durchgangsprüfung; prüfe zuerst, dass zwischen 5V und GND kein Kurzschluss besteht, dann, dass es zwischen den Anschlüssen jeder Zeile der Netzliste piept.

Die aufgebaute Schaltung testen: Code für Arduino und ESP32

Am schnellsten erkennst du, ob du den Plan richtig übertragen hast, mit einem kleinen Testprogramm, das jedes Netz einzeln prüft. Der folgende Code lässt beim Start zuerst die LED eine Sekunde leuchten, dann den Summer kurz piepen und schreibt den aktuellen Schritt in den seriellen Monitor; danach überwacht er den Taster. Die Konstantennamen im Code entsprechen den Netznamen im Plan: Das Netz BZ aus dem Schaltplan findest du im Code als BZ_PIN. Auf dem ESP32 wechselt derselbe Code die Pinnummern selbst; verdrahte nach der folgenden Tabelle.

1// Şemadan kurulan devreyi net net test eder / Tests the circuit built from the schematic, net by net
2// Sabit isimleri şemadaki net isimleriyle aynı / Constant names match the net names on the schematic
3#if defined(ESP32)
4const int LED_PIN = 18;   // LED neti: R1 üzerinden LED1 anoduna / LED net: to LED1 anode via R1
5const int BTN_PIN = 4;    // BTN neti: SW1 ve C1, diğer uçları GND / BTN net: SW1 and C1, other ends to GND
6const int BZ_PIN  = 19;   // BZ neti: R2 üzerinden Q1 beyzine / BZ net: to Q1 base via R2
7#else
8const int LED_PIN = 9;
9const int BTN_PIN = 2;
10const int BZ_PIN  = 8;
11#endif
12
13bool lastPressed = false;
14
15void setup() {
16  Serial.begin(115200);
17  pinMode(LED_PIN, OUTPUT);
18  pinMode(BZ_PIN, OUTPUT);
19  pinMode(BTN_PIN, INPUT_PULLUP);   // dahili pull-up, şemada ayrı direnç yok / internal pull-up, no separate resistor on the schematic
20
21  Serial.println(F("1) LED testi / LED test"));
22  digitalWrite(LED_PIN, HIGH);      // N1 netine akım gider, LED1 yanar / current flows into N1, LED1 lights
23  delay(1000);
24  digitalWrite(LED_PIN, LOW);
25
26  Serial.println(F("2) Buzzer testi / Buzzer test"));
27  digitalWrite(BZ_PIN, HIGH);       // Q1 iletime geçer, N3 GND'ye çekilir / Q1 turns on, N3 is pulled to GND
28  delay(300);
29  digitalWrite(BZ_PIN, LOW);
30
31  Serial.println(F("3) Butona bas / Press the button"));
32}
33
34void loop() {
35  bool pressed = (digitalRead(BTN_PIN) == LOW);   // SW1 basılıyken BTN neti GND olur / BTN net goes to GND while SW1 is pressed
36  digitalWrite(LED_PIN, pressed ? HIGH : LOW);
37  digitalWrite(BZ_PIN, pressed ? HIGH : LOW);
38
39  if (pressed != lastPressed) {                    // yalnızca değişince yaz / print only on change
40    if (pressed) {
41      Serial.println(F("Basildi / Pressed"));
42    } else {
43      Serial.println(F("Birakildi / Released"));
44    }
45    lastPressed = pressed;
46  }
47  delay(10);
48}

Drei Zeilen im Programm hängen direkt mit dem Schaltplan zusammen. INPUT_PULLUP schaltet den internen Pull-up-Widerstand ein, der im Plan nicht gezeichnet ist; deshalb liest der Pin HIGH, solange der Taster nicht gedrückt ist, und LOW, wenn er gedrückt ist, weil SW1 das Netz mit GND verbindet. digitalWrite(BZ_PIN, HIGH) schickt über R2 Strom in die Basis von Q1: Am 5-V-Uno sind das (5 − 0,7) / 1000 ≈ 4,3 mA. Da der BC547 eine Stromverstärkung von mindestens 110 hat, schaltet dieser Strom die etwa 30 mA des Summers mühelos; am ESP32 liefert der Pin 3,3 V, der Basisstrom sinkt auf 2,6 mA und reicht immer noch. Der LED-Strom beträgt am Uno für eine rote LED (5 − 2) / 220 ≈ 14 mA; diese Rechnungen kannst du mit dem Rechner zum ohmschen Gesetz nachvollziehen.

Derselbe Schaltplan mit Raspberry Pi Pico und MicroPython

Das Schöne an einem Schaltplan ist, dass er nicht vom Board abhängt: Um dieselbe Netzliste am Pico aufzubauen, schreibst du neben die Netznamen einfach andere Pinnummern. Schließe am Pico den Plusanschluss des Summers an VBUS (Pin 40) an, der die 5 V vom USB liefert. GP16 ist nur über R2 mit der Basis des Transistors verbunden; die 5-V-Seite liegt am Kollektor und berührt den Pin des Pico nie direkt, deshalb bleiben die 3,3-V-Pins sicher. Speichere den Code mit Thonny als main.py auf dem Pico:

1# Pico: şemadan kurulan devreyi net net test eder / tests the circuit built from the schematic, net by net
2from machine import Pin
3import time
4
5led = Pin(15, Pin.OUT)               # LED neti: GP15 -> R1 -> LED1 / LED net
6btn = Pin(14, Pin.IN, Pin.PULL_UP)   # BTN neti: GP14 -> SW1 + C1 -> GND / BTN net
7bz = Pin(16, Pin.OUT)                # BZ neti: GP16 -> R2 -> Q1 beyz / BZ net to Q1 base
8
9print("1) LED testi / LED test")
10led.on()
11time.sleep(1)
12led.off()
13
14print("2) Buzzer testi / Buzzer test")
15bz.on()                              # Q1 iletime geçer / Q1 turns on
16time.sleep(0.3)
17bz.off()
18
19print("3) Butona bas / Press the button")
20last = False
21while True:
22    pressed = btn.value() == 0       # basılıyken 0 okunur / reads 0 while pressed
23    led.value(pressed)
24    bz.value(pressed)
25    if pressed != last:              # yalnızca değişince yaz / print only on change
26        print("Basildi / Pressed" if pressed else "Birakildi / Released")
27        last = pressed
28    time.sleep_ms(10)

Schaltpläne von Modulen lesen

Fertige Module (Relaisplatinen, I2C-LCD-Adapter, OLED-Displays, Sensorplatinen) sind eigentlich auch kleine Schaltungen, und die meisten Schaltpläne findest du auf der Händlerseite oder im Datenblatt des Herstellers. Beim Lesen eines Modulplans willst du nicht jeden Widerstand verstehen, sondern die fünf Informationen finden, die dir sagen, wie du das Modul anschließen musst: Versorgungsspannung und Regler, Logikpegel, Pull-up-Widerstände, low-aktive Eingänge sowie Brücken, die Adresse oder Modus wählen. Auch der Schaltplan des Arduino Uno selbst ist eine gute Übung: Nur aus ihm erfährst du, dass die L-LED beim Uno R3 nicht direkt an D13 hängt, sondern über einen Operationsverstärker-Puffer, den LMV358.

Fritzing-Breadboard-Ansicht und Schaltplan: der Unterschied

Die bunten Zeichnungen, die du in den meisten Arduino-Projekten im Netz siehst, sind eigentlich keine Schaltpläne, sondern die Breadboard-Ansicht des Programms Fritzing. Fritzing hält dieselbe Schaltung in drei Ansichten: die Breadboard-Ansicht mit fotoähnlichen Zeichnungen echter Bauteile, die Schaltplanansicht mit genormten Symbolen und die Leiterplattenansicht für das Platinenlayout. Eine Verbindung, die du in einer Ansicht herstellst, erscheint in den anderen als gestrichelte Ratsnest-Linie (Luftlinie); das Programm weiß also, dass die Verbindung existiert, überlässt es aber dir, sie in dieser Ansicht sauber zu zeichnen. Die automatisch gezeichnete Schaltplanansicht von Tinkercad Circuits erfüllt eine ähnliche Brückenfunktion; mehr dazu in Tinkercad Arduino Simulation.

Die Breadboard-Ansicht ist für Einsteiger sehr bequem: Sie zeigt genau, in welches Loch jedes Kabel kommt. Wächst die Schaltung aber, laufen die Kabel übereinander, man erkennt kaum, in welcher Reihe ein Kabel endet, und versteht nicht, warum die Schaltung so aufgebaut ist. Ein Schaltplan verzichtet ganz auf die räumliche Anordnung und zeigt nur die Funktion; deshalb kehrst du für die Fehlersuche, den Umzug auf ein anderes Board oder den Platinenentwurf immer zum Schaltplan zurück. Gewöhn dir an: Beim Aufbauen schaust du auf die Breadboard-Zeichnung, beim Verstehen auf den Schaltplan.

Typische Fehler und ihre Lösungen

Projektideen zum Üben des Schaltplanlesens

• Eine LED mit Widerstand: Du beginnst mit zwei Symbolen und drei Netzen; mach aus der Schaltung in Was ist eine LED? zuerst einen Schaltplan und dann einen Steckbrettaufbau.
• Automatisches Nachtlicht: Der Spannungsteiler aus einem LDR und einem 10-kΩ-Widerstand lehrt dich, Reihenschaltungen und den gemeinsamen Mittelpunkt im Plan zu lesen.
• Ampel: Mit drei LEDs und drei Widerständen ist die Arduino-Ampel ideal, um sich wiederholende Blöcke zu erkennen.
• Lampe mit Relais schalten: Im Schaltplan eines Relaismoduls kommen Transistor, Diode und low-aktiver Eingang zusammen.
• Blinker mit dem 555: Der Timer-IC 555 ist die klassische Übung, ein Kastensymbol mit nummerierten Pins zu lesen.
• 7-Segment-Zähler: Schaltpläne mit 7-Segment-Anzeige zeigen, wie acht Segmente mit Netznamen ordentlich gezeichnet werden.

Schaltpläne zu lesen wirkt anfangs wie ein fremdes Alphabet, doch sobald du Schaltzeichen, Punktregel und Netznamen beherrschst, baust du jedes neue Projekt mit Verständnis statt durch Abkupfern. Als nächsten Schritt kannst du die Beispielschaltung aus diesem Artikel in deinem eigenen Zeichenprogramm neu zeichnen und mit den kirchhoffschen Regeln Ströme und Spannungen in jedem Netz berechnen. In der BlueGrays-App kannst du die Schaltpläne von Projekten wie LED-Blinken, Taster, Nachtlicht, Summer und Ampel Schritt für Schritt samt Code ansehen und das Gelernte sofort mit echten Bauteilen ausprobieren.