Convertire nF in µF: tabella, codice condensatori e unità
Convertire nF in µF in modo semplice: tabella pF-nF-µF, codice condensatore 104 e 2n2, kΩ, mA, mV, mAh in Wh ed errori di unità tipici nel codice Arduino.
Per convertire nF in µF basta una regola: 1 µF = 1000 nF e 1 nF = 1000 pF. Da nF a µF dividi per 1000, da µF a nF moltiplichi per 1000: 100 nF = 0,1 µF, 4,7 µF = 4700 nF. Il 104 stampato su un condensatore ceramico indica proprio quei 100 nF, cioè 0,1 µF. Quasi tutte le conversioni di unità in elettronica procedono a salti di mille; una volta assimilati i prefissi, anche i calcoli su resistenze, corrente, tensione e batterie diventano molto più semplici.
In questa guida abbiamo raccolto i prefissi p, n, µ, m, k e M in un'unica tabella. Imparerai a leggere i codici dei condensatori (104, 2n2, 474J), le notazioni 4K7 e R47 delle resistenze, a passare da mA ad A e da mV a V, a convertire la capacità di una batteria da mAh a Wh e le scorciatoie di unità che ti permettono di applicare la legge di Ohm a mente. Nell'ultima parte vedremo gli errori di unità più comuni nel codice per Arduino, ESP32 e Raspberry Pi Pico, e come scriverli correttamente.

