Modulo MOSFET E-Switch, controllo 3-20V, uscita 5-36V, con optoisolatore

Questo tutorial utilizza la scheda Arduino Uno R3 per comandare tramite PWM una striscia LED da 12 V con il modulo E-Switch MOSFET con optoisolatore. Il modulo è utile nei progetti in cui una scheda di sviluppo con uscite da 5 V deve accendere, spegnere o regolare un carico in corrente continua più grande di quanto un pin possa sostenere direttamente, ad esempio strisce LED, motori, pompe o elettrovalvole.

Come funziona:

Sulla scheda si trova un MOSFET F5305S a canale P, montato sulla linea positiva del carico. Il segnale di comando su IN+ e IN- accende il LED dell'optoaccoppiatore PC817, e la parte di uscita di quest'ultimo porta il gate del MOSFET in conduzione. Finché c'è segnale di comando, il carico è alimentato, mentre quando il segnale scompare, il MOSFET si interdice. L'optoaccoppiatore separa elettricamente i due circuiti, per questo il GND di Arduino non deve essere collegato al negativo dell'alimentatore da 12 V.

La corrente di comando è di circa 5 mA, un valore che un pin Arduino può fornire senza problemi. I 5 V di un pin della scheda Uno rientrano nell'intervallo di comando del modulo, 3 - 20 VDC.

Nel PWM, la tensione media applicata al carico è la tensione dell'alimentatore moltiplicata per il duty cycle. La funzione analogWrite riceve un valore tra 0 e 255, e il duty cycle è valore / 255. Ad esempio, con il valore 128 il duty cycle è 128 / 255, cioè circa il 50 %, e una striscia LED da 12 V riceve in media circa 6 V. Il pin D9 della scheda Uno genera un PWM di circa 490 Hz, quindi il periodo è di circa 2 ms, una frequenza adatta a questo modulo.

Collegamento:

Il montaggio utilizza un alimentatore di rete da 12 VDC con almeno 2 A, un adattatore jack da 5.5 x 2.1 mm con morsetti a vite e una striscia LED monocolore da 12 V. Collegate tutto con l'alimentatore scollegato e alimentatelo alla fine. I due blocchi di morsetti sono contrassegnati + e -. Sul blocco + il positivo dell'alimentatore entra nella vite sul lato della coda della freccia della scheda, mentre il positivo del carico parte dalla vite sulla punta della freccia. Il blocco - è il negativo comune dell'alimentatore e del carico. Non sono necessari convertitore di livello, resistenze di pull-up o un'alimentazione separata per la parte di comando.

Scheda e librerie:

In Arduino IDE selezionate da Tools > Board la scheda Arduino Uno dal pacchetto Arduino AVR Boards, che viene installato insieme ad Arduino IDE. Il programma utilizza solo le funzioni di base di Arduino, quindi non è necessario installare alcuna libreria.

Il codice:

Il programma imposta in successione cinque livelli di luminosità, poi esegue un aumento e una diminuzione graduali della luminosità, mostrando sul monitor seriale cosa sta accadendo.

/*
  E-Switch MOSFET module with optoisolator (F5305S + PC817) - PWM brightness demo
  Board: Arduino Uno (Tools > Board > Arduino AVR Boards > Arduino Uno)
  Libraries: none, only the core Arduino functions are used.
  Wiring:
    Module IN+  -> Arduino Uno D9 (PWM, about 490 Hz)
    Module IN-  -> Arduino Uno GND
    Module + (screw 1) -> 12 VDC supply +
    Module - (screw 1) -> 12 VDC supply -
    Module + (screw 2) -> 12 V LED strip +12V
    Module - (screw 2) -> 12 V LED strip -
*/
const int MOSFET_PIN = 9;                          // PWM pin connected to IN+
const int LEVELS[] = {0, 64, 128, 192, 255};       // test brightness levels
const int NUM_LEVELS = sizeof(LEVELS) / sizeof(LEVELS[0]);
// Send a PWM value (0 - 255) to the module and print it
void setBrightness(int value) {
  analogWrite(MOSFET_PIN, value);                  // set the duty cycle
  Serial.print("Brightness level: ");
  Serial.print(value);
  Serial.print(" / 255 (");
  Serial.print(value * 100L / 255);                // convert to percent
  Serial.println(" %)");
}
void setup() {
  Serial.begin(9600);                              // start the serial monitor
  pinMode(MOSFET_PIN, OUTPUT);                     // control pin as output
  analogWrite(MOSFET_PIN, 0);                      // start with the load off
  Serial.println("E-Switch MOSFET module test (Arduino Uno, pin D9)");
}
void loop() {
  // Step through the fixed levels, two seconds each
  for (int i = 0; i < NUM_LEVELS; i++) {
    setBrightness(LEVELS[i]);
    delay(2000);
  }
  // Smooth fade up from 0 to 255
  Serial.println("Fade up...");
  for (int value = 0; value <= 255; value++) {
    analogWrite(MOSFET_PIN, value);
    delay(10);
  }
  // Smooth fade down from 255 to 0
  Serial.println("Fade down...");
  for (int value = 255; value >= 0; value--) {
    analogWrite(MOSFET_PIN, value);
    delay(10);
  }
  analogWrite(MOSFET_PIN, 0);                      // load off before repeating
  delay(1000);
}

Come funziona il codice:

La costante MOSFET_PIN ha valore 9 e indica il pin PWM a cui è collegato IN+. L'array LEVELS contiene i cinque valori di test, 0, 64, 128, 192 e 255, mentre NUM_LEVELS è il loro numero.

Nella funzione setup si avvia la comunicazione seriale a 9600 baud, il pin MOSFET_PIN viene configurato come uscita e si applica il valore 0, in modo che il carico parta spento.

La funzione setBrightness riceve un valore tra 0 e 255, lo invia con analogWrite al modulo e mostra il valore e la percentuale corrispondente.

Nella funzione loop, un ciclo for percorre l'array LEVELS e mantiene ogni livello per due secondi. Poi due cicli for aumentano il valore da 0 a 255 e lo diminuiscono fino a 0, con una pausa di 10 ms tra i passi, ottenendo un effetto di accensione e spegnimento graduale. Dopo una pausa di un secondo la sequenza ricomincia.

Risultato:

Aprite il monitor seriale a 9600 baud. La striscia LED passa attraverso i cinque livelli di luminosità, poi si accende e si spegne gradualmente, e sul monitor compare un testo simile a quello qui sotto.

E-Switch MOSFET module test (Arduino Uno, pin D9)
Brightness level: 0 / 255 (0 %)
Brightness level: 64 / 255 (25 %)
Brightness level: 128 / 255 (50 %)
Brightness level: 192 / 255 (75 %)
Brightness level: 255 / 255 (100 %)
Fade up...
Fade down...
Brightness level: 0 / 255 (0 %)
Brightness level: 64 / 255 (25 %)
Brightness level: 128 / 255 (50 %)

Problemi frequenti:

Il carico resta acceso sempre. La causa più comune è il collegamento dell'alimentatore e del carico in senso inverso rispetto alla freccia sulla scheda, nel qual caso la corrente passa aggirando il MOSFET. Ricollegate l'alimentatore alla vite sul lato della coda della freccia e il carico alla vite sulla punta della freccia.

Il carico non si accende affatto. Verificate che IN+ sia collegato a D9 e IN- a GND, che l'alimentatore da 12 V sia acceso e che il negativo dell'alimentatore e del carico siano sul blocco -. Controllate anche che la tensione di comando sia di almeno 3 V.

La luminosità non varia, la striscia si accende solo al massimo. Verificate che il segnale sia su un pin con PWM, contrassegnato con ~ sulla scheda Uno, e che nel codice sia usato analogWrite e non digitalWrite.

Il modulo si scalda molto. La corrente del carico supera 5 A senza raffreddamento. Riducete il carico oppure montate un dissipatore e una ventola.

Con motori o pompe si verificano riavvii della scheda Arduino o un comportamento instabile. Un motore produce picchi di tensione allo spegnimento. Montate un diodo di protezione in parallelo al carico, con il catodo verso il positivo, e usate fili di sezione adeguata.

Limitazioni e consigli:

Il modulo commuta solo carichi in corrente continua da 5 - 36 VDC e non è adatto alla tensione alternata. La tensione di comando consigliata è di 3 - 20 VDC, mentre la corrente di comando è di circa 5 mA. Fino a 5 A non serve raffreddamento, mentre con dissipatore e ventola si può arrivare a 22 A, controllando la temperatura del MOSFET.

L'optoaccoppiatore limita la frequenza PWM utilizzabile, quindi i circa 490 Hz del pin D9 sono adatti, ma un PWM molto veloce non è consigliato. Dallo stesso montaggio potete realizzare un dimmer per la striscia LED con un potenziometro, un regolatore di velocità per un motore in corrente continua oppure un interruttore per pompe ed elettrovalvole comandato da sensori.