MOSFET HEXFET IRLB3034PBF, canale N, 40V, 195A, TO-220AB

IRLB3034PBF è un MOSFET HEXFET a canale N, in capsula TO-220AB, progettato per commutare correnti elevate a tensioni fino a 40 V. Essendo un MOSFET semplice, senza controller proprio, ha bisogno di un microcontrollore che ne comandi il gate (gate). In questo tutorial usiamo la scheda Arduino Uno R3, alimentata via USB dal computer, perché la sua uscita da 5 V è sufficiente per aprire completamente il transistor.

Lo usiamo per accendere e regolare la luminosità di una striscia LED 5050 da 12 V, alimentata separatamente da un alimentatore da 12 VDC tramite l'adattatore con jack DC e terminali. Lo stesso schema può essere usato per motori, pompe, solenoidi o relè, se rispettate tensione e corrente.

Come funziona:

Un MOSFET a canale N si comporta come un interruttore comandato in tensione. Tra drain (D) e source (S) la corrente passa o non passa, in funzione della tensione tra gate (G) e source (S), indicata VGS. Il gate non assorbe corrente in regime stazionario, ma solo nei momenti di commutazione, quando si carica o si scarica la sua capacità di ingresso.

IRLB3034PBF è ottimizzato per il comando a livello logico. La soglia VGS(th) è tra 1.0 e 2.5 V, mentre la resistenza in conduzione RDS(on) è di massimo 2 mΩ a VGS = 4.5 V e di 1.4 mΩ tipico (1.7 mΩ massimo) a VGS = 10 V. L'uscita da 5 V della scheda Arduino Uno lo apre completamente, quindi non serve un driver di gate. La tensione massima sul gate è di ±20 V, mentre la tensione massima drain - source è di 40 V.

La corrente di drain è di 343 A, limitata dal silicio, e di 195 A, limitata dalla capsula. In pratica il limite reale lo danno i terminali TO-220, i fili e il raffreddamento, quindi per correnti elevate si calcolano separatamente il cablaggio e il dissipatore. Per una striscia LED da 1 m, di circa 14.4 W a 12 V, la corrente è 14.4 W / 12 V = 1.2 A. La potenza dissipata nel transistor è P = I x I x RDS(on) = 1.2 x 1.2 x 0.002, cioè circa 3 mW, quindi il transistor resta freddo e non ha bisogno di dissipatore. Il valore di 14.4 W/m è tipico, quindi verificate l'etichetta della vostra striscia.

La regolazione della luminosità avviene tramite PWM. Il pin D9 della scheda Arduino Uno genera un segnale di circa 490 Hz, quindi un periodo di circa 2 ms, e la funzione analogWrite(9, valore), con valore tra 0 e 255, stabilisce quanta parte del periodo il gate è attivo. A 128 il duty cycle è di circa 50 %, la striscia riceve corrente per metà del tempo e sembra accesa al 50% della luminosità.

La resistenza R1 da 220 ohm, in serie con il gate, limita la corrente di carica del gate a circa 5 V / 220 ohm = 23 mA, sotto il limite di 40 mA di un pin Arduino Uno. Insieme alla capacità di ingresso di circa 10.3 nF, R1 forma una costante di tempo di circa 2.3 microsecondi, trascurabile rispetto al periodo PWM di circa 2 ms. La resistenza R2 da 10 kohm, tra gate e GND, mantiene il transistor bloccato mentre la scheda si riavvia o il pin D9 è indefinito, così che la striscia non si accenda da sola all'accensione.

Collegamento:

Alimentate la scheda Arduino Uno tramite il cavo USB dal computer, e la striscia LED separatamente, da un alimentatore da 12 VDC (minimo 2 A per 1 m di striscia), tramite l'adattatore con jack DC femmina 5.5 x 2.1 mm con terminali. Il transistor commuta il negativo della striscia (commutazione sul lato di massa, low side). La massa della scheda Arduino e il negativo dell'alimentatore da 12 V devono essere collegati insieme, altrimenti il segnale sul gate non ha riferimento. Il segnale D9 ha livello logico di 5 V, quindi non serve un convertitore di livello. Tenendo il transistor con la faccia marcata verso di voi e i terminali in basso, l'ordine da sinistra a destra è G, D, S. La piastra metallica è collegata al drain, quindi non lasciatela toccare altri componenti metallici o la massa.

Se al posto della striscia LED comandate un motore, un relè o un solenoide, mettete un diodo di protezione (per esempio 1N5819 o 1N4007) in parallelo al carico, con il catodo verso +12 V. Senza di esso, i picchi di tensione generati allo spegnimento possono superare 40 V e danneggiare il transistor.

Scheda e librerie:

In Arduino IDE selezionate in Tools > Board la scheda Arduino Uno, dal pacchetto Arduino AVR Boards, che è installato insieme ad Arduino IDE. Se manca, lo installate da Boards Manager. Il programma usa solo le funzioni di base di Arduino, quindi non serve installare alcuna libreria.

Il codice:

Il programma percorre cinque livelli fissi di luminosità, poi aumenta e diminuisce dolcemente la luminosità della striscia, stampando ogni livello sul monitor seriale.

/*
  IRLB3034PBF MOSFET driving a 12 V LED strip with PWM
  Board: Arduino Uno (Tools > Board > Arduino AVR Boards > Arduino Uno)
  Libraries: none, the program uses only the core Arduino functions
  Wiring (TO-220AB, marked face toward you, leads down: G, D, S from left to right):
    Arduino D9  -> R1 220 ohm -> IRLB3034 G (Gate)
    IRLB3034 G  -> R2 10 kohm -> Arduino GND (pull-down)
    IRLB3034 D  -> LED strip minus (-)
    IRLB3034 S  -> DC jack adapter minus (-)
    Arduino GND -> DC jack adapter minus (-) (common ground)
    DC jack adapter plus (+) -> LED strip +12 V
    12 VDC power supply (minimum 2 A) -> DC jack adapter
*/
const uint8_t GATE_PIN = 9;                                       // PWM pin connected to the gate through R1
const uint8_t LEVELS[] = {0, 64, 128, 192, 255};                  // Brightness steps (0 - 255)
const uint8_t LEVEL_COUNT = sizeof(LEVELS) / sizeof(LEVELS[0]);   // Number of steps
// Apply a brightness value to the gate and print it as a percentage
void setBrightness(uint8_t value) {
  analogWrite(GATE_PIN, value);                                   // Set the PWM duty cycle
  uint8_t percent = (uint8_t)(((uint16_t)value * 100) / 255);     // Convert 0 - 255 to 0 - 100 %
  Serial.print(F("Brightness step: "));
  Serial.print(value);
  Serial.print(F(" ("));
  Serial.print(percent);
  Serial.println(F(" %)"));
}
void setup() {
  pinMode(GATE_PIN, OUTPUT);                                      // Gate pin is an output
  analogWrite(GATE_PIN, 0);                                       // Start with the strip off
  Serial.begin(9600);                                             // Start the serial monitor at 9600 baud
  Serial.println(F("IRLB3034 PWM test started on pin D9"));
}
void loop() {
  // Part 1: go through the fixed brightness steps
  for (uint8_t i = 0; i < LEVEL_COUNT; i++) {
    setBrightness(LEVELS[i]);                                     // Apply the current step
    delay(1500);                                                  // Keep it for 1.5 seconds
  }
  // Part 2: fade up smoothly
  Serial.println(F("Fade up"));
  for (int value = 0; value <= 255; value += 5) {
    analogWrite(GATE_PIN, value);                                 // Increase the duty cycle
    delay(20);                                                    // Short pause between steps
  }
  // Part 3: fade down smoothly
  Serial.println(F("Fade down"));
  for (int value = 255; value >= 0; value -= 5) {
    analogWrite(GATE_PIN, value);                                 // Decrease the duty cycle
    delay(20);                                                    // Short pause between steps
  }
}

Come funziona il codice:

La costante GATE_PIN definisce il pin D9, che comanda il gate tramite R1. Il vettore LEVELS contiene i cinque livelli di luminosità (0, 64, 128, 192 e 255), mentre LEVEL_COUNT è il loro numero, calcolato automaticamente dalla dimensione del vettore.

