Elektronische Bauteile: Symbole, Einheiten und Funktionen

Elektronische Bauteile sind die Grundbausteine jeder Schaltung: Teile, die Strom begrenzen, Energie speichern, Strom nur in eine Richtung durchlassen, schalten, ein Signal verstärken oder die Schaltung schützen. Widerstand, Kondensator, Spule, Diode, LED, Transistor, MOSFET, integrierte Schaltung, Relais, Spannungsregler, Sicherung, Taster, Potentiometer und Quarz: Vom Handy-Ladegerät bis zum Arduino-Board steckt in fast jedem elektronischen Gerät eine Auswahl dieser vierzehn Bauteile. Jedes hat ein eigenes Schaltzeichen, einen Kennbuchstaben (etwa R, C, L, D oder Q) und eine Einheit, in der sein Wert angegeben wird. Wer sie erkennt, macht den ersten Schritt, um Schaltpläne zu lesen und eigene Projekte ohne Fehler aufzubauen.

In diesem Ratgeber fassen wir zuerst alle vierzehn Bauteile mit Kennbuchstabe, Einheit, Schaltzeichen, Aussehen und typischer Aufgabe in einer Übersichtstabelle zusammen. Danach erklären wir den Unterschied zwischen passiven und aktiven Bauelementen, wie jedes Bauteil funktioniert, welche Werte dir begegnen und welche Fehler am häufigsten passieren; am Ende jedes Abschnitts findest du einen Link zum ausführlichen Artikel über das jeweilige Bauteil. Zum Schluss baust du eine Schaltung für Arduino, ESP32 und Raspberry Pi Pico, die Potentiometer, Widerstand, LED, Taster, Transistor, Diode, Kondensator und Relais vereint, und siehst, wie du Bauteile mit dem Arduino und dem Multimeter prüfst.

Welche elektronischen Bauteile gibt es? Die Übersichtstabelle

Die folgende Tabelle vergleicht die vierzehn Bauteile dieses Artikels auf einen Blick. Der Kennbuchstabe steht im Schaltplan am Anfang der Bauteilbezeichnung; Nummern wie R1, C3 oder Q2 unterscheiden Bauteile derselben Art. Die Spalte Einheit zeigt, in welcher Größe der Wert angegeben wird: Widerstände werden in Ohm (Ω), Kondensatoren in Farad (F), Spulen in Henry (H) und Quarze in Hertz (Hz) gemessen. Dioden, Transistoren und Relais haben keine einzelne Einheit; du wählst sie nach der Spannung (V) und dem Strom (A), die sie vertragen. Die Schaltzeichen folgen der in Europa üblichen IEC-Darstellung; in amerikanischen (ANSI-)Schaltplänen sehen manche Symbole anders aus.

Passive und aktive Bauelemente

Elektronische Bauteile werden meist in zwei große Gruppen eingeteilt. Passive Bauelemente führen der Schaltung keine Energie zu und können kein Signal verstärken; sie wandeln Energie nur um (Widerstand), speichern sie (Kondensator, Spule) oder filtern. Aktive Bauelemente steuern mit Energie aus einer Stromquelle einen anderen Strom oder verstärken ein Signal; Transistoren, MOSFETs und integrierte Schaltungen gehören dazu. Dioden und LEDs liegen auf der Grenze: Da sie nicht verstärken, sind sie nach strenger Definition passiv, weil sie aber aus demselben Halbleitermaterial wie Transistoren bestehen, zählen viele Lehrbücher sie zu den aktiven Bauelementen. Kommt die Frage in einer Prüfung, halte dich an die Definition deines Lehrbuchs. Relais, Taster und Sicherungen werden oft gesondert als elektromechanische Bauteile oder Schutzbauteile geführt.

Widerstand: das Bauteil, das den Strom begrenzt

Der Widerstand ist das grundlegendste Bauteil: Er hemmt den Stromfluss und wandelt dabei einen Teil der Energie in Wärme um. Seine Einheit ist das Ohm (Ω), und der Zusammenhang zwischen Spannung, Strom und Widerstand lautet U = I × R, das ohmsche Gesetz. Am Arduino brauchst du Widerstände vor allem für zwei Aufgaben: den Strom eines Bauteils wie einer LED zu begrenzen und einen Spannungsteiler aufzubauen. Um zum Beispiel eine rote LED an einem 5-V-Pin mit 15 mA zu betreiben, brauchst du (5 − 2) / 0,015 = 200 Ω; gewählt wird der nächsthöhere Normwert 220 Ω. Den Wert bedrahteter Widerstände liest du an den Farbringen ab: rot-rot-braun-gold bedeutet 220 Ω mit ±5 % Toleranz. Widerstände gibt es in genormten Werten der sogenannten E12-Reihe (10, 12, 15, 18, 22, 27, 33, 39, 47, 56, 68, 82 und deren Zehnervielfache). Genauso wichtig wie der Wert ist die Belastbarkeit: Widerstände in Bastelschaltungen sind meist für 1/4 W ausgelegt, und wenn die mit P = I² × R berechnete Leistung höher ist, wird der Widerstand heiß und brennt durch. Die Farbringe entschlüsselst du mit dem Werkzeug Widerstands-Farbcode; mehr dazu in Was ist ein Widerstand? und Ohmsches Gesetz.

Kondensator: ein kleiner, schneller Energiespeicher

Ein Kondensator speichert elektrische Ladung auf zwei leitenden Platten, die durch eine isolierende Schicht getrennt sind, und gibt sie bei Bedarf sehr schnell wieder ab. Seine Einheit ist das Farad (F); weil ein Farad riesig ist, rechnest du in der Praxis mit Pikofarad (pF), Nanofarad (nF) und Mikrofarad (µF): 1 µF = 1.000 nF = 1.000.000 pF. Ist er geladen, sperrt er Gleichstrom, schnelle Signaländerungen und Störungen lässt er dagegen durch. Deshalb sitzt neben den Versorgungspins jedes ICs ein keramischer 100-nF-Abblockkondensator, und an Motor- und Servoversorgungen kommen Elkos mit 100–1000 µF. Keramikkondensatoren sind ungepolt, ihr Wert ist als Code aufgedruckt: 104 heißt 10 und vier Nullen, also 100.000 pF = 100 nF. Elkos sind gepolt; der helle Streifen auf dem Gehäuse markiert das Minus-Bein, und falsch herum angeschlossen können sie sich aufblähen und platzen. Zusammen mit einem Widerstand bestimmt die Zeitkonstante τ = R × C, wie schnell sich der Kondensator lädt; mit 10 kΩ und 100 µF ist τ = 1 Sekunde. Codes entschlüsselst du mit dem Werkzeug Kondensator-Code, Bauformen und Berechnungen findest du in Was ist ein Kondensator?.

Spule (Induktivität): das Bauteil, das sich schnellen Stromänderungen widersetzt

Eine Spule entsteht, wenn ein Draht meist auf einen Eisenpulver- oder Ferritkern gewickelt wird; sie speichert Energie im Magnetfeld. Ihre Einheit ist das Henry (H); in der Elektronik begegnen dir meist Mikrohenry (µH) und Millihenry (mH). Anders als der Kondensator widersetzt sich die Spule plötzlichen Änderungen des Stroms: Die Spannung an ihr ergibt sich aus U = L × di/dt. Gleichstrom lässt sie deshalb fast ungehindert durch, hohe Frequenzen dagegen hemmt sie; dieser Widerstand berechnet sich mit XL = 2π × f × L. Am häufigsten triffst du sie als große schwarze Spule auf Schaltreglern wie dem LM2596 (typisch 33–47 µH), wo sie in jedem Schaltzyklus Energie speichert und an die Last weitergibt. Auch Relais, Motoren, Summer und Lautsprecher enthalten Spulen, die beim Abschalten eine hohe Spannungsspitze in Gegenrichtung erzeugen; um sie abzufangen, schaltet man eine Diode in Sperrrichtung parallel zur induktiven Last. Den Wert kleiner bedrahteter Spulen geben Farbringe wie bei Widerständen an, in µH; du liest sie mit dem Werkzeug Spulen-Code ab, mehr dazu in Was ist eine Spule?.

Diode und LED: eine Einbahnstraße für den Strom

Eine Diode ist ein Halbleiter, der Strom nur in eine Richtung leitet, von der Anode zur Kathode; in Gegenrichtung fließt fast kein Strom. Im leitenden Zustand fällt an ihr eine Durchlassspannung ab: bei Siliziumdioden etwa 0,6–1 V, bei Schottky-Dioden 0,15–0,6 V. Der graue oder weiße Ring auf dem Gehäuse markiert die Kathode und entspricht dem Querstrich im Schaltzeichen. Die gängigsten Typen sind die Gleichrichterdiode 1N4007 für 1 A und 1000 V, die schnelle Kleinsignaldiode 1N4148 und die Schottky-Diode 1N5819 mit geringem Spannungsverlust. Eine Diode hat vier Grundaufgaben: Wechselstrom in Gleichstrom umwandeln (Gleichrichten), die Schaltung vor einer verpolten Batterie schützen, Spannungsspitzen induktiver Lasten wie Relais und Motoren abfangen (Freilaufdiode) und als Z-Diode eine Spannung auf einem festen Wert halten. Ausführliche Vergleiche und Messmethoden findest du in Was ist eine Diode?.

Eine LED (Leuchtdiode) ist eine Diode, die leuchtet, sobald Strom fließt, und wie jede Diode nur in einer Richtung funktioniert. Das lange Bein ist die Anode (+), das kurze die Kathode (−); außerdem ist die Kuppel auf der Kathodenseite abgeflacht. Die wichtigste Regel lautet: immer mit Vorwiderstand. Eine LED begrenzt ihren Strom nicht selbst; steigt die Spannung etwas über die Durchlassspannung, schießt der Strom in die Höhe, und die LED oder der Arduino-Pin nimmt Schaden. Den Vorwiderstand berechnest du mit R = (UVersorgung − ULED) / I. Normale 5-mm-LEDs laufen gut mit 10–20 mA; rote und gelbe LEDs haben eine Durchlassspannung von etwa 2 V, blaue, weiße und hellgrüne etwa 3 V. Die Rechnung übernimmt das Werkzeug LED-Vorwiderstand, die Durchlassspannungen nach Farbe zeigt LED-Spannungen, mehr steht in Was ist eine LED?.

Transistor und MOSFET: elektronische Schalter

Ein Transistor (BJT) ist ein dreibeiniger Halbleiter, der mit einem kleinen Basisstrom einen viel größeren Kollektorstrom steuert. Seine Anschlüsse heißen Basis (B), Kollektor (C) und Emitter (E), die Stromverstärkung lautet IC = hFE × IB. Es gibt zwei Typen, NPN und PNP; in Arduino-Projekten ist der NPN-Typ mit dem Emitter an GND weit verbreitet. Weil ein Arduino-Pin nicht viel mehr als etwa 20 mA sicher liefern kann, steuerst du Relais, Motoren, Summer und LED-Streifen über einen Transistor. Zwischen Pin und Basis gehört immer ein Widerstand: Um ein 5-V-Relais (etwa 71 mA) mit einem 2N2222A zu schalten, passen am Arduino Uno 680 Ω und am ESP32 und Pico mit 3,3 V 470 Ω. Für kleine Lasten nimmt man den BC547 (100 mA), für mittlere den 2N2222A (600 mA) und bis zu einigen Ampere den Darlington-Transistor TIP120 (5 A). Da die Pinbelegung je nach Typ verschieden ist, prüfe sie mit dem Werkzeug Transistor-Pinbelegung; Arbeitsbereiche und Berechnungen erklärt Was ist ein Transistor?.

Ein MOSFET ist ebenfalls ein Transistor, wird aber über die Spannung statt über den Strom gesteuert. Seine Anschlüsse heißen Gate (G), Drain (D) und Source (S). Das Gate ist durch eine dünne Oxidschicht vom Kanal isoliert und zieht im Ruhezustand praktisch keinen Strom; liegt die Gate-Source-Spannung deutlich über der Schwellenspannung (VGS(th)), sinkt der Drain-Source-Widerstand (RDS(on)) auf wenige Milliohm. Deshalb wird ein MOSFET bei hohen Strömen viel weniger warm als ein BJT. Am Arduino ist das Wichtigste, einen Logic-Level-Typ zu wählen: Der IRLZ44N schaltet mit 5 V am Gate voll durch, der verbreitete IRF540N braucht dafür 10 V und wird bei 5 V heiß. Für die 3,3-V-Pins von ESP32 und Pico eignen sich Typen mit niedrigerer Schwelle wie IRLB8721 oder AO3400. In die Gate-Leitung kommt ein Widerstand von 100–220 Ω, zwischen Gate und GND ein 10-kΩ-Pulldown. Schaltpläne findest du in MOSFET am Arduino verwenden.

Integrierte Schaltung (IC): Tausende Bauteile auf einem Chip

Eine integrierte Schaltung (IC, Chip) ist eine fertige Schaltung, in der Tausende oder sogar Milliarden Bauteile wie Transistoren, Widerstände und Kondensatoren auf einem einzigen Stück Silizium vereint sind. Im Schaltplan wird sie meist als Kasten mit nummerierten Pins und dem Buchstaben U oder IC gezeichnet. Steckbrettfreundliche Versionen gibt es im DIP-Gehäuse (DIP-8, DIP-14, DIP-16), fertige Platinen verwenden viel kleinere SMD-Gehäuse (SOIC, TSSOP). Um richtig zu verdrahten, suchst du zuerst Pin 1: Achte auf die halbrunde Kerbe an einem Ende oder den kleinen Punkt in einer Ecke. Schaust du von oben auf den Chip und die Kerbe zeigt nach links, ist der Pin unten links Pin 1, und die Nummern steigen gegen den Uhrzeigersinn. Die ICs, die dir in Bastelprojekten am häufigsten begegnen, sind der Timer NE555, das Schieberegister 74HC595 für mehr Ausgänge, der Operationsverstärker LM358, Logikgatter-ICs und der 28-polige ATmega328P, das Gehirn des Arduino Uno. Gewöhne dir an, zwischen VCC und GND jedes ICs so nah wie möglich einen 100-nF-Kondensator zu setzen.

Relais: große Lasten mit kleinem Signal schalten

Ein Relais ist ein elektromechanischer Schalter: Fließt Strom durch seine Spule, zieht das Magnetfeld einen Metallkontakt an. Weil die Kontaktseite galvanisch von der Spule getrennt ist, kannst du mit einem 5-V-Signal eine 230-V-Lampe oder eine 12-V-Pumpe schalten. Die Kontakte heißen COM (gemeinsamer Kontakt), NO (Schließer, normalerweise offen) und NC (Öffner, normalerweise geschlossen): Ohne Spulenstrom ist COM mit NC verbunden, zieht die Spule an, wechselt COM zu NO. Das Relais SRD-05VDC-SL-C aus Arduino-Sets hat eine Spule mit etwa 70 Ω und zieht bei 5 V rund 71 mA, weit mehr, als ein Pin liefern kann. Deshalb wird ein Relais immer über einen Transistor angesteuert, und parallel zur Spule kommt eine Freilaufdiode in Sperrrichtung. Fertige Relaismodule haben Transistor, Diode und Status-LED bereits auf der Platine. Kleine Schalter, bei denen sich zwei dünne Kontakte in einem Glasröhrchen schließen, sobald ein Magnet in die Nähe kommt, heißen Reedkontakte und stecken in Tür- und Fenstersensoren.

Spannungsregler: eine stabile, sichere Versorgung

Ein Spannungsregler hält am Ausgang eine konstante Spannung, auch wenn die Eingangsspannung schwankt. Das bekannteste Beispiel ist der 7805: Er erzeugt aus 7–35 V am Eingang 5 V und liefert mit Kühlkörper bis zu 1,5 A. Mit der beschrifteten Seite zu dir sind die Pins von links nach rechts Eingang (IN), GND und Ausgang (OUT). Der 7805 ist ein Linearregler; er verheizt die Spannungsdifferenz. Die Verlustleistung beträgt P = (Uein − Uaus) × I: Bei 0,5 A von 12 V auf 5 V entstehen 3,5 W Wärme, die ein TO-220-Gehäuse ohne Kühlkörper nicht verkraftet. Für 3,3 V am Ausgang nimmt man den AMS1117-3.3, der auch auf vielen ESP32-Boards sitzt; als Low-Drop-Regler (LDO) braucht er nur etwa 1,1–1,3 V mehr am Eingang als am Ausgang. Brauchst du viel Strom und hohen Wirkungsgrad, liefert ein Schaltregler wie der LM2596 bis zu 3 A bei etwa 80–90 % Wirkungsgrad. Vergiss die Kondensatoren an Ein- und Ausgang nicht; Details in Spannungsregler 7805 und Arduino mit Strom versorgen.

Sicherung: der Sicherheitsgurt der Schaltung

Eine Sicherung ist ein Schutzbauteil, das den Stromkreis trennt, indem es schmilzt oder seinen Widerstand stark erhöht, sobald der Strom einen festgelegten Wert überschreitet. Ihre eigentliche Aufgabe ist nicht der Schutz der Elektronik, sondern der Schutz von Leitungen, Akkus und Netzteil vor Hitze und Brand durch einen Kurzschluss. Aufgedruckt sind der Nennstrom (z. B. 1 A) und die maximale Spannung (z. B. 250 V). Auch der Buchstabe davor zählt: Eine F-Sicherung (flink) löst bei plötzlichem Überstrom sofort aus, eine T-Sicherung (träge) übersteht den kurzen Einschaltstrom von Motoren und großen Kondensatoren. Wähle etwa das 1,25- bis 1,5-Fache des normalen Betriebsstroms und setze die Sicherung in die Plusleitung, möglichst nah an der Quelle. Glasrohr- (5×20 mm) und Kfz-Flachsicherungen musst du nach dem Auslösen ersetzen; PTC-Sicherungen (selbstrückstellend) begrenzen den Strom, wenn sie warm werden, und kehren nach dem Abkühlen in den Normalzustand zurück. Auch der Arduino Uno hat am USB-Eingang eine solche PTC-Sicherung, die den USB-Port deines Computers bei mehr als 500 mA schützt. Ob dein Board wirklich defekt ist, findest du mit Ist mein Arduino kaputt? heraus.

Taster und Schalter: den Stromkreis von Hand öffnen und schließen

Ein Taster schließt den Kontakt nur, solange du ihn drückst, und öffnet beim Loslassen wieder. Ein Schalter (Schiebe-, Kipp- oder Wippschalter) bleibt in der Stellung, in der du ihn lässt. Die Kontaktart wird mit Abkürzungen beschrieben: SPST ist ein einfacher Ein-Aus-Schalter, SPDT ein Umschalter, der einen gemeinsamen Anschluss mit einem von zwei Ausgängen verbindet, und DPDT schaltet zwei getrennte Stromkreise gleichzeitig um. Der 6×6-mm-Taster aus Steckbrett-Sets hat vier Beine, aber nur zwei getrennte Kontakte: Je zwei Beine sind intern verbunden, deshalb schließt du ihn am sichersten über die diagonal gegenüberliegenden Beine an. Am Arduino brauchst du einen Pullup- oder Pulldown-Widerstand, damit der Pin nie in der Luft hängt; am einfachsten aktivierst du mit INPUT_PULLUP den internen 20–50-kΩ-Widerstand des ATmega328P. Dann liest der Pin LOW, solange der Taster gedrückt ist. Mechanische Kontakte prellen beim Drücken einige Millisekunden lang; das filterst du in der Software heraus, indem du 20–50 ms wartest (Entprellen). Details in Taster am Arduino anschließen.

Potentiometer: ein einstellbarer Widerstand

Ein Potentiometer ist ein dreibeiniger, einstellbarer Widerstand, dessen mittlerer Anschluss (der Schleifer) beim Drehen der Achse über eine Widerstandsbahn gleitet. Zwischen den äußeren Beinen ist der Widerstand fest (z. B. 10 kΩ), zwischen dem mittleren und einem äußeren Bein ändert er sich von 0 bis 10 kΩ. Schließt du die äußeren Beine an 5V und GND und das mittlere an einen Analogeingang an, wird das Poti zum einstellbaren Spannungsteiler, und die Funktion analogRead() des Arduino Uno liest einen Wert von 0 bis 1023. Der Buchstabe auf dem Gehäuse gibt die Kennlinie an: Bei den meisten Typen steht B für linear und A für logarithmisch (für Lautstärke); B10K ist ein lineares 10-kΩ-Poti. Die kleinen Versionen, die auf die Platine gelötet und einmal mit dem Schraubendreher eingestellt werden, heißen Trimmer (Trimmpoti); sie dienen etwa zum Einstellen des LCD-Kontrasts oder von Sensor-Schwellen. Details und Beispielprojekte in Was ist ein Potentiometer?.

Quarz: der Herzschlag der Schaltung

Ein Quarz (Schwingquarz) ist ein dünnes Quarzplättchen, das unter Spannung mit einer sehr stabilen Frequenz schwingt; man nennt das den piezoelektrischen Effekt. Seine Einheit ist das Hertz (Hz), der Wert steht in MHz oder kHz auf dem Gehäuse (z. B. 16.000 = 16 MHz). Mikrocontroller arbeiten ihre Befehle im Takt dieser Schwingung ab, und davon hängt auch die Genauigkeit von Zeitfunktionen wie delay() und millis() ab. Arduino-Boards mit ATmega328P laufen mit 16 MHz (der originale Uno R3 nutzt dafür statt eines Quarzes einen günstigeren Keramikresonator, viele Nachbauten haben einen Quarz im Metallgehäuse); zwischen den Quarzbeinen und GND sitzen meist zwei kleine 22-pF-Kondensatoren. Unter dem Metalldeckel von ESP32-Modulen steckt ein 40-MHz-Quarz, der Raspberry Pi Pico hat einen mit 12 MHz. Uhrenmodule verwenden einen Quarz mit 32,768 kHz, denn dieser Wert ist 2 hoch 15: Fünfzehnmal halbiert ergibt er genau 1 Hz, also einen Impuls pro Sekunde. So halten RTC-Module die Uhrzeit auch dann genau, wenn der Arduino ausgeschaltet ist.

Bauteile und Werte im Schaltplan lesen

Im Schaltplan stehen an jedem Bauteil zwei Angaben: die Bezeichnung aus Kennbuchstabe und Nummer (R1, C2, Q1, U3) und der Wert (220, 100n, BC547). Dieselben Bezeichnungen sind auf die Platine gedruckt, sodass du R7 aus dem Schaltplan schnell auf der Platine findest. Bei Werten ersetzt oft der Einheitenbuchstabe das Komma; so kann ein Komma im kleinen Aufdruck nicht verschwinden und der Wert nicht zehnfach falsch gelesen werden. Wie du Schaltpläne Schritt für Schritt liest, erklären wir in Schaltplan lesen; diese Schreibweisen siehst du am häufigsten:

• 4k7, 1M, 2R2, 0R: Der Reihe nach 4,7 kΩ, 1 MΩ und 2,2 Ω; der Buchstabe R ersetzt bei Ohm-Werten das Komma. 0R ist eine Drahtbrücke mit null Ohm.
• 100n, 104, 0.1u: Alle drei bedeuten denselben Wert, 100 nF; weil auf der Tastatur kein µ ist, schreibt man u.
• 10u/16V: Ein Elko mit 10 µF und 16 V Spannungsfestigkeit; die Spannungsfestigkeit sollte mindestens das 1,5-Fache der höchsten Spannung in der Schaltung betragen.
• L1 4u7: Eine Spule mit 4,7 µH; weil die Bezeichnung mit L beginnt, ist die Einheit Henry.
• D1 1N4007, Q1 BC547, U1 NE555: Bei Halbleitern steht statt eines Werts die Typenbezeichnung; die Kennwerte findest du im Datenblatt des Typs.
• 472 oder 01C: Das sind Codes auf SMD-Widerständen; 472 bedeutet 47 und zwei Nullen, also 4,7 kΩ. Für Codes mit Buchstaben siehe SMD-Widerstandscodes und das Werkzeug SMD-Code.

Praxis: acht Bauteile in einer Schaltung

Am besten festigst du die Theorie, wenn die Bauteile zusammenarbeiten. In der Schaltung, die wir aufbauen, stellt ein Potentiometer die Helligkeit einer LED ein, ein 220-Ω-Widerstand begrenzt den LED-Strom, und ein Taster schaltet bei jedem Druck ein Relais ein oder aus; das Relais zieht ein 2N2222A-Transistor an, der über einen Basiswiderstand angesteuert wird. Eine 1N4007-Diode in Sperrrichtung parallel zur Relaisspule schützt den Transistor, und ein 100-nF-Kondensator zwischen Schleifer und GND verringert das Rauschen beim Analogmessen. An die Relaiskontakte musst du vorerst nichts anschließen; dass es schaltet, hörst du am Klicken. Wenn du zum ersten Mal mit einem Steckbrett arbeitest, lies vorher Was ist ein Steckbrett?.

1// Elektronik devre elemanları deneyi / Electronic components experiment
2// Pot -> LED parlaklığı, buton -> transistör + röle / pot -> LED brightness, button -> transistor + relay
3#if defined(ESP32)
4const int POT_PIN = 34;       // ADC1, yalnızca giriş / ADC1, input only
5const int LED_PIN = 18;       // 220 Ω üzerinden LED / LED via 220 Ω
6const int BUTTON_PIN = 4;     // diğer bacak GND'ye / other leg to GND
7const int RELAY_PIN = 23;     // 470 Ω ile 2N2222A beyzine / to the 2N2222A base via 470 Ω
8const int ADC_MAX = 4095;     // 12 bit ADC
9const float VREF = 3.3;
10#else
11const int POT_PIN = A0;
12const int LED_PIN = 9;        // PWM pini (~) / PWM pin (~)
13const int BUTTON_PIN = 2;     // diğer bacak GND'ye / other leg to GND
14const int RELAY_PIN = 7;      // 680 Ω ile 2N2222A beyzine / to the 2N2222A base via 680 Ω
15const int ADC_MAX = 1023;     // 10 bit ADC
16const float VREF = 5.0;
17#endif
18
19bool relayOn = false;
20int lastReading = HIGH;             // son ham okuma / last raw reading
21int stableState = HIGH;             // zıplamadan arınmış durum / debounced state
22unsigned long lastChange = 0;       // son değişim anı / time of last change
23unsigned long lastPrint = 0;
24
25void setup() {
26  pinMode(LED_PIN, OUTPUT);
27  pinMode(RELAY_PIN, OUTPUT);
28  digitalWrite(RELAY_PIN, LOW);           // açılışta röle kapalı / relay off at startup
29  pinMode(BUTTON_PIN, INPUT_PULLUP);      // dahili pull-up direnci / internal pull-up resistor
30  Serial.begin(115200);
31}
32
33void loop() {
34  // 1) Potansiyometre -> LED parlaklığı (PWM) / potentiometer -> LED brightness (PWM)
35  int pot = analogRead(POT_PIN);
36  analogWrite(LED_PIN, map(pot, 0, ADC_MAX, 0, 255));
37
38  // 2) Buton -> röle, 30 ms zıplama filtresi / button -> relay, 30 ms debounce
39  int reading = digitalRead(BUTTON_PIN);
40  if (reading != lastReading) {
41    lastChange = millis();
42    lastReading = reading;
43  }
44  if (millis() - lastChange > 30 && reading != stableState) {
45    stableState = reading;
46    if (stableState == LOW) {             // basıldı / pressed
47      relayOn = !relayOn;
48      digitalWrite(RELAY_PIN, relayOn ? HIGH : LOW);
49    }
50  }
51
52  // 3) Yarım saniyede bir rapor / report every half second
53  if (millis() - lastPrint >= 500) {
54    lastPrint = millis();
55    Serial.print("Pot: ");
56    Serial.print(pot * VREF / ADC_MAX, 2);
57    Serial.print(" V | Röle / relay: ");
58    Serial.println(relayOn ? "AÇIK / ON" : "KAPALI / OFF");
59  }
60}

Der Code erledigt drei unabhängige Aufgaben in derselben loop(), ohne dass eine die andere warten lässt. analogRead() liest die Spannung am Schleifer des Potis, und map() rechnet sie in den Bereich 0–255 um; per PWM folgt die Helligkeit der LED diesem Wert. Den Taster liest der Code mit millis() statt delay(): Bleibt der Messwert 30 ms lang unverändert, gilt das als echter Tastendruck, und der Relaiszustand wird umgeschaltet. Geht der Pin auf HIGH, schaltet der 2N2222A voll durch, Strom fließt durch die Relaisspule, und der Kontakt springt mit einem Klicken auf NO; geht der Pin auf LOW, baut sich die Energie der Spule gefahrlos über die 1N4007 ab. Dank der Zeile #if defined(ESP32) lässt sich derselbe Code auf dem ESP32 mit dessen Pins und 12-Bit-ADC kompilieren. Öffne den seriellen Monitor mit 115200 Baud, um Poti-Spannung und Relaiszustand live zu verfolgen.

Dieselbe Schaltung mit Raspberry Pi Pico und MicroPython

Um dieselbe Schaltung mit MicroPython auf dem Raspberry Pi Pico zu betreiben, verdrahte sie nach der Pico-Spalte der Tabelle und versorge die Relaisspule über den Pin VBUS, an dem die 5 V vom USB anliegen. Weil die Funktion read_u16() des Pico Werte von 0 bis 65535 liefert, kannst du den Wert ohne Umrechnung direkt an die PWM-Funktion duty_u16() übergeben. Speicherst du den Code mit Thonny als main.py auf dem Pico, startet er bei jedem Einschalten automatisch. Bist du neu bei MicroPython, beginne mit Was ist der Raspberry Pi Pico?.

1# Pico: pot -> LED parlaklığı, buton -> transistör + röle / pot -> LED brightness, button -> transistor + relay
2from machine import Pin, ADC, PWM
3import time
4
5pot = ADC(26)                            # GP26 = ADC0, pot orta ucu / pot wiper
6led = PWM(Pin(15))                       # GP15, 220 Ω üzerinden LED / LED via 220 Ω
7led.freq(1000)                           # 1 kHz PWM
8button = Pin(14, Pin.IN, Pin.PULL_UP)    # diğer bacak GND'ye / other leg to GND
9relay = Pin(16, Pin.OUT, value=0)        # 470 Ω ile 2N2222A beyzine / to the 2N2222A base via 470 Ω
10
11relay_on = False
12last = 1
13last_print = time.ticks_ms()
14
15while True:
16    raw = pot.read_u16()                 # 0-65535
17    led.duty_u16(raw)                    # parlaklık / brightness
18
19    now = button.value()
20    if now == 0 and last == 1:           # basıldı / pressed
21        time.sleep_ms(30)                # zıplamayı bekle / wait out the bounce
22        if button.value() == 0:
23            relay_on = not relay_on
24            relay.value(1 if relay_on else 0)
25    last = now
26
27    if time.ticks_diff(time.ticks_ms(), last_print) >= 500:
28        last_print = time.ticks_ms()
29        state = "AÇIK / ON" if relay_on else "KAPALI / OFF"
30        print("Pot: {:.2f} V | Röle / relay: {}".format(raw * 3.3 / 65535, state))
31    time.sleep_ms(5)

Widerstandswert und LED-Durchlassspannung mit dem Arduino messen

