Arduino per il monitoraggio del consumo energetico – parte 4 – it

A quanto pare il monitoraggio energetico interessa a molti a giudicare dalle richieste di aiuto che ho ricevuto. Sinora abbiamo visto come utilizzare le pinze amperometriche per monitorizzare il consumo energetico in maniera non invasiva sia con Arduino UNO che DUE, ma ci siamo sempre limitati ad una piccola grande approssimazione, ossia abbiamo valutato la corrente assorbita senza tenere conto della tensione reale istantanea, sinora approssimata a 220-230V. Oggi infrangiamo questo ultimo ostacolo e andiamo a vedere come calcolare la tensione di rete.

Il trasformatore

Ovviamente Arduino, indipendentemente da quale abbiamo, non è in grado di leggere direttamente la tensione a 230V, infatti a seconda delle versioni a nostra disposizione, saremo in grado di leggere tensioni da 0 a 3.3 o 5V. Quindi il nostro scopo è trasformare una tensione alternata 230V in una nuova tensione alternata in grado di soddisfare il range di lettura della nostra scheda. Il dispositivo in grado di fare ciò è il classico trasformatore. Probabilmente tutti i lettori di questo blog sanno e ricordano cos’è un trasformatore, basti comunque ricordare che è formato da un nucleo di materiale ferroso attorno a cui sono disposti due avvolgimenti di rame il cui rapporto di spire fra questi due avvolgimenti determina il fattore di trasformazione. Giusto per capirci, se all’avvolgimento primario dove arriva la 230V ci fossero 100 spire e al secondario ci fossero 15spire, essendo 100/15=6.67 avremmo che la tensione in uscita sarà di 230/6.67=34V. La scelta del trasformatore non è molto vincolante ma è importante prestare attenzione senza fidarci troppo di quanto riportato sulle etichette. Ad esempio, io ho testato un vecchio trasformatore che sull’etichetta riporta “220-9V”. Tanto per cominciare la tensione di rete in tutta Europa dovrebbe essere di 230V per cui l’uscita già di per se dovrebbe diventare 9.4V (essendo 230V e non 220V). Ma facendo una misurazione “a vuoto”, ossia senza alcun carico collegato al trasformatore, scopriamo che la tensione in uscita è di 11.5V. Perché? Questo è dovuto al fatto che le perdite del trasformatore aumentano con l’aumentare della corrente che transita per cui per riuscire a garantire la tensione di 9V al massimo carico di progettazione, ci sarà inevitabilmente una tensione più alta “a vuoto”. Allora come calcoliamo la “vera” tensione. Ve lo dico subito, se non è di buona qualità lasciate perdere il multimetro, non accontentatevi, il mio, giusto per fare un esempio a 237V mi fornisce una letture di 224V, e 11.3V anziché 12.05V : insomma non fidatevi troppo se non avete un buono strumento di misura.

Per misurare la tensione reale in uscita dal nostro alimentatore abbiamo due modi. Uno del tutto empirico, ossia incrementiamo del 20% la tensione di uscita indicata sulla targhetta del trasformatore (sempre che ci sia). Nel nostro caso 9.4+20%=10.2V, inferiore però al dato reale di 11.5V, motivo per cui vi sconsiglio questa pratica anche se in rete troverete anche voi questo consiglio. Il secondo metodo, più preciso, prevede l’uso di un multimetro, quello che vi avevo appena detto di lasciar perdere; vediamo perché. Misurate la tensione in ingresso e quella in uscita e semplicemente calcolate il rapporto fra le due. Nel mio caso, giusto per fare un paio di esempi, misuravo  227 / 11.3 e in un tempo successivo 224 / 11.2 con un rapporto di 20. Anche se il vostro multimetro, è di scarsa qualità, l’errore sulle due misure sarà similare per cui il rapporto fra le due sarà realistico. Nel mio caso facendo 230/20 ottengo 11.5V che è appunto la mia tensione in uscita senza carico.

Tensione di picco

