MOSFET con Arduino: comandare strisce LED, motori e pompe 12V

Un circuito con MOSFET e Arduino è il modo più efficiente per accendere e spegnere in sicurezza carichi da diversi ampere, come una striscia LED a 12 V, un motore DC, una pompa dell'acqua o una serratura a solenoide, usando pin di Arduino che possono fornire solo circa 20 mA. Il MOSFET è un interruttore elettronico comandato in tensione: applica 5 V al gate e il percorso tra drain e source diventa quasi un filo senza resistenza; a 0 V è completamente interdetto. Un MOSFET logic level scelto bene si intiepidisce appena portando un carico di 3 A senza dissipatore.

In questo articolo imparerai come funziona un MOSFET, perché non tutti i MOSFET vanno bene con Arduino (la differenza tra IRLZ44N e IRF520), a cosa servono la resistenza di gate, la resistenza di pull-down e il diodo di ricircolo (flyback), e come regolare velocità e luminosità con il PWM. Più avanti trovi codice pronto per striscia LED, motore DC, pompa e serratura a solenoide a 12 V, esempi per ESP32 e Raspberry Pi Pico, il calcolo del riscaldamento e del dissipatore e una tabella di confronto tra MOSFET, transistor e relè.

Che cos'è un MOSFET e come funziona?

Il MOSFET (Metal Oxide Semiconductor Field Effect Transistor) è un transistor a effetto di campo con tre piedini: gate, drain e source. Il gate è isolato dal resto del componente da un sottile strato di ossido, quindi non vi scorre corrente continua e si comporta come un piccolo condensatore. Quando la tensione tra gate e source (VGS) supera una certa soglia, tra drain e source si forma un canale conduttivo attraverso cui passa la corrente del carico. Un classico transistor BJT si pilota con la corrente di base, mentre il MOSFET si pilota in tensione; il pin di Arduino fornisce corrente solo nei pochi microsecondi in cui carica e scarica il gate.

Nei progetti con Arduino si usa quasi sempre un MOSFET a canale N posto sul lato negativo (GND) del carico: si chiama commutazione low-side. Il positivo del carico va direttamente al positivo dell'alimentatore esterno, il negativo va al drain del MOSFET e il source va a GND. In questo modo la tensione gate-source coincide con la tensione del pin di Arduino. Questi sono i valori del datasheet da controllare:

MOSFET logic level: IRLZ44N, IRF520 e altri

L'errore più comune è guardare VGS(th) e pensare «la soglia è 4 V, Arduino dà 5 V, quindi funziona». La tensione di soglia è il punto in cui il canale lascia passare appena 250 µA; perché il MOSFET porti diversi ampere con bassa resistenza, la tensione di gate deve essere ben più alta. La domanda giusta è: a quale VGS il datasheet garantisce l'RDS(on)? Se è indicata per 4,5 V o 5 V, il MOSFET va in piena conduzione con un Arduino a 5 V e si chiama MOSFET logic level. Se è indicata solo per 10 V, è un MOSFET standard che un pin di Arduino apre solo a metà. Nella nomenclatura di International Rectifier (oggi Infineon) i modelli che iniziano con IRL (IRLZ44N, IRLB8721, IRL540N) sono logic level, mentre IRFZ44N, IRF520 e IRF540N sono standard.

La regola della tabella è semplice: per le schede a 5 V come Uno, Nano e Mega scegli un MOSFET con RDS(on) specificata a 4,5 V o 5 V. Con le schede a 3,3 V come ESP32 e Pico è un po' più difficile, perché i datasheet dei MOSFET TO-220 più diffusi, come IRLZ44N e IRLB8721, non garantiscono alcun valore a 3,3 V; ci torneremo nella sezione sull'ESP32. Non scegliere nemmeno in base al contenitore: IRLZ44N e IRFZ44N hanno lo stesso package e una sigla quasi identica, ma quella sola lettera (L) cambia tutto per Arduino. Puoi controllare l'ordine dei piedini con lo strumento Piedinatura dei transistor; nei MOSFET TO-220, con il lato stampato verso di te, l'ordine da sinistra a destra è gate, drain, source e la linguetta metallica è collegata al drain.

