Scheda per gestire lo scambio enel-FV con UPS

[calcola]

Se può essere utile allego lo schema di costruzione di una scheda basata su arduino in grado di gestire lo scambio ENEL-FV con gli UPS.

Preciso che la scheda è stata elaborata per uso personale e per puro diletto. Non sono un tecnico, quindi vi prego di perdonare la crudezza dello schema, che però è funzionante.

I materiali occorrenti sono:

1) http://www.ebay.it/itm/New-Pro-Mini-atmega328-5V-16M-Replace-ATmega128-Arduino-Compatible-Nano-/200957063666?pt=LH_DefaultDomain_0&hash=item2ec9f971f2

2) http://www.ebay.it/itm/130896589016?ssPage...984.m1439.l2649

3) http://www.ebay.it/itm/5V-One-1-Channel ... 484f323632

4)http://www.ebay.it/itm/5V-One-1-Channel-Relay-Module-Board-Shield-For-PIC-AVR-DSP-ARM-MCU-Arduino-/310566336050?pt=LH_DefaultDomain_0&hash=item484f323632

5) Due resistenze da 1K ed una da 10K, un diodo zener da 5,1V.

6) una scatola di derivazione grande

7) una basetta millefori

8) due led uno verde ed uno rosso

9) cavi vari e morsetti




In seguito posterò qualche foto della realizzazione e il software da caricare sull'atmega.

[calcola]

partitore montato, a sinistra i morsetti per il collegamento alla batteria, a destra filo marrone per il pin A0 e il cavo nero per il GND


Trasformatore con uscita regolabile


Trasformatore collegato con input all'ingresso corrente batterie (morsetti di sinistra), sulla destra si notano i morsetti per i cavi diretti alla bobina del contattore, al centro il neutro del partitore ed il filo marrone per il contatto A0 dell'arduino. Ancora più al centro i cavi di uscita del trasformatore (5,5V) che formano una piazzola alla quale sono collegati due cavi rossi e due neri (alimentazione arduino e zoccolo relè)


Retro della scheda


Sembra un pasticcio, ma in realtà la realizzazione è piuttosto semplice


particolare del collegamento del led verde


Particolare del led bicolore rosso/verde. Il led ha tre poli uno per il rosso da collegare al pin5, uno per il verde da collegare al pin 4 ed uno centrale da collegare a massa mettendo però prima in serie una resistenza da 1K.


Particolare del collegamento dello zoccolo relè, ne ho usato uno con due, ma è sufficiente quello singolo. Lo zoccolo ha bisogno di un positivo 5,5V, un neutro, ed un collegamento al pin 4 di arduino.

[calcola]

Particolare del collegamento di arduino. Si nota il cavo marrone al pin A0, il neutro del partitore ad un GND, il cavo del sensore relè/led verde al pin4, quello del led rosso pin5, sul retro l'alimentazione arduino.
Io ho saldato tutti i pin, ma consiglio di saldare solo i quattro posteriori (Vcc, GND, RX, TX) il pin A0, il pin 4, il 5, ed altri due GND a scelta. Il resto non vi serve e fa solo confusione.


Visione d'insieme di tutti i componenti collegati.


I componenti sono stati incollati su un pezzetto di compensato e poi inseriti dentro una scatola di derivazione per incasso 10 X 15 cm. Il pezzetto di legno è solo incastrato può essere estratto con tutti i componenti.


Una volta data l'alimentazione (funziona a 12V o a 24V è indifferente) l'arduino si accende ed il led lampeggia, quindi tutto OK.


Ai pin posteriori TX, RX, e ad un altro GND libero di arduino è collegata l'interfaccia seriale-USB per caricare il software. Il software è stato caricato e per bassa tensione il led rosso è acceso.
Il morsetto verde in basso serve per collegare + e - dalle batterie, quello in alto fornisce la tensione per alimentare la bobina del contattore. La bobina deve funzionare con la tensione uguale a quella delle batterie.
Sul coperchio occorre praticare un foro con una punta da 5mm e quindi inserire il led nel foro. Volendo sul coperchio si può inserire anche un interruttore a pulsante o levetta che interrompendo la corrente in ingresso spegne e resetta tutto. A monte anche un fusibile da 2A.

Come vedete è una realizzazione semplice, poco costosa, ma efficiente, chiaramente è una realizzazione di base.

<u>LA SCHEDA E' STATA DA ME COSTRUITA PER PURO DILETTO E STUDIO, CHIUNQUE LA REALIZZA LO FA A PROPRIO RISCHIO, NON POSSO GARANTIRE CHE NON VI SIANO ERRORI, OMISSIONI, DIFETTI DI PROGETTAZIONE</u>.