Der Arduino kann auch zu einem einfachen Messgerät werden, mit dem du deine Bauteile bestimmst. Stecke den Widerstand mit unbekanntem Wert zwischen A1 und GND und einen bekannten 10-kΩ-Widerstand zwischen 5V und A1; beide bilden einen Spannungsteiler, und der unbekannte Widerstand ergibt sich aus Rx = 10 kΩ × Messwert / (1023 − Messwert). Am genauesten ist die Messung, wenn der unbekannte Widerstand in der Nähe des Referenzwerts liegt (etwa 1–100 kΩ). Für die zweite Messung verbindest du 5V über einen 220-Ω-Widerstand mit der Anode einer LED, die Kathode mit GND und die Anode zusätzlich mit A2: Die an A2 gemessene Spannung ist die Durchlassspannung der LED bei etwa 8–14 mA. Öffne den seriellen Monitor mit 9600 Baud, stecke nacheinander LEDs verschiedener Farben ein und vergleiche mit der Tabelle oben.

1// Arduino ile direnç ve LED ileri gerilimi ölçme / Measuring a resistor and an LED's forward voltage with Arduino
2const float VCC = 5.0;          // Uno besleme gerilimi / Uno supply voltage
3const float R_REF = 10000.0;    // 5V ile A1 arası bilinen direnç / known resistor between 5V and A1
4
5void setup() {
6  Serial.begin(9600);
7}
8
9void loop() {
10  int raw = analogRead(A1);     // bilinmeyen direnç A1 ile GND arasında / unknown resistor between A1 and GND
11  if (raw >= 1023) {
12    Serial.println("Direnç takılı değil / no resistor connected");
13  } else {
14    float rx = R_REF * raw / (1023.0 - raw);   // gerilim bölücü formülü / voltage divider formula
15    Serial.print("R = ");
16    Serial.print(rx, 0);
17    Serial.println(" ohm");
18  }
19
20  float vf = analogRead(A2) * VCC / 1023.0;    // 5V - 220 Ω - A2 - LED - GND
21  Serial.print("LED Vf = ");
22  Serial.print(vf, 2);
23  Serial.println(" V");
24  Serial.println();
25  delay(1000);
26}

Bauteile mit dem Multimeter prüfen

Funktioniert eine Schaltung nicht, ist oft ein Bauteil mit falschem Wert oder ein defektes Bauteil schuld. Mit dem Multimeter prüfst du jedes Teil in wenigen Sekunden; miss immer im spannungsfreien Zustand und möglichst mit ausgebautem Bauteil, denn andere Bauteile in der Schaltung verfälschen den Messwert. Wie du die einzelnen Messbereiche nutzt, erklären wir ausführlich in Multimeter richtig benutzen.

Projektideen mit diesen Bauteilen

• Ampel: Dein erstes Projekt mit Ausgängen in Reihenfolge, mit drei LEDs und drei 220-Ω-Widerständen; die Schritte stehen in Arduino-Ampel.
• Automatisches Nachtlicht: Ein Spannungsteiler aus LDR und 10-kΩ-Widerstand erkennt Dunkelheit, ein Transistor schaltet einen 12-V-LED-Streifen ein.
• Blinker ohne Arduino: Eine LED, die mit einem NE555, zwei Widerständen und einem Kondensator einmal pro Sekunde blinkt; mit R und C stellst du die Frequenz ein.
• Lauflicht: Steuere acht LEDs über einen 74HC595 mit nur drei Pins an (Arduino-Lauflicht).
• Digitales Voltmeter: Miss mit einem Spannungsteiler aus zwei Widerständen Spannungen über der 5-V-Grenze des Arduino (Arduino-Voltmeter bauen).
• Smarte Steckdose: Schalte mit Relais und ESP32 eine Lampe vom Handy aus; die Sicherheitsregeln stehen in Was ist ein Relaismodul?.

Häufige Fehler und Lösungen

Elektronische Bauteile kennenzulernen ist wie das Alphabet einer Sprache zu lernen: Sobald du weißt, was Widerstand, Kondensator, Diode, Transistor und die anderen tun, wird jeder neue Schaltplan und jedes Modul verständlicher. Als nächsten Schritt kannst du die ausführlichen Artikel zu den einzelnen Bauteilen nacheinander lesen, mit den kirchhoffschen Regeln Schaltungen berechnen und im Ratgeber Arduino-Starterkit entscheiden, welche Teile du kaufst. In der BlueGrays-App findest du Projekte mit diesen Bauteilen, etwa LED-Blinken, LED per Taster schalten, ein LDR-Nachtlicht, einen Servo per Potentiometer und eine Netzlampe per Relais, Schritt für Schritt mit Schaltplänen und Code.