CITAZIONE

Quindi calcola se io prima carico il bootloader corretto (il tipo di bootloader viene scelto selezionando il tipo di Arduino?) e poi carico il programma con la voce "Carica con programmatore" il bootloader viene sovrascritto dal programma?
Giusto per capire bene tutte le opzioni disponibili e così essere in grado di usarle come si deve..
Il programmatore non è altro che un tipo di Arduino! Infatti il processore è sempre un Atmel (non ricordo bene quale).

CITAZIONE

Se al progetto si vuole collegare una scheda ethernet si può acquistare questa:


E' possibile collegarla al pro mini mediante ponticelli, attenzione a scegliere una scheda basata sul microprocessore W5100, è già dotata di scheda SD.

pro-mini --> ethernet
pin 10 --> pin10
pin 11 --> pin 11
pin 12 --> pin12
pin 13 --> pin13
vcc --> vcc+5V
gnd --> gnd
rst --> rst

Come software è possibile caricare quello proposto da emanuele78 a pagina 30 oppure il seguente programma che ho adattato usando il contributo di emanuele78.

LINK

Dopo varie peripezie tra programmatori,arduino,bootloader,softwere finalmente sono arrivato alla fine,volevo ringraziare tutti,calcola in particolare,per questa guida fatta veramente bene e comprensibile a tutti anche a duri come me...

Immagine Allegata: image.jpg
 

Ottimo, ordinata e ben fatta, carica la versione 3.8 sono convinto che sia la migliore e mi raccomando fai sapere come va.

PS: perchè non hai messo i led di stato? Personalmente li trovo molto utili.

Grazie ,non ho messo il led perché la associo ad un progettino,trattato in un'altro tread,che inserisce un ritardo di 3 secondi nello scambio che già funziona da tempo nel mio impianto dove ho inserito li i led di stato.
Illuminami sulla versione 3.8,io ho montato il listato di pagina 21 da te fatto modificando appena le soglie......se devo dire la verità ho trovato qualche problema nel coefficiente di conversione,giusto oggi Fastweb ha deciso di lasciarmi senza connessione,quindi non potendo leggere tutta la discussione in merito,quello caricato non tornava con le tensioni da me riscontrate quindi sono andato avanti a tentativi.....ti puoi immaginare....la cosa strana che dettata la soglia inferiore a 23.8v e superiore a 27.4v mi ritrovo con il passaggio ad Enel si a 23.8 ma provando con l'alimentatore il ritorno ad isola a 27.7 anziché a 27.4.
Va' bene anche così ma la curiosità di sapere come mai è piuttosto forte.
Grazie ancora ,vi farò sapere una volta accoppiata come funziona..........

Dimenticavo qualche particolare,ho programmato il mini pro con un programmatore usb asp caricando direttamente il listato quindi sovrascrivendo sul bootloader visto che quello montato nella mia scheda era quello ad 1mhz e con il seriale non mi permetteva di caricare il softwere.......soluzione sempre segnalata in questa discussione semplice ed intuitiva

La versione 3.8 è stata pubblicata a pagina 26 della discussione comunque la replico di seguito:

//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);
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(" Tensione batteria all'avvio, valore intermedio tra min-max: ");
Serial.println(media_avvio);
Serial.println("-----------");
Serial.print(" Tensione 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);
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


Va bene caricare il listato direttamente, senza bootloader, al momento è lo stesso però con la prossima modifica non sarà più indifferente, in quanto verrà aggiunto l'auto riavvio in caso di blocco e quello per funzionare richiede il bootloader dell'arduino uno. Per settare il corretto coefficiente di conversione occorre avviare la scheda e lasciarla in funzione per qualche ora in modo da riscaldare bene le resistenze del partitore.
Successivamente bisogna aprire il monitor seriale e leggere il numero che appare dopo la lettura della tensione media che ora chiamo "valore a", quindi dopo aver letto con un voltmetro la tensione ai poli della batteria (non all'ingresso della scheda proprio ai poli della batteria) occorre dividere la tensione con il "valore a", il risultato ottenuto è il nuovo coefficiente di conversione. Il nuovo valore è possibile usarlo per sostituire quello indicato nel listato oppure, in alternativa, si può scrivere la parola soglie sulla riga alta del monitor seriale e poi enter, il programma chiederà i vari valori delle soglie in successione, compreso il coefficiente di conversione, inserire il valore usando "." come separatore decimale. Inserire solo i valori che si intendono modificare, non inserire nulla per i valori che vogliono essere mantenuti. Se il partitore funziona bene il numero letto sul monitor deve essere stabile al massimo si può accettare l'oscillazione di una unità, in tal caso è consigliabile usare il valore medio.

La versione del software 3.8 aggiunge le seguenti funzionalità alla versione 3.4:

1) i valori delle soglie sono ora impostabili tramite monitor seriale e memorizzati nella eeprom, quindi le nuove impostazioni sono mantenute anche spegnendo la scheda e senza dover ricaricare il software;
2) è stata inserita una nuova gestione del tempo di ritardo impostabile per il rientro alla rete in caso di batterie scariche. Ora quando si scende sotto la soglia minima la commutazione non è più istantanea il sistema attende il numero di secondi impostato, quindi rilegge la tensione se è ancora sotto la soglia di commutazione passa alla rete altrimenti resta a batterie. La funzione è utile per evitare commutazioni a seguito di abbassamenti di tensione momentanei. Il ritardo inserito non ferma l'esecuzione del listato come accade nella versione 3.4/3.5.

sempre chiaro ottimo allora provvedo......

Caricata la 3.8 e provata sul banco tutto perfetto,il ritardo inserito nel listato si fa sentire alla perfezione,quindi l'ho associata al rele' di scambio.........amore a prima vista.
Gran bel lavoro,credo che un ringraziamento al suo ideatore,a chi ha contribuito alla sua realizzazione sia d'obbligo.

Purtroppo l'unico contributo è stato per la realizzazione della 3.8 versione ethernet di cui al link presente nel quarto post di questa pagina, per il resto di aiuti nisba... e si che ogni contributo sarebbe gradito ed apprezzato.

CITAZIONE (alexamma, 03/04/2014 17:28:33 )

Caricata la 3.8 e provata sul banco tutto perfetto,il ritardo inserito nel listato si fa sentire alla perfezione,quindi l'ho associata al rele' di scambio.........amore a prima vista.
Gran bel lavoro,credo che un ringraziamento al suo ideatore,a chi ha contribuito alla sua realizzazione sia d'obbligo.

Salve a tutti...
So che è antieconomico, ma vorrei inserire un mosfet di potenza al postò del relè da 5V. Vorrei capire come scegliere le resistenze da inserire tra Source e Gate e come scegliere quella che dal pin arduino arriva al Drain. Potreste indirizzarmi o dare qualche dritta?
Grazie e a presto.