In seguito le istruzioni per caricare il software ed il listato da copiare.

[calcola]

Gli zoccoletti relè, sono di due tipi, apparentemente uguali, ma opposti nel funzionamento.




I due blocchi di relè se non fosse per la "N" e la "P" marcata sopra da me non si distinguerebbero, però come dicevo funzionano all'opposto quindi è necessario distinguerli in quanto se ne deve tenere conto nei collegamenti ai morsetti del relè.

Premetto che tutti e due i tipi richiedono per funzionare di una alimentazione 5,5 V direttamente prelevata dal trasformatore di alimentazione, inoltre per il pilotaggio possiedono un pin per ogni relè. Il tipo che chiamo "P" fa scattare il relè quando sul pin di pilotaggio viene mandata/tolta una tensione di 5V. Il tipo invece "N" fa scattare il relè quando sul pin di pilotaggio viene tolta/mandata la tensione di 5V. Non so se sono stato chiaro, in sintesi il relè "P" scatta quando arriva la 5V sul pin pilota, mentre nel tipo "N" il relè scatta quando viene tolta la 5V.

<u>Come fare a capire se il blocco relè acquistato è del tipo "P" o "N"</u>

Collegate a VCC ed a GND rispettivamente +,- 5,5V poi ponticellate il VCC con il pin pilota se il relè scatta vuol dire che è di tipo "P" se invece scatta ponticellando con GND allora è di tipo "N".

Con relè tipo "N" i cavi del circuito sono collegati ai morsetti NC, mentre nel tipo "P" i cavi vanno collegati ai morsetti NA. I cavi rossi da collegare sono quelli marcati A e B sulle foto.

[calcola]

Il l'adattatore seriale-USB è necessario per caricare il software e per visualizzare il monitor seriale sul PC.



Sono presenti 4 poli in uscita: rosso, verde, bianco, nero. Isolate il cavo rosso, non serve. Ai restanti cavi collegate tre connettori tipo quelli in foto. Il cavo nero va collegato a qualunque GND libero dell'arduino, mentre il cavo bianco va sul pin "TX0" e quello verde al pin "RX0".

[calcola]

Dopo aver collegato l'adattatore seriale-usb e dato alimentazione all'arduino collegandolo mediante i morsetti d'ingresso alle batterie, è il momento di caricare il software sul pc, il programma si chiama arduino ide ed è scaricabile gratuitamente da http://arduino.cc/en/Main/Software .

Dopo l'installazione aprire il programma e dalla barra menu' scegliere : Strumenti --> tipo di arduino --> Arduino pro or pro mini 5V, 16 Mhz W/ATMEGA 328.
Poi su strumenti --> porta seriale scegliere la porta seriale alla quale è collegata l'interfaccia usb.

Dentro la finestra bianca incollare il seguente listato (con copia - incolla):

Codice: Seleziona tutto

//Inizio listato
//prodotto da calcola (antrec.geo@yahoo.com)//
//ver.3_2
#include "OneWire.h"
#include "Wire.h"

////////////////////////////////
//INIZIO PARTE MODIFICABILE
///////////////////////////////
#define tensione_bassa 11.9 //valori: 11.9 (sistema 12V); 23.8 (sistema 24V)
#define tensione_alta 13.7 //valori: 13.7 (sistema 12V); 27.4 (sistema 24V)
///////////////////////////////
//FINE PARTE MODIFICABILE
///////////////////////////////

#define coefficiente_conversione 0.05620

#define RELAY1 4 //led verde + relè commutazione. Indicatore stato batterie
#define RELAY2 5 //led rosso. Indicatore stato rete.
#define inputPin (A0) //Sensore tensione collegato al pin analogico 0
#define NUMREADINGS 5 //Il numero indica i valori tensione da leggere
#define bassatensione (tensione_bassa/coefficiente_conversione) // Valore della tensione stop batt ritorno rete
#define altatensione (tensione_alta/coefficiente_conversione) // Valore tensione stop rete ritorno batt.

int readings[NUMREADINGS]; //Letture dal input analogico
int index = 0; //Indice della lettura corrente
int total = 0; //Totale letture
int average = 0; //Media
#define media1 (bassatensione + altatensione)/2 // Media tensione per avvio

void setup()
{
//Apro la comunicazion seriale
Serial.begin(57600);
Wire.begin();
pinMode(RELAY1, OUTPUT);
pinMode(RELAY2, OUTPUT);
pinMode(inputPin, INPUT);

{if (analogRead(inputPin) > media1)
{digitalWrite(RELAY2, LOW);
digitalWrite(RELAY1, HIGH);
}

else

{digitalWrite(RELAY1, LOW);
digitalWrite(RELAY2, HIGH);}
}

for (int i = 0; i < NUMREADINGS; i++)
readings[i] = 0; //Mette tutti 0 nell'array

}

void loop()

{
for (int A = 0; A < NUMREADINGS; A++)
{
total -= readings[index]; //Sottrae l'ultima lettura
readings[index] = analogRead(inputPin); //Legge i valori provenienti dal sensore e li salva nell'array
total += readings[index]; //Aggiunge la lettura al totale
index = (index + 1); //Incrementa l'indice

if (index >= NUMREADINGS)
index = 0; //Alla fine dell'array resetta l'indice a 0

average = total / NUMREADINGS; //Calcola la media
}

float VoltageReading;
float media_avvio;
VoltageReading=average*coefficiente_conversione;
media_avvio=media1*coefficiente_conversione;

if (VoltageReading < tensione_bassa)

{
digitalWrite(RELAY2, HIGH);
delay(200);
digitalWrite(RELAY1, LOW);
}

else if (VoltageReading > tensione_alta)
{
digitalWrite(RELAY1, HIGH);
delay(200);
digitalWrite(RELAY2, LOW);

}
Serial.print(" Voltaggio batteria intermedio tra min-max: ");
Serial.println(media_avvio);
Serial.println("-----------");
Serial.print(" Voltaggio batteria (media 5 letture): ");
Serial.println(VoltageReading); //Serial.println(average);
Serial.print(" Passa a enel quando minore di: ");
Serial.println(tensione_bassa);
Serial.print(" Passa a batterie quando maggiore di: ");
Serial.println(tensione_alta);
Serial.println("-----------");
Serial.println();
delay(2000);
}
//Fine listato

Il listato deve apparire così come lo vedete sopra.

Ora salvatelo file --> salva con nome scegliete il nome che volete.

Ora siete pronti per caricarlo sulla scheda.

Posizionare il mouse sul secondo pulsante da sinistra (freccetta verso destra) e cliccare, sulla parte bassa della finestra leggete per pochi secondi "compilazione software" e poi "carico" in quell'istante pigiate e rilasciate il pulsante reset presente su arduino (se il caso aiutatevi con un cacciavite). Se tutto va a buon fine leggerete sulla barra in basso dei messaggi una frase di completamento, altrimenti apparirà un messaggio d'errore. In questo caso ripetete l'operazione. Se si blocca durante la fase di compilazione vuol dire che nel copia incolla del programma avete compiuto qualche errore.

Non occorre essere sincronizzati al millesimo con il messaggio di carico del software, diciamo che appena appare schiacciate il pulsante dell'arduino.

Nella parte del listato marcata come modificabile potete cambiare le soglie come volete, attenzione che la virgola del decimale è il punto. Es: 13.2 e non 13,2.

Dopo caricato il software, se tutto funziona, si accenderà il led verde/rosso in base allo stato di carica della batteria.

Potete vedere il buon funzionamento del tutto aprendo la finestra di comunicazione da strumenti --> monitor seriale -->.
Appariranno dei valori: tensione batterie, valore intermedio tra la soglia minima e quella massima, la soglia minima di passaggio a enel, la soglia massima di passaggio a batterie.

All'avvio il programma calcola la media del valore tra la soglia minima (passaggio a enel) e massima (passaggio a batteria), se la tensione della batteria è superiore alla media partirà a batterie, se inferiore rimarrà su enel. e passerà a batterie solo quando raggiungerà la soglia impostata per il passaggio a batterie.

Questo è tutto se serve aiuto (non modifiche o miglioramenti) chiedete pure.
Buon lavoro!!

P.S. La scheda l'ho costruita l'altro ieri per diletto ed appositamente per il forum per realizzare questa guida, a me non serve, la tengo ancora qualche giorno in prova, poi la smonto per recuperare i componenti. Però, se qualcuno la vuole la posso vendere, metterò una inserzione alla sezione vetrina.

[calcola]

Vedremo ora come si tara il partitore di tensione. Infatti il partitore di tensione utilizzato è di tipo resistivo e le resistenze hanno sempre dei piccoli margini di errore, quindi si rende necessario tarare il proprio partitore in modo che il programma possa restituire i corretti valori di tensione. Consiglio di caricare una prima volta il software, controllare sul monitor seriale che i valori di tensione restituiti siano uguali a quelli della batteria e misurati con il tester ai morsetti verdi d'ingresso alla scheda. Se sono uguali con errore +- di un decimo (0,1V) lasciate stare, altrimenti procedete con la taratura.

