Io ho la fase tra R3 e R4, il neutro non è staccato. Comunque i contatti NC sono: R3 che esce su R4 e R5 che esce su R6. Mentre quelli NA sono 1-->2 e 7-->8. Quindi puoi usare R3-->R4 oppure R5-->R6 a tua scelta. Oppure se vuoi staccare le due fasi una su R5-->R6, l'altra su R3-->R4.

Tra 7 e 8 ho messo invece il neutro dell'alimentazione dell'eletttronica del contatore digitale in modo che quando commuta a batterie il contatore è alimentato e misura i KWh prodotti dal FW e consumati.

Se stacchi solo la fase (ed ho fatto delle prove con un apparecchio che misura la PE dell'impianto), il salvavita continua a funzionare come con la corrente di rete anche quando l'impianto è alimentato dall'inverter. Invece con la bifase, ho verificato tempi di reazione del salvavita più lunghi.

Buongiorno a tutti e ringrazio ancora questo fantastico forum per gli spunti che riesce a dare...

@calcola
ho fatto come da te consigliato...sembra tutto OK, devo inserire solo il codice in modo che mi salti un calo eccessivo di tensione.

@sabin
ho una domanda sull'utilizzo del pulsante per passaggio forzato ad enel. Non basta levare l'alimentazione alla scheda per far sì che il contattore da 24V faccia passare la corrente ENEL e quindi l'inverter, invece di alimentare i carichi da batterie,li alimenti da rete elettrica? Potrebbe bastare un pulsante che apra o chiuda, in modo fisico, il polo positivo che arriva dalle batterie? Io ho notato che staccando o attaccando il positivo ottengo un passaggio forzato ad enel. Saluti e grazie ancora.

E' proprio quello che ho fatto io, sulla linea a 24v che va al contattore ho messo un interruttore che interrompe un polo, in questo modo quando lo pigio passo ad enel anche con batterie cariche. L'interruttore è utile per evitare ripetute commutazioni quando lavoro alla scheda o all'impianto a 24V, inoltre con quell'interruttore azionato l'impianto passerà a batterie solo in caso di interruzione del servizio da parte enel.

CITAZIONE (shadowcaster, 19/01/2014 09:08:46 )

Ho prodotto una nuova versione del software in cui si può impostare il tempo di attesa prima della commutazione sulla rete, inoltre ho aggiunto la visualizzazione dello stato: enel, batterie, al monitor seriale.
Intendevo sostituire il listato presente all'inizio della discussione con la nuova versione, solo che questo nuovo portale non mi fa più modificare il relativo post, chiedo quindi ad elettro se può, di fare la sostituzione del listato iniziale con quello pubblicato di seguito.

//Inizio listato
//prodotto da calcola (antrec@geocities.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.05620

///////////////////////////////
//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

Consiglio di non superare il tempo d'attesa di 8 secondi, oltre per me è controproducente.

Consiglio inoltre di aggiungere un interruttore sull'alimentazione della scheda, in modo da spegnerla completamente e consiglio di spegnerla una volta al mese. Questo per evitare eventuali blocchi dell'atmega per riempimento della memoria che conteggia in millisecondi "Millis" il tempo di funzionamento dal momento dell'accensione. In teoria dovrebbe riavviarsi da solo peccato che per un difetto nel bootloader del duemilanove e del pro-mini l'auto reset non funziona.

GRANDE!!!!!!!!

Salve a tutti. Mi è venuta un'altra idea partendo dal progetto base. Vorrei aggiungere un display per visualizzare stampati sul monitor seriale, ed inoltre un modulo RTC che mi tenga traccia degli scambi avvenuti durante la giornata...
Quindi avrei bisogno di:
Un LCD 16x2
Un modulo RTC
Un modulo con SD (o potrei farne a meno?)
Un pulsante per accendere o spegnere l'LCD
Un pulsante per scorrere le righe dell'LCD e visualizzare i dati...
Manca qualcosa?
A presto.

Penso che la lista dei desideri sia completa Il modulo SD ti serve perchè nella memoria interna dell'RTC puoi memorizzare solo 6 date.

Purtroppo a scrivere il listato non potrò aiutarti, il periodo di riposo forzato causa influenza è, se Dio vuole, finito. Domani riprendo il lavoro e di tempo... ne avrò poco. Però se hai dei dubbi posta pure il listato, lavoro permettendo su un aiuto potrai sempre contare.

Ok. Grazie, allora ordino i componenti e comincio a creare il PCB. L'importante è che comunichino fra di loro, poi come lo stabiliamo dopo...

ciao Calcola, scusa se mi intrometto ma volevo darti un suggerimento se fattibile.

premesso che di programmazione non so assolutamente nulla, ma non puoi fare nel listato che ogni tot "millis" o al raggiungimento di una soglia della memoria l'apparato faccia un reset?

per esempio potresti comandare un'uscita su un relè temporizzato a 3/5 sec che ti scollega l'alimentazione, non so se c'è un pin di reset.

io l'ho fatto per una scheda che ho realizzato, che mi perdeva sincronismo dopo un po' di tempo così la resettavo e poi proseguiva perfettamente con tutti i suoi compiti.

ciao

Raul

Il problema è in un baco nel bootloader dell'arduino duemilanove e quindi anche del pro-mini che ha il medesimo bootloader. Se si abilita la funzione dell'auto reset al verificarsi della condizione impostata per il reset, il sistema va in loop infinito e rimane bloccato. Qualcuno ha risolto con un NE555 io invece in un modo più semplice ho sostituito il bootloader originale con quello dell'arduino uno ed il problema è risolto alla fonte. Tra le altre cose quello dell'uno è più piccolo, occupa meno spazio e quindi lascia più memoria per il programma. Solo che per cambiare il bootloader occorre un apposito programmatore seriale e bisogna saperlo usare. Quindi chi è alle prime armi fa prima a spegnerlo una volta al mese.

Il metodo da te suggerito ha lo stesso effetto dell'uso dell'NE555, ogni tot secondi se non si riceve un impulso il circuito mette a massa il pin reset per una frazione di secondo. E' un metodo semplice, ma efficace, oppure come dicevo è sufficiente sostituire il bootloader. Non appena compro una scheda faccio subito la sostituzione e non ci penso più. Poi chiaramente va impostato l'IDE alla voce arduino uno e non più pro-mini...

CITAZIONE (calcola, 21/01/2014 11:21:02 )

delay imposta una pausa nell'esecuzione del loop e corrisponde all'istruzione Millis() che restituisce in millisecondi il tempo dall'accensione + la pausa sempre in millisecondi, quindi delay funziona con i millis. L'istruzione lcd.print(millis()/1000); chiede di stampare sull'LCD il tempo di accensione in secondi.

Purtroppo riempita la memoria non sempre il contatore si azzera può anche andare in errore per overflow e bloccare il loop. Con il delay si imposta una pausa nell'esecuzione delle istruzioni, può essere controproducente se esegui delle istruzioni che non vuoi che si fermino. In tali casi è meglio usare i millis con una istruzione del tipo:

int a= millis();
if (millis()= a+8000){istruzione per commutare}
else [istruzione per restare a batterie];

il vantaggio è che nell'attesa degli 8 secondi di pausa l'esecuzione delle istruzioni non si ferma. Nel nostro caso è una inutile complicazione in quanto il programma esegue una sola funzione, quindi non vi è niente d'altro che possa essere interrotto.


CITAZIONE

Cercando su internet ho trovato un sistema furbo per riavviare in automatico la scheda dopo x gg di funzionamento.
Occorre ponticellare il pin reset con un pin digitale non usato, esempio il pin 9 avendo cura di inserire in serie al ponticello una resistenza da 1K.

Poi scrivere nelle dichiarazioni:

#define reset 9

nel void setup inserire l'istruzione:

pinMode(reset, OUTPUT);
digitalWrite(reset, HIGH);

Nel void loop
subito dopo la prima parentesi la seguente istruzione:

{if (millis()> 1728000){digitalWrite(reset, LOW); }
else digitalWrite(reset, HIGH);}


In pratica fino a quando millis è minore di 1728000 ms (20gg) tiene il pin 9 a 5V, quando lo supera pone il pin 9 a 0v in questo modo si mete a massa il reset e la scheda si riavvia.

Provatelo e ditemi se funziona, io non ne ho avuto il tempo.

Salve a tutti. Avrei una domanda, secondo voi è possibile utilizzare pin in comune sull'arduino? Ho un progetto in mente e mi sono reso conto che i pin digitali a mia disposizione non sono sufficienti...