nF in µF umrechnen: Kondensator-Code und Elektronik-Einheiten
nF in µF umrechnen leicht gemacht: pF-nF-µF-Tabelle, Kondensator-Code 104 und 2n2, kΩ, mA, mV, mAh in Wh und typische Einheitenfehler im Arduino-Code.
Wer nF in µF umrechnen will, braucht nur eine Regel: 1 µF = 1000 nF und 1 nF = 1000 pF. Von nF nach µF teilst du also durch 1000, von µF nach nF multiplizierst du mit 1000: 100 nF = 0,1 µF, 4,7 µF = 4700 nF. Der Aufdruck 104 auf einem Keramikkondensator steht genau für diese 100 nF, also 0,1 µF. Fast alle Umrechnungen in der Elektronik laufen in solchen Tausenderschritten; hast du die Vorsätze einmal verinnerlicht, werden auch Widerstands-, Strom-, Spannungs- und Akkurechnungen viel einfacher.
In dieser Anleitung haben wir die Vorsätze p, n, µ, m, k und M in einer Tabelle zusammengefasst. Du lernst, Kondensator-Codes (104, 2n2, 474J) zu lesen, die Schreibweisen 4K7 und R47 auf Widerständen zu verstehen, zwischen mA und A sowie mV und V zu wechseln, die Akkukapazität von mAh in Wh umzurechnen und das ohmsche Gesetz mit Einheiten-Abkürzungen im Kopf zu lösen. Zum Schluss schauen wir uns die häufigsten Einheitenfehler im Code für Arduino, ESP32 und Raspberry Pi Pico an und wie man sie richtig schreibt.