Effettuate il controllo con la sola scheda collegata alla batteria, quindi: pannelli staccati, inverter spento, nessun carico.

COME EFFETTUARE LA TARATURA DEL PARTITORE

1) individuate alla fine del listato la riga seguente: Serial.println(VoltageReading); //Serial.println(average);

eliminate le due barrette // solo le barrette, in modo che l'istruzione diventi: Serial.println(VoltageReading); Serial.println(average);

2) ricaricate il software così modificato sull'arduino.

3) aprite il monitor seriale, apparirà una schermata di questo tipo:


individuate il numero evidenziato sulla foto con il punto nero, nell'esempio "225", misurate il valore della tensione della batteria ai morsetti d'ingresso della scheda, supponiamo 12.7 V, quindi fate il seguente calcolo: 12.7/225= 0.05644 quello è il valore che deve essere sostituito al coefficiente di conversione all'inizio del listato al punto : #define coefficiente_conversione 0.05620.

4) ricaricate nuovamente il programma modificato

Non aspettatevi una precisione assoluta nel mio caso la tensione realmente misurata con il tester alla batteria è veramente di 12,65 che diviso 225 fa un coefficiente appunto di: 0.056222222 che ho arrotondato a 0.05620, però se osservate la lettura precedente potete vedere che la penultima lettura della tensione era di 12.7 V. Quindi vi è un errore di circa 0,05V. Ho visto che se si usano resistenze di precisione (quelle colorate in genere di blu) l'errore diminuisce, ma secondo me non ne vale la pena.

Attenzione prima di tarare aspettate qualche ora dopo che il partitore è stato messo in funzione in modo che le resistenze siano già in temperatura di funzionamento, la lettura è influenzata dalla temperatura e dalla tensione. La taratura effettuata con tensioni di esercizio a 12V non va bene se la tensione passa a 24V e viceversa.

Il partitore funziona con impianti 12 o 24V, per impianti a 48V occorre sostituire la prima resistenza da 10K con una da 20K o 25K. Poi è necessario fare la taratura seguendo le istruzioni.

Sperimentate, solo così s'impara.

Questo un frammento del listato del monitor seriale con decine di letture, in modo da poter effettuare un confronto:

----------

Voltaggio batteria intermedio tra min-max: 12.45
-----------
Voltaggio batteria (media 5 letture): 12.65
225
Passa a enel quando minore di: 11.90
Passa a batterie quando maggiore di: 13.00
-----------

Voltaggio batteria intermedio tra min-max: 12.45
-----------
Voltaggio batteria (media 5 letture): 12.65
225
Passa a enel quando minore di: 11.90
Passa a batterie quando maggiore di: 13.00
-----------

Voltaggio batteria intermedio tra min-max: 12.45
-----------
Voltaggio batteria (media 5 letture): 12.65
225
Passa a enel quando minore di: 11.90
Passa a batterie quando maggiore di: 13.00
-----------

Voltaggio batteria intermedio tra min-max: 12.45
-----------
Voltaggio batteria (media 5 letture): 12.65
225
Passa a enel quando minore di: 11.90
Passa a batterie quando maggiore di: 13.00
-----------

Voltaggio batteria intermedio tra min-max: 12.45
-----------
Voltaggio batteria (media 5 letture): 12.70
226
Passa a enel quando minore di: 11.90
Passa a batterie quando maggiore di: 13.00
-----------

Voltaggio batteria intermedio tra min-max: 12.45
-----------
Voltaggio batteria (media 5 letture): 12.59
224
Passa a enel quando minore di: 11.90
Passa a batterie quando maggiore di: 13.00
-----------

Voltaggio batteria intermedio tra min-max: 12.45
-----------
Voltaggio batteria (media 5 letture): 12.65
225
Passa a enel quando minore di: 11.90
Passa a batterie quando maggiore di: 13.00
-----------

Voltaggio batteria intermedio tra min-max: 12.45
-----------
Voltaggio batteria (media 5 letture): 12.70
226
Passa a enel quando minore di: 11.90
Passa a batterie quando maggiore di: 13.00
-----------

Voltaggio batteria intermedio tra min-max: 12.45
-----------
Voltaggio batteria (media 5 letture): 12.65
225
Passa a enel quando minore di: 11.90
Passa a batterie quando maggiore di: 13.00
-----------

Voltaggio batteria intermedio tra min-max: 12.45
-----------
Voltaggio batteria (media 5 letture): 12.65
225
Passa a enel quando minore di: 11.90
Passa a batterie quando maggiore di: 13.00
-----------

