Deviatore Automatico

Come da titolo, sono intenzionato nella realizzazione di un deviatore automatico ovvero un sistema che possa “deviare” il carico da una alimentazione verso un’altra nel caso in cui una di questa raggiunga un valore di tensione troppo basso.

In particolare sto tentando di realizzare un sistema che sia in grado di:

  • rilevare la tensione di una batteria

  • determinare se tale valore sia compreso in una certa soglia di intervento (ad esempio < 11V)

  • preventivamente allo scambio dell’alimentazione faccia avviare un alimentatore (precedentemente in modalità di stand-by) e ne controlli lo stato di funzionamento
    N.B: per stato di funzionamento intendo la lettura di segnali che determineranno:

  1. la presenza di tensione dell’alimentatore [in stand-by]
  2. lo stato del segnale DC-OK fornito dall'alimentatore [in funzione]
  3. il valore della tensione erogata dall'alimentatore [in funzione]
  • in caso che tale tensione rientri nei valori nominali faccia chiudere o aprire in sequenza due relè che effettivamente si prenderanno in carico di commutare il carico da una sorgente verso l’altra.

  • nel caso non si verifichi tale condizione lo notifichi (con un buzzer e/o led)


Secondo la mia idea poi tale procedimento dovrà essere reversibile quindi in caso la tensione della batteria ritorni ad essere a valori normali (ad esempio > 12.8V) il sistema dovrà:

  • chiudere o aprire in sequenza i due relè che riporteranno l’alimentazione del carico verso la batteria

  • dopo aver atteso un certo periodo di tempo (3 secondi) riportare in stand-by l’alimentatore

Questo è il funzionamento in linea generale del sistema che ho in mente, purtroppo però, sto avendo diverse difficoltà nello sviluppo di un codice che permetta di fare tutto ciò che ho appena descritto.
Così dopo aver provato per settimane nel tentare di risolvere questo problema mi sono deciso nel chiedere aiuto tramite il forum poiché dalle mie ricerche in internet non ho trovato nulla di simile .

Detto ciò posto anche il mio attuale codice (che però non funziona per nulla) in cui ho omesso la parte di set-up poiché oltre alla inizializzazione dei pin come input o output e la definizione di un riferimento di tensione esterno a 2,50V aveva ben poco.

void loop(){
	
	//V_BATT = ((analogRead(V_BATT_pin) * 2.50)/1023.00) * A;
	
	V_BATT 	   = 0;
	V_BATT_SUM = 0;
	
	//V_BATT SENS.
	for(int i = 0; i < 10; i++) {
		V_BATT_SUM += ((analogRead(A0) * 2.50)/1023.00) * ((R1+R2)/R2);
		delay(20);
		}
		
	V_BATT = V_BATT_SUM / 10.00;
	
	
	V_PSU 	   = 0;
	V_PSU_SUM  = 0;
	
	//V_BATT SENS.
	for(int i = 0; i < 10; i++) {
		V_PSU_SUM += ((analogRead(A1) * 2.50)/1023.00) * ((R1+R2)/R2);
		delay(20);
		}
		
	V_PSU = V_PSU_SUM / 10.00;
	
	
	if (V_BATT >= 12.30){
		
		if ((GRID_ACT == false) && (BATT_ACT == false)){
			do {
				digitalWrite(K1A_pin,HIGH);
				delay(30);
				digitalWrite(K1B_pin,LOW);
				
				BATT_ACT = true;
			} while(BATT_ACT == false);
		}
		
		if (GRID_ACT == true){
			do {
				digitalWrite(K1A_pin,HIGH);
				delay(30);
				digitalWrite(K1B_pin,LOW);
				delay(1000);
				
				digitalWrite(PSU_EN_pin, LOW);
				
				GRID_ACT == false;
				BATT_ACT == true;
			} while (BATT_ACT == false);
		}
	}
	
	if (V_BATT < 11.00){
	
		if ((GRID_ACT == false) && (BATT_ACT == false)){
			
			if ((digitalRead(PSU_ONLINE_pin)) == HIGH){
				digitalWrite(PSU_EN_pin, HIGH);
				delay(800);
			}
			
			if ((digitalRead(PSU_ONLINE_pin)) == LOW){
				//ALLARME: RETE NON PRESENTE
				ALL_RNP ();
			}
			
			if ((digitalRead(PSU_ONLINE_pin) == HIGH) && (digitalRead(PSU_DC_OK_pin) == HIGH) && (V_PSU > 10)){
				delay(3000);
				
				do {
				digitalWrite(K1A_pin,LOW);
				delay(30);
				digitalWrite(K1B_pin,HIGH);
				delay(1000);
				
				GRID_ACT == true;
				BATT_ACT == false;
				} while (BATT_ACT == false);
			}
			
			if ((digitalRead(PSU_ONLINE_pin) == LOW) || (digitalRead(PSU_DC_OK_pin) == LOW) || (V_PSU < 10)){
				//ALLARME: ALIMNETATORE NON AVVIATO O ALIMENTAZIONE FUORI LIMITE
				ALL_ANA_AFL ();
			}
		}
	}
	delay(2500);
}



