Un saluto a tutti, con l'aiuto del forum vorrei riuscire pilotare l'inverter grid tie powerjack da 1200w già modificato con il firmware del grande ElettroshockNow.
Riassumo il mio impiantino ad isola composto attualmente da un banco batterie 12V (di recupero) caricate da un pannello da 185wp e un regolatore di carica mppt 30A che mi alimentano le luci a led di casa monitorato da arduino LINK.
L'idea è quella di far funzionare il grid tie una volta che le batterie sono cariche per non sprecare energia, per far questo vorrei deviare la potenza del pannello dall'ingresso del regolatore di carica verso l'inverter con un bel mosfet o igbt pilotato in pwm da un arduino uno. L'arduino avrebbe quindi il compito di misurare l'energia richiesta dai carichi di casa e di pilotare l'inverter.
Per rilevare la corrente assorbita dal carico vorrei usare il sensore a pinzetta che ha usato Elettro per i suoi progetti:

PS: Ora che ci penso visto che il firmware di Elettro per i lgrid tie prevede un potenziometro per regolare la potenza erogata, forse si potrebbe evitare di pilotare l'inverter con il mosfet, ma modulare un segnale fornito in uscita da arduino che simula il potenziometro. A tal fine ricordo di aver provato con successo tempo fa un potenziometro digitale collegato ad arduino...

Domande e suggerimenti sono ben accetti    ;)

Bello bello ...mi piace.

Per modulare la potenza di uscita ti basterà inviare una tensione continua al pin controllo da 0 a 5V.
-0V sarà inverter spento
-5V sarà inverter alla massima potenza (la massima impostata tramite Eeprom)

Per generare tale tensione puoi semplicemente usare il digitalWrite di Arduino e  porre un piccoli filtro rc in uscita.
Ora sto al cell e  quindi non posso essere tanto preciso ,ma una resistenza da 10K e un cond da 1uF dovrebbero essere sufficienti.
Calcola che la frequenza pwm di arduino (senza usare librerie esterne ) è circa 500Hz, quindi il filtro deve essere calcolato su tale valore .

Quindi con il digitalWrite puoi regolare la potenza in uscita con 255 step più che sufficienti al tuo scopo.

Le risorse necessarie sono praticamente nulle e possono essere richieste all'arduino che si preoccupa del tua pagina online .

Il problema nasce nel misurare la potenza assorbita e prodotta.

In quel caso devi dedicare un micro a tale scopo se vuoi avere la potenza attiva ,altrimenti puoi optare come nel progetto Powermeter in semplici letture (circa 1000 ) e fare la media.
In tal caso avrai solo una potenza apparente .

Cosa comporta ?

Per esperienza il cosfi risulta essere basso a basse potenze ,quindi è facile che con assorbimento di pochi watt (100-200) ci vuole poco per immettere in rete.
Io ancora misuro l'apparente ed ho risolto mettendo un gap di 150W.
Produco la potenza assorbita - 150W ....
Nella realtà a basse potenze sto al limite per immettere invece ad alte perdo 150W ....

Ciao
Elettro

Sempre preciso Elettro anche dal telefono. 
Come si misura la potenza attiva? Pensavo appunto di fare delle letture e ricavarne una media non va bene? Posso dedicare un altro arduino allo scopo di modulare la potenza dell'inverter e fare le letture di potenza senza problemi, forse però  potrei farlo fare a quello che invia i dati alla pagina web visto che ne fa una ogni 5 secondi, magari nel tempo morto può  calcolare  la potenza e pilotare il grid tie.
Intanto ho ordinato i sensori ;)

La potenza apparente è semplicemente V*I ,dove V è la tensione efficace e la I la corrente efficace .

La potenza attiva (quella conteggiata dai contatori) è  la radice quadrata della media dei  prodotti V * I istantanei.

Quindi bisogna misurare tensione e corrente istantaneamente.

Dopo ogni lettura (che per arduino senza modifiche sui registri è 100uS x numero ingressi) bisogna   tensione con la  corrente ed elevarlo al quadrato.
Alla lettura successiva ripetere l'operazione sommando il risultato con il primo .
E così via fino a raggiungere il tempo scelto (non meno di un periodo = 20mS) al termine del quale il risultato totale và diviso per le campionature  (cioè quante volte abbiamo letto i valori istantanei ) ottenendo la media .

La media sotto radice quadrata è la potenza attiva chiama anche RMS (Root Mean Square).

Quel valore è il conteggiato dai nostri contatori.

Il massimo della precisione di ottiene calcolando la potenza RMS ad ogni periodo ,però per farlo bisogna aumentare la velocità di lettura del micro agendo sui registri.
Oppure calcolare il valore su due o più periodi.

Personalmente leggere 100mS è un buon compromesso ,lasciando cmq 50W di gap tra la potenza immessa e l'assorbita.

Se vai alla fine della discussione del powermeter trovi la base del codice che puoi usare .
Appena posso lo sposto anche qui.
Ciao
Elettro



//**************************************************

#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);//ASSEGNAZIONE PIN  LCD
const int BACKLIGH_PIN = 10;

int OffsetPin = A4; 
int TensionePin = A1; 
int CorrentePin_1 = A2;
int CorrentePin_2 = A3; 
float Fattore_Conversione_Tensione = 1.03; //da calcolare 
float Fattore_Conversione_Corrente_1 = .2212; //da calcolare
float Fattore_Conversione_Corrente_2 = .2212 ; //da calcolare 
float TensioneRMS ; 
float CorrenteRMS_1 ; 
float CorrenteRMS_2 ;
float PotenzaAttiva_1;
float PotenzaAttiva_2; 
float PotenzaApparen
te_1;
float PotenzaApparente_2;
float FattorediPotenza_1;
float FattorediPotenza_2;

void setup() {
  pinMode(BACKLIGH_PIN, OUTPUT);
  digitalWrite(BACKLIGH_PIN, HIGH);
  lcd.begin(16, 2);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("PowerMeter");
  lcd.setCursor(0,1);
  lcd.print("Enhanced");
  delay(2000);
  lcd.clear();
ADCSRA&=0X90+ 0b101; //Setta ADC prescaler a 32 
  
  
}

void loop() { 
float SommaV=0; 
float SommaI_1=0;
float SommaI_2=0; 
float SommaP_1=0;
float SommaP_2=0;
int NumCampionamenti = 0; 
int Offset = analogRead(OffsetPin); 
unsigned long start = micros() ; 
while (micros() < (start + 20000)){ 
float Tensioneinst = (analogRead(TensionePin)-Offset)*Fattore_Conversione_Tensione; 
float Correnteinst_1 = (analogRead(CorrentePin_1)-Offset)*Fattore_Conversione_Corrente_1;
float Correnteinst_2 = (analogRead(CorrentePin_2)-Offset)*Fattore_Conversione_Corrente_
2; 


SommaV += pow(Tensioneinst,2); 
SommaI_1 += pow(Correnteinst_1,2);
SommaI_2 += pow(Correnteinst_2,2);
SommaP_1 += (Tensioneinst*Correnteinst_1);
SommaP_2 += (Tensioneinst*Correnteinst_2); 
NumCampionamenti++; 
} 

TensioneRMS = sqrt(SommaV / NumCampionamenti); 
CorrenteRMS_1 = sqrt(SommaI_1 / NumCampionamenti);
CorrenteRMS_2 = sqrt(SommaI_2 / NumCampionamenti);
if (CorrenteRMS_1 < 0.10) {//soglia minima 
CorrenteRMS_1=0; 
SommaP_1=0;}
if (CorrenteRMS_2 < 0.10) {//soglia minima 
CorrenteRMS_2=0; 
SommaP_2=0;}
PotenzaAttiva_1 = SommaP_1/ NumCampionamenti; 
PotenzaAttiva_2 = SommaP_2/ NumCampionamenti; 
PotenzaApparente_1 = TensioneRMS * CorrenteRMS_1; 
PotenzaApparente_2 = TensioneRMS * CorrenteRMS_2; 
FattorediPotenza_1 = PotenzaAttiva_1/PotenzaApparente_1;
FattorediPotenza_2 = PotenzaAttiva_2/PotenzaApparente_2; 


lcd.setCursor(0, 0);
lcd.print(TensioneRMS,0);
lcd.print("V          
           ");
lcd.setCursor(5, 0);
lcd.print(CorrenteRMS_1,1);
lcd.print("A                     ");
lcd.setCursor(11, 0);
lcd.print(CorrenteRMS_2,1);
lcd.print("A                     ");
lcd.setCursor(0,1);
lcd.print(PotenzaAttiva_1,0);
lcd.print("W                     ");
lcd.setCursor(6,1);
lcd.print(PotenzaAttiva_2,0);
lcd.print("W                     ");
lcd.setCursor(12,1);
lcd.print(FattorediPotenza_1,2);
lcd.print("                     ");

} 
//***************************************************


Ottimo allora uso il powermeter per misurare le 2 potenze, poi è  un gioco da ragazzi pilotare il grid tie. Ingegnoso aggiungere i 2.5v in serie all'uscita del trasformatore per avere la sinusoide traslato e consentire la lettura della tensione compatibile con il pin di arduino.
Leggevo  però  che il nostro sensore di corrente ha l'uscita di 1volt, non si rischia di avere una bassa risoluzione delle letture?

danye :
Leggevo  però  che il nostro sensore di corrente ha l'uscita di 1volt, non si rischia di avere una bassa risoluzione delle letture?

Si  dato è corretto per gli SCT-13-030 .

In pratica avrai sul piedino analogico una tensione che varierà da un minimo di 1.5V a 3.5V con 30A di assorbimento.
Questa limitazione è data dal sensore che ha la resistenza di carico nel sensore stesso .
Altri sensori possono essere modificati a piacimento variando la resistenza di carico.

E quindi ?

Nessun problema.
Innanzitutto la corrente di 30A sarà la corrente di picco ... Quindi con un carico resistivo il sensore arriverà al massimo con un carico di circa 4kW ....
E ... Una risoluzione di 100mA

Per aumentare tale sensibilità puoi far passare il filo da misurare due volte nella pinza ottenendo 50mA di risoluzione .
La tensione avrà un range da 0.5V a 4.5V perché a 30A sarà 2V .

Ciao
Elettro

Ps: i 2.5V reference devono essere i più stabili possibili ;)