Collegare il MOSFET ad Arduino: resistenza di gate, pull-down e massa comune

Il circuito di base ha cinque elementi: il MOSFET, la resistenza di gate, la resistenza di pull-down, un diodo di ricircolo per i carichi induttivi e un alimentatore esterno. La tabella mostra i collegamenti per tre schede; il carico di esempio è una striscia LED o un motore a 12 V. Tutto il codice dell'articolo usa questi pin.

La resistenza di gate (100–220 Ω) limita la corrente istantanea prelevata dal pin mentre si carica la capacità del gate. La capacità di ingresso dell'IRLZ44N è di circa 1700 pF; senza resistenza il pin vede per un attimo quasi un cortocircuito a ogni commutazione e sulla linea di gate nascono oscillazioni (ringing). Con 220 Ω la corrente di picco è al massimo 5 / 220 ≈ 23 mA e il gate si carica comunque in pochi microsecondi. La resistenza di pull-down (10 kΩ) evita che il gate resti flottante mentre il pin è un ingresso: all'accensione, al reset o durante il caricamento dello sketch. Un gate flottante può caricarsi a metà a causa dei disturbi; il MOSFET resta mezzo acceso, il motore gira da solo e il MOSFET si surriscalda in fretta. Metti la pull-down dal lato del MOSFET, direttamente tra gate e source, così il MOSFET resta spento anche se si stacca il filo di controllo. Le due resistenze formano un piccolo partitore di tensione, ma l'effetto è trascurabile: al gate arrivano 5 × 10000 / 10220 ≈ 4,89 V.

Diodo di ricircolo: perché serve con motori, pompe e solenoidi

I carichi induttivi come motori, pompe, solenoidi, bobine di relè e ventole si oppongono all'interruzione improvvisa della corrente. Nell'istante in cui il MOSFET si spegne, l'energia magnetica della bobina si scarica come un picco di tensione sul drain, molto più alto della tensione di alimentazione (V = L × di/dt). Questo picco può superare il limite VDS del MOSFET e distruggerlo, oppure generare disturbi che resettano Arduino. La soluzione è un diodo collegato in inversa ai capi del carico: catodo (lato con la fascia) al positivo dell'alimentazione, anodo al drain. Nel funzionamento normale il diodo è polarizzato inversamente e non conduce; quando il MOSFET si spegne, la corrente della bobina ricircola nel diodo e si esaurisce dolcemente. Il diodo di body del MOSFET non svolge questo compito, perché si trova tra source e drain e non ai capi del carico. Per approfondire leggi Che cos'è un diodo?.

Passo dopo passo: regolare una striscia LED 12 V con Arduino

1. Prepara i componenti: Arduino Uno, IRLZ44N, resistenze da 220 Ω e 10 kΩ, un potenziometro da 10 kΩ, una striscia LED a 12 V e un alimentatore a 12 V in grado di fornire la corrente della striscia.
2. Calcola la corrente della striscia: una striscia 5050 da 60 LED/m assorbe circa 14,4 W al metro, cioè 1,2 A a 12 V. Due metri richiedono 2,4 A; scegli l'alimentatore con un margine del 20 % (almeno 3 A).
3. Posiziona il MOSFET: collega il source dell'IRLZ44N alla linea GND, il gate a D9 tramite 220 Ω e metti 10 kΩ tra gate e GND.
4. Collega il carico: il filo +12V della striscia va al positivo dell'alimentatore, il filo negativo al drain del MOSFET. I contatti della breadboard reggono circa 1 A; per correnti maggiori usa morsetti a vite o salda i fili del carico.
5. Collega il potenziometro: piedini esterni a 5V e GND, centrale ad A0.
6. Unisci le masse e prova: collega il negativo dell'alimentatore al GND di Arduino, carica il codice e poi inserisci l'alimentatore nella presa.

