Visualizzazione post con etichetta PWM. Mostra tutti i post
Visualizzazione post con etichetta PWM. 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ì 9 giugno 2021

Arduino N° 98 - Comando proporzionale Ventola

< Arduino N° 97

 Achille De Santis

> Arduino N°  99


Controllo di velocità per ventola, comandata con telecomando ad infrarosso.


Fig. 1: Layout dei componenti; driver a MOSFET;

Due coppie di codici permettono l'avanzamento UP/DOWN con passo LOW e FAST  attraverso i quattro pulsanti di avanzamento lento (< >) e veloce (<< >>).

i condensatori sulla linea di alimentazione servono per non avere brutte sorprese di malfunzionamenti.

Il diodo di "libera circolazione" è molto utile per la salvaguardia del MOSFET.

Il LED fornisce una indicazione visiva dell'attuazione dei comandi, peraltro visibili aprendo il monitor seriale.

Il MOSFET, nella configurazione a Source Comune, pilota la tensione da fornire alla ventola  e la relativa corrente.

Dalla disposizione dei componenti ricavate lo schema elettrico; vi aiuterà molto nella comprensione del circuito. 


In alternativa, è possibile pilotare il motore con un circuito driver a BJT, come in fig. 2. Il firmware resta lo stesso ma bisogna modificare l'interfaccia di comando motore per avere un pilotaggio in corrente.

Fig. 2: Comando ventola con infrarosso e driver a BJT;




Varianti: 

E' possibile collegare la ventola a tensione di 12 volt, scollegando il filo rosso che la alimenta e collegando ad una tensione di 12 Vcc, massa comune con il circuito.

Nota 1: 

Se avete un telecomando diverso è possibile cambiare facilmente i codici di attivazione leggendoli direttamente a monitor ed inserendoli nelle righe dei comandi.


Nota 2:

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: 

Comando proporzionale ventola con MOSFET_V5.3


Argomenti correlati: 

mercoledì 2 giugno 2021

Arduino N° 97 - Accelerazione motore in DC_V3

< Arduino N° 96

 Achille De Santis

> Arduino N°  98




In questo post propongo un dispositivo per il comando progressivo di un .motore in corrente continua, che ne determina l'accelerazione/decelerazione.


Aprendo il monitor seriale è possibile controllare il valore PWM impostato, di volta in volta; L'aggiornamento del valore, da zero a 255, viene effettuato soltanto quando c'è un comando di variazione di velocità, altrimenti resta memorizzato il valore precedente. In questo modo, si aumenta la leggibilità a monitor e si evita lo scorrimento continuo dei valori.



I due condensatori posti sulla linea di alimentazione servono a filtrare l'alimentazione ed a prevenire fenomeni di interferenza. Il diodo di "libera circolazione protegge il transistore da sovratensioni."


Il motore è predisposto per ruotare in un solo verso.
Se è necessario, si può cambiare il verso di rotazione invertendo la polarità sul motore agendo sui morsetti.

Attenzione al verso del diodo di libera circolazione!

Nel caso fosse necessario un doppio verso di rotazione il circuito andrebbe modificato con l'uso di un driver L293 o L298 o, in alternativa, facendo uso di un relay 2vie/2posizioni configurato come invertitore di polarità. 

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: 

Accelerazione motore in DC_V3


Argomenti correlati: 



mercoledì 15 aprile 2020

Arduino N° 45 - Luci psichedeliche a LED V2.0





< Segue da Arduino N°  44             

 Achille De Santis

> Arduino N° 46


            






Con questo sketch è possibile pilotare una striscia LED RGB alimentata a 12 volt.
Potete provare il funzionamento del programma predisponendo un solo LED RGB a catodo comune, opportunamente polarizzato, su una piccola breadboard. Un potenziometro in ingresso al segnale di bassa frequenza serve a regolare la sensibilità del dispositivo e ad adattarlo al livello audio.

Poiché molte strisce LED operano a logica negata, serve uno stadio separatore a transistori in configurazione invertente, a tre canali. Il positivo di alimentazione a 12 volt sarà collegato alla linea di ingresso, mentre le tre linee RGB andranno collegate alle uscite (open collector) del driver a BJT.




/* ----------------------------- Inizio Programma ---------------------------------------
 * prof. Achille De Santis  19-01-2020
 * Variazione continua del colore di un LED RGB a catodo comune
 * o di una striscia LED ad anodo comune con driver a BJT
 * Luci psichedeliche a LED V2.0
 * le uscite utilizzate DEVONO essere PWM.
 * -------------------------------------------------------------------------------------------
*/

// ------------ Ingresso analogico ---------------
#define BF   A2
// -----------------------------------------------
// -------- uscite PWM per il LED RGB -----------------
#define ROSSO   10
#define VERDE   11
#define BLU     9
// --------------------------------------------------------------

const int T1=200;                       // tempo di transizione colore
int segnale=0,     segnale2=0;          // inizializza le variabili
int soglia1=20,    soglia2=30;          // ------ valori di soglia per i colori ---------
// -------------------------------------------------------------------------------------------

void coefficienti(int a,int b,int c)  { analogWrite(ROSSO,a); analogWrite(VERDE,b); analogWrite(BLU,c); }

void test()             // routine di prova dei colori.
  {
    coefficienti(255,0,0); delay(500);   coefficienti(0,255,0); delay(500);
    coefficienti(0,0,255); delay(500);   coefficienti(0,0,0); delay(1000);
  }

void intestazione()
  { Serial.println(" ----------------------------------------------\n - Autore: Tecnatron - ing. Achille De Santis -");
    Serial.println(" - Variazione continua della luminosità       -\n - per LED RGB a catodo comune CK             -");
    Serial.println(" - ingresso analogico: A2                     -\n - uscite PWM usate:  D11, D10, D9   V2.0     -");
    Serial.println(" ----------------------------------------------");
  }

void setup()
  {
    Serial.begin(9600);                                         // velocità seriale di comunicazione
    pinMode(BF, INPUT),                                   // imposta il pin come input per il segnale audio
    pinMode(VERDE, OUTPUT), (BLU, OUTPUT), (ROSSO, OUTPUT);   // imposta i pin di uscita
    digitalWrite (VERDE, LOW), (BLU, LOW), (ROSSO, LOW);      // inizialmente, led RGB spento;
    intestazione();    test();
  }

void loop()
  {
    segnale=analogRead(A2);
    segnale2=map(segnale,0,1023,0,255); //
    if (segnale2<soglia1)                      { analogWrite(ROSSO, segnale2); }
    if (segnale2>=soglia1 & segnale2<soglia2)  { analogWrite(VERDE, segnale2); }
    if  (segnale2>=soglia2)                    { analogWrite(BLU, segnale2); }
    // delay(100);
    coefficienti(0,0,0);
 }
// ----------------------------- Fine Programma ---------------------------------------



Simulazione:


Argomenti correlati:


> Arduino N° 46

mercoledì 26 febbraio 2020

Arduino N° 38 - Lampeggiatore modulato

< Segue da Arduino N°  37

 Achille De Santis

> Arduino N° 39




Proviamo ad usare le uscite analogiche di Arduino.
In effetti la tensione di uscita non è proprio analogica ma a gradinata, sfruttando la tecnica PWM cioè modulando la larghezza degli impulsi. Si ottiene una tensione di uscita che può essere variata, in qualche modo, con il comando analogWrite().

Il programma qui presentato varia, a due livelli, la luminosità di un LED. I livelli di uscita possono essere 256 (da 0 a 255). In questo caso, sono stati usati i livelli 128 e 255, corrispondenti a circa 5 volt e 2,5 volt di tensione di uscita.
La resistenza in serie al LED può essere da 470 Ohm, il ché limita la corrente massima a circa 10mA.

Il programma può essere anche realizzato come "routine" da richiamare all'interno di un programma principale, ad esempio come spia lampeggiante a due livelli. In questo caso è opportuno modificare la routine facendo uso della funzione "millis", per evitare il blocco del programma principale.


/* ------------------ Inizio programma -----------------------------------------------------------
 * utilizzo della funzione analogWrite() per variare, a step, la luminosità di un LED.
 * Achille De Santis - V2 del 14-11-2019
*/

// ------------------ I/O --------------------------------------------------------
  #define LED 11 // LED collegato al pin digitale 11  (PWM)
// valori di uscita: 255/128
// -------------------------------------------------------------------------------

void intestazione()
{ Serial.println(" ------------------------------------------------------ ");
  Serial.println(" - Autore: Tecnatron - ing. Achille De Santis - ");
  Serial.println(" - Sketch: varia la luminosità di un LED - V.2- ");
  Serial.println(" - il piedino di uscita deve essere un PWM   - ");
  Serial.println(" ------------------------------------------------------- ");
}

void accendi(int L, int V)  {  analogWrite(L, V); delay(500);  }   // accende il LED a tensione variabile.

void setup() 
{
  pinMode(LED, OUTPUT);  // imposta il pin come output
  Serial.begin(9600);              // setto la velocità di comunicazione
  intestazione();                      // intestazione, inviata alla seriale
}       

void loop()
  {
    accendi(LED, 255);        // accende il LED a tensione massima.   
    accendi(LED, 128);        // accende il LED a tensione metà.
  }
// --------------- Fine programma ---------------------------------------------



Simulazione: Lampeggiatore modulato

Argomenti correlati:



> Arduino N° 39

mercoledì 13 novembre 2019

Arduino N° 23 - Fader per canali RGB

< Arduino N° 22

 Achille De Santis

> Arduino N° 24




Gestione proporzionale PWM dei colori per un LED RGB a "catodo comune".
Lo sketch produce lo spegnimento progressivo dei LED (affievolimento).

Con facili modifiche è possibile ottenere l'accensione progressiva di ogni colore, lo spegnimento progressivo, il lampeggio, la miscelazione dei colori primari ecc...
I colori "primari" Rosso, Verde, Blu permettono di generare tutti gli altri colori, compreso il bianco, con opportuni coefficienti.

/* ------------------- Inizio Programma ----------------------------------------------------------------
 * Achille De Santis
 * fader per canali RGB  - V2.0 del 02-07-2019
 * collegare i LED con una resistenza, in serie, da 470 Ohm.
*/

// ------------- I/O -----------
#define VERDE   9
#define BLU     10
#define ROSSO   11
// -----------------------------

int delayTime = 20;

void setup()
  {
    pinMode(VERDE, OUTPUT);
    pinMode(BLU, OUTPUT);
    pinMode(ROSSO, OUTPUT);
 
  }

void accenditutto()
  {
    analogWrite(VERDE, 255);
    analogWrite(BLU, 255);
    analogWrite(ROSSO, 255);
  }

void spegni(int colore)
  {
    for (int i=0; i<255; i++)
     {
      analogWrite(colore, 255-i);
      delay (delayTime);
     } 
  }
 
void loop()
   { 
      accenditutto();
      spegni(VERDE); 
      spegni(BLU);
      spegni(ROSSO);
   }
 // ---------------------- Fine Programma -------------------------------------------------------------


Simulazione:
Fader per RGB a catodo comune
Fader per RGB ad anodo comune
Controllo di accelerazione per motore in DC con PWM


Arduino N° 24

mercoledì 23 ottobre 2019

Arduino N° 20 - Controllo motore CC con PWM

< Arduino N° 19

 Achille De Santis

> Arduino N° 21




Controllo di velocità per motori in Corrente Continua attraverso comando PWM.
Due pulsanti UP/DOWN permettono di regolare la velocità in modo "proporzionale" con una "gradinata" di 256 valori diversi.
Uno stadio driver a transistore BJT accoppia/separa lo stadio finale attuatore.
Dimensionando opportunamente lo stadio è anche possibile alimentare un motore  a tensioni nominali diverse (es. 12 V o 24 volt).


/* ------------------------------Inizio Programma -------------------------------------
 *  26/5/2015
 *  PWM per comando dei motori in CC (controllo UP/DOWN)
 *  L'uscita va disaccoppiata con uno stadio driver.
 *  Modificato da Achille De Santis il 07-07-2019
 *
*/

// -------------------------- I/O .------------------------
#define UP           2     
#define DOWN    3   
#define USCITA  9           // Uscita PWM
// --------------------------------------------------------

bool S1;                         // variabili booleane interne
bool S2;
const int PAUSA=10;   // Costante pausa. Serve a dare comandi progressivi non troppo veloci.
int pwm;                       // variabile di uscita

void setup()
{
  // Impostazione di pull-up interna ad Arduino
  pinMode(UP, INPUT_PULLUP);            // il pulsante va collegato verso massa
  pinMode(DOWN, INPUT_PULLUP);    // il pulsante va collegato verso massa
  pinMode(USCITA, OUTPUT);               // uscita per comando motore
  pwm = 0;
}

void loop()
{
  S1=digitalRead(UP);
  S2=digitalRead(DOWN);

  if(S1=LOW && pwm<255) pwm++;
    else if(S2=LOW && pwm>0) pwm--;
  analogWrite(USCITA, pwm);
  delay(PAUSA);
}

 // ------------------------------ Fine Programma -------------------------------------