[quote]
Ps: i 2.5V reference devono essere i più stabili possibili ;)


La tua soluzione per ottenerli mi sembra ottima  ;)


Nel tuo schema inserisci la R5 e la R6 in parallelo ai sensori, di fatto forma un parallelo con R interna. Cosi facendo non si rischia di non avere piu 1volt di uscita? Si possono eventualmente togliere per guadagnare in sensibilità?

Sono le resistenze interne .
Lo ho rappresentate nello schema per chi usa sensori diversi (cioè io  ) .
Se hai acquistato gli originali sct puoi tranquillamente toglierle ;)

Ho montato tutto su millefori. Ho usato un atmega 328 stand-alone ( sto in fissa ) ma ho problemi con la lettura della corrente. In pratica ho messo la pinzetta a valle del generale di casa ho acceso il gril del forno circa 1500W, ma leggo solo pochi watt di assorbimento, la situazione migliora se faccio 3 giri con il cavo nel sensore, ma arrivo al massimo a leggere 2A, dovrebbero almeno essere 6 o 7A. Ho fatto la taratura ma leggo a vuoto 0.5A. Ho fatto una prova veloce, possibile che non mi funziona mai niente a prima botta? 

Una figata! Non solo il powermeter è preciso una volta calibrato,ma ho scoperto che la potenza passa a negativo se cambia verso! In pratica potrei utilizzare solo un sensore sull'entrata della acea e se passa a negativo zac! taglio della potenza immessa. Grande Elettro!

Ps: all'inizio non funzionava a causa della scarsità di un alimentatore di bassa qualità che alimentava il circuito.



O

... Sisi è  vero ,mi ero dimenticato che poteva misurare anche il verso della potenza .

Che spettacolo ....

Mentre sto iniziando a scrivere il codice per pilotare l'inverter mi sono accorto che nello scketch originale c'è un piccolissimo errore:

Bisogna modificare la riga:


PotenzaApparente_1 = TensioneRMS * CorrenteRMS_1;

in

PotenzaApparente_2 = TensioneRMS * CorrenteRMS_2;

perchè è doppia ;)


... ops ... Forse ho salvato durante delle prove.
Grazie

Ps:modifico il post del codice

Bene ho buttato giu il codice per gestire l'inverter sul pin di uscita pwm 9.
La logica è quella di controllare se la potenza acea è maggiore della potenza inverter e di incrementare il pwm se è vero altrimenti decrementa. Ho inserito un tempo di attesa dopo ogni regolazione per dare il tempo  all'inverter di adeguarsi alla richiesta, ma in caso di decremento della potenza questo tempo diminuisce di 5 volte, per avere una reattività maggiore e non correre il rischio di immettere potenza in rete. In tutti i casi se la potenza acea fosse minore di 0 il pwm si porterebbe immediatamente a 0.
Ho aggiunto anche un tempo di refresh del display per evitare di visualizzare fluttuazioni sui valori.
Che ne dici può andare?


