Contatore modulo 22

Contatore modulo 22.

Contatore modulo 22.

Generalità.

Progetto di un contatore sincrono modulo 22 realizzato mediante una rete logica che ha i seguenti ingressi:

En : segnale di abilitazione del contatore;

Cp : impulso di conteggio;

U/d : ingresso di conteggio a crescere o decrescere, in particolare con u = 1 a crescere e u = 0

A decrescere;

Load : segnale di precaricamento sincrono;

Li : segnali contenenti il valore da precaricare;

Reset : segnale di reset asincrono.

In uscita al contatore abbiamo :

Qi : segnale contenenti valori di conteggio;

Div: segnale che indica raggiungimento di Umax (se u/d = 1) o Umin (se u/d = 0);

Ripple : segnale di passaggio da Umax ad Umin nel caso u/d =1 e viceversa quando u/d = 0.

Progetto del circuito.

Essendo 22 gli stati da realizzare occorrono 5  variabili Q0, Q1, Q2, Q3, Q4, Q5.

e altrettanti flip-flop T.

A questo punto determiniamo gli ingressi dei flip-flop trascurando l'ingresso di Load.

U = 1 (crescere).

J = U

J = U * ( Q4 * Q0 + Q0 * Q2 )

J = U * ( Q1 * Q0 + Q4 * Q2 * Q0 )

J = U * Q2 * Q1 * Q0

J = U * ( Q3 * Q2 * Q1 * Q0 + Q4 * Q2 * Q0 )

U = 0 (decrescere).

J =U

J = U * ( Q0 * Q3 + Q0 * Q2 + Q0 * Q1 + Q0 * Q4 )

J = U * Q0 * Q1

J = U * ( Q3 * Q2 * Q1 * Q0 + Q4 * Q2 * Q1 * Q0 )

J = U * Q3 * Q2 * Q1 * Q0

Div = U * Q4 * Q2 * Q0 + U * Q4 * Q3 * Q2 * Q1 * Q0

Ripple =Div * Clock

Sino a questo punto abbiamo trascurato il segnale di load e considerato il f.f.J.K. in conurazione T. Adesso per considerare anche il suddetto segnale non possiamo più imporre che sia a J che a K abbiano lo stesso ingresso , infatti

Ji = load * Qi + load * Li

Ki = load * Qi + load * Li.

In definitiva si ha che:

J = load + load * L0

K = load + load * L0

J = load * [ U * ( Q0 * Q2 + Q0 * Q4 ) + U * ( Q0 * Q1 + Q0 * Q2 + Q0 * Q3 + Q0 * Q4 ) ] +

+ load * L1

K = load * [ U * ( Q0 * Q2 + Q0 * Q4 ) + U * ( Q0 * Q1 + Q0 * Q2 + Q0 * Q3 + Q0 * Q4 ) ] +

+ load * L1

J2 = load * [ U * ( Q0 * Q1 + Q0 * Q2 * Q4 ) + U * Q0 * Q1 ) ] + load * L2.

K2 = load * [ U * ( Q0 * Q1 + Q0 * Q2 * Q4 ) + U * Q0 * Q1 ) ] + load * L2.

J3 = load * [ U * Q0 * Q1 * Q2 + U * ( Q0 * Q1 * Q2 * Q4 + Q0 * Q1 * Q2 * Q3 ) ] + load * L3.

K3 = load * [ U * Q0 * Q1 * Q2 + U * ( Q0 * Q1 * Q2 * Q4 + Q0 * Q1 * Q2 * Q3 ) ] + load * L3

J4 =  load * [ U * ( Q0 * Q2 * Q4 + Q0 * Q1 * Q2 * Q3 ) + U * Q0 * Q1 * Q2 * Q3 ) ] + load * L4

K4 = load * [ U * ( Q0 * Q2 * Q4 + Q0 * Q1 * Q2 * Q3 ) + U * Q0 * Q1 * Q2 * Q3 ) ] + load * L4