1// IRLZ44N ile 12 V LED şerit parlaklık kontrolü / 12 V LED strip dimming with an IRLZ44N
2const int STRIP_PIN = 9;    // PWM pini, 220 Ω ile gate'e / PWM pin, to the gate via 220 Ω
3const int POT_PIN = A0;     // potansiyometre orta ucu / potentiometer wiper
4
5void setup() {
6  pinMode(STRIP_PIN, OUTPUT);
7  digitalWrite(STRIP_PIN, LOW);             // açılışta kapalı / off at startup
8  Serial.begin(9600);
9}
10
11void loop() {
12  int pot = analogRead(POT_PIN);            // 0–1023
13  float x = pot / 1023.0;                   // 0.0–1.0
14  int duty = (int)(x * x * 255.0 + 0.5);    // basit gama düzeltmesi / simple gamma correction
15  analogWrite(STRIP_PIN, duty);             // D9'da 490 Hz PWM / 490 Hz PWM on D9
16  Serial.print("Parlaklik / Brightness: %");
17  Serial.println(duty * 100 / 255);
18  delay(50);
19}

analogWrite() genera sul pin 9 un segnale PWM che si accende e si spegne circa 490 volte al secondo; 0 significa completamente spento e 255 completamente acceso. I pin PWM dell'Uno sono 3, 5, 6, 9, 10 e 11; i pin 5 e 6 lavorano a circa 980 Hz. Poiché l'occhio non percepisce la luminosità in modo lineare, elevare al quadrato il valore del potenziometro (una semplice correzione gamma) rende la regolazione molto più morbida ai livelli bassi. Trovi tutti i dettagli sul PWM in Che cos'è il PWM?. Calcoliamo anche il calore: a 2,4 A l'IRLZ44N dissipa P = I² × RDS(on) = 2,4² × 0,025 ≈ 0,14 W, quindi al tatto è appena tiepido. Nel frattempo la striscia LED assorbe 28,8 W: la perdita nel MOSFET è meno dell'uno per cento del totale.

Controllo di velocità di motori e pompe DC con il PWM

Motori e pompe si pilotano con lo stesso circuito della striscia LED; l'unica differenza è il diodo di ricircolo da aggiungere ai capi del carico. I motori hanno anche una corrente di spunto: un motore fermo può assorbire nel primo istante da 3 a 8 volte la corrente di funzionamento. Dimensiona quindi MOSFET e alimentatore sulla corrente di stallo del motore e usa un avvio graduale invece di passare di colpo da 0 a 255. Le mini pompe sommerse assorbono circa 0,1–0,3 A a 3–6 V, le pompe a membrana da 12 V di solito 0,5–1 A; l'IRLZ44N le gestisce entrambe con ampio margine. Alimenta però la mini pompa con una sorgente alla sua tensione (5–6 V), non con l'alimentatore da 12 V; il circuito del MOSFET resta lo stesso. Per scegliere la pompa e realizzare un'irrigazione leggi Mini pompa dell'acqua.

1// IRLZ44N ile motor/pompa hız kontrolü ve yumuşak kalkış / Motor or pump speed control with soft start (IRLZ44N)
2const int MOTOR_PIN = 9;     // 220 Ω ile gate'e / to the gate via 220 Ω
3const int POT_PIN = A0;      // hız ayarı / speed setting
4const int MIN_DUTY = 60;     // bunun altında motor yalnızca vızıldar / below this the motor only hums
5
6int current = 0;             // şu anki PWM değeri / current PWM value
7
8void setup() {
9  pinMode(MOTOR_PIN, OUTPUT);
10  digitalWrite(MOTOR_PIN, LOW);
11  // TCCR1B = (TCCR1B & 0b11111000) | 0x02;   // isteğe bağlı: D9/D10 PWM ≈3,9 kHz / optional: D9/D10 PWM ≈3.9 kHz
12}
13
14void loop() {
15  int target = map(analogRead(POT_PIN), 0, 1023, 0, 255);
16  if (target < MIN_DUTY) target = 0;         // çok düşük hızda tamamen durdur / stop completely at very low speed
17
18  if (current < target) current++;           // yavaşça hızlan / speed up gently
19  else if (current > target) current--;      // yavaşça yavaşla / slow down gently
20
21  analogWrite(MOTOR_PIN, current);
22  delay(8);                                  // 0→255 yaklaşık 2 s / 0→255 takes about 2 s
23}