Prefissi SI: cosa significano p, n, µ, m, k e M?
In elettronica i valori coprono un intervallo enorme: un microcontrollore in sleep assorbe pochi microampere, un motore diversi ampere; il condensatore accanto a un quarzo può essere da 22 picofarad e quello all'uscita di un alimentatore da 2200 microfarad. Per questo, invece di scrivere lunghe file di zeri, usiamo un prefisso. Ogni prefisso moltiplica l'unità di base per una potenza di 10, e quelli usati in elettronica distano tutti un fattore 1000 l'uno dall'altro. Le regole valgono allo stesso modo per volt, ampere, ohm, farad, henry, watt e hertz.
| Prefisso | Simbolo | Fattore | Esempio in elettronica |
|---|---|---|---|
| pico | p | 10⁻¹² (0,000 000 000 001) | Condensatore da 22 pF vicino al quarzo |
| nano | n | 10⁻⁹ (0,000 000 001) | Condensatore di disaccoppiamento da 100 nF, periodo di clock di 62,5 ns |
| micro | µ (u) | 10⁻⁶ (0,000 001) | Condensatore da 10 µF, corrente in sleep di 10 µA |
| milli | m | 10⁻³ (0,001) | LED a 20 mA, passo dell'ADC di 4,88 mV |
| (unità di base) | - | 1 | 5 V, 1 A, 1 Ω, 1 F |
| kilo | k | 10³ (1000) | Resistenza di pull-up da 10 kΩ, portante IR a 38 kHz |
| mega | M | 10⁶ (1 000 000) | Impedenza d'ingresso di 1 MΩ, clock a 16 MHz |
| giga | G | 10⁹ | Wi-Fi e Bluetooth a 2,4 GHz |
Tabella di conversione pF, nF e µF
Quello che confonde di più con i condensatori è che lo stesso valore può comparire in tre unità diverse. Lo schema dice 0,1 µF, il negozio online 100 nF, il componente 104, eppure sono lo stesso pezzo. Per convertire nF in µF dividi per 1000; per passare da pF a nF dividi di nuovo per 1000. Nel senso opposto moltiplichi per 1000. La tabella riunisce i valori più usati insieme ai codici che troverai stampati sopra; vale la pena stamparla e appenderla sopra il banco di lavoro.
| pF | nF | µF | Codice |
|---|---|---|---|
| 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 |
Leggere il codice di un condensatore: quanti nF è 104?
Sui piccoli condensatori ceramici e in poliestere il valore completo non ci sta, quindi viene stampato un codice a tre cifre la cui unità è sempre il picofarad. Le prime due cifre sono il valore, la terza indica quanti zeri aggiungere. Per 104 metti quattro zeri dopo il 10: 100.000 pF, cioè 100 nF o 0,1 µF. Se non vuoi farlo a mente, il calcolatore del codice dei condensatori lo risolve in un secondo; come funzionano i condensatori lo spieghiamo in Cos'è un condensatore?.
- Scrivi le prime due cifre: 47 per 474.
- Aggiungi tanti zeri quanti ne indica la terza cifra: 47 più 4 zeri fa 470.000 pF.
- Dividi per 1000 per passare ai nF: 470.000 pF = 470 nF.
- Dividi ancora per 1000 per passare ai µF: 470 nF = 0,47 µF.
- Guarda la lettera dopo il codice: J significa ±5%, K ±10% e M ±20% di tolleranza. Un 474J è quindi un condensatore da 0,47 µF al ±5%.
- Se prima del codice c'è una sigla come 2A o 1H, è la tensione di lavoro: 1H = 50 V, 2A = 100 V, 2J = 630 V.
| Scritta | Significato | Valore |
|---|---|---|
| 2n2 | La n fa da virgola | 2,2 nF = 2200 pF |
| 4n7 | La n fa da virgola | 4,7 nF = 4700 pF |
| µ1 o u1 | La µ fa da virgola | 0,1 µF = 100 nF |
| 4µ7 | La µ fa da virgola | 4,7 µF |
| p68 | La p fa da virgola | 0,68 pF |
| 109 | Terza cifra 9 = ×0,1 | 1,0 pF |
| 104Z | Z = tolleranza +80% / -20% | 100 nF |
| 35 MFD | Vecchia notazione: MFD = microfarad | 35 µF |
Unità delle resistenze: Ω, kΩ, MΩ e la notazione 4K7
L'unità di base delle resistenze è l'ohm (Ω), ma la maggior parte dei valori che vedrai nei circuiti con Arduino è nell'ordine dei kiloohm: 220 Ω per un LED, 10 kΩ di pull-up, 1 MΩ per un ingresso ad alta impedenza. Negli schemi e nelle distinte componenti si usa una lettera al posto della virgola, perché un puntino può sparire in stampa mentre una lettera no. R indica gli ohm, K i kiloohm e M i megaohm, e la posizione della lettera segna la virgola. Per decifrare le fasce colorate consulta la nostra guida al codice colori delle resistenze o il calcolatore del codice colori; per codici come 103 e 4701 sui componenti SMD leggi i codici delle resistenze SMD.
| Notazione | Valore | 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 e 3 zeri | 10.000 Ω = 10 kΩ |
| 4701 (SMD, 4 cifre) | 470 e 1 zero | 4700 Ω = 4,7 kΩ |
Il codice a tre cifre funziona allo stesso modo su resistenze e induttori, ma l'unità di base cambia: picofarad su un condensatore, ohm su una resistenza SMD e microhenry su un induttore. Quindi 101 su un condensatore vale 100 pF, su una resistenza SMD 100 Ω e su un induttore 100 µH. Non interpretare mai un codice senza sapere su che componente si trova.
Corrente e tensione: convertire mA in A, µA e mV in V
Con la corrente passerai soprattutto da mA ad A: 1 A = 1000 mA e 1 mA = 1000 µA. Un LED che assorbe 20 mA assorbe 0,02 A; i 10 µA di un ESP32 in deep sleep sono 0,01 mA, cioè 0,00001 A. La tensione segue gli stessi salti: 1 V = 1000 mV. L'ADC a 10 bit di Arduino Uno divide 5 V in 1024 parti, quindi ogni passo vale 5 / 1024 = 0,00488 V, cioè 4,88 mV. Nei datasheet dei sensori trovi rapporti come mV per grado (10 mV/°C per l'LM35) o mV per ampere (185 mV/A per l'ACS712-5A); usarli nell'unità giusta determina la precisione della misura. La lettura analogica è spiegata in dettaglio in Cos'è un ADC?.
| Situazione | Valore tipico | In unità di base |
|---|---|---|
| Corrente per pin di Arduino Uno (consigliata / massimo assoluto) | 20 mA / 40 mA | 0,02 A / 0,04 A |
| Corrente di lavoro di un LED rosso | 10-20 mA | 0,01-0,02 A |
| ESP32 durante una trasmissione Wi-Fi | fino a 250 mA | 0,25 A |
| Corrente del chip ESP32 in deep sleep | circa 10 µA | 0,00001 A |
| Passo dell'ADC di Arduino Uno (5 V, 10 bit) | 4,88 mV | 0,00488 V |
| Passo dell'ADC di ESP32 e Pico (3,3 V, 12 bit) | circa 0,8 mV | 0,0008 V |
| Corrente di stallo di un servo SG90 | 650-700 mA | circa 0,7 A |
Scorciatoie di unità per la legge di Ohm: V, mA e kΩ
Non serve convertire ogni valore nell'unità di base prima di calcolare. Se abbini i prefissi in modo che si annullino, il risultato esce direttamente nell'unità giusta. L'abbinamento più comodo è questo: volt diviso kiloohm dà milliampere. Se applichi 5 V a una resistenza di pull-up da 10 kΩ scorrono 5 / 10 = 0,5 mA, senza impazzire con gli zeri. Con la stessa logica, milliampere per kiloohm dà volt, e volt per milliampere dà milliwatt. Vale anche per la carica di un condensatore: kiloohm per microfarad dà millisecondi. Per ripassare le basi leggi La legge di Ohm, oppure usa il calcolatore della legge di Ohm per un risultato veloce.
| Formula | Abbinamento di unità | Esempio |
|---|---|---|
| I = V / R | V / kΩ = mA | 5 V / 10 kΩ = 0,5 mA |
| R = V / I | V / mA = kΩ | (5 V - 2 V) / 20 mA = 0,15 kΩ = 150 Ω |
| V = I × R | mA × kΩ = V | 2 mA × 4,7 kΩ = 9,4 V |
| P = V × 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 e Wh: convertire la capacità di una batteria
I mAh (milliampere-ora) dicono quanta corrente una batteria può erogare e per quante ore, mentre i Wh (wattora) dicono quanta energia contiene davvero. Per confrontare batterie con tensioni diverse servono i Wh, perché una pila AA da 2000 mAh e una batteria al litio da 2000 mAh non accumulano la stessa energia. La formula è semplice: Wh = mAh × V / 1000. Una cella 18650 da 2600 mAh e 3,7 V contiene 2600 × 3,7 / 1000 = 9,62 Wh. Il limite di 100 Wh che le compagnie aeree fissano per i power bank nel bagaglio a mano corrisponde a circa 27.000 mAh a 3,7 V.
Per stimare l'autonomia dividi la capacità per la corrente media: ore = mAh / mA. In pratica la batteria non si sfrutta tutta e il regolatore spreca energia, quindi moltiplicare il risultato per 0,7-0,8 è più realistico. Un progetto con ESP32 che assorbe in media 80 mA dura circa 2600 / 80 × 0,8 = 26 ore con una cella da 2600 mAh. I 10.000 mAh stampati su un power bank si riferiscono alle sue celle da 3,7 V; portati a 5 V con un rendimento di circa l'85%, restano all'incirca 10.000 × 3,7 × 0,85 / 5 ≈ 6300 mAh utilizzabili. Per il calcolo dettagliato leggi Cosa significa mAh? oppure prova il calcolatore di autonomia della batteria.
| Pila / batteria | Capacità | Tensione | Energia |
|---|---|---|---|
| Pila a bottone CR2032 | 220 mAh | 3 V | 0,66 Wh |
| Pila AA alcalina (stilo) | circa 2500 mAh | 1,5 V | circa 3,75 Wh |
| Batteria alcalina da 9 V | circa 500 mAh | 9 V | circa 4,5 Wh |
| LiPo da 1000 mAh | 1000 mAh | 3,7 V | 3,7 Wh |
| Cella 18650 agli ioni di litio | 2600 mAh | 3,7 V | 9,62 Wh |
| Power bank da 10.000 mAh | 10.000 mAh | 3,7 V (cella) | 37 Wh |
Tempo e frequenza: ms, µs, Hz, kHz e MHz
Frequenza e periodo sono l'uno l'inverso dell'altra: T = 1 / f. Dato che l'hertz è "uno al secondo", l'inverso dei kHz dà millisecondi e quello dei MHz microsecondi. I servomotori si pilotano a 50 Hz, quindi arriva un impulso ogni 1 / 50 = 0,02 s = 20 ms. La maggior parte dei pin PWM di Arduino Uno lavora a circa 490 Hz con un periodo di 2,04 ms; i pin 5 e 6 a 980 Hz con 1,02 ms (più dettagli in Cos'è il PWM?). Con un clock a 16 MHz un ciclo dura 62,5 ns. Non confondere nemmeno le due funzioni di tempo di Arduino: millis() restituisce millisecondi, micros() microsecondi, e delayMicroseconds() è precisa solo fino a 16.383 µs; per attese più lunghe usa la temporizzazione con millis.
Anche le unità di velocità si basano sulle stesse conversioni. Nel sensore a ultrasuoni HC-SR04 la velocità del suono è di 343 m/s; convertita in cm/µs diventa 34.300 cm / 1.000.000 µs = 0,0343 cm/µs. Poiché il sensore restituisce il tempo di andata e ritorno dell'eco, distanza = tempo (µs) × 0,0343 / 2, e un'eco di 1000 µs corrisponde a 17,15 cm. Se sai da dove viene quel 0,0343, puoi ricavare da solo il fattore giusto quando vuoi il risultato in metri o in pollici.
Errori di unità nel codice Arduino: convertire la lettura dell'ADC in mV e V
Anche quando la conversione è giusta sulla carta, nel codice ti aspettano due trappole. La prima è l'overflow di int: su Arduino Uno un int contiene al massimo 32.767, ma 1023 × 5000 fa 5.115.000 e il risultato diventa insensato. La seconda è la divisione intera: 4700 / 1000 dà 4 e non 4,7, perché dividendo due interi la parte decimale viene scartata. La soluzione è eseguire la moltiplicazione con un long e scrivere 1000.0 invece di 1000 quando vuoi un risultato con i decimali. Lo sketch seguente converte correttamente la tensione su A0 in mV e V, poi calcola la tensione reale all'ingresso di un partitore di tensione da 10 kΩ e 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}Il cast (long)raw fa eseguire la moltiplicazione a 32 bit, così non c'è overflow. Dividiamo per 1024 perché è la formula del datasheet dell'ATmega328P; la differenza rispetto a 1023 è intorno allo 0,1 per cento. Scrivere le resistenze del partitore in kΩ non è un problema, perché nel rapporto le unità si annullano. Con questo partitore A0 riceve al massimo 5 V, mentre all'ingresso puoi misurare fino a circa 15,6 V.
Decodificatore del codice dei condensatori: scrivi 104 nel Monitor seriale
Per rendere la decodifica un automatismo, scriviamo un piccolo strumento. Il programma legge il codice a tre cifre che digiti nel Monitor seriale e ne stampa il valore in pF, nF e µF. Gestisce anche i casi speciali in cui la terza cifra è 8 o 9 (×0,01 e ×0,1). Basta impostare il fine riga del Monitor seriale su "A capo (NL)".
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}Conversioni di unità su ESP32 e Raspberry Pi Pico
L'ADC dell'ESP32 è a 12 bit e restituisce 0-4095, ma i pin lavorano a 3,3 V e l'ADC devia in modo leggermente diverso su ogni scheda. Per questo è meglio usare la funzione analogReadMilliVolts() del core invece di convertire da solo il valore grezzo: sfrutta la calibrazione scritta in fabbrica nel chip e restituisce direttamente i millivolt. Con l'attenuazione predefinita di 11 dB l'intervallo misurabile arriva a circa 3,1 V, e i risultati più precisi si ottengono tra 0,15 e 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}Sul Raspberry Pi Pico la funzione read_u16() di MicroPython scala il valore su 0-65535 anche se l'ADC è a 12 bit. Il fattore di conversione deve quindi essere 3,3 / 65535 e non 3,3 / 4095; con il fattore sbagliato il risultato è 16 volte troppo grande. La risoluzione reale resta comunque 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)Errori di unità frequenti e come risolverli
- Confondere m con M: tra 1 mΩ (milliohm) e 1 MΩ (megaohm) c'è un fattore di un miliardo. La m minuscola è milli, la M maiuscola è mega; fai attenzione alla lettera sullo schema.
- Leggere 104 come 104 pF: la terza cifra è il numero di zeri, quindi il valore è 100.000 pF. Solo le scritte a due cifre come 22 e 47 sono picofarad diretti; nei codici a tre cifre persino 220 significa 22 pF e non 220 pF.
- Confrontare i mAh senza guardare la tensione: per confrontare batterie con tensioni diverse passa ai Wh, altrimenti una batteria da 9 V sembrerà più debole e una pila AA più forte di quanto siano.
- Divisione intera: in Arduino 3 / 2 fa 1. Se ti servono i decimali, scrivi uno dei numeri come 3.0 oppure usa float.
- Overflow di int: prodotti come analogRead() × 5000 superano il limite di 32.767 di Arduino Uno. Fai il cast a (long) prima di moltiplicare.
- Confondere W e Wh: il W è la potenza istantanea, il Wh l'energia consumata quando quella potenza dura un'ora. Un circuito da 2 W funziona 5 ore con una batteria da 10 Wh, perdite escluse.
- Dimenticare la potenza della resistenza: 1/4 W equivale a 250 mW. Una resistenza da 100 Ω collegata a 12 V dissipa 1,44 W e brucia una normale resistenza da un quarto di watt; fai sempre il calcolo della potenza.
Con prefissi e scorciatoie di unità ben chiari, leggere un datasheet, scegliere i componenti e scrivere il fattore giusto nel codice diventa molto più rapido. Se vuoi mettere in pratica quanto visto, nell'app BlueGrays i progetti voltmetro digitale con LCD, lettura della luce con LDR, misura della temperatura con NTC e deep sleep dell'ESP32 mostrano passo dopo passo, con schema e codice, come si calcolano le letture dell'ADC, le correnti e l'autonomia della batteria.
Domande frequenti
Quanti nF è un condensatore 104?
Il codice 104 si legge come 10 seguito da quattro zeri: 100.000 pF. Equivale a 100 nF, cioè 0,1 µF. È il condensatore di disaccoppiamento che trovi sull'alimentazione di quasi ogni circuito con Arduino.
Quanti nF sono 1 µF?
1 µF equivale a 1000 nF. Per convertire nF in µF dividi per 1000: per esempio 470 nF = 0,47 µF e 22 nF = 0,022 µF.
Cosa significa 2n2 su un condensatore?
In 2n2 la lettera n indica sia l'unità (nanofarad) sia la virgola, quindi il valore è 2,2 nF, cioè 2200 pF. Lo stesso condensatore può riportare anche il codice a tre cifre 222.
Come si convertono i mAh in Wh?
Moltiplica i mAh per la tensione nominale della batteria e dividi per 1000: Wh = mAh × V / 1000. Una cella 18650 da 3,7 V e 2600 mAh contiene circa 9,6 Wh.
Cosa vuol dire 4K7 su una resistenza?
In 4K7 la K indica sia i kiloohm sia la virgola, quindi il valore è 4,7 kΩ, cioè 4700 Ω. È uno dei valori di pull-up più usati sulle linee I2C.
Cosa significa MFD su un condensatore?
MFD è una vecchia notazione per microfarad. Un condensatore di avviamento o di marcia con la scritta 35 MFD è quindi da 35 µF; la sigla simile MMFD indica invece i picofarad.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Misurare l'intensità luminosa con LDR
Vuoi vedere quanto è luminosa la tua stanza sotto forma di numero? L'LDR, un piccolo componente sensibile alla luce, misura la luce ambiente e l'Arduino scrive il valore sullo schermo del computer…

