Nello schema di pagina 6 non c'è nessun partitore anche se non ho capito casa è! Ho solo capito che anticipa lo scambio e non saprei per quale beneficio visto che la tensione di scambio si programma nella logica

Lo schema più chiaro è a pagina 7 ed quello che troverai di seguito. L'altro con il circuito per anticipare lo scambio è stato fatto da Sabin per una sua particolare esigenza. Se guardi lo schema riprodotto in questo post vedrai che un partitore di tensione c'è ed è indispensabile essendo il cuore di questa modesta applicazione.



Il partitore di tensione è il sensore della tensione delle batterie, è usato dall'arduino per decidere quando scambiare.

Ok quindi devo Acquistare anche io il partitore.
Che mi condigliate visto che lavoro a 48v.
Io volevo staccare a 49v per non solfatare assai le batterie

Ti consiglio vivamente di leggere le prime pagine della discussione, così perdi solo tempo. Il partitore non si compra, si fa con due resistenze ed un diodo zenner, è tutto spiegato. Nel tuo caso occorre una resistenza da 25K ed una resistenza da 1K.

Leggi, non si può spiegare sempre tutto da zero.

Ok

Ecco l'ultimo schema che propongo.
Per non creare confusione ho evitato di fare alcuni collegamenti ovvi,
tipo alimentazione relè, e simili.
Nell'ultimo codice di Calcola mi pare che si utilizza A0 per lettura tensione,
pin 4 per il relè (non ho messo il led), e pin 5 per il led.
Sul led propongo una resistenza da 500 ohm per avere una luce evidente,
a 1000 per ridurre un po la luminosità.
Consiglierei di mettere arduino su uno zoccolo (header pin female), in caso
di problemi si può sostituire senza dissaldare, o si evita di fare una nuova scheda.
Nel disegno ho tratteggiato l'area arduino, che si potrebbe realizzare per come si vede.
Si parlava del partitore. Serve per interfacciare una corrente troppo alta per
arduino, e ridurla ad un livello che non crei danni. Da una prova con alimentazione
simulata, 24v al partitore la riduce a 2v.. 30v diventano 2,5v.

Immagine Allegata: 140627_semplice.png
 

Grazie al recente aiuto di elettro abbiamo assodato che è meglio regolare la tensione di alimentazione non a 5,5V,ma a 5V. Tensioni superiori a 5V si possono usare per alimentare l'arduino dal pin RAW.
Ho sempre usato il pin A0 per il partitore ed i pin 4 e 5 per i led verde e rosso.

CITAZIONE (calcola, 02/07/2014 22:01:12 )

CITAZIONE (ElettroshockNow, 04/07/2014 18:46:10 )

Va bene quello.

Allora ci sono oggi è arrivato l'ultimo pezzo e ho finito il circuito ora inserisco la programmazione e vedo come va che domani devo partire inserisco le foto.
inserisco il listato cosi:
//Inizio listato
//prodotto da calcola (antrec.geo@yahoo.com)//
//ver.3_2
//#include "OneWire.h"
#include "Wire.h"

////////////////////////////////
//INIZIO PARTE MODIFICABILE
///////////////////////////////
#define tensione_bassa 48.5 //valori: 11.9 (sistema 12V); 23.8 (sistema 24V)
#define tensione_alta 49.5 //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

Immagine Allegata: 20140717_174012.jpg
 

Prima di partire verifica bene il funzionamento della scheda e del partitore, nella scheda non mi sembrano adeguati quei ponticelli fatti con filo di rame scoperto, per il resto sembra a posto. La versione 3.2 del software è obsoleta, dovresti caricarne una più recente, controllo quale è la più adatta per la tua scheda e la posto.

La versione 3.8 è la più adatta, ho disabilitato la possibilità di impostare le variabili da monitor seriale.
ATTENTO: La versione 3.2 che hai postato sopra è corrotta, mancano delle ")"

//Inizio listato
//prodotto da calcola (antrec.geo@yahoo.com)//
//ver.3_8_3 - Senza la possibilità di impostare le variabili da monitor seriale
// - Ritardo gestito con millis
//
//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"

////////////////////////////////
//INIZIO PARTE MODIFICABILE
///////////////////////////////

float coefficiente_conversione = 0.0552; //arrotondare alla 4.a cifra decimale
float tensione_bassa = 11.9; //valori: 11.9 (sistema 12V); 23.8 (sistema 24V)
float tensione_alta = 13.7; //valori: 13.7 (sistema 12V); 27.4 (sistema 24V)
byte pausa = 8; //ritardo in secondi per compensare brevi abbassamenti di tensione

///////////////////////////////
//FINE PARTE MODIFICABILE
///////////////////////////////


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 (tensione_bassa/coefficiente_conversione) // Valore numerico della tensione stop batt ritorno rete
#define altatensione (tensione_alta/coefficiente_conversione) // Valore numerico tensione stop rete passo batt.
#define media1 (bassatensione + altatensione)/2 // Media tensione per avvio numero
#define media_avvio media1*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);
Wire.begin();
pinMode(RELAY1, OUTPUT);
pinMode(RELAY2, OUTPUT);
pinMode(inputPin, INPUT);

{
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 ((media_tens_volt < tensione_bassa) && (enel0 != 1) && (stato != 1))
{
ritardo();
}
if (stato == 1){
b=millis();
if ((b-a > rit) && (media_tens_volt < tensione_bassa)){
enel();
}
}
if(media_tens_volt > 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(tensione_bassa);
Serial.print(" Passa a batterie quando maggiore di: ");
Serial.println(tensione_alta);
Serial.println("-----------");
Serial.print("Ritardo commutazione: ");
Serial.println(pausa);
Serial.print("Coefficiente di conversione: ");
Serial.println(coefficiente_conversione,4);
Serial.println("-----------");
Serial.println("v: 3_8_3");
//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*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 = pausa*1000;
a = millis();
stato = 1;
}
//Fine listato

pazienza il tempo era poco è non l'ho potuto verificare. quando hai postato ero gia arrivato a destinazione in settimana tenterò di finire il lavoro