Il codice si avvicina di un passo alla velocità desiderata letta dal potenziometro ogni 8 ms, così il motore passa da 0 alla massima velocità in circa 2 secondi e la corrente di spunto non fa crollare l'alimentatore. MIN_DUTY è il valore PWM più basso al quale il motore inizia a girare; trovalo provando con il tuo motore. Il PWM a 490 Hz produce un fischio udibile nel motore. La riga commentata con TCCR1B porta la frequenza di D9 e D10 a circa 3,9 kHz; anche la libreria Servo usa il Timer1, quindi non usarle insieme. Alzare ancora la frequenza è allettante, ma poiché un pin di Arduino impiega alcuni microsecondi a caricare il gate di un grosso MOSFET a ogni commutazione, le perdite di commutazione crescono con la frequenza: intorno ai 20 kHz anche un motore da 2 A può causare più di 1 W di perdite nel MOSFET. A queste frequenze si usa un gate driver come il TC4427.

Serrature a solenoide e carichi di breve durata

Le serrature a solenoide da 12 V assorbono 0,5–1 A e quasi tutte non sono progettate per restare alimentate in continuo: se restano attive a lungo, la bobina si scalda. Il codice deve quindi tenere aperta la serratura solo per pochi secondi. Poiché il solenoide viene solo acceso e spento, senza PWM, come diodo di ricircolo basta un 1N4007. Nell'esempio qui sotto, premendo il pulsante su D2 la serratura si apre per 3 secondi e poi si richiude anche se il pulsante resta premuto. Per attivarla con un lettore di schede RFID o un tastierino basta cambiare la condizione dell'if; i tipi di serratura e il comportamento in caso di blackout sono spiegati in Serratura a solenoide.

1// Butonla 3 saniyelik solenoid kilit açma / Open a solenoid lock for 3 seconds with a button
2const int LOCK_PIN = 9;                 // 220 Ω ile IRLZ44N gate'ine / to the IRLZ44N gate via 220 Ω
3const int BUTTON_PIN = 2;               // buton D2 ile GND arasında / button between D2 and GND
4const unsigned long OPEN_MS = 3000;     // kilidin açık kalma süresi / how long the lock stays open
5
6void setup() {
7  pinMode(LOCK_PIN, OUTPUT);
8  digitalWrite(LOCK_PIN, LOW);          // kilit kapalı / locked
9  pinMode(BUTTON_PIN, INPUT_PULLUP);    // basılınca LOW / LOW when pressed
10}
11
12void loop() {
13  if (digitalRead(BUTTON_PIN) == LOW) {
14    digitalWrite(LOCK_PIN, HIGH);       // solenoid çeker, kilit açılır / solenoid pulls in, lock opens
15    delay(OPEN_MS);
16    digitalWrite(LOCK_PIN, LOW);        // bobini soğumaya bırak / let the coil cool down
17    while (digitalRead(BUTTON_PIN) == LOW) {}   // buton bırakılana kadar bekle / wait until released
18    delay(50);                          // buton zıplamasını süz / debounce
19  }
20}

Perché il modulo IRF520 non basta a 5 V

Il modulo MOSFET IRF520, molto diffuso nei kit per principianti, è una schedina con morsetti a vite venduta con valori come «24 V, 5 A». Accanto al MOSFET ci sono alcune resistenze e un LED di segnalazione; la maggior parte delle versioni non ha il diodo di ricircolo. Il problema è il MOSFET stesso: l'IRF520 è un MOSFET standard con soglia di 2–4 V e la sua RDS(on) di 0,27 Ω è garantita solo con VGS = 10 V. Secondo le curve tipiche del datasheet, con 5 V sul gate l'IRF520 inizia a limitare la corrente intorno ai 2 A; in un esemplare con soglia alta questo limite scende sotto 1 A. A quel punto il MOSFET non si comporta più come un interruttore, ma come una resistenza variabile.

Facciamo un esempio: immagina di pilotare con il modulo IRF520 un motore a 12 V che assorbe 2 A. Se sul MOSFET cadono 1,5 V, la potenza dissipata è P = 1,5 × 2 = 3 W. Con una resistenza termica di 62 °C/W per il contenitore TO-220 senza dissipatore, sono circa 186 °C sopra la temperatura ambiente; il MOSFET si surriscalda in fretta e si guasta, o nel migliore dei casi il motore gira piano. I 5 A riportati sul modulo valgono solo con 10 V sul gate. Ecco i morsetti del modulo e come collegarli:

• Sostituisci il MOSFET: dissalda l'IRF520 dal modulo e salda al suo posto un IRLZ44N con lo stesso ordine dei piedini (G-D-S); la scheda funziona allo stesso modo, ma ora va in piena conduzione a 5 V.
• Usa un modulo logic level: i moduli con il MOSFET AOD4184A (D4184) offrono un'RDS(on) di al massimo 9,5 mΩ a 4,5 V e funzionano senza problemi con un Arduino a 5 V.
• Pilota il gate con una tensione più alta: un gate driver come il TC4427 alimentato a 12 V trasforma il segnale a 5 V o 3,3 V di Arduino in 12 V sul gate, e l'IRF520 raggiunge le sue vere prestazioni. Rispetta il limite di tensione di gate: ±20 V per l'IRF520, ±16 V per l'IRLZ44N.
• Usalo così com'è con carichi piccoli: sotto 1 A (una striscia LED corta, una mini pompa) il modulo IRF520 funziona a 5 V con un riscaldamento accettabile; se il MOSFET scotta al tatto, riduci il carico.

MOSFET con ESP32 e Raspberry Pi Pico (3,3 V)

Poiché i pin di ESP32 e Pico forniscono 3,3 V, la scelta del MOSFET è ancora più importante. Il datasheet dell'IRLZ44N specifica l'RDS(on) solo fino a 4 V; secondo le curve tipiche verso i 3 V lascia ancora passare diversi ampere senza problemi, ma con un esemplare a soglia alta non è garantito. Regola pratica: con schede a 3,3 V usa IRLZ44N o IRLB8721 fino a 2–3 A, misura con il multimetro la tensione drain-source mentre il carico è in funzione e calcola la potenza dissipata con P = VDS × I; con un TO-220 senza dissipatore resta sotto 1 W. Per correnti maggiori usa un driver che porti il gate a 5–12 V, per piccoli carichi un AO3400A, la cui RDS(on) è garantita a 2,5 V. Sull'ESP32 scegli per il MOSFET pin come GPIO 25, 26, 27, 32 o 33: GPIO 0, 2, 5, 12 e 15 sono pin di strapping, mentre GPIO 1, 3, 5, 14 e 15 possono andare brevemente HIGH o emettere PWM all'avvio. Su questi pin il carico può accendersi da solo all'avvio, oppure la pull-down può disturbare il boot.

Il codice ESP32 qui sotto avvia una pompa tramite il MOSFET con avvio graduale quando il sensore di umidità del terreno segnala terra secca, irriga per 5 secondi e poi la ferma dolcemente. Per il PWM usa le funzioni ledcAttach() e ledcWrite() del core ESP32 per Arduino 3.x; le vecchie versioni 2.x usavano invece ledcSetup() e ledcAttachPin(), e il loro ledcWrite() voleva un numero di canale anziché un pin. Le righe #if del codice scelgono le chiamate giuste per il core installato, così si compila con entrambe le versioni. Poiché il gate è pilotato a 3,3 V tramite 100 Ω, la frequenza resta a 1 kHz così le perdite di commutazione sono trascurabili. Misura i valori del sensore con terra asciutta e bagnata, come in Sensore di umidità del terreno, e regola la soglia DRY_LEVEL.