Voltaggio batteria intermedio tra min-max: 12.45
-----------
Voltaggio batteria (media 5 letture): 12.65
225
Passa a enel quando minore di: 11.90
Passa a batterie quando maggiore di: 13.00
-----------

Voltaggio batteria intermedio tra min-max: 12.45
-----------
Voltaggio batteria (media 5 letture): 12.65
225
Passa a enel quando minore di: 11.90
Passa a batterie quando maggiore di: 13.00
-----------

Voltaggio batteria intermedio tra min-max: 12.45
-----------
Voltaggio batteria (media 5 letture): 12.65
225
Passa a enel quando minore di: 11.90
Passa a batterie quando maggiore di: 13.00
-----------

Voltaggio batteria intermedio tra min-max: 12.45
-----------
Voltaggio batteria (media 5 letture): 12.70
226
Passa a enel quando minore di: 11.90
Passa a batterie quando maggiore di: 13.00
-----------

Voltaggio batteria intermedio tra min-max: 12.45
-----------
Voltaggio batteria (media 5 letture): 12.65
225
Passa a enel quando minore di: 11.90
Passa a batterie quando maggiore di: 13.00
-----------

Preciso che la scheda funziona con qualunque versione dell'arduino tipo1, quindi:duemilanove, uno, mini, pro-mini..., non ho avuto il tempo di provare con un arduino tipo2.
La scelta del pro-mini è stata fatta per le ridotte dimensioni e per il minor costo. Usando un arduino normale non serve il cavo seriale-usb, e non serve l'operazione del reset durante il trasferimento del software.

[calcola]

Il partitore di tensione accetta in ingresso tensioni da 0 a circa 55V (ora non ricordo esattamente) e riduce questa tensione in modo proporzionale in tensione da 0 a 5V, lo zenner è necessario per impedire che in caso di tensioni in ingresso superiori a 55V quella d'uscita possa superare i 5V. L'arduino riceve la tensione da 0 a 5V su un ingresso analogico e la trasforma in un valore numerico compreso tra 0 e 1023. Quindi se sull'analogico mandi esattamente 5V l'arduino la vede come 1023. Se invii valori di tensione minori di 5V leggerà valori inferiori a 1023. Se mandi tensioni superiori a 5V, l'arduino si brucia ed ecco la necessità dello zenner 5,1.
Con una proporzione è possibile calcolare il coefficiente di conversione e poi, conoscendo la tensione reale in ingresso, adattarlo alla realtà. Durante le conversioni si commette sempre un piccolo errore che va compensato.

Il partitore è adatto a monitorare impianti a 12v o a 24v, per impianti a 48v, sostituire la prima resistenza da 10K del partitore con una da 20K o 25K, poi seguire le istruzioni del post sulla taratura.

Questo è tutto spero possa essere d'aiuto.

[maxlinux2000]

complimenti Calcola!

mi sembra semplice anche il codice... la pause sono in millisecondi?

mi piacerebbe anche (visto che ci pigli parecchio) se hai tempo che tu facessi un introduzione ad Arduino, ma non tanto alla programmazione, ma su cosa consigli di comprare per iniziale a fare qualche cosa.

Sto pensando ci cimentarmi anche io con l' arduino, e ho visto che nel sito vendono un kit per novizi, ma non sono convinto. Tu che ne dici?

CMQ per non inquinare questa discussione sarebbe meglio aprirne una nuova..... e probabilmente spostare questa in Linux, (lasciando un argomento ombra qui in fotovoltaico)

...Titone, che di dici?

[calcola]

Si, le pause sono in millisecondi. In questo periodo non ho tanto tempo, lascia passare qualche settimana e poi vedrò di postare qualcosa sull'arduino.

Per iniziare compra un arduino originale o clone cinese, poi realizza qualche circuito in grado di usare gli esempi di software presenti sull'IDE, lampeggio led, interruttori, gestione delle porte I/O... si impara in fretta è semplice. Io quel poco che so l'ho imparato in questo modo. Su internet di esempi ve ne sono di tutti i tipi.

Comunque il software per la mia scheda che ha sensori di corrente, orologio, porta ethernet, sito web interno, sensori di presenza rete... me lo sono fatto fare da un mio parente, molto prossimo e che ora... lo sta adattando all'arduino yun, vi sarà la possibilità di implementare direttamente un soc, grafici dei principali valori: tensione, corrente di carica, corrente +- delle batterie...

[calcola]

Nuova versione del software, ho aggiunto un ritardo nella commutazione da batterie ad enel, in pratica quando la tensione scende al di sotto della soglia di commutazone, il programma attende un numero di secondi programmabile, poi ricontrolla la tensione se è ancora bassa commuta altrimenti rimane sulle batterie. E' utile per prevenire le premature commutazioni dovute ai brevi sbalzi di tensione durante lo spunto dei motori induttivi.