//ALLARME: RETE NON PRESENTE
void ALL_RNP (){
	serial.println("ALLARME RETE NON PRESENTE");
}



//ALLARME: ALIMENTATORE NON AVVIATO O ALIMENTAZIONE FUORI LIMITE
void ALL_ANA_AFL (){
	serial.println("ALLARME ALIMNETATORE NON AVVIATO O ALIMENTAZIONE FUORI LIMITE");
}

Dove:

V_BATT: contiene il valore della tensione della batteria (di tipo double)
V_BATT_SUM: contiene le somme di 10 rilevazioni per fare la media aritmetica (di tipo double)
V_PSU: contiene il valore della tensione dell’alimentatore (di tipo double)
V_PSU_SUM: stesso di V_BATT_SUM ma per l’alimentatore (di tipo double)

GRID_ACT: variabile che salva lo stato della modalità a rete [true=attiva false=non attiva] (di tipo bool)
BATT_ACT:variabile che salva lo stato della modalità a batteria [true=attiva false=non attiva] (di tipo bool)

Come hardware utilizzo un Arduino NANO e poi sono definiti come:
K1A relè collegato alla batteria
K1B relè collegato all’alimentatore

PSU_ONLINE: è allo stato HIGH quando l’alimentatore ha tensione e resta cosi anche quando è acceso
PSU_DC_OK: è allo stato HIGH quando l’alimentatore fornisce una tensione entro i limiti

PSU_EN: è un segnale che deve fornire l'aurduino e quando questo è allo stato HIGH l’alimentatore è acceso mentre quando questo è allo stato LOW l'alimentatore è in stand-by.

Fornisco in oltre un schema elettrico della parte dei relè per poter far comprendere meglio qual’è la tipologia del circuito.

Spero, grazie all'aiuto del forum, di risolvere questo problema di natura software e mi scuso in anticipo se tale argomento non fosse in linea con il forum

Ringrazio in anticipo per le risposte fornite

Saluti

Per selezionare quale tensione ottenere in uscita, tra quella della batteria e quella dell'alimentatore, basta un semplice diodo.
La fonte di energia a tensione maggiore alimenterà il carico.
Con il sistema a relè potrebbe esserci un annanco di corrente spegnendo il carico.

Pero' lui parla di "alimentatore in standby", quindi immagino che quello "di scorta" non venga tenuto acceso sempre, ma acceso solo al momento in cui deve intervenire ... tuttavia, anche qui un bel paio di diodi robusti risolvono senza rele', dato che basta leggere le due tensioni prima dei diodi, ed accendere il secondo alimentatore quando il primo scende sotto la soglia ...

Per usare dei rele' in quel modo senza avere microinterruzioni bisognerebbe trovare dei vecchi rele' "telefonici", che erano meccanicamente differenti da quelli standard, perche' i deviatori chiudevano il contatto NA prima di aprire quello NC, al contrario di tutti i rele' standard (per evitare cadute di linea nelle commutazioni) ...

Pero' queste sono considerazioni hardware, l'OP ha chiesto per un problema software ...

I due diodi sui collettori sono collegati al contrario! Diodi e transistor si bruciano appena questi ultimi vanno in conduzione!

Innanzitutto volevo ringraziare tutti quelli che hanno risposto.
Risponderò ora ai vostri suggerimenti e consigli.

Arco_500:
Per selezionare quale tensione ottenere in uscita, tra quella della batteria e quella dell'alimentatore, basta un semplice diodo.
Con il sistema a relè potrebbe esserci un annanco di corrente spegnendo il carico.

Avevo già valutato la possibilità di non usare relè e utilizzare solo due diodi nella stessa configurazione dello schema che ho postato nel primo post ma la cosa che mi ha fatto desistere nell’utilizzare tale approccio è stato il fatto delle perdite di potenza a causa della caduta di tensione dei diodi che, soprattutto per le correnti che vorrei far scorrere, si trasformerebbe in una potenza termica non indifferente ed io vorrei evitare tutto questo.

Per il fatto dell’ammanco di tensione durante lo scambio ho già valutato tale tempo di “vuoto” è dell’ordine di 30 ms (misurato con una telecamera in slowmotion).
Se riesco a commutare tali relè conseguentemente ovvero spegnere uno ed accendere l’altro avrò un “buco” di tensione di 30ms medio
che potrò filtrare con una capacità a monte dello scambiatore adeguatamente dimensionata per scaricarsi in un tempo maggiore del tempo di scambio dei relè.


Etemenanki:
Pero' lui parla di "alimentatore in standby", quindi immagino che quello "di scorta" non venga tenuto acceso sempre, ma acceso solo al momento in cui deve intervenire ... tuttavia, anche qui un bel paio di diodi robusti risolvono senza rele', dato che basta leggere le due tensioni prima dei diodi, ed accendere il secondo alimentatore quando il primo scende sotto la soglia ...

Si esatto vorrei spegnere l’alimentatore anche perché date le potenze in gioco (200W) non mi converrebbe lasciarlo 24/24 h acceso e visto che è provvisto di tale funzionalità vorrei spegnerlo quando non necessario.
Un secondo aspetto che mi fa optare per questo approccio è il reperimento dei componenti che mi servono per tale sistema. Tali relè sono di tipo automotive e quindi di facile reperimento per me e comunque possono portare la corrente di cui necessito senza grossi problemi.


Datman:
I due diodi sui collettori sono collegati al contrario! Diodi e transistor su bruciano appena questi ultimi vanno in conduzione!

Si ammetto di aver sbagliato ma ho voluto dare una idea nello schema della configurazione dei relè.

Ringrazio tutti nuovamente per le vostre risposte e consigli
Purtroppo però per i vari motivi che ho descritto qui sopra preferisco ancora non usare diodi.

Saluti

Wally_rc3:
...
Per il fatto dell’ammanco di tensione durante lo scambio ho già valutato tale tempo di “vuoto” è dell’ordine di 30 ms (misurato con una telecamera in slowmotion).
...

Se non sbaglio a leggere lo schema, usi due diversi pin, uno per rele' ... riduci al minimo il tempo morto commutando quello che accende tipo 25mS prima di quello che spegne :wink:

(calcola pero' anche il ritardo in fase di spegnimento del rele' che stacchi, prima di decidere gli intervalli :wink: )

allora, cominciamo, vedere se ci ho capito giusto:

  1. batteria, che viene ricaricata a parte, altrimenti non potrebbe mai ri-guadagnare i 12.8 Volt per ricommutare indietro i teleruttori

  2. alimentatore, che ha due uscite : on line che indica che ha energia, power good che indica che è prono ad erogare corrente alla tensione desiderata

giusto fin qui?

noi non vogliamo usare dei diodi per non avere la caduta di tensione che ci sarebbe (nemmeno diodi Schottky?)

inoltre non ci fidiamo del power good, ma vogliamo leggere la tensione all'uscita dell'alimntatore, giusto?

OK

consigli:

  1. le variabili vanno minuscole
  2. il codice va indentato come K&R comandano, come lo hai messo tu è difficile da leggere causa troppi spazi (tabulazione troppo profonda)
  3. ma perché cercarsi casini leggendo una tensione dall'alimentatore quando leggi anche il power good?
  4. i tempi dei relè si risolvono in altra maniera:

alimentatore e batteria sono in parallelo sul carico attraverso due diodi Schottky (o anche normali) e il comune di un semplce teleruttore a scambio

se vai a batteria il teleeruttore è (per esempio) de-energizzato, contatto NC alimenta diretto il carico
se vai a corrrente il teleruttore è (per esempio) energizzato, contatto NA alimenta il carico
durante la commutazione uno o l'altro dei due diodi alimenta il carico

  1. inoltre il tuo sistema ha 3 stati, non due
    a va a batteria
    b va ad alimentatore
    c batteria scarica e alimentatore no good

quindi 3 stati di funzionamento

  1. altro consiglio, non fare le misure nel loop, chiama solo delle funzioni che restituiscono la tensione (e ti togli un problema, e anche per gli azionamenti, usa delle funzioni che ti restituiscono 1 per eseguito, 0 per anomalia

  2. il programma, in pseudocidice, potrebbe essere

void loop(void)
{
   switch (stato)
   {
     case 0: // a batteria
     // controllo solo la batteria
     if (vbat()<11)
     {
       //passo ad alimentatore
      if (alimentatore())
         {
         stato=2;
         }
      else
         {
         stato=3;
         }
      break;
      case 1: // alimentatore
      if (vabt()>12.8){
// e da qui sono sicuro che puoi proseguire da solo 
      }     
   }
}

Salve a tutti,

Etemenanki:
Se non sbaglio a leggere lo schema, usi due diversi pin, uno per rele' ... riduci al minimo il tempo morto commutando quello che accende tipo 25mS prima di quello che spegne :wink:

Si esatto, ho pensato l'utilizzo di due pin per non avere una posizione che possa selezionarsi nel caso la logica (l’Arduino )rimanga senza tensione questo è anche il motivo per cui non ho utilizzato relè con contatto NA/NC ma solo un contatto NA.
Comunque una volta arrivato ad un funzionamento stabile senza dubbio farò in modo di ottimizzare i tempi morti per ridurli al minimo.


Standardoil:
allora, cominciamo, vedere se ci ho capito giusto:

  1. batteria, che viene ricaricata a parte, altrimenti non potrebbe mai ri-guadagnare i 12.8 Volt per ricommutare indietro i teleruttori

  2. alimentatore, che ha due uscite : on line che indica che ha energia, power good che indica che è prono ad erogare corrente alla tensione desiderata

giusto fin qui?

si esatto tutto giusto la batteria viene caricata dal fotovoltaico

Standardoil:
noi non vogliamo usare dei diodi per non avere la caduta di tensione che ci sarebbe (nemmeno diodi Schottky?)

inoltre non ci fidiamo del power good, ma vogliamo leggere la tensione all'uscita dell'alimntatore, giusto?

esatto vorrei evitare di utilizzare diodi che possano portare a cadute di tensione e quindi a perdite di energia sotto forma di calore.
Dalle mie ricerche ho visto che anche un diodo Schottky mi porterebbe portare ad dissipare dai 7W ai 10W in potenza termica (nel caso peggiore ovvero di una corrente circolante molto alta, di circa 10A nel mio caso, certo tale corrente non sarà continuativa ma sto dimensionando tutto il sistema per tale corrente in modo da avere margine di sicurezza).
Quindi per questo motivo vorrei evitare i diodi.

La mia scelta di leggere la tensione dell’alimentatore in effetti sto notando essere ridondante e abbastanza senza senso poiché l’alimentatore già fornisce tale segnale e quindi penso di non utilizzarla per lo scambio.
Comunque poi tale misurazione la terrò utile lo stesso poiché questo sistema dovrà inviare via seriale tutte le tensioni in gioco (e anche correnti, misurate con relativo shunt) ad il sistema di monitoraggio.

Standardoil:

  1. le variabili vanno minuscole
  2. il codice va indentato come K&R comandano, come lo hai messo tu è difficile da leggere causa troppi spazi (tabulazione troppo profonda)
  3. ma perché cercarsi casini leggendo una tensione dall'alimentatore quando leggi anche il power good?
  1. pensavo che le variabili potessero assumere sia lettere maiuscole che minuscole così ho pensato di riflettere le denominazioni dei pin sul codice per evitare di fare confusione
  2. si ammetto di aver esagerato con i “TAB” :smiley:
  3. si come detto prima è un procedimento ridondante

Standardoil:
4) i tempi dei relè si risolvono in altra maniera:

alimentatore e batteria sono in parallelo sul carico attraverso due diodi Schottky (o anche normali) e il comune di un semplce teleruttore a scambio

se vai a batteria il teleeruttore è (per esempio) de-energizzato, contatto NC alimenta diretto il carico
se vai a corrrente il teleruttore è (per esempio) energizzato, contatto NA alimenta il carico
durante la commutazione uno o l'altro dei due diodi alimenta il carico

  1. questo punto non l’ho capito proprio bene, dovrei quindi unire un approccio con diodi e relè per utilizzare entrambi?
    Potrebbe essere una idea ma vorrei capire meglio qual’era il tuo suggerimento...

Standardoil:
5) inoltre il tuo sistema ha 3 stati, non due
a va a batteria
b va ad alimentatore
c batteria scarica e alimentatore no good

quindi 3 stati di funzionamento

  1. in effetti credo che sia l’approccio migliore in questo modo ,quindi non valutare lo stato c tramite l’else if durante ogni “lettura” dei segnali ma definire un caso di allarme nella stessa “forma” degli scambi da alimentatore o batteria.

Standardoil:
6) altro consiglio, non fare le misure nel loop, chiama solo delle funzioni che restituiscono la tensione (e ti togli un problema, e anche per gli azionamenti, usa delle funzioni che ti restituiscono 1 per eseguito, 0 per anomalia

  1. ok, credo di aver capito cioè quindi fare una funzione che l’unico scopo sia effettuare le misure e fornire i valori
    stessa cosa quindi per le funzioni che definiscono quando scambiare e in caso o no di scambio, forniscano solo un valore 0 o 1 che possa essere utilizzato nel resto del codice. Corretto?

Standardoil:
7) il programma, in pseudocidice, potrebbe essere

void loop(void)

