Platine entwerfen: Schritt-für-Schritt-Anleitung mit EasyEDA

Platine entwerfen heißt, eine Schaltung, die du mit Kabeln auf dem Steckbrett aufgebaut hast, in eine dauerhafte Leiterplatte (PCB, Printed Circuit Board) zu verwandeln, auf der Kupferbahnen die Bauteile verbinden. Dafür brauchst du heute weder teure Software noch eine Fabrik: Mit dem kostenlosen EasyEDA zeichnest du im Browser den Schaltplan, entwirfst die Platine, erzeugst die Fertigungsdateien und bestellst mit wenigen Klicks; ein, zwei Wochen später hältst du professionell aussehende Platinen in der Hand.

In dieser Anleitung gehst du den gesamten Ablauf Schritt für Schritt am Beispiel einer kleinen Sensorplatine mit Arduino Nano durch: Schaltplan zeichnen, für jedes Bauteil den richtigen Footprint wählen, Bauteile platzieren, die Leiterbahnbreite passend zum Strom festlegen, eine GND-Kupferfläche hinzufügen, mit dem DRC Fehler suchen, Gerber-Dateien erzeugen, bestellen und die gelieferte Platine testen. Zum Schluss geht es um die häufigsten Designfehler von Einsteigern und einen kurzen Vergleich mit der leistungsstarken Alternative KiCad.

Was ist eine Platine und warum vom Steckbrett zur Platine wechseln?

Eine Platine besteht aus dünnen Kupferschichten auf einer glasfaserverstärkten Epoxidplatte (FR-4). Die meisten Bastlerplatinen sind zweilagig: Oben und unten ist Kupfer, und beide Lagen sind über kleine durchkontaktierte Löcher, sogenannte Vias, verbunden. Die grüne (oder andersfarbige) Schicht über dem Kupfer ist der Lötstopplack; er schützt die Leiterbahnen und sorgt dafür, dass Lötzinn nur an den Pads haftet. Die weiße Beschriftung obendrauf ist der Bestückungsdruck (Silkscreen). Ein Steckbrett ist perfekt zum Ausprobieren, doch Kabel lockern sich durch Vibration, lange Jumper fangen Störungen ein und die Schaltung passt in kein Gehäuse. Eine Platine liefert ein robustes, kompaktes, reproduzierbares Ergebnis, das sich leicht prüfen lässt.

Beispielprojekt: Sensorplatine mit Arduino Nano

In dieser Anleitung bringen wir eine oft auf dem Steckbrett gebaute Schaltung auf eine Platine: einen Arduino Nano, einen DHT22-Temperatur- und Feuchtesensor, eine vierpolige Stiftleiste für ein I2C-OLED-Display, zwei Taster, eine LED und einen passiven Summer. Statt den Nano direkt einzulöten, stecken wir ihn in zwei 15-polige Buchsenleisten; so kannst du ihn für ein anderes Projekt herausnehmen oder bei einem Defekt einfach tauschen. Die Platine bekommt 7–12 V von einem Netzteil über eine Schraubklemme und ist mit einer Diode gegen Verpolung geschützt. Die Pinnummern findest du in Arduino-Nano-Pinbelegung.

Ablauf des Platinenentwurfs: 7 Schritte

1. Schaltplan: Zeichne die Schaltung mit Symbolen und prüfe jede Verbindung.
2. Footprints: Wähle für jedes Symbol die Pad- und Lochanordnung auf der Platine.
3. Platzierung: Leg die Platinengröße fest und ordne die Bauteile in sinnvollen Gruppen an.
4. Leiterbahnen: Zeichne die Verbindungen als Kupferbahnen; Versorgungsbahnen breit halten.
5. Kupferfläche: Füll freie Flächen mit Kupfer, das an GND hängt.
6. DRC: Prüf die Designregeln und behebe die Fehler.
7. Gerber und Bestellung: Erzeuge die Fertigungsdateien, kontrolliere sie und lade sie beim Hersteller hoch.

1. Den Schaltplan in EasyEDA zeichnen

EasyEDA gibt es in zwei Versionen: die ältere, schlichte Standard und die neuere, leistungsfähigere Pro. Beide sind kostenlos und laufen im Browser oder als herunterladbarer Desktop-Client. Fang als Einsteiger mit Pro an. Nach dem Anlegen eines kostenlosen Kontos erstellst du ein neues Projekt und bekommst ein leeres Schaltplanblatt. Suche im Bereich Library nach dem Bauteilnamen oder der LCSC-Teilenummer und platziere das Teil im Schaltplan; Grundbauteile wie Widerstände, Kondensatoren und LEDs bringen Symbol und Footprint fertig mit. Verbinde dann die Pins mit dem Werkzeug Wire und nutze für die Versorgung die Symbole VCC und GND. Bist du das Lesen von Schaltplänen nicht gewohnt, erklärt Schaltpläne lesen die Symbole einzeln.

