CITAZIONE (shadowcaster, 14/02/2014 07:06:14 )

OK. Grazie!

I pin VCC e GND sono tutti uguali, puoi scegliere quello più comodo in base al tuo circuito. Attento che vanno usati solo per alimentare l'arduino, non è buona cosa usarli per alimentare i circuiti che andrebbero alimentati sempre dalla 5V che arriva dall'alimentatore. Infatti la corrente circolante dentro i circuiti dell'arduino pro-mini è di pochi mA, se si supera si brucia. Se osservi lo schema pubblicato all'inizio della discussione vedrai che tutti i circuiti prendono la +5V direttamente dall'alimentatore.

Per alimentare pulsanti (menu) led e LCD non ci sono problemi.
Mentre per i relè, il calo di tensione si vede.

Proprio così, non bisogna superare mai i 40 mA per gli arduino uno, mentre pare che i pro-mini siano più robusti ed arrivano fino a 150 mA, però prendi questa affermazione con beneficio d'inventario, l'ho letta in una descrizione della scheda, ma non l'ho mai verificata.

Salve e grazie a tutti...penso proprio che inserirò un diodo solo vs Arduino...
Un'altra domanda, io sono fissato con i circuiti stampati, esiste una versione del relè da 5V x PCB? Ne ho trovate tante ma non capisco quale sia quella che fa caso nostro...

Qualunque relè per PCB da almeno 10A a 30v DC, va bene. Purtroppo i soli relè costano di più di uno zoccoletto già fatto, ti conviene inserire quello in un lato della scheda. Potresti staccare i contatti e spostarli sotto, sulla scheda in corrispondenza puoi preparare le piazzole per la saldatura.

Io ho rinunziato a fare una sola scheda con tutto dentro, troppi problemi, meglio una scheda con arduino e dei connettori per il collegamento, tutte le altre schede a girare. Il tutto fissato su uno spezzone di compensato o volendo di vetronite. Questa è la configurazione che si presta meglio per il nostri impianti, è modulare ed in caso di guasto facilmente riparabile in breve tempo, è sufficiente sostituire il modulo guasto e ripararlo successivamente.

CITAZIONE (calcola, 16/02/2014 19:06:36 )

Questa è la scheda che ho prodotto:

La avvito ad un supporto, metto le schede che servono e poi il tutto dentro una scatola, per precauzione metto sempre una ventolina 5V per il raffreddamento dell'atmega. La ventola la faccio accendere a 45°C e spegnere a 40°C, non dovrebbero esserci problemi di raffreddamento. ma per precauzione... Volendo si potrebbe usare l'uscita della ventola per pilotare direttamente il contattore od altro.

Nuova versione del codice, ora memorizza le variabili nella memoria interna, permette anche la modifica da monitor seriale del coefficiente di conversione. Ritardo di commutazione gestito in millis, quindi durante la pausa l'esecuzione del software non si arresta. La pausa avviene nei secondi impostati + 3 secondi fissi che i delay durante la visualizzazione dei dati a monitor seriale impongono. Quindi tenetene conto, se impostate 8 sec, il tempo di pausa effettivo sarà di 11-12 secondi.

//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(" 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);
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

Scordavo, ora le variabili sono memorizzate sulla eeprom dell'arduino (1024byte max per l'atmega328), se per qualche motivo volete ritornare ai valori della configurazione iniziale e pulire la eeprom, potete farlo caricando il codice "eeprom clear" presente tra gli esempi dell'IDE. Poi è necessario ricaricare il codice di gestione.

Che dire...Complimenti!!! Tanta passione è rara...

Potrebbe servire? http://www.elettronicaincorso.it/diodi_zener.html

calcola con il tuo pro mini neanche il minimo problema!!
Da subito sono riuscito a caricare il programma blink modificato!! Che bello!! Posso cominciare anche io!
A questo punto i due pro mini che ho preso io sono entrambi difettosi.. Speriamo che gli altri che devono arrivare siano migliori... grazie ancora e a buon rendere!