generatore di parità a 4 bit?

qualcuno mi può dare la soluzione per favore ?

1 risposta

Classificazione
  • 8 anni fa
    Risposta preferita

    Ciao,

    un generatore di parità aggiunge ai dati di ingresso un ulteriore bit, detto di parità, in modo che la parola finale (ovvero l'ingresso + il bit di parità) abbiano un numero di '1' pari (parità pari) o dispari (parità dispari) a secondo di quello che si vuole.

    Supponiamo di volere il caso più comune: ovvero parità pari pari.

    In pratica, vogliamo un circuito che controlli in numero di '1' nella parola di ingresso e se questo numero di '1' è dispari, produrrà una uscita U ad 1 bit che varrà '1' (altrimenti produrrà uno '0' perché la parola di ingresso ha un bit di '1' che è già pari).

    Lo possiamo risolvere facendo un circuito puramente combinatorio in cui gli ingressi sono i singoli bit della parola di ingresso X.

    Considerando X formata dai bit: X = X3 X2 X1 X0

    questi 4 bit (ovvero X3, X2, X1 ed X0) saranno gli ingressi del nostro circuito. L'uscita la chiameremo U (ma potremmo chiamarla in questo caso anche P)

    Facciamo a questo punto la tavola di verità. L'uscita U varrà '1' quando il numero di bit a '1' (dentro X) sarà dispari (infatti X + U avrà poi un numero di bit '1' pari). U sarà '0' altrimenti. Ovvero avremo:

    X3 X2 X1 X0 | U

    ------------------|-----

    0...0...0...0. | 0 <= (0 bit a '1' è pari quindi U = '0')

    0...0...0...1. | 1 <= (1 bit a '1' è dispari quindi U = '1')

    0...0...1...0. | 1 <= (1 bit a '1' è dispari quindi U = '1')

    0...0...1...1. | 0 <= (2 bit a '1' è pari quindi U = '0')

    0...1...0...0. | 1 <= (1 bit a '1' è dispari quindi U = '1')

    0...1...0...1. | 0 <= (2 bit a '1' è pari quindi U = '0')

    0...1...1...0. | 0 <= (2 bit a '1' è pari quindi U = '0')

    0...1...1...1. | 1 <= (3 bit a '1' è dispari quindi U = '1')

    1...0...0...0. | 1 <= (1 bit a '1' è dispari quindi U = '1')

    1...0...0...1. | 0 <= (2 bit a '1' è pari quindi U = '0')

    1...0...1...0. | 0 <= (2 bit a '1' è pari quindi U = '0')

    1...0...1...1. | 1 <= (3 bit a '1' è dispari quindi U = '1')

    1...1...0...0. | 0 <= (2 bit a '1' è pari quindi U = '0')

    1...1...0...1. | 1 <= (3 bit a '1' è dispari quindi U = '1')

    1...1...1...0. | 1 <= (3 bit a '1' è dispari quindi U = '1')

    1...1...1...1. | 0 <= (4 bit a '1' è pari quindi U = '0')

    A questo punto puoi scrivere l'equazione in forma canonica e poi semplificarla, oppure ottenere direttamente la mappa di Karnaugh che presenterà la classica forma a scacchiera indice che l'uscita U è un EXOR (od EX-NOR a seconda dei casi e della parità scelta) degli ingressi.

    In particolare quindi U sarà data da:

    U = X3 xor X2 xor X1 xor X0

    Si può realizzare utilizzando una porta logica EXOR a quattro ingressi.

    Oppure, sfruttando le proprietà degli EXOR si può riscrivere U come:

    U = (X3 xor X2) xor (X1 xor X0)

    quindi 3 porte logiche EXOR a 2 ingressi connesse ad albero (ovvero ho un primo livello di EXOR a due ingressi in cui combino questi a 2 a due e le uscite di questi EXOR le mando in ingresso ad un EXOR finale sempre a due ingressi).

    Ti consiglio di ripetere per conto tuo l'esercizio (magari facendo a mano anche la semplificazione della forma canonica). E di fare quello simile con la parità dispari.

    Spero di esserti stato di aiuto e buono studio

    PS: Se hai già studiato circuiti sequenziali, prova ad immaginare come si possa realizzare lo stesso circuito usando elementi di ritardo ed ipotizzando di ricevere un nuovo bit della parola da testare ad ogni colpo di clock)

Altre domande? Fai una domanda e ottieni le risposte che cerchi.