Una dritta. Relè on/off senza ulteriore pulsante.

[TardoFreak]

... non penso che sia opportuno, anche se elegante, utilizzare un microcontrollore ...

Un paio di domande:
- Perché trovi inopportuno utilizzare un micro?
- Perché sarebbe elegante utilizzare un micro?

Sono solo curioso.

[thunderbolt128]

Quindi vorresti utilizzare il 4017 modificando questo schema giusto?

Sorgente FidoCadJ | Ingrandisci | Cos'è Fidocad

Quindi adesso bisognerebbe aggiungere al circuito un 555 come monostabile, sostituire il diodo led 2 con un optoisolatore e apportare qualche modifica.....

[thunderbolt128]

Guardiamo dal punto di vista logico:
Proseguo con quello che dicevo: al pin 2 si arriva pigiando 2 volte e pigiando altre 2 si arriva al pin 4 che dovrebbe essere usato come comando spegni quindi non appena arriva a segnale il pin 4 si dovrebbe diseccitare il relè e togliere per un attimo la corrente all'integrato contatore e quindi questo si dovrebbe resettare e cosi via. Questo ovviamente senza timer, se si vuole aggiungere un timer le cose si complicano un pochino. Se hai bisogno anche del timer chiedilo, sto pensando ad uno schema, ma al momento non l'ho ancora completato causa malditesta. Appena mi passa cerco di completarlo.

[TardoFreak]

Se non ho capito male vorrebbe fare una cosa del genere.

Giusto?

rele.rar

(955 Byte) Scaricato 82 volte

contiene il file .hex del programma.

[claudiocedrone]

Effettivamente, a vederlo così... non è proprio il massimo dell'eleganza

[TardoFreak]

Urca! Mi sono dimenticato di mettere il sorgente

Codice: Seleziona tutto

// File di definizione dei registri del micro.
#include "p18f47j53.h"
#include <delays.h>

// File di configurazione dei fuses
#include "configurazione.h"   

// Mappatura delle interrupt
#include "mappa_int.h"

// Header del main
#include "main.h"


//------------------------------------------------------------------------------
// Variabili globali
//------------------------------------------------------------------------------
#pragma udata
volatile unsigned short timer_delay;    // Timer software per pulsante
volatile unsigned short timer_reset;    // Timer per il reset dell' uscita
volatile unsigned short timer_deb;      // Timer per antirimbalzo

#define T_ATTIVA 500    // Intervallo massimo fra i due impulsi (500 ms)
#define T_RESET  5000   // Tempo di reset automatico (5 s)
#define T_DEBOUNCE 20   // Costante di tempo per il debouncing (20 ms)

//------------------------------------------------------------------------------
// Funzione di servizio delle interrupt ad ALTA priorità
//------------------------------------------------------------------------------
#pragma code
#pragma interrupt highPriorityInterrupt
void highPriorityInterrupt()
{
  // Verifica quale flag ha causato l' interrupt
  // Esegui la parte di codice di servizio dell' interrupt
  // Azzera il flag che ha causato l' interrupt
  // ...
}

//------------------------------------------------------------------------------
// Funzione di servizio delle interrupt a BASSA priorità
//------------------------------------------------------------------------------
#pragma interruptlow lowPriorityInterrupt
void lowPriorityInterrupt()
{
  // Verifica quale flag ha causato l' interrupt
  // Esegui la parte di codice di servizio dell' interrupt
  // Azzera il flag che ha causato l' interrupt
  // ...
 
  // Gestione dell' interrupt del timer 2
  if(PIR1bits.TMR2IF)
  {
    // gestione dei timer software. I timer software devono decrementarsi
    // fino ad arrivare a 0. Una volta arrivati a 0 restano fermi a 0.
    if (timer_delay) timer_delay--;
    if (timer_reset) timer_reset--;
    if (timer_deb) timer_deb--;
      
    // Resetta il flag che ha generato l' interrupt
    PIR1bits.TMR2IF = 0;
  }
}

//------------------------------------------------------------------------------
// Prototipi delle funzioni
//------------------------------------------------------------------------------
#pragma code
void timer2_deInit(void);
char get_pulsante(void);
void set_out(void);
void reset_out(void);
void commuta_out(void);

//------------------------------------------------------------------------------
// Funzioni
//------------------------------------------------------------------------------
#pragma code

char get_pulsante(void)
{
  if (!PORTDbits.RD5) return(1); else return(0);
}

void set_out(void)
{
  LATDbits.LATD7 = 1;
}

void reset_out(void)
{
  LATDbits.LATD7 = 0;
}

void commuta_out(void)
{
  LATDbits.LATD7 ^= 1;
}