Codice: Seleziona tutto

//Inizio listato
//prodotto da calcola (antrec.geo@yahoo.com)//
//ver.3_4
#include "Wire.h"
//
//
//
//
////////////////////////////////
//INIZIO PARTE MODIFICABILE
///////////////////////////////
#define tensione_bassa 11.9 //valori: 11.9 (sistema 12V); 23.8 (sistema 24V)
#define tensione_alta 13.7 //valori: 13.7 (sistema 12V); 27.4 (sistema 24V)
#define pausa 8 //ritardo in secondi per compensare brevi abbassamenti di tensione

#define coefficiente_conversione 0.05520

///////////////////////////////
//FINE PARTE MODIFICABILE
///////////////////////////////
//
//
//
//
//
//
#define RELAY1 4 //led verde + relè commutazione. Indicatore stato batterie
#define RELAY2 5 //led rosso. Indicatore stato rete.
#define inputPin (A0) //Sensore tensione collegato al pin analogico 0
#define numero_letture 5 //Il numero indica i valori tensione da leggere
#define bassatensione (tensione_bassa/coefficiente_conversione) // Valore della tensione stop batt ritorno rete
#define altatensione (tensione_alta/coefficiente_conversione) // Valore tensione stop rete passo batt.

int readings[numero_letture]; //Letture da ingresso analogico
int index = 0; //Indice della lettura corrente
int total = 0; //Totale letture
int media_tens = 0; //Media tensione indice analogico
float media_tens_volt; //media tensione espressa in Volt
byte enel0 = 0;
byte stato = 0;
int rit = pausa*1000;
#define media1 (bassatensione + altatensione)/2 // Media tensione per avvio 
float media_avvio; // media1 in Volt

void setup()
{
//Apro la comunicazion seriale
Serial.begin(57600);
Wire.begin();
pinMode(RELAY1, OUTPUT);
pinMode(RELAY2, OUTPUT);
pinMode(inputPin, INPUT);

{if (analogRead(inputPin) > media1)
{digitalWrite(RELAY2, LOW);
digitalWrite(RELAY1, HIGH);
stato = 1;
}

else

{digitalWrite(RELAY1, LOW);
digitalWrite(RELAY2, HIGH);
stato = 2;
}}

for (int i = 0; i < numero_letture; i++)
readings[i] = 0; //Mette tutti 0 nell'array
}

void loop(){
  
tensione();
{
if ((media_tens_volt < tensione_bassa) && (enel0 !=1))
{ritardo();}
  if (media_tens_volt < tensione_bassa){enel();}
  else if(media_tens_volt > tensione_alta){batterie();}}
  { if (stato == 1){Serial.println("Stato: batterie");}
  else if (stato == 2){Serial.println("Stato: enel");}
}



Serial.print(" Voltaggio batteria intermedio tra min-max: ");
Serial.println(media_avvio);
Serial.println("-----------");
Serial.print(" Voltaggio batteria (media 5 letture): ");
Serial.println(media_tens_volt); //Serial.println(media_tens);
Serial.print(" Passa a enel quando minore di: ");
Serial.println(tensione_bassa);
Serial.print(" Passa a batterie quando maggiore di: ");
Serial.println(tensione_alta);
Serial.println("-----------");
Serial.println();
delay(2000);
}

void tensione(){
 
for (int A = 0; A < numero_letture; A++){
total -= readings[index]; //Sottrae l'ultima lettura
readings[index] = analogRead(inputPin); //Legge i valori provenienti dal sensore e li salva nell'array
total += readings[index]; //Aggiunge la lettura al totale
index = (index + 1); //Incrementa l'indice

if (index >= numero_letture)
index = 0; //Alla fine dell'array resetta l'indice a 0

media_tens = total / numero_letture; //Calcola la media
}
media_tens_volt=media_tens*coefficiente_conversione;
media_avvio=media1*coefficiente_conversione;
}

void enel() 
{
digitalWrite(RELAY2, HIGH);
delay(200);
digitalWrite(RELAY1, LOW);
enel0 = 1;
stato = 2 ;
}

void batterie(){
  digitalWrite(RELAY1, HIGH);
delay(200);
digitalWrite(RELAY2, LOW);
enel0 = 0;
stato = 1 ;
}

void ritardo()
{delay (rit); tensione();}

//Fine listato

[maxlinux2000]

Bello! .quando arrivo a casa me lo guardo meglio.

Sai mica se esiste un simulatore di arduino + parte elettronica virtuale + ide programmazione?

