Se sei già registrato           oppure    

Orario: 29/03/2024 13:31:46  

 

Energia Alternativa ed Energia Fai Da Te > Applicazioni E Realizzazioni Pratiche

VISUALIZZA L'ALBUM

Pagine: (18)   1   2   3   4   5   6   7   8   9   [10]   11   12   13   14   15   16   17   18    (Ultimo Msg)


Voltmetro, Amperometro, Wattmetro, Contatori Assorbimento
FinePagina

ElettroshockNow

Avatar
GigaWatt


Gruppo:Utente
Messaggi:4656

Stato:



Inviato il: 09/02/2014 17:54:42

Hai ragione.
Maggiore sara' il fondoscala e minore sara' la sensibilità.
Però se il problema è aumentare la sensibilità con basse correnti puoi amplificare il segnale del sensore e usare un secondo ingresso analogico.
In pratica avrai due sensibilità con due fondi scala.
Il circuito è realizzabile con un semplice operazionale e puoi prendere spunto del circuito da questo....LINK
Ciao
ElettroshockNow



Modificato da ElettroshockNow - 09/02/2014, 18:09:36
 

5a2v0
Watt


Gruppo:Utente
Messaggi:66

Stato:



Inviato il: 18/03/2014 20:08:18

CITAZIONE (ElettroshockNow, 09/02/2014 17:54:42 ) Discussione.php?53671885&9#MSG133

CITAZIONE (ciccioro, 09/02/2014 10:02:01 ) Discussione.php?53671885&9#MSG130
Salve ho visto questo progetto simpatico per la regolazione dei carichi di casa
possibile capire dove si trova lo schema
sono nuovo e anche scompetente mi aiutate?
Grazie anticipatamente

Il progetto di 5a2v0 non è stato fornito di schema di collegamenti,ma lo puoi estrapolare dal listato che ha condiviso nella pagina precedente.
Ciao


Oltre al fatto che vedendo che "funziona" quello che ho già, pur sapendo che lo posso migliorare mi sono un po cullato sugli allori...
Sono stato inoltre preso da altri "purtroppo troppi" progetti che ho in corso ma non ho assolutamente abbandonato...anzi !!! XD

Ho addirittura acquistato un Arduino Yun per sperimentare qualcosa di aggiuntivo per il mio progetto. In particolare sin ora ho fatto:

- Preso Arduino Yun;

- Comprato e collegato un lcd più grande (20x4) al posto del 16x2 precedente e l'ho collegato tramite adattatore seriale (interfaccia I2C) cosi da usare solo 2 pin digitali anzichè 6 !!!

- Attualmente montati ho 3 sensori SCT-013-030 e ne ho un 4° (e ultimo penso) in arrivo...

Ho in parte modificato lo sketch, in modo che grazie alle potenzialità di Arduino Yun, io possa collegarmi da casa e da fuori casa ad una pagina web che gira su Arduino (connesso al router tramite wifi presente su YUN) e visualizzare i consumi in qualsiasi momento.

I sensori sono diventati 4 perchè oltre a leggere il consumo totale, voglio leggere anche i consumi nelle sezioni "cucina, bagni e stanze".
Cosi posso staccare quella che effettivamente consuma piuttosto di andare secondo una logica prestabilita (priorità da me assegnate) che magari mi stacca una sezione con consumo basso/bassimo/zero...

Per ora Yun è montato su breadboard in modo che testo le varie funzioni che vado scrivendo (anche se ho esaurito lo spazio per gli sketch e devo "pulire" il codice fatto fin ora).

Appena mi sento "pronto" stacco la cassetta con Arduino Uno e ci trasferisco dentro lo Yun... vi terrò informati

 

supermomo717
Watt


Gruppo:Utente
Messaggi:68

Stato:



Inviato il: 18/04/2014 14:36:34