//------------------------------------------------------------------------------
// De-inizializza il timer 2 e lo porta nello stato in cui si trovava
// subito dopo il RESET
void timer2_deInit(void)
{
  T2CON = 0;            // Resetta il timer 2 control register
  TMR2 = 0;             // Azzera il contatore interno
  PR2 = 0;              // Azzera il registro comparatore
  PIE1bits.TMR2IE = 0;  // Disabilita l' interrupt
  IPR1bits.TMR2IP = 0;  // Resetta il bit di priorità dell' interrupt
  PIR1bits.TMR2IF = 0;  // Azzera il flag di interrupt
}

//------------------------------------------------------------------------------
// MAIN
void main(void)
{
  char puls;      // stato attuale del pulsante
  char puls_old;  // stato precedente pulsante
  char impulsi;   // contatore di impulsi
 
  // Fa partire il PLL.
  // Anche se viene selezionato tramite i bit di configurazione
  // il suo funzionamento non è automatico. Ha bisogno di un comando.
  OSCTUNEbits.PLLEN = 1;
  // Attende abbastanza tempo per far stabilizzare il PLL
  Delay1KTCYx(100);
  // Da ora in poi abbiamo il PLL funzionante ed il micro con il turbo.
 
  // -------- Inizializzazione delle periferiche --------
 
  // Inizializza la PORTD
  // bit 4 input pulsante PL0
  //  "  5 input pulsante PL1
  //  "  6 output LED LED1
  //  "  7 output LED LED2
  TRISD = 0x3F;
  // Mette a 0 tutte le uscite
  LATD = 0;
 
 
  // De-inizializza il timer2. Non sarebbe necessario perché il micro esce
  // allo stato di RESET ma è comunque buona pratica de-inizializzare sempre
  // le periferiche per non tralasciare nessun bit.
  timer2_deInit();
  // Inizializza il timer 2 per interrupt ogni millisecondo.
  // prescaler divide per 16
  T2CONbits.T2CKPS = 2;
  // Postscaler divide per 5
  T2CONbits.T2OUTPS = 4;
  // Imposta il valore comparatore a 150
  PR2 = 150;
  // Imposta l' interrupt del Timer 2 a priorita' bassa
  IPR1bits.TMR2IP = 0;
  // abilita interrupt del timer
  PIE1bits.TMR2IE = 1;
 
  // -------- Selezione ed abilitazione delle interrupt -------- 
  // Ora che si sono inizializzate tutte le periferiche si possono abilitare
  // Oppurtunamente le interrupt
  // abilita le interrupt a bassa priorita'
  RCONbits.IPEN = 1;
  // abilta tutte le interrupt a priorità bassa
  INTCONbits.GIEL = 1;
  // Abilita tutte le interrupt in generale
  INTCONbits.GIEH = 1;         
 
  // -------- Attivazione delle periferiche -------- 
  // Con le interrupt abilitate possiamo ora far partire il timer 2
  // Accende il timer
  T2CONbits.TMR2ON = 1;
   
  // Inizializza la variabile che funge da timer software
  timer_delay = 0;
  // Inizializza la variabile di conteggio
  puls_old = 0;
 
  // Resetta l' uscita
  reset_out();
 
  impulsi = 0;
 
  // -------------- Ciclo infinito di funzionamento -------------
  for(;;)
  {
    // Legge lo stato del pulsante
    puls = get_pulsante();
   
    // Guarda se c'è transizione pulsante
    if (!puls_old && puls)
    {
      // C' è transizione da rilasciato a premuto
      // fa partire il time della finestra temporale
      timer_delay = T_ATTIVA;
      // Incrementa il numero di impulsi rilevati
      impulsi ++;
      if (2 == impulsi)
      {
        // Fa partire il timer di disattivazione
        timer_reset = T_RESET;
        commuta_out();
        impulsi = 0;
      }
    }
   
    // Se il timer della finestra arriva a zero azzera tutto
    if (!timer_delay)
    {
      impulsi = 0;
    } 
   
    // Se il timer di reset automatico è a 0 resetta l' uscita
    if (!timer_reset) reset_out();
     
    // Ritardo hardware per debouncing del pulsante
    timer_deb = T_DEBOUNCE;
    while(timer_deb);
   
    // Aggiorna lo stato precedente del pulsante
    puls_old = puls;
  } // for(;;)
}

Descrizione del programma.
Ho preso il programma di demo, gli ho tolto un po' di roba e ne ho messo un po' di altra.

Peace and love.

[ginusweb]

... non penso che sia opportuno, anche se elegante, utilizzare un microcontrollore ...

Un paio di domande:
- Perché trovi inopportuno utilizzare un micro?
- Perché sarebbe elegante utilizzare un micro?

Sono solo curioso.

Ciao a tutti...