SI-Vorsätze: Was bedeuten p, n, µ, m, k und M?
Werte in der Elektronik erstrecken sich über einen riesigen Bereich: Ein Mikrocontroller braucht im Schlafmodus ein paar Mikroampere, ein Motor zieht mehrere Ampere; der Kondensator neben einem Quarz hat 22 Pikofarad, der am Ausgang eines Netzteils 2200 Mikrofarad. Deshalb schreiben wir keine langen Nullenketten, sondern einen Vorsatz. Jeder Vorsatz multipliziert die Grundeinheit mit einer Zehnerpotenz, und die in der Elektronik üblichen liegen jeweils Faktor 1000 auseinander. Die Regeln gelten gleichermaßen für Volt, Ampere, Ohm, Farad, Henry, Watt und Hertz.
| Vorsatz | Symbol | Faktor | Beispiel aus der Elektronik |
|---|---|---|---|
| Piko | p | 10⁻¹² (0,000 000 000 001) | 22 pF Lastkondensator am Quarz |
| Nano | n | 10⁻⁹ (0,000 000 001) | 100 nF Abblockkondensator, 62,5 ns Taktperiode |
| Mikro | µ (u) | 10⁻⁶ (0,000 001) | 10 µF Kondensator, 10 µA Schlafstrom |
| Milli | m | 10⁻³ (0,001) | 20 mA LED-Strom, 4,88 mV ADC-Schritt |
| (Grundeinheit) | - | 1 | 5 V, 1 A, 1 Ω, 1 F |
| Kilo | k | 10³ (1000) | 10 kΩ Pull-up-Widerstand, 38 kHz IR-Träger |
| Mega | M | 10⁶ (1 000 000) | 1 MΩ Eingangswiderstand, 16 MHz Takt |
| Giga | G | 10⁹ | 2,4 GHz WLAN und Bluetooth |
Umrechnungstabelle pF, nF und µF
Was bei Kondensatoren am meisten verwirrt: Derselbe Wert kann in drei Einheiten angegeben sein. Im Schaltplan steht 0,1 µF, im Onlineshop 100 nF, auf dem Bauteil 104, und trotzdem ist es dasselbe Teil. Um nF in µF umzurechnen, teilst du durch 1000; von pF nach nF teilst du ebenfalls durch 1000. In die andere Richtung multiplizierst du mit 1000. Die Tabelle zeigt die gängigsten Werte zusammen mit den Codes, die du auf den Bauteilen findest; es lohnt sich, sie auszudrucken und über den Arbeitsplatz zu hängen.
| pF | nF | µF | Code |
|---|---|---|---|
| 10 pF | 0,01 nF | 0,00001 µF | 100 |
| 22 pF | 0,022 nF | 0,000022 µF | 220 |
| 100 pF | 0,1 nF | 0,0001 µF | 101 |
| 1000 pF | 1 nF | 0,001 µF | 102 |
| 2200 pF | 2,2 nF (2n2) | 0,0022 µF | 222 |
| 4700 pF | 4,7 nF (4n7) | 0,0047 µF | 472 |
| 10.000 pF | 10 nF | 0,01 µF | 103 |
| 47.000 pF | 47 nF | 0,047 µF | 473 |
| 100.000 pF | 100 nF | 0,1 µF | 104 |
| 220.000 pF | 220 nF | 0,22 µF | 224 |
| 470.000 pF | 470 nF | 0,47 µF | 474 |
| 1.000.000 pF | 1000 nF | 1 µF | 105 |
| 10.000.000 pF | 10.000 nF | 10 µF | 106 |
Kondensator-Code lesen: Wie viel nF ist 104?
Auf kleine Keramik- und Folienkondensatoren passt der volle Wert nicht, deshalb wird ein dreistelliger Code aufgedruckt, und dessen Einheit ist immer Pikofarad. Die ersten beiden Ziffern sind der Wert, die dritte Ziffer gibt die Anzahl der angehängten Nullen an. Bei 104 hängst du an die 10 vier Nullen an: 100.000 pF, also 100 nF oder 0,1 µF. Wenn du nicht im Kopf rechnen willst, erledigt der Kondensator-Code-Rechner das in einer Sekunde; wie Kondensatoren funktionieren, erklären wir im Artikel Was ist ein Kondensator?.
- Schreib die ersten beiden Ziffern auf: 47 bei 474.
- Häng so viele Nullen an, wie die dritte Ziffer sagt: 47 und 4 Nullen ergibt 470.000 pF.
- Teil durch 1000, um nF zu erhalten: 470.000 pF = 470 nF.
- Teil noch einmal durch 1000, um µF zu erhalten: 470 nF = 0,47 µF.
- Achte auf den Buchstaben hinter dem Code: J bedeutet ±5 %, K ±10 % und M ±20 % Toleranz. 474J ist also ein 0,47-µF-Kondensator mit ±5 %.
- Steht vor dem Code etwas wie 2A oder 1H, ist das die Spannungsfestigkeit: 1H = 50 V, 2A = 100 V, 2J = 630 V.
| Aufdruck | Bedeutung | Wert |
|---|---|---|
| 2n2 | n ersetzt das Komma | 2,2 nF = 2200 pF |
| 4n7 | n ersetzt das Komma | 4,7 nF = 4700 pF |
| µ1 oder u1 | µ ersetzt das Komma | 0,1 µF = 100 nF |
| 4µ7 | µ ersetzt das Komma | 4,7 µF |
| p68 | p ersetzt das Komma | 0,68 pF |
| 109 | Dritte Ziffer 9 = ×0,1 | 1,0 pF |
| 104Z | Z = +80 % / -20 % Toleranz | 100 nF |
| 35 MFD | Alte Schreibweise: MFD = Mikrofarad | 35 µF |
Widerstandseinheiten: Ω, kΩ, MΩ und die Schreibweise 4K7
Die Grundeinheit beim Widerstand ist das Ohm (Ω), doch die meisten Werte in Arduino-Schaltungen liegen im Kiloohm-Bereich: 220 Ω als LED-Vorwiderstand, 10 kΩ als Pull-up, 1 MΩ für einen hochohmigen Eingang. In Schaltplänen und Stücklisten ersetzt ein Buchstabe das Komma, weil ein kleiner Punkt im Ausdruck verschwinden kann, ein Buchstabe aber nicht. R steht für Ohm, K für Kiloohm und M für Megaohm, und wo der Buchstabe steht, ist das Komma. Für die Farbringe auf dem Gehäuse hilft unsere Anleitung zum Widerstand-Farbcode oder der Farbcode-Rechner; Codes wie 103 und 4701 auf SMD-Bauteilen erklärt der Artikel SMD-Widerstand-Codes.
| Schreibweise | Wert | In Ohm |
|---|---|---|
| R47 | 0,47 Ω | 0,47 Ω |
| 2R2 | 2,2 Ω | 2,2 Ω |
| 220R | 220 Ω | 220 Ω |
| 1K | 1 kΩ | 1000 Ω |
| 4K7 | 4,7 kΩ | 4700 Ω |
| 47K | 47 kΩ | 47.000 Ω |
| 1M0 | 1 MΩ | 1.000.000 Ω |
| 103 (SMD) | 10 und 3 Nullen | 10.000 Ω = 10 kΩ |
| 4701 (SMD, 4-stellig) | 470 und 1 Null | 4700 Ω = 4,7 kΩ |
Der dreistellige Code funktioniert bei Widerständen und Spulen genauso, aber die Grundeinheit wechselt: Pikofarad beim Kondensator, Ohm beim SMD-Widerstand und Mikrohenry bei der Spule. 101 auf einem Kondensator sind also 100 pF, auf einem SMD-Widerstand 100 Ω und auf einer Spule 100 µH. Deute einen Code nie, ohne zu wissen, auf welchem Bauteil er steht.
Strom und Spannung: mA in A, µA und mV in V umrechnen
Beim Strom wechselst du meistens zwischen mA und A: 1 A = 1000 mA und 1 mA = 1000 µA. Eine LED mit 20 mA zieht 0,02 A; die 10 µA eines ESP32 im Deep Sleep sind 0,01 mA oder 0,00001 A. Bei der Spannung gelten dieselben Schritte: 1 V = 1000 mV. Der 10-Bit-ADC des Arduino Uno teilt 5 V in 1024 Stufen, jede Stufe ist also 5 / 1024 = 0,00488 V oder 4,88 mV. In Sensor-Datenblättern findest du Verhältnisse wie mV pro Grad (10 mV/°C beim LM35) oder mV pro Ampere (185 mV/A beim ACS712-5A); diese Werte in der richtigen Einheit zu verwenden, entscheidet über die Genauigkeit deiner Messung. Details zum analogen Einlesen stehen im Artikel Was ist ein ADC?.
| Situation | Typischer Wert | In Grundeinheit |
|---|---|---|
| Arduino-Uno-Pinstrom (empfohlen / absolutes Maximum) | 20 mA / 40 mA | 0,02 A / 0,04 A |
| Betriebsstrom einer roten LED | 10-20 mA | 0,01-0,02 A |
| ESP32 beim WLAN-Senden | bis 250 mA | 0,25 A |
| Deep-Sleep-Strom des ESP32-Chips | etwa 10 µA | 0,00001 A |
| ADC-Schritt Arduino Uno (5 V, 10 Bit) | 4,88 mV | 0,00488 V |
| ADC-Schritt ESP32 und Pico (3,3 V, 12 Bit) | etwa 0,8 mV | 0,0008 V |
| Blockierstrom eines SG90-Servos | 650-700 mA | etwa 0,7 A |
Einheiten-Abkürzungen im ohmschen Gesetz: V, mA und kΩ
Du musst nicht jeden Wert erst in die Grundeinheit umrechnen. Kombinierst du die Vorsätze so, dass sie sich aufheben, kommt das Ergebnis direkt in der richtigen Einheit heraus. Die praktischste Kombination lautet: Volt geteilt durch Kiloohm ergibt Milliampere. Legst du 5 V an einen 10-kΩ-Pull-up, fließen 5 / 10 = 0,5 mA, ganz ohne Nullen. Nach derselben Logik ergibt Milliampere mal Kiloohm Volt, und Volt mal Milliampere ergibt Milliwatt. Auch für die Ladezeit eines Kondensators gilt: Kiloohm mal Mikrofarad ergibt Millisekunden. Zum Auffrischen der Grundlagen lies Das ohmsche Gesetz, für schnelle Rechnungen nutze den Rechner für das ohmsche Gesetz.
| Formel | Einheiten-Kombination | Beispiel |
|---|---|---|
| I = U / R | V / kΩ = mA | 5 V / 10 kΩ = 0,5 mA |
| R = U / I | V / mA = kΩ | (5 V - 2 V) / 20 mA = 0,15 kΩ = 150 Ω |
| U = I × R | mA × kΩ = V | 2 mA × 4,7 kΩ = 9,4 V |
| P = U × I | V × mA = mW | 5 V × 20 mA = 100 mW |
| τ = R × C | kΩ × µF = ms | 10 kΩ × 100 µF = 1000 ms = 1 s |
| τ = R × C | kΩ × nF = µs | 10 kΩ × 100 nF = 1000 µs = 1 ms |
| τ = R × C | MΩ × µF = s | 1 MΩ × 10 µF = 10 s |
mAh und Wh: Akkukapazität umrechnen
mAh (Milliamperestunden) sagt, wie viel Strom ein Akku wie viele Stunden lang liefern kann, Wh (Wattstunden) dagegen, wie viel Energie tatsächlich darin steckt. Um Akkus mit unterschiedlicher Spannung zu vergleichen, brauchst du Wh, denn eine AA-Zelle mit 2000 mAh und ein Lithium-Akku mit 2000 mAh speichern nicht dieselbe Energie. Die Formel ist einfach: Wh = mAh × V / 1000. Eine 18650-Zelle mit 2600 mAh und 3,7 V speichert 2600 × 3,7 / 1000 = 9,62 Wh. Die Grenze von 100 Wh, die Fluggesellschaften für Powerbanks im Handgepäck setzen, entspricht bei 3,7 V etwa 27.000 mAh.
Um die Laufzeit abzuschätzen, teilst du die Kapazität durch den mittleren Strom: Stunden = mAh / mA. In der Praxis lässt sich der Akku nicht ganz leeren und der Spannungsregler verliert Energie, deshalb ist ein Faktor von 0,7-0,8 realistisch. Ein ESP32-Projekt mit durchschnittlich 80 mA läuft mit einer 2600-mAh-Zelle etwa 2600 / 80 × 0,8 = 26 Stunden. Die 10.000 mAh auf einer Powerbank beziehen sich auf die 3,7-V-Zellen im Inneren; nach dem Hochsetzen auf 5 V bei etwa 85 % Wirkungsgrad bleiben rund 10.000 × 3,7 × 0,85 / 5 ≈ 6300 mAh nutzbare Kapazität. Die ausführliche Rechnung findest du im Artikel Was bedeutet mAh? oder im Akkulaufzeit-Rechner.
| Batterie / Akku | Kapazität | Spannung | Energie |
|---|---|---|---|
| CR2032 Knopfzelle | 220 mAh | 3 V | 0,66 Wh |
| AA Alkaline (Mignon) | etwa 2500 mAh | 1,5 V | etwa 3,75 Wh |
| 9-V-Block Alkaline | etwa 500 mAh | 9 V | etwa 4,5 Wh |
| 1000-mAh-LiPo | 1000 mAh | 3,7 V | 3,7 Wh |
| 18650 Li-Ion | 2600 mAh | 3,7 V | 9,62 Wh |
| 10.000-mAh-Powerbank | 10.000 mAh | 3,7 V (Zelle) | 37 Wh |
Zeit und Frequenz: ms, µs, Hz, kHz und MHz
Frequenz und Periodendauer sind Kehrwerte voneinander: T = 1 / f. Weil Hertz "pro Sekunde" bedeutet, ergibt der Kehrwert von kHz Millisekunden und der von MHz Mikrosekunden. Servomotoren werden mit 50 Hz angesteuert, also kommt alle 1 / 50 = 0,02 s = 20 ms ein Impuls. Die meisten PWM-Pins des Arduino Uno arbeiten mit etwa 490 Hz und 2,04 ms Periode; die Pins 5 und 6 mit 980 Hz und 1,02 ms (mehr dazu in Was ist PWM?). Bei 16 MHz Takt dauert ein Taktzyklus 62,5 ns. Verwechsle auch die beiden Zeitfunktionen des Arduino nicht: millis() liefert Millisekunden, micros() Mikrosekunden, und delayMicroseconds() ist nur bis 16.383 µs genau; für längere Wartezeiten nimm Zeitsteuerung mit millis.
Auch Geschwindigkeiten beruhen auf diesen Umrechnungen. Beim Ultraschallsensor HC-SR04 beträgt die Schallgeschwindigkeit 343 m/s; in cm/µs umgerechnet sind das 34.300 cm / 1.000.000 µs = 0,0343 cm/µs. Weil der Sensor die Laufzeit hin und zurück liefert, gilt Abstand = Zeit (µs) × 0,0343 / 2; ein Echo von 1000 µs entspricht also 17,15 cm. Wenn du weißt, woher die 0,0343 kommt, kannst du den passenden Faktor für Meter oder Zoll selbst bestimmen.
Einheitenfehler im Arduino-Code: ADC-Werte in mV und V umrechnen
Selbst wenn die Umrechnung auf dem Papier stimmt, lauern im Code zwei Fallen. Die erste ist der int-Überlauf: Auf dem Arduino Uno fasst ein int höchstens 32.767, 1023 × 5000 sind aber 5.115.000, und das Ergebnis ist Unsinn. Die zweite ist die Ganzzahldivision: 4700 / 1000 ergibt 4 statt 4,7, weil bei der Division zweier Ganzzahlen die Nachkommastellen wegfallen. Die Lösung: das Produkt als long berechnen und für ein Ergebnis mit Nachkommastellen 1000.0 statt 1000 schreiben. Der folgende Sketch rechnet die Spannung an A0 korrekt in mV und V um und bestimmt dann die tatsächliche Eingangsspannung eines Spannungsteilers aus 10 kΩ und 4,7 kΩ.
1// ADC değerini mV ve V'a çevirme / Converting ADC readings to mV and V
2const int SENSOR_PIN = A0;
3const long VREF_MV = 5000; // Uno referansı 5000 mV / Uno reference 5000 mV
4const float R1_KOHM = 10.0; // üst direnç 10 kΩ / top resistor 10 kΩ
5const float R2_KOHM = 4.7; // alt direnç 4,7 kΩ / bottom resistor 4.7 kΩ
6
7void setup() {
8 Serial.begin(9600);
9}
10
11void loop() {
12 int raw = analogRead(SENSOR_PIN); // 0-1023
13
14 // YANLIŞ: int ile raw * 5000 taşar / WRONG: raw * 5000 overflows an int
15 // int wrongMv = raw * 5000 / 1024;
16
17 long mv = (long)raw * VREF_MV / 1024; // doğru: long ile mV / correct: mV using long
18 float volts = mv / 1000.0; // mV -> V, 1000.0 ondalıklı böler / 1000.0 keeps decimals
19 float vin = volts * (R1_KOHM + R2_KOHM) / R2_KOHM; // kΩ / kΩ birimsizdir / kΩ over kΩ is unitless
20
21 Serial.print("ham / raw: "); Serial.print(raw);
22 Serial.print(" mV: "); Serial.print(mv);
23 Serial.print(" V: "); Serial.print(volts, 3);
24 Serial.print(" Vin: "); Serial.println(vin, 2);
25 delay(500);
26}Der Cast (long)raw sorgt dafür, dass die Multiplikation mit 32 Bit läuft und nichts überläuft. Wir teilen durch 1024, weil das die Formel aus dem Datenblatt des ATmega328P ist; der Unterschied zu 1023 liegt bei etwa 0,1 Prozent. Die Widerstände des Teilers in kΩ anzugeben ist kein Problem, weil sich die Einheiten im Verhältnis aufheben. Mit diesem Teiler liegen an A0 höchstens 5 V an, während du am Eingang bis etwa 15,6 V messen kannst.
Kondensator-Code-Decoder: 104 in den seriellen Monitor tippen
Damit das Entschlüsseln in Fleisch und Blut übergeht, schreiben wir ein kleines Werkzeug. Das Programm liest den dreistelligen Code, den du in den seriellen Monitor tippst, und gibt den Wert in pF, nF und µF aus. Auch die Sonderfälle mit 8 oder 9 als dritter Ziffer (×0,01 und ×0,1) werden berücksichtigt. Stell im seriellen Monitor als Zeilenende einfach "Neue Zeile" ein.
1// Kondansatör kodu çözücü / Capacitor code decoder
2// Seri Monitör'e 104, 222, 475 gibi bir kod yaz / Type a code such as 104, 222 or 475
3
4void printValue(float pf) {
5 Serial.print(pf, 1); Serial.print(F(" pF = "));
6 Serial.print(pf / 1000.0, 3); Serial.print(F(" nF = "));
7 Serial.print(pf / 1000000.0, 6); Serial.println(F(" uF"));
8}
9
10void setup() {
11 Serial.begin(9600);
12 Serial.println(F("Kod yaz (or. 104) / Type a code (e.g. 104)"));
13}
14
15void loop() {
16 if (!Serial.available()) return;
17 String code = Serial.readStringUntil('\n');
18 code.trim();
19
20 if (code.length() != 3 || !isDigit(code[0]) || !isDigit(code[1]) || !isDigit(code[2])) {
21 Serial.println(F("3 haneli kod yaz / Enter a 3-digit code"));
22 return;
23 }
24
25 int digits = (code[0] - '0') * 10 + (code[1] - '0'); // ilk iki hane / first two digits
26 int mult = code[2] - '0'; // üçüncü hane / third digit
27 float pf = digits;
28
29 if (mult == 9) pf *= 0.1; // 9 = ×0,1 / 9 means ×0.1
30 else if (mult == 8) pf *= 0.01; // 8 = ×0,01 / 8 means ×0.01
31 else for (int i = 0; i < mult; i++) pf *= 10; // sıfır ekle / append zeros
32
33 Serial.print(code); Serial.print(F(" -> "));
34 printValue(pf);
35}Einheiten umrechnen auf ESP32 und Raspberry Pi Pico
Der ADC des ESP32 hat 12 Bit und liefert 0-4095, doch die Pins arbeiten mit 3,3 V und der ADC weicht auf jedem Board etwas anders ab. Deshalb ist es genauer, statt eigener Umrechnung die Funktion analogReadMilliVolts() des Cores zu verwenden: Sie nutzt die werkseitig im Chip gespeicherte Kalibrierung und liefert direkt Millivolt. Mit der Standarddämpfung von 11 dB reicht der Messbereich bis etwa 3,1 V, am genauesten sind die Werte zwischen 0,15 und 2,45 V.
1// ESP32: ham ADC değeri ve kalibrasyonlu mV / raw ADC value and calibrated mV
2const int ADC_PIN = 34; // yalnız giriş pini, ADC1 / input-only pin, ADC1
3
4void setup() {
5 Serial.begin(115200);
6 analogReadResolution(12); // 0-4095
7}
8
9void loop() {
10 int raw = analogRead(ADC_PIN);
11 unsigned long mv = analogReadMilliVolts(ADC_PIN); // fabrika kalibrasyonu / factory calibration
12 float volts = mv / 1000.0; // mV -> V
13 Serial.printf("ham/raw: %d mV: %lu V: %.3f\n", raw, mv, volts);
14 delay(500);
15}Beim Raspberry Pi Pico skaliert MicroPython mit read_u16() den Wert auf 0-65535, obwohl der ADC nur 12 Bit hat. Der Umrechnungsfaktor muss also 3,3 / 65535 lauten, nicht 3,3 / 4095; mit dem falschen Faktor wird das Ergebnis 16-mal zu groß. Die echte Auflösung liegt trotzdem bei 3,3 V / 4096 ≈ 0,8 mV.
1# Pico: ADC değerini mV ve V'a çevirme / converting ADC readings to mV and V
2from machine import ADC
3import time
4
5adc = ADC(26) # GP26 = ADC0
6CONV = 3.3 / 65535 # read_u16() 0-65535 aralığı / range of read_u16()
7
8while True:
9 raw = adc.read_u16()
10 volts = raw * CONV
11 mv = volts * 1000 # V -> mV
12 print("ham/raw:", raw, " mV:", round(mv), " V:", round(volts, 3))
13 time.sleep(0.5)Typische Einheitenfehler und ihre Lösung
- m und M verwechseln: Zwischen 1 mΩ (Milliohm) und 1 MΩ (Megaohm) liegt der Faktor eine Milliarde. Kleines m heißt Milli, großes M heißt Mega; achte im Schaltplan auf die Schreibweise.
- 104 als 104 pF lesen: Die dritte Ziffer ist die Anzahl der Nullen, der Wert ist 100.000 pF. Nur zweistellige Aufdrucke wie 22 und 47 sind direkt Pikofarad; bei dreistelligen Codes bedeutet sogar 220 nicht 220 pF, sondern 22 pF.
- mAh ohne Spannung vergleichen: Rechne beim Vergleich von Akkus mit unterschiedlicher Spannung in Wh um, sonst wirkt ein 9-V-Block schwächer und eine AA-Zelle stärker, als sie sind.
- Ganzzahldivision: Im Arduino ergibt 3 / 2 den Wert 1. Brauchst du Nachkommastellen, schreib eine der Zahlen als 3.0 oder verwende float.
- int-Überlauf: Produkte wie analogRead() × 5000 sprengen auf dem Uno die Grenze von 32.767. Caste vor der Multiplikation auf (long).
- W und Wh verwechseln: W ist die momentane Leistung, Wh die Energie, die verbraucht wird, wenn diese Leistung eine Stunde lang anliegt. Eine Schaltung mit 2 W läuft an einem 10-Wh-Akku ohne Verluste 5 Stunden.
- Die Belastbarkeit des Widerstands vergessen: 1/4 W sind 250 mW. Ein 100-Ω-Widerstand an 12 V setzt 1,44 W um und verbrennt einen normalen Viertelwatt-Widerstand; mach also immer die Leistungsberechnung.
Sitzen die Vorsätze und Einheiten-Abkürzungen erst einmal, liest du Datenblätter, wählst Bauteile und schreibst den richtigen Faktor in deinen Code viel schneller. Wenn du das Gelernte praktisch umsetzen willst, zeigen dir die Projekte LCD-Digitalvoltmeter, Lichtstärke messen mit LDR, Temperaturmessung mit NTC und ESP32 Deep Sleep in der BlueGrays-App Schritt für Schritt mit Schaltplan und Code, wie ADC-Werte, Ströme und Akkulaufzeiten berechnet werden.
Häufige Fragen
Wie viel nF hat ein 104-Kondensator?
Der Code 104 wird als 10 mit vier angehängten Nullen gelesen: 100.000 pF. Das sind 100 nF oder 0,1 µF. Genau dieser Wert sitzt als Abblockkondensator an der Versorgung fast jeder Arduino-Schaltung.
Wie viel nF sind 1 µF?
1 µF entspricht 1000 nF. Um nF in µF umzurechnen, teilst du durch 1000; zum Beispiel sind 470 nF = 0,47 µF und 22 nF = 0,022 µF.
Was bedeutet 2n2 auf einem Kondensator?
Bei 2n2 steht das n zugleich für die Einheit Nanofarad und für das Komma, der Wert ist also 2,2 nF oder 2200 pF. Derselbe Kondensator kann auch mit dem dreistelligen Code 222 beschriftet sein.
Wie rechnet man mAh in Wh um?
Multipliziere die mAh mit der Nennspannung des Akkus und teile durch 1000: Wh = mAh × V / 1000. Eine 18650-Zelle mit 3,7 V und 2600 mAh speichert etwa 9,6 Wh.
Was bedeutet 4k7 bei einem Widerstand?
Bei 4k7 steht das k zugleich für Kiloohm und für das Komma, der Wert ist also 4,7 kΩ oder 4700 Ω. Es ist einer der häufigsten Pull-up-Werte für I2C-Leitungen.
Was bedeutet MFD auf einem Kondensator?
MFD ist eine alte Schreibweise für Mikrofarad. Ein Anlauf- oder Betriebskondensator mit der Aufschrift 35 MFD hat also 35 µF; die verwandte Angabe MMFD bedeutet Pikofarad.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Lichtstärke messen mit LDR
Willst du sehen, wie hell dein Zimmer ist, und zwar als Zahl? Der LDR, ein kleines lichtempfindliches Bauteil, misst das Umgebungslicht, und der Arduino schreibt den Wert jede halbe Sekunde auf…