Il progetto di questo misuratore è veramente notevole e infatti sto aspettando mi arrivi il materiale per poterlo realizzare. Quello che mi piace in modo particolare è il poter gestire le uscite in funzione dei carichi misurati e delle soglie impostate.
Tuttavia, sempre se riesco a farlo funzionare, vorrei provare una soluzione, che potrebbe risolvermi diverse problematiche inerenti agli utilizzatori e la loro ubicazione. Ma vi spiego meglio il motivo e cosa vorrei ottenere ...
Il motivo principale è che mi piacciono le cose pulite e funzionali e non per ultimo, mi sono chiesto che cosa posso fare se conosco i consumi della mia casa, se conosco la produzione del mio FV ma non posso gestire i miei carichi se non in prossimità di Arduino?
Ho visto dei blog dove degli smanettoni di arduno sono riusciti a controllare delle "prese telecomandate" (facilmente ed economicamente recuprabili) direttamente con il modulo 433 mhz, inviando alle prese dei segnali di accensione/spegnimento, operando una sorta di "emulazione" del telecomando originale. Il tutto quindi andrebbe ad impegnare una sola uscita digitale di arduino ma quello che è veramente il plus della cosa è che non siamo vincolati dai fili.
In pratica potrei decidere di accendere un utilizzatore in una stanza superata una certa soglia, accendere un condizionatore o pompa di calore in una diversa oltre la successiva soglia e così via.
Qundi andrei a sperimentare per prima cosa il lavoro fatto da ElettroshockNow e da quanti hanno cooperato e sfruttare il lavoro fatto da altri di cui vi parlavo e provare a metterli insieme. Io di mio non ho queste capacità di scrivere codice anche perchè lo sto cercando di imparare ma sono alle prime armi e dunque mi destreggio nel copia/incolla.
Dite che arduino posso avere le risorse per gestire questo ulteriore carico di lavoro?
Buona Pasqua!

 

ElettroshockNow

Avatar
GigaWatt


Gruppo:Utente
Messaggi:4656

Stato:



Inviato il: 18/04/2014 15:47:19

CITAZIONE (supermomo717, 18/04/2014 14:36:34 ) Discussione.php?53671885&10#MSG137

Io di mio non ho queste capacità di scrivere codice anche perchè lo sto cercando di imparare ma sono alle prime armi e dunque mi destreggio nel copia/incolla.
Dite che arduino posso avere le risorse per gestire questo ulteriore carico di lavoro?
Buona Pasqua!

Allora siamo in due.
Se vedi i miei codici fanno pena ,ma funzionano .

Arduino ? ... Lo può fare tranquillamente ....
Devi però recuperare il protocollo che usano le prese ... dobbiamo sapere che lingua parlano

BUONA PASQUA

 

supermomo717
Watt


Gruppo:Utente
Messaggi:68

Stato:



Inviato il: 19/05/2014 14:48:43

Ho fatto un po diverso del lavoro che avevo in mente. Ho modificato il codice del ricevente e ho realizzato un PowermeterRemo. In pratica arrivando tutti i dati belli e pronti dall'arduino Master, ho lavorato con le variabili IF ELSE per gestire le uscite esattamente come sul powermeter.Adesso però dispongo di molte uscite e direttamente nel loco di utilizzo, svincolandomi dai fili. Se qualcuno vuole il codice client remoto lo posso postare se ElettroshockNow acconsente in quanto la creatura è sua, io l'ho solo adattata alle mie esigenze.

 

ElettroshockNow

Avatar
GigaWatt


Gruppo:Utente
Messaggi:4656

Stato:



Inviato il: 19/05/2014 15:12:28

CITAZIONE (supermomo717, 19/05/2014 14:48:43 ) Discussione.php?53671885&10#MSG139

Se qualcuno vuole il codice client remoto lo posso postare se ElettroshockNow acconsente in quanto la creatura è sua, io l'ho solo adattata alle mie esigenze.

Ci mancherebbe che devo dare il consenso violerebbe il mio modo di essere ...
e poi .... vedere il progetto evolversi e migliorarsi mi fà solo piacere .

 

supermomo717
Watt


Gruppo:Utente
Messaggi:68

Stato:



Inviato il: 03/06/2014 23:12:07

