Arduino

Attivare e gestire una candela con ArduinoUNO

Spark plug parte 1: generare archi elettrici utilizzando componenti automotive

In questo tutorial andremo a vedere i passi da compiere per attivare e gestire una candela automotive, in inglese spark plug. L’obiettivo è di generare archi elettrici da decine di kilovolt partendo da una tensione continua di 12 V. Lo schema proposto, ovviamente semplificato quanto più possibile, simula il processo di gestione degli attuali autoveicoli benzina. Infatti, quest’ultimi, per dar vita alla combustione all’interno del motore necessitano di un carburante (benzina) e di un sistema di innesco affidato ad un piccolo arco elettrico generato da una candela all’interno della camera di combustione. La centralina fa scoccare la scintilla di ciascuna candela in un istante preciso rispetto alla posizione del pistone, poco prima del punto morto superiore (anticipo d’accensione): la miscela aria-benzina, iniettata in precedenza, brucia così al momento giusto e il motore resta in moto.

Prendendo in esame un autoveicolo benzina a quattro cilindri possiamo affermare che ogni singola candela viene attivata circa 7 volte al secondo in regime di minimo (750-900 giri/minuto dell’albero motore): in un motore a quattro tempi ogni cilindro accende una volta ogni due giri, quindi a circa 840 giri/minuto si ottengono 840 / 2 / 60 ≈ 7 scintille al secondo. La bobina però non resta alimentata per la maggior parte del ciclo: il transistor conduce solo per il tempo di dwell, cioè i 2-5 ms necessari a caricare la bobina. Con un periodo di circa 143 ms il duty cycle ON è quindi di circa l’1,5-3,5% (2/143 ≈ 1,4% e 5/143 ≈ 3,5%; non il 95%, che corrisponde invece al tempo in cui il transistor resta spento). Quanto segue permette quindi di gestire la candela con i parametri appena descritti.

Componenti necessari

Per realizzare il nostro circuito abbiamo bisogno dei seguenti componenti:

  • 1 Spark Plug: qualsiasi candela va bene; meglio se di tipo resistivo (sigla “R” nel codice), che riduce i disturbi verso Arduino.
  • 1 bobina di accensione (ignition coil): può andare bene sia un sistema a bobina singola (ricavata da autoveicoli più datati che sfruttano lo spinterogeno come distributore meccanico della scintilla) sia un sistema a doppia bobina (sistema a scintilla persa) per attivare contemporaneamente 2 candele.
  • 1 cavo siliconico per candele (non risparmiate su questo cavo… rappresenta la sicurezza di questo progetto)
  • 1 IGBT d’accensione con clamp integrato: ISL9V3040P3 (consigliato, pilotabile direttamente da Arduino) oppure, in alternativa, il Darlington BU941ZP con stadio driver (vedi più avanti)
  • 1 resistenza 330 Ω (in serie al gate)
  • 1 resistenza 10 kΩ (pull-down tra gate ed emettitore)
  • 1 portafusibile con fusibile da 10 A sul +12 V, montato vicino al polo positivo della sorgente; cavi di potenza di sezione adeguata (almeno 1,5 mm²)
  • 1 scheda programmabile ArduinoUNO o compatibile

Schema elettrico e principio di funzionamento

Schema elettrico per comandare bobina di accensione e candela con ArduinoUNO

Nota: lo schema risale alla versione originale dell’articolo e mostra ancora il transistor 2N6384 con 10 kΩ di base, oggi sconsigliato (vedi più avanti). Il circuito corretto è quello descritto nel testo: IGBT ISL9V3040P3 con 330 Ω in serie al gate, 10 kΩ di pull-down tra gate ed emettitore, fusibile da 10 A sul +12 V e massa comune tra Arduino e stadio di potenza.

ArduinoUNO verrà programmato affinché una sua uscita digitale produca, alla frequenza di 7 Hz, un breve impulso HIGH (il dwell) seguito da una lunga pausa LOW. Durante l’impulso il transistor conduce e la corrente nel primario della bobina cresce; al termine dell’impulso il transistor si apre di colpo, la corrente viene interrotta e sul secondario nasce l’alta tensione che fa scoccare la scintilla. La scintilla avviene quindi sul fronte di discesa del segnale.

Perché i transistor si guastano (e perché non serve un diodo di ricircolo)

Nelle prime prove avevo notato che transistor BJT e MOSFET generici funzionano solo per alcuni cicli prima di danneggiarsi. La causa non è la mancanza del diodo di ricircolo: un diodo in antiparallelo al primario farebbe ricircolare la corrente della bobina, limitando la tensione sul primario a meno di 1 V. In quel modo non si genererebbe alcuna alta tensione sul secondario e la scintilla non scoccherebbe. Il diodo di ricircolo va bene per relè ed elettrovalvole, non per una bobina di accensione.

Il vero problema è la sovratensione sul collettore. All’apertura del transistor il primario genera picchi di 300-400 V (che, moltiplicati per il rapporto spire della bobina, danno le decine di kV sul secondario). Se la scintilla tarda o non scocca, la tensione sale ancora. Un transistor generico, non protetto, va in breakdown a valanga e dopo pochi cicli si distrugge.

La soluzione è un clamp che limiti la tensione di collettore a un valore sicuro ma comunque sufficiente per la scintilla:

  • clamp attivo collettore-gate/base con una catena di zener o un TVS (circa 350-400 V): quando la tensione supera la soglia, il transistor si riaccende parzialmente e dissipa in modo controllato l’energia in eccesso;
  • oppure, più semplicemente, un dispositivo d’accensione con clamp interno, come gli IGBT d’accensione usati nelle centraline (ISL9V3040, clamp interno di circa 400 V) o il Darlington BU941ZP (zener interno collettore-base di circa 350 V).

Anche con il clamp, evita di far funzionare il circuito con la candela scollegata: senza scintilla tutta l’energia della bobina deve essere assorbita dal clamp, e l’alta tensione può perforare l’isolamento interno della bobina.

Scelta del transistor e calcolo della resistenza di comando

Il 2N6384 della versione originale è inadatto: ha una VCEO di circa 60 V, ben al di sotto dei 300-400 V di flyback. Inoltre, con 10 kΩ di base la corrente di pilotaggio era di circa (5 − 1,4) V / 10 kΩ ≈ 0,36 mA: anche con un guadagno di 1000 il transistor poteva condurre solo poche centinaia di mA, troppo pochi per saturare con i diversi ampere richiesti dalla bobina.

Corrente di primario. In una bobina la corrente cresce secondo la legge I(t) = (V / R) · (1 − e−t·R/L). Una bobina moderna ha tipicamente R ≈ 0,4-0,8 Ω e L ≈ 3-6 mH. Con R = 0,5 Ω e L = 4 mH, a 12 V si ottengono circa 7,5 A dopo 3 ms e circa 11 A dopo 5 ms. Le bobine più datate (R ≈ 1,5-3 Ω, spesso con resistenza di zavorra) si fermano invece a 4-6 A anche con dwell più lunghi. Il dwell va quindi scelto in base alla bobina: parti da 3 ms con le bobine a bassa resistenza e verifica la corrente con una pinza amperometrica o una resistenza di shunt, puntando a 6-8 A di picco.

Opzione consigliata: ISL9V3040P3. È un IGBT “logic level” con clamp interno, pensato proprio per l’accensione (VCE(sat) di circa 1,3-1,6 V a 6-10 A con 4-5 V sul gate) e regge senza problemi la corrente indicata. Il gate si comanda in tensione, quindi la resistenza serve solo a limitare il picco di corrente di carica: con 330 Ω si ha 5 V / 330 Ω ≈ 15 mA, entro i limiti di un pin di ArduinoUNO. La resistenza da 10 kΩ verso l’emettitore tiene l’IGBT spento mentre Arduino si avvia o viene riprogrammato (pin flottante), evitando che la bobina resti alimentata.

Alternativa: BU941ZP. È un Darlington con zener di clamp integrato, ma è pilotato in corrente: per saturarlo a circa 8 A servono circa 100 mA di base, che un pin di Arduino (20 mA consigliati, 40 mA massimi) non può fornire. Serve uno stadio driver, ad esempio un PNP BD140 con emettitore sul +12 V, comandato da un NPN BC337 collegato ad Arduino. La resistenza di base va calcolata così: Rb = (12 V − VCE(sat) driver − VBE Darlington) / Ib = (12 − 0,5 − 2,0) V / 0,1 A ≈ 100 Ω, da 0,5 W (con un duty cycle di pochi punti percentuali la potenza media è molto bassa).

Il transistor, configurato per lavorare tra la zona di interdizione e la zona di saturazione, si comporta come un interruttore digitale pilotato alla frequenza prestabilita nel software di ArduinoUNO. Per approfondire l’argomento rimandiamo al seguente articolo:

BJT NPN come interruttore

Nella bobina di accensione, alimentata a +12 V, scorrerà quindi una corrente che verrà bruscamente interrotta alla fine di ogni dwell. Questa violenta interruzione genera sul primario una sovratensione di alcune centinaia di volt, limitata dal clamp del transistor, che la bobina porta a decine di kV sul secondario e che, tramite il cavo siliconico, raggiunge la spark plug (o più comunemente chiamata candela).

La candela DEVE avere il corpo filettato connesso a GND (potenziale 0 V) per chiudere il circuito. Se tale connessione è assente, oltre a creare una forte instabilità del circuito, non permetterà la generazione della scintilla e l’alta tensione cercherà un’altra strada verso massa.

Programmazione di ArduinoUNO

Per pilotare correttamente il transistor dobbiamo generare un impulso di dwell ripetuto nel tempo. Se vogliamo avvicinarci ai parametri reali di un autoveicolo al minimo consideriamo una frequenza di 7 Hz (periodo di 1000/7 ≈ 142,9 ms, che nel codice la divisione intera tra interi riduce a 142 ms) e un dwell di 3 ms: il transistor resta acceso per 3 ms e spento per 139 ms, con un duty cycle ON di circa il 2,1%. Il dwell di 5 ms va considerato solo come limite massimo. Tenendo i parametri in costanti con un nome chiaro è facile adattarli alla propria bobina:

// Comando di una bobina di accensione con ArduinoUNO
// Transistor: IGBT d'accensione ISL9V3040 (oppure BU941ZP con stadio driver)

const uint8_t PIN_BOBINA = 10;                  // uscita verso il gate (tramite 330 ohm)
const unsigned long FREQUENZA_HZ = 7;           // scintille al secondo (minimo, 4 cilindri)
const unsigned long PERIODO_MS = 1000 / FREQUENZA_HZ;   // 142 ms (divisione intera)
const unsigned long DWELL_MS = 3;               // tempo di carica bobina, transistor ON (massimo 5 ms)
const unsigned long PAUSA_MS = PERIODO_MS - DWELL_MS;   // transistor OFF, 139 ms
// Duty cycle ON = DWELL_MS / PERIODO_MS = 3 / 142, circa 2,1%

void setup() {
  digitalWrite(PIN_BOBINA, LOW);   // bobina non alimentata all'avvio
  pinMode(PIN_BOBINA, OUTPUT);
}

void loop() {
  digitalWrite(PIN_BOBINA, HIGH);  // ON: la corrente nel primario cresce
  delay(DWELL_MS);
  digitalWrite(PIN_BOBINA, LOW);   // OFF: la corrente si interrompe e scocca la scintilla
  delay(PAUSA_MS);
}

Non aumentare il dwell oltre il necessario: una volta raggiunta la corrente di picco desiderata, un dwell più lungo non produce una scintilla migliore ma solo più calore nella bobina e nel transistor. Il valore predefinito DWELL_MS = 3 è adatto alle bobine a bassa resistenza (circa 7,5 A con la bobina d’esempio, mentre 5 ms darebbero circa 11 A); solo con bobine datate ad alta resistenza si può salire fino a 5 ms, verificando la corrente.

La funzione delay() blocca il programma: se lo sketch deve svolgere anche altri compiti (lettura di sensori, pulsanti, display), conviene gestire dwell e pausa con millis(), come spiegato nell’articolo Semplice orologio con la funzione millis().

Proteggere Arduino e il PC. Le scariche producono forti disturbi elettromagnetici che possono resettare o danneggiare ArduinoUNO e la porta USB del computer. Carica lo sketch, poi scollega il cavo USB e alimenta Arduino in modo autonomo (batteria o alimentatore dedicato, con la massa in comune con il −12 V dello stadio di potenza) prima di collegare la bobina. Tieni il cavo AT e la candela lontani dalla scheda e dai cavi di segnale; per una separazione completa si può interporre un optoisolatore tra il pin di Arduino e lo stadio di pilotaggio.

Admin | MST-Tutorial

Appassionato di elettronica, elettrotecnica e programmazione. Fondatore di MST-Tutorial, condivido con entusiasmo conoscenze, esperienze e progetti legati all’innovazione tecnologica, con l’obiettivo di rendere accessibili concetti tecnici complessi attraverso tutorial chiari e pratici.

Articoli Correlati

Check Also
Chiudi
Pulsante per tornare all'inizio