#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);//ASSEGNAZIONE PIN  LCD
const int BACKLIGH_PIN = 10;
const int INVERTER_PIN = 9;

int OffsetPin = A4;
int TensionePin = A1;
int CorrentePin_Acea = A2;
int CorrentePin_Inverter = A3;
int pwm = 0;
int Potenza_Delta = 10; // potenza di sicurezza massima tra l'acea e l'inverter in watt
float Fattore_Conversione_Tensione = 0.623; //da calcolare
float Fattore_Conversione_Corrente_Acea = 0.073; //da calcolare
float Fattore_Conversione_Corrente_Inverter = 0.073; //da calcolare
float TensioneRMS ;
float CorrenteRMS_Acea ;
float CorrenteRMS_Inverter ;
float PotenzaAttiva_Acea;
float PotenzaAttiva_Inverter;
float PotenzaApparente_Acea;
float PotenzaApparente_Inverter;
float FattorediPotenza_Acea;
float FattorediPotenza_Inverter;
float TensioneRMS_display ;
float CorrenteRMS_Acea_display ;
float CorrenteRMS_Inverter_display;
float PotenzaAttiva_Acea_display;
float PotenzaAttiva_Inverter_display;
unsigned int MediaLetture = 0;
unsigned int disp_refresh = 1000; //tempo di refresh del display
unsigned long ultimo_refresh = 0;//variabile di temporizzazione
unsigned long Ultima_Regolazione_Inverter;// variabile di temporizzazione
unsigned int Regolazione_Refresh = 250;//tempo di attesa prima del prossimo aumento di potenza dell'inverter
unsigned int Nuova_Regolazione_Refresh = Regolazione_Refresh;

void setup() {
  //pinMode(BACKLIGH_PIN, OUTPUT);
  //digitalWrite(BACKLIGH_PIN, HIGH);
    Serial.begin(9600);
  pinMode(INVERTER_PIN, OUTPUT);
  analogWrite(INVERTER_PIN, pwm);
  lcd.begin(16, 2);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("PowerMeter");
  lcd.setCursor(0,1);
  lcd.print("Enhanced");
  delay(2000);
  lcd.clear();
ADCSRA&=0X90+ 0b101; //Setta ADC prescaler a 32   
}

