Sekvensiell logikk

I motsetning til kombinatorisk logikk har sekvensielle kretser hukommelse – utgangen avhenger av både nåværende innganger og tidligere tilstander. Hukommelsen realiseres med bistabile elementer: latcher og flip-flops.

SR-latch

Den enkleste bistabile kretsen. To NOR-porter (eller NAND) koblet i kryss:

$S=1, R=0$: Set ($Q = 1$)
$S=0, R=1$: Reset ($Q = 0$)
$S=0, R=0$: Holder tilstand (hukommelse)
$S=1, R=1$: Forbudt tilstand (begge utganger 0, udefinert oppførsel)

D-latch og D-flip-flop

En D-latch (gated) tar inn data $D$ og en Enable-signal $E$. Mens $E=1$ er utgangen transparent ($Q$ følger $D$). Når $E=0$ huker latchen siste verdi av $D$. Problem: utgangen kan endre seg flere ganger i løpet av en klokkepuls hvis inngangen endrer seg.

En D-flip-flop (kant-trigget) lagrer $D$ kun på en bestemt klokkeflank (stigende eller fallende). To D-latcher i serie (master-slave) realiserer kant-triggingen. Viktige timingparametre:

Setup-tid ($t_{setup}$): Minimum tid $D$ må være stabil FØR klokkeflank.
Hold-tid ($t_{hold}$): Minimum tid $D$ må være stabil ETTER klokkeflank.
Propagasjonsforsinkelse ($t_{pcq}$): Tid fra klokkeflank til $Q$ er stabil.

Registre og skiftregistre

Et register er en samling D-flip-floper med felles klokke, brukt til å lagre et $n$-bits ord. Et skiftregister kobler flip-flopenes $Q_i$ til $D_{i+1}$, slik at bitene skifter én posisjon per klokkesyklus. Skiftregistre brukes i serielt-til-parallell og parallelt-til-serielt omforming.

Synkron vs. asynkron design

I synkron design er alle flip-floper koblet til den samme systemklokken. Alle tilstandsoverganger skjer på klokkeflanken. Fordeler: forutsigbar timing, lettere å analysere og verifisere. I asynkron design mangler global klokke – tilstandsoverganger utløses direkte av inngangssignaler. Vanskelig å designe korrekt pga. race conditions og glitcher.

Eksempel: D-flip-flop timing

En D-flip-flop har $t_{setup} = 2\,\text{ns}$, $t_{hold} = 1\,\text{ns}$, $t_{pcq} = 3\,\text{ns}$. Kombinatorisk logikk mellom to flip-floper har forsinkelse $t_{comb} = 8\,\text{ns}$. Minimum klokkperiode: $T_{min} = t_{pcq} + t_{comb} + t_{setup} = 3 + 8 + 2 = 13\,\text{ns}$. Maksimal klokkefrekvens: $f_{max} = 1/13\,\text{ns} \approx 77\,\text{MHz}$.

Eksempel: Kritisk sti, propageringsforsinkelse og maks klokkefrekvens

Dette er en eksamensklassiker: regn ut propageringsforsinkelse gjennom en krets og deretter maks klokkefrekvens for en pipeline-versjon. Vis alltid eksplisitt hvilke portnivåer du teller.

Anta at en port (AND/OR/XOR) i en ASIC har propageringsforsinkelse $40\,\text{ps}$. En fulladder beregnes som $m = a \oplus b$, $sum = m \oplus c_{in}$, $c_{out} = (a\cdot b) + (m\cdot c_{in})$. Lengste sti gjennom én fulladder er to portnivåer i serie: $2 \times 40 = 80\,\text{ps}$.

Vi kjeder fire fulladdere til en ripple-carry adder. Kritisk sti går fra laveste bit gjennom hele carry-kjeden til siste sum. Hvert carry-trinn koster to portnivåer ($80\,\text{ps}$), og siste sum krever ett ekstra XOR-nivå. Teller du carry-kjeden som $4 \times 80 = 320\,\text{ps}$ pluss ett sum-nivå $40\,\text{ps}$, blir kritisk sti $360\,\text{ps}$.

I en FPGA legges hver fulladder i én oppslagstabell (LUT) med fast forsinkelse $200\,\text{ps}$. Total forsinkelse for 4-bits kjeden: $4 \times 200 = 800\,\text{ps}$.

Vi pipeliner ved å sette inn et register som gir $200\,\text{ps}$ tillegg på kritisk sti. Maks klokkefrekvens: $f_{max} = 1/(800 + 200)\,\text{ps} = 1/(1000\,\text{ps}) = 1\,\text{GHz}$.

Studieguide: Sekvensiell logikk og flip-flops

Studieguide: Sekvensiell logikk og flip-flops