Realizza un Fuoco Artificiale con Arduino: Tecnologia e Design per Serate Invernali Speciali

Con l’uso di un Arduino, possiamo creare un accogliente fuoco artificiale senza fiamme, cenere o odore di fumo, utilizzando LED colorati e vapore per portare un tocco suggestivo nella nostra casa e creare l’atmosfera perfetta per le serate invernali.

Nella trasposizione cinematografica del capolavoro di Collodi, diretta da Luigi Comencini, il povero Mastro Geppetto (mirabilmente interpretato dal compianto Nino Manfredi), babbo putativo e creatore di Pinocchio, non avendo un soldo per scaldarsi dipinse sul muro un camino, probabilmente perché anche solo l’immagine ed il pensiero di averne in casa uno vero poteva far molto, riscaldando l’animo quanto la vera legna e la brace scalderebbero la stanza ed il suo corpo.

Dalla fantasia alla realtà, poco cambia, perché talvolta è vero che la sola vista di un fuoco ci basta a farci sentire meglio e a cambiare l’umore nelle giornate fredde. Sarà forse per questo che esistono stufe e caminetti che simulano il fuoco, pur senza scaldare, almeno per quel che la Fisica definisce calore.

Ed è per la stessa ragione che vogliamo proporvi la relizzazione di un bracere con un fuoco di apparenza, per scaldare almeno l’animo nelle feste di fine d’anno e in ogni altra occasione nella quale si vuole rendere più “caldo” e accogliente un ambiente.

Un fuoco che ha degli innegabili vantaggi: potete collocarlo come meglio credete perché non rischiate di incendiare alcunché, tantomeno l’arredo di casa; non sporca né fa cattivo odore e, tantomeno, richiede l’aerazione costante o periodica dell’ambiente, in quanto non consuma ossigeno.

Il progetto del Fuoco con Arduino

Il nostro fuoco artificiale viene realizzato combinando un effetto luminoso, nello specifico la luce tremolante multicolore caratteristica delle fiamme, con la produzione di fumo artificiale, che poi fumo non è ma, semmai, un vapore; alla gestione di tali effetti provvede una comune scheda Arduino UNO, opportunamente programmata con lo sketch che vi proporremo tra breve.

Il fumo è ottenuto con un nebulizzatore alimentato in corrente continua, che micronizza acqua che appare come della nebbia ed esce dal fondo del “bracere” spinto verso l’alto; la luce deriva invece da tre moduli LED COB, due a luce bianca e uno a luce rossa, che vengono alimentati ad impulsi per ottenere l’effetto visivo della luce tremolante prodotta dal fuoco. Una ventola, la cui velocità di rotazione può essere variata a piacimento, “soffierà sul fuoco” aumentando il fumo.

Il tutto può essere attivato sia costantemente, una volta alimentato l’insieme, ovvero quando qualcuno si approssima, grazie all’intervento di un sensore di movimento a infrarossi passivi (P.I.R.) che correda il sistema; la selezione si effettua mediante un comune interruttore a pulsante, che può anche essere omesso se si vuole una sola modalità.

Il circuito che relizza tutto questo è meglio descritto dallo schema di cablaggio pubblicato in queste pagine, che vi invitiamo a seguire per comprendere la descrizione del funzionamento; il cuore del progetto è Arduino UNO, alle cui linee di I/O abbiamo collegato due moduli driver a MOSFET (uno per gestire la ventola e l’altro per comandare il LED di potenza bianco) un potenziometro per variare la velocità di rotazione della ventola, un nebulizzatore elettrico a ultrasuoni, un sensore P.I.R. per rilevare l’approssimarsi delle persone e accendere il fuoco e, infine, una scheda a due relé comandabile con impulsi TTL, la quale commuta l’alimentazione verso il controller dei LED e il nebulizzatore, per accenderli.

Su Arduino c’è poco da dire, essendo una scheda ormai conosciutissima; di essa abbiamo utilizzato, e configurato all’avvio dello sketch, i seguenti I/O:

• D12, inizializzato come input per leggere il segnale del sensore P.I.R. ossia l’1 logico quando il radar a infrarossi passivi rileva il movimento di una persona nel proprio raggio di azione;
• D3, inizializzato come output PWM e utilizzato per produrre il segnale a impulsi modulati in larghezza con cui viene pilotato il driver della ventola;
• D13, inizializzato come output digitale per controllare l’accensione pulsante di uno dei LED COB bianchi tramite il driver a MOSFET;
• D4 e D5, inizializzati come uscite digitali per comandare la scheda a 2 relé potendo operare distintamente sui due relé;
• A0, input analogico con cui tramite l’ADC di Arduino acquisiamo la tensione fornita dal cursore del potenziometro (alimentato agli estremi dai pin 5V e GND della scheda…) che verrà convertita nel duty-cycle della tensione PWM erogata dal pin D3 al modulo controller a MOSFET per la ventola.
• D8, inizializzato come ingresso digitale con pull-up interna viene utilizzato per scegliere la modalità di funzionamento. Se lo stato del PIN si trova a livello basso il fuoco rimarrà sempre acceso, mentre se a livello alto, verrà considerato il sensore P.I.R. per l’attivazione dello stesso.

Riguardo alla gestione della scheda relé 2 canali, facciamo notare che pur potendo utilizzare un unico pin di uscita per pilotare i due ingressi (unendoli…) abbiamo preferito usare due linee separate, sebbene nel nostro firmware è previsto che le due linee siano attivate insieme per dare alimentazione a LED, ventola e nebulizzatore, ovvero disattivate simultaneamente per spegnere i predetti componenti e dispositivi.

La disponibilità di due linee permetterà di apportare modifiche alla gestione di LED e nebulizzatore, se lo riterrete opportuno.

Andiamo ora ad analizzare i singoli componenti impiegati nello schema, iniziando con il sensore a infrarossi passivi: si tratta di un P.I.R. miniaturizzato siglato MINIPIRMOD (lo vedete in Fig. 1); questo sensore in miniatura contiene il sensore piroelettrico con lente di Fresnel e una scheda di interfaccia con uscita a livello TTL comptibile 0/3,3V.

Il sensore ha un tempo di ritardo fisso di 10 secondi dall’accensione, un assorbimento a riposo inferiore a 50 µA, un angolo di rilevamento di 110° e una portata massima di 5 metri, più che sufficiente per il nostro scopo.

Dispone di tre piedini, uno di uscita logica e due di alimentazione a 5Vcc. A riposo l’uscita è a zero logico, mentre in caso venga rilevato lo spostamento di un corpo fornisce un impulso a +3,3V.

Malgrado Arduino UNO sia a logica TTL e quindi 0/5V, i suoi ingressi leggono correttamente i 3,3V come 1 logico, quindi non abbiamo problemi di sorta.

Fig. 1 Il sensore a infrarossi passivi.

Fig. 2 Il nebulizzatore con LED.

Passiamo ora al nebulizzatore che produce il fumo artificiale: si tratta del prodotto codice HS2682, che possiamo assimilare a una piccola macchina per il fumo utilizzabile per realizzare piccole sculture animate e oggetti d’arredo: la nebulizzazione è ottenuta mediante un trasduttore ad ultrasuoni a disco del diametro di 20 mm, operante alla frequenza di 1,7 MHz, che urtando il liquido lo micronizza come farebbe una macchinetta per l’aerosol.

Per il nostro progetto abbiamo utilizzato della comune acqua di rubinetto o distillata: il risultato è garantito in ogni caso.

Il nebulizzatore dispone di un anello di 12 LED disposti attorno al trasduttore a ultrasuoni, che abbiamo oscurato con vernice nera per non alterare la luce prodotta dai LED COB.

Il prodotto viene fornito con un alimentatore da rete, ma nel nostro progetto lo alimentiamo indirettamente attraverso lo scambio di uno dei relé della scheda relé 2CH, quindi utilizziamo sì l’alimentatore, ma con una presa jack prendiamo i 24Vcc dal suo spinotto e li portiamo alla scheda relé in modo che possa accendere e spegnere in nebulizzatore quando occorre.

Questo dispositivo nasce per aggiungere l’effetto nebbia a fontane da interni, giochi d’acqua, paesaggi in vaso, ecc. e va benissimo per simulare le fiamme che escono dal fuoco.

La nebbia generata è in quantità più che sufficiente per i nostri scopi, ossia 400 ml/h di liquido.

Procediamo e andiamo a vedere la sezione di attuazione a relé, composta dalla scheda MODULO RELÈ 2 CH (Fig. 3), RELAY2CH: si tratta sostanzialmente di due relé comandati ciascuno da un ingresso TTL compatibile che fa capo ad un transistor NPN il cui collettore pilota la bobina quando l’ingresso corrispondente riceve il livello logico alto (5V).

I relé hanno entrambi la bobina funzionante a 5 volt e quindi la scheda si alimenta con 5Vcc, tensione che viene prelevata dal pin 5V di Arduino UNO.

Fig. 3 La scheda con due relé.

I due relé commutano le due alimentazioni del circuito e, più nel dettaglio, CH1 (IN1) quando viene eccitato chiude l’alimentazione 12Vcc principale di ingresso sul parallelo dei tre LED COB, ciascuno dei quali richiede 12V; i 12V all’ingresso del circuito alimentano permanentemente la scheda Arduino, la quale deve rimanere sempre alimentata (non preoccupatevi perché a riposo assorbe pochissimo…) per poter assolvere alle funzioni di controllo del sistema.

Il secondo relé (CH2-IN2) provvede invece a portare l’alimentazione fornita dall’alimentatore a 24Vcc all’ingresso di alimentazione del nebulizzatore con LED.

Passiamo adesso ai due driver a MOSFET siglati MOSDRIVER: ciascuno di essi contiene due MOSFET di potenza a canale N collegati in parallelo che controllano in modo sink l’alimentazione di un utilizzatore funzionante a bassa tensione e in continua; la scheda (Fig. 4) ha un ingresso logico che quando viene portato a livello alto (5Vcc) porta in stato di ON il MOSFET, il cui drain è collegato al negativo dell’uscita in modo che connettendo il carico tra esso ed il positivo, lo stato di ON determina l’alimentazione del carico stesso.

Fig. 4 Il modulo driver a MOSFET.

Il modulo permette anche, inviando un segnale PWM in ingresso con frequenza max di 20 kHz (trigger: 0V uscita disabilitata – 3,3V÷20V uscita attiva), di controllare motori elettrici in continua e altri utilizzatori modulabili in PWM che richiedano un’alimentazione compresa tra 5 e 36 Vcc e assorbano fino a 15 A (max 400 watt).

Le due morsettiere del modulo sono state previste dal costruttore, una per l’alimentazione e l’altra per l’uscita, fermo restando che l’alimentazione da fornire dev’essere a tensione uguale a quella del carico.

Il driver della ventola è comandato da un segnale PWM e alimenta la ventola che soffierà sul fumo per farlo uscire più in fretta, ovvero lo aspirerà (se la mettete sopra al nebulizzatore) per soffiarlo verso l’alto, mentre quello dei LED controlla l’accensione tremolante di uno dei LED COB bianchi: l’altro di questi LED è collegato in parallelo al rosso e viene acceso a luce fissa quando il relé della scheda relé chiude l’alimentazione, la quale viene commutata anche per il driver MOSFET, dato che la linea 12V uscente dal relé viene riportata sulla morsettiera di alimentazione del driver stesso.

Notate che questa particolare modalità di comando permette di simulare bene il tremolìo della fiamma, giacché due LED sono sempre accesi e il bianco (che come vedremo verrà mascherato, insieme agli altri due, da una lastra di plexiglass di colore rosso-violetto, fermata attraverso del nastro di Kapton) pulserà con una determinata frequenza, correggendo l’effetto visivo dei LED accesi fissi e facendo in modo che si avvicini il più possibile a quello della fiamma vera.

Chiudiamo la panoramica sugli elementi connessi ad Arduino UNO con il potenziometro collegato alla linea di I/O A0 di Arduino, che dev’essere di tipo a variazione lineare, di valore non critico, in quanto potete utilizzarne uno con resistenza compresa fra 4,7 e 100 kohm.

Schema di cablaggio del fuoco con Arduino

Realizzazione pratica del fuoco con Arduino

Ora possiamo concentrarci sulla parte pratica del progetto, che implica sia una realizzazione meccanica, sia un cablaggio dei vari dispositivi componenti il sistema.

Sul piano elettrico/elettronico, dovete collegare il tutto come mostrato nello schema di cablaggio che vedete in queste pagine, utilizzando di volta in volta cavetti jumper per Arduino o spezzoni di filo in rame in guaina del diametro di 0,25 mm.

Per la linea di alimentazione che va dal jack di ingresso 12V alle morsettiere della scheda relé e da questa ai LED COB, utilizzate della piattina rosso-nera, così da facilitare l’identificazione della polarità; come sezione della linea tra l’alimentazione a 12V e la scheda relé usate 2×0,75 mm, dato che i tre LED al massimo della potenza assorbono intorno ai 3,5 ampere. Invece per la connessione fra la scheda MOSDRIVER e l’uscita della linea 12V della scheda relé, va bene una piattina 2×0,5 mmq.

Riguardo alle barre a LED, ricordate che vanno tra loro in parallelo e direttamente alimentati dallo scambio del relé 1 un LEDCOB200R ed un LEDCOB200W, mentre alla morsettiera di uscita del modulo MOSDRIVER pilotato dal pin 13 di Arduino UNO collegherete l’altro LEDCOB200W.

Notate che siccome i LED COB scaldano abbastanza, abbiamo previsto di posizionarli e fissarli su un dissipatore di calore, come proposto nella Fig. 5, che ritrae un dettaglio del nostro prototipo.

Come vedete, i LED COB sono stati fissati a una piastrina di alluminio e questa è stata poi applicata, interponendo della pasta termica al silicone, ad un radiatore di calore in alluminio alettato, avente resistenza termica di circa 1 °C/W. Il collegamento di queste barrette luminose è semplificato dal fatto che i poli + e – sono ripetuti sui lati corti, con lo stesso orientamento.

Per alimentare il nebulizzatore e per la linea che dal jack di ingresso 24V porta alla morsettiera relativa al relé 2 della scheda relé, utilizzate della piattina 2×0,5 mmq, badando alla polarità del collegamento.

Ricordate di collegare al pin digitale D8 di Arduino UNO un interruttore, a levetta o a pulsante, terminante a GND, per decidere se mantenee sempre in funzione il bracere o asservirne l’accensione alla presenza e al movimento di persone davanti al sensore MINIPIRMOD; a riguardo vi facciamo notare che se non vi interessa la funzione di attivazione solo in presenza di persone, potete non montare il sensore a infrarossi passivi e ponticellare a GND la linea D8 di Arduino UNO.

Fig. 5 Montaggio e cablaggio dei LED COB.

Adesso andiamo alla parte meccanica, da realizzare con i materiali e la forma che riterrete più opportuno, anche sulla base degli attrezzi e delle capacità di cui disponete; potete prendere spunto dal nostro prototipo, che di fatto è un bracere o se volete, la base di un camino che poi porrete nell’ambiente in base al vostro gusto.

Il tutto deve avere alla base un contenitore in materiale isolante dove sistemerete l’elettronica ed un piano aperto su cui potrete disporre della legna, per far sembrare il fuoco più realistico.

La parte meccanicamente più complessa risiede nel sistema di produzione e diffusione, almeno se volete fare un convogliatore come quello da noi realizzato; bisogna, in pratica, collocare e incollare con del slicone sigillante il nebulizzatore in un contenitore in plastica tipo quelli per alimenti, sul fondo, quindi forare il coperchio per applicare la ventola mediante silicone sigillante o colla a caldo e poi fare un secondo foro per realizzare il bocchettone di carico del liquido da nebulizzare.

Potete ricavare il bocchettone da una tanichetta in plastica da 5 litri di acqua distillata, tagliandone la sommità dove finisce il collo e incollando questa parte sul foro realizzato nel coperchio del contenitore per alimenti, tramite silicone sigillante o colla a caldo. Chiaramente prima di fare il foro dovete aver scelto cosa usare come bocchettone.

Affinché il sistema erogatore funzioni, ossia soffi fuori il fumo, la ventola andrà collegata in maniera che spinga l’aria all’interno del contenitore, pertanto dovrete disporla con l’uscita verso l’interno del contenitore; inoltre, per evitare che disturbi il vaporizzatore, è utile incollare o fissare tramite viti o rivetti, una lamina in plastica o alluminio che diriga il getto d’aria lontano dalla superficie del trasduttore a ultrasuoni.

In caso contrario ostacolerebbe la produzione del fumo artificiale. Prendete a riferimento la Fig. 6 e la Fig. 7 per realizzare l’erogatore di fumo artificiale.

Nel nostro prototipo, abbiamo aggiunto all’erogatore una finezza: un diffusore a più canali ottenuto tagliando 6 spezzoni di profilato in plastica a sezione rettangolare (ma il numero non è vincolante: possono essere anche solo tre o quattro) e chiudendoli a sandwich con due lastre di plexiglass da 2 mm applicato con della colla; questo diffusore consente di dirigere il fumo lungo una zona rettangolare, che potrete far coincidere con la cava da realizzare alla base di sostegno della legna per far uscire il vapore e la luce prodotta dai LED COB.

Fig. 6 L’erogatore di fumo al completo, con il diffusore multicanale applicato al coperchio.

Fig. 7 La lamina di deflessione del flusso d’aria incollata all’interno del coperchio del contenitore.

Nell’utilizzo non preoccupatevi di bagnare il nebulizzatore, perché è in esecuzione stagna e quindi sopporta tranquillamente l’acqua; ricordate che il nebulizzatore deve avere un minimo di copertura di liquido, altrimenti la produzione di fumo verrà interrotta. Il minimo livello è quello che corrisponde a coprire il sensore presente sulla sommità del nebulizzatore.

A proposito di LED COB, nel nostro caso li abbiamo coperti con una lastra di plexiglass rosso-arancio affinché la luce prodotta diventi più simile a quella del fuoco di un camino; riferitevi alla Fig. 8 per l’assemblaggio del relativo blocco.

Per l’assemblaggio del sistema potete prendere spunto dalla Fig. 9, che illustra la disposizione degli elementi sinora descritti e del circuito all’interno di un contenitore in cartone, rivestito con della carta colorata di nero, in funzione di bracere e quindi di base del nostro fuoco.

A chiudere superiormente l’insieme potrete mettere un pannello in cartone ondulato pesante con una feritoia abbastanza larga da far uscire il fumo e la luce; su questo pannello disporrete una sorta di montagnetta di carbone fatta con della carta sagomata mediante colla vinilica diluita in acqua e opportunamente increspata, che una volta asciugata potrete colorare di nero con della pittura ad acqua, magari con della vernice acrilica.

Sopra questo finto carbone potrete appoggiare dei pezzi di rami secchi, che una volta acceso il tutto sembreranno ardere come su un fuoco vero, illuminati dalla luce dei LED COB e circondati dal fumo prodotto dal vaporizzatore.

Fig. 8 I LED sono stati coperti da una lastra colorata per modificare il colore della luce emessa.

Fig. 9 Gli elementi disposti nel contenitore base che abbiamo realizzato.

La programmazione

Una volta completato il tutto sul piano sia elettronico che meccanico, dovrete programmare la scheda Arduino affinché lo gestisca come previsto; dovrete quindi caricarvi lo sketch.

Il codice è meglio descritto nel Listato 1, dove vediamo che come prima cosa vengono definiti i pin per l’uscita PWM (pin 3) e per l’ingresso analogico (A0) con il quale Arduino leggerà la tensione del potenziometro, per poi convertirla in un valore numerico che verrà utilizzato nel loop, ossia nella porzione seguente:

void ventola()

che opera il controllo di velocità della ventola in based alla lettura del cursore del potenziometro, la quale avviene mediante l’istruzione:

float val = analogRead(pot);

La riga seguente imposta il duty-cycle del PWM fornito dal pin 3 in base al valore dell’ADC:

float duty = map(val,0,1023,0,255);

e l’istruzione:

analogWrite(pwm, duty);

genera il segnale rettangolare PWM sulla base della variabile “duty”.

Nel setup dello sketch vengono impostati gli I/O di Arduino definendo sia se saranno input oppure output (e che tipo di output) sia le modalità (per esempio, pinMode(pwm,OUTPUT)).

Sempre nel setup, si imposta il funzionamento della porta seriale per l’utilizzo eventuale di Serial Monitor e si disattivano le uscite PWM e dei due relé, in modo da predisporre il circuito nelle condizioni iniziali. Si passa poi al loop, ripartito in varie sezioni, ognuna delle quali gestisce un aspetto del funzionamento del circuito; prima abbiamo esposto quella di controllo della ventola tramite segnale PWM asservito alla lettura del pin analogico A0, ma il loop inizia con la prima verifica da fare, la quale poi determina il funzionamento del sistema.

Più esattamente, controllo_int(); testa lo stato dell’interruttore collegato al pin digitale 8 in modo da decidere se ciò che verrà dopo dipenderà dal livello logico fornito dal sensore P.I.R. al pin digitale 12, ovvero se verrà eseguito a prescindere, dal momento in cui il circuito è acceso ed è terminata l’inizializzazione.

In particolare, se l’interruttore è chiuso il funzionamento è indipendente, mentre se è aperto, si avvia soltanto quando la variabile PIR è a livello 1.

Se ha valore 0, trascorso un certo intervallo di ritardo il sistema (ossia i LED e il vaporizzatore, con relativi relé) viene portato a riposo.

Bene, precisato ciò passiamo alla programmazione di Arduino UNO, che va effettuata al solito da un Personal Computer con installato l’IDE Arduino e dotato di porta USB: collegate con un cavo USB A/B il PC al connettore USB di Arduino e, senza alimentare il sistema, quando la scheda è stata correttamente riconosciuta aprite il file dello sketch (comando di menù File>Apri), quindi dal menù Strumenti, selezionate il tipo di scheda con il comando Scheda… e di seguito scegliete la COM virtuale cui è collegata tramite USB.

Fatto ciò cliccate sul pulsante Carica (freccia a destra in alto nella toolbar dell’interfaccia utente dell’IDE, sotto il menù) e attendete il completamento del caricamento. Fatto ciò, chiudete l’IDE, sconnettete il cavo da Arduino e siete pronti per mettere in funzione il vostro fuoco, per vedere come funziona.

Ricordate che per l’alimentazione dell’insieme vi occorre un alimentatore capace di erogare una tensione continua, meglio se stabilizzata, di 12V e una corrente di circa 4 ampère; serve ovviamente anche l’alimentatore dedicato del vaporizzatore, fornito in dotazione con esso.

Listato 1

#define pwm 3 // pin 3, uscita PWM per controllo ventola
#define pot A0 // pin A0, centrale potenziomentro

int ledPin = 13; // pin comando LED bianco
int PIR = 12; // pin ingresso segnale del sensore PIR
int interruttore = 8; // pin interruttore per accensione fissa (esclude il sensore PIR)
int rel1 = 5; // pin controllo relè 1
int rel2 = 4; // pin controllo relè 2
int I_ON = 0; // variabile attivazione interruttore
byte flicker[] = {
  190,
  90,
  109,
  100,
  255,
  200,
  120,
  150,
  100,
  230,
  180,
  125,
  110
}; // definisci valori per creare sfarfallio LED bianco

void setup() {
  pinMode(pwm, OUTPUT); // imposta come uscita
  pinMode(pot, INPUT); // imposta come ingresso
  pinMode(ledPin, OUTPUT); // imposta come uscita
  pinMode(PIR, INPUT); // imposta come ingresso
  pinMode(interruttore, INPUT_PULLUP); // imposta come ingresso pull-up
  pinMode(rel1, OUTPUT); // imposta come uscita
  pinMode(rel2, OUTPUT); // imposta come uscita

  Serial.begin(9600); // definisci velocità porta seriale
  analogWrite(pwm, 0); // disattiva ventola
  digitalWrite(rel1, LOW); // disattiva relè alim. 12V
  digitalWrite(rel2, LOW); // disattiva relè alim. 24V 
}

void loop() {
  controllo_int(); // controlla stato interruttore a pulsante
}

void fiamma() // genera tremolio LED bianco
{
  for (int i = 0; i < 13; i++) {
    analogWrite(ledPin, flicker[i]); // attiva ledpin con valore definito da flicker
    ventola(); // attiva ventola secondo potenziometro
    delay(40); // ritardo
  }
}

void ventola() // controllo velocità ventola con potenziometro
{
  float val = analogRead(pot); // leggi valore assunto da potenziometro
  float duty = map(val, 0, 1023, 0, 255); // definisci il duty in funzione della posizione del potenziometro
  analogWrite(pwm, duty); // genera PWM per controllo ventola 
}

void rele_ON() // attiva i relè di alimentazione
{
  digitalWrite(rel1, HIGH); // attiva relè 12V
  digitalWrite(rel2, HIGH); // attiva relè 24V 
}

void rele_OFF() // disattiva i relè di alimentazione
{
  digitalWrite(rel1, LOW); // disattiva relè 12V
  digitalWrite(rel2, LOW); // disattiva relè 24V 
}

void controllo_int() // controlla stato interruttore a pulsante 
{
  if (digitalRead(interruttore) == LOW & I_ON == 1) //se interruttore chiuso e variabile interruttore =1
  {
    rele_ON(); // attiva i 2 relè di alimentazione 
    fiamma(); // attiva fiamma con ventola 
  }

  if (digitalRead(interruttore) == LOW & I_ON == 0) //se interruttore chiuso e variabile interruttore =0
  {
    I_ON = 1; // flegga variabile interruttore
    rele_ON(); // attiva i 2 relè di alimentazione 
    delay(1000); // ritardo
    rele_OFF(); // disattiva i 2 relè di alimentazione 
    delay(1000); // ritardo
    rele_ON(); // attiva i 2 relè di alimentazione 
    delay(1000); // ritardo
    rele_OFF(); // disattiva i 2 relè di alimentazione 
    delay(1000); // ritardo
    rele_ON(); // attiva i 2 relè di alimentazione 
    delay(500); // ritardo
    fiamma(); // attiva fiamma con ventola 
  }

  if (digitalRead(interruttore) == HIGH & I_ON == 1) //se interruttore aperto e variabile interruttore =1
  {
    I_ON = 0; // azzera variabile interruttore
    rele_OFF(); // disattiva i 2 relè di alimentazione 
    delay(100); // ritardo
    rele_ON(); // attiva i 2 relè di alimentazione 
    delay(100); // ritardo
    rele_OFF(); // disattiva i 2 relè di alimentazione 
    delay(100); // ritardo
    rele_ON(); // attiva i 2 relè di alimentazione 
    delay(100); // ritardo
    rele_OFF(); // disattiva i 2 relè di alimentazione 
    delay(100); // ritardo
    rele_ON(); // attiva i 2 relè di alimentazione 
    delay(100); // ritardo
  }

  if (digitalRead(interruttore) == HIGH & I_ON == 0) //se interruttore aperto e variabile interruttore =0
  {
    if (digitalRead(PIR) == LOW) // se PIR disattivato
    {
      rele_OFF(); // disattiva i 2 relè di alimentazione
      analogWrite(pwm, 0); // disattiva ventola
    } else if (digitalRead(PIR) == HIGH) // se PIR attivato
    {
      rele_ON(); // attiva i 2 relè di alimentazione 
      fiamma(); // attiva fiamma con ventola
    }

  }
}

Conclusioni

Bene, con questo chiudiamo la descrizione di questo magnifico progetto, dove l’elettronica fa la parte tecnica ma la fantasia e la manualità di ciascuno di voi faranno la differenza e saranno gli elementi che conferiranno al sistema aspetto ed effetto realistico, rendendo confortevole e gradevole l’ambiente dove poi lo collocherete.
Dunque, mettetevi all’opera che le feste di fine d’anno si stanno avvicinando rapidamente!