Perdonate la poca esperienza ma ho cercato comunque di fare del mio meglio.
Stuzzicato dal progetto che ElettroshockNow ha presentato in questo 3d, ho voluto realizzare un ricevitore che accoppiato al trasmettitore Powermeter3_5 potesse permettermi di godere di maggiore "libertà di movimento", in pratica avere le uscite da gestire non vincolate fisicamente (fili) al ricevitore stesso.
Modificando il codice del ricevitore che ElettroshockNow ha gentilmente offerto alla community, me lo sono personalizzato come dicevo, facendolo diventare un aggieggino simpatico da tenere anche in vista per gli ospiti, dipende da quanto siete "artistici" e fantasiosi.
Veniamo al dunque con le caratteristiche:
- Niente fili dei sensori, quindi trasportabile dove volete compatibilmente con le prestazioni dei piccoli moduli wireless.
- Numero uscite a piacere, anche se 2 mi sono più che sufficienti.
- Niente display, solo indicatore a led di veloce lettura della potenza monitorata.
- Led che informa la corretta ricezione dei segnale del TX
- Led che informa che la produzione FV è minore del consumo domestico.
- 2 Tasti, Up e Down per modifica delle soglie impostate senza bisogno di pc.
- Led indicatore ad impulsi (ogni impulso sono 100 watt) di quanto è impostata la nuova soglia una volta modificata.
- Introduzione di un misuratore di intervallo di tempo prima che le uscite vengano disattivate al raggiungimento della soglia di spegnimento impostata.

Il lavoro grosso è svolto naturalmente dal TX mentre questo ricevitore elabora solamente i dati che riceve e opera di conseguenza.

Mettendo mano allo sketch potete fare qualsiasi cosa; la cosa più difficile? capire cosa si vuole fare.



CITAZIONE



/* Progetto RemoteRice Powermeter 1.2
    "" Energia Alternativa & Energia Fai Da Te ""
  http://www.energialternativa.info/
  Ricevitore personalizzato da Supermomo717 per PowerMeter_TX3_5 realizzato da ElettroshockNow.
  Si tratta di un sistema remoto per gestione uscite , 2 in questo caso.
  Il Ricevitore Remote Powermeter 1.2, rielavora i valori ricevuti dal PowerMeter_TX3_5
  e ne gestisce i carichi, collegati. 
  - Introdotti 4 Led di controllo della potenza che si desidare monitorare, con soglie a 
  diversi valori impostabili.
  - Introdotto Led di avviso ricezione segnale da TX
  - Introdotto intervallo di tempo antecedente lo spegnimento a raggiungimento una determinata soglia (per ovviare al problema che
  un carico in avvio possa far leggere al ricevitore un raggiungimento di sottosoglia e staccare 
  l'uscita al momento in cui il carico stesso dovrebbe avviarsi).
  - Introdotti pulsanti per aumento delle soglie di accensione e spegnimento.
  */

#include 

const int Uscita2 = 12; //assegnazione pin uscita 2
const int Uscita1 = 10; //assegnazione pin uscita 1
const int LedNegativo = 9; //assegnazione pin uscita led consumo da rete
const int Led1 = 8; //assegnazione pin led1
const int Led2 = 7; //assegnazione pin led2
const int Led3 = 6; //assegnazione pin led3
const int Led4 = 5; //assegnazione pin led4
const int LedControllo = 4; //assegnazione pin led controllo segnale e soglie
const int PulsanteUp = 3; // pulsante aumento soglie
const int PulsanteDown = 2; //pulsante diminuzione soglie


const int ledPin = 13; //pin del led per controllo segnale da scheda
int a=0; // usata per impulsi al led quando cambio le soglie
int b=0; // contatore degli impulsi al led per cambio soglie
int ledState = LOW; // ledState usato per settare il led
long previousMillis = 0; //conteggio per led quando c'è verifica segnale
long interval = 100;


int statoPulsanteUp = 0;
int statoPulsanteDown = 0;

byte monitor = 1;

int Uscita_1_ON ;
int Uscita_1_Time_On ;
int Uscita_1_Time_Off ;
unsigned long TUscita1in = 0;
unsigned long TUscita1out = 0;
int Uscita_1_OFF ;

int Uscita_2_ON ;
int Uscita_2_Time_On;
int Uscita_2_Time_Off ;
unsigned long TUscita2in = 0;
unsigned long TUscita2out = 0;
int Uscita_2_OFF;

int Led1_On;
int Led2_On;
int Led3_On;
int Led4_On;


int PotenzaMon;//Potenza da Monitorare

int Tensione;
int PotenzaPro;
int PotenzaAss;
float CorrentePro;
float CorrenteAss;
float TotalePro;
float TotaleAss;

void setup()
{
  
  //aggiunta dami
  pinMode(Uscita1, OUTPUT);
  digitalWrite(Uscita1, LOW);
  pinMode(Uscita2, OUTPUT);
  digitalWrite(Uscita2, LOW);
  pinMode(LedControllo, OUTPUT);
  digitalWrite(LedControllo, LOW);
  pinMode(LedNegativo, OUTPUT);
  digitalWrite(LedNegativo, LOW);
  pinMode(Led1, OUTPUT);
  digitalWrite(Led1, LOW);
  pinMode(Led2, OUTPUT);
  digitalWrite(Led2, LOW);
  pinMode(Led3, OUTPUT);
  digitalWrite(Led3, LOW);
  pinMode(Led4, OUTPUT);
  digitalWrite(Led4, LOW);
  
  pinMode(PulsanteUp, INPUT);
  pinMode(PulsanteDown, INPUT);
  
  pinMode(ledPin, OUTPUT);
  
  monitor = 3; //Potenza da monitorare 1=prodotta - 2=assorbita - 3 = prodotta-assorbita - 4= assorbia-prodotta

    Uscita_1_ON = 800; //Accendi a XXX Watt
    Uscita_1_Time_On = 20; //Accendi dopo TOT secondi raggiunti XXX Watt
    Uscita_1_Time_Off = 10; //Spegni dopo TOT secondi raggiunti YYY Watt
    Uscita_1_OFF = 0; //Spegni a YYY Watt
    Uscita_2_ON = 2000; //Accendi a xxx Watt
    Uscita_2_Time_On = 5; //Accendi dopo tot secondi raggiunti xxx Watt
    Uscita_2_Time_Off = 5; //Spegni dopo tot secondi raggiunti yyy Watt
    Uscita_2_OFF = 1000 ; //Spegni a yyy Watt
    
    //Parte visiva
    Led1_On = 250; //Accendi led 1 superati determinati watt
    Led2_On = 500; //Accendi led 2 superati determinati watt
    Led3_On = 750; //Accendi led 3 superati determinati watt
    Led4_On = 1000; //Accendi led 4 superati determinati watt
  
  
Serial.begin(9600); // Debugging only
Serial.println("setup");

// Initialise the IO and ISR
vw_set_ptt_inverted(true); // Required for DR3100
vw_setup(2000); // Bits per sec

vw_rx_start(); // Start the receiver PLL running
}

void loop()
{
  statoPulsanteUp = digitalRead(PulsanteUp);
  statoPulsanteDown = digitalRead(PulsanteDown);
  
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;

if (vw_get_message(buf, &buflen)) // Non-blocking
{
  
  // parte relativa al lampeggio del led di controllo quando RX ha segnale da TX
  unsigned long currentMillis = millis();
 
  if(currentMillis - previousMillis > interval) {
    // save the last time you blinked the LED
    previousMillis = currentMillis;   

    // if the LED is off turn it on and vice-versa:
    if (ledState == LOW)
      ledState = HIGH;
    else
    
      ledState = LOW;
    // set the LED with the ledState of the variable:
    digitalWrite(LedControllo, ledState); // originale è ledPin per lampeggio led 13 su Arduino
     
/*
int i;
digitalWrite(13, true); // Flash a light to show received good message
// Message with a good checksum received, dump it.
Serial.print("Got: ");

for (i = 0; i < buflen; i++)
{
Serial.print(buf[i], DEC);
Serial.print(" ");
}
*/
Tensione = buf[1];
PotenzaPro = (int(buf[3]<<8)+buf[2]);
PotenzaAss = (int(buf[5]<<8)+buf[4]);
CorrentePro = float(int(buf[7]<<8)+buf[6])/100;
CorrenteAss = float(int(buf[9]<<8)+buf[8])/100;
TotalePro = float(long(buf[12]<<16)+int(buf[11]<<8)+buf[10])/10;
TotaleAss = float(long(buf[15]<<16)+int(buf[14]<<8)+buf[13])/10;

/*
Serial.write ("Tensione= ");
Serial.print(Tensione);
Serial.println(" Volt");
Serial.write ("Potenza Assorbita= ");
Serial.print(PotenzaAss);
Serial.println(" Watt");
Serial.print ("Potenza Prodotta= ");
Serial.print(PotenzaPro);
Serial.println(" Watt");
Serial.write ("Corrente Assorbita= ");
Serial.print(CorrenteAss);
Serial.println(" Amper");
Serial.write ("Corrente Prodotta= ");
Serial.print(CorrentePro);
Serial.println(" Amper");
Serial.write ("Totale Consumata= ");
Serial.print(TotaleAss);
Serial.println(" Kwh");
Serial.write ("Totale Prodotta= ");
Serial.print(TotalePro);
Serial.println(" Kwh");
*/

Serial.write ("Registro una Potenza Prodotta di ");
Serial.print(PotenzaPro);
Serial.write (" Watt");
Serial.println("");
Serial.write ("Registro una Potenza Assorbita di ");
Serial.print(PotenzaAss);
Serial.write (" Watt");
Serial.println("");
Serial.write ("Immetto in rete una Potenza di ");
Serial.print(PotenzaMon);
Serial.write (" Watt");
Serial.println("");
Serial.write ("Accensione Uscita 1 Impostata a ");
Serial.print(Uscita_1_ON);
Serial.println("");
Serial.write ("Spegnimento Uscita 1 Impostata= ");
Serial.print(Uscita_1_OFF);
Serial.println("");
Serial.write ("Accensione Uscita 2 Impostata a ");
Serial.print(Uscita_2_ON);
Serial.println("");
Serial.write ("Spegnimento Uscita 2 Impostata= ");
Serial.print(Uscita_2_OFF);
Serial.println("");
Serial.write ("Totale Prodotta= ");
Serial.print(TotalePro);
Serial.println(" Kwh");
Serial.println("");



//Serial.println("");
digitalWrite(13, false);

switch (monitor){ //Non modificare sopra non qui. Selettore potenza da monitorere
              case 1:
                PotenzaMon=PotenzaPro;
              break;
              case 2:
                PotenzaMon=PotenzaAss;
              break;
              case 3:
                PotenzaMon=PotenzaPro-PotenzaAss;
              break;
              case 4:
                PotenzaMon=PotenzaAss-PotenzaPro;
              break;
            }    
            if (PotenzaMonmillis();
  else if (millis()>(Uscita_1_Time_On*1000+TUscita1in)) digitalWrite(Uscita1,HIGH);
          if (PotenzaMon>Uscita_1_OFF) TUscita1out=millis();
  else if (millis()>(Uscita_1_Time_Off*1000+TUscita1out)) digitalWrite(Uscita1,LOW);

  
            if (PotenzaMonmillis();
  else if (millis()>(Uscita_2_Time_On*1000+TUscita2in)) digitalWrite(Uscita2,HIGH);
            if (PotenzaMon>Uscita_2_OFF) TUscita2out=millis();
  else if (millis()>(Uscita_2_Time_Off*1000+TUscita2out)) digitalWrite(Uscita2,LOW);
  
     
  if (PotenzaMon>Led1_On) digitalWrite(Led1,HIGH);
  else digitalWrite(Led1,LOW);
  
  if (PotenzaMon>Led2_On) digitalWrite(Led2,HIGH);
  else digitalWrite(Led2,LOW);
  
  if (PotenzaMon>Led3_On) digitalWrite(Led3,HIGH);
  else digitalWrite(Led3,LOW);
  
  if (PotenzaMon>Led4_On) digitalWrite(Led4,HIGH);
  else digitalWrite(Led4,LOW);
  
 if (PotenzaAss>PotenzaPro) digitalWrite(LedNegativo,HIGH);
 else digitalWrite(LedNegativo,LOW);
  
}
// parte relativa ai tasti di modifica soglie intervento
}
if (statoPulsanteUp == LOW){
  Serial.print("Aumento Soglie Intervento, accensione Uscita 1 a ");
  Uscita_1_ON = Uscita_1_ON + 100;
  Uscita_2_ON = Uscita_2_ON + 100;
  Uscita_1_OFF = Uscita_1_OFF + 100;
  Uscita_2_OFF = Uscita_2_OFF + 100;
  Serial.print(Uscita_1_ON);
  Serial.print(" e uscita 2 a ");
  Serial.print(Uscita_2_ON);
  delay(500);
  while (b  {digitalWrite(LedControllo, HIGH);
  delay(300);
  digitalWrite(LedControllo, LOW);
  delay(300);
  b++;
  }
  
    b=0;
  }
     
  else if (statoPulsanteDown == LOW){
  Serial.print("Diminuzione Soglie Intervento, accensione Uscita 1 a ");
  Uscita_1_ON = Uscita_1_ON - 100;
  Uscita_2_ON = Uscita_2_ON - 100;
  Uscita_1_OFF = Uscita_1_OFF - 100;
  Uscita_2_OFF = Uscita_2_OFF - 100;
  Serial.print(Uscita_1_ON);
  Serial.print(" e uscita 2 a ");
  Serial.print(Uscita_2_ON);
  delay(500);
  while (b  {digitalWrite(LedControllo, HIGH);
  delay(300);
  digitalWrite(LedControllo, LOW);
  delay(300);
  b++;
  

b=0;

}





Modificato da supermomo717 - 03/06/2014, 23:16:00
 

5a2v0
Watt


Gruppo:Utente
Messaggi:66

Stato:



Inviato il: 16/07/2014 11:15:19

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 ?

 

ElettroshockNow

Avatar
GigaWatt


Gruppo:Utente
Messaggi:4656

Stato:



Inviato il: 16/07/2014 20:06:12

Ciao,
Misura a vuoto tutti gli input , probabilmente l'offset è diverso.
Se invece usi una tensione offset in comune per tutti i sensori devi necessariamente usare un operazionale per abbassare l'impedenza , altrimenti i sensori si disturbano a vicenda, in quesyo caso potrai usare un pin analogico per misurare tale valore e sottrarlo in tempo reale hai valori dei sensori.

A titolo di curiosità:
Visto che stai usando yun , testa anche quanti campionamenti riesce ad eseguire a periodo di default..



Modificato da ElettroshockNow - 16/07/2014, 20:56:51
 

5a2v0
Watt


Gruppo:Utente
Messaggi:66

Stato:



Inviato il: 17/07/2014 11:38:29

Attualmnte ho rimesso questo codice (che era quello che avevo preparato per yun prima ancora di montarlo, sulla base di quello che usavo per UNO):


  //###################
  //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);
  }
  while ((millis() - inizioCampionamenti) < 80);
  /*Serial.print(offsetValue);
  Serial.println(sensorTotValue);
  Serial.println(sensorCucinaValue);
  Serial.println(sensorBagniValue);
  Serial.println(sensorStanzeValue);
  Serial.println("-------------------");*/
  //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;


Che in fin dei conti mi da il problema minore, ovvero qualche lettura più alta del normale in assenza di carico...

Per completezza preciso che uso un partitore di tensione in comune per tutti i sensori e per l'offset ed effettuando prove sia con tester sia con sketch appositamete modificato, senza sensori collegati, il voltaggio arriva uguale ad ogni porta!

p.s. allego stavolta un (seppur elementare) schema fatto con Fritzing..

Andrò a cercare qualche info sugli "operazionali" che mi hai menzionato per vedere come funzionano e cercare di capire come posso usarlo nel mio caso..



Immagine Allegata: proto_yun.png
 
ForumEA/A/proto_yun.png


Scarica allegato

proto_yun_nowire.png ( Numero download: 355 )

 

ElettroshockNow

Avatar
GigaWatt


Gruppo:Utente
Messaggi:4656

Stato:



Inviato il: 17/07/2014 12:21:15

Occhio stai usando Vin ? è voluta ?
C'è il rischio di danneggiare gli ingressi analogici se lo alimenti dal jack DC.

Prova cosi'(vanno bene moltissimi operazionali )
http://www.energialternativa.info/public/newforum/ForumEA/B/Voffset.jpg
dovresti risolvere .

Se non hai la necessità di un gran fondo scala (visto che hai sezionato in 4 zone) potresti anche aumentare la sensibilità riducendo il valore di R3 portandolo ad esempio a 220 Ohm , oppure mantenendo gli attuali 100 Ohm far passare il filo due volte nel sensore.
http://www.energialternativa.info/public/newforum/ForumEA/B/y9y0.jpg

Ricordati di ricalcolare il fattore di conversione .....

Nuovo_fattore_di_conversione = Potenza_reale * Attuale_fattore_di_conversione /Potenza_letta

Ciao
Elettro



Modificato da ElettroshockNow - 17/07/2014, 12:35:58
 

5a2v0
Watt


Gruppo:Utente
Messaggi:66

Stato:



Inviato il: 17/07/2014 16:18:56

Alimento sia la shield sia arduino Yun tramite il Vin della shield.
Gli erogo 5.08v da un alimentatore stabilizzato..

Voluto perchè:

1) Yun non ha un regolatore di tensione per la linea dei 5v

2) Alimentando Yun dalla micro-USB, sul piedino della +5v si hanno 4,xx v in base all'assorbimento dei vari led, lcd, ecc che si hanno collegati allo Yun..

Per il discorso del fondo scala, è vero che io ho sezionato, ma uno dei sensori monitora il cavo in arrivo dal contatore enel, quindi il mio "Totale"..

Per gli operazionali, tu intendi che dovrei metterne uno solo prima del pin che mi misura l'offset? O che dovrei metterne uno per ogni porta analogica alla quale collego un sensore ?



Modificato da 5a2v0 - 17/07/2014, 16:40:19
 

ElettroshockNow

Avatar
GigaWatt


Gruppo:Utente
Messaggi:4656

Stato:



Inviato il: 18/07/2014 10:35:36

CITAZIONE (5a2v0, 17/07/2014 16:18:56 ) Discussione.php?53671885&10#MSG147

Alimento sia la shield sia arduino Yun tramite il Vin della shield.
Gli erogo 5.08v da un alimentatore stabilizzato.....

Chiarissimo ,non avrei mai pensato che avrebbero tolto il regolatore e ho ritenuto il Vin come il vecchio Uno .


CITAZIONE
Per il discorso del fondo scala, è vero che io ho sezionato, ma uno dei sensori monitora il cavo in arrivo dal contatore enel, quindi il mio "Totale"..

Puoi tranquillamente avere diversi fondi scala con diversi fattori di conversione.

CITAZIONE
Per gli operazionali, tu intendi che dovrei metterne uno solo prima del pin che mi misura l'offset? O che dovrei metterne uno per ogni porta analogica alla quale collego un sensore ?

Ne basta uno per tutti
In pratica la tensione di offset attuale la disconetti e la invii al pin + dell'operazionale e riprelevi la nuova tensione di offset (uguale come valore ) dal pin OUT e -.
Il tutto alimentandolo con i 5V e GND

 

5a2v0
Watt


Gruppo:Utente
Messaggi:66

Stato:



Inviato il: 18/07/2014 17:40:49

Ok, ma in pratica, usando l'operazionale in questo modo, l'offset sarà ancora più stabile, giusto?
Però non potrei comunque avere problemi dovuto al Sample&Hold dell'ADC che magari quando legge prima il sensore Bagni (supponiamo con un carico grosso) resti "carico" di quella tensione e quindi più del voltaggio dell' offset e quando poi legge il successivo sensore per esempio Stanze (supponiamo con un carico minimo o 0) venga restituito un consumo anche per Stanze ?


Io intanto per completezza posto 4 screenshot dell'app per Android che ho realizzato..

ForumEA/us/v2/280x200q90/674/30edcf.jpgForumEA/us/v2/280x200q90/661/e82164.jpg ForumEA/us/v2/280x200q90/540/a6961c.jpg ForumEA/us/v2/280x200q90/673/772fc4.jpg

 

ElettroshockNow

Avatar
GigaWatt


Gruppo:Utente
Messaggi:4656

Stato:



Inviato il: 18/07/2014 18:06:55

Molto molto bello

Io stò cercando di far funzionare Processing con Android .... ma per ora vince lui .

Per quanto riguarda l'offset ,essa deve essere una tensione di riferimento stabile immune da ciò che accade sui sensori.
Quindi qualsiasi valore misurino i sensori ,la tensione di offset non deve batter ciglio.
Per un solo sensore è sufficiente un partitore resistivo ,ma se vuoi un solo Voffset per tutti i sensori con la comodità di monitorarlo con un solo pin ,dovrai necessariamente usare un operazionale (soluzione più economica).
Altrimenti potresti anche usare un REF03Z oppure LT1019 2.5V (soluzione ancore più performante).
Io personalmente vistà la qualità del tuo operato opterei per la seconda

PS: qualche dritta per i programmi Android

 
 InizioPagina
 

Pagine: (18)   1   2   3   4   5   6   7   8   9   [10]   11   12   13   14   15   16   17   18    (Ultimo Msg)

Versione Mobile!

Home page       TOP100-SOLAR      Home page forum