SCT-013-030 (020) per rilevare troppa corrente
Elevata corrente assorbita dalla casa con Arduino e SCT-013-020 / SCT-013-030
Questa pagina descrive un sistema hardware (Arduino + sensore sct-013-030) e software capace di rilevare la corrente transitante in un cavo allo scopo di stabilire se in casa abbiamo acceso troppi elettrodomestici e quindi rischiamo di far scattare il contatore.
Lo scopo del programma è quello fornire un valore, contenuto in una variabile, da usare per accendere un relè, o emettere segnali sonori, quando si accendono contemporaneamente due carichi elettrici ad alto assorbimento di corrente quali forno, phon, lavatrici, lavastoviglie il cui assorbimento è intorno ai 2000W.
Tale valore è utile al fine di evitare il distacco del contatore elettrico per troppa potenza assorbita.
Viste le email di informazioni ricevute, preciso fin da subito che questo progettino non misura la corrrente assorbita ma sfrutta il rapporto di consumo tra piccoli (consumo di circa 100W) e grandi elettromestici (superiore ai 1000W) per determinare quando sono accesi contemporaneamente almeno due di quest’ultimi. In questo modo il circuito e il programma sono molto semplificati.
E’ molto economico perché utilizza solo un sensore non invasivo da pochi euro (SCT-013-020 o SCT-013-030) per rilevare la corrente transitante sulla linea principale dell’alimentazione elettrica. Tuttavia dato che il contatore decide quando staccare la corrente basandosi sulla potenza reale assorbita, mentre il sensore sct-013-030 rivela solo la corrente, diventa necessario precisare che esistono condizioni (poco frequenti) nel quale questo sistema non riesce ad assolvere il suo compito. Tuttavia per un numero di apparati elettrici limitato, come quelli che normalmente si possono trovare in casa, si rivela funzionante ed affidabile.
Questo perché il suo funzionamento dipende da quanti apparati di tipo switching o induttivi (lampadine elettroniche, notebook, PC, TV..) avete. Questi apparati sfasano la tensione e la corrente di un certo angolo e più l’angolo è ampio e più aumenta l’errore di questo sistema. Più che l’angolo si usa direttamente il termine cos(angolo). Sui libretti di istruzione delle apparecchiature è possibile trovarlo con il termine cosphi, cos(phi) o “Fattore di potenza”). Per apparecchiature che non sfasano la corrente (resistenze) il cosphi è 1 il massimo. Nelle peggiori apparecchiature, tra cui alcune lampadine elettroniche a risparmio energetico, tale cosphi può scendere a valori molto bassi.
Per comprendere utilizziamo la figura a destra in cui rappresentiamo un caso limite:
I due vettori (frecce rosse) rappresentano la potenza apparente e sono identici in lunghezza. Ma il loro orientamento produce due proiezioni diverse lungo l’asse x (potenza reale). Il contatore elettrico scatta quando questa proiezione supera un determinato valore ( esempio 3000 Watt). Così graficamente è facile notare che il contatore scatta solo per il vettore più basso.
Il difetto del sistema è proprio questo. E’ sensibile solo per la lunghezza del vettore (3300VA) e quindi non sa se il contatore sta per scattare perché, non ha modo di calcolare la proiezione del vettore lungo l’asse x.
Tuttavia il caso illustrato è un caso limite.
Nelle abitazioni domestiche la maggior parte dei grossi carichi elettrici sono resistenze che non sfasano la corrente e pertanto il loro vettore è lungo l’asse x (nella figura sotto il vettore verde che 
rappresenta 2000W). Gli altri carichi switching o induttivi, sommati insieme sono rappresentati dal vettore celeste (nella figura sotto a sinistra 1200VA a 45°). Già con questa situazione la differenza tra la potenza apparente 2972VA e la potenza reale 2848W e poco meno di 150W.
Diverso è il caso nella parte a destra, in cui si ipotizza che i carichi switching hanno come vettore 1880VA a 62°. In questa situazione l’errore è maggiore. Anche se in entrambi i casi la proiezione del vettore lungo l’asse x è all’incirca uguale sui 2845 Watt, il che significa che essendo sotto ai 3Kw il contatore non scatta, il programma rileva valori di potenza apparente (vettori blu) molto differenti 2972 contro 3258. Un errore talmente ampio che sembra vanificare questo programma.
Invece lo scopo del programma non è quello di avere una misura precisa della potenza, ma bensì di determinare quando due elettrodomestici da 2000W sono accesi insieme. Per questo fine è utile la considerazione che, normalmente, accendere insieme un elettrodomestico da 2000W e tutti gli altri carichi minori (lampadine televisori ecc.), non fa scattare il contatore. Mentre, due elettrodomestici da 2000W insieme, invece si. Diventa quindi possibile scegliere una soglia opportuna per far funzionare il programma procedendo così:
Collegate un Arduino come nello schema (a fondo pagina) al sensore sct-013-030 e caricate il programma. Rilevate il valore più piccolo che il programma fornisce alla accensione di diverse combinazioni di due di questi elettrodomestici da circa 2000W per volta. (Attenzione accendeteli insieme per pochi secondi altrimenti il contatore può scattare. Per carichi da 2000W si intente i carichi più grossi disponibili nelle case, dal più piccolo ferro da stiro da 1200W in su). Questo valore così ricavato lo chiamiamo MAX (indicato così nelle figure precedenti).
Accendete ora questi elettrodomestici uno per volta e determinate quello che vi da il valore maggiore. Una volta trovato, lasciatelo acceso e ignorate tutti gli altri elettrodomestici ad alto assorbimento ma accendete ogni altra cosa collegata all’impianto elettrico (lampadine, televisori, luci, PC notebook). Il valore che alla fine avrete chiamatelo MIN.
Se MAX e’ maggiore di MIN il sistema vi funzionerà e la soglia di discriminazione del programma deve essere impostata ad un valore intermedio tra i due valori.
Da prove effettuate in una casa è risultato che il programma mi ha dato il valore 125 (MAX) a fronte dell’assorbimento prodotto da forno e Phon. Accendendo Forno e tutte le luci e apparati switching, ho ottenuto 100 (MIN). Da considerare che ho acceso tutto quello che ho, ovvero tutte le TV, 28 lampadine a risparmio energetico e anche riesumato vecchi PC obsoleti. In teoria, senza il carico da 2000W, dovrei aver raggiunto 950W e in una situazione che normalmente non raggiungerò mai. Quindi scegliendo come valore di soglia 110 sono sicuro di superarla solo quando accenderò due elettrodomestici da 2000W insieme.
Invece se MAX è minore di MIN allora il sistema qui descritto non è adatto per la vostra casa. E’ possibile che abbiate molte lampadine a risparmio energetico, tanti pc e notebook, molti televisori e/o piastre ad induzione. Se tutto questo è distribuito su una casa enorme le soluzioni per non avere false segnalazioni possono essere le seguenti: 1) rifasare l’impianto, 2) accettare false segnalazioni (curioso. ma d’altronde se avete una casa enorme sarà difficile che accendiate tutte le luci contemporaneamente). Soluzione alternativa potrebbe essere quella di suddividere l’impianto elettrico in zone servite da più sensori come questo e quindi gestirli via software. Ma ciò non avrebbe più senso perché il costo per farlo non giustifica più l’adozione di questa piccola soluzione.
Vediamo qualche caratteristica del programma.
Onda mediata
Il programma legge la tensione rilevata dal sensore sct-013-030 tramite il pin analogico dell’Arduino. Da alcune rilevazioni reali ho notato che la rappresentazione di questa onda rilevata dal sensore è disseminata di spikes (valori spuri sull’onda che si presentano come dei picchi di ampiezza e posizione casuale). Per contenerli, il programma non considera direttamente l’onda, ma la sua mediazione a 5 valori. (Sotto una reale onda con spike e in rosso la sua mediazione a 5 valori).
Calcolo del valore di riferimento a zero volt
Appena acceso, l’Arduino tramite il sensore sct-013-030 legge alcuni cicli sinusoidali per identificare il valore che l’input analogico della scheda Arduino rileva sullo zero volt dell’onda sinusoidale. Da queste letture determina il picco massimo e minimo dell’onda che mediati insieme forniscono il valore medio assunto come 0 Volt. Ho preferito calcolare ogni volta lo zero volt perché il pin analogico è mantenuto a 2,5V da un partitore resistivo che difficilmente ha le resistenze uguali o le mantiene tali negli anni (fenomeno noto come deriva dei componenti). Ne consegue che il valore di riferimento potrebbe essere diverso da 2,5V e cambiare nel tempo. Tuttavia ricalcolandolo sempre il giusto valore per lo zero volt ad ogni accensione della scheda Arduino eviteremo di dover tarare periodicamente il circuito. Lo zero volt è importante perché da lui dipende il risultato. Lo si può vedere nella figura seguente dove le aree delle semionde cambiano al variare del riferimento a zero volt. (nella figura il valore dell’area celeste è diverso da quella rosso per il semplice fatto che l’area rossa prende il riferimento a zero volt più basso.)
Output del programma
Il programma fornisce una indicazione numerica che cresce con la corrente al solo scopo di avere un valore di soglia per staccare un relè o, come nel mio caso segnalare con messaggi vocali che è bene disattivare qualche apparato. L’indicazione numerica non rappresenta né una potenza e né una corrente. E’ solo un numero che cresce al crescere della corrente. La scelta di non misurare la potenza deriva principalmente dal fatto che il programma è pensato per essere inserito come routine in un programma più complesso. Pertanto deve avere la caratteristica di non richiedere troppa potenza di calcolo e di utilizzare la minor memoria possibile. Altri fattori che hanno influito sulla scelta, il costo totale (il sensore costa 6 euro).
Metodo di Calcolo
Il programma fornisce la sua indicazione numerica calcolando la media aritmetica di ripetute letture sul periodo dell’onda sinusoidale (assumendo le semionde negative come positive). In pratica, salvo utilizzare la media geometrica anziché quadratica, è lo stesso algoritmo (un ciclo ripetuto) che si utilizza per calcolare la corrente efficace.
Nella realizzazione dello sketch, ho scelto di utilizzare la media aritmetica perché ipotizzavo che, per la scheda Arduino, questa sarebbe stata molto più veloce da calcolare (In seguito ho constatato che non ci sono differenze significative tra i tempi di calcolo delle due medie). Inoltre, la differenza tra le due medie consiste solo in una compressione dei risultati che non influisce sullo scopo del progetto che, quindi, funziona indipendentemente dalla media utilizzata.
Il programma tramite un ciclo While si assicura di effettuare un congruo numero di letture. Scarta i primi valori fintantoché l’onda non passa per il valore relativo allo zero volt e quindi comincia a trattare i valori fino a che, dopo aver letto diversi periodi l’onda non ripassa per lo 0V. In altre parole il programma legge periodi completi e su questi effettua i suoi calcoli per determinarne l’area.
Onde rilevate dal sensore SCT-013-020 sotto diverse combinazioni di carichi elettrici.
L’area e non il picco dell’onda perché da qualche prova ho notato che aumentando il carico elettrico, il picco-picco dell’onda non aumenta più di tanto, mentre, invece l’onda diventa più larga (ovvero aumenta l’area dell’onda). In figura l’onda verde-acqua (l’onda più alta) in confronto con l’onda grigia). In altri casi, l’onda si divide in due picchi; onda verde scuro).
La figura mostra onde rilevate dal sensore SCT-013-30 (o SCT-013-20) con diversi carichi elettrici. All’inizio dell’asse x una breve linea orizzontale continua esprime la media geometrica dell’onda dal colore corrispondente. Linea che, dopo un fronte di salita, continua con un ulteriore tratto orizzontale che rappresenta la media quadratica. Questa rappresentazione esprime visivamente la differenza tra le due medie. Salta all’occhio che la media quadratica ha valori espansi lungo l’asse y. Tuttavia allo scopo prefissato dal programma, utilizzare l’una o l’altra media è equivalente. Con entrambe le medie esiste un valore di soglia, diverso a secondo della media utilizzata e tale che il comportamento del sistema rimane identico.
Schema elettrico circuito per collegare l’Arduino con il sensore SCT-013-020 o SCT-013-030
Circuito per collegare il sensore_SCT-013-020 o SCT-013-030 agli ingressi analogici della scheda Arduino
Il Sensore SCT-013-30
Il circuito di collegamento al sensore sct-013-030
Video:
Il programma per leggere la corrente dal sensore non invasivo SCT 013 020 (o SCT 013 030)
//** ********************************************************************* **//
//** **//
//** AlertHighPower **//
//** **//
//** Rilevatore di troppa corrente per sensore SCT-013-020 o SCT-013-030 **//
//** **//
//** ********************************************************************* **//
//** Lo scopo del programma è quello fornire un valore, contenuto in una **//
//** variabile, da usare per accendere un relè o emettere segnali sonori **//
//** quando in una casa si accendono contemporaneamente due grossi carichi **//
//** elettrici (forno, phon, lavatrici, lavastoviglie ecc.; in generale **//
//** quelli superiori a 1500W). **//
//** **//
//** E’ un programma utile al fine di evitare il distacco del contatore **//
//** elettrico per troppa potenza assorbita. **//
//** **//
//** Tuttavia il programma funziona a condizione che l’ assorbimento del **//
//** maggiore carico elettrico, acceso insieme a tutti gli altri carichi **//
//** inferiori (tv, lampadine, computer ecc.) non sia tale da far scattare **//
//** il contatore. Una condizione rispettata in quasi tutte le case **//
//** medio-piccole. **//
//** **//
//** Per la prima impostazione: **//
//** Lanciate il programma. Rilevate il valore (max) dato dall’assorbimen- **//
//** to di due grossi carichi. Rilevate il valore (min) dato dal più gros- **//
//** so carico che avete acceso insieme con tutti i carichi minori. Assu- **//
//** mete la media tra questi due valori come valore di soglia ed **//
//** impostatelo nell’ ultimo IF del programma (…if somma >110… ) al **//
//** posto del numero 110. **//
//** **//
//** **//
//** Maggiori informazioni in myelectronichome.altervista.org. **//
//** **//
//** Scritto da Corrado Bevilacqua nei ritagli di tempo. **//
//** Iniziato il 23/09/2013. Software e debug completato il 31/12/2013. **//
//** Versione che non memorizza in un vettore i singoli valori dell’ onda **//
//** per risparmiare memoria. **//
//** Lavora sulla media delle ultime 5 letture per contenere la presenza **//
//** di impulsi spuri “spike” sull’onda sinosuidale rilevata. **//
//** **//
//** Software liberamente copiabile a patto morale di citare l’autore nei **//
//** commenti del vostro programma. **//
//** ********************************************************************* **//
//** Written by Corrado Bevilacqua (C) – myelectronichome.altervista.org **//
//** ********************************************************************* **//
//** ********************************************************************* **//
//** Variabili per il sensore di corrente **//
//** ********************************************************************* **//
int valmedio[5];
int analogPin = 1; //pin da collegare al rilevatore di corrente SCT 013 020
int zerovolt=0;
long Quantacorrenteoldtempo=0; //per evitare che controlli la corrente di continuo
void setup()
{
Serial.begin(19200);
Serial.println(“Sketch: AlertHighPower”);
delay(500);
//** **************************************************************** **//
//** Per il sensore di corrente – Rileva lo zerovolt **//
//** **************************************************************** **//
ZeroVolt(); //** **//
//** **************************************************************** **//
} // end setup
void loop()
{
//controlla la corrente
QuantaCorrente();
} //end loop
void ZeroVolt()
{
//** **************************************************************** **//
//** Determino il valore da 2,5V a cui è collegato il sensore **//
//** SCT 013-020. Lo calcolo ogni volta all’accensione dell’Arduino **//
//** per evitare la deriva dei componenti. **// **
//** **************************************************************** **//
int max2 =0;
int min2 =9999;
valmedio[0]=analogRead(analogPin);
valmedio[1]=analogRead(analogPin);
valmedio[2]=analogRead(analogPin);
valmedio[3]=analogRead(analogPin);
valmedio[4]=analogRead(analogPin);
int punta=0;
int mediato=0;
long oldtime1;
oldtime1=millis();
while (millis()-oldtime1<=85)
{
valmedio[punta]=analogRead(analogPin);
if (punta<4)
{punta=punta+1;}
else
{punta=0;}
mediato=(valmedio[0]+valmedio[1]+valmedio[2]+valmedio[3]+valmedio[4])/5;
if (max2<mediato)
{max2=mediato;}
if (min2>mediato)
{min2=mediato;}
}
zerovolt = (max2+min2)/2;
Serial.print(“zerovolt = ” );
Serial.println(zerovolt);
} //end zerovolt
int QuantaCorrente()
{
if (abs(millis()-Quantacorrenteoldtempo) >= 10000) //entra nel ciclo solo ogni dieci secondi
{
long somma=0;
long conta=0;
int punta=0;
int mediato=0;
int i=0;
int PerZeroOk=0;
int tante = 10; //indica quante mezze onde leggere. Con 10 semionde (5 periodi) ci mette 100ms
//leggi valori per costruire la prima media
valmedio[0]=analogRead(analogPin);
valmedio[1]=analogRead(analogPin);
valmedio[2]=analogRead(analogPin);
valmedio[3]=analogRead(analogPin);
valmedio[4]=analogRead(analogPin);
mediato=(valmedio[0]+valmedio[1]+valmedio[2]+valmedio[3]+valmedio[4])/5;
boolean onda=0;
if (mediato-zerovolt>0 ) //Se maggiore di uno allora per onda metto 1 altrimenti zero, Dice se l’onda è sopra o sotto lo zero
{onda=1;}
long TempoStart; //variabile per calcolare quanto tempo ci mette
TempoStart=millis();
while (PerZeroOk<=tante && abs(millis()-TempoStart) < (tante+4)*20)
{
//Mediamo i valori letti per contenere gli spikes
valmedio[punta]=analogRead(analogPin);
if (punta<4)
{punta=punta+1;}
else
{punta=0;}
mediato=(valmedio[0]+valmedio[1]+valmedio[2]+valmedio[3]+valmedio[4])/5;
mediato=mediato-zerovolt;
// L’IF seguente Rileva il passaggio per zero e conseguentemente riesce a contare le semionde.
// Tuttavia per bassi assorbimenti di corrente non riesce a contarle bene e quindi fornisce un
// valore più basso di quello dovuto. E’ un problema che si presenta solo per basse correnti
// e quindi non inficia il funzionamento del programma perchè lavora sulla fascia dei forti
// assorbimenti di corrente.
if ((onda==1 && mediato <0) || (onda==0 && mediato >0))
{
PerZeroOk=PerZeroOk+1;
onda=onda^B1; //Cambia lo stato da 0 a 1 e viceversa
}
//In PerZeroOK=0 siamo in un punto a caso della prima semionda per cui ignoriamone i valori. Dobbiamo prendere sempre semionde intere.
if (PerZeroOk>=1)
{
somma=somma+abs(mediato);
conta=conta+1;
}
}
TempoStart=millis()-TempoStart;
somma=somma/conta;
Serial.print(“Indicatore=”);
Serial.print(somma);
Serial.print(” TempoElaborazione=”);
Serial.print(TempoStart);
Serial.print(” conta=”);
Serial.print(conta);
Serial.print(” Semionde=”);
Serial.println(tante);
if (somma >110 ) //se il valore supera la soglia, qui impostata a 110, allora segnala il troppo assorbimento di corrente.
{
Serial.print(“***************”);
Serial.print(“Troppa corrente”);
Serial.print(“***************”);
}
Quantacorrenteoldtempo=millis();
}
} //end QuantaCorrente
L’intero programma (sketch) è scaricabile dal seguente link: