2. מבוסס על הרצאות של יורם זינגר, האוניברסיטה העברית י"ם
Flip Flop
יהודה אפק, יוסי מטיאס אוניברסיטת תל אביב
מבוסס על הרצאות של
יורם זינגר, האוניברסיטה העברית י"ם

3. מערכות זיכרון – Sequential Logic
Input
כניסות
Combinatorial
Circuit
מעגל צירופי
Output
יציאות
Storage/Mem
יחידה זיכרון
עד כה טיפלנו במערכות צירופיות שהינן חסרות "זיכרון" או מצב.  שינוי בערכי הכניסה גורר שינוי "מיידי" (לאחר השהייה) בערכי היציאה.
כל מחשב וכן בקרים מתוכנתים (Controllers) מכילים זיכרון המשמש לשמירת נתונים ולביצוע תוכניות.
פרט למבנים כמו SDRAM,ROM וזיכרון בועות (Bubble memory), "הזיכרון" מושג ע"י שימוש במשוב (feedback) של יחידות לוגיות.

4. Synchronous Sequential Circuits
פעולת המערכת מתבצעת ב"פיקודו" של שעון וערכי המערכת נקבעים מערכי הכניסה בנקודות זמן מסוימות שהינן תלויות שעון  מצב המערכת תלוי בשעון.
Asynchronous Sequential Circuits
פעולות המערכת תלויות בסדר של שינוי הכניסות, מצב המערכת יכול להשתנות בכל רגע.
"יציב"
"מהיר"
Combinatorial
Circuit
Memory
Clock
Pulses

5. L A T C H S R – L a t c h 1 R Q Q’ S R Q Q’ S 1 2 Reset Set O  1 
1 
Reset
Set R S 1 Q 1 1 2 Q’

6. זכרון 1 Q 1 1 2 Q’

7. זכרון = =
קלט 1
פלט 1
פלט
קלט 1 Q 1 1 2 Q’

8. זכרון
Reset
Set R S 1 Q 1 1 2 Q’

9. L A T C H 1 2
S R – L a t c h
Reset
Set R S Q’ Q
O  1
1 

10. L A T C H 1 2
S R – L a t c h
Reset
Set R S Q’ Q 1

11. L A T C H S R – L a t c h 1 R Q Q’ S מקודם Reset (1) 1 (0) 2 Set
(0) 1
(1)
מקודם
נניח שניתנה פקודת Set
 S=1, R=0 ועתה אנו "מורידים" את הכניסות (S=0, R=0).
ערכי היציאה Q’, Q "זוכרים" את פקודת ה-Set.
באותו אופן יזכרו את ה - Reset.

12. L A T C H S R – L a t c h R S Q’ Q 1 Reset 1 2 Set R=1, S=1
כאשר הערכים יורדים ל – "0" (S=0, R=0) הערך של Q ו Q’ תלוי באיזה קו ישתנה ראשון RACE Condition 
המצב הבא נקרא לא מוגדר. 1

13. דיאגרמת זמנים: טבלת אמת – מצבים: Reset State Set State Undefined
"1" Q
"0"
"1" S
"0"
"1" R
"0"
טבלת אמת – מצבים: S R Q Q’ 1
Reset State
Set State
Undefined
(מצב אסור)
Latch איננו פונקציה בוליאנית.
ערכי היציאה תלויים בפעולת Set או Reset האחרונה.
עבור כניסות (0,0) ערך היציאה נשמר קבוע כל זמן שיש מתח.

14. SR Latch with NAND R Q Q’ S Set State Reset State Undefined1 R S Q’ Q 1 S R Q’ Q 1
Set State
Reset State
Undefined 1
Set Command
Reset Command

15. SR Latch with NAND R Q Q’ S Set State Reset State Undefined1 R S Q’ Q 1 S R Q’ Q 1
Set State
Reset State
Undefined 1
Set Command
Reset Command

16. SR Latch מבוקר שעון: R Q CP Q’ S R 1 1 S S R CP Q Clock Pulse C S R
Clock Pulse S R CP Q C S R
Next Q 
No change 1
Q = 1
Q = 0
Undef

17. D (data) Latch D Q CP Q’ Latch D הינו יחידה שאוגרת / "זוכרת" ביט יחיד.1 D Q’ Q CP 1 D'
Q = 1 (Set)
Q = 0 (Reset)
No change
Next State of Q 1  C D
Latch D הינו יחידה שאוגרת / "זוכרת" ביט יחיד.
נמנעים ממצב לא מוגדר.
אבן בניין בסיסית של אוגרים (Registers).

18. D Latch אינו מספיק !!
Input
כניסות
Combinatorial
Circuit
מעגל צירופי
Output
יציאות D Q’ Q CP
מחזור שעון ארוך והמעגל יחליף את מצבו מספר פעמים !!!!

19. Flip - Flops
הזמן שלוקח עד שהמוצא של Latch מתייצב יכול ליצור בעיות כאשר מחברים שתי יחידות זיכרון.
המוצא אינו צריך להיות תלוי בתזמון וצריך להימנע "ממצבים מתהפכים" (JK).
פתרון צריך לדאוג שהמוצא יהיה יציב לפרק זמן מובטח.
Flip-Flop פתרון מבוסס על Latch:
שימוש בשני Latch בצורה שתבטיח שהפלט יהיה מבודד מהכניסות המשתנות:
Master-Slave Flip-Flop

20. Master – Slave Flip - FlopC Q Q’
ג ב ר ת
ע ב ד M Y Y’
כאשר (master) M פעיל S (slave) אינו פעיל והינו זוכר את היציאות של M מהשלב ש – M היה סביל. C S Y Q
אין השפעה!

21. Master – Slave Flip - Flop1
10
01
נשאר 1
נעשה פעיל S R C Q Q’
ג ב ר ת
ע ב ד M Y Y’
כאשר M פעיל S אינו פעיל והינו זוכר את היציאות של M מהשלב ש – M היה סביל. C S Y Q
אין השפעה!

22. D Flip Flop כן מספיק !! Input Combinatorial כניסות Circuit מעגל צירופיS Y S S R C Q Q’
ג ב ר ת S R C Q Q’
ע ב ד Q Y’ R Q’ C

23. JK Latch "עידון" של SR Latch: K Q CP Q’ J 1 3 4 2
כאשר K = 0 , J = 1 :
א) המשוב מ – Q לתוך שער 1 לא משפיע היות ו – K=0.
ב) כניסות לשער 3 הינם 0,0  Q=1  Q’=0.
כאשר K=1, J=0 נקבל Q’=1 Q=0.
כאשר K=1, J=1 ?

24. JK Latch "עידון" של SR Latch: K Q CP Q’ J ("חדש") 1 (חדש) 1 3 1 11
("חדש") 1
("חדש") 0
(ישן) 1 1
(חדש)
(ישן)
Q=0 K=0 J=1 a
JK Latch
"עידון" של SR Latch: K J Q’ Q CP 3 4 1 2
כאשר CP=0 אין שינוי מצב כמקודם.
כאשר K = 0 , J = 1 :
א) המשוב מ – Q לתוך שער 1 לא משפיע היות ו – K=0.
ב) כניסות לשער 3 הינם 0,0  Q=1  Q’=0.
כאשר K=1, J=0 נקבל Q’=1 Q=0.
כאשר K=1, J=1 ?

25. JK Latch "עידון" של SR Latch: K Q CP Q’ J המצב "נשמר" 1 1 3 4 2
("ישן") 0
(ישן) 1
Q=0 K=1 J=0 b
(ישן)
המצב "נשמר"
או Reset
JK Latch
"עידון" של SR Latch: K J Q’ Q CP 3 4 1 2
כאשר CP=0 אין שינוי מצב כמקודם.
כאשר K = 0 , J = 1 :
א) המשוב מ – Q לתוך שער 1 לא משפיע היות ו – K=0.
ב) כניסות לשער 3 הינם 0,0  Q=1  Q’=0.
כאשר K=1, J=0 נקבל Q’=1 Q=0.
כאשר K=1, J=1 ?

26. JK Latch "עידון" של SR Latch: K Q CP Q’ J 1 1 3 (1) 4 2 (0)
אם 1=J=K=C לאורך זמן מצב Q יתהפך עוד ועוד.
 מעברים חוזרים ונשנים. 1
(0)
(1)
K=1 J= c
JK Latch
"עידון" של SR Latch: K J Q’ Q CP 3 4 1 2
כאשר CP=0 אין שינוי מצב כמקודם.
כאשר K = 0 , J = 1 :
א) המשוב מ – Q לתוך שער 1 לא משפיע היות ו – K=0.
ב) כניסות לשער 3 הינם 0,0  Q=1  Q’=0.
כאשר K=1, J=0 נקבל Q’=1 Q=0.
כאשר K=1, J=1 ?

27. טבלת אמת עבור JK: דיאגרמת זמנים:
Q(t) J K
Q(t+1) 1
דיאגרמת זמנים: J K CP Q
Q יתהפך בין 0 ל –1 הלוך ושוב כל זמן ש – cp=1

28. T (trigger) Latch מתקבל ע"י חיבור J,K ב JK-Latch למקור אחד:
T = 0  J = K = 0 אין שינוי במצב
T = 1  J = K = 1 היפוך מצב
היפוך זה יחיד אם משך הזמן בו T = 1 הינו "קצר" Qt T
Qt+1 1 Qt D
Qt+1 1

29. JK Flip-Flop: Slave Master J K Q’ Y1 Y0 01 1 10 10 0 (0) (1)C Q SR
Latch D
Slave
Master J K Q’
Y1
Y0
01 1 10
10 0
(0)
(1)
כאשר J = K = 1 היציאה Q הינה קבועה.
עם עליית השעון ה Master יהפוך מצב (Y התהפך).
Q ישאר קבוע כל זמן שהשעון הינו "1" ו – Y ישאר קבוע לאחר עליית השעון.
עם ירידת השעון הערך של Y יוכנס ל – D Latch ו – Q ישתנה.

30. T (trigger) Flip-Flop D (data) Flip-Flop Slave Master Q’ Y TC Q SR
Latch D
Slave
Master Q’ Y T
Q(t) Q’(t+1)
Q(t) Q(t)
T=1
T=0
D (data) Flip-Flop D C
Latch
Slave
Master Q Y
Q(t+1)  D(t)

31. טבלאות המצבים: JKFF SRFF DFF TFF t Q(t) t+1 Q(t) שינוי של קלט
שינוי של פלט
JKFF
SRFF J K
Q(t+1)
Q(t)
No Change 1
Reset
Set
Q’(t)
Complement S R
Q(t+1)
Q(t)
No Change 1
Reset
Set ?
Undef.
DFF
TFF D
Q(t+1)
Reset 1
Set T
Q(t+1)
Q(t)
No Change 1
Q’(t)
Complement

32. Finite State Machine (FSM)
00/0
01/0
11/0
10/1 1
=Iקלט (כמקודם)
=Oפלט
האוטומט פולט 1 אחרי ש"ראה" לפחות 3 1-ים מאז ה- 0 האחרון.
פלט מצוייר במצבים Moore FSM

33. Finite State Machine (FSM)
0/0
קלט (כמקודם) 00
1/0
0/0 01
0/0
0/0
1/0 10
פלט
1/1 11
1/1
האוטומט פולט 1 אחרי ש"ראה" לפחות 3 1-ים מאז ה- 0 האחרון.
פלט מצוייר על הקשתות Mealy FSM

34. טבלת המצבים –Moore הפלט תלוי ב – A & B At Bt I=0 I=1 At+1 Bt+1 Ot 1
00/0 At Bt
I=0
I=1
At+1
Bt+1 Ot 1 1
01/0 1
11/0 1
10/1 1
הפלט תלוי ב – A & B

35. טבלת המצבים - Mealy At Bt
X=0
X=1
At+1
Bt+1 Ot 1
הפלט תלוי ב - X

36. טבלת המצבים – Moore At Bt I=0 I=1 At+1 Bt+1 Ot 1 10 11 01 00 Bt+1 1 10
00/0
01/0
11/0
10/1 1
טבלת המצבים – Moore At Bt
I=0
I=1
At+1
Bt+1 Ot 1 AB AB 10 11 01 00
Bt+1 1 10 11 01 00
At+1 1 I

37. דוגמא - Moore A B כניסה אחת ויציאה אחת 2FF מסוג Data  4 מצבים. I OQ A Q’ O D Q B Q’
At+1= A*I + B * I= I(A+B)
Bt+1= A*I
כניסה אחת ויציאה אחת
2FF מסוג Data  4 מצבים.
O = A*B

38. דוגמא – Mealy A X Out B כניסה אחת ויציאה אחתD Q A Q’ X
Out D Q B Q’
כניסה אחת ויציאה אחת
היציאה תלויה ב- QA, QB ו- X.
2FF מסוג Data  4 מצבים.

39. Moore Vs. Mealy פלט: אוטומט: שיקולים: Moore שקול ל – Mealy (ולהפך)
Moore – לא תלוי ב"יציבות" הקלט (מספיק שיהיה קבוע Ts + Th) אך ידרשו FFs נוספים אם דרושה תלות היציאה בקלט.
Mealy – פשוט לממוש אם יש תלות של היציאה בקלט אך נדרשת יציבות.
Moore שקול ל – Mealy (ולהפך)

40. נוהל עיצוב הגדר במילים את פעולת המעגל. בנה את טבלת המצבים (אוטומט)
צמצם / מצא ייצוג קטן של אוטומט המצבים.
קבע משתנים אשר ייצגו את המצבים (בצורה וקטורית). קבע את מספר הדלגלגים והתאם אות לכל דלגלג.
בחר בסוג הדלגלג להשתמש בו.
קבל טבלאות העירור והיציאות של המעגל מטבלת המצבים.
חשב את פונקציות היציאה של המעגל ואת פונקציות הכניסה של FF (בעזרת מפות קרנו או כל שיטה אחרת)
צייר הדיאגרמה הלוגית. *

41. דוגמת תכנון "תקין" "תקין" "שמאלה" "ימינה" מערב "שמאלה" מרכז "ימינה"
I Robot
"תקין"
"תקין"
"שמאלה"
"ימינה"
מערב
"שמאלה"
מרכז
"ימינה"
מזרח
"תקין"
"תקין"
"שמאלה"
"ימינה"
"תקוע"
"תקוע"

42. אוטומט המצבים – תיאור סמלי:
מרכז
תקין / שמאל
תקין / ימין
תקין / ימין
תקוע / שמאל
תקין / שמאל
מזרח
מערב
תקוע / ימין

43. 00 10 01 אוטומט המצבים: תקין : 0 תקוע : 1 "ימין" : 0 "שמאל" : 1
תקין : 0 תקוע : 1
"ימין" : 0 "שמאל" : 1
המצב הנוכחי
קלט X
המצב הבא
פלט Y A B 1 A B 00
0/0
1/0
קלט
מרכז
1/1 10 01
1/0
0/0
פלט
מזרח
מערב
0/1
3 מצבים
נזדקק ל – 2FF
2FF יכולים "לזכור" 4 מצבים.
מצב שלא משתמשים בו ("11")

44. טבלת המצבים + מעברים:
המצב הנוכחי
קלט X
המצב הבא
פלט Y A B 1

45. פונקציות יציאה + מצב הבא:
מימוש עבור D-FF Bt 1 
A(t+1) = B’X’ = (B+X)’ At Xt Bt 1 
B(t+1) = A’X At Xt Bt 1 
Y(t) = AX’ + BX At Xt

46. מימוש עבור DFF (שעון מושמט)
דיאגרמה לוגית:
AX’ X D Q
B’X’ A C Q’ y D Q
A’X B BX C Q’
מימוש עבור DFF (שעון מושמט)

47. Graphical Specification of FSM
How many state bits will we need?
חובר בספטמבר 2001

48. Finite State Machine for Control
חובר בספטמבר 2001

49. The control signals decoder
We just implement the table of slide 54:
Let’s look at ALUSrcA: it is “0” in states 0 and 1 and it is “1” in states 2, 6 and 8. In all other states we don’t care.
let’s look at PCWrite: it is “1” in states 0 and 9. In all other states it must be “0”.
And so, we’ll fill the table below and build the decoder. S3 S2 S1 S0
ALUSrcA
state
Control signals 1 X
PCWrite
All other combinations
PCWriteCond
fetch
decode
AdrCmp
load WB
store
ALU
WBR
branch
jump

50. The state machine “next state calc.” logic
IR31
IR30
IR29
IR28
IR27
IR26
opcode S3 S2 S1 S0
current state
next state X 1
Fetch
Jump 9
WBR 7
Load 3
Branch 8
ALU 6
AdrCmp 2
Store 5
Decode 1 WB 4
lw+sw
R-type
beq j sw lw
R-type
lw+sw lw sw
R-type=000000, lw=100011, sw=101011, beq=000100, bne=000101, lui=001111, j= , jal=000011, addi=001000

51. Interrupt and exception
Type of event From Where ? MIPS terminology
Interrupt External I/O device request
Invoke Operation system Internal Exception
From user program
Arithmetic Overflow Internal Exception
Using an undefined
Instruction Internal Exception
Hardware malfunctions Either Exception or interrupt
חובר בספטמבר 2001

52. Exceptions handling Exception type Exception vector address (in hex)
Undefined instruction c
Arithmetic Overflow c
We have 2 ways to handle exceptions:
Cause register or Vectored interrupts
MIPS – Cause register
חובר בספטמבר 2001

53. Handling exceptions

54. Handling exceptions
חובר בספטמבר 2001

55. Handling interrupts: Jump WBR Load ALU Store WB 1 5 2 8 6 9 7 4 3
Fetch
Jump
WBR
Load
Branch
ALU
AdrCmp
Store
Decode WB 1 5 2 8 6 9 7 4 3
lw+sw
R-type
beq j sw lw
SavePC 10
IRET
JumpInt 11

56. PLA Implementation
If I picked a horizontal or vertical line could you explain it?
חובר בספטמבר 2001

57. ROM Implementation ROM = "Read Only Memory"
values of memory locations are fixed ahead of time
A ROM can be used to implement a truth table
if the address is m-bits, we can address 2m entries in the ROM.
our outputs are the bits of data that the address points to m is the "heigth", and n is the "width" m n
חובר בספטמבר 2001

58. ROM Implementation
How many inputs are there? 6 bits for opcode, 4 bits for state = 10 address lines (i.e., 210 = 1024 different addresses)
How many outputs are there? 16 datapath-control outputs, 4 state bits = 20 outputs
ROM is 210 x 20 = 20K bits (and a rather unusual size)
Rather wasteful, since for lots of the entries, the outputs are the same — i.e., opcode is often ignored
חובר בספטמבר 2001

59. ROM vs PLA
Break up the table into two parts — 4 state bits tell you the 16 outputs, x 16 bits of ROM — 10 bits tell you the 4 next state bits, 210 x 4 bits of ROM — Total: 4.3K bits of ROM
PLA is much smaller — can share product terms — only need entries that produce an active output — can take into account don't cares
Size is (#inputs ´ #product-terms) + (#outputs ´ #product-terms) For this example = (10x17)+(20x17) = 460 PLA cells
PLA cells usually about the size of a ROM cell (slightly bigger)
חובר בספטמבר 2001

60. Microprogramming
What are the “microinstructions” ?
חובר בספטמבר 2001

61. Microprogramming A specification methodology
appropriate if hundreds of opcodes, modes, cycles, etc.
signals specified symbolically using microinstructions
Will two implementations of the same architecture have the same microcode?
What would a microassembler do?
חובר בספטמבר 2001

62. Details
חובר בספטמבר 2001

63. Microinstruction format
חובר בספטמבר 2001

64. Maximally vs. Minimally Encoded
No encoding:
1 bit for each datapath operation
faster, requires more memory (logic)
used for Vax 780 — an astonishing 400K of memory!
Lots of encoding:
send the microinstructions through logic to get control signals
uses less memory, slower
Historical context of CISC:
Too much logic to put on a single chip with everything else
Use a ROM (or even RAM) to hold the microcode
It’s easy to add new instructions
חובר בספטמבר 2001

65. Microcode: Trade-offs
Distinction between specification and implementation is sometimes blurred
Specification Advantages:
Easy to design and write
Design architecture and microcode in parallel
Implementation (off-chip ROM) Advantages
Easy to change since values are in memory
Can emulate other architectures
Can make use of internal registers
Implementation Disadvantages, SLOWER now that:
Control is implemented on same chip as processor
ROM is no longer faster than RAM
No need to go back and make changes
חובר בספטמבר 2001

66. “Macro and micro - instruction” Interpretation
User program
plus Data
this can change!
Main
Memory
ADD
SUB
AND .
one of these is
mapped into one
of these
DATA
execution
unit
CPU
control
memory
AND microsequence
e.g., Fetch
Calc Operand Addr
Fetch Operand(s)
Calculate
Save Answer(s)

67. The Big Picture
חובר בספטמבר 2001

68. Edge Triggered Flip-Flops
דלגלגים מדורבני קצה:
Edge Triggered Flip-Flops
שינוי המצב מתבצע עם שינוי השעון ומתייצב אח"כ.
דופק ושעון חיובי
קצה חיובי
קצה שלילי
דופק ושעון שלילי
קצה שלילי
קצה חיובי
Ts-Setup Time CP Ts Tn
Th-Holdup Time D
יציב Ts+Tn

69. כניסות ישירות: Direct Inputs
כאשר המתח במעגל ספרתי "עולה" המצב של Flip Flops איננו מוגדר לכן יש לבצע אתחול.
אתחול מבוצע ע"י כניסות ישירות אשר קובעות ישירות את המצב (Preset).
preset / clear J Q CP K Q’
PreSet CP J K Q Q’  1 
no change
flip state

70. מעגלים סדרתיים – תזמון:
דוגמא:
MSJFF
MSJFF YA YB  J Q J
Out A B Q CP CP K Q’ K Q’
Out(t)
D(t-2) 
2JKFF  CP YA QA YB QB