2. Footprints wählen: das Gegenstück des Symbols auf der Platine

Das Symbol zeigt im Schaltplan, was ein Bauteil tut; der Footprint legt fest, in welchen Pads und Löchern seine Beinchen auf der Platine sitzen und wie viel Fläche es belegt. Derselbe 10-kΩ-Widerstand hat Dutzende Footprints: ein bedrahteter (THT) Axialwiderstand mit 7,62 mm oder 10,16 mm Raster oder SMD-Gehäuse wie 0805 und 0603. Wähle nie einen Footprint, ohne die Maße des Bauteils in deiner Hand mit Lineal oder Messschieber zu prüfen. Für die erste Platine fängst du am besten mit THT-Bauteilen an, die sich leicht von Hand löten lassen; beim Umstieg auf SMD ist die Größe 0805 am angenehmsten für Handlötung. Die Codes auf SMD-Widerständen entschlüsselst du mit dem Werkzeug SMD-Code-Rechner.

3. Platinengröße und Platzierung

• Zuerst die Kontur: Zeichne die Platinenkontur (Board Outline). Unsere Beispielplatine misst 60 × 50 mm; viele Hersteller fertigen Platinen unter 100 × 100 mm in ihrer günstigsten Preisklasse.
• Befestigungslöcher: Setz in die vier Ecken, etwa 3,5 mm vom Rand, Löcher mit 3,2 mm Durchmesser (M3); das Verschrauben im Gehäuse wird später viel einfacher.
• Steckverbinder an die Kante: Schraubklemme, OLED-Anschluss und die USB-Buchse des Nano sollen zur Platinenkante zeigen, damit beim Einstecken nichts im Weg ist.
• Gruppiert platzieren: Versorgungsbauteile (Klemme, Diode, Kondensator) in einer Ecke, die Taster an der Kante, an der man sie drückt.
• Sensor fern von Wärme: Setz den DHT22 weit weg vom Regler des Nano und vom Summer; die Abwärme des Reglers kann die Temperaturmessung um einige Grad verfälschen.
• Platz zum Löten lassen: Zwischen den Bauteilen muss die Lötspitze hinpassen; der Abstand zwischen zwei benachbarten Pads sollte nicht unter 1 mm fallen.
• Bestückungsdruck: Schreib die Referenz jedes Bauteils (R1, D1), die Polung von LED und Kondensator, die Pinnamen und den Platinennamen auf; Text nicht über Pads laufen lassen.

4. Leiterbahnen ziehen und Leiterbahnbreite wählen

Nach dem Platzieren siehst du dünne Linien zwischen den Bauteilen; diese Ratsnest-Linien zeigen Verbindungen, die im Schaltplan existieren, aber noch nicht in Kupfer ausgeführt sind. Mit dem Werkzeug Track machst du aus jeder eine Kupferbahn. Die Breite einer Leiterbahn bestimmt, wie viel Strom sie tragen kann: Eine schmale Bahn erwärmt sich bei hohem Strom, verursacht Spannungsabfall und brennt im schlimmsten Fall durch. Für Signalbahnen reichen 0,25–0,3 mm; Versorgungsbahnen wie 5 V und VIN solltest du mindestens 0,6–1 mm breit machen, besonders wenn sie Servos, Motoren oder LED-Streifen versorgen. Die folgenden Werte sind grobe Richtwerte nach der IPC-2221-Näherung für eine Außenlage mit 1 oz (35 µm) Kupfer und etwa 10 °C Erwärmung; eine Sicherheitsreserve schadet nie.

Halte den Abstand zwischen Leiterbahnen (Clearance) bei mindestens 0,2–0,3 mm; die meisten Hersteller schaffen engere Abstände, aber ein großzügiger Abstand lässt bei Fertigung und Löten Spielraum für Fehler. Muss eine Bahn auf die andere Lage wechseln, nimm ein Via; 0,3 mm Bohrung und 0,6 mm Außendurchmesser sind für Bastlerplatinen eine übliche Wahl. Biege Ecken in 45-Grad-Schritten und vermeide spitze Winkel (unter 90 Grad). Auf zweilagigen Platinen hilft es, Bahnen oben überwiegend waagerecht und unten senkrecht zu führen, um Kreuzungen aufzulösen. Den Wert des LED-Widerstands berechnest du mit dem LED-Vorwiderstandsrechner.

5. GND-Kupferfläche (Copper Pour)

