Ritardare accensione relè tramite potenziometro

Salve, a tutti, è possibile ritardare da 1 a 10 secondi un segnale digitale e poi mandarlo come impulso a un relè, variando il tempo di ritardo tramite trimmer ? Esempio: attraverso un pulsante normalmente aperto passano 24Vac li trasformo a 5 v dc e li mando in un pin di ingresso ad arduino. poi in un altra entrata analogica collego il trimmer e in base alla tensione che rileva ritarda il segnale da 1 a 10 secondi. poi alla fine mi uscirà il segnale a 5 v dc che modificherò a 24vac

certo, nessuna difficoltà

fai un passo per volta:

comincia con il gestire un pulsante e una uscita, magari la 13 che ha il led integrato

per il ritardo, ti basta segnarti da qualche parte il tempo ed il verso di commutazione del pulsante, aggiungere un valore fisso e usarlo per un test su millis()

naturalmente a test passato esegui l'azoione che ti eri segnata

oppure, se ti va bene una granularità più elevata che il millisecondo puoi ciclare un array di stati del pulsante ogni ciclo leggi lo stato, lo usi per accendere e/o spegnere l'uscita, leggi il pulsante, lo carichi nello stato e poi aggiorni il puntatore all'array, quando sei arrivato in fondo ricominci da capo

mica male

Alla pressione del pulsante memorizzi il valore di millis() e leggi l'ingresso analogico per sapere il ritardo. Calcoli quanto è questo ritardo e, passato il tempo, attivi il tuo relè.

SE non sai di cosa stò parlando ... allora devi studiarti cosa è e come si usa la millis(), prima QUI, poi QUI ed infine leggi anche QUI e QUI ... vedrai che ti sarà tutto più chiaro ;)

Guglielmo

Edit: docsavage ed io ci siamo sovrapposti, ma i concetti sono simili ;)

Se invece il relè fosse uno solo, e non ti interessasse usare arduino....

Basta caricare una cella rc con la r il potenziometro, e far scattare il relè con un comparatore

docsavage: Se invece il relè fosse uno solo, e non ti interessasse usare arduino....

... ed io dovrei chiudere il thread ::)

Ce lo vogliamo ricordare il punto 16.11 del REGOLAMENTO o no ? >:(

Guglielmo

Hai perfettamente ragione

E mi scuso

Se posso però vorrei tentare una giustificazione:

Non ho consigliato allo OP di seguire questa strada, mi è solo sembrato giusto segnalare una alternativa

Chiaro che se lo O P scegliesse in tal senso non sarebbe questo il forum corretto

Ma non me la sento di non citare alternative percorribili, per deformazione professionale

OK, la notte porta consiglio

ci ho pensato un po’ e l’alternativa che mi piace di più è di

gestire un array di byte
indirizzarlo bit a bit con le funzioni bitread e bitwrite
naturalmente occorrera spezzare l’indirizzo in byte nell’array e bit nel byte
gli operatore divisione (/) e resto (%) sono li per quello

leggere cambiera aggiornare lo stato etc etc

un passo all’indirizzo
e si ricomincia

per variare la durata della ripetizione ci sono due strade

mantenedo la granularità
serve dimensionare un array sufficentemente grande per il tempo massimo
e una vriabile accessoria LIMITE (inferiore alla dimensione dell’array)
il potenziometro regola il LIMITE
Svantaggio: quando si allunga il tempo, il primo ciclo successivo “inventa” nuove cose, lette da parti dell’array che prima erano inutilizzate
quando si accorcia il tempo, il primo ciclo successivo “perde” azioni, quelle rimaste scritt in parti dell’array non più lette

perdendo la granularità minima garantita
ovvero con una granularità variabile
si dimensiona l’array per il tempo massimo
si cicla sempre tutto lo array
il potenziometro varia l’attesa tra un passo e il successivo
svantaggio
la relazione tempo-posizione del potenziometro diventa complicata
il tempo diventa funzione dell’inverso della velocità, che però è data come cadenza di lettura, che però può assumere solo determinati valori, risultato la variazione col potenzioetro sarà probabilmente un po’ a scatti

se ti serve aiuto chiedi

Ho letto le varie pagine riguardanti all' utilizzo dell' opzione mills e ho optato vista la mia esperienza di programmazione, di realizzarlo tramite componenti, con l' ausilio di una ne 555

Beh, visto che lo OP ha deciso per altra via, e ha quindi risolto

nessuno se ne prenderà a male se metto una possibile soluzione

// programma per ritardo di un pulsante

#define INGRESSO 2
//occhio, debounce software
#define USCITA 12
// il comando rele
#define ALLARME 13
//per usare il led interno
#define EVENTI 10
// massimi 10 eventi
boolean stato;
//memoria del pulsante
boolean pulsante;
// lettura del pulsante

long ritardo = 1000;

boolean comandi[EVENTI];
unsigned long tempi[EVENTI];

void setup(void) {
  pinMode(INGRESSO, INPUT);
  pinMode(USCITA, OUTPUT);
  pinMode(ALLARME, OUTPUT);
}


void loop(void) {
  //acquisisco il pulsante
  pulsante = digitalRead(INGRESSO);

  if (stato != pulsante) {
    // cambio di stato
    stato = pulsante;
    // rest allarmi
    digitalWrite(ALLARME, LOW);
    // la funzione prenota carica l'azione da eseguire se trova spazio
    //restituisce 0 se lo ha fatto, 1 se non ha trovato spazio

    if (prenota(pulsante)) {
      //allarme
      digitalWrite(ALLARME, HIGH);
    }
  }

  // adesso ciclo lo array di azioni e tempi

  for (int i = 0; i < EVENTI; i++) {
    // per ogni riga di eventi
    // se il tempo NON è zero
    // tempo zero implica azione NON prenotata
    if (tempi[i]) {
      // se il tempo è passato
      if (millis() - tempi[i] > ritardo) {
        // esegui l'azione
        digitalWrite(USCITA, comandi[i]);
        //resetto il tempo
        tempi[i] = 0;
      }
    }

  }

  // qui si mette la map per calcolare il valore attuale di ritardo
  // sono sicuro che qui non ci siano problemi a scriverla per lo OP


  // fatto, finito...
}


boolean prenota (boolean azione) {
  // prenota dentro nell'array eventi l'azione richiesta
  // se trova spazio retituisce 0
  // se non trova spazio restituisce 1


  for (int i = 0; i < EVENTI; i++) {
    // per ogni riga di eventi
    //se NON prenotato
    if (!tempi[i]) {
      tempi[i] = millis();
      comandi[i] = azione;
      return false;

    }
  }
  return true;

}

la cosa che mi scoccia è che avevo scritto anche l’altra soluzione
quella con un array di 125 byte, indirizzati singolarmente bit per bit

che memorizzava mille centesimi di secondo
e ciclava lo array con una cadenza data dal resto della divisione tra millis e la velocità
una genialata, dal mio punto di vista

ma la ho salvata con lo stesso nome di questa

chi è causa del suo mal pianga se stesso…