Messung der Lichtintensität mit dem ESP32-LDR-Modul
Echtzeit-Anzeige des ADC-Rohwerts des LDR-Moduls und des anhand von Dunkel- und Hellreferenzwerten berechneten relativen Lichtwerts in Prozent im Serial Monitor. Dieser Prozentwert ist keine Lux-Messung. Vermittelt die Kalibrierungslogik des Moduls. Sollte idealerweise vor Projekt 10 durchgeführt werden, da es zur Festlegung des Schwellenwerts dient.

HC-SR04 Abstandsmessung (serielle Anzeige)
Der Sensor HC-SR04 funktioniert wie eine Fledermaus, die im Dunkeln ihren Weg findet: Er sendet einen Ton, den du nicht hörst, lauscht auf das Echo und misst, wie weit der Gegenstand vor ihm entfernt…

Digitales Voltmeter mit LCD-Anzeige
Finde mit einem selbstgebauten Messgerät heraus, wie viel Spannung eine Batterie oder ein Netzteil liefert.

Temperaturmessung mit NTC und 2x16 Lcd Display
Miss die Umgebungstemperatur mit einem Sensor, der aussieht wie eine kleine Perle.

ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)
In diesem Projekt steuern wir die Helligkeit einer LED analog über ein Potentiometer. Der ADC-Pin des ESP32 liest die vom Potentiometer kommende Spannung von 0-3,3 V aus, woraufhin dieser Wert in ein PWM-Signal (Pulsweitenmodulation) umgewandelt und an die LED gesendet wird. So leuchtet die LED beim Drehen des Potentiometers stufenweise auf und erlischt wieder. Mit Arduino Core 3.0+ kann analogWrite() direkt verwendet werden; bei ESP32-S2/S3 ist die ADC-Auflösung auf 12 Bit festgelegt.

ESP32 Deep Sleep – Batteriesparmodus (OLED + RTC-RAM-Zähler)
Im Deep-Sleep-Modus schaltet der ESP32 die CPU und die meisten Peripheriegeräte ab und senkt den Strom auf etwa 10µA, entscheidend für batteriebetriebene IoT-Geräte. Das Projekt nutzt drei Weckquellen: einen Timer (15 s), einen externen Pin (EXT0, Taster an GPIO 33) und einen Touch-Pin (T0/GPIO 4). Mit RTC_DATA_ATTR markierte Zähler bleiben im Deep Sleep erhalten.

Frequenzeinstellung mit Buzzer
Mit vier Knöpfen steuerst du den Ton eines Summers: Einer startet den Ton, einer macht ihn stumm, die anderen beiden machen ihn höher oder tiefer.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