Wenn alle Bahnen gezogen sind, füllst du die übrige freie Fläche der Platine mit einer Kupferfläche am GND-Netz; in EasyEDA übernimmt das das Werkzeug Copper Area. Füge die Fläche auf Ober- und Unterseite hinzu und verbinde beide Lagen mit einigen über die Platine verteilten GND-Vias. Das bringt drei Vorteile: Die GND-Verbindung jedes Bauteils entsteht auf kürzestem Weg ohne eigene Bahn, Widerstand und Störungen der Masseleitung sinken, und der Hersteller muss weniger Kupfer wegätzen. Die GND-Pads bedrahteter Bauteile hängen über Wärmefallen (Thermal Relief, vier dünne Stege) an der Fläche, damit der Lötkolben das Pad erwärmen kann, ohne die Wärme an die große Kupferfläche zu verlieren. Lass die Fläche nach dem Hinzufügen neu berechnen und entferne kleine Kupferinseln, die nirgends angeschlossen sind.

6. Der DRC

Der DRC (Design Rule Check) prüft deinen Entwurf automatisch gegen die festgelegten Regeln: Er listet zu dicht liegende Bahnen, Kupfer zu nah am Rand, überlappende Pads, Bauteile außerhalb der Platine und noch unverbundene Netze auf. Klickst du auf eine Zeile der Fehlerliste, zeigt EasyEDA dir die Problemstelle. Lass den DRC so lange laufen, bis keine Fehler mehr übrig sind, aber verlass dich nicht allein auf ihn; der DRC weiß nicht, dass ein Footprint falsch gewählt oder ein Pin mit dem falschen Netz verbunden wurde. Mach vor der Bestellung zusätzlich diese Prüfungen von Hand:

1. Stell sicher, dass keine Ratsnest-Linien mehr zu sehen sind und der DRC null Fehler meldet.
2. Druck die Platine im Maßstab 100 % auf Papier aus und leg die echten Bauteile darauf; Lochabstände und die Nano-Buchsenleisten müssen genau passen.
3. Öffne die 3D-Ansicht: Überlappen sich Bauteile, zeigen USB-Buchse und Klemme zur Kante?
4. Verfolge den Versorgungsweg: Liegen Klemme, Diode, Kondensator und VIN-Pin des Nano in der richtigen Reihenfolge?
5. Prüf, ob der Bestückungsdruck Polungszeichen, Pinnamen, den Platinennamen und eine Versionsnummer (z. B. v1.0) enthält.

7. Gerber-Dateien erzeugen und bestellen

Hersteller arbeiten nicht mit deiner Entwurfsdatei, sondern mit den branchenüblichen Gerber-Dateien. Gerber beschreibt jede Lage der Platine in einer eigenen Datei; Lochpositionen und -durchmesser stehen in einer separaten Bohrdatei (Drill). Wählst du im Fertigungsmenü von EasyEDA die Gerber-Ausgabe, landen alle Dateien in einem einzigen ZIP-Archiv; die Möglichkeit, direkt beim Schwesterhersteller von EasyEDA zu bestellen, findest du auf demselben Bildschirm. Das ZIP kannst du aber auch bei jedem anderen Hersteller hochladen. Egal, wen du wählst: Sieh dir die Platine nach dem Hochladen im Online-Gerber-Viewer Lage für Lage an; hier siehst du ein letztes Mal, dass das Gefertigte dem Gezeichneten entspricht.

Die Platinen werden meist innerhalb weniger Tage gefertigt, der Versand kann je nach gewählter Methode ein bis zwei Wochen dauern. Wenn sie ankommen, löte nicht gleich alles: Setz zuerst nur Diode, Kondensator und Klemme ein, miss mit dem Multimeter, dass zwischen VIN und GND kein Kurzschluss besteht, leg dann Spannung an und prüf, dass an der Nano-Buchsenleiste die richtige Spannung anliegt. Danach lötest du von niedrig nach hoch: Widerstände, Diode, Taster, Buchsenleisten und zuletzt die großen Teile. Für saubere Lötstellen siehe Richtig löten, fürs Messen Multimeter benutzen. Steck den Nano ein und lade den folgenden Test-Sketch hoch, um jede Verbindung der Platine einzeln zu prüfen.

