Visualizzazione post con etichetta BJT. Mostra tutti i post
Visualizzazione post con etichetta BJT. Mostra tutti i post

lunedì 19 agosto 2024

Arduino - Interfaccia con MosFet IRF520

 

Note sull’uso del modulo MOSFET IRF520.

Achille De Santis


Fig. 1: schema elettrico e layout del modulo;


    Da quello che si legge in rete ho notato la scarsità di documentazione fornita e la conseguente incertezza nell’uso del modulo soprattutto da parte dei meno avvezzi all’uso di queste interfacce.

Il problema riscontrato da molti sta nel far funzionare correttamente il modulo!

Niente paura! Cercherò di spiegare il tutto in modo che sia facilmente comprensibile anche agli inesperti.

Il modulo, visibile in fig. 1, sia come “layout” che come schema elettrico, non è altro che un interruttore elettronico a MOSFET in configurazione “Source Comune”.


La diversa tensione di pilotaggio e di attuazione del carico permette un buon isolamento tra le parti.

In pratica, il comando è dell’ordine di 5 Volt mentre la tensione di funzionamento dell’attuatore può andare da 12 a 60 Volt continui.

Prova

1.      Prova a vuoto

a.      Collegare la tensione di 5 volt sull’ingresso (Vcc/GND, v. fig. 1);

b.      Con un cavetto volante, collegare l’ingresso segnale (SIGnal, n.d.a.) al +5 Volt; deve accendersi il led sul modulo, che assicura il comando di Gate. L’ingresso di Gate è ad alta impedenza e non carica l’eventuale uscita di Arduino. Una corrente di circa 3,5 mA è richiesta per alimentare il led, per un totale di circa 8 mA di assorbimento.

2.      Prova a carico

a.      Collegare l’alimentazione del carico (tipicamente 12 volt) su Vin/GND (v. fig. 2);

b.      Sul piedino V+ si deve misurare la tensione Vin di ingresso;

c.      Il piedino V- (del carico, n.d.a.) è collegato al Drain del Mosfet e chiude a massa quando si manda "alto" l’ingresso di segnale, (SIGnal, n.d.a.).

d.      Il carico va inserito tra V+ & V-

3.      Fatto! Provate con un Led opportunamente polarizzato o con un piccolo motorino in CC.


Fig. 2: particolare del layout del modulo, con i piedini di I/O;


    Il modulo (v. fig. 2) si presta anche ad interfacciare segnali PWM. Basta inserire in ingresso un segnale ad impulsi rettangolari 0V/5Volt con duty-cycle variabile. L’uscita avrà un andamento “chopper” in opposizione di fase con il segnale di ingresso. Pilotando un motore con questa tensione si ottiene una velocità “modulabile” entro un ampio margine. Allo stesso modo, pilotando un led si ottiene una luce ad intensità “modulabile”.


Nota: I morsetti Vin e V+  normalmente sono in contatto; se non lo sono spostate il carico da V+ a Vin, lasciando l’altro terminale su V-.

Se siete esperti di SMD potete sostituire la resistenza di pull-down da 1KOhm con altra da 10KOhm, in modo da ridurre la corrente richiesta nella fase di ON. Se non siete esperti... lasciate tutto così com'è!


Fig. 3: interfaccia, tre linee parallele a BJT;
Se volete, potete realizzare questa interfaccia su una piccola piastrina "protoboard" già forata.

In alternativa, al posto del MOSFET potete utilizzare un BJT NPN, in configurazione ad "Emettitore Comune" modificando l'ingresso per il pilotaggio "in corrente" del BJT.

In figura 3 potete vedere la piccola interfaccia realizzata su protoboard con tre linee indipendenti di segnale e BJT in contenitore TO220. Sugli ingressi di base trovate le  rispettive e necessarie resistenze di polarizzazione.


 Se opportuno, potete aggiungere tre piccoli dissipatori per TO220, prima di effettuare le saldature. Lo spazio previsto ne permette un facile montaggio.


Con questa piccola scheda, assemblata su protoboard, potete comandare tre canali indipendenti, sia in modalità ON/OFF, sia lineare,  sia in modalità PWM.


  


mercoledì 7 aprile 2021

Arduino N° 89 - Servomotore con abilitazione a BJT

< Arduino N° 88

 Achille De Santis

> Arduino N°  90




In questo post vi presento un dispositivo con servomotore, dotato di abilitazione a BJT e pilotato da Arduino.

Il funzionamento del servomotore è stato già descritto e trovate qualche collegamento in Argomenti correlati.

L'abilitazione del servomotore avviene cambiando stato al piedino digitale  D11 (PNP con uscita di collettore: OFF abilita; ON disabilita).

Ad evitare movimenti incontrollati del servomotore bisogna sempre leggere e partire dalle condizioni iniziali ed istantanee del motore, utilizzando oculatamente la temporizzazione.



Nota:

Il circuito è SOLO dimostrativo. L'uscita va ASSOLUTAMENTE collegata ad una sorgente di alimentazione separata. La figura la riporta collegata alla alimentazione di Arduino a puro titolo di esempio.


Simulazione: 

Servomotore con abilitazione a BJT


Argomenti correlati: 

mercoledì 24 marzo 2021

Arduino N° 87 - Sirena Italiana con driver a BJT

< Arduino N° 86

 Achille De Santis

> Arduino N°  88




In questo post vi presento la realizzazione di una "sirena italiana" di potenza, pilotata da uno stadio driver a BJT.

Il transistore usato è un NPN di potenza, del tipo TIP3055 o equivalenti (NPN).

Arduino fornisce il solo segnale di pilotaggio. Lo stadio di potenza può essere alimentato con una sorgente a 12 volt, massa comune con quella dell'Arduino.

Non ci sono particolari comandi, se non l'interruttore di abilitazione/disabilitazione della sirena.

Come trasduttore elettroacustico di uscita potete utilizzare un altoparlante o, meglio, un classico altoparlante a "tromba".

Una spia a led indica l'attivazione.


N.B.: E' severamente vietato l'uso sconsiderato di questo dispositivo. 


Simulazione: 

Sirena Italiana_V2 con driver BJT


Argomenti correlati: 

Sirena Italiana

Sirena Italiana V2

Sirena Bitonale


tecnatronATgmail.com


> Arduino n° 88


mercoledì 4 marzo 2020

Arduino N° 39 - Telecomando ad Infrarosso con driver a BJT

< Segue da Arduino N° 38

 Achille De Santis

> Arduino N° 40







Ricevitore per telecomando ad infrarosso. L'uscita  ON/OFF è interfacciata con transistore BJT.
In questo modo è possibile comandare direttamente un relay con un "contatto puro" per il collegamento ad una qualsivoglia alimentazione per l'attuatore, sia a 12 o 24 volt in continua, sia anche a 230 volt c.a, separando la logica di comando dalla rete di attuazione.

Il pulsante serve soltanto per prova e va eliminato.
tecnatronATgmail.com


Simulazione: 


Argomenti correlati: 

mercoledì 22 gennaio 2020

Arduino N° 33 - Pilotaggio di un relay con driver a BJT

< Arduino N° 32

 Achille De Santis

> Arduino N° 34





Pilotaggio di un relay attraverso uno stadio driver a BJT, in configurazione ad "Emettitore Comune" opportunamente polarizzato.

Un cicalino, escludibile, segnala l'avvenuta attuazione.

Per il dimensionamento dello stadio a transistore BJT, del tipo NPN, vedere la pagina a questo link.

Immettendo i dati indicati in rosso si ottengono i valori dei componenti. Non modificate gli altri campi!

Il transistore NPN può essere un comune BJT per usi generali (BC108, BC109, 2n1711, 2N1613, 2N2222); consigliato il 2N2369 che è ottimo per l'uso in commutazione.

Per carichi notevoli serve un BJT di potenza da utilizzare come stadio finale.

Nota:
Il buzzer NON è un altoparlante ma un cicalino (ronzatore)! L'altoparlante manderebbe in corto-circuito l'alimentazione di Arduino!


/* ------------------------ Inizio Programma -----------------------
 * Pilotaggio intermittente di un Relay con Arduino
 * Segnalazione acustica tramite Buzzer
 * Uso delle routines per le operazioni elementari ripetitive.
 */ ---------------------------------------------------------------------

// --------------- I/O ------------------------------
 #define R 13     // Uscita comando relay
 #define B 12     // Uscita comando buzzer
// --------------------------------------------------

 const int  T1=100,   // ritardo
                 T2=1000,
                 T3=3000;     // ritardo

void setup()
{
  pinMode(R, OUTPUT); // viene settato il pin R come uscita
  pinMode(B, OUTPUT); // viene settato il pin B come uscita
}

void accendi(int r, int b)
{
  digitalWrite(r, HIGH);  // mette R a livello alto facendo andare il BJT in saturazione
  digitalWrite(b, HIGH); // mette B a livello alto facendo suonare il buzzer
  delay(T1);                    // attende T1 millisecondi
}
void spegni(int r, int b)
{
  digitalWrite(r, LOW);  // spegne il bjt, spegne il relè e il buzzer
  digitalWrite(b, LOW);
  delay(T1);                    // ritardo
}
void loop()
{
  accendi(R,B);   delay(100);
  // digitalWrite(B, LOW);    // per segnalazione impulsiva.
  delay(T2);   

  spegni(R,B);    delay(T3);    // ritardo, poi il ciclo si ripete
}

// --------------------- Fine programma -----------------------------



Simulazione: 

Pilotaggio relay con Arduino e driver a BJT;


Argomenti correlati: 

dimensionamento dello stadio a transistore;



> Arduino N° 34