In setup() il pin GATE_PIN è configurato come uscita con pinMode(), viene avviato con analogWrite(GATE_PIN, 0), quindi la striscia è spenta, poi si apre la porta seriale a 9600 baud e si visualizza un messaggio di avvio.

In loop() la prima parte percorre i livelli di LEVELS. Per ciascuno viene richiamata setBrightness(), che applica il valore con analogWrite(), calcola la percentuale e la visualizza, poi si attendono 1.5 secondi.

La seconda parte aumenta la luminosità da 0 a 255 e la riduce di nuovo a 0 a passi di 5, con una pausa di 20 ms tra i passi, ottenendo un effetto di accensione e spegnimento dolce. Al valore 0 il gate resta a 0 V, mentre a 255 resta stabilmente a 5 V.

Risultato:

Aprite il monitor seriale a 9600 baud. A ogni livello la striscia cambia luminosità, e i messaggi qui sotto compaiono in ordine, seguiti dall'accensione e dallo spegnimento dolce della striscia. Sul monitor vengono visualizzati solo i livelli fissi.

IRLB3034 PWM test started on pin D9
Brightness step: 0 (0 %)
Brightness step: 64 (25 %)
Brightness step: 128 (50 %)
Brightness step: 192 (75 %)
Brightness step: 255 (100 %)
Fade up
Fade down
Brightness step: 0 (0 %)
Brightness step: 64 (25 %)
Brightness step: 128 (50 %)

Problemi frequenti:

La striscia resta spenta a qualsiasi valore. La causa più frequente è la mancanza della massa comune o l'ordine sbagliato dei pin. Verificate che il GND di Arduino sia collegato al negativo dell'adattatore con jack DC e che i terminali siano G, D, S da sinistra a destra, con la faccia marcata verso di voi.

La striscia è accesa in permanenza, anche al valore 0. Il gate potrebbe essere non definito, se R2 manca o non è collegata al GND, oppure il transistor è montato con drain e source invertiti, nel qual caso il diodo interno conduce la corrente. Verificate R2 e la posizione dei pin.

Non compare nulla sul monitor seriale. Verificate che la velocità del monitor seriale sia impostata a 9600 baud e che la scheda Arduino Uno sia selezionata correttamente in Tools > Board e Tools > Port.

Il transistor si scalda. Con una striscia da 1.2 A non dovrebbe scaldarsi. Se si scalda, il carico consuma molto più di quanto calcolato oppure il gate non riceve 5 V, per esempio a causa di un filo debole. Misurate la tensione tra G e S in conduzione.

La scheda Arduino si riavvia o si comporta in modo strano quando comanda un motore o un relè. I picchi di tensione dello spegnimento del carico induttivo disturbano il circuito. Montate il diodo di protezione in parallelo al carico, con il catodo verso +12 V.

La striscia sfarfalla a valori bassi di PWM. A duty cycle piccoli la corrente media è molto bassa e qualsiasi disturbo è visibile. Verificate i collegamenti e usate cavi corti per il segnale di comando.

Limiti e consigli:

La tensione massima drain - source è di 40 V, quindi il transistor non si usa direttamente a tensioni di rete o oltre 40 V. Sul gate non superate ±20 V. La corrente di 195 A è un valore di catalogo della capsula, mentre nelle applicazioni reali il limite è dato dai terminali TO-220, dallo spessore dei fili e dal raffreddamento, quindi per correnti dell'ordine delle decine di ampere usate cavi spessi, saldature buone e un dissipatore.

Lo schema di questo tutorial commuta il negativo del carico. Per commutare il positivo serve un MOSFET a canale P o un driver dedicato. La scheda Arduino Uno comanda il gate con 5 V, al quale RDS(on) è di massimo 2 mΩ. Con comando a 3.3 V la resistenza in conduzione non è garantita e va verificata sul montaggio reale.

In seguito potete comandare con lo stesso montaggio una pompa, una ventola, un motorino con diodo di protezione o più strisce LED in parallelo, con un transistor per ogni canale di colore.