Inopportuno è perché poi il circuito non potrebbe, diciamo semplicemente, essere fatto da tutti, essere alla portata di tutti: se si volesse avere una esclusiva, anche da un punto di vista commerciale, diciamo una incopiabilità, allora ok. Diciamo che non è alla portata di tutti avere un programmatore, avere il software giusto e saper cosa fare.

Di contrappasso da un punto di vista prettamente funzionale è il massimo: eleganza, compattezza, pochi componenti, una logica impeccabile, suscettibile di infinite migliorie ed aggiunte di funzioni, il cui limite è solo la fantasia del programmatore. E' ovvio che in pochi passi del programma si implementa il ricosocimento di due tocchi on, due tocchi off, timer a 5 minuti ed autoreset in accensione. Eccezionale il video del funzionamento del doppio tocco: perfettamente funzionante ed insensibile ad altre pigiate sul tasto !!!

Ciao ciao ed ancora grazie per la

[brabus]

Inopportuno è perché poi il circuito non potrebbe, diciamo semplicemente, essere fatto da tutti, essere alla portata di tutti: se si volesse avere una esclusiva, anche da un punto di vista commerciale, diciamo una incopiabilità, allora ok. Diciamo che non è alla portata di tutti avere un programmatore, avere il software giusto e saper cosa fare.

Beh... Bof...

Diciamo che per molti è difficile persino procurarsi i 4017, i transistor, le millefori... persino le resistenze.

Io trovo molto più comodo poter ordinare il pacchetto completo da un sito (noi!), che peraltro offre l'intero circuito open source, il listato del programma... e pure i microcontrollori già programmati!
Se poi uno vuole autocostruirlo, qui trova comunque tutto.
Alla fine costa molto, molto meno rispetto alla soluzione discreta, anche (e soprattutto) in tempi di costruzione e debug.

Se già uno si trova in difficoltà con la reperibilità di un micro, figuriamoci cosa si mette a fare per saldare e debuggare uno schedino tutto analogico/misto... con quale strumentazione poi, un tester?

Facciamo così: noi ti diamo comunque una mano con la soluzione discreta, è pur sempre un ottimo esercizio didattico, però sotto il banco teniamo pronto lo schedino col micro.
Io te lo propongo, poi scegli tu se comunicare ai membri del club la scelta: "potete procurarvi i componenti, saldare il tutto e provarlo, oppure comprare lo schedino bello pronto all'uso (e rugged) su electroyou.it".

[ginusweb]

Beh... Bof...

Diciamo che per molti è difficile persino procurarsi i 4017, i transistor, le millefori... persino le resistenze...ecc ecc...

Mio caro " brabus " non ci sono problemi di sorta riguardo l'eventuale pubblicazione, pubblicità e proposta a tutti i membri del forum Scarabeo...ovviamente la mia non era una mancanza di disponibilità e sinceramente riuscire a rimpinguare le nostre povere tasche, di questi tempi sarebbe cosa gradita. E' una bella idea, direi utile ed applicabile in tanti altre necessità; non so sino in fondo i risvolti legali alla modifica di un impianto elettrico sottoposto ad omologazione e commerciali della vendita, ma la cosa in qualunque modo me la proponiate è fattibilissima ed onorevole.

Io, non ti nego, sarei il primo a proporre ed acquistare il micro con opto e con timer 10 minuti...vabbè si fa per dire acquistare...sarei io la cavia al montaggio sul mezzo ed il propositore alla vendita...quindi uno sconto è d'obbligo...

Scherzi a parte, concludo: ok per qualsiasi soluzione...poi, al di là della fattibilita, del fatto che alcuni non conoscano neanche un millefori...beh pian piano tutto si impara...basta avere pazienza, passione e conoscenza...

Ciao ciao...e grazie...

[thunderbolt128]

Da quello che ho capito abbiamo carta libera?
Dal mio punto di vista con un PIC dovrebbe risultare più semplice ma effettivamente utilizzando il 4017 ed il 555 e collocando componenti già dimensionati ne verrebbe un kit di montaggio che magari potrebbe venir consegnato con un PCB ed i componenti da stagnare, come i kit di Nuova Elettronica. Qualche mese fa mi venne un idea analoga ma non riesco a fare in modo che quando si preme due volte per spegnere dovrebbe resettarsi tutto e che il sistema funzioni solo quando premo due volte molto vicine tra loro. Mi ha molto interessato anche il pierin PIC 18 proposto da TardoFreak ma al momento sto già imparando ad usare Arduino . Ormai è da mesi che cerco di far funzionare il 4017 a dovere ma purtroppo ultimamente ho sempre qualcosa da fare e non trovo la soluzione a ciò che ho elencato
Se riesco a combinare qualcosa vi faccio sapere ma per ora sono nel pallone.