Grazie ma non sono molto ferrato in elettronica potresti farmi uno schema dove dovrei mettere i puntali del tester per misurare tensione e corrente
scusami credo di aver capito
misuro tra il filo che  va sul pin gnd e il filo che va sul pin a3  mi dovrebbe dare 3 v       
gnd a2  2.5v  sempre sul filo
gnd  a1 2.5v


giusto o ho detto un altra cazz

Ora  sto lavorando :construction.gif: alle 22 sono a casa provo e ti faccio sapere subito i valori
comunque sei mmmmmmmmmolto gentile mi stai aiutando tantissimo in questo progetto  è spero che tutto ciò che sto sperimentando sia utile a qualcuno che come me per paura di sbagliare non lo realizza
tutto questo  grazie a te Elettro

Ciao ragazzi,
ho visto sullo sketch di 5a2v0 una parte di codice che sembra calcoli
in automatico l'offset.
non ho capito pero cosa ha integrato nel pin per far questo.
a seguire uno stralcio...

void loop() {
  //##################
  //CHECK INIZIALE ###
  //##################
  //Eseguo solo una volta all'accensione delle letture a vuoto per l'assestamento dei valori ottenuti dal sensore di corrente
  if (sensorTest == 0) {
    do {
      offsetValue = analogRead(offsetPin);
      sensorTotValue = analogRead(sensorTotPin);
      lcd.setCursor(0,0);
      lcd.print("Check in corso...");
      lcd.setCursor(0,1);
      //Calcolo e scrivo una percentuale sul display in relazione alla seguente equazione
      //5000 : 100% = millis() : x %
      lcd.print(millis() / 50);
      lcd.print("% ");
    }
    //Sono necessari circa 5 secondi affinchè le letture si stabilizzino
    while(millis() < 5000);
    //Note di fine check e test funzionamento buzzer
    tone(buzzer, 4699, 125);
    delay(160);
    noTone(buzzer);
    tone(buzzer, 4699, 125);
    delay(160);
    noTone(buzzer);
    //Azzero la variabile utilizzata in fase di check e specifico che il test iniziale è concluso
    sensorTotValue = 0;
    sensorTest = 1;
    delay(1000);
  }
  //###################
  //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;
  numeroCampionamenti = 0;
  inizioCampionamenti = millis() ;
  do
  {
    numeroCampionamenti++;
    //offsetValue è la lettura senza carico quindi lo sottraiamo alle letture dei sensori
    offsetValue = analogRead(offsetPin);
    sensorTotValue = analogRead(sensorTotPin);
    sensorCucinaValue = analogRead(sensorCucinaPin);
    sensorStanzeValue = analogRead(sensorStanzePin);
    //Codice per eventuale controllo dei valori letti
    //Serial.println("OFFSET");
    //Serial.println(offsetValue);
    //Serial.println("SENSORE");
    //Serial.println(sensorTotValue);
    //Serial.println("---------");
    sensorTotValue = (sensorTotValue - offsetValue);
    sensorCucinaValue = (sensorCucinaValue - offsetValue);
    sensorStanzeValue = (sensorStanzeValue - offsetValue);
    //Alcune letture potrebbero avere valore negativo per cui noi consideriamo il valore assoluto
    ampereTot+= abs(sensorTotValue);
    ampereCucina+= abs(sensorCucinaValue);
    ampereStanze+= abs(sensorStanzeValue);
  }
  //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;
  //Infine moltiplichiamo gli ampere per la tensione stabilita per ottenere il consumo in Watt
  consumoTot = ampereTot * tensione;
  consumoCucina = ampereCucina * tensione;
  consumoStanze = ampereStanze * tensione;

 

mi spiegate il ragionamento dietro questo principio?

tnx

ciao eolo,
attendo anche io un intervento di aiuto,
sono alla prova di controllo voltaggio ma i
valori mi sballano troppo e non ho certezza che sia
la logica dello sketch o il partitore non efficiente.

ho letture sfalsate nel senso che il valore del sensore non è costante
ma sale e scende durante la lettura in un ciclo for di 1000 campionamenti
di tutta l onda sinusoidale.
sembra che abbia risolto con un pezzo di codice che è in prima pagina qui.

if (Tensionepicco < Tensioneinst) Tensionepicco = Tensioneinst;

 

questo lo rende stabile.

pero ho dubbi vari su partitore, offset e varie.

vediamo se piano piano qualcuno di aiuta.

CITAZIONE (iannez, 19/05/2015 13:59:33 ) Quote:


Certo che è fattibile,ma non ho niente di pronto(ho perso i codici).

Ti spiego a grandi linee come fare.
LINK
Il progetto linkato è l'evoluzione del Powermeter.
Come vedi sia la corrente che la tensione hanno un offset di circa 2.5V.
Dico circa perchè è normale che tale valore sia leggermente maggiore o inferiore.

Ad inizio progetto avevo scelto il calcolo software dell'offset ,ma non avevo ottenuto la qualità che mi ero preposto.

Quindi ho scelto una strada ancora più semplice:
-per ogni segnale uso due ingressi analogici,uno sul partitore che genera l'offset e uno all'uscita sensore.

In pratica (metodo semplificato):
-leggo i valori degli offset (basta una volta ad inizio semionda)
-eseguo un ciclo while per un tempo di 20mS (una semionda)
-eseguo misure ripetitive e tengo in memoria il numero di letture
-terminati i 20mS calcolo tutti i valori

Per una migliore precisione si potrebbe impostare un timer che si preoccupa di campionare con una sequenza costante gli ingressi ,ma non è necessario.


Codice NON TESTATO
//---------------------------------------------------

int TensioneOffsetPin = A0;
int CorrenteOffsetPin = A1;    
int TensionePin = A2; 
int CorrentePin = A3;
int Fattore_Conversione_Tensione = 1; //da calcolare
int Fattore_Conversione_Corrente = 1; //da calcolare

float Tensionemax ;
float Tensionemin ;
float TensioneRMS ;
float CorrenteRMS ;
float PotenzaAttiva;
float PotenzaApparente;
float FattorediPotenza;
float SommaV;
float SommaI;
float SommaP;


void setup() {
  ADCSRA&=0X90+ 0b100; //Setta ADC prescaler a 16
}

void loop() {
int NumCampionamenti = 0;
int OffsetTensione = analogRead(TensioneOffsetPin);
int OffsetCorrente = analogRead(CorrenteOffsetPin);
unsigned long start = micros() ;
while (micros() < (start + 20000)){ 
float Tensioneinst = (analogRead(TensionePin)-OffsetTensione)*Fattore_Conversione_Tensione;
float Correnteinst = (analogRead(CorrentePin)-OffsetCorrente)*Fattore_Conversione_Corrente;

if ( Tensionemax < Tensioneinst ) Tensionemax=Tensioneinst;
if ( Tensionemin > Tensioneinst ) Tensionemin=Tensioneinst;


SommaV += pow(Tensioneinst,2);
SommaI += pow(Correnteinst,2);
SommaP += (Tensioneinst*Correnteinst);
NumCampionamenti++;
} 

TensioneRMS = sqrt(SommaV / NumCampionamenti);
CorrenteRMS = sqrt(SommaI / NumCampionamenti);
if (CorrenteRMS < 0.10) {//soglia minima
CorrenteRMS=0;
SommaP=0;}
PotenzaAttiva = SommaP/ NumCampionamenti;
PotenzaApparente = TensioneRMS * CorrenteRMS;
FattorediPotenza = PotenzaAttiva/PotenzaApparente;            
}


//------------------------------------------------------

Ciao
Elettro

:clap.gif: Bellissimo .
Se implementi il codice sopra postato ,potrai misurare anche potenza attiva - reattiva e apparente ,oltre al cosfi

Le modifiche hardware non sono difficili (vista l'opera che hai realizzato)
Se ho tempo (e non ne ho) disegno il nuovo schema del PowerMeter Enhanced