[calcola]

max, non so se esiste qualcosa, preferisco fare le prove con la scheda reale, dalla Cina un pro-mini costa meno di 3 euro, non vale la pena...

La prossima modifica sarà quella di interagire con l'arduino tramite monitor seriale, in modo da inviare dalla seriale i parametri variabili di configurazione e non dover ogni volta modificare il listato per poi caricarlo tramite l'IDE. L'idea finale è quella di collegare tramite seriale l'arduino ad una scheda raspberry o similare dove far girare un web server che memorizza tutti i valori di tensione, corrente... visualizzare grafici... Il lavoro per me che devo imparare sperimentando è lungo, mentre il tempo disponibile poco...

[calcola]

Nuova versione, ora è possibile modificare il valori delle variabili direttamente da monitor seriale e senza dover ricaricare il software. Per accedere alla configurazione occorre scrivere "soglie" sulla riga di immissione della finestra del monitor seriale dell'IDE. Altra miglioria, ora la gestione del ritardo di commutazione è fatta mediante mediante millis() e non più con i delay, così ora durante la "pausa di riflessione" l'esecuzione del software non si ferma e si possono usare tempi più lunghi, con 8 secondi di ritardo si compensano bene le oscillazioni di tensione indotte dallo spunto di molti utilizzatori, con 12 secondi si compensano anche i frigo.

Codice: Seleziona tutto

//INIZIO CODICE
//
//
//Inizio listato
//prodotto da calcola (antrec@geocities.com)//
//ver.3_8
//
//ATTENZIONE:
//
//CC BY-NC-SA 4.0
//Uso non commerciale, modificabile, con obbligo di condivisione-
//http://creativecommons.org/licenses/by-nc-sa/4.0/deed.it
//
#include "Wire.h"
#include "avr/eeprom.h"
#define CONFIG_EEPROM_ADDR ((byte*) 0x10)

struct Config {
    float tensione_bassa;
    float tensione_alta;
    byte pausa;
    float coefficiente_conversione;
    byte valid; //lasciare alla fine!
} config;

static void loadConfig() {
    for (byte i = 0; i < sizeof config; ++i)
        ((byte*) &config)[i] = eeprom_read_byte(CONFIG_EEPROM_ADDR + i);
        if (config.valid != 253) {
        config.valid = 253;
//
////////////////////////////////
//INIZIO PARTE MODIFICABILE
///////////////////////////////
        
        config.coefficiente_conversione = 0.0552; //arrotondare alla 4.a cifra decimale
        config.tensione_bassa = 11.9;      //valori: 11.9 (sistema 12V); 23.8 (sistema 24V)
        config.tensione_alta = 13.7;      //valori: 13.7 (sistema 12V); 27.4 (sistema 24V)
        config.pausa = 8;                //ritardo in secondi per compensare brevi abbassamenti di tensione
        
///////////////////////////////
//FINE PARTE MODIFICABILE
///////////////////////////////
//        
        }
        
        }

    static void saveConfig() {
    for (byte i = 0; i < sizeof config; ++i)
        eeprom_write_byte(CONFIG_EEPROM_ADDR + i, ((unsigned char*) &config)[i]);        
}
int rit;
int c;
unsigned long a;
unsigned long b;
#define RELAY1 4 //led verde + relè commutazione. Indicatore stato batterie
#define RELAY2 5 //led rosso. Indicatore stato rete.
#define inputPin (A0) //Sensore tensione collegato al pin analogico 0
#define numero_letture 5 //Il numero indica i valori tensione da leggere

#define bassatensione (config.tensione_bassa/config.coefficiente_conversione) // Valore numerico della tensione stop batt ritorno rete
#define altatensione (config.tensione_alta/config.coefficiente_conversione) // Valore numerico tensione stop rete passo batt.
#define media1 (bassatensione + altatensione)/2 // Media tensione per avvio numero
#define media_avvio media1*config.coefficiente_conversione // media1 in Volt

int readings[numero_letture]; //Letture da ingresso analogico
int index = 0; //Indice della lettura corrente
int total = 0; //Totale letture
int media_tens = 0; //Media tensione indice analogico
float media_tens_volt; //media tensione espressa in Volt
byte enel0 = 0;
byte stato = 0;


  
void setup()
{
//Apro la comunicazion seriale
Serial.begin(57600);
while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }
Wire.begin();
pinMode(RELAY1, OUTPUT);
pinMode(RELAY2, OUTPUT);
pinMode(inputPin, INPUT);
loadConfig();

{if (analogRead(inputPin) > media1){batterie();}
else{enel();}}

