vuoi
o PayPal
tutte le volte che vuoi
ENTITÀ INV
Questa è una semplice porta NOT, realizzata implementando una singola gate NOR2 che in ingresso prende la stessa variabile in entrambe le porte. Di seguito il sorgente:
entity inv is
port ( x: in std_logic;
y: out std_logic);
end inv;
architecture withnor2 of inv is
component n
port (x, y: in std_logic;
o: out std_logic);
end component;
for all: n use entity work.nor2(behavior);
begin
g0: n port map (x,x,y);
end withnor2;
ENTITÀ OR2
La porta OR2 è semplicemente il negato della NOR2. Avremmo potuto realizzarla in maniera più esplicita con una NOR e una NOT, ma abbiamo preferito ignorare il livello di astrazione offerto dalla NOT in favore di una più comprensibile implementazione. Di seguito il sorgente:
entity or2 is
port ( x, y: in std_logic;
o: out std_logic);
end or2;
architecture withnor of or2 is
component n
port (x, y: in std_logic;
o: out std_logic);
end component;
for all: n use entity work.nor2(behavior);
signal s1: std_logic;
begin
g0: n port map (x, y, s1);
g1: inv port map (s1, o);
end withnor;
```html
y, s1); g1: n port map (s1, s1, o); end withnor;
ENTITÀ AND2
Per realizzare una AND2 in NOR2, è sufficiente negare gli ingressi e mandarli a una NOR2. Di seguito il sorgente:
<architecture WIRED of and2 is
component q1 port (x, y: in std_logic; o: out std_logic);
end component;
for all: q1 use entity work.nor2(BEHAVIOR);
signal i0, i1: std_logic;
begin
g0: q1 port map(x, x, i0);
g1: q1 port map(y, y, i1);
g2: q1 port map(i0,i1,o);
end WIRED;
ENTITÀ RSFLIPFLOP
Per realizzare un flip-flop RS, ovviamente asincrono, è sufficiente incrociare due NOR tenendo presente che in uscita alla NOR con ingresso S il bit in uscita è Q’. Di seguito il sorgente:
<entity RSFLIPFLOP is
port ( r: in std_logic;
s: in std_logic;
q: buffer std_logic;
qn: buffer std_logic);
end RSFLIPFLOP;
architecture WIRED of RSFLIPFLOP is
component N1 port (x, y: in std_logic; o: out std_logic);
end component;
for all: N1 use entity work.nor2(BEHAVIOR);
begin
q0: N1 port map (r, qn, q);
q1: N1 port map (s, q,
qn);end WIRED;ENTITÀ D_TO_RS
Questa entità è un po’ più complessa delle precedenti. Il suo funzionamento è quello di adattatore di interfaccia.
Non ha senso parlare di questa entità senza aver prima illustrato l’interfaccia di un flip-flop D, ma è necessario implementarla prima di implementare il flip-flop D. Semplicemente, questo componente trasforma i segnali in ingresso a un flip-flop D (D, Enable e Reset) in segnali di controllo per flip-flop RS. Di seguito il sorgente:
work.d_to_rs(wired);
signal res, set: std_logic_vector(7 downto 0);
begin
flips: for i in 7 downto 0 generate
a : ad port map(d(i),en,rst,res(i),set(i));
f : ff port map(res(i),set(i),q(i),qn(i));
end generate;
end wired;
ENTITÀ THREESTATE
La porta tri-state è una speciale porta, non realizzabile come rete logica, la cui uscita ha 3 stati: alto, basso e altaimpedenza. Questo particolare stato rappresenta lo scollegamento elettrico del circuito a valle da quello a monte: la porta, infatti, assume una impedenza tendente all’infinito tale che non vi possa essere influenza elettrica sul circuito alla quale è collegata. La porta tri-state è utilizzata nei circuiti di scrittura su bus: quando più dispositivi devono scrivere dati su di una stessa linea elettrica, in un dato istante deve essercene soltanto uno effettivamente connesso. Se due dispositivi fossero in parallelo sulla linea di bus, potrebbe addirittura verificarsi un corto circuito. Per evitare una
simile situazione, è necessario l'uso di un interruttore che separi dal bus i dispositivi che non devono scrivervi. La porta tri-state è proprio un interruttore elettronico, che funziona nel modo seguente:
Se la linea di abilitazione è attiva, in uscita viene scritto il valore della linea dati
Se la linea di abilitazione è disattiva, il circuito viene scollegato.
Non entreremo nei dettagli elettronici di come si realizzi una porta tri-state. In VHDL, l'abbiamo implementata per mezzo di una descrizione data flow:
```html
un registro con rete asincrona. Il riconoscitore di fronte di salita restituisce uscita alta solo sul fronte di salita di un segnale. L'uso che ne facciamo è particolare: nel PIC, è usato per limitare la durata del segnale che abilita il registro buffer a catturare l'ID della periferica da scrivere sul bus, simulando un comportamento impulsivo. Nel nostro caso, abbiamo appositamente modificato il circuito per far sì che il riconoscitore di fronte sia in realtà un limitatore logico, ossia un circuito che limita il tempo in cui il segnale ad esso in ingresso sia alto. Lo abbiamo progettato in logica NOR, e questo ci costa un ritardo di 10ns, tipicamente inaccettabile per applicazioni come il riconoscimento di fronte. Tuttavia il circuito assolve correttamente i suoi compiti, e solo il nome è un abuso di notazione.
Possiamo definire la relazione ingresso-uscita nel modo che segue:
Quando il segnale in ingresso è basso, l'uscita è
comunque bassa. Quando il segnale in ingresso è alto, il segnale in uscita è alto, ma la sua durata non supera i 30ns circa. Ciò significa che la durata dell'impulso alto è pari al minimo tra 30ns e la durata dell'impulso alto in ingresso. Nella realtà, i riconoscitori di fronte si realizzano con amplificatori operazionali retroazionati e non i circuiti logici. Il motivo per cui facciamo durare l'impulso ben 30ns è dovuta ai ritardi sulle linee di traduzione dei segnali dei registri.
Di seguito il codice:
std_logic;
signal stage: std_logic_vector(0 to 7);
begin
n1: nt port map (x, xn);
n0: nt port map (x, stage(0));
sts: for i in 0 to 6 generate
ns: nt port map (stage(i), stage(i + 1));
end generate;
nf: nr port map (xn, stage(7),y);
end wired;
4. Implementazione dei componenti
Come già accennato, avremmo implementato il PIC per mezzo dei componenti principali. Innanzi tutto, abbiamo definito l'architettura base del modello semplificato, dalla quale abbiamo rimosso il bus interno e registri come gli ICW/OCW e l'ISR. Questa architettura è tutta sotto la direzione della logica di controllo, implementata attraverso un'architettura VHDL comportamentale, che reagisce ai segnali provenienti dai componenti fisicamente mappati all'interno del controller.
Gli ingressi delle linee IR7-IR0 vengono presi direttamente dall'IRR, che li filtra in base alla maschera (nel nostro caso impostata a 111, ma grazie al test bench IRR è facile desumere il comportamento del
dispositivo con una maschera attiva), quindi gli interrupt filtrati entrano nel priority resolver, che ha due variabili in uscita: una è un bit che indica se è presente una richiesta di interrupt, l'altro un codice a 3 bit che indica l'ID del dispositivo a maggior priorità che ha vinto l'arbitraggio.
Il codice va in ingresso ai bit meno significativi di un registro D, il quale, attraverso porte tri-state abilitate dalla logica di controllo scrive sul bus una stringa i cui tre bit meno significativi rappresentano l'ID della periferica da servire. I bit più significativi, per quanto non specificati nella logica, sono comunque impostati a zero.
La logica di controllo è guidata da due unici segnali in ingresso: INTA' e il segnale is_int in uscita dal selettore di priorità. È dunque realizzata mediante un processo VHDL.
Essi utilizzano alcune variabili di stato. Uno controlla quante pulsazioni INTA' sono state ricevute,
l'altro controlla lo stato di funzionamento del protocollo di interrupt. Quando il circuito è inizializzato, si suppone che le linee IR siano tutte a zero, dunque non vi siano richieste di interruzione. Nel momento in cui almeno una delle linee IR si alza, il codice di interruzione cambia, e va in ingresso ai registri di buffer che sono però ancora disabilitati. Nel contempo, il segnale is_int si alza e avvia un apposito processo della logica di controllo che alza INT verso la CPU. Supponendo che il processore riceva INT e reagisca, imporremo al test bench una pulsazione negativa sulla linea INTA'. In seguito a questa prima pulsazione, il processo relativo alla linea INTA
Accedi a tutti gli appunti
Tutor AI: studia meglio e in meno tempo
