Buonasera, sto utilizzando arduino per un controllo antiallagamento del mio depuratore posizionato sotto il lavello.
Il funzionamento è molto semplice , resistenza in pull-Down su piedino A0 , il sensore semplicemente è composto da un filo a GND e uno su A0. qundo l'acqua tocca i due fili la tensione su A0 passa da 1023 a 400 e attiva un rele che pilota una saracinesca motorizzata.
di seguito lo sketch da me realizzato
Il mio problema è che vorrei che la saracinesca motorizzata fosse pilotata solo una volta per il tempo prefissato (nel caso 3 secondi) e poi rimanesse non alimentata fino alla pressione del reset.
Ora nel mio schema la saracinesca al rilevamento dell'acqua eccita il relè di pilotaggio della saracinesca , dopo 3 secondi disecita il relè , ma.... siccome arduino continua a controllare rileva la presenza di acqua e rieccita nuovamente il relè in loop infinito.
Mah, per fare quello che vuoi mi pare non sia complicato ma è proprio l'attuale codifica che non mi convince molto ossia non so se tu abbia ragionato abbastanza quando hai scritto quelle istruzioni. A parte l'indentazione (premi Ctrl-T) che è "secondaria" in listati corti come questo ma è bene abituarsi in generale, e le #define che vanno scritte senza lo spazio tra "#" e "define", il pin del sensore del quale hai messola #define ma che non usi nel loop(), e le costanti che per convenzione vanno scritte in maiuscolo. Ma per ora traliasciamo questi "dettagli".
Tu praticamente hai un loop che controlla ogni 3 secondi il valore letto, e se è minore di 500 attiva la saracinesca. Fin qui va bene, ma se dici che quando la attiva vorresti attendere 3 secondi e poi in attesa del tasto di reset (che, nota per @gonpezzi, non è il reset di Arduino ma un apposito pulsante che vedi nelle #define ) devi mettere dentro alla if() l'attesa di 3 secondi (non fuori), seguito dall'attesa del tasto ossia:
while(digitalRead(P_RESET) == LOW) { }
Insomma, vedi una cosa del tipo:
// Mettiamo le costanti dei pin con prefisso "P_"
#define P_CHIUDI 13
#define P_RESET 12
#define P_SENSORE A1
#define P_LED 11
int valore ;
void setup()
{
pinMode(P_SENSORE,INPUT);
pinMode(P_CHIUDI,OUTPUT);
pinMode(P_RESET,INPUT);
pinMode(P_LED,OUTPUT);
Serial.begin(9600);
digitalWrite (P_CHIUDI,LOW);
}
void loop()
{
valore=analogRead(P_SENSORE);
if(valore<500) {
Serial.println(valore);
digitalWrite(P_CHIUDI, HIGH);
digitalWrite(P_LED,HIGH);
delay(3000); // Attendo almeno 3 secondi
// Ora attendo il reset
while(digitalRead(P_RESET) == LOW) { }
// Rimetto le cose a posto
digitalWrite (P_CHIUDI,LOW);
}
// Aggiungere qui un'altra delay() se si desidera diradare le letture
}
PS: il pulsante di reset deve avere una resistenza di pull-down (o in alternativa invertire la logica ed usare la pullup interna con INPUT_PULLUP).
grazie mille per l'aiuto e per le correzioni , non ho capito indentazione ctrl-t??
Comunque nonostante tutto l'idea di usare due fili come sensore funziona da qui poi l'evoluzione:
Precisazione la saracinesca ha due comandi uno di chiusura e uno di apertura una volta chiusa o aperta mantiene la condizione .quindi:
Perdita di acqua, l'ingresso A1 passa da 1023 a 450 , porto alta l'uscita 13 che attiva un rele per alimentazione dell'attuatore della saracinesca che chiude l'acqua, attendo 3-5 secondi (che è il tempo necessario per chiudere il passaggio) poi tolgo l'alimentazione alla saracinesca , si accende il led di segnalazione , e tutto deve rimanere in questa condizione fino a quando viene premuto il pulsante di reset, che attiverà un secondo relè che riapre la saracinesca , si spegne il led e riporta arduino in attesa di eventuali perdite.
per questo motivo il delay è fuori dal ciclo if.
Visto le Vostre soluzioni penso che dovrò ristudiare il while .
Credo comunque che non sarei mai arrivato alla soluzione while(1){} che non mi è ben chiara.
questa serà proverò con i vostri suggerimenti .
Nell'IDE Arduino premi Ctrl-T, ci pensa lui a sistemarti il codice con una indentazione "standard".
Ok allora in questo caso il codice devi modificarlo per seguire queste tue indicazioni.
Ma abituati ad inserire per prima cosa i commenti che spiegano i passi in italiano, e poi sotto ad ogni commento inizi a codificare le istruzioni che eseguono quanto scritto. Ossia vedi quanto è più immediato non solo codificare ma avrai alla fine anche un codice ben commentato:
// Perdita di acqua?
valore=analogRead(P_SENSORE);
if(valore<500) {
Serial.println(valore);
// porto alta l'uscita che attiva un rele che chiude l'acqua
digitalWrite(P_CHIUDI, HIGH);
// attendo 3-5 secondi (che è il tempo necessario per chiudere il passaggio)
delay(5000);
// poi tolgo l'alimentazione alla saracinesca
digitalWrite (P_CHIUDI,LOW);
// si accende il led di segnalazione
digitalWrite(P_LED,HIGH);
// tutto deve rimanere in questa condizione fino a quando viene premuto il pulsante di reset
while(digitalRead(P_RESET) == LOW) { }
// che attiverà un secondo relè che riapre la saracinesca
// (NOTA: quale sarebbe questo secondo relè??? Manca?)
// si spegne il led
digitalWrite(P_LED,LOW);
// e riporta arduino in attesa di eventuali perdite
}
ok basta fermi li ho capito .non mettetemi altre righe di programma altrimenti vi do il mio indirizzo così mi completate il lavoro .
Veramente grazie di tutto . appena finito posterò il lavoro .
ok mntato il tutto .
per non occupare spazio metto lo sketch e la foto del sensore fatto da .
[code]
// la movimentazione di questa saracinesca è data da un piccolo motore alimentato con tre fili a 220v:
// un filo di comune e due per apertura e chiusura.
// per cui volendo togliere alimentazione al motore e per evitare che incollandosi i contatti del relè venissero alimentati
// in contemporanea i due comandi di apertura e chiusura è stato messo un rele alimentazione con il contatto NO connesso al
// comune del rele scambio , e i fili apre e chiude della saracinesca in corrispondenza del contatto NC (chiude) e NO (apre)
// del rele di scambio.
// è stato messo un led lampeggiante( 1 flash di 10 ms ogni 3 secondi) per verificare il funzionamento di arduino
// nota a parte il led di controllo ove uso millis per i tempi della saracinesca ho preferito usare delay
#define rele_alimentazione 12
#define rele_scambio 11
#define sensore A1
#define tasto_reset 10
#define led_allarme 9
#define apertura_manuale 8
int valore = 0;
int manuale;
// tempo apre e tempo chiude servono a dare il tempo necessario alla saracinesca
// di chiudersi e aprirsi, dopodichè viene tolta la alimentazione .
int tempo_apre = 22000;
int tempo_chiude = 23000;
// sezione riguardante il led lampeggiante di controllo del funzionamento di arduino
#define led_chek 6
unsigned long time;
unsigned long lampeggio_time = 0;
void setup() {
pinMode(sensore, INPUT);
pinMode(rele_alimentazione, OUTPUT);
pinMode(rele_scambio, OUTPUT);
pinMode(led_allarme , OUTPUT);
pinMode(tasto_reset, INPUT);
pinMode(apertura_manuale, INPUT);
pinMode(led_chek, OUTPUT);
Serial.begin(9600);
}
void loop() {
//nel caso fosse necessario aprire manualmente la saracinesca . per esempio dopo un allarme
// con sucessiva mancanza di alimentazione alla centralina
manuale = digitalRead(apertura_manuale);
if (manuale == LOW) {
// la saracinesca viene comandata in apertura
digitalWrite(rele_alimentazione, HIGH);
digitalWrite ( rele_scambio, HIGH);
//tempo per completare il ciclo di apertura
delay(tempo_apre);
// tolgo alimentazione alla saracinesca
digitalWrite(rele_alimentazione, LOW);
digitalWrite(rele_scambio, LOW);
}
// perdita acqua?
valore = analogRead(sensore);
Serial.println(valore);
if (valore < 500) {
//porto alta uscita che attiva il rele che chiude l'acqua
digitalWrite(rele_alimentazione, HIGH);
//si accende il led di segnalazione rilevamento acqua
digitalWrite(led_allarme, HIGH);
// attesa di 15 secondi che è il tempo necessario per la chiusura della saracinesca
if (digitalRead(rele_alimentazione) == HIGH) {
delay(tempo_chiude);
// poi tolgo l'alimentazione alla saracinesca
digitalWrite(rele_alimentazione, LOW);
}
// il tutto deve rimanere in questa condizione fino alla pressione del tasto di reset
while (digitalRead(tasto_reset) == HIGH) {}
// che attiva il rele di alimentazione e scambio che riapre la saracinesca
digitalWrite(rele_alimentazione, HIGH);
digitalWrite(rele_scambio, HIGH);
// si spegne il led di segnalazione allarme
digitalWrite(led_allarme, LOW);
//attendo 20 secondi che è il tempo necessario per aprire la saracinesca
if (digitalRead((rele_alimentazione) && (rele_scambio == HIGH)) ) {
delay(tempo_chiude);
// poi tolgo l'alimentazione alla saracinesca
digitalWrite(rele_alimentazione, LOW);
digitalWrite(rele_scambio, LOW);
}
// e riporta arduino in attesa di eventuali perdite
}
// sezione riguardante il lampeggio led di controllo funzionamento di arduino
time = millis();
if (time > lampeggio_time + 3000) // tempo durata spegnimento led_chek arduino
{
digitalWrite(led_chek, HIGH);
}
if (time > lampeggio_time + 3010) // tempo durata accensione led_chek arduino deve essere > del tempo di spegnimento
{
digitalWrite(led_chek, LOW);
lampeggio_time = millis();
}
}
[/code]
) devi mettere dentro alla if() l'attesa di 3 secondi (non fuori), seguito dall'attesa del tasto ossia:
