Nov 042016
 

Quest’oggi vi mostrerò passo a passo un progettino completo che ho sviluppato per un mio amico. Il progetto da un punto di vista concettuale è piuttosto semplice, ma la realizzazione necessita di diversi accorgimenti che andremo a vedere di volta in volta. L’argomento, non a caso, è il medesimo di numerose scorse puntate, ossia il monitoraggio energetico. L’idea di base è abbastanza semplice, ossia monitorare da un lato il consumo elettrico della casa, dall’altra la produzione dei pannelli fotovoltaici e nel caso di surplus di energia dare corrente alla pompa di calore. Il cuore del progetto sarà quello dei precedenti articoli, anche se quest’oggi troverete grosse novità, infatti il software è stato completamente riscritto ed inserito nella nuova versione della “McMajan Library Pack”. Ora sono state sviluppate delle strutture per la gestione dei vari sensori di tensione e corrente, inoltre è stata sviluppata una nuova classe che ho chiamato “Energia” che si occupa di tutti i calcoli inerenti la potenza. Altra particolarità dal lato software è l’introduzione dei filtri di Kalman per la riduzione del rumore di fondo con netto miglioramento prestazionale rispetto al filtro di denoising che avevo temporaneamente progettato io anche se quest’ultimo era molto più selettivo sugli spike di rumore.

Quali requisiti

Come per ogni progetto dobbiamo per prima cosa porci delle domande su quali saranno le funzioni del sistema ed il dimensionamento dello stesso. Ad esempio, quali correnti sono in gioco? Quanto produce l’impianto fotovoltaico e da quanti kW è il contratto dell’energia elettrica di casa? Questa prima domanda è fondamentale in quanto dobbiamo dotarci di almeno due pinze amperometriche per le due linee che però devono essere adeguatamente dimensionate. Nel caso specifico, ad esempio, abbiamo a che fare con un impianto fotovoltaico di 6KW, che a 230V fanno un massimo di 26A per cui dobbiamo escludere i modelli da 20A e scegliere quello da 30. La casa ha un contratto di altrettanti 6KW per cui usiamo una seconda pinza da 30A. E la pompa di calore quanto assorbe? Questo dato ci interessa perchè abbiamo necessità di un relè che dia / tolga corrente in base alle condizioni che prefissiamo. Ci interessa ovviamente il valore di picco, non tanto il consumo a regime, e siamo sui 4.5KW per cui siamo a poco meno di 20A. Come sempre meglio avere un certo margine di sicurezza per cui ho optato per un relè da 25A. Nel momento dell’acquisto dovete ovviamente pensare anche alla tensione di funzionamento del relè stesso altrimenti, a titolo di esempio, potreste trovarvi poi a dover operare con una linea a 24V per il relè, una a 5V per Arduino, una a 3.3V per eventuali moduli aggiunti, etc, etc.

Una seconda fase sarà quella di definire il funzionamento del sistema. A dirvela tutta non ho ancora definito nei dettagli questa fase perchè preferisco prima raccogliere dei dati oggettivi sul campo prima di impostare un funzionamento definitivo. Facciamo un esempio. Mettiamo che la casa stia assorbendo complessivamente 2KW ed i moduli fotovoltaici producano 2.1KW, quindi abbiamo un surplus di 100W. Dobbiamo accendere la pompa di calore che assorbe 4.5kW all’accensione? E se decidessimo di si e dopo soli 10 secondi la produzione del fotovoltaico calasse a 1.9kW cosa facciamo? La spegniamo di nuovo? Certo questo non è uno scenario di funzionamento ideale, anche perchè le pompe di calore consumano molto finchè non entrano a regime ma poi il loro consumo si riduce per cui dobbiamo sfruttare al massimo questa seconda fase. Certo che per prendere delle decisioni ci servono dei dati più precisi, si potrebbe pensare di monitorare i consumi della pompa di calore per capire quanto consuma nelle varie fasi di funzionamento e quanto tempo ci mette ad entrare a regime.

Accessori

Il sistema base è abbastanza semplice, ricordiamoci però che questa volta pur trattandosi di una forma di prototipo, verrà installata a casa di una persona che non ha dimestichezza con l’elettronica, per cui dobbiamo pensare anche all’inscatolamento del circuito, l’isolamento di tutti i punti in tensione, l’utilizzo di connettori che impediscano ad esempio di mescolare l’alta tensione con la bassa tensione o di collegare la pinza amperometrica direttamente alla 230V, etc, etc. Altra cosa da pensare sarà la previsione di un pulsante di accensione e spegnimento del sistema, potremmo utilizzare un display per mettere in evidenza i principali parametri di funzionamento del sistema, allo stesso modo possiamo pensare di utilizzare un modulo wifi per trasmettere i dati in remoto. Potremmo anche pensare all’uso di potenziometri per calibrare le soglie di intervento del sistema direttamente in loco anziché farlo nel firmware, ma sono tutte cose accessorie non indispensabili al funzionamento di base del sistema. Vi sarete chiesti perchè non eseguire anche il monitoraggio della temperatura interna ed esterna per valutare a priori se sia necessario accendere la pompa di calore. E’ una cosa sicuramente fattibile e che probabilmente verrà realizzata in un secondo tempo, ma che per ora esula da questo progetto in quanto per ora ci limiteremo ad intervenire solamente dove sono posti i principali quadri elettrici senza necessità di intervenire su altri ambienti della casa.

I materiali

Il discorso è sempre lo stesso: prendiamo una scheda Arduino / Genuino e la riempiamo di cavi e cavetti o creiamo un PCB su misura? Per questo prototipo mi sono organizzato per utilizzare una scheda Arduino Nano ma per il prossimo futuro è mia intenzione costruire un pcb apposito anche perchè ho in mente alcune idee che non possono essere realizzate su una scheda Arduino pre-assemblata in quanto richiedono modifiche dell’hardware. Questa volta abbiamo detto che non possiamo utilizzare “fili volanti”, per cui dobbiamo munirci dei connettori per i jack 3.5mm per il collegamento delle pinze amperometriche. Il circuito nella sua completezza utilizzerà una linea a 230V per cui dobbiamo decidere se far uscire direttamente un cavo con la spina dalla scatola di assemblaggio o prevedere un connettore 230V a cui connettere il relativo cavo, opzione per cui ho optato. Internamente perciò ci servirà un alimentatore per trasformare la 230V in una tensione compatibile sia con il funzionamento di Arduino che con il relè. Non dobbiamo però scordare che abbiamo anche la necessità di avere un trasformatore AC-AC per “leggere” la tensione di rete e quindi calcolare in modo preciso le potenze in gioco. Abbiamo due possibilità distinte. Da un lato possiamo avere un alimentatore che porta la 230V alternata in una tensione continua compatibile con Arduino ed il relè scelto e in parallelo un secondo trasformatore da usare per la lettura della tensione con il classico partitore. Io avevo pensato di optare per una seconda opzione: senza partire da zero ho acquistato dei moduli di alimentazione già pronti che trasformano la 230AC in 5V continua, ma che non sono scatolati per cui posso accedere ai pin di uscita del trasformatore e prelevare la tensione alternata a basso voltaggio. Purtoppo però questi alimentatori agiscono anche sul segnale in ingresso al trasformatore per cui il segnale in uscita non è proporzionale alla tensione in ingresso il che mi ha fatto tornare alla prima opzione. Dovendo usare un trasformatore ad ok, avrei potuto usare la tensione in uscita sia per alimentare Arduino che per comandare il relè e leggere il segnale di tensione, ma visto che oramai gli alimentatori li ho acquistati ho deciso di usare questi ultimi per l’alimentazione di Arduino mentre relegherò il trasformatore alla lettura del segnale di tensione.

Vi riporto qui sotto uno schizzo generico del progetto:

schizzo progetto

La pinza collegata alla pompa di calore è del tutto opzionale, l’ho prevista come opzione nella prima fase di installazione per tenere monitorato il consumo della pompa di calore e determinare in maniera più precisa il funzionamento del sistema.

Relè

Come dicevamo agli inizi ho optato per un relè da 25A, un relè a stato solido a cui ho aggiunto un bel dissipatore in alluminio che si aggancia direttamente alla barra DIN semplificandomi anche l’installazione nel quadro elettrico. Ovviamente ho provveduto anche ad acquistare la pasta termica da interporre fra il relè ed il dissipatore per migliorare le performance di dissipazione del calore. Questo relè può essere attivato con una tensione fra i 3 ed i 32V con un assorbimento di 7.5mA a 12V (quindi circa 18mA a 5V).

Arduino

Allora, avevamo detto che per il progetto utilizzerò Arduino Nano. Ero molto dibattuto se usare i classici jumper per fare i vari collegamenti elettrici, o saldare direttamente i fili sulla scheda. Il secondo approccio ha il vantaggio di dare maggior stabilità / affidabilità al circuito in quanto le saldature non si sfilano certo quanto i jumper. Lo svantaggiò però sta nel fatto che se decido poi di cambiare il progetto sono costretto a rimuovere le stagnature e rifarle. Ho perciò optato per i jumper che ho però fermato in sede con una goccia di colla a caldo che è facilmente rimovibile e rimpiazzabile. Non fornisce certo la stabilità di una stagnatura, ma mi permette di modificare il progetto anche una volta installato e funzionante.

Sezione di alimentazione

schema_arduino_consumo_energeticoPrima di cominciare questa sezione vi riporto qui vicino lo schema di collegamento che abbiamo utilizzato nello scorso articolo anche se quest’oggi andiamo a ricalcolare tutti i valori di resistenza in base al materiale in mio possesso per questo nuovo progetto. 

Vi ho già detto che ho optato per usare un alimentatore pre-assemblato per fornire corrente ad Arduino, mentre userò il trasformatore per leggere la tensione di rete. A questo punto procediamo come nei precedenti articoli motivo per cui ho collegato l’alimentatore alla 230V ed ho misurato con il multimetro la tensione di ingresso e di uscita dal trasformatore. Nella misurazione ho ottenuto 229V in ingresso e 14.3 V in uscita; in una misura più tardiva ho ottenuto 228V e 14.1V.

Se ricordate questi valori ci servono per calibrare in modo corretto il partitore di tensione  che a sua volta ci permetterà di ottenere la corretta misura della tensione di rete.  Ma ripassiamo i calcoli fatti la scorsa volta. Per prima cosa calcoliamo il rapporto fra la tensione in ingresso ed uscita al trasformatore per cui abbiamo

229 / 14.3 = 16. Sappiamo perciò che se prendiamo la tensione di ingresso e dividiamo per 16 otteniamo la tensione in uscita. Poi dobbiamo ricordarci che la massima tensione di rete deve essere 230V rms +10% di tolleranza per cui otteniamo, arrotondando all’eccesso, 358V. Essendo 358 / 16 = 22.375 sappiamo che la tensione massima che può raggiungere il partitore sarà appunto, approssimata in eccesso, di 23V. Questo valore massimo si deve tradurre in un valore massimo correttamente leggibile da Arduino. Nel nostro caso Arduino è in grado di misurare tensioni sino a 5V, valore che però per motivi di sicurezza preferisco ridurre a 4.5V rinunciando a un po’ di accuratezza nella misura. A quei 4.5V deve essere sottratto il punto medio (2.5V) per cui abbiamo un’oscillazione massima di 2V. Il partitore perciò dovrà portare la nostra tensione massima di 23V ad una tensione massima di 2V. Io come sempre vi propongo di utilizzare la mia app per determinare i valori del partitore, ma siete ovviamente liberi di fare come preferite, con qualunque altro software o manualmente. Dopo i dovuti calcoli ho scelto i valori di 100k e 10kΩ rispettivamente per R1 ed R2. Per quanto riguarda R3 ed R4 ho usato dei resistori da 560Ω non tanto per una specifica esigenza, quanto perchè ne avevo alcuni già a portata di mano.

La scatola

Certo, non ci pensiamo mai al contenitore quando creiamo i nostri progetti, ma in questo caso devo proprio spenderci un po’ di tempo. Ho usato una semplice scatola in pvc per quadri elettrici che mi permette di fissare la scatola stessa a muro ed installare con semplicità tutte le parti del circuito. Ovviamente ho dovuto prevedere alcuni connettori che permettono di collegare in maniera semplice la “scatola” con il mondo esterno. Ho usato i classici connettori per jack audio per le pinze amperometriche, ma anche per portare la tensione di alimentazione al relè che verrà invece montato sul quadro elettrico principale. L’alternativa sarebbe stata quella di mettere il relè nella scatola con Arduino ma in primo luogo avrei dovuto usare una più costosa scatola con barra din per agganciarci il dissipatore, inoltre avrei dovuto far fuoriuscire dalla scatola la 230V / 25A in uscita dal relè, cosa che non mi faceva tanto piacere. Ovviamente usando lo stesso connettore sia per la pinza che per il controllo del relè è buona norma indicare in modo chiaro sulla scatola le funzioni dei vari connettori ed è preferibile posizionarli in posti diversi in modo da non poterli confondere. Poi ho usato un connettore C7 per portare la 230V di alimentazione alla scatola. Un interruttore per accendere e spegnere il circuito senza dover staccare il cavo di alimentazione e per finire un display per mostrare le informazioni base: con questo siamo pronti per montare il tutto.

Il display

Per questo progetto ho usato un display lcd verde 20×4, HD44780. Come sapete questo tipo di display utilizza la bellezza di 11 pin digitali di Arduino, che possono scendere a 7 utilizzando l’interfaccia a 4 bit, sacrificio che potremmo anche tollerare, ma ho preferito usare uno shitf register 74HC595 per liberare un bel po’ di pin e lasciare alle mie librerie l’onere di controllare il display. Ciò mi permette di lasciare liberi i pin per l’interfaccia SPI dato che devo costruire dei sistemi simili dotati di modulo nrf24, inoltre lascio liberi anche i pin della porta seriale, utile sia per comunicare con il PC sia per l’eventuale utilizzo di un modulo ESP2886. Ciò permetterà l’eventuale espansione del sistema anche in un secondo tempo.

Assembliamo il tutto

Abbiamo visto i materiali in gioco, ora dobbiamo solo procedere con il montaggio di tutto i circuito. Rispetto ai precedenti articoli  ho aggiunto anche alcuni diodi in serie ad un piccolo filtro RC per proteggere gli ingressi analogici di Arduino, sia per quanto riguarda il trasformatore che le pinze amperometriche. Il filtro RC permette di attenuare piccole fonti di rumore come potete osservare nel prossimo grafico. Si noti l’unità temporale che mostra chiaramente come il filtro agisce su interferenze di brevissima durata. Inoltre benchè il resistore da 22Ω permetta di far passare una gran quantità di corrente, oltre 200mA a 5V, ne pone comunque un limite massimo che può fare la differenza.

filtro_rc_200o_100nfPer quanto riguarda l’uso dei diodi contrapposti, questi permettono di “scaricare” la tensione in eccesso sia positiva che negativa permettendo di salvare gli ingressi analogici di Arduino sia da sovraccarichi che da semionde negative. Nel prossimo grafico potere osservare una forma d’onda irregolare e l’effetto di taglio che otteniamo al raggiungimento dei 5V. Lo stesso avviene per segnali al di sotto dello zero, anche se non ho riportato un esempio in forma grafica.

protezione-con-doppio-diodoComplessivamente lo schema attuale si presenta come riportato nel prossimo diagramma. Tenete presente che non ho aggiunto la terza pinza amperometrica per la verifica del consumo della pompa di calore, ne eventuali moduli esp286 o nrf24 benchè il sistema sia pronto per ospitarli.

schema

Qui di seguito vi lascio alcune foto scattate durante la costruzione di questo prototipo. Cliccandoci sopra si aprono più in grande e sotto vi riporto una breve descrizione di ognuna.

Il Software

E’ con gran piacere che per questo articolo andrò ad usare una nuova versione della McMajan Library. Non cercatela sul blog perchè non l’ho ancora rilasciata in quanto ci sono ancora alcune cose da sistemare prima del rilascio ufficiale al grande pubblico, sto infatti adeguando tutto il software per renderlo compatibile anche con Arduino DUE e quindi gran parte delle nuove schede in circolazione, ma ho ancora un po’ di lavoro da completare; inoltre devo aggiornare la pagina di supporto e descrivere tutte le nuove aggiunte, cosa non da poco.

Comunque sia nella versione in sviluppo oltre alla nuova libreria per il controllo dei moduli nrf24, c’è Energia, la nuova classe nata per la gestione del calcolo del consumo energetico. Questa classe si occupa di tutto quanto abbiamo descritto nei precedenti articoli, dal semplice campionamento dei segnali analogici anche con oversampling del segnale, ai calcoli sui voltaggi, correnti, potenze o all’utilizzo dei filtri di Kalman per il filtraggio dei dati raccolti. Come mio stile è una libreria di semplice utilizzo e molto leggera pur mantenendo una grande flessibilità di utilizzo per chi ama “smanettare”.  Ciò non toglie che un progetto così articolato richiede comunque un discreto sforzo anche con una sottostante libreria pronta all’uso. Giusto per farvi capire la complessità di ciò che avviene nel mondo reale rispetto alla pura teoria, mi sono dovuto confrontare con il ripple residuo degli “alimentatori cinesi” che sono decisamente meno accurati della comune porta USB o dei classici alimentaori per smartphone, per cui il rumore di fondo mi ha creato non pochi problemi nel distinguere il reale segnale dal rumore di fondo in caso di basse potenze. In parte ho risolto utilizzando un filtro RC aggiuntivo sulla linea a 2.5V, con un condensatore molto più grosso, in parte via software con l’ausiglio sia dei filtri di Kalman che di funzioni specifiche per la rimozione del ripple. Ma non voglio esagerare per cui in questo articolo vi riporto una versione assai semplificata del software giusto per prendere familiarità con le nuove funzionalità.

Anche se è una versione del software molto rudimentale e decisamente meno performante di quella installata realmente sul dispositivo, ritengo che sia interessante per evidenziare alcuni aspetti di funzionamento sia della nuova libreria Energia, che tutta la gestione degli input analogici oltre che un ripasso della hc595. Per quanto riguarda quest’ultima non ci sono novità, le istruzioni da ripassare sono:

hc595 My595(5,4,6,1); // latch (ST),clock (SH),data (DS),number of 74hc595

Questa crea l’oggetto My595 di tipo hc595 usando i pin 5, 4 e 6 come ST, SH e DS. L’1 indica che c’è un solo 74hc595 sulla catena.

My595.DisplayReset(LCD595_BASIC_DISPLAY_INIT | LCD595_MORELINES ,0);

Inizializza il display.

My595.DisplayClean(0);

Svuota il display cancellandone tutto il contenuto.

My595.SetCursor(0,0,1,0);

Modifica la posizione del cursore. I primi due valori rappresentano la x ed y, il terzo dipende dalla tipologia di display, il quarto indica il numero di shift register occupato nella catena, in questo caso essendoci solo questo sarà il numero zero.

My595.DisplayWrite(“McMajan Energia V0.1”,0);

Permette di scrivere una stringa sulla posizione prima definita del cursore.

Ora analizziamo le peculiarità riguardanti il monitoraggio energetico ed i segnali analogici in generale.

struct Mc_AnalogSensor I1_Probe; // pinza A
struct Mc_AnalogSensor I2_Probe; // pinza B
struct Mc_AnalogSensor V1_Probe;
class Energia MyEnergyCalculator;

Queste tre istruzioni sono decisamente una novità. Le prime tre preparano tre strutture Mc_AnalogSensor rispettivamente per le due pinze amperometriche e per la misurazione della tensione. L’ultima istruzione crea un’istanza di classe Energia e la chiama MyEnergyCalculator.

  I1_Probe.pin=A2;  //SCT013 30A (pinza A – rete)
  I1_Probe.sensor_range=30;
  I1_Probe.sensor_voltage_range=1;
  Mc_CalculateSensorStep(&I1_Probe);

Con queste istruzioni indichiamo per prima cosa il pin dove deve avvenire la misura analogica. La seconda specifica il range di misura del nostro sensore, nel nostro caso è 30 in quanto l’SCT 013-30 ha un output di 1v quando raggiunge la massima ampiezza misurata di 30A. La terza istruzione indica proprio che all’estremo del range di misura fornisce 1V di tensione. L’ultima istruzione fa si che il sistema calcoli alcuni fattori di conversione interni che permettono di ottenere successivamente i risultati che desideriamo direttamente in watt, ampere, volt, etc.

Per la misura del voltaggio invece usiamo le seguenti due istruzioni:

  V1_Probe.pin=A1;
  Mc_SetSensorStep(&V1_Probe,0.92);

La prima indica il pin come prima. Poi però non abbiamo un range preciso da fornire in quanto non si tratta di un sensore standardizzato, lo abbiamo creato noi con un trasformatore ed un partitore di tensione per cui anzichè ricavare i relativi valori, cosa fattibile, istruiamo il sensore inserendo direttamente il “valore di calibrazione”. La procedura per ricavare questo valore esula da questo articolo, ma di base si ricava confrontando i risultati forniti dal sistema non calibrato rispetto al risultato atteso.

MyEnergyCalculator.Start(A5);

Effettua alcune inizializzazioni e prende A5 come pin per la misura del “punto medio”, teoricamente di 2.5V ma che nel mio esemplare è invece ad un valore leggermente più alto, probabilmente in quanto i resistori del partitore non erano così uguali come avrebbero dovuto. Non è indispensabile calcolare il punto medio per il funzionamento di Energia, ma la misura finale sarà più accurata.

MyEnergyCalculator.ReadPowerData(&V1_Probe,&I1_Probe);

Questa funzione è il cuore di Energia. Gli vengono dati in pasto gli indirizzi (nota &) di due sensori prima definiti, uno per il voltaggio ed uno per la corrente. Questo perchè Energia calcola in maniera del tutto automatica potenza apparente, reale, tensione, corrente, etc. Se però non avete il trasformatore per la lettura della tensione Energia funziona ugualmente sostituendo la tensione con il valore standard impostato nella configurazione della libreria, che di base è 230V. Dopo aver richiamato la funzione vista sopra possiamo leggere tutti i valori calcolati che saranno i valori rms di corrente e tensione, i valori di potenza reale ed apparente, i valori massimi di tensione e corrente rilevati durante le letture.

Il software una volta calcolate le due potenze decide se accendere o spegnere il relè. Ovviamente il software reale non è così grezzo in quanto se la potenza rilevata dalle due pinze fosse similare e magari vi fosse un repertino passaggio fra la maggior lettura di una e dell’altra si avrebbe un continuo accendimento e spegnimento del relè, cosa del tutto inopportuna.


#define relaypin 7

#include <Ss_McMajan_Config.h>

hc595 My595(5,4,6,1); // latch (ST),clock (SH),data (DS),number of 74hc595

char fstring[15];

struct Mc_AnalogSensor I1_Probe; // pinza A
struct Mc_AnalogSensor I2_Probe; // pinza B
struct Mc_AnalogSensor V1_Probe;

class Energia MyEnergyCalculator;

uint16_t ciclo=0;
uint16_t temporizzatore=0;

double mytimer;
float pa,pb;

void setup()
{
  
  Serial.begin(9600);
  while (!Serial) {} // wait for serial port to connect. Needed for Leonardo only
  pinMode(relaypin,OUTPUT);
  Serial.println("STARTING READER.... ");
  My595.DisplayReset(LCD595_BASIC_DISPLAY_INIT | LCD595_MORELINES ,0); // multiline display
  My595.SetCursor(0,0,1,0); // cursor at 0,0, display type 1 on first 595
  My595.DisplayWrite("McMajan Energia V0.1",0); // Write string

  My595.SetCursor(0,1,1,0); //setto la posizione del cursore
  My595.DisplayWrite("by Stefano Smania",0); 

  I1_Probe.pin=A2;  //SCT013 30A (pinza A - rete)
  I1_Probe.sensor_range=30;
  I1_Probe.sensor_voltage_range=1;
  Mc_CalculateSensorStep(&I1_Probe); 

  I2_Probe.pin=A3;     //SCT013 30A (pinza B - pannelli)
  I2_Probe.sensor_range=30;
  I2_Probe.sensor_voltage_range=1;
  Mc_CalculateSensorStep(&I2_Probe);

  V1_Probe.pin=A1;
  Mc_SetSensorStep(&V1_Probe,0.92); 
  MyEnergyCalculator.Start(A5); // lettura del middlepoint su A5

  MyEnergyCalculator.ReadPowerData(&V1_Probe,&I1_Probe);
  pa=MyEnergyCalculator.rP;
  MyEnergyCalculator.ReadPowerData(&V1_Probe,&I2_Probe);
  pb=MyEnergyCalculator.rP; 

  delay(1000);
  My595.DisplayClean(0); 

  mytimer=millis();
}

void loop()
{
  MyEnergyCalculator.ReadPowerData(&V1_Probe,&I1_Probe,1);
  pa=MyEnergyCalculator.rP; 
  MyEnergyCalculator.ReadPowerData(&V1_Probe,&I2_Probe,1);
  pb=MyEnergyCalculator.rP; 
  
if(millis()-mytimer>1000)
{ 
//================================= V  
  My595.SetCursor(0,0,1,0);
  My595.DisplayWrite("V:",0);

  //floatToString(fstring, K_V.value, 1, 4);
  dtostrf(MyEnergyCalculator.rmsV,3,1,fstring);
  strcat(fstring," ");
  My595.SetCursor(3,0,1,0); 
  My595.DisplayWrite(fstring,0);

 //================================= P A 
  My595.SetCursor(0,2,1,0);
  My595.DisplayWrite("P:",0);
  
  dtostrf(pa,2,1,fstring); 
  strcat(fstring," ");
  My595.SetCursor(3,2,1,0); 
  My595.DisplayWrite(fstring,0);   
   
  //================================= P B 
  My595.SetCursor(10,2,1,0);
  My595.DisplayWrite("P:",0);
  
  dtostrf(pb,2,1,fstring);
  strcat(fstring," "); 
  My595.SetCursor(13,2,1,0); 
  My595.DisplayWrite(fstring,0); 

  My595.SetCursor(10,0,1,0);
  if(pa<pb) 
  {
    FastdigitalWrite(relaypin,false);
    My595.DisplayWrite("OFF",0);
  }
  else 
  {
    FastdigitalWrite(relaypin,true); 
    My595.DisplayWrite("ON ",0);
  }
  mytimer=millis();
} // millis
ciclo++;
} 

Mi rendo conto che questo articolo è un po’ “monco” come l’ultimo sui moduli nrf24 in quanto le rispettive nuove librerie non sono ancora disponibili sul blog. Vi chiedo di pazientare ancora un po’, gran parte del vecchio software è stato modificato ed ora è completamente compatibile con Arduino DUE. Devo valutare ancora alcune cose e poi devo preparare le relative pagine di supporto visto che le novità sono davvero tante, per cui ho bisogno ancora di un po’ di tempo ma vedrete che vi fornirò una libreria unica nel suo genere.

 

Salva

Salva

Salva

Salva

Salva

  5 Responses to “Energia – it”

  1.  

    Ti consiglierei di cambiare il nome da Energia a qualcosa di diverso, tipo mcmajanenergia, perché immagino che esistano già librerie con questo nome ma soprattutto un eventuale porting per l’IDE per MSP430 e altre MCU della TI sarebbe problematico in quando si chiama proprio Energia.

  2.  

    Ciao
    Sono nuovo e poco esperto, però volevo chiederti come mai non utilizzi un display i2c; nell’arduino nano i pin SDL e SDA sono gli A4 e A5; non potresti spostare quello utilizzato per il riferimento di tensione (A5) nei pin A6 o A7 e risparmiarti 3 pin digitali?

    In futuro (quando le nuove librerie saranno pronte) vorrei provare a realizzare anche io una cosa simile; sto iniziando a imparare arduino (sono digiuno di programmazione ma me la cavo con l’elettronica) anche per questo motivo vorrei chiederti (anche se ne hai già parlato nei precedenti articoli, con vantaggi e svantaggi che è inutile ripetere) un suggerimento sull’utilizzo di sensori di hall al posto delle pinze amperometriche, per il fatto che in passato ne ho prese varie e vorrei provare ad utilizzare quelle.
    Approfitto anche per ringraziarti del tuo lavoro condiviso; ho imparato molto sulla programmazione leggendo i tuoi articoli.

  3.  

    1) Non uso i display spi per due motivi. Il primo è costano complessivamente di più. Il secondo è che la mia libreria gestisce sulla stessa catena di shift register quanti display e uscite digitali vuoi, in contemporanea. Puoi quindi permetterti ad esempio di usare due display e 8 uscite digitali con la stessa catena di shift registers.
    2) Ho provato alcuni sensori di hall con buoni risultati. Gli svantaggi sono però il fatto che siano invasivi per cui sei obbligato a modificare l’impianto elettrico cosa che con le pinze non serve, le attacchi e stacchi quando ti pare. Inoltre la pinza essaedo fisicamente separata dalla linea elettrica, offre una protezione maggiore dai sovraccarichi (ovviamente non infinita).
    3) Grazie mille!!!!! Se hai imparato dai miei articoli significa che qualcosa di buono l’ho fatto 🙂 🙂

  4.  

    Ciao,
    complimenti per l’ottimo progetto.
    Volevo chiederti se l’istuzione:

    MyEnergyCalculator.Start(A0);

    per la lettura del punto medio non vada su A5 anzichè A0 che è scollegato.

    Grazie e spero che pubblichi a breve la libreria.

    •  

      Si, si hai ragione. E’ che come sempre prima faccio gli schemi e poi quando vado ad assemblare il tutto vado a cambiare qualcosa, nello specifico ho messo i pin analogici tutti attaccati per avere più stabilità sui connettori (lasciando il 5 da solo era più facile che si sfilasse accidentalmente). Il software è un riassunto di quello realmente presente sul prototipo per cui usava i pin “reali” e non quelli dello schema, da qui il piccolo errore. Comunque complimenti perchè significa che hai letto con moooolta attenzione. Per la libreria mi ci vuole ancora un po’, devo convertire la “ir-remote modificata” o decidere se eliminarla, ma sono restio a toglierla perchè è molto utilizzata e mi dispiacerebbe deludere tutte le persone che la usano e non si ritroverebbero senza tutte le nuove caratteristiche (che sono davvero tante). D’altro canto è difficile da modificare perchè utilizza i timers che su arduino uno e due sono profondamente differenti.