{
  switch (stato)
  {
    case 0: // a batteria
    // controllo solo la batteria
    if (vbat()<11)
    {
      //passo ad alimentatore
      if (alimentatore())
        {
        stato=2;
        }
      else
        {
        stato=3;
        }
      break;
      case 1: // alimentatore
      if (vabt()>12.8){
// e da qui sono sicuro che puoi proseguire da solo
      }   
  }
}

  1. si ,credo di aver capito grazie per l’utilissimo esempio

Ora mi metterò a lavorare per definire una nuova versione del codice (cestinando quella vecchia :smiley: ) con i nuovi concetti e forme consigliate da voi.

Grazie
Saluti

Wally_rc3:
Ora mi metterò a lavorare per definire una nuova versione del codice (cestinando quella vecchia :smiley: ) con i nuovi concetti e forme consigliate da voi.

Grazie
Saluti

Bravo

Come dico sempre: ci si mette meno a ripartire da capo

Per i diodi

Ora non ho sottomano un pc per disegnare

Rileggi con calma:

Batteria -> diodo ->
-> contatto nc -> carico

Alimentatore -> diodo -> carico
-> contatto na -> carico

Standardoil:
...
Ora non ho sottomano un pc per disegnare
...

Hai provato il cad "carta&matita" ? ... funziona dappertutto, anche senza alimentazione, e perfino senza PC ... :wink:

(scusa, non ho resistito :D)

Ma avendo traffico in gonnella....

Tu che avresti fatto?

Ah, be ... quello ha la precedenza, di traffico ... anche perche' se non glie la concedi, di solito poi son guai :smiley:

Standardoil:
Bravo

Come dico sempre: ci si mette meno a ripartire da capo

Si esatto poiché il tempo per correggere tutto sarebbe stato sicuramente maggiore del tempo che impiegherò per riscrivere da zero il codice. :grinning:
Cosa che credo di fare nel fine settimana poichè nel resto della settimana sono impegnato. :smiley:

Standardoil:
Per i diodi

Rileggi con calma:

Batteria -> diodo ->
-> contatto nc -> carico

Alimentatore -> diodo -> carico
-> contatto na -> carico

Ok, credo di aver capito come posizionare i diodi, in questa maniera il diodo è in parallelo al contatto del relè e quindi quando chiude il contatto la corrente viene deviata dal diodo al contatto.
Però non capisco che utilità avrebbe una configurazione del genere, credo però che potrebbe aiutare nella commutazione poiché prima che tale azione venga effettuata l’altro diodo farà passare la corrente per la tensione dell’alimentatore che sarà più alta della tensione della batteria.
Però non credo che tale configurazione migliori le cose perché prima della commutazione l’alimentatore è spento e quindi solo un diodo sarebbe in conduzione che però è il diodo che è deviato dal relè attivo e quindi non passerebbe corrente.
L’unica cosa che potrebbe variare è nella condizione in cui tutti e due i relè sono spenti.

Cosi ho capito il tuo suggerimento Standardoil e di seguito metto anche un schema dello schema con l’aggiunta dei diodi.

Diodi che ho posizionato tramite un doppio diodo Schottky (STPS3045CW) con corrente massima ammessa per diodo di 15A.
(Componenti che ho recuperato da un alimentatore da PC guasto)

Altra cosa che poi tengo a precisare è che per sicurezza ho aggiunto lo stesso doppio diodo a valle del commutatore in modo da evitare che una sovratensione del condensatore rispetto all’alimentatore, possa provocare una corrente inversa dannosa per l’alimentatore ed altre parti del circuito (dovuta all’alta capacità del condensatore per far fronte al vuoto durante lo scambio).

In questo caso ho collegato i due anodi dei due diodi in parallelo in modo cercare di ripartire la corrente attraverso i due diodi e ridurre (si spera) la caduta di tensione.
E’ presente poi una resistenza di bleeder per scaricare la capacità.

Saluti

Buonasera,
aggiorno con un nuovo messaggio questo thread per innanzitutto farmi vivo in quanto sono rimasto in silenzio per un po' di tempo.

Tornando al codice, non sono giunto ancora ad una versione “stabile” del codice, se è per questo nemmeno a qualcosa che si avvicini ad essere chiamato codice :smiley: .
Sto avendo problemi poiché credo di non aver molto chiaro il “percorso” che dovrei seguire.

Mi spiego meglio,come suggeritomi da Standardoil , ho bisogno di una funzione switch che definisca 3 stati fondamentali del sistema, questi stati sono numerati all’interno della variabile stato che definisce con:
0: batteria
1: alimentatore
2: anomalia

Successivamente all’interno di ogni stato vengono definiti delle funzioni ifche richiamano altre funzioni il cui compito è fornire un valore in caso gli altri componenti del sistema sia ok oppure non ok.

Inoltre devo definire altre funzioni che leggano le tensioni.
Cosa che io in precedenza cercavo di fare nel loop (un po' per pigrizia nello scrivere dell’altro ho omesso) ma per comodità meglio far svolgere in funzioni ad-hoc.
In secondo luogo sto valutando la possibilità se utilizzare funzioni che restituiscano il valore direttamente oppure porre le variabili con il valore dall’interno della funzione per poi utilizzare solo la variabile con il valore di cui necessito.
Spero di essermi spiegato correttamente

Ora detto tutto ciò io non mollo e sono determinato a portare a termine il progetto, ma ho bisogno di confrontarmi con qualcun'altro che la pensi o meno come me.

Ringrazio in anticipo per l’aiuto
Saluti

Wally_rc3:
In secondo luogo sto valutando la possibilità se utilizzare funzioni che restituiscano il valore direttamente oppure porre le variabili con il valore dall’interno della funzione per poi utilizzare solo la variabile con il valore di cui necessito

Dipende. Il primo modo è quello "canonico", ma se quel valore deve servire in più punti forse meglio chiamare prima una funzione che effettua le letture e valorizza le variabili necessarie, e poi nel resto del programma si possono usare i valori delle variabili (è anche più veloce nell'esecuzione).

Questo secondo sistema porta in modo naturale a scrivere un'elaborazione a blocchi successivi che può semplificare molto una logica che pensata invece in modo "monolitico" sarebbe troppo complessa.

Faccio un esempio, immaginiamo di voler rilevare un click, un doppio click o una pressione lunga, e al contempo voler realizzare un debounce software. Tutto questo pensato in un unico blocco è molto (troppo) complesso. Ma se scriviamo prima un blocco che legge l'ingresso e ne fa il debounce valorizzando una variabile (che rappresenta l'ingresso filtrato), poi la logica di analisi dei tempi può fare riferimento alla variabile senza più occuparsi di debounce o livelli degli ingressi ecc.

In sostanza tramite le variabili puoi subito fare astrazioni sull'hardware e ragionare con una logica più semplice.

Invece per il resto del discorso si, suddividere esplicitamente l'elaborazione nei vari stati in cui il sistema si può trovare (tramite il test su una o più variabili di stato) e pensare nei termini di "in questo stato se succede questo faccio quest'altro" è il modo più generale e semplice per scrivere qualsiasi automazione (anche composta di N processi portati avanti in parallelo, sia indipendenti che cooperanti), quindi è senz'altro l'investimento in tempo studio più sensato.

Hai uno schema definito?

Da questo schema 'estrai' l'interfaccia con arduino

E questo ti dà le varie pinmode e frittura mista per cominciare il programma

Buonasera,

Claudio_FF:
Dipende. Il primo modo è quello "canonico", ma se quel valore deve servire in più punti forse meglio chiamare prima una funzione che effettua le letture e valorizza le variabili necessarie, e poi nel resto del programma si possono usare i valori delle variabili (è anche più veloce nell'esecuzione).

Questo secondo sistema porta in modo naturale a scrivere un'elaborazione a blocchi successivi che può semplificare molto una logica che pensata invece in modo "monolitico" sarebbe troppo complessa.

quindi in generale dipende dai casi e dalle applicazioni in particolare…
Tuttavia nella mia applicazione mi converrebbe restare nell’approccio che hai descritto Claudio_FF quindi valorizzare la variabile nella funzione separata per poi utilizzare tale valore in vari punti del programma per esempio.
E poi ora che ci penso l’approccio a blocchi che descrivevi tu, non mi sta per nulla antipatico anzi, lo preferisco anche perché poi ho già utilizzato questo approccio in progetti passati come ad esempio nel mio penultimo thread.:

https://forum.arduino.cc/index.php?topic=691477.0

dove nella query (che è una funzione separata dal loop) vengono ottenute le variabili per poi essere mostrate su lcd attraverso una funzione separata.

Claudio_FF:
Invece per il resto del discorso si, suddividere esplicitamente l'elaborazione nei vari stati in cui il sistema si può trovare (tramite il test su una o più variabili di stato) e pensare nei termini di "in questo stato se succede questo faccio quest'altro" è il modo più generale e semplice per scrivere qualsiasi automazione (anche composta di N processi portati avanti in parallelo, sia indipendenti che cooperanti), quindi è senz'altro l'investimento in tempo studio più sensato.

Per quanto riguarda questo, si dopo ulteriori pensieri (:D) sono giunto alla conclusione che andrò avanti in questo modo.

Ora vediamo quindi se ho capito….
quindi il mio codice sarà in futuro composto da vari blocchi così ordinati all’interno del loop:

NB: che a loro volta faranno parte di funzioni o meno

1- letture tensione batteria (o altro)

2- definizione dello stato tramite degli if
una volta letto la tensione dovrò valutare come “impostare” il sistema se a batteria o valutare per l’alimentatore

3- funzione a batterie

4- funzione ad alimentatore
in questo caso quindi agirò quindi valutando se il PSU è ok oppure no

5- anomalie varie

Spero che con questo elenco sia riuscito a mostrare ciò che ho in mente e da questo mi sia anche più chiaro a me il procedimento.


Standardoil:
Hai uno schema definito?

Da questo schema 'estrai' l'interfaccia con arduino

E questo ti dà le varie pinmode e frittura mista per cominciare il programma

si si, ho due schemi, uno è lo schema elettrico dell’hardware e poi ho costruito un diagramma di flusso per capire cosa a grandi linee dovrò fare nel codice ma sto pensando di rifare completamente anche se credo di aver capito ora come devo fare, (credo :D)

Detto questo continuerò il mio lavoro su questo progetto credo che in questo fine settimana avrò i primissimi risultai

ringrazio nuovamente per tutti i suggerimenti dati fino ad ora

Saluti

Mi inserisco per alcune osservazioni che potrebbero tornare utili (come anche no, in tal caso ignorare pure questa risposta, non mi offendo)

Wally_rc3:
Dalle mie ricerche ho visto che anche un diodo Schottky mi porterebbe portare ad dissipare dai 7W ai 10W in potenza termica (nel caso peggiore ovvero di una corrente circolante molto alta, di circa 10A nel mio caso, certo tale corrente non sarà continuativa ma sto dimensionando tutto il sistema per tale corrente in modo da avere margine di sicurezza).
Quindi per questo motivo vorrei evitare i diodi.

I STPS3045CW sono diodi doppi con Vf = 0,57V se non ho letto male il datasheet.
Tu dici che il caso peggiore ha corrente 10A
Perchè calcoli una potenza dai 7W ai 10W?
Che ne usi uno solo o li metti in parallelo hai P = V * I = 0,57V * 10A = 5,7W, stessa cosa se fai 2 * (0,57V * 5A)
Tu hai calcolato un max 10W perchè hai guardato caratteristiche di altri diodi?

Wally_rc3:
In questo caso ho collegato i due anodi dei due diodi in parallelo in modo cercare di ripartire la corrente attraverso i due diodi e ridurre (si spera) la caduta di tensione.
E’ presente poi una resistenza di bleeder per scaricare la capacità.

Come scritto sopra, mi sa che al fine della tensione o della potenza cambi poco, però ripartendo in questo modo i due diodi interni dovrebbero lavorare comunque meglio ripartendosi il carico di lavoro e quindi restando più bassi rispetto ai loro massimi di utilizzo.
Quindi va bene anche se mi sa non otterrai l'effetto sperato sulla tensione.

Wally_rc3:

  1. pensavo che le variabili potessero assumere sia lettere maiuscole che minuscole così ho pensato di riflettere le denominazioni dei pin sul codice per evitare di fare confusione
  2. si ammetto di aver esagerato con i “TAB” :smiley:

Le "regole" suggerite non sono regole, ma convenzioni per avere uno standard di facile lettura per tutti.
Usarle evita a chi legge il codice di andare a cercare le dichiarazioni iniziali per capire di cosa si tratti.

Wally_rc3:
6) ok, credo di aver capito cioè quindi fare una funzione che l’unico scopo sia effettuare le misure e fornire i valori
stessa cosa quindi per le funzioni che definiscono quando scambiare e in caso o no di scambio, forniscano solo un valore 0 o 1 che possa essere utilizzato nel resto del codice. Corretto?

Questo aiuta a tenere il codice snello isolando task specifici in funzioni specifiche e tendenzialmente dal nome autoesplicativo, così da aumentare la leggibilità del codice e la riusabilità di queste funzioni.
Isola anche i problemi che possono essere affrontati singolarmente.
Ad es. se non sai come fare le letture, puoi creare la funzione vuota e fare il resto del programma e poi concentrarti su quella senza avere tutto il resto per la testa.
Con questo approccio, puoi creare tutto lo scheletro del programma prima ancora di aver pensato a come risolvere i vari sottoproblemi, ma avendo solo in testa il risultato desiderato.

Wally_rc3:
quindi in generale dipende dai casi e dalle applicazioni in particolare…
Tuttavia nella mia applicazione mi converrebbe restare nell’approccio che hai descritto Claudio_FF quindi valorizzare la variabile nella funzione separata per poi utilizzare tale valore in vari punti del programma per esempio.

Una strada iniziale, potrebbe essere di mescolare i due approcci top-down e bottom-up per arrivare a convergenza.
Approccio bottom-up: identifichi le operazioni atomiche, cioè quelle più piccole e autonome possibili, es. la lettura di una tensione.
Approccio top-down: identifichi una condizione particolare che ti determina una scelta nel tuo processo principale, es. batteria scarica.
A questo punto puoi impostare due funzioni, la prima che fa la lettura della batteria, la seconda che usando la prima, determina se la batteria è scarica.
Una volta che con i due metodi hai capito cosa ti serve e cosa puoi fare, decidi come strutturare il codice, ma concettualmente, almeno all'inizio, puoi fare tutto senza implementare i dettagli, anche se le due funzioni dovessero coincidere. Se coincidono, fai una semplificazione, anche se la lettura non la usi da nessun'altra parte, puoi semplificare. Questo lo decidi dopo in base al procedere dell'implementazione.
Non è uno scandalo avere la funzione batteria scarica di una sola riga, ad es. che testa se la funzione che legge la tensione restituisce un valore minore di X.

Lo schema a punti che hai scritto in seguito, va benissimo, prova a metterlo giù in logica, anche solo in italiano e vedi che cosa ti serve per farlo funzionare. Poi ti scrivi le if o gli switch necessari che richiamino le funzioni che pensi ti servano e poi passi a implementare queste funzioni vedendo se possono essere ulteriormente suddivise ecc. ecc. seguendo un approccio totalmente top-down, oppure con il mix hai già un'idea di che elementi atomici hai e vai a convergenza.

L'informatica, sostanzialmente, è prendere problemi complessi e scomporli in problemi più piccoli fino ad arrivare ad avere un insieme di tanti problemi elementari da risolvere.

Scusa se mi son permesso, ma ho voluto dare alcune spiegazioni perchè quando si capisce il perchè delle cose poi diventa più facile applicarle.

Ora aspetto la nuova versione del programma che recepisce i suggerimenti che hai già ricevuto e metabolizzato, per vedere se posso esserti di aiuto più nello specifico.

Maurizio

Ci sarebbe, in teoria, il modo di dissipare molta meno potenza (ma poi mi accuserebbero di complicare la vita ... vabbe', pazienza, in fondo complicare la vita fa parte del lavoro, per cui te lo dico lo stesso, per conoscenza :D) ... usare mosfet di potenza come diodi (non capisco perche' nessuno li prenda mai in considerazione, poveracci :D) ...

E' vero, al contrario della semplice protezione da inversione di polarita', dove tante volte basta il solo mosfet, in questo caso i soli mosfet non basterebbero, servirebbe usare anche un driver specifico prodotto tempo fa dalla TI, LM74700-Q1, un piccolo chip a 6 pin che trasforma in pratica un mosfet in un "diodo ideale" (o quasi) ... con questa soluzione, figura 36 a pagina 21, potresti eliminare tutti i comandi come se usassi i soli due diodi a catodo comune, pero' con la caduta di tensione e la proporzionale dissipazione di potenza dei mosfet ... e proviamo a calcolare quali sarebbero usando, ad esempio, dei PSMN1R8-40YLC (circa 1.8 milliohm, diciamo 2 nel peggiore dei casi, di RdsON, 40V, un centinaio di Ampere tirati, sui 70 senza problemi, sull'euro scarso al pezzo) ... a 10A, avresti nel peggiore dei casi 0.02V di caduta, con circa 0.2W di dissipazione ... non proprio male, potresti comunque pilotare l'alimentatore in standby ed accenderlo al bisogno, ma senza neppure la necessita' di usare i rele' e risparmiando un sacco di spazio :wink:

EDIT: e dato che i chip hanno un'enable, li si potrebbe perfino pilotare in remoto come interruttori

Etemenanki:
Ci sarebbe, in teoria, il modo di dissipare molta meno potenza (ma poi mi accuserebbero di complicare la vita ... vabbe', pazienza, in fondo complicare la vita fa parte del lavoro, per cui te lo dico lo stesso, per conoscenza :D) ... usare mosfet di potenza come diodi (non capisco perche' nessuno li prenda mai in considerazione, poveracci :D) ...

E' vero, al contrario della semplice protezione da inversione di polarita', dove tante volte basta il solo mosfet, in questo caso i soli mosfet non basterebbero, servirebbe usare anche un driver specifico prodotto tempo fa dalla TI, LM74700-Q1, un piccolo chip a 6 pin che trasforma in pratica un mosfet in un "diodo ideale" (o quasi) ... con questa soluzione, figura 36 a pagina 21, potresti eliminare tutti i comandi come se usassi i soli due diodi a catodo comune, pero' con la caduta di tensione e la proporzionale dissipazione di potenza dei mosfet ... e proviamo a calcolare quali sarebbero usando, ad esempio, dei PSMN1R8-40YLC (circa 1.8 milliohm, diciamo 2 nel peggiore dei casi, di RdsON, 40V, un centinaio di Ampere tirati, sui 70 senza problemi, sull'euro scarso al pezzo) ... a 10A, avresti nel peggiore dei casi 0.02V di caduta, con circa 0.2W di dissipazione ... non proprio male, potresti comunque pilotare l'alimentatore in standby ed accenderlo al bisogno, ma senza neppure la necessita' di usare i rele' e risparmiando un sacco di spazio :wink:

EDIT: e dato che i chip hanno un'enable, li si potrebbe perfino pilotare in remoto come interruttori

WOW, mi hai aperto un mondo con questi aggeggi. W i mosfet, W i diodi ideali (o quasi), W le complicazioni, W etem k+ ;D

Maurizio