Quello che noi interessa realmente è la tensione di picco che può raggiungere Arduino in quanto non deve oltrepassare la soglia dei 5V su Arduino UNO e di 3.3V su Arduino DUE, anche se sarebbe più corretto dire “la tensione AREF” che non è detto ricalchi esattamente la tensione ideale di alimentazione. Ma fate molta attenzione. Le tensioni alternate di cui abbiamo parlato sinora, sono tensioni RMS (Root Mean Square), per trovare il picco dobbiamo moltiplicare il tutto per la radice di 2 (circa 1.41) per cui la nostra tensione massima in uscita passerebbe da 11.5 a 16.2. Allora ci siamo? NO! Sinora abbiamo fatto i calcoli come se la tensione di ingresso fosse fissa a 230V, cosa che ovviamente non è, altrimenti che senso avrebbe misurarla? Quindi dobbiamo conoscere la variabilità di ingresso della tensione che deve essere al massimo del 10%, ciò significa che i valori RMS massimi e minimi della tensione di rete in Italia sono di 207-253V. Anche se potremmo rifare i calcoli da zero partendo dai 253V, possiamo accontentarci di aggiungere il 10% al valore prima calcolato e, arrotondando, arriviamo a 18V. Quindi fate attenzione, come vedete siamo partiti da un alimentatore in cui era scritto 9V e siamo arrivati a calcolare un picco di 18V, ossia il doppio.

Questione di onde

No, mi dispiace, quanto visto non basta ancora. Abbiamo calcolato un’onda massima in uscita con picco di 18V, però ci siamo scordati che la semionda negativa arriverà a -18, cosa incompatibile con Arduino che non tollera valori inferiori allo zero. Quindi cosa fare? Dobbiamo innanzitutto innalzare la tensione base allo stesso modo di quanto visto con la pinza amperometrica per cui con un partitore di tensione simmetrico portiamo la 5V o la 3.3V rispettivamente a 2.5 o 1.65V. La seconda cosa da fare sarà quella di “comprimere” l’onda in uscita per impedire che sfori il tetto massimo verso l’alto o scenda sotto lo zero verso il basso. Per fare ciò dobbiamo usare un partitore asimmetrico. Potete usare la mia app per dimensionarlo correttamente, ma nulla vi vieta di fare i calcoli manualmente o ricorrere ad altri tools. Tenete presente che è fortemente consigliato “comprimere” l’onda lasciando un margine libero, ossia non arrivare ad un massimo teorico esattamente di 5V o 3.3V. Questo per diversi motivi: da un lato non possiamo escludere che ci siano delle sovratensioni che superano il 10% (temporali?), in secondo luogo i resistori hanno una certa tolleranza per cui il calcolo non sarà mai così preciso come ce lo aspettiamo e per finire non è detto che i 5V e 3.3V siano tali, nel senso che il valore di riferimento è AREF che dipende dall’alimentazione che a sua volta non è detto essere perfetta. In definitiva meglio sacrificare una parte della scala e ridurre la precisione di misura che rischiare di bruciare Arduino.

Riassumiamo

Per semplificarvi la vita ho provveduto a riassumere quanto detto sopra in alcune semplici formule da applicare allo schema che vi propongo qui vicino. Lo schema è quasi del tutto sovrapponibile a quello visto con la pinza amperometrica, l’unica differenza è che al posto della pinza abbiamo il trasformatore e cambiano i valori del partitore R1-R2. Per il partitore R3-R4 vale la regola che i resistori devono essere identici, ricordate che se di valore più elevato riducono il consumo del circuito.

M=Vcc/2 (Vcc è la tensione di funzionamento di Arduino, 5 o 3.3V)

P=(Sec*sqr(2)) + 10%. Ossia il valore rms in uscita dal trasformatore, moltiplicato per la radice di due e a cui alla fine aggiungiamo il 10%. Questo è il valore di picco massimo atteso.

A partire da questi possiamo calcolare a nostra scelta R1 o R2. Fissiamo uno dei due valori a nostro piacimento e calcoliamo il secondo

R1=R2*((P-M)/M)) e R2=R1*(M/(P-M))

Il primo prototipo l’ho testato con Arduino DUE che sappiamo operare a 3.3V, ma nelle formule anziché i 3.3V ho usato 3V (quindi M=1.5) per avere un margine di protezione sugli ingressi di Arduino, infatti se osservate lo schema, non c’è nulla che protegga gli ingressi di Arduino da una sovratensione. Così facendo ho usato 110K per R1 e 10K per R2. Bene ora che abbiamo tutte le informazioni necessarie per dimensionare il sistema dobbiamo passare alla parte software e qui un pizzico di teoria ci sarà d’aiuto

Potenza apparente e attiva

Ricordate che ho sempre detto che sinora abbiamo utilizzato la pinza amperometrica con due semplificazioni di base? La prima riguardava il fatto che la tensione fosse fissa a 230V e l’altra che il carico misurato fosse puramente resistivo, quindi privo di tutte le componenti induttive e capacitive che i comuni apparecchi elettronici hanno. Tutto ciò può portare ad un errore che è tanto più marcato quanto più ci scostiamo da questi parametri ideali. Abbiamo detto che la classica lampadina ad incandescenza è un carico puramente resistivo e non per nulla abbiamo usato questo strumento per calibrare il nostro sistema. In queste condizioni infatti tensione e corrente sono perfettamente in fase, per cui la potenza è data dalla moltiplicazione dei due, ossia P=V*I. Questa è la potenza apparente e si misura in VA (Volt Ampere). Con un carico puramente resistivo questa corrisponde alla potenza reale (potenza attiva), ma ciò è dato solamente dal caso particolare che stiamo analizzando, infatti l’introduzione di carichi induttivi e capacitivi provoca uno sfasamento fra le due onde calcolabile con un “angolo di sfasamento”, e guarda caso la potenza attiva si calcola con P=V*I*cos(φ). Se l’angolo di sfasamento è nullo, il coseno vale uno e come si suol dire “il cerchio si chiude”.

Come calcoliamo l’angolo di sfasamento? Beh direte, basta che valutiamo dove si trovano i picchi o il passaggio per lo zero delle due onde e da li riusciamo a calcolare l’angolo di sfasamento. Verissimo, ma questo assunto prevede che le onde di corrente e tensione siano delle sinusoidi perfette, cosa che nella realtà non accade, anzi, spesso le forme d’onda presentano morfologie bizzarre e distorte che sono tutto tranne che delle sinusoidi ideali. Quindi? In realtà è molto più semplice di quanto sembri. Cominciamo a campionare le due onde e punto per punto moltiplichiamo il valore di corrente per quello di tensione, in questo modo otteniamo la potenza istantanea punto per punto. Facendo la media dei campionamenti lungo l’intera onda otteniamo la potenza attiva (che si misura in W). In modo similare è possibile calcolare la potenza RMS. In questo caso facciamo la somma dei quadrati sia della tensione che del voltaggio, senza moltiplicarli fra loro, cosa che annulla l’effetto dell’angolo di sfasamento. Una volta calcolata la somma totale dividiamo per il numero di campionamenti sia della tensione che della corrente e mettiamo i relativi risultati sotto radice. Una volta ottenuti i valori RMS di tensione e corrente li moltiplichiamo fra loro ed otteniamo la potenza apparente che come dicevamo non è influenzata dall’angolo di sfasamento, ossia è quella che calcolavamo quando semplificavamo il sistema prevedendo un angolo di sfasamento nullo.

Qui sotto vi riporto un grafico che mostra in arancio l’ondulazione proveniente dall’alimentatore e in blu la lettura della pinza amperometrica con un carico resistivo di 100W applicato. Si nota che con questo carico il segnale è molto debole, ma dopotutto la pinza in mio possesso è il modello da 30A in grado di misurare carichi di quasi 7kW. Ciò nonostante l’errore di misura sui 100W si attesta ad un massimo del 3% e ripeto la parola massimo visto che in gran parte delle misure l’errore si è dimostrato intorno l’1% anche se devo ammettere che questo risultato l’ho ottenuto applicando un algoritmo di denoising che però non tratteremo in quanto aumenterebbe troppo la complessità del nostro articolo.

Visto così il segnale pare molto pulito, la realtà è invece un po’ diversa. Nel prossimo grafico vi mostro in dettaglio il segnale della pinza amperometrica senza carico, che di fatto dovrebbe corrispondere alla tensione in uscita dal partitore di tensione applicato alla 3.3V (su Arduino DUE). Come potete vedere senza algoritmi di denoising c’è parecchio rumore di fondo per cui la misura diventa particolarmente imprecisa per piccoli carichi, è anche vero che se a qualcuno interessa misurare carichi più piccoli può incrementare il numero di avvolgimenti del cavo in ingresso sulla pinza o utilizzare una pinza amperometrica progettata per carichi inferiori.

Con Arduino UNO invece la minor risoluzione del convertitore ADC fa si che anche la soglia di percezione del rumore sia inferiore per cui lo stesso grafico diventerebbe:

rumore che si attenua notevolmente utilizzando la tecnica di oversampling che vi ho spiegato in un precedente articolo, nel grafico qui sotto vediamo l’oversampling a 11 bit su Arduino UNO.

Qui sotto invece vi riporto il grafico con la lettura dell’alimentatore e della pinza amperometrica, sempre con carico resistivo di 100W, ma con ArduinoUNO e oversampling del segnale a 11bit.

Tra le altre le prove con Arduino UNO le ho fatto semplicemente spostando i cavi di alimentazione, massa e letture analogiche dalla DUE alla UNO, non ho perciò modificato i resistori del partitore presenti sul trasformatore, cosa che mi permetterebbe di aumentare la gamma della lettura con maggior precisione della stessa.

Lo schema

Di fatto si tratta più di una ripetizione più che di cose nuove, ma qui metto tutto insieme per cui è più facile seguire lo schema se dovete cominciare da zero. Ci tengo a sottolineare che ci sono alcuni miglioramenti da poter fare, questo circuito è da considerarsi perfettamente funzionante ma perfettibile, giusto per ribadire la cosa non ci sono protezioni che salvino Arduino in caso di sovratensioni sia positive che negative al di fuori dei limiti teorici previsti.

Il circuito è formato da un partitore R3-R4 dal quale fuoriesce la tensione di alimentazione di Arduino dimezzata e che appunto usiamo come riferimento “zero” per le letture sia dal trasformatore che dalla pinza amperometrica. Il trasformatore usa un secondo partitore che permette, come spiegato, di ridurre la massima tensione in uscita per adattarla a quella leggibile da Arduino.

Lo schema qui vicino dovrebbe chiarire il tutto. In azzurro vediamo il partitore che divide la linea di alimentazione, nel caso specifico ho usato la linea a 3.3V (filo rosso), ma su Arduino UNO dovete usare la linea a 5V (lo schema riporta Arduino UNO solo per semplicità di disegno). La linea azzurra, termina in tre posti, ossia all’ingresso analogico numero 4 per la lettura diretta da parte di Arduino (nota: nello sketch troverete A5), alla pinza amperometrica e al trasformatore. La linea verde esce dalla pinza amperometrica e termina all’ingresso analogico A1. Si noti che dall’uscita del trasformatore arriviamo al secondo partitore di cui ho più sopra spiegato come dimensionare. L’uscita dallo stesso raggiunge A2 per la misurazione da parte di Arduino.

Sketch

Immagino siate impazienti di provare qualcosa di pronto per cui eccoci alla parte software vera e propria. Lo sketch di oggi funziona sia su Arduino UNO che su Arduino DUE, occorrono solo piccole modifiche che riguardano la calibrazione del trasformatore. Inoltre ho deciso di sfruttare una delle caratteristiche delle ultime versioni dell’IDE di Arduino, ossia la funzione “Plotter Seriale” che permette di generare direttamente dall’IDE, i grafici che vi ho riportato in questo articolo. E’ un sistema molto rudimentale, che non permette di fare nulla di nulla, la scala è automatica, i colori delle tracce anche, non è possibile fermare il grafico ne effettuare uno screenshot, ma comunque è una caratteristica decisamente molto comoda. Se la prima linea del listato (//#define LOCALDEBUG 1) è commentata, il listato si prepara per l’output grafico che potete vedere applicando la funzione “Plotter Seriale” dell’IDE, in caso contrario fornisce un output testuale con i seguenti dati:

Midpoint= 1024.00
min V= -570.00 – max V= 569.00 min I= -8.00 – max I= 8.50 – campionamenti= 17.00
rms I= 0.45 – V= 227.02
Real power= 100.20
Apparent power= 101.24
Power Factor= 0.99

Ci sono perciò la misura del “midpoint”, ossia la tensione in uscita dal partitore sulla linea di alimentazione, i valori minimi e massimi sia sul voltaggio che sulla corrente, il numero di campionamenti effettuati sul periodo stabilito, che di default è un’intera onda, i valori rms di corrente e tensione, la potenza reale, quella apparente ed il fattore di potenza. L’unica modifica necessaria è quella che permette di calibrare il trasformatore e relativo partitore. Per farlo alla linea 46 dove è riportato ”  sensorVstep=0.5555; //0.181 SU ARDUINO DUE” , impostate dapprima sensorVstep=1 e compilate lasciando attiva la modalità debug (prima linea non commentata). A questo punto provate il software applicando alla pinza un carico puramente resistivo noto, io come sempre ho usato una lampadina ad incandescenza da 100W. A questo punto guardate il risultato della potenza reale letta, non badate alle prime misure, aspettate almeno 5-6 misure per far si che il sistema si sia stabilizzato. A questo punto facciamo finta che vengano misurati 180W. Calcoliamo ora Carico reale / misurato, ossia 100/180 ed otteniamo 0.555, guarda caso l’esempio che vi porto è quello che ho ottenuto nella realtà e che perciò trovate nel listato. Sostituite con il valore calcolato, ricompilate e il vostro sistema è pronto. Per migliorare la precisione di calibrazione potete fare due, tre o quattro avvolgimenti del filo sulla pinza amperometrica, in questo caso la misura dovrà essere 200, 300 o 400W motivo per cui con 4 avvolgimenti avrete un carico reale di 400W e la misura non calibrata potrebbe essere di 720W. Poi però ricordatevi di togliere gli avvolgimenti sulla pinza amperometrica, io ho perso una buona oretta a capire perchè il mio portatile consumava più di 240W quando me ne aspettavo una sessantina. Il listato è già impostato per fare l’oversampling a 11bit con prescaler modificato nel caso venga utilizzato Arduino UNO, potete comunque intervenire su questi parametri come spiegato nei precedenti articoli. Al fine di ridurre il rumore sia la tensione che la corrente vengono campionate come media di 3 misurazioni consecutive per cui nell’esempio che vi ho mostrato sopra, i 17 campionamenti si riferiscono comunque a 51 campionamenti sulla tensione e altrettanti sulla corrente che vengono però mediati in 17+17 per ridurre il rumore delle misure. Ecco qui sotto il listato

#define LOCALDEBUG 1

#ifdef __AVR__
  #define PS_8 ((1 << ADPS1) | (1 << ADPS0))
  #define PS_16 (1 << ADPS2)
  #define PS_32 ((1 << ADPS2) | (1 << ADPS0))
  #define PS_64 ((1 << ADPS2) | (1 << ADPS1))
  #define PS_128 ((1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0))
 // i bit del convertitore ADC di arduino, su UNO sono 10
 #define basic_bits 10
 //i bit che vogliamo ottenere col sovravcampionamento
 #define extended_bits 11
 #define arduinorange 5
#else
 #define basic_bits 12
 //i bit che vogliamo ottenere col sovravcampionamento
 #define extended_bits 12
 //arduino adc range (5V, 3.3V or href value)
 #define arduinorange 3.3
#endif

//voltage range of sensor
#define sensorvoltagerange 1
//how many ampere the sensor reads (RMS)
#define sensorrange 30


//parametri calcolati automaticamente, NON modificare!
// bit di sovracampionamento
#define overbit extended_bits-basic_bits
//divisore oversampling
#define decimatoreoversample (pow(2,overbit))
//calcola risoluzione sensore

double sensorunit;
double sensorIstep;
double sensorVstep;


void setup()
{
  Serial.begin(19200);
  while (!Serial) {} // wait for serial port to connect. Needed for Leonardo only
  sensorunit=(((int)(1<<extended_bits))*(float)sensorvoltagerange/(float)arduinorange);
  sensorIstep=((float)sensorrange/(float)sensorunit);  // su DUE con sensore 30A ho 0.0242
  sensorVstep=0.5555; //0.181 SU ARDUINO DUE // QUESTO DEVE ESSERE CALIBRATO SUL VOSTRO SISTEMA
  
  //puntozero=(1<<(extended_bits-1)); // da tenere se non fai la lettura analogica
 
  #if defined __AVR__
   ADCSRA &= ~PS_128;  //Set up the ADC: remove bits set by Arduino library
   ADCSRA |= PS_32;    // set our own prescaler to XX
  #else
   analogReadResolution(12);
  #endif
 
   
  double tstart,tstop,test;
}

float SampleAnalogAvg(int localpin,unsigned char campioni)
{
  float valore=OversampledAnalogRead(localpin);
  for(int i=0;i<campioni;i++) valore=(valore+OversampledAnalogRead(localpin))/2;
  return(valore);
}


inline double OversampledAnalogRead(int pin)
{
 unsigned int val=0;
 unsigned int misureoversample=pow(4,overbit);
 for(unsigned char z=0;z<misureoversample;z++) val+=analogRead(pin);
 
 return(val>>overbit); //2^n
}


void loop()
{
  double istI,istV,istP,maxI=0,maxV=0,minI=256000,minV=256000,sum_inst_power=0,sqrV=0,sqrI=0,sum_sqrV=0,sum_sqrI=0;
  double rmsI,rmsV,rP,aP;
  double midpoint,tstart;
  float wavenumber=1;
  double timelen=(double)wavenumber*1/50*1000*1000; //0.02sec...è la lunghezza in microsecondi dell'onda completa.
  double counter=0;


  boolean st=false;                                  
  tstart = micros();    

   midpoint=SampleAnalogAvg(A5,10);  // su A5 è campionato il midpoint, ossia il voltaggio che da Arduino passa al partitore per essere dimezzato.
#ifdef LOCALDEBUG
  Serial.print("Midpoint= ");
  Serial.println(midpoint);  
#endif
  while(st==false) // aspetta di essere intorno allo zero per iniziare a campionare.                                   
  {
   istV=SampleAnalogAvg(A2,2)-midpoint; // A2 legge l'onda che arriva dal trasformatore
   if (istV<50 && istV>-50) st=true;  //check its within range
   if ((micros()-tstart)>5*timelen) st = true;
  }
  
  tstart=micros();
  while(micros()-tstart<timelen) 
  {
   
   istI=(SampleAnalogAvg(A1,3)-midpoint); // A1 è collegato alla pinza amperometrica. 
   istV=(SampleAnalogAvg(A2,3)-midpoint); // A2 legge l'onda che arriva dal trasformatore
   istP=istV*istI;
   sqrV=istV*istV;
   sqrI=istI*istI;
   sum_sqrV+=sqrV;
   sum_sqrI+=sqrI;
   sum_inst_power+=istP;   
 
   if(minV>istV) minV=istV;
   if(minI>istI) minI=istI; 

   if(maxV<istV) maxV=istV;
   if(maxI<istI) maxI=istI; 
   counter++;
  }
  rmsI=sqrt(sum_sqrI/counter)*sensorIstep;
  rmsV=sqrt(sum_sqrV/counter)*sensorVstep; 
  rP=sensorIstep*sensorVstep*sum_inst_power/counter;
  aP=rmsV*rmsI;

  
#ifdef LOCALDEBUG
  Serial.print("min V= ");
  Serial.print(minV);
  Serial.print(" - max V= ");
  Serial.print(maxV);

  Serial.print(" min I= ");
  Serial.print(minI);
  Serial.print(" - max I= ");
  Serial.print(maxI);
  Serial.print(" - campionamenti= ");
  Serial.println(counter);
  
  Serial.print("rms I= ");
  Serial.print(rmsI,2);
  Serial.print(" - V= ");
  Serial.println(rmsV,2);

  Serial.print("Real power= ");
  Serial.println(rP,2);
  Serial.print("Apparent power= ");
  Serial.println(aP,2);
  Serial.print("Power Factor= ");
  Serial.println(rP/aP,2);  
  Serial.println(" ");
  delay(5000);
  #else
  Serial.print(rmsI,2);
  Serial.print(",");
  Serial.print(rmsV,2);
  Serial.print(",");
  Serial.print(aP,2);
  Serial.print(",");
  Serial.println(rP,2);  
  #endif
  
  
} 

E’ abbastanza lungo ma gran parte non è altro che quanto già spiegato in passato, in particolare per quanto riguarda le funzioni di oversampling e la modifica del prescaler. In questo esempio, a differenza del passato, ho portato la velocità della porta seriale a 19200 per cui dovete modificare il relativo valore sul Monitor / Plotter seriale per ottenere una corretta visualizzazione dell’output. Ho fatto ciò per rendere il plotter più veloce. Nella foto a lato potete osservare il prototipo che ho realizzato. In alto a destra potete vedere il trasformatore che ho messo su una basetta millefori, ho preparato dei connettori a vite in cui da una parte abbiamo l’ingresso a 230V (cavi rosso, blu, giallo) e subito in vicinanza l’uscita che termina in una presa per collegarci l’utilizzatore finale oltre che la pinza amperometrica. Dai cavi grigi esce la tensione trasformata che vedete andare sulla breadboard. Una cosa molto importante non visibile in foto è che il fondo della mille fori con i vari fili stagnati è stata ricoperta con della plastica ed il tutto sigillato con colla a caldo per isolare in maniera sicura la 230V dal mondo esterno.

Nella fotto ci sono sia Arduino UNO che DUE per il semplice motivo che mi è comodo averli vicini e spostare al volo i cavi da uno all’altro per fare le relative prove. Ad essere onesto il progetto su breadboard ha una differenza rispetto a quanto ho sopra descritto sopra, infatti dalla tensione di Arduino partono due distinti partitori, uno per la pinza amperometrica ed uno per il trasformatore, ma ciò è dovuto solamente alla maggior semplicità nei test, è infatti più semplice staccare singole parti dello schema e fare le relative misure con l’oscilloscopio; non c’è perciò nessuna motivazione legata al funzionamento del sistema.

Il futuro

Con mia sorpresa devo ammettere che questa serie di articoli sul consumo energetico ha superato ogni mia aspettativa, anche perchè esistendo il progetto OpenEnergyMonitor pensavo di scrivere solo i primi due articoli della serie solo per completezza di questo blog, ma alla fine ho dovuto ricredermi e approfondire ancora la materia viste le numerose richieste che ricevo in tal senso. Vi chiederete se possono esserci sviluppi ulteriori e la risposta è sicuramente si. Pensavo, tanto per cominciare, di utilizzare degli schermi per mostrare l’output delle misurazioni direttamente su Arduino senza dover per forza restare collegati al PC per leggere l’output seriale. Una seconda cosa che farò è trasmettere la misura ad un secondo Arduino ricevente, a distanza. Una terza cosa che farò, sarà quella di permettere la lettura di più pinze amperometriche in contemporanea per far si che si possano monitorare più linee elettriche in un solo colpo. In molti mi chiedono infatti la possibilità di monitorare la produzione dei pannelli fotovoltaici ed il consumo dell’abitazione. Non ultimo dovrò spostare buona parte del codice in una libreria “ad ok”, in modo da rendere più semplice la progettazione e sviluppo dei sistemi che ne fanno uso.

 

Fonti principali:

https://openenergymonitor.org/emon/
http://www.atmel.com/images/atmel-2566-single-phase-power-energy-meter-with-tamper-detection_ap-notes_avr465.pdf