1// Nano kartı ilk test: her bağlantıyı tek tek doğrula
2// Nano board first test: check every connection one by one
3#include <Wire.h>
4
5const int DHT_PIN  = 2;              // DHT22 veri hattı, 10 kΩ pull-up / DHT22 data line, 10 kΩ pull-up
6const int BUTON1   = 3;              // buton GND'ye / button to GND
7const int BUTON2   = 4;
8const int LED_PIN  = 6;              // LED + 330 Ω
9const int BUZZER   = 8;              // pasif buzzer / passive buzzer
10
11void i2cTara() {
12  byte bulunan = 0;
13  for (byte adres = 1; adres < 127; adres++) {
14    Wire.beginTransmission(adres);
15    if (Wire.endTransmission() == 0) {             // cihaz cevap verdi / a device answered
16      Serial.print(F("I2C cihaz / device: 0x"));
17      Serial.println(adres, HEX);                  // OLED genelde 0x3C / OLED is usually 0x3C
18      bulunan++;
19    }
20  }
21  if (bulunan == 0) Serial.println(F("I2C cihaz yok: A4/A5 yollarini kontrol et / no I2C device: check the A4/A5 tracks"));
22}
23
24void setup() {
25  Serial.begin(9600);
26  pinMode(BUTON1, INPUT_PULLUP);
27  pinMode(BUTON2, INPUT_PULLUP);
28  pinMode(LED_PIN, OUTPUT);
29  pinMode(DHT_PIN, INPUT);
30  Wire.begin();
31
32  Serial.println(F("--- Kart testi / board test ---"));
33  i2cTara();
34  // Pull-up direnci lehimliyse veri hattı boşta HIGH okunur
35  // If the pull-up resistor is soldered, the idle data line reads HIGH
36  Serial.print(F("DHT hatti / DHT line: "));
37  Serial.println(digitalRead(DHT_PIN) ? F("HIGH (pull-up tamam / OK)") : F("LOW (pull-up ya da kisa devre? / pull-up or short?)"));
38  tone(BUZZER, 2000, 150);                         // buzzer kısa bip / short beep
39}
40
41void loop() {
42  digitalWrite(LED_PIN, (millis() / 500) % 2);     // LED yarım saniyede bir / LED every half second
43
44  static bool once1 = HIGH, once2 = HIGH;
45  bool b1 = digitalRead(BUTON1);
46  bool b2 = digitalRead(BUTON2);
47  if (b1 == LOW && once1 == HIGH) { Serial.println(F("Buton 1 / button 1")); tone(BUZZER, 1000, 80); }
48  if (b2 == LOW && once2 == HIGH) { Serial.println(F("Buton 2 / button 2")); tone(BUZZER, 1500, 80); }
49  once1 = b1;
50  once2 = b2;
51  delay(20);                                       // basit debounce / simple debounce
52}

Der Code scannt beim Start den I2C-Bus und gibt bei eingestecktem OLED dessen Adresse aus (meist 0x3C); findet er nichts, sollst du die Bahnen an A4 und A5 prüfen. Ist der Pull-up-Widerstand R1 richtig eingelötet, liest die DHT22-Datenleitung im Ruhezustand HIGH; siehst du LOW, fehlt der Widerstand oder die Leitung hat Kurzschluss nach GND. Der Summer piept beim Start kurz, die LED blinkt im Halbsekundentakt, und jeder Taster schreibt seinen Namen in den seriellen Monitor und erzeugt einen anderen Ton. Sind alle Tests bestanden, fügst du die Bibliotheken für Sensor und Display hinzu und machst mit deinem eigentlichen Projekt weiter.

Häufige Fehler beim Platinenentwurf

Ein kurzer Blick auf KiCad: EasyEDA oder KiCad?

In KiCad ist der Ablauf derselbe: Du zeichnest die Schaltung im Schaltplaneditor, ordnest jedem Symbol einen Footprint zu, platzierst und verdrahtest im Leiterplatteneditor, lässt den DRC laufen und erzeugst über das Menü Plotten die Gerber- und Bohrdateien. Für die erste Platine sparen die fertige Bibliothek von EasyEDA und die Bestellung in einem Schritt Zeit. Wachsen deine Entwürfe und willst du offline arbeiten, deine Dateien ganz bei dir behalten und erweiterte Funktionen nutzen, lohnt sich der Wechsel zu KiCad; die hier gelernten Begriffe Footprint, Leiterbahnbreite, Kupferfläche und DRC sind in beiden Programmen gleich.

Sobald du deine erste Platine in der Hand hältst, siehst du, wie eine robuste, reproduzierbare Leiterplatte den Kabelsalat auf dem Steckbrett ersetzt; selbst wenn dir ein Fehler unterläuft, wird die zweite Version immer besser. Fang mit einer kleinen Platine mit THT-Bauteilen an, prüf Footprints und Versorgungsbahnen doppelt und druck den Entwurf vor der Bestellung auf Papier aus, um die Bauteile anzuprobieren. Die Schaltpläne der LED-, Taster-, Summer-, DHT11-, LCD- und OLED-Projekte in der BlueGrays-App sind ein guter Ausgangspunkt für deine eigene Platine; bring die Schaltung zuerst mit den Schritten der App auf dem Steckbrett zum Laufen und übertrag sie dann auf eine Platine.