void loop() {
float SommaV=0;
float SommaI_Acea=0;
float SommaI_Inverter=0;
float SommaP_Acea=0;
float SommaP_Inverter=0;
int NumCampionamenti = 0;
int Offset = analogRead(OffsetPin);
unsigned long start = micros();
while (micros() < (start + 20000)){
float Tensioneinst = (analogRead(TensionePin)-Offset)*Fattore_Conversione_Tensione;
float Correnteinst_Acea = (analogRead(CorrentePin_Acea)-Offset)*Fattore_Conversione_Corrente_Acea;
float Correnteinst_Inverter = (analogRead(CorrentePin_Inverter)-Offset)*Fattore_Conversione_Corrente_Inverter;


SommaV += pow(Tensioneinst,2);
SommaI_Acea += pow(Correnteinst_Acea,2);
SommaI_Inverter += pow(Correnteinst_Inverter,2);
SommaP_Acea += (Tensioneinst*Correnteinst_Acea);
SommaP_Inverter += (Tensioneinst*Correnteinst_Inverter);
NumCampionamenti++;
}

TensioneRMS = sqrt(SommaV / NumCampionamenti);
CorrenteRMS_Acea = sqrt(SommaI_Acea / NumCampionamenti);
CorrenteRMS_Inverter = sqrt(SommaI_Inverter / NumCampionamenti);
if (CorrenteRMS_Acea < 0.10) {//soglia minima
CorrenteRMS_Acea=0;
SommaP_Acea=0;}
if (CorrenteRMS_Inverter < 0.10) {//soglia minima
CorrenteRMS_Inverter=0;
SommaP_Inverter=0;}
PotenzaAttiva_Acea = SommaP_Acea/ NumCampionamenti;
PotenzaAttiva_Inverter = SommaP_Inverter/ NumCampionamenti;
PotenzaApparente_Acea = TensioneRMS * CorrenteRMS_Acea;
PotenzaApparente_Acea = TensioneRMS * CorrenteRMS_Acea;
FattorediPotenza_Acea = PotenzaAttiva_Acea/PotenzaApparente_Acea;
FattorediPotenza_Inverter = PotenzaAttiva_Inverter/PotenzaApparente_Inverter;

//blocco che pilota l'inverter
if(millis() - Ultima_Regolazione_Inverter >= Nuova_Regolazione_Refresh){
  if(PotenzaAttiva_Acea  >  Potenza_Delta{
    if(pwm < 255){ 
      pwm++;
      Nuova_Regolazione_Refresh = Regolazione_Refresh;
    }
    }else{
    if(pwm > 0){
      pwm--;
      Nuova_Regolazione_Refresh = Regolazione_Refresh / 5;
    }
   }
  Ultima_Regolazione_Inverter = millis();
}
if(PotenzaAttiva_Acea <= 0){
  pwm = 0;
}
analogWrite(INVERTER_PIN, pwm);
/*debug
Serial.print(PotenzaAttiva_Acea);
Serial.print("----");
Serial.print(PotenzaAttiva_Inverter);
Serial.print("----");
Serial.println(pwm);
*/
//****************************


//visualizzo i dati sul display
if(millis() - ultimo_refresh <= disp_refresh){
TensioneRMS_display += TensioneRMS;
CorrenteRMS_Acea_display += CorrenteRMS_Acea;
CorrenteRMS_Inverter_display += CorrenteRMS_Inverter;
PotenzaAttiva_Acea_display += PotenzaAttiva_Acea;
PotenzaAttiva_Inverter_display += PotenzaAttiva_Inverter;
MediaLetture++;
}
else{
TensioneRMS_display = (TensioneRMS_display / MediaLetture);
CorrenteRMS_Acea_display = (CorrenteRMS_Acea_display / MediaLetture);
CorrenteRMS_Inverter_display = (CorrenteRMS_Inverter_display / MediaLetture);
PotenzaAttiva_Acea_display = (PotenzaAttiva_Acea_display / MediaLetture);
PotenzaAttiva_Inverter_display = (PotenzaAttiva_Inverter_display / MediaLetture);
lcd.setCursor(0, 0);
lcd.print(TensioneRMS_display,0);
lcd.print("V                     ");
lcd.setCursor(5, 0);
lcd.print(CorrenteRMS_Acea_display,1);
lcd.print("A                     ");
lcd.setCursor(11, 0);
lcd.print(CorrenteRMS_Inverter_display,1);
lcd.print("A                     ");
lcd.setCursor(0,1);
lcd.print(PotenzaAttiva_Acea_display,0);
lcd.print("W                     ");
lcd.setCursor(6,1);
lcd.print(PotenzaAttiva_Inverter_display,0);
lcd.print("W                     ");
lcd.setCursor(12,1);
lcd.print(FattorediPotenza_Acea,2);
lcd.print("                      ");
MediaLetture = 0;
TensioneRMS_display = 0;
CorrenteRMS_Acea_display = 0;
CorrenteRMS_Inverter_display = 0;
PotenzaAttiva_Acea_display = 0;
PotenzaAttiva_Inverter_display = 0;
ultimo_refresh = millis();
}
}
//***************************************************


Fatte le prime prove, esito GO! (come dice il grande  ;)).


..uao
Bello bello ,aiutami a dire bello

Belloooooooo

Un piccolo ibrido per contenere i consumi recuperando l'energia di scarto dell'impianto ad isola è un'ottima scelta.

Complimenti   ;)

Cominciato il montaggio definitivo dell' impianto. 



Ciao ragazzi....ho provato a realizzare il circuito e dopo alcune regolazioni funziona tutto egregiamente....
Ho in mente di gestire con questo circuito un sunny boy 1200 tl
variando in pwm la stringa di 7 pannelli 60 celle con un mosfeet 500 v e circa 40A....direttamente dai 500 hz di arduino...pensate sia possibile?

Ho usato lo sketc di elettro, ma vorrei implementare anche la modifica fatta da danye...ma non ho capito molto, sono state cambiate alcune diciture e sono andato in palla.....come faccio a integrare un uscita pwm allo sketc di elettro?

Ciao lo sketch che ho postato piu in alto implementa già l'uscita in pwm sul pin 9. L' arduino varierà il pwm in base alla richiesta di corrente del carico. Secondo me dovresti usare un igbt al posto del mosfet, in base anche alle esperienze fatte da Elettro. ;)