for (int i = 0; i < numero_letture; i++)
readings[i] = 0; //Mette tutti 0 nell'array
}

void loop(){

  tensione();
if (Serial.available()>0){ immissione();}

if ((media_tens_volt < config.tensione_bassa) && (enel0 !=1) && (stato !=1))
{ritardo();}
  if (stato ==1){b=millis(); if ((b-a>rit)&&(media_tens_volt < config.tensione_bassa)){enel();}}
  if(media_tens_volt > config.tensione_alta){batterie();}
  if (enel0 == 0){Serial.println("Stato: batterie");}
  else if (enel0 == 1){Serial.println("Stato: enel");}


Serial.print(" Voltaggio batteria intermedio tra min-max: ");
Serial.println(media_avvio);
Serial.println("-----------");
Serial.print(" Voltaggio batteria (media 5 letture): ");
Serial.println(media_tens_volt); //Serial.println(media_tens);
Serial.print(" Passa a enel quando minore di: ");
Serial.println(config.tensione_bassa);
Serial.print(" Passa a batterie quando maggiore di: ");
Serial.println(config.tensione_alta);
Serial.println("-----------");
Serial.print("Ritardo commutazione: ");
Serial.println(config.pausa);
Serial.print("Coefficiente di conversione: ");
Serial.println(config.coefficiente_conversione,4);
Serial.println("-----------");
Serial.println("v: 3_8");
//Serial.print("Millis iniziali; ");
//Serial.println(a);
//Serial.print("Millis finali: ");
//Serial.println(b);
Serial.println("-----------");
Serial.println();
delay(2000);
}

void tensione(){
 
for (int A = 0; A < numero_letture; A++){
total -= readings[index]; //Sottrae l'ultima lettura
readings[index] = analogRead(inputPin); //Legge i valori provenienti dal sensore e li salva nell'array
total += readings[index]; //Aggiunge la lettura al totale
index = (index + 1); //Incrementa l'indice

if (index >= numero_letture)
index = 0; //Alla fine dell'array resetta l'indice a 0

media_tens = total / numero_letture; //Calcola la media
}
media_tens_volt=media_tens*config.coefficiente_conversione;

}

void enel() 
{
digitalWrite(RELAY2, HIGH);
delay(200);
digitalWrite(RELAY1, LOW);
a=b;
enel0 = 1;
stato = 2 ;
}

void batterie(){
  digitalWrite(RELAY1, HIGH);
delay(200);
digitalWrite(RELAY2, LOW);
a=b;
enel0 = 0;
stato = 2 ;
}

void ritardo(){
rit = config.pausa*1000;
a= millis();
stato = 1;
}


void immissione(){
 c= Serial.findUntil("soglie", "soglie");
 if (c == 1){Serial.flush(); c=0;
 loadConfig();
 
Serial.print("Tensione commutazione enel: ");
delay(4000);
while (Serial.available()>0){config.tensione_bassa=Serial.parseFloat();
Serial.println(config.tensione_bassa);
Serial.flush();} 
Serial.println("");

Serial.print("Tensione commutazione batterie: ");
delay(4000);
while (Serial.available()>0){ config.tensione_alta=Serial.parseFloat();
Serial.println(config.tensione_alta);
Serial.flush();}
Serial.println("");

Serial.print("Coefficiente di conversione: ");
delay(4000);
while (Serial.available()>0){ config.coefficiente_conversione=Serial.parseFloat();
Serial.println(config.coefficiente_conversione,4);
Serial.flush();}
Serial.println("");

Serial.print("Secondi ritardo commutazione: ");
delay(4000);
 while (Serial.available()>0){ config.pausa=Serial.parseFloat();
Serial.println(config.pausa);
Serial.flush();}

saveConfig();

}

else Serial.println("Errore, ripeti");
delay(2000);}
//Fine listato

[Franchetto]

Ho visto solo oggi questo interessante post e siccome con Arduino, FV e UPS ci bazzico pure io sarebbe molto utile per migliorare la comprensione, oltre quello che hai gia ampiamente documentato, se tu facessi una descrizione chiara della logica di funzionamento del circuito dettagliando la funzione dei componenti dello schema.
Grazie per la condivisione del sapere.

[calcola]

Premetto che non ricevo la notifica delle risposte alle discussioni a cui partecipo e purtroppo non ho notato la tua richiesta. Certo che potrei commentare il listato, però è trascorso del tempo dal tuo intervento e non so se l'argomento ti interessa ancora. Facciamo così, se sei interessato a capire meglio qualche linea del codice, indicamela e quanto prima cercherò di accontentarti. Se tardo a risponderti, inviami pure un messaggio, quelle notifiche le ricevo ancora.