Lettura dell'intensità luminosa con il modulo LDR ESP32
Monitoraggio in tempo reale sul Serial Monitor del valore grezzo dell'ADC del modulo LDR e della percentuale relativa di luce calcolata dai valori di riferimento al buio e alla luce. Questa percentuale non è una misurazione in lux. Spiega il principio di calibrazione del modulo. È consigliabile eseguirlo prima del Progetto 10, poiché serve a determinare il valore di soglia.

HC-SR04 Misura della distanza (display seriale)
Il sensore HC-SR04 funziona come un pipistrello che trova la strada al buio: manda un suono che non puoi sentire, ne ascolta l'eco e misura quanto è lontano l'oggetto davanti a sé.

Voltmetro digitale con display LCD
Scopri quanta tensione dà una pila o un alimentatore con uno strumento costruito da te.

Misura di temperatura con NTC e display Lcd 2x16
Misura la temperatura dell'ambiente con un sensore che sembra una piccola perlina.

Luminosità di un LED con Potenziometro su ESP32 (Analogico → PWM)
In questo progetto controlliamo in modo analogico la luminosità di un LED tramite un potenziometro. Il pin ADC dell'ESP32 legge la tensione tra 0 e 3,3 V dal potenziometro; il valore viene convertito in un segnale PWM (Pulse Width Modulation) e inviato al LED. Ruotando il potenziometro, il LED si accende e si spegne gradualmente. Con Arduino Core 3.0+ si usa direttamente analogWrite(); su ESP32-S2/S3 la risoluzione dell'ADC è fissata a 12 bit.

ESP32 Deep Sleep — Risparmio della batteria (OLED + contatore in RTC RAM)
La modalità Deep Sleep dell'ESP32 spegne la CPU e quasi tutte le periferiche e riduce il consumo a circa 10µA, un aspetto cruciale per i dispositivi IoT a batteria. Il progetto usa tre sorgenti di risveglio: un timer (15 s), un pin esterno (EXT0, il pulsante su GPIO 33) e un pin touch (T0/GPIO 4). I contatori marcati con RTC_DATA_ATTR restano salvati durante il deep sleep.

Impostazione della frequenza con cicalino
Comandi il suono di un buzzer con quattro pulsanti: uno avvia il suono, uno lo zittisce e gli altri due lo rendono più acuto o più grave.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

