Accendere un LED con il Flip-Flop

[PietroBaima]

Grazie obiuan

Ciao da Pietro.

[PietroBaima]

Ora pero' monta quello di PietroBaima, altrimenti si offende eh!

ma no, voleva solo essere un esempio sul quale magari approfondire.
Insomma, volevo buttare una pietra nello stagno e generare qualche onda

questi argomenti si fanno in un corso di Calcolatori Elettronici?
Non di elettronica digitale qualcosa?
(chiedo perché queste cose le ho studiate per conto mio, non ho mai fatto un corso apposito)

Ciao,
Pietro.

[rusty]

Si PietroBaima, iniziamo con esercizi del genere (come quello che hai fatto tu), dall'automa alla rete NAND-NAND o NOR-NOR... ecc.. questo io lo facevo in Calcolatori Elettronici.
Mentre in Elettronica dei Sistemi Digitali (ESD) e Sistemi Digitali e Processori (SDP) formalizzavamo il tutto ad un livello piu' alto (e decisamente piu' eccitante per il sottoscritto... infatti sarebbe diventato il mio lavoro) con delle robe del genere:

Processore mu0, basato sul MIPS (papa' degli ARM):

mu0.zip

(74.21 KiB) Scaricato 154 volte

Il progetto è apribile con Modelsim x.x (download free, google -> modelsim PE Student Edition).

Notare all'interno il datapath e il controllo del modulo nb (nobounce), che è esattamente quello che dicevi prima riguardo alla gestione dei rimbalzi via software con un contatore e una FSM.

Uno stralcio del "controllo", ovvero la FSM che governa la CPU:

Codice: Seleziona tutto

//controllo processore mu0
/////////////////////////////////////////////////////////////

module controllo(ck,reset,opcode,ACCz,ACC15,
                  Asel,Bsel,ACCce,PCce,IRce,ACCoe,ALUfs,RnW);
input ck,reset;
input [3:0] opcode;
input ACCz,ACC15;
output Asel,Bsel,ACCce,PCce,IRce,ACCoe,RnW;
output [1:0] ALUfs;

reg Asel,Bsel,ACCce,PCce,IRce,ACCoe,RnW;
reg [1:0] ALUfs;
reg [2:0] state, state_nxt;

parameter [2:0] PREFETCH=0,FETCH=1,EXE=2,MEM=3,STOP=4;

//aggiornamento dello stato
always@(posedge ck or posedge reset)
if(reset) state<=PREFETCH;
else state <= state_nxt;

//logica calcolo dello stato successivo
always@(state or opcode)
case(state)
    PREFETCH : state_nxt = FETCH;
       FETCH : state_nxt = EXE;
         EXE : if(opcode == 4'b1000) state_nxt = STOP;
               else state_nxt = MEM;
         MEM : state_nxt = PREFETCH;
        STOP : state_nxt = STOP;
     default : state_nxt = PREFETCH;
endcase

//logica d'uscita (uscite di MOORE)
always@(state or ACCz or ACC15 or opcode)
case(state)
    PREFETCH : {Asel,Bsel,ACCce,PCce,IRce,ACCoe,ALUfs,RnW} = 9'b000100111;
       FETCH : {Asel,Bsel,ACCce,PCce,IRce,ACCoe,ALUfs,RnW} = 9'bxx0010xx1;
         EXE : casex({opcode,ACCz,ACC15})
               6'b0000xx : {Asel,Bsel,ACCce,PCce,IRce,ACCoe,ALUfs,RnW} = 9'b1x0000xx1;
               6'b0001xx : {Asel,Bsel,ACCce,PCce,IRce,ACCoe,ALUfs,RnW} = 9'b1x0001xx0;
               6'b0010xx : {Asel,Bsel,ACCce,PCce,IRce,ACCoe,ALUfs,RnW} = 9'b1x0000xx1;
               6'b0011xx : {Asel,Bsel,ACCce,PCce,IRce,ACCoe,ALUfs,RnW} = 9'b1x0000xx1;
               6'b0100xx : {Asel,Bsel,ACCce,PCce,IRce,ACCoe,ALUfs,RnW} = 9'b100100101;
               6'b0101x0 : {Asel,Bsel,ACCce,PCce,IRce,ACCoe,ALUfs,RnW} = 9'b100100101;
               6'b01100x : {Asel,Bsel,ACCce,PCce,IRce,ACCoe,ALUfs,RnW} = 9'b100100101;
                 default : {Asel,Bsel,ACCce,PCce,IRce,ACCoe,ALUfs,RnW} = 9'bxx0000xx1;
               endcase
         MEM : casex({opcode,ACCz,ACC15})
               6'b0000xx : {Asel,Bsel,ACCce,PCce,IRce,ACCoe,ALUfs,RnW} = 9'bx11000101;
               6'b0010xx : {Asel,Bsel,ACCce,PCce,IRce,ACCoe,ALUfs,RnW} = 9'bx11000001;
               6'b0011xx : {Asel,Bsel,ACCce,PCce,IRce,ACCoe,ALUfs,RnW} = 9'bx11000011;
                 default : {Asel,Bsel,ACCce,PCce,IRce,ACCoe,ALUfs,RnW} = 9'bxx0000xx1;
               endcase
        STOP : {Asel,Bsel,ACCce,PCce,IRce,ACCoe,ALUfs,RnW} = 9'bxx0000xx1;
     default : {Asel,Bsel,ACCce,PCce,IRce,ACCoe,ALUfs,RnW} = 9'bxx0000xx1;
endcase

endmodule               


Ma siamo troppo OT, dovrei fare un corso introduttivo al verilog RTL prima di presentare questa roba... ma non trovo mai il tempo mannaggia (e manca al forum).
Sono sicuro che attirerei molti utenti ad abbandonare i vari AVR e PIC per passare alle logiche FPGA/CPLD una volta capita la loro potenza "by example".
Qui stiamo parlando di descrivere la nostra CPU, inventandoci le istruzioni, la larghezza di BUS, tutto insomma, e una volta "burnata" abbiamo la nostra CPU personale... sono stato impressionato dalla potenza di questo linguaggio di descrizione (attenzione è un linguaggio di descrizione dell'hardware, non di programmazione), è veramente insuperabile (Verilog e/o VHDL ovviamente).

Un giorno riusciro' a scriverlo, maybe... if i'm not too busy

[rusty]

P.S. Gli esercizi che facevamo erano su questa falsa riga :

viewtopic.php?f=1&t=32141

quando al tempo lo scrissi passo' quasi inosservato, ma cercai di spiegare a grandi linee il metodo.

[PietroBaima]

Ho pensato ad una piccola miglioria per la rete sincrona.
Già che abbiamo un FF in più... usiamolo per il led.
In questo modo possiamo avere due uscite, quella diritta e quella negata.
Al prezzo, chiaramente, di avere l'uscita ritardata di un colpo di clock, ma non lo vedo come un problema.

Ciao,
Pietro.

Sorgente FidoCadJ | Ingrandisci | Cos'è Fidocad

[ricello9]

Ciao PietroBaima, ho appena ordinato i 74HCT132; voglio provare a realizzare il tuo circuito.
Una cosa non capisco, premesso che il 74HCT175 commuta il valore d'uscita solo sul fronte di salita del clock, dal tuo schema vedo che il segnale di clok è gestito dalla seconda porta NAND del 74HCT132, e come ingresso questa porta ha un condesatore, quindi il segnale in ingreso è statico.
In pratica l'ingresso di clock non sentira mai un fronte di salita.

Dove sbaglio?

Grazie
Marcello

[rusty]

Provo a risponderti io, nel mentre che arriva PietroBaima.

Quello formato dalla nand, resistore e condensatore, è un oscillatore, uno dei piu' semplici che puoi fare con delle porte logiche. In base ai valori di R e C genera un'onda quadra ad una certa frequenza (qui mi pare attorno ai 9KHz). La nand è montata con gli ingressi collegati tra loro, è quindi di fatto una NOT.

All'accensione poniamo che il condensatore sia scarico, l'ingresso sia a livello basso, dunque l'uscita (NOT) è a livello alto; il condensatore comincia a caricarsi proprio tramite la R grazie al fatto che l'uscita è alta, ma quando il condensatore (l'ingresso) diviene abbastanza alto, essendo una NOT, l'uscita va bassa, e il condensatore si scarica stavolta tramite la stessa R, e cosi' via.... oscilla continuamente tra 0 e 5V alla frequenza data dalla costante RC.
I livelli di commutazione della porta sono di tipo isteretico, ma non voglio confonderti, a grandi linee in funzionamento è questo.

Come noterai TUTTI i clock sono comandati da questa onda quadra, che è a circa 9KHz, questo infatti è un circuito sincrono, vale a dire che gli stati sono aggiornati nello stesso istante; 9KHz è una frequenza molto alta rispetto alla frequenza che imporremo noi al pulsante in ingresso (premeremo al massimo 2,3 volte al secondo?).
Tutta la macchina è in continua ricerca del nuovo stato, aggiorna gli stati 9000 volte al secondo, appena premi il pulsante lo stato viene istantaneamente aggiornato, cosi' come quando lo rilasci.
E' come se fosse un campionamento continuo del segnale in ingresso, ovvero del pulsante, la macchina guarda 9000 volte al secondo il suo stato, per essere pronta ad aggiornare i suoi stati di conseguenza.

Spero qualcosa si sia capito

[ricello9]

Spero qualcosa si sia capito

Non potevi spiegarlo meglio di così.
Quello che mi sfuggiva è che la porta essendo una NOT all'accensione va a livello alto anche se in ingresso non ho nessuna tensione.

Grazie per l'aiuto.

[rusty]

Quello che mi sfuggiva è che la porta essendo una NOT all'accensione va a livello alto

E' una nand, ma collegata in quel modo svolge di fatto la funzione logica di una not

Grazie per l'aiuto.

Figurati, e' stato un piacere

[PietroBaima]

La spiegazione di rusty va molto bene!
Volevo solo aggiungere qualche grafico.

Il circuito è questo:

Sorgente FidoCadJ | Ingrandisci | Cos'è Fidocad

All'accensione il condensatore è scarico e l'uscita si porta a livello alto. (come ha detto rusty ricordiamoci che questa NAND fa le funzioni di una NOT). La tensione sul condensatore sale esponenzialmente, fino a quando non raggiunge la tensione . Quella tensione fa commutare bruscamente la porta logica a livello basso: il condensatore si scarica quindi esponenzialmente, fino ad arrivare a , tensione alla quale la porta logica commuta nuovamente la sua uscita a livello alto, dando modo al ciclo di ripetersi da capo.
Quando l'uscita della porta logica è a livello alto la sua uscita si porta a e, se la carica del condensatore non venisse arrestata prima dalla nuova commutazione della porta, quella sarebbe la sua tensione asintotica.
Facciamo un disegno:

Sorgente FidoCadJ | Ingrandisci | Cos'è Fidocad

Si deve notare che, avvenendo l'accensione del circuito a t=0 s, il tempo del primo periodo a livello alto è maggiore di tutti gli altri. Questo avviene perché all'accensione il condensatore è scarico, quindi parte con tensione nulla ai suoi capi. In qualunque altro ciclo il condensatore si scarica fino a , dopodichè avviene la commutazione della porta logica e il condensatore riprende a caricarsi.

Con questo è tutto.
Ciao,
Pietro.