Grundlagen · 11 Min. Lesezeit

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.

Elektrolytkondensatoren mit der Aufschrift 470 µF 16 V und 220 µF 16 V
Auf Elkos steht der Wert im Klartext (470 µF, 16 V); kleine Keramikkondensatoren tragen dagegen Codes wie 104.

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.

VorsatzSymbolFaktorBeispiel aus der Elektronik
Pikop10⁻¹² (0,000 000 000 001)22 pF Lastkondensator am Quarz
Nanon10⁻⁹ (0,000 000 001)100 nF Abblockkondensator, 62,5 ns Taktperiode
Mikroµ (u)10⁻⁶ (0,000 001)10 µF Kondensator, 10 µA Schlafstrom
Millim10⁻³ (0,001)20 mA LED-Strom, 4,88 mV ADC-Schritt
(Grundeinheit)-15 V, 1 A, 1 Ω, 1 F
Kilok10³ (1000)10 kΩ Pull-up-Widerstand, 38 kHz IR-Träger
MegaM10⁶ (1 000 000)1 MΩ Eingangswiderstand, 16 MHz Takt
GigaG10⁹2,4 GHz WLAN und Bluetooth
Ein Vorsatz nach oben oder unten heißt: Komma um drei Stellen verschieben. Von einer kleinen zu einer größeren Einheit wird die Zahl kleiner (2200 pF = 2,2 nF), von einer großen zu einer kleineren wird sie größer (0,1 µF = 100 nF). Fehlt auf der Tastatur das µ, schreibt man u: 10uF ist dasselbe wie 10 µF.

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.

pFnFµFCode
10 pF0,01 nF0,00001 µF100
22 pF0,022 nF0,000022 µF220
100 pF0,1 nF0,0001 µF101
1000 pF1 nF0,001 µF102
2200 pF2,2 nF (2n2)0,0022 µF222
4700 pF4,7 nF (4n7)0,0047 µF472
10.000 pF10 nF0,01 µF103
47.000 pF47 nF0,047 µF473
100.000 pF100 nF0,1 µF104
220.000 pF220 nF0,22 µF224
470.000 pF470 nF0,47 µF474
1.000.000 pF1000 nF1 µF105
10.000.000 pF10.000 nF10 µF106

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?.

  1. Schreib die ersten beiden Ziffern auf: 47 bei 474.
  2. Häng so viele Nullen an, wie die dritte Ziffer sagt: 47 und 4 Nullen ergibt 470.000 pF.
  3. Teil durch 1000, um nF zu erhalten: 470.000 pF = 470 nF.
  4. Teil noch einmal durch 1000, um µF zu erhalten: 470 nF = 0,47 µF.
  5. 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 %.
  6. Steht vor dem Code etwas wie 2A oder 1H, ist das die Spannungsfestigkeit: 1H = 50 V, 2A = 100 V, 2J = 630 V.
AufdruckBedeutungWert
2n2n ersetzt das Komma2,2 nF = 2200 pF
4n7n ersetzt das Komma4,7 nF = 4700 pF
µ1 oder u1µ ersetzt das Komma0,1 µF = 100 nF
4µ7µ ersetzt das Komma4,7 µF
p68p ersetzt das Komma0,68 pF
109Dritte Ziffer 9 = ×0,11,0 pF
104ZZ = +80 % / -20 % Toleranz100 nF
35 MFDAlte Schreibweise: MFD = Mikrofarad35 µF
Auf älteren und amerikanischen Kondensatoren stehen MFD und sogar mF für Mikrofarad; die "35 MFD" auf dem Kondensator eines Deckenventilators oder einer Klimaanlage sind 35 µF, nicht 35 Millifarad. Ebenso bedeutet MMFD in alten Schaltplänen Pikofarad. Wenn du Ersatz kaufst, deute die Einheit aus dem Zusammenhang; ein Kondensator in dieser Größe kann ohnehin keine Millifarad haben.

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.

SchreibweiseWertIn Ohm
R470,47 Ω0,47 Ω
2R22,2 Ω2,2 Ω
220R220 Ω220 Ω
1K1 kΩ1000 Ω
4K74,7 kΩ4700 Ω
47K47 kΩ47.000 Ω
1M01 MΩ1.000.000 Ω
103 (SMD)10 und 3 Nullen10.000 Ω = 10 kΩ
4701 (SMD, 4-stellig)470 und 1 Null4700 Ω = 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?.

SituationTypischer WertIn Grundeinheit
Arduino-Uno-Pinstrom (empfohlen / absolutes Maximum)20 mA / 40 mA0,02 A / 0,04 A
Betriebsstrom einer roten LED10-20 mA0,01-0,02 A
ESP32 beim WLAN-Sendenbis 250 mA0,25 A
Deep-Sleep-Strom des ESP32-Chipsetwa 10 µA0,00001 A
ADC-Schritt Arduino Uno (5 V, 10 Bit)4,88 mV0,00488 V
ADC-Schritt ESP32 und Pico (3,3 V, 12 Bit)etwa 0,8 mV0,0008 V
Blockierstrom eines SG90-Servos650-700 mAetwa 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.

FormelEinheiten-KombinationBeispiel
I = U / RV / kΩ = mA5 V / 10 kΩ = 0,5 mA
R = U / IV / mA = kΩ(5 V - 2 V) / 20 mA = 0,15 kΩ = 150 Ω
U = I × RmA × kΩ = V2 mA × 4,7 kΩ = 9,4 V
P = U × IV × mA = mW5 V × 20 mA = 100 mW
τ = R × CkΩ × µF = ms10 kΩ × 100 µF = 1000 ms = 1 s
τ = R × CkΩ × nF = µs10 kΩ × 100 nF = 1000 µs = 1 ms
τ = R × CMΩ × µF = s1 MΩ × 10 µF = 10 s
Die zweite Zeile der Tabelle ist eigentlich eine LED-Vorwiderstand-Berechnung: Zieh von 5 V die 2 V Flussspannung der LED ab, teil die restlichen 3 V durch 20 mA und du erhältst 0,15 kΩ. Gibt es den Wert in der Normreihe nicht, nimm den nächsthöheren (150 Ω oder 220 Ω). Um mit Zeitkonstanten in RC-Gliedern zu experimentieren, probier den RC-Zeitkonstanten-Rechner aus.

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 / AkkuKapazitätSpannungEnergie
CR2032 Knopfzelle220 mAh3 V0,66 Wh
AA Alkaline (Mignon)etwa 2500 mAh1,5 Vetwa 3,75 Wh
9-V-Block Alkalineetwa 500 mAh9 Vetwa 4,5 Wh
1000-mAh-LiPo1000 mAh3,7 V3,7 Wh
18650 Li-Ion2600 mAh3,7 V9,62 Wh
10.000-mAh-Powerbank10.000 mAh3,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Ω.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

MicroPython
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.
Wenn dir ein Ergebnis verdächtig vorkommt, schreib die Einheiten zu den Zahlen und kürze sie. Kommt nicht die erwartete Einheit heraus (mA, ms, Wh), fehlt irgendwo in der Formel ein Vorsatz. Diese Gewohnheit fängt die meisten Fehler schon auf dem Papier ab, in der Prüfung genauso wie an der Werkbank.

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.

Alle Projekte ansehen
Lichtstärke messen mit LDR
AR-11Anfänger

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…

4.6(83)
143
Messung der Lichtintensität mit dem ESP32-LDR-Modul
ES-11Anfänger

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.

4.6(36)
55
HC-SR04 Abstandsmessung (serielle Anzeige)
AR-27Anfänger

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…

4.6(50)
82
Digitales Voltmeter mit LCD-Anzeige
AR-56Mittel
Premium

Digitales Voltmeter mit LCD-Anzeige

Finde mit einem selbstgebauten Messgerät heraus, wie viel Spannung eine Batterie oder ein Netzteil liefert.

4.5(27)
36
Temperaturmessung mit NTC und 2x16 Lcd Display
AR-44Anfänger
Premium

Temperaturmessung mit NTC und 2x16 Lcd Display

Miss die Umgebungstemperatur mit einem Sensor, der aussieht wie eine kleine Perle.

4.5(33)
44
ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)
ES-13Mittel
Premium

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.

4.5(19)
32
ESP32 Deep Sleep – Batteriesparmodus (OLED + RTC-RAM-Zähler)
ES-33Fortgeschritten
Premium

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.

4.3(10)
16
Frequenzeinstellung mit Buzzer
AR-14Mittel

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.

4.6(69)
120