1// ESP32 + MOSFET ile otomatik sulama pompası / Automatic watering pump with ESP32 + MOSFET
2const int PUMP_PIN = 25;                 // 100 Ω ile gate'e, gate–GND 10 kΩ / to the gate via 100 Ω, 10 kΩ gate–GND
3const int SOIL_PIN = 34;                 // toprak nem sensörü, ADC1 / soil moisture sensor, ADC1
4const int DRY_LEVEL = 2800;              // üstü kuru sayılır, kalibre et / above this counts as dry, calibrate
5const unsigned long WATER_MS = 5000;     // sulama süresi / watering time
6
7void pumpWrite(int duty) {               // 0–255 PWM, iki çekirdek sürümünde / on both core versions
8#if ESP_ARDUINO_VERSION_MAJOR >= 3
9  ledcWrite(PUMP_PIN, duty);             // 3.x: pin numarasıyla / 3.x: by pin number
10#else
11  ledcWrite(0, duty);                    // 2.x: kanal 0 ile / 2.x: by channel 0
12#endif
13}
14
15void pumpRamp(int from, int to) {        // yumuşak hız değişimi / smooth speed change
16  int step = (to > from) ? 5 : -5;
17  for (int d = from; d != to; d += step) {
18    pumpWrite(d);
19    delay(20);
20  }
21  pumpWrite(to);
22}
23
24void setup() {
25  Serial.begin(115200);
26#if ESP_ARDUINO_VERSION_MAJOR >= 3
27  ledcAttach(PUMP_PIN, 1000, 8);         // 1 kHz, 8 bit (0–255); çekirdek 3.x / core 3.x
28#else
29  ledcSetup(0, 1000, 8);                 // çekirdek 2.x: kanal 0 / core 2.x: channel 0
30  ledcAttachPin(PUMP_PIN, 0);
31#endif
32  pumpWrite(0);                          // pompa kapalı / pump off
33}
34
35void loop() {
36  int soil = analogRead(SOIL_PIN);       // 0–4095
37  Serial.printf("Toprak / Soil: %d\n", soil);
38  if (soil > DRY_LEVEL) {
39    pumpRamp(0, 255);                    // yaklaşık 1 s'de tam hıza / full speed in about 1 s
40    delay(WATER_MS);
41    pumpRamp(255, 0);                    // yumuşakça dur / stop gently
42    delay(60000);                        // suyun toprağa yayılmasını bekle / let the water soak in
43  }
44  delay(1000);
45}

Sul Raspberry Pi Pico, in MicroPython basta la classe machine.PWM; duty_u16() accetta un valore da 0 a 65535. Il codice qui sotto dà a una striscia LED da 12 V collegata al MOSFET su GP15 un morbido effetto «respiro». Come nell'esempio per Arduino, il valore viene elevato al quadrato per una semplice correzione gamma, così il passaggio dal buio alla luce appare naturale. Anche i pin del Pico forniscono 3,3 V, quindi valgono le stesse regole sui MOSFET viste per l'ESP32.

1# Pico + MOSFET ile 12 V LED şerit nefes efekti / 12 V LED strip breathing effect with Pico + MOSFET
2from machine import Pin, PWM
3import time
4
5strip = PWM(Pin(15))          # 100 Ω ile gate'e, gate–GND 10 kΩ / to the gate via 100 Ω, 10 kΩ gate–GND
6strip.freq(1000)              # 1 kHz: titreme görünmez / 1 kHz: no visible flicker
7
8def set_level(x):             # x: 0.0–1.0
9    strip.duty_u16(int(x * x * 65535))   # basit gama düzeltmesi / simple gamma correction
10
11while True:
12    for i in range(101):                 # yavaşça aydınlan / fade in
13        set_level(i / 100)
14        time.sleep_ms(20)
15    for i in range(100, -1, -1):         # yavaşça sön / fade out
16        set_level(i / 100)
17        time.sleep_ms(20)
18    time.sleep_ms(500)

Riscaldamento, calcolo della potenza e scelta del dissipatore

Il calore di un MOSFET in piena conduzione si ricava da un'unica formula: P = I² × RDS(on). Tieni presenti due aspetti. Primo, l'RDS(on) cresce con la temperatura; nell'IRLZ44N a 100 °C è circa 1,5 volte il valore a 25 °C, quindi è più realistico calcolare con 38 mΩ invece di 25 mΩ. Secondo, il contenitore può cedere all'aria solo una quantità limitata di calore: la resistenza termica di un TO-220 senza dissipatore (RθJA) è di 62 °C/W, cioè ogni watt porta il chip 62 °C sopra la temperatura ambiente. La tabella mostra come si scalda l'IRLZ44N con 5 V sul gate e senza dissipatore:

Il dissipatore si dimensiona con la stessa logica: Tj = Tambiente + P × (RθJC + RθCS + RθSA). Se a 10 A si dissipano 3,8 W e vuoi tenere il chip a 100 °C in una stanza a 30 °C, la resistenza termica totale non deve superare (100 − 30) / 3,8 ≈ 18 °C/W. La resistenza giunzione-contenitore dell'IRLZ44N è di 1,4 °C/W e un contatto con pasta termica vale circa 0,5 °C/W, quindi il dissipatore deve avere al massimo 16 °C/W, cioè un piccolo dissipatore alettato per TO-220. La linguetta metallica del MOSFET è collegata al drain; se monti più MOSFET sullo stesso dissipatore, usa un isolante in mica o silicone e una boccola in plastica per la vite. La seconda fonte di calore con il PWM sono le perdite di commutazione: trascurabili a 490 Hz, crescono con la frequenza.

MOSFET, transistor e relè a confronto

In breve: se vuoi controllare un carico in continua in modo rapido, silenzioso e con il PWM, usa un MOSFET; se devi accendere una lampada o una presa collegata alla rete a 230 V, usa un modulo relè. Per piccoli carichi da qualche centinaio di milliampere va bene anche un BJT economico; il calcolo della resistenza di base è in Che cos'è un transistor?. Se lo stesso motore deve girare nei due sensi, un solo MOSFET non basta: serve un ponte H con quattro interruttori, quindi usa un driver motore L298N o un modulo ponte H a MOSFET.

Idee di progetti con il MOSFET

• Luce automatica per armadio o scale: quando un sensore PIR rileva un movimento, accendi dolcemente una striscia LED a 12 V con il PWM e spegnila dopo un po'.
• Lampada crepuscolare: con un LDR aumenta gradualmente la luminosità della striscia man mano che la stanza si fa buia.
• Ventola intelligente: fai girare più veloce una ventola da PC a 12 V man mano che sale la temperatura misurata con un DHT11.
• Irrigazione automatica delle piante: annaffia i vasi da soli con un sensore di umidità del terreno e una pompa pilotata da un MOSFET; usa un MOSFET per ogni pompa.
• Serratura con tessera: apri una serratura a solenoide da 12 V per 3 secondi quando un RFID RC522 legge la tessera giusta.
• Serra intelligente: realizza una serra intelligente che gestisce ventola, pompa e riscaldatore con MOSFET separati.

Errori comuni e soluzioni

Il MOSFET è il modo più pulito per collegare Arduino a carichi potenti del mondo reale: con un componente logic level scelto bene, una resistenza di gate, una pull-down e un diodo per i carichi induttivi, controlli qualsiasi carico in continua, dalla striscia LED alla pompa, in modo silenzioso ed efficiente. Nell'app BlueGrays trovi progetti come la dissolvenza dei LED con il PWM, la regolazione della luminosità con un potenziometro, una stazione di irrigazione intelligente e l'illuminazione intelligente, con schemi e codice passo passo, per trasformare subito in un progetto reale il circuito con MOSFET imparato qui.