… redazione in corso … articolo n. 284
Il progetto “CONTAWATT” è davvero interessante e particolare, perchè, a fronte di un hardware semplicissimo, che più semplice non si può, presenta un software molto corposo e capace di calcoli molto complessi, di qui la denominazione “ARCHIMEDE”.
Vedi anche l’articolo n. 269 del novembre scorso: MONITORAGGIO CONSUMI con la centralina “ARCHIMEDE CONTAWATT”.
Questo progetto non è certo il più faticoso, ma ne vado orgoglioso.
In effetti l’hardware è semplicissimo, perchè formato da una scheda arduino – UNO o NANO – da un display seriale e da 2 resistenze; tutto qui, salvo l’alimentatore da 9 volt.
Si può assemblare in pochissimo tempo e nei contenitori praticamente di ogni tipologia e dimensione, purchè in grado di ospitare il display che è la parte più corposa.
Personalmente ho privilegiato le “scatole” per quadro DIN, anche perchè la centralina va utilizzata con un contatore digitale, anch’esso per quadro DIN; il tutto su un quadretto per binario din da 10 moduli, perchè abbiamo anche un sezionatore da 2 moduli.
Il contatore digitale misura l’energia in corrente alternata 230 volt e va inserito in serie alla linea dei consumi o della produzione.
Deve avere le uscite SO+ e SO- che servono alla centralina per “catturare” gli impulsi e elaborare i dati.
PRESTAZIONI
Il lavoro del microcontrolore è piuttosto pesante perchè deve elaborare tantissime informazioni che riversa sul display con due sole videate che si alternano.
Nella prima viene indicata l’energia (watt) istantanei e l’energia cumulata nel tempo (wattora), da quando la centralina è stata accesa.
Nella seconda videata vengono visualizzate 3 informazioni, più precisamente:
1) l’energia (wattora) cumulata nell’ultima ora;
2) quella cumulata nelle ultime 24 ore;
3) quella cumulata negli ultimi 30 giorni.
Questi dati vengono aggiornati continuamente sostituendo con l’informazione più recente quella più obsoleta; vedremo come.
CENTRALINA “PAZZA”
Nonostante la semplicità del progetto è sorto qualche problema, in situazioni particolari, ma c’è la soluzione.
Un problema, assai antipatico, è emerso con una centralina collocata su un piccolo impianto fotovoltaico sperimentale. allo scopo di misurare la produzione, per avere un riscontro circa il rendimento nelle varie situazioni che si presentano, meteo e stagionali.
Ha riguardato la “cattura” – oltre che del segnale SO+ e SO- anche di disturbi che hanno mandato in tilt il microprocessore (arduino UNO o NANO) che, mentre funziona benissimo in laboratorio, a qualunque potenza, in altre situazioni, sul campo, “impazza” e segnala potenze esagerate.
Sembra che il cavetto che trasporta il segnale dalle uscite del contatore digitale alla centralina sia una specie di antenna radio molto sensibile.
La diagnosi – e soprattutto la soluzione – non è stata trovata facilmente.
Questo difetto non si verifica sistematicamente, ma solo in particolari situazioni, ad esempio con la centralina di monitoraggio della produzione, accanto a un microinverter Y & H da 350 watt e solo quando la potenza generata supera un certo limite.
La soluzione è stata difficile da trovare – dopo verifiche con condensatori e altro – ma estremamente semplice: consiste nel rendere meno “dolce” la cattura dell’impulso da contatore digitale con la modifica di una sola riga di codice.
Anzichè
if (volt_partitore_consumi > 200) // la tensione deve essere maggiore di 1 volt:
si è modificato il codice come segue:
if (volt_partitore_consumi > 600) // la tensione deve essere maggiore di 3 volt: In sostanza sono stati maggiorati i segmenti utili per la rilevazione degli impulsi, passati da 200 su 1024 (corrispondenti a circa ad un volt), a 600 che corrispondono all’incirca a 3 volt.
Evidentemente i segnali spuri non sono così forti da arrivare a 3 volt, ma si possono provare anche altri valori.
Un’altra modifica poteva riguardare la diminuzione della resistenza di “carico” ora molto “leggera” da soli 39k, scelta per non “caricare” troppo l’uscita SO- del contatore digitale.
NUMERO DI IMPULSI X KWH
Altro problema.
Nei contatori digitali gli impulsi si manifestano con l’illuminazione di un led, cui corrisponde anche un’uscita di segnale tramite SO+ e SO-.
La potenza istantanea viene misurata con un calcolo che tiene conto del numero di impulsi e del tempo che passa tra un impulso e il precedente.
La taratura di fabbrica prevede un certo numero di impulsi per chilowattora e, in commercio, ci sono contatori con numero di impulsi pari a 1000, 1.600, 2000 e altro ancora.
Nelle mie centraline, e anche in “CONTAWATT“, ho privilegiato l’utilizzo di contatori digitali da 3.200 impulsi, semplicemente perchè l’impulso – e quindi la misura – è molto più veloce.
Purtroppo, ultimamente i contatori digitali da 3.200 impulsi sono diventati introvabili e occorre orientarsi su contatori con un numero inferiore di impulsi per chilowattora.
E’ un inconveniente, tuttavia, mentre la velocità è molto importante quando si tratta di utilizzare il surplus di energia, nella centralina “CONTAWATT” la velocità degli impulsi è poco importante.
C’è la necessità di aggiornare il software e anche questa modifica è di una facilità assoluta: un numero su una riga di codice software.
Anzichè:
int impulsi_kwh = 3200;
modifichiamo come segue:
int impulsi_kwh = 2000;
Attenzione, perchè serve modificare anche un’altra riga di codice, alla riga 167.
potenza_watt_consumi = 1000000 / tempo_trascorso_consumi * 36 / 32;
Questo conteggio va modifica come segue:
potenza_watt_consumi = 1000000 / tempo_trascorso_consumi * 36 / 20;La modifica riguarda l’utilizzo di contatori digitali da 2.000 impulsi, abbastanza comuni, ma il numero 20, al denominatore, si può modificare in 16 con contatori da 1.600 impulsi e in 10 con contatori da 1.000 impulsi.
Di seguito, in calce all’articolo, il software “CONTAWATT” per contatori digitali da 2.000 impulsi.
Questa nuova versione rileva i dati di PRODUZIONE con la visualizzazione delle informazioni istantanee e il cumulo in 1 ora, 24 ore e 30 giorni, davvero molto interessante per quanto assai impegnativ per il microprocessore.
Si è usato il codice per la rilevazione dei consumi con solo le modifiche dei dati visualizzati sul display, senza mettere mano alla ridenominazione delle variabili.
E’ stata anche indicata , nella fase di avvio del software, l’indicazione del numero di impulsi, previsto dalla versione utilizzata.
Immutato anche l’ingresso analogico di arduino: A1.
HARDWARE
L’hardware della centralina “CONTAWATT” è semplicissimo: vanno egualmente bene le schede UNO e NANO.
L’ingresso analogico, deputato alla “cattura” degli impulsi va collegato a SO- e, tra questo ingresso e massa (GND), va posta una resistenza da 39k.
SO+ va collegato ai 5 volt positivi tramite una resistenza di protezione da 100 ohm; non serve alcuna regolazione.
Le informazioni elaborate dal microprocessore vanno visualizzate sul display seriale collegato a GND, +5 volt, A4 e A5.
Tutto qui, salvo l’alimentazione che può essere assicurata da un alimentatore da 9 volt, con positivo su VIN; questo alimentatore può essere collocato sulla millefori e prevede un trasformatore da 6 volt 1,5 watt, un diodo ponte e un condensatore elettrolitico di stabilizzazione, da 470 mf 16 volt.
Il tutto si può collocare su una millefori e questa su un contenitore EFI o da quadro DIN, da 6 moduli, come da foto.
Questa dimensione facilita la collocazione, nella testata della centralina, del display, senza utilizzo di colonnine di supporto.
Prima di assemblare il tutto, va curata con attenzione la collocazione di ciascun componente, compreso il trasformatorino e gli eventuali supporti in nylon per il display (non previsti, nell’esempio).
Su questa base collocare un morsetto per gli ingressi SO+ e SO- (in basso a sinistra) e il filo di collegamento alla tensione AC 230 volt, in ingresso del trasformatorino (in alto).
E’ talmente semplice che non vale la pena realizzare un circuito stampato: è più semplice installare quanto serve su una millefori.
SOFTWARE
Il software fa un grosso lavoro e vengono utilizzate moltissime variabili, abbastanza critiche.
L’energia istantanea viene conteggiata tenendo conto del tempo (millisecondi) che intercorrono tra un impulso e il precedente.
potenza_watt_consumi = 1000000 / tempo_trascorso_consumi * 36 / 20; //valido per contatore da 2000 impulsi L’energia prodotta viene cumulata in tranche di 5 minuti che vanno a “caricare” la memoria dell’energia dell’ultima ora, con il meccanismo della sostituzione (la tranche m12 viene sostituita con la tranche m11, la m11 con la m10, e così via).
Lo stesso meccanismo viene utilizzato per aggiornare il dato giornaliero e quello mensile.
E’ davvero bello vedere questi dati, sempre aggiornati, ogni 5 minuti, sul display.
E’ importante notare che questi dati hanno un valore “fiscale” perchè conteggiati sulla base del conteggio degli impulsi “catturati”:
contawatt_1h = impulsi_1h*1000/impulsi_kwh;
contawatt_24h = impulsi_24h*1000/impulsi_kwh;
contawatt_30g = impulsi_30g/impulsi_kwh; La rilevazione può riguardare l’energia consumata (progetto del novembre scorso) e l’energia prodotta (questa nuova versione).
Il software, cioè lo sketch, va caricato tramite l’IDE di arduino, come di consueto.
Attenzione, come al solito, alla tipologia di display seriale impiegato che richiede una codifica diversa tra quelle proposte, che sono le più comuni.
Altrettanto dicasi riguardo la libreria utilizzata per il display seriale, di PARSIC-ITALIA, sostituibile con quella utilizzata d’abitudine.
Non resta che divertirsi a verificare la produzione con il bello e il brutto tempo e con le varie stagioni, tramite questa centralina “fiscale”.
Oggi, 10 aprile, con cielo sereno, ho verificato una produzione di 260 watt sul piccolo impianto con 2 pannelli da 175 watt ciascuno, e 72 celle, molto datati.
Moltiplicando per 10 i valori emersi otteniamo le risultanze di un impianto da 3 kw.
MICROINVERTER
Il microinverter è un Y & H da 350 watt. Quest’ultimo è molto semplice, economico, carino e di dimensioni molto contenute; purtroppo, nonostante la temperatura fresca, scalda parecchio e serve un sistema di raffreddamento: ne riparleremo.
Da subito qualcosa è stato fatto.
Nella foto si vede chiaramente che il microinverter è stato collocato su una barra di alluminio che funge da dissipatore.
Sono stati fatti anche fori di sfiato dell’aria calda, nelle pareti laterali.
Sarà sufficiente per garantire, nelle giornate caldissime e afose di agosto, una buona produzione, senza anomalie ?
PRESTAZIONI MICRO IMPIANTO FV
L’impianto è davvero micro, perchè composto da due “vecchi” pannelli da 175 watt, ciascuno da 72 celle, posti in parallelo.
I pannelli sono collocati su una casetta e l’esposizione non è neppure ottimale, perchè con leggero orientamento sud-ovest.
Le prestazioni sono però interessanti ed oggi, nonostante qualche nuvola, si è quasi raggiunto il livello di 2 Kwh, più esattamente 1.955 wattora.
17/02/2023: invece oggi giornata completamente nuvolosa senza il minimo raggio di sole. Risultato: 464 wattora prodotti, cioè un quarto del giorno prima.
Non rimane quindi che continuare a monitorare il tutto, i prossimi giorni e mesi, grazie alla centralina “CONTAWATT” che “cattura” gli impulsi e restituisce un valore “fiscale” dell’energia prodotta.
Ricordo che, in teoria, le prestazioni migliori si hanno con cielo limpido, molte ore di luce e sole alto all’orizzonte (mese di Giugno), temperature basse (dopo un temporale) e buona ventilazione.
Naturalmente questa – preziosa – energia non viene sprecata: si cumula con quella dell’impianto fotovoltaico di casa: in parte viene consumata, in parte viene immessa in rete e debitamente conteggiata dal contatore bidirezionale Enel.
Qualora non si abbia lo “scambio sul posto” e si intenda fare un utilizzo continuativo del microimpianto FV, si hanno due possibilità, alternative:
1) utilizzo di una centralina per “immissioni zero” con 2 contatori digitali, uno sulla produzione e l’altro sulla linea dei consumi (vedi altri articoli sul BLOG);
2) chiedere a Enel di attivare il contatore bidirezionale per “pannelli da balcone”.
Alla prossima. PASSA PAROLA !!!
/* PROGRAMMA ARCHIMEDE 1 CONTAWATT per contatore digitale.
Versione per display 2x16 SERIALE (A4 e A5)
Allaccio contatori a A1 (Produzione Penelope)
autore SoftPlus Consumo Zero - email: [email protected]
Versione software aggiornata il 8 aprile 2023:
//
IMPORTANTE: il contatore digitale va collocato sulla linea della produzione.
//
IMPORTANTE: i sensori digitali producono degli impulsi la cui distanza, l'uno dall'altro, è inversamente proporzionale alla potenza:
ciò comporta una certa lentezza nella valutazione dei piccoli carichi,la contropartita è una misurazione "fiscale" della massima
precisione, come i contatori Enel; i sensori utilizzati (reperibili presso PARSIC ITALIA - Cervia) richiedono 3200 impulsi ora per un KWora.
//
Basetta di interfaccia, tra contatori e Arduino: 1 resistenze da 39 Kohm lato massa e 1 da 100 ohm lato 5 volt.
Relativamente al numero di impulsi, va utilizzato il software relativo, oppure modificare le istruzioni che fanno riferimento
agli impulsi.
//
*/
#include <Arduino.h> //inclusione della libreria base:
// includere altre librerie:
#include <Wire.h>
#include <LiquidCrystal_I2C_Parsic_V40.h>
// #include <LiquidCrystal_I2C.h>
// LiquidCrystal_I2C lcd(0x20, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // LCM1602 IIC A0 A1 A2:
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); //POSITIVE=accensione retroilluminazione:
// LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // indirizzo LCD Philips PCF8574AT:
// LiquidCrystal_I2C lcd(0x27,16,2);
//
int pin_consumi = A1; // pin dove arrivano gli impulsi della produzione:
int conta1 = 0;
int conta2 = 0;
unsigned long val_cons = 0;
unsigned long potenza_watt_consumi = 0; // non modificare unsigned long:
double vecchio_millis_consumi = 0;
double corrente_millis_consumi = 0;
double tempo_adesso_consumi = 0;
double vecchio_millis_minuti = 0;
double corrente_millis_minuti = 0;
double vecchio_millis_ore = 0;
double corrente_millis_ore = 0;
double vecchio_millis_giorni = 0;
double corrente_millis_giorni = 0;
unsigned long tempo_trascorso_consumi = 0; // non modificare unsigned long anzichè int:
unsigned long contawattora = 0;
int volt_partitore_consumi = 0;
unsigned long impulsi_consumi = 0;
unsigned long impulsi_consumi_nuovo = 0;
unsigned long impulsi_consumi_vecchio = 0;
unsigned long impulsi_1h = 0;
unsigned long contawatt_1h = 0;
unsigned long impulsi_24h = 0;
unsigned long contawatt_24h = 0;
unsigned long impulsi_30g = 0;
unsigned long contawatt_30g = 0;
unsigned long m1 = 0;
unsigned long m2 = 0;
unsigned long m3 = 0;
unsigned long m4 = 0;
unsigned long m5 = 0;
unsigned long m6 = 0;
unsigned long m7 = 0;
unsigned long m8 = 0;
unsigned long m9 = 0;
unsigned long m10 = 0;
unsigned long m11 = 0;
unsigned long m12 = 0;
unsigned long h1 = 0;
unsigned long h2 = 0;
unsigned long h3 = 0;
unsigned long h4 = 0;
unsigned long h5 = 0;
unsigned long h6 = 0;
unsigned long h7 = 0;
unsigned long h8 = 0;
unsigned long h9 = 0;
unsigned long h10 = 0;
unsigned long h11 = 0;
unsigned long h12 = 0;
unsigned long h13 = 0;
unsigned long h14 = 0;
unsigned long h15 = 0;
unsigned long h16 = 0;
unsigned long h17 = 0;
unsigned long h18 = 0;
unsigned long h19 = 0;
unsigned long h20 = 0;
unsigned long h21 = 0;
unsigned long h22 = 0;
unsigned long h23 = 0;
unsigned long h24 = 0;
unsigned long g1 = 0;
unsigned long g2 = 0;
unsigned long g3 = 0;
unsigned long g4 = 0;
unsigned long g5 = 0;
unsigned long g6 = 0;
unsigned long g7 = 0;
unsigned long g8 = 0;
unsigned long g9 = 0;
unsigned long g10 = 0;
unsigned long g11 = 0;
unsigned long g12 = 0;
unsigned long g13 = 0;
unsigned long g14 = 0;
unsigned long g15 = 0;
unsigned long g16 = 0;
unsigned long g17 = 0;
unsigned long g18 = 0;
unsigned long g19 = 0;
unsigned long g20 = 0;
unsigned long g21 = 0;
unsigned long g22 = 0;
unsigned long g23 = 0;
unsigned long g24 = 0;
unsigned long g25 = 0;
unsigned long g26 = 0;
unsigned long g27 = 0;
unsigned long g28 = 0;
unsigned long g29 = 0;
unsigned long g30 = 0;
//
// **********************************************************************************************************
// int impulsi_kwh = 3200; // dato da modificare in base agli impulsi del contatore:
int impulsi_kwh = 2000; // ATTENZIONE va modificata anche la riga 165:
// **********************************************************************************************************
// altre definizioni:
void setup()
{
pinMode(A2, INPUT); //pin sensore digitale consumi:
//
lcd.begin(16,2); // Inizializzo LCD 16 caratteri per 2 linee, SERIALE:
lcd.print(" SoftPlus ");
lcd.setCursor(0, 1);
lcd.print("ARCHIMEDE contaW");
delay(3000);
lcd.setCursor(0, 1);
lcd.print(" ");
lcd.setCursor(0, 1);
lcd.print("Impulsi: ");
lcd.print(impulsi_kwh);
delay(3000);
//
// lcd.begin(16,2);
//
}
//
// Inizia ciclo
void loop() {
//
// step 1 lettura dei dati digitali:
//
tempo_adesso_consumi = millis();
if (tempo_adesso_consumi > vecchio_millis_consumi + 200) // bisogna che siano passati almeno 100 millisecondi dall'ultima lettura:
// (mettere 100 per misure fino a 6 Kw e 200 per misure fino a 3 kw).
{
// legge lo stato e percepisce l'impulso sul pin deputato a rilevare i consumi:
volt_partitore_consumi = analogRead(A1);
// ************* MODIFICA IMPORTANTE ANTIDISTURBI ***************************:
// if (volt_partitore_consumi > 200) // la tensione deve essere maggiore di 1 volt:
if (volt_partitore_consumi > 600) // la tensione deve essere maggiore di 3 volt:
// ********************* FINE MODIFICA X DISTURBI ***************************:
{
corrente_millis_consumi = millis();
tempo_trascorso_consumi = corrente_millis_consumi - vecchio_millis_consumi;
vecchio_millis_consumi = corrente_millis_consumi;
// potenza_watt_consumi = 1000000 / tempo_trascorso_consumi * 36 / 32; //valido per contatore da 3200 impulsi
potenza_watt_consumi = 1000000 / tempo_trascorso_consumi * 36 / 20; //valido per contatore da 2000 impulsi
// potenza_watt_consumi = 1000000 / tempo_trascorso_consumi * 36 / 10; //valido per contatore da 1000 impulsi
val_cons = potenza_watt_consumi;
impulsi_consumi = impulsi_consumi + 1;
}
//
// step 2 aggiornamento dati:
//
corrente_millis_minuti = millis();
if (corrente_millis_minuti > vecchio_millis_minuti + 300000) // significa che sono passati 5 minuti (60.000 x 5 = 300000):
{
vecchio_millis_minuti = corrente_millis_minuti;
m12 = m11; // indicazione delle tranche di 5 minuti (ce sono 12 in un'ora):
m11 = m10;
m10 = m9;
m9 = m8;
m8 = m7;
m7 = m6;
m6 = m5;
m5 = m4;
m4 = m3;
m3 = m2;
m2 = m1;
impulsi_consumi_nuovo = impulsi_consumi;
m1 = impulsi_consumi_nuovo - impulsi_consumi_vecchio;
impulsi_consumi_vecchio = impulsi_consumi_nuovo;
impulsi_1h = m1 + m2 + m3 + m4 + m5 + m6 + m7 + m8 + m9 + m10 + m11 + m12;
//
corrente_millis_ore = millis();
if (corrente_millis_ore > vecchio_millis_ore + 3600000) // 3,6 milioni, cioè un'ora (60.000 x 60 = 3600000):
{
vecchio_millis_ore = corrente_millis_ore;
h24 = h23;
h23 = h22;
h22 = h21;
h21 = h20;
h20 = h19;
h19 = h18;
h18 = h17;
h17 = h16;
h16 = h15;
h15 = h14;
h14 = h13;
h13 = h12;
h12 = h11;
h11 = h10;
h10 = h9;
h9 = h8;
h8 = h7;
h7 = h6;
h6 = h5;
h5 = h4;
h4 = h3;
h3 = h2;
h2 = h1;
h1 = impulsi_1h;
impulsi_24h = h1 + h2 + h3 + h4 + h5 + h6 + h7 + h8 + h9 + h10 + h11 + h12 + h13;
impulsi_24h = impulsi_24h + h14 + h15 + h16 + h17 + h18 + h19 + h20 + h21 + h22 + h23 + h24;
//
corrente_millis_giorni = millis();
if (corrente_millis_giorni > vecchio_millis_giorni + 86400000) // 24 ore (3,6 milioni x 24 = 86400000):
{
vecchio_millis_giorni = corrente_millis_giorni;
g30 = g29;
g29 = g28;
g28 = g27;
g27 = g26;
g26 = g25;
g25 = g24;
g24 = g23;
g23 = g22;
g22 = g21;
g21 = g20;
g20 = g19;
g19 = g18;
g18 = g17;
g17 = g16;
g16 = g15;
g15 = g14;
g14 = g13;
g13 = g12;
g12 = g11;
g11 = g10;
g10 = g9;
g9 = g8;
g8 = g7;
g7 = g6;
g6 = g5;
g5 = g4;
g4 = g3;
g3 = g2;
g2 = g1;
g1 = impulsi_24h;
impulsi_30g = g1+g2+g3+g4+g5+g6+g7+g8+g9+g10+g11+g12+g13+g14+g15+g16+g17;
impulsi_30g = impulsi_30g+g18+g19+g20+g21+g22+g23+g24+g25+g26+g27+g28+g29+g30;
}
//
}
//
}
//
}
//
// step 3 visualizzazione dati:
if (conta1 == 15000)
{
// contawatt = impulsi_consumi/3200; // perchè abbiamo 3200 impulsi per Kwh:
contawattora = impulsi_consumi/ (impulsi_kwh / 100); // abbiamo i Kwh con 2 decimali:
//
lcd.setCursor(0, 0);
lcd.print("W_FV Kwh_Produzi");
lcd.setCursor(0, 1);
lcd.print(" ");
lcd.setCursor(1, 1);
lcd.print(val_cons);
lcd.setCursor(11, 1); //
lcd.print("0,00");
if (contawattora < 10)
{
lcd.setCursor(14, 1);
lcd.print(contawattora);
}
if (contawattora > 9 && contawattora < 100)
{
lcd.setCursor(13, 1);
lcd.print(contawattora);
}
if (contawattora > 99 && contawattora < 999)
{
lcd.setCursor(12, 1);
lcd.print(contawattora);
lcd.setCursor(12, 1);
lcd.print(",");
lcd.setCursor(11, 1);
lcd.print(contawattora / 100);
}
if (contawattora > 999 && contawattora < 9999)
{
lcd.setCursor(11, 1);
lcd.print(contawattora);
lcd.setCursor(12, 1);
lcd.print(",");
lcd.setCursor(10, 1);
lcd.print(contawattora / 100);
}
if (contawattora > 9999 && contawattora < 99999)
{
lcd.setCursor(10, 1);
lcd.print(contawattora);
lcd.setCursor(12, 1);
lcd.print(",");
lcd.setCursor(9, 1);
lcd.print(contawattora / 100);
}
//
}
if (conta1 == 25000)
{
contawatt_1h = impulsi_1h*1000/impulsi_kwh; // perchè abbiamo 3200 impulsi per Kwh:
contawatt_24h = impulsi_24h*1000/impulsi_kwh;
contawatt_30g = impulsi_30g/impulsi_kwh; // è espresso in Kwh;
//
lcd.setCursor(0, 0);
lcd.print("Wh_1h 24h 30ggKw");
lcd.setCursor(0, 1);
lcd.print(" ");
lcd.setCursor(0, 1);
lcd.print(contawatt_1h);
lcd.setCursor(5, 1);
lcd.print(contawatt_24h);
lcd.setCursor(12, 1);
lcd.print(contawatt_30g);
conta2 = 0;
conta1 = 0;
}
//
conta1 = conta1 + 1;
//
}
// FINE listato by SoftPlus Consumo Zero - Faenza.