Rieccomi...finalmente ho potuto testare il lavoro realizzato in questo ultimo periodo e come promesso al mio post precedente, vi aggiorno sulla situazione:
Messo da parte Arduino Uno, ho "inscatolato" il nuovo Yun, con una proto-shield leggermente modificata dalla precedente per leggere tutti i sensori e per collegare il display via I2C e usare solo 2 pin digitali anzichè 6pin come con il normale collegamento..
Ho inoltre sostituito il buzzer usato per le segnalazioni acustiche, con una cassa (
LINK) che collego ad una scheda audio usb
LINK collegata alla parte linux alla quale faccio riprodurre degli mp3 sempre come segnalazione di "over-consumo" (risparmiando così 1 altro pin digitale, ottenendo un effetto audio più simpatico, e un maggior volume audio rispetto al buzzerino!)
Lo sketch differisce quindi per la parte che si occupa della comunicazione dei dati ottenuti (consumi) da arduino alla sua parte linux che poi sarebbe quella che mi permette di leggere i dati e interagire con i relè anche da remoto
Ma per quanto riguarda il calcolo dei consumi, lo sketch è basato sulla stessa logica di prima e quindi del lavoro di ElettroshockNow !
Subito dopo il montaggio (avevo cercato di curare al meglio lo sketch per non avere sorprese) ho visto che in linea generale, funzionava...
I sensori riportavano valori dei consumi delle linee monitorate attendibili, MA: nelle linee in cui non avevo carichi, per esempio, la linea bagni con a monte il magnetotermico messo su OFF, arduino mi riportava un consumo "fantasma" di circa 80 - 90 watt !!
Ho provato addirittura a staccare TUTTI i magnetotermici del quadro elettrico (tranne quello che da l'alimentazione ad arduino) e mi aspettavo quindi un bel 0 dai sensori CUCINA, BAGNI, STANZE e qualcosa (MA POCO) dal TOTALE... questo test con Arduino UNO l'avevo effettuato ed effettivamente riportava una manciata di watt.
Purtroppo con Yun e con quello sketch ho ottenuto il consumo "fantasma" su tutti e 4 i sensori... ora, potrei anche fare finta di nulla, tanto alla fine è una condizione rara quella in cui non ci sia davvero nessun utilizzatore che assorbe un po di corrente in ogni stanza, ma il problema è che potenzialmente questo consumo "fantasma" si va ad aggiungere alle letture reali quando invece il consumo C'E', inoltre avendo sviluppato anche l'app per android che mi mostra:
Consumo Totale
Consumo Cucina
Consumo Bagni
Consumo Stanze
non è particolarmente bello leggere valori come (esempio):
totale 2250 watt
cucina 2200 watt
bagni 90 watt
stnze 80 watt
perchè giustamente fa capire che qualcosa non va !!
(riporto la parte di codice che effettua la lettura)
//###################
//LETTURA SENSORI ###
//###################
//Lettura dati dei sensori e calcolo della corrente assorbita e dei consumi in watt
ampereTot = 0.00;
ampereCucina = 0.00;
ampereStanze = 0.00;
ampereBagni = 0.00;
numeroCampionamenti = 0;
inizioCampionamenti = millis() ;
do
{
numeroCampionamenti++;
sensorTotValue = analogRead(sensorTotPin);
sensorCucinaValue = analogRead(sensorCucinaPin);
sensorStanzeValue = analogRead(sensorStanzePin);
sensorBagniValue = analogRead(sensorBagniPin);
//offsetValue è la lettura senza carico quindi lo sottraiamo alle letture dei sensori
offsetValue = analogRead(offsetPin);
sensorTotValue -= offsetValue;
sensorCucinaValue -= offsetValue;
sensorStanzeValue -= offsetValue;
sensorBagniValue -= offsetValue;
//Alcune letture potrebbero avere valore negativo per cui noi consideriamo il valore assoluto
ampereTot += abs(sensorTotValue);
ampereCucina += abs(sensorCucinaValue);
ampereStanze += abs(sensorStanzeValue);
ampereBagni += abs(sensorBagniValue);
}
//20 sono i millisecondi che verranno campionati
while ((millis() - inizioCampionamenti) < 20);
//Per ottenere gli ampere reali moltiplichiamo la media di ampere letti nei 20ms per 0.166 che è il fattore di conversione calcolato con un carico noto
ampereTot = (ampereTot / numeroCampionamenti) * fattoreConversione;
ampereCucina = (ampereCucina / numeroCampionamenti) * fattoreConversione;
ampereStanze = (ampereStanze / numeroCampionamenti) * fattoreConversione;
ampereBagni = (ampereBagni / numeroCampionamenti) * fattoreConversione;
//Infine moltiplichiamo gli ampere per la tensione stabilita per ottenere il consumo in Watt
consumoTot = ampereTot * tensione;
consumoCucina = ampereCucina * tensione;
consumoStanze = ampereStanze * tensione;
consumoBagni = ampereBagni * tensione;
Ho provato allora a moficare qualcosa (aumentando SOLO il tempo di campionamento) visto che ora avevo più sensori, magari serviva più tempo per effettuare un adeguato numero di letture per ogni porta analogica e fare una giusta media ecc ecc... --> Nulla di risolto
Allora ho provato tante altre modifiche, ma senza raggiungere mai buoni risultati, anzi ho addirittura incontrato un NUOVO problema, ovvero:
Facendo consecutivamente tante letture analogiche di porte DIVERSE, alcune letture (le prime) di ogni pin vengono influenzate dalla lettura precedene del pin precedente in quanto (se ho ben capito) la parte che si occupa di effettuare la lettura analogica, per farlo, carica un condensatore che quindi va a falsare la lettura del prossimo pin, specialmente se le tensioni sono molto simili..
io in particolare con lo sketch eseguivo nei 20ms le letture così:
A1, A2, A3, A4, A5, A1, A2, A3, A4, A5, e cosi via quindi l'ADC cambiava la porta ad ogni lettura falsando quindi TUTTE le letture...
Seguendo un consiglio ottenuto sul forum di arduino, ho provato il seguente codice:
do
{
numeroCampionamenti++;
//offsetValue è la lettura senza carico quindi lo sottraiamo alle letture dei sensori
offsetValue = analogRead(offsetPin);
offsetValue = analogRead(offsetPin);
sensorTotValue = analogRead(sensorTotPin);
sensorTotValue = analogRead(sensorTotPin) - offsetValue;
sensorCucinaValue = analogRead(sensorCucinaPin);
sensorCucinaValue = analogRead(sensorCucinaPin) - offsetValue;
sensorStanzeValue = analogRead(sensorStanzePin);
sensorStanzeValue = analogRead(sensorStanzePin) - offsetValue;
sensorBagniValue = analogRead(sensorBagniPin);
sensorBagniValue = analogRead(sensorBagniPin) - offsetValue;
//20 sono i millisecondi che verranno campionati
while ((millis() - inizioCampionamenti) < 20);
che avrebbe dovuto effettuare una lettura a vuoto per ogni pin analogico per avere la seconda lettura più precisa, ma avevo sempre problemi con le letture..
In preda alla disperazione, o forse colto da un improvvisa ispirazione, ho pensato che la strada giusta fosse quella di fare tante letture consecutive per ogni pin e POI cambiare e leggere il successivo, così ho riscritto la parte delle letture così:
//###################
//LETTURA SENSORI ###
//###################
//Lettura dati dei sensori e calcolo della corrente assorbita e dei consumi in watt
sensorTotValue = 0;
sensorCucinaValue = 0;
sensorStanzeValue = 0;
sensorBagniValue = 0;
offsetValue = 0;
//SENSORE BAGNI
numeroCampionamenti = 0;
inizioCampionamenti = millis() ;
do
{
numeroCampionamenti++;
sensorBagniValue += analogRead(sensorBagniPin);
}
//20 sono i millisecondi che verranno campionati per ogni sensore
while ((millis() - inizioCampionamenti) < 20);
sensorBagniValue /= numeroCampionamenti;
//SENSORE STANZE
numeroCampionamenti = 0;
inizioCampionamenti = millis() ;
do
{
numeroCampionamenti++;
sensorStanzeValue += analogRead(sensorStanzePin);
}
//20 sono i millisecondi che verranno campionati per ogni sensore
while ((millis() - inizioCampionamenti) < 20);
sensorStanzeValue /= numeroCampionamenti;
//SENSORE CUCINA
numeroCampionamenti = 0;
inizioCampionamenti = millis() ;
do
{
numeroCampionamenti++;
sensorCucinaValue += analogRead(sensorCucinaPin);
}
//20 sono i millisecondi che verranno campionati per ogni sensore
while ((millis() - inizioCampionamenti) < 20);
sensorCucinaValue /= numeroCampionamenti;
//SENSORE TOTALE
numeroCampionamenti = 0;
inizioCampionamenti = millis() ;
do
{
numeroCampionamenti++;
sensorTotValue += analogRead(sensorTotPin);
}
//20 sono i millisecondi che verranno campionati per ogni sensore
while ((millis() - inizioCampionamenti) < 20);
sensorTotValue /= numeroCampionamenti;
//OFFSET
numeroCampionamenti = 0;
inizioCampionamenti = millis() ;
do
{
numeroCampionamenti++;
//offsetValue è la lettura senza carico che poi sottraiamo alle letture dei sensori
offsetValue += analogRead(offsetPin);
}
//20 sono i millisecondi che verranno campionati per ogni sensore
while ((millis() - inizioCampionamenti) < 20);
offsetValue /= numeroCampionamenti;
sensorTotValue -= offsetValue;
sensorCucinaValue -= offsetValue;
sensorStanzeValue -= offsetValue;
sensorBagniValue -= offsetValue;
//Alcune differenze potrebbero avere valore negativo per cui noi consideriamo il valore assoluto
sensorTotValue = abs(sensorTotValue);
sensorCucinaValue = abs(sensorCucinaValue);
sensorStanzeValue = abs(sensorStanzeValue);
sensorBagniValue = abs(sensorBagniValue);
//Per ottenere gli ampere reali moltiplichiamo la media di ampere letti nei 20ms per 0.166 che è il fattore di conversione calcolato con un carico noto
ampereTot = sensorTotValue * fattoreConversione;
ampereCucina = sensorCucinaValue * fattoreConversione;
ampereStanze = sensorStanzeValue * fattoreConversione;
ampereBagni = sensorBagniValue * fattoreConversione;
//Infine moltiplichiamo gli ampere per la tensione stabilita per ottenere il consumo in Watt
consumoTot = ampereTot * tensione;
consumoCucina = ampereCucina * tensione;
consumoStanze = ampereStanze * tensione;
consumoBagni = ampereBagni * tensione;
Con 5 cicli do-while (1 per ogni porta analogica) ho ottenuto finalmente dei bei 0 (o valori comunque bassi e accettabili) in condizioni di NIENTE CARICO, cosa STRANA invece in condizioni di carico dove leggo si un consumo ma BASSO rispetto all'assorbimento di utilizzatori NOTI..(esempio un phon da max 1800 watt me lo leggeva 160watt)
Facendo di nuovo prove sul TEMPO DI CAMPIONAMENTO, ho provato ad abbassarlo per tutti e 5 i cicli do-while da 20ms a 10ms e magicamente spunta il consumo VERO... ma ancora con un altro problema:
il consumo è letto ad intervalli (esempio): phon max 1800watt acceso, il consumo Totale mi mostra 1750watt (ok) dopo 1 secondo mi dice 1780watt (ok) dopo ancora mi dice 1740watt (ok) dopo mi dice di colpo 500watt e dopo magari riprende con valori attendibili ma sempre con un valore nettamente inferiore in mezzo..
altro esempio: consumo STANZE con 1 pc acceso, qualche tv in preaccensione, modem, switch ecc ecc mi da 160 watt circa (ci può stare) poi 190 poi 200 ma ogni tanto mi dice 30!
Ho provato ad abbassare ulteriormente e poi anche ad aumentare oltre i 20ms il tempo di campionamento, ma i risultati peggioravano addirittura...
Diciamo che rispetto all'inizio non ho più le letture fantasma ma ho sempre qualche problemino.. sono sicuro che mi sfugge qualcosa, ma non so cosa, per cui chiedo aiuto a Voi...
Che mi consigliate ?
Pages: 
Voltmetro, Amperometro, Wattmetro, Contatori Assor (Read 194854 times)
