‫‪For more please visit – www.nsof.

info‬‬

‫‪:Look Ahead Carry Generator‬‬ ‫אלגברה בוליאנית‬ ‫בסיסים וקודים‬

‫בעזרת הפונקציות הבאות ניתן לחזות מה יהיה ה‪ Carry -‬וע"י כך לחסוך‬ ‫נוסחאות פישוט‪:‬‬ ‫מעבר מבסיס ‪ r‬לבסיס ‪:10‬‬
‫רמות במימוש‪.‬‬ ‫‪n‬‬

‫‪Si = Ai ⊕ Bi ⊕ Ci = Pi ⊕ Ci‬‬ ‫‪Gi = Ai ⋅ Bi‬‬ ‫‪Ci +1 = Gi + Pi ⋅ Ci‬‬ ‫; ‪X +0 = X ; X +1= 1 ; X + X = X‬‬ ‫)‪X +YZ = (X +Y)(X + Z‬‬ ‫= ‪(23.1)5‬‬ ‫‪∑ar‬‬
‫‪i =− m‬‬
‫‪i‬‬
‫‪i‬‬
‫‪= 2 ⋅ 51 + 3 ⋅ 50 + 1 ⋅ 5−1 = 13.2‬‬
‫‪X × X = X ; X × X' = 0 ; X + X' = 1‬‬ ‫‪(X +Y)(X +Y') = X ; X(X +Y) = X‬‬
‫לדוגמא‪:‬‬
‫)‪(X +Y)+ Z = X +(Y + Z‬‬ ‫‪XY' +Y = X +Y‬‬ ‫מעבר מבסיס ‪ 10‬לבסיס ‪:r‬‬
‫‪C2 = G1 + PC‬‬
‫) ‪1 1 = G1 + P1 (G0 + P0C0‬‬ ‫‪(242.1875)10 → (?)8‬‬
‫‪(XY)Z = X(YZ) = XYZ‬‬ ‫‪XY +YZ + X'Z = XY + X'Z‬‬
‫חיבור בבסיס אחר מ‪) 2 -‬בסיס ‪ (r‬ע"י ‪:FA‬‬ ‫‪X(Y + Z) = XY + XZ‬‬ ‫‪(X +Y)(X' + Z) = XZ + X'Y‬‬ ‫⎫ )‪242 / 8 = 30 (2) LSB 0.1875 ⋅ 8 = 1.5 (1‬‬
‫‪ .1‬הופכים את הספרה ‪ r-1‬לבינארי – ובודקים כמה סיביות צריך ע"מ‬ ‫⎪‬
‫לייצג אותה בבינארי‪.‬‬
‫‪XY + XY' = X ; X + XY = X‬‬ ‫)‪(X +Y)(Y + Z)(X' + Z) = (X +Y)(X' + Z‬‬ ‫)‪30 / 8 = 3 (6‬‬ ‫‪0.15 ⋅ 8 = 4.0 (4) ⎬ (362.14)8‬‬
‫‪ .2‬מחברים שתי ספרות ‪ r-1‬ומקבלים תוצאה בעשרוני‪.‬‬ ‫' )' ‪( X + Y + Z + ...) = ( X ' Y ' Z‬‬ ‫' ‪( XYZ ) ' = X '+ Y '+ Z‬‬
‫דה‪-‬מורגן‪:‬‬ ‫‪3 / 8 = 0 (3) MSB‬‬ ‫‪0⋅8 = 0‬‬ ‫⎪‬
‫⎭‬
‫‪ .3‬הופכים את התוצאה לבסיס ‪.r‬‬
‫‪ .4‬מייצגים את ספרת האחדות של התוצאה מסעיף ‪ ,3‬ע"י מספר בבינארי‬ ‫‪:Xor / Xnor‬‬ ‫חילוק‪:‬‬ ‫מעבר מבסיס ‪ t‬לבסיס ‪:r‬‬
‫‪( x ⊕ y) ' = x y = x ⊗ y‬‬ ‫‪101.1‬‬ ‫כאשר ‪ t‬ו‪ r -‬הם חזקות של אותו מספר‪ .‬למשל – ‪ 2,4,8,16‬או ‪:3,9,27‬‬ ‫‪.1‬‬
‫עם מס' הסיביות הדרוש לספרה )מסעיף ‪.(1‬‬
‫‪ .5‬מייצגים את ספרת העשרות ע"י סיבית ‪ 1‬בבינארי‪.‬‬ ‫‪(2501.24)8 → (?) 2‬‬
‫‪x⊕ y⊕z = x y z‬‬ ‫‪11011.1 101‬‬
‫‪ .6‬שמים את ספרת העשרות בבינארי משמאל למספר בבינארי שקיבלנו‬ ‫‪101‬‬ ‫‪(010 101 000 001 . 010 100)2‬‬
‫בסעיף ‪.4‬‬ ‫' )‪x '⊕ y ⊕ z... = ( x ⊕ y ⊕ z...‬‬ ‫כל ספרה מיוצגת ע"י ‪ 3‬בבינארי‪. 23 = 8 :‬‬
‫‪00111‬‬
‫‪ .7‬מחברים שתי ספרות ‪ r-1‬בבינארי‪.‬‬ ‫' )' )‪x '⊕ y '⊕ z... = (( x ⊕ y ⊕ z...‬‬ ‫בכל מקרה אחר – עוברים דרך בסיס ‪.10‬‬ ‫‪.2‬‬
‫‪ .8‬מהתוצאה מחסרים את המספר מסעיף ‪.6‬‬ ‫‪101‬‬
‫‪ .9‬זהו המספר בבינארי שיש להוסיף לתוצאת החיבור של ה‪.FA -‬‬ ‫' ‪x ⊕ 0 = x , x ⊕1 = x‬‬ ‫קוד ‪) BCD‬זהה לקוד ממושקל ‪:(8421‬‬
‫‪0101‬‬
‫‪ .10‬ממשים ‪ Correction Unit‬שמחברת לכל סיבית שהגיעה מה‪ FA -‬את‬ ‫‪(171.7)10 = (0001 0111 0001 . 0111) BCD‬‬
‫‪101‬‬
‫המספר מסעיף ‪ 9‬רק אם ה‪ Carry -‬מה‪ FA -‬הוא ‪ 1‬או אם הסיביות‬ ‫' )‪( x ⊕ y ⊕ z‬‬ ‫‪x⊕ y⊕z‬‬ ‫קודים ממושקלים‪:‬‬
‫שהגיעו מה‪ FA -‬מייצגות ביחד את המספר ‪ 10‬בבסיס ‪.r‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪000‬‬ ‫קוד חוקי = אם ניתן להציג את כל הספרות בעזרתו‪.‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬
‫בעיות עלות מינימלית‪:‬‬ ‫‪(3)10 = (?)642−3‬‬
‫בוררים‪ ,‬מפענחים מקודדים ומשווים‬ ‫‪ XOR‬נותן ‪ 1‬אם מספר האחדים הוא‬
‫ישירות‬ ‫‪Xor‬‬‫מעבר ל‪-‬‬ ‫‪.1‬‬
‫‪= 1 ⋅ 6 + 0 ⋅ 4 + 0 ⋅ 2 + 1 ⋅ ( −3) = 3 ⇒ (1001)642−3‬‬
‫ממפת קרנו‪.‬‬
‫‪ - Encoder‬מקודד‪:‬‬ ‫‪ - Decoder‬מפענח‪:‬‬ ‫‪ - MUX‬בורר‪:‬‬ ‫אי‪-‬זוגי‪.‬‬ ‫שימוש בנוסחאות פישוט‪.‬‬ ‫‪.2‬‬ ‫יכול להיות יותר מייצוג ‪ 1‬לכל מספר‪.‬‬
‫מקבל קוד בינארי – מוציא ‪ 1‬מקבל ‪ 1‬באחת הכניסות‬ ‫דוגמא ‪:MUX 4x1 -‬‬ ‫‪ XNOR‬נותן ‪ 1‬אם מספר האפסים הוא‬ ‫דה מורגן‪.‬‬ ‫‪.3‬‬ ‫קוד ‪:Excess-3‬‬
‫ביציאה המייצגת את המספר ומוציא את המספר המתאים‬ ‫זוגי‪.‬‬
‫העשרוני המתאים‪ .‬בכל שאר בבינארי‪.‬‬ ‫מוסיפים ‪ 3‬לספרה העשרונית‪ ,‬וממירים לבינארי‪.‬‬
‫‪Priority‬‬ ‫ניתן לקבוע‬ ‫היציאות – ‪.0‬‬ ‫הערות לפונקציות בוליאנ'‪:‬‬ ‫‪(1955)10 = 4 12 8 8 = (0100 1100 1000 1000) Excess−3‬‬
‫‪ Encoder‬כך שאם יש‬ ‫דוגמא ‪ -‬מפענח ‪.2x4‬‬ ‫‪ -‬יעילות של פונקציה בוליאנית שערים לוגיים‪:‬‬
‫בכניסות יותר ממספר ‪1‬‬ ‫‪AND : xy‬‬ ‫קוד משלים עצמי‪:‬‬
‫נקבעת ע"י מספר המכפלות‪.‬‬
‫אחד‪ ,‬אז מתיחסים רק ל‪1 -‬‬ ‫אם הייצוג של ‪ 9-N‬יכול להתקבל מהייצוג של ‪ N‬ע"י הפיכת הסיביות‪.‬‬
‫‪OR : x + y‬‬ ‫בשוויון בודקים את המחברים‪.‬‬
‫הגדול ביותר‪ ,‬ועל שאר‬
‫‪ -‬כל פונקציה בוליאנית היא‬ ‫‪N = (3)10 ⇒ 3 + 3 = (0110) Excess −3‬‬
‫הכניסות יש ‪.Don’t Care‬‬ ‫' ‪NOT : x‬‬
‫מצב בו כל הכניסות‬ ‫דואלית‪ .‬כלומר‪ ,‬ניתן להחליף‬ ‫‪(9 − 3)10 ⇒ 6 + 3 = (1001) Excess −3‬‬
‫מקבלות ‪ 0‬אינו מוגדר‬ ‫' ) ‪NAND : ( xy‬‬ ‫"‪ "1‬ב‪ "+" ,"0" -‬ב‪" i " -‬‬ ‫הערה‪ BCD :‬אינו קוד משלים עצמי‪.‬‬
‫במקודד‪.‬‬ ‫ולהיפך – כולל התוצאה‪,‬‬
‫דוגמא ‪ -‬מקודד ‪.4x2‬‬ ‫' ) ‪NOR : ( x + y‬‬
‫ועדיין השוויון יתקיים‪.‬‬ ‫קוד ממושקל משלים עצמי‪:‬‬
‫‪E‬‬ ‫‪E‬‬ ‫‪E‬‬ ‫‪XOR : x ' y + xy ' = x ⊕ y‬‬
‫אם סכום המשקולות = ‪.9‬‬
‫‪00‬‬ ‫‪XNOR : xy + x ' y ' = x‬‬ ‫‪y‬‬
‫‪0‬‬ ‫‪00‬‬ ‫‪X‬‬ ‫‪00‬‬
‫‪1‬‬ ‫‪01‬‬ ‫‪Y‬‬ ‫‪01‬‬ ‫‪01‬‬ ‫מערכת פעולה שלמה )קבוצות אוניברסאליות(‬ ‫מרחק בין מילות קוד )מרחק ‪:(Hamming‬‬
‫‪2‬‬ ‫‪10‬‬ ‫‪10‬‬ ‫‪10‬‬ ‫קבוצת פעולות בעזרתה ניתן להציג כל פונקציה בוליאנית‪ .‬כלומר‪ ,‬פונקציה‬ ‫מספר הסיביות השונות בין ‪ 2‬מילות קוד‪.‬‬
‫‪3‬‬ ‫‪11‬‬ ‫‪11‬‬ ‫‪11‬‬ ‫אחת שבעזרתה ניתן לייצג אחת מהקבוצות הבאות‪:‬‬ ‫‪ - 100 ⇔ 001‬מרחק = ‪.2‬‬
‫} ' ; ‪NOR = { + ; ' } = ( x + y ) ' NAND = { i ; ' } = ( xy ) ' { + ; i‬‬ ‫מרחק מינימלי – המרחק הקטן ביותר בין מילים בקוד‪ .‬אם המרחק‬
‫‪XY‬‬
‫שגיאות‪.‬‬
‫הערה‪ :‬אם בכניסה ‪ (Enable) E‬מגיע ‪ 0‬אז כל היציאות יהיו ‪.0‬‬
‫בעזרת ‪ NOT‬ו‪ (NAND) AND -‬או ‪ NOT‬ו‪ (NOR) OR -‬ניתן לייצג כל פונקציה‬
‫בוליאנית‪.‬‬
‫המינימלי ‪ ,K‬ניתן לגלות עד ‪ K-1‬שגיאות‪ ,‬ולתקן עד ]‪[(k − 1) / 2‬‬
‫במקום לפתור תרגיל נתון ניתן להמירו למערכת שקולה ע"י דה‪-‬מורגן ‪-‬‬ ‫קוד ‪:Gray‬‬
‫‪) Comperator‬משווה(‪:‬‬ ‫ולפתור אותה‪.‬‬ ‫קוד ציקלי‪ ,‬כל מספר נבדל מאלו שמעליו ומתחתיו בסיבית אחת בלבד‬
‫‪A3 A2 A1 A0‬‬ ‫)מרחק בין מילות קוד = ‪.(1‬‬
‫צורות קנוניות‬ ‫מעבר מקוד ‪ Gray‬לבינארי )סיבית ראשונה נשארת(‪:‬‬
‫‪L – A<B‬‬
‫‪4 bit‬‬ ‫‪ .1‬הולכים סיבית‪ ,‬סיבית – משמאל לימין‪.‬‬
‫‪E – A=B‬‬ ‫‪:Minterm & Maxterm‬‬ ‫‪ .2‬סופרים כמה אחדים יש משמאל לסיבית עליה נמצאים )לא כולל(‪.‬‬
‫‪Comperator‬‬ ‫‪G – A>B‬‬ ‫‪X‬‬ ‫‪Y‬‬ ‫‪Z‬‬ ‫‪Min‬‬ ‫‪Max‬‬
‫לדוגמא ‪ -‬נוסחה ל‪:G -‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫’‪X’Y’Z‬‬ ‫‪X+Y+Z‬‬ ‫‪ .3‬אם מספר האחדים זוגי ‪ -‬לא משנים את הסיבית‪.‬‬
‫‪B3 B2 B1 B0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪X’Y’Z‬‬ ‫’‪X+Y+Z‬‬ ‫‪ .4‬אם מספר האחדים אי‪-‬זוגי – הופכים את הסיבית‪.‬‬
‫וכן הלאה‪...‬‬ ‫מעבר מבינארי לקוד ‪) Gray‬סיבית ראשונה נשארית(‪:‬‬
‫‪.A3=B3, A2=B2, A1>B1‬‬ ‫‪.3‬‬ ‫‪.A3>B3‬‬ ‫‪.1‬‬ ‫ייצוגים קנוננים‪:‬‬ ‫‪ .1‬הולכים סיבית‪ ,‬סיבית – משמאל לימין‪.‬‬
‫' ‪A3 B3 ⋅ A2 B2 ⋅ A1B1‬‬ ‫' ‪A3 ⋅ B3‬‬ ‫‪ – SOP‬סכום מכפלות קנוני – סכום המינטרמים בהם הפונקציה מקבלת‬ ‫‪ .2‬מבצעים ‪ XOR‬בין הסיבית שעליה נמצאים לסיבית משמאלה‪.‬‬
‫"‪ ."1‬למשל‪:‬‬ ‫‪ .3‬אם מספר האחדים אי‪-‬זוגי – הופכים את הסיבית‪.‬‬
‫‪.A3=B3, A2=B2, A1=B1, A0>B0‬‬ ‫‪.4‬‬ ‫‪.A3=B3, A2>B2‬‬ ‫‪.2‬‬
‫‪ – POS‬מכפלת סכומים קנונית – מכפלת מקסטרמים בהם הפונקציה‬
‫‪A3‬‬ ‫‪B3 ⋅ A2‬‬ ‫‪B2 ⋅ A1‬‬ ‫' ‪B1 ⋅ A0 B0‬‬ ‫' ‪A3 B3 ⋅ A2 B2‬‬
‫מקבלת את הערך "‪ ."0‬למשל‪:‬‬ ‫זוגיות‪:‬‬
‫)‪f ( x, y, z ) = ∏ (3, 4, 5) + ∏ d (0, 7) = ∑ (0,1, 2, 6, 7) + ∑ d (0, 7‬‬ ‫‪ – Even Parity‬מוספים ‪ 1‬כדי שמספר האחדים יהיה זוגי‪.‬‬
‫בין הסעיפים)‪ :(1-4‬שער ‪.OR‬‬ ‫‪ – Odd Parity‬מוסיפים ‪ 0‬עדי שמספר האחדים יהיה אי‪-‬זוגי‪.‬‬
‫)‪f ' = ∏ (0,1, 2, 6, 7) + ∏ d (0, 7‬‬ ‫‪1011 0 − Odd Parity‬‬ ‫‪1011 1 − Even Parity‬‬
‫‪Static Hazard‬‬ ‫מפות קרנו‪:‬‬
‫הגדרה – אם המוצא אמור היה להשאר קבוע‪ ,‬כאשר רק אחת הכניסות‬ ‫עבור ‪:(LSB = D) POS‬‬ ‫ייצוג מספרים‬
‫משתנה‪ ,‬אך הוא נתן תוצאה אחרת‪ .‬תופעה זו מתקיימת בגלל שחלק‬ ‫‪CD‬‬ ‫’‪CD‬‬ ‫’‪C’D‬‬ ‫‪C’D‬‬
‫מהמשתנים עוברים דרך יותר שערים בדרך למוצא‪.‬‬ ‫‪) _ _._ _ :Fixed Point‬טווח מוגבל(‪.‬‬
‫‪00‬‬ ‫‪01‬‬ ‫‪11‬‬ ‫‪10‬‬
‫‪ :Hazard 1‬המוצא אמור היה להשאר ‪ 1‬והפך ל‪) 0 -‬קורה במימוש ‪.(SOP‬‬ ‫‪AB‬‬ ‫‪00‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪3‬‬ ‫‪2‬‬
‫‪ :Hazard 0‬המוצא אמור היה להשאר ‪ 0‬והפך ל‪) 1 -‬קורה במימוש ‪.(POS‬‬ ‫’‪AB‬‬ ‫‪01‬‬ ‫‪4‬‬ ‫‪5‬‬ ‫‪7‬‬ ‫‪6‬‬ ‫‪number = M ⋅ r E :Floating Point‬‬
‫עבור המספר ‪53.491‬‬
‫’‪A’B‬‬ ‫‪11‬‬ ‫‪12‬‬ ‫‪13‬‬ ‫‪15‬‬ ‫‪14‬‬
‫שיטת מינימיזציה – ‪Quine Mclluskey‬‬ ‫‪ – r = 10‬בסיס ‪.10‬‬
‫‪A’B‬‬ ‫‪10‬‬ ‫‪8‬‬ ‫‪9‬‬ ‫‪11‬‬ ‫‪10‬‬
‫מציאת הגורמים ‪ /‬מינטרמים‪.‬‬ ‫‪.1‬‬ ‫מנטיסה – המספר עצמו‪.5.3491 :‬‬
‫‪ -‬מותר רביעיה )כאילו באלכסון‪(...‬‬
‫הכנסת לטבלה‪:‬‬ ‫‪.2‬‬
‫)' ‪f = ( D + B ) ⋅ ( D '+ B‬‬ ‫‪M ⋅ r E = 5.3491 ⋅ 101 = 53.491‬‬ ‫אקספוננט – ‪.01 – E‬‬
‫‪1#‬‬ ‫גורמים‬ ‫‪1#‬‬ ‫גורמים‬ ‫‪1#‬‬ ‫גורמים‬
‫עשרוני‬ ‫בינארי‬ ‫עשרוני‬ ‫בינארי‬ ‫בינארי עשרוני‬ ‫ליטרלים = משתנים‪.‬‬ ‫הצגת סימן‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0000‬‬ ‫‪0‬‬ ‫‪0,1‬‬ ‫‪000-‬‬ ‫‪0‬‬ ‫‪0,1,2, 00- -‬‬
‫‪0,2‬‬ ‫‪00-0‬‬ ‫‪3‬‬ ‫אימפליקנט ראשי )גורם ראשי( = גורם שאינו מוכל בגורם גדול יותר‪.‬‬ ‫‪:Sign / Magnitude‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪0001‬‬ ‫‪1‬‬ ‫‪1,3‬‬ ‫‪00-1‬‬ ‫הערה‪ :‬מותר לקחת רק קבוצות של חזקות של ‪ .2‬אסור לקחת קבוצה של ‪3‬‬ ‫הספרה השמאלית מייצגת סימן‪.‬‬
‫‪2‬‬ ‫‪0010‬‬ ‫‪2,3‬‬ ‫‪001-‬‬
‫‪2‬‬ ‫‪3‬‬ ‫‪0011‬‬ ‫תאים‪.‬‬ ‫‪ = 0‬חיובי‪ = r-1 .‬שלילי‪.‬‬
‫הערה‪ :‬משווים מספרים בקבוצות סמוכות‪ ,‬כאשר כל הסיביות זהות‬ ‫מצבים לא מוגדרים )‪:(don’t care‬‬ ‫‪( +5)10 = (0 / 05)10 ; (−5)10 = (9 / 05)10‬‬
‫)כולל קו מול קו( פרט לאחת‪ .‬השוני בה מתבטא ע"י ‪ 0‬או ‪) 1‬ולא ע"י‬ ‫מסומנים ע"י‪ ,d ,X :‬או ‪. φ‬‬ ‫יש ‪ 2‬ייצוגים ל‪.0 -‬‬
‫קו(‪.‬‬ ‫בשיטה זו – עושים בנפרד פעולות על הסימן‪.‬‬
‫בעזרת טבלת גורמים ראשוניים מצמצמים את מה שמיותר‪:‬‬ ‫‪.3‬‬ ‫ניתן להוסיפם לגורם אך לא לקחת אותם כגורם נפרד‪.‬‬
‫גורמים‬ ‫‪1‬‬ ‫‪4‬‬ ‫‪5‬‬ ‫‪6‬‬ ‫‪11‬‬ ‫‪12‬‬ ‫‪13‬‬ ‫‪14‬‬ ‫החלפת עמודות ‪ /‬שורות במפות קרנו‪:‬‬ ‫‪±2 − 1‬‬
‫‪n−1‬‬
‫‪:‬‬ ‫בבינארי‬ ‫מס' מקס' ומינ'‬
‫‪4,6,12,14‬‬ ‫‪X‬‬ ‫‪X‬‬ ‫‪X‬‬ ‫‪X‬‬ ‫אם נחליף לפחות משתנה אחד בהופכי שלו )למשל ‪ A‬ב‪ ,(A' -‬נשנה את‬ ‫‪-‬‬ ‫משלים ל‪:r-1 -‬‬
‫‪12,13‬‬ ‫‪X‬‬ ‫‪X‬‬
‫‪1,5‬‬ ‫‪X‬‬ ‫‪X‬‬ ‫סדר כל ארבעת השורות או העמודות ביחד‪.‬‬ ‫‪( +631)10 = (0 / 631)10 ; ( −631)10 = (9 / 368)10‬‬
‫אם נחליף משתנה במשתנה שלידו )למשל ‪ A‬עם ‪ (B‬אז נחליף רק ‪2‬‬ ‫‪-‬‬
‫שורות ‪ /‬עמודות‪.‬‬
‫‪( +11)10 = (0 /1011) 2 ; ( −11)10 = (1/ 0100)2‬‬
‫‪:Shift Register with Parallel Load‬‬
‫יש ‪ 2‬ייצוגים ל‪.0 -‬‬
‫מעבר מ‪ AND -‬ו‪ OR -‬ל‪NAND -‬‬ ‫מס' מקס' ומינ' בבינארי‪±2n−1 − 1 :‬‬
‫‪ .1‬מגיעים ל‪ SOP -‬מינימלי‪.‬‬ ‫דוגמא לחיבור‪:‬‬
‫‪ .2‬מבצעים פיקטור בהתאם להגדרת ‪) Fan In‬מס' כניסות לשער(‪.‬‬ ‫אם יש גלישה – מוסיפים אותה ל‪.LSB -‬‬
‫‪ .3‬ממשים ע"י שערי ‪ AND‬ו‪ OR -‬כך שבכל רמה מופיע שער אחר )‪AND-‬‬ ‫‪14‬‬ ‫‪10001 110001‬‬
‫‪+‬‬ ‫‪+‬‬ ‫‪+‬‬
‫‪.(OR-AND-OR...‬‬ ‫‪−12‬‬ ‫‪10011 110011‬‬
‫‪ .4‬מיספור הרמות מהיציאה ועד לכניסה‪.‬‬
‫‪ .5‬החלפת כל שער בשער ‪.NAND‬‬ ‫‪−26‬‬ ‫‪1100100‬‬
‫‪+‬‬
‫‪ .6‬את כל הכניסות לרמות האי‪-‬זוגיות מקבלות ‪) NOT‬כניסות ברמות‬ ‫‪1‬‬
‫הזוגיות נשארות אותו הדבר(‪.‬‬
‫‪100101‬‬
‫הערה‪ :‬ניתן גם להגיע לפונקציה של מכפלות עם ‪ NOT‬בלבד )ע"י דה‪-‬מורגן(‬
‫ואז לממש ישירות ע"י ‪.NAND‬‬ ‫משלים ל‪:r -‬‬
‫‪( −631)10 = (9 / 368 + 1)10 = (9 / 369)10‬‬
‫מסכמים ומחסרים‬ ‫‪( −11)10 = (111 / 0100 + 1) 2 = (111 / 0101) 2‬‬
‫‪:Full Adder‬‬ ‫‪ -‬את ה‪ 1 -‬תמיד מוסיפים ל‪) LSB -‬לא קשור לנק' עשרונית – תמיד לסיבית‬
‫מחבר ‪ /‬מחסר‪:‬‬ ‫= ‪S = A⊕ B ⊕C‬‬ ‫הימנית ביותר‪ ,‬ולא משנה אם עוברים מ‪ "-" -‬ל‪ "+" -‬או ההפך(‪.‬‬
‫'‪ 1 :a / s‬עבור חיבור‪ 0 ,‬עבור חיסור‪.‬‬ ‫‪ -‬בחיבור‪ :‬אם יש גלישה – מזניחים אותה‪ ,‬אלא אם חיברנו ‪ 2‬מספרים‬
‫‪= A ' B ' C + A ' BC '+ AB ' C '+ ABC‬‬
‫‪X‬‬ ‫‪Y‬‬ ‫שלילים )אם התשובה אמורה לצאת במינוס – לא מזניחים את ה‪.(1 -‬‬
‫’‪a / s‬‬ ‫‪Cout = AB + ACin + BCin = AB + ( A ⊕ B )Cin‬‬ ‫‪A‬‬ ‫‪B‬‬
‫‪B in‬‬ ‫‪FA‬‬ ‫‪B out‬‬
‫‪Cout‬‬ ‫‪Cin‬‬ ‫הערה‪ :‬אם המספר מוצג ביותר סיביות ממה שצריך – פשוט משכפלים את‬
‫‪2-bit FA‬‬
‫סיבית הסימן‪.‬‬
‫‪S‬‬ ‫‪ – 1‬לא מספר ראשוני‪ – 0 .‬מספר ראשוני‪.‬‬
‫‪S‬‬
 ‫‪For more please visit – www.nsof.info‬‬

‫מערכות מורכבות‬ ‫מערכות עקיבה סינכרוניות‬ ‫רכיבי זיכרון‬

‫מבנה כללי‪:‬‬ ‫מכונת מצבים סופית )‪:(Finite State Machine‬‬ ‫‪:Rom – Read Only Memory‬‬
‫‪ .1‬אוסף סופי של מצבים‪ .‬בד"כ אחד מהם מוגדר כמצב ההתחלתי‪.‬‬ ‫דוגמא – ‪ROM 2n × m‬‬
‫רשת צירופית‬ ‫מונה‬ ‫מחלק תדר‬
‫‪ .2‬אם יש ‪ n‬מצבים צריך ‪ n : 2n : m‬תאי זיכרון )אך לכן עושים‬
‫‪ - n‬כניסות למפענח‪.‬‬
‫מינימיזציה שתידון בהמשך(‪.‬‬
‫‪ - 2n‬יציאות מהמפענח‪.‬‬
‫מונה‪:‬‬ ‫‪ .3‬מספר סופי של כניסות בינאריות‪ ,‬ומספר סופי של יציאות בינאריות‪.‬‬
‫‪ - m‬פונקציות יציאה )שערי ‪.(OR‬‬
‫תכנון מונה מתבצע ע"פ סד"פ סינתזה של מערכות עקיבה סינכרוניות‪,‬‬ ‫‪ .4‬אוסף חוקי מעבר המתארים לכל מצב נוכחי ולכל ערכי כניסה את‬ ‫‪0‬‬
‫כאשר הכניסות‪.‬‬ ‫המצב הבא‪.‬‬ ‫מפענח‬ ‫‪1‬‬
‫‪2‬‬
‫‪ .5‬פונקציה המתארת את היציאות‪:‬‬ ‫‪n : 2n‬‬
‫מחלק תדק ומונה בינארי ‪:Ripple Counter /‬‬ ‫מכונת ‪ :Moore‬היציאות הן פונקציה של המצב הנוכחי בלבד‪.‬‬ ‫א‪.‬‬ ‫‪Decoder‬‬
‫דוגמא‪:‬‬ ‫מכונת ‪ :Mealy‬היציאות הן פונקציה של המצב הנוכחי והכניסות‬ ‫ב‪.‬‬ ‫‪2n‬‬
‫מונה בינארי של ‪ 256‬שניות ע"י שימוש בשעון של ‪ 2‬שניות הכולל ‪.Clear‬‬ ‫הנוכחיות‪.‬‬
‫מחזור השעון הוא ‪ 2‬שניות‪ ,‬ולכן המונה צריך לספור ‪ 128‬מחזורי שעון‪:‬‬ ‫מכונת ‪ Moore‬היא מצב פרטי של מכונת ‪.Mealy‬‬ ‫ג‪.‬‬
‫‪. 128 = 256 / 2‬‬ ‫‪ .6‬מערכת סופית‪ :‬לא ניתן לממש באמצעות ‪ FSM‬כל פעולה רצויה על‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪. . . .‬‬ ‫‪m‬‬
‫‪ -‬נשתמש ב‪ T-FF -‬בעל כניסת ‪.Clear‬‬ ‫הקלט‪ ,‬מפני שיש לנו מספר סופי של מצבים‪ .‬לכן‪ ,‬על הקלט להיות‬
‫‪ -‬ביצוע ‪ Clear‬מכניס ‪ 0‬לכל ה‪.T-FF -‬‬ ‫סופי או מחזורי בעל חוקיות מסוימת שתאפשר יצירת מספר סופי של‬
‫מצבים‪.‬‬ ‫רכיבים מתכנתים‬
‫‪ -‬ה‪ T-FF -‬מתעדכן בעליית השעון!‬
‫מכונה סופית המקבלת קלט מחזורי חייבת להוציא פלט מחזורי‪.‬‬ ‫‪:PLA – Programmable Login Array‬‬
‫"‪"1‬‬
‫דוגמא ‪:PLA 3x4x2‬‬
‫‪T0‬‬ ‫‪T1‬‬ ‫‪T2‬‬ ‫‪T3‬‬ ‫‪T4‬‬ ‫‪T5‬‬
‫‪:Flip Flops‬‬ ‫' ‪F1' = a ' b '+ a ' c '+ b ' c‬‬ ‫‪F 2 = b ' c '+ a ' c '+ abc‬‬
‫טבלת אפיון – משמשת לניתוח מערכות )אנליזה(‪.‬‬ ‫טבלת תכנון ‪:PLA‬‬
‫טבלת עירור – משמשת לתכנון מערכות )סינתזה(‪.‬‬ ‫‪a‬‬ ‫‪b‬‬ ‫‪c‬‬ ‫‪F1‬‬ ‫‪F2‬‬
‫‪clk‬‬ ‫‪Q0‬‬ ‫‪Q1‬‬ ‫‪Q2‬‬ ‫‪Q3‬‬ ‫‪Q4‬‬ ‫‪Q5‬‬ ‫’‪b’c‬‬ ‫‪-‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬
‫‪Clear‬‬ ‫‪Y(t)=R’Y(t-1)+S :SR-FF‬‬ ‫’‪a’c‬‬ ‫‪0‬‬ ‫‪-‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬
‫טבלת עירור ‪SR‬‬ ‫טבלת אפיון ‪SR‬‬ ‫’‪a’b‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪-‬‬ ‫‪1‬‬
‫השרטוט הנ"ל הוא ‪ 6-bit Ripple Counter‬אבל בגלל שה‪ clk -‬הוא ‪ 2‬שניות אז‬
‫)‪Y(t-1‬‬ ‫)‪Y(t‬‬ ‫‪S‬‬ ‫‪R‬‬ ‫‪S‬‬ ‫‪R‬‬ ‫)‪Y(t‬‬ ‫‪abc‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪-‬‬ ‫‪1‬‬
‫זהו למעשה ‪) 7-bit Ripple Counter‬סופר מ‪ 0 -‬עד ‪ 127‬בבינארי וחוזר ל‪.(0 -‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪d‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫)‪Y(t-1‬‬
‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪a‬‬ ‫‪b‬‬ ‫‪c‬‬ ‫‪OR‬‬ ‫מימוש ב‪:PLA -‬‬
‫‪ Qi‬מדמה שעון בעל זמן מחזור כפול מ‪:Qi-1 -‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬
‫‪clk‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪d‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪-‬‬
‫‪Q0‬‬ ‫‪Y(t)=JY’(t-1)+K’Y(t-1) :JK-FF‬‬ ‫’‪a’b‬‬
‫‪Q1‬‬ ‫טבלת עירור ‪JK‬‬ ‫טבלת אפיון ‪JK‬‬ ‫’‪a’c‬‬
‫)‪Y(t-1‬‬ ‫)‪Y(t‬‬ ‫‪J‬‬ ‫‪K‬‬ ‫‪J‬‬ ‫‪K‬‬ ‫)‪Y(t‬‬ ‫’‪b’c‬‬
‫מינימיזציה של מכונות‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪d‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫)‪Y(t-1‬‬ ‫‪abc‬‬
‫בני הפרדה‪:‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪d‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪ 2‬מצבים ‪ A, B‬הם בני הפרדה )‪ (Distinguishable‬אם קיימת סדרת כניסה‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪d‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬
‫‪AND‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪d‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫’)‪Y(t-1‬‬
‫אחת לפחות )סדרת הפרדה( המספקת יציאות שונות מהמצבים ‪.A, B‬‬
‫‪Y(t+1)=D :D-FF‬‬ ‫‪F1‬‬ ‫‪F2‬‬
‫סדרת הפרדה מקסימלית של מכונה עם ‪ n‬מצבים היא באורך ‪.n-1‬‬ ‫טבלת עירור ‪D‬‬ ‫טבלת אפיון ‪D‬‬
‫)‪Y(t-1‬‬ ‫)‪Y(t‬‬ ‫‪D‬‬ ‫‪D‬‬ ‫)‪Y(t‬‬ ‫‪:PLA – Programmable Login Array‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬
‫‪ K‬בני הפרדה‪:‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬
‫‪ 2‬מצבים ‪ A, B‬הם ‪ K‬בני הפרדה אם קיימת עוברם סדרת הפרדה באורך ‪K‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬
‫שקולים‪:‬‬ ‫‪Y(t)=T⊕Y(t-1) :T-FF‬‬
‫‪ 2‬מצבים ‪ A, B‬הם שקולים אם כל סדרת כניסה אפשרית מפיקה אותה‬ ‫טבלת עירור ‪T‬‬ ‫טבלת אפיון ‪T‬‬
‫סדרת יציאה בין אם המצב ההתחלתי הוא ‪ A‬או ‪.B‬‬ ‫)‪Y(t-1‬‬ ‫)‪Y(t‬‬ ‫‪T‬‬ ‫‪T‬‬ ‫)‪Y(t‬‬
‫כלומר‪ A ,‬ו‪ B -‬שקולים אמ"מ הם אינם בני הפרדה‪.‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫)‪Y(t-1‬‬
‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫’)‪Y(t-1‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬
‫‪ K‬שקולים‪:‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪ A‬ו‪ B -‬הם ‪ K‬שקולים אמ"מ הם אינם ‪ K‬בני הפרדה‪.‬‬

‫האלגוריתם של ‪ Moore‬למינימיזציה‪:‬‬ ‫מימוש ‪ FF‬מסוג אחד בעזרת ‪ FF‬מסוג אחר‪:‬‬

‫דוגמא‪ :‬בניית ‪ JK‬בעזרת ‪.SR‬‬
‫מטבלת המצבים רואים את ההפרדה הראשונה בקלות ומשם מתחילים‪:‬‬
‫)‪(ABCD FG)(E‬‬ ‫ע"פ טבלת העירור של ‪ (SR) FF‬שבעזרתו בונים את ה‪ FF-‬החדש )‪(JK‬‬
‫רושמים טבלה בצורה הבאה‪:‬‬
‫‪x=0‬‬ ‫‪x=1‬‬
‫משתני עירור‬ ‫תוצאה נדרשת ע"י ‪ S‬ו‪R -‬‬
‫מערכות עקיבה‬
‫‪ECBGED CAGADG‬‬
‫‪(AF)(BCDG)(E)...‬‬ ‫‪J‬‬ ‫‪K‬‬ ‫)‪y(t-1‬‬ ‫)‪Y(t‬‬ ‫‪S‬‬ ‫‪R‬‬ ‫‪:SR-Latch‬‬
‫מכאן ממשיכים הלאה באותו האופן‪:‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪d‬‬ ‫‪S‬‬ ‫‪Q‬‬ ‫‪S‬‬ ‫‪Q‬‬
‫מפתחים את הביטוי גם ל‪ X=0 -‬וגם ל‪ X=1 -‬תמיד ובודקים אילו‬ ‫‪-‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪d‬‬ ‫‪0‬‬
‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪d‬‬ ‫=‬
‫מהאותיות שקיבלנו שייכות לאותה קבוצה )למשל ‪ (ABCDFG‬ואילו‬
‫וכן הלאה‪...‬‬ ‫’‪R Q‬‬
‫שייכות לקבוצה השניה )‪.(E‬‬ ‫’‪Q‬‬
‫בוחרים להשתמש בחלוקה אפשרית אחת )למשל ‪.(ECBGED -x=0‬‬ ‫‪-‬‬ ‫‪R‬‬
‫רושמים מחדש את החלוקה כך שהמצבים שהופיע כשייכים לקבוצה‬ ‫‪-‬‬ ‫אנליזה )ניתוח( של מערכות עקיבה סינכרוניות‬ ‫הערה‪ :‬אם ‪ S=R=1‬ומשנים אותם ביחד ל‪ S=R=0 -‬המצב אינו ידוע ‪/‬‬
‫אחרת יהיו בנפרד‪.‬‬ ‫רושמים את משוואות העירור )משוואות הכניסה( – ז"א מה שנכנס ל‪-‬‬ ‫‪.1‬‬ ‫מוגדר‪ .‬לכן יש מוסכמה – אין לשנות בו זמנית את ‪ S, R‬ב‪SR-Latch -‬‬
‫ממשיכים באותו אופן עד אשר מקבלים את אותו הביטוי פעמים‪.‬‬ ‫‪-‬‬ ‫‪ FF‬השונים במערכת‪.‬‬ ‫והמצב ‪ S=R=1‬אינו מוגדר‪.‬‬
‫אין חשיבות לסדר בתוך הקבוצה‪ ,‬אלא רק לשייכות לקבוצה עצמה‪.‬‬ ‫‪-‬‬ ‫ע"י המשוואות האופייניות של ה‪ FF -‬מוצאים את משוואות המצב‬ ‫‪.2‬‬
‫הבא‪.‬‬ ‫‪:Gated SR-Latch‬‬
‫רישום טבלת המצבים החדשה‪:‬‬ ‫מוצאים את משוואת התפוקה )מוצא המערכת(‪.‬‬ ‫‪.3‬‬ ‫טבלת עירור‬
‫‪PS‬‬ ‫‪NS‬‬ ‫טבלת מעברים‪:‬‬ ‫‪.4‬‬ ‫‪S‬‬ ‫‪S‬‬ ‫‪Q‬‬ ‫‪G‬‬ ‫‪S‬‬ ‫‪R‬‬ ‫)‪Q(t+1‬‬
‫‪X=0‬‬ ‫‪X=1‬‬ ‫‪PS‬‬ ‫‪NS‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪Q‬‬
‫‪G‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪A=α‬‬ ‫‪ε‬‬ ‫‪0‬‬ ‫‪δ‬‬ ‫‪0‬‬ ‫‪X=0‬‬ ‫‪X=1‬‬
‫‪F=β‬‬ ‫‪ε‬‬ ‫‪0‬‬ ‫‪γ‬‬ ‫‪0‬‬
‫‪y1‬‬ ‫‪y2‬‬ ‫‪R‬‬ ‫’‪Q‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬
‫‪Y1‬‬ ‫‪Y2‬‬ ‫‪Z‬‬ ‫‪Y1‬‬ ‫‪Y2‬‬ ‫‪Z‬‬ ‫‪R‬‬
‫‪BD = γ‬‬ ‫‪δ‬‬ ‫‪0‬‬ ‫‪α‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪-‬‬
‫‪CG = δ‬‬ ‫‪γ‬‬ ‫‪0‬‬ ‫‪δ‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪:D-latch / Transparent Latch‬‬
‫‪E=ε‬‬ ‫‪β‬‬ ‫‪1‬‬ ‫‪γ‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪G‬‬ ‫‪S‬‬ ‫‪Q‬‬ ‫טבלת עירור‬
‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬
‫‪D‬‬ ‫‪G‬‬ ‫)‪Q(t+1‬‬
‫‪ – PS‬המצב הנוכחי )‪.(Present State‬‬
‫מכונות איזומורפיות‬ ‫‪ – NS‬המצב הבא )‪.(Next State‬‬ ‫‪R‬‬ ‫’‪Q‬‬
‫‪0‬‬ ‫‪Q‬‬
‫‪1‬‬ ‫‪D‬‬
‫מכונות שקולות ‪ /‬איזומורפיות‪:‬‬ ‫‪ – X‬הוא הכניסה למערכת‪.‬‬
‫מכונות הן איזומרפיות ‪ /‬שקולות אמ"מ עבור אותו קלט מקבלים את אותו‬ ‫‪ – Z‬נקבע לפי ה‪.PS -‬‬
‫הפלט‪ ,‬בשתי המכונות‪.‬‬ ‫טבלת מצבים‪:‬‬ ‫‪.5‬‬ ‫‪:Edge Triggered D Flip-Flop‬‬
‫לכל מצב של המערכת נותנים שם )אות(‪.‬‬ ‫‪Master‬‬ ‫‪Slave‬‬
‫ניתן להשוות בין ‪ 2‬מכונות רק במצב סטנדרטי ‪ /‬קנוני‪.‬‬ ‫‪PS‬‬ ‫‪NS‬‬ ‫‪Data‬‬ ‫‪D‬‬ ‫‪Q‬‬ ‫‪D‬‬ ‫‪Q‬‬ ‫‪D‬‬ ‫‪Q‬‬
‫‪X=0‬‬ ‫‪Z‬‬ ‫‪X=1‬‬ ‫‪Z‬‬ ‫=‬
‫צורה סטנדרטית ‪ /‬קנונית‪:‬‬ ‫‪A‬‬ ‫‪B‬‬ ‫‪0‬‬ ‫‪A‬‬ ‫‪1‬‬ ‫‪clk‬‬ ‫‪G‬‬ ‫’‪Q‬‬ ‫‪G‬‬ ‫’‪Q‬‬ ‫’‪clk Q‬‬
‫‪B‬‬ ‫‪D‬‬ ‫‪0‬‬ ‫‪C‬‬ ‫‪0‬‬
‫שמות המצבים יקבעו לפי סדר הופעתם משמאל לימין ומלמעלה למטה‪.‬‬
‫‪C‬‬ ‫‪B‬‬ ‫‪0‬‬ ‫‪A‬‬ ‫‪0‬‬
‫‪NS‬‬ ‫‪NS‬‬
‫‪PS‬‬ ‫‪PS‬‬ ‫‪D‬‬ ‫‪D‬‬ ‫‪1‬‬ ‫‪C‬‬ ‫‪0‬‬
‫‪X=0‬‬ ‫‪X=1‬‬ ‫‪X=0‬‬ ‫‪X=1‬‬ ‫מה שנכנס לכניסה ‪" D‬ייזכר" ע"י הרכיב ברגע שהשעור יעבור מצב‪.‬‬ ‫‪-‬‬
‫דיאגרמת מצבים‪:‬‬ ‫‪.6‬‬ ‫שינוי מצב מתאפשר רק כאשר כניסת השעון משתנה מ‪ 0 -‬ל‪.1 -‬‬
‫‪α‬‬ ‫‪ε‬‬ ‫‪0‬‬ ‫‪δ‬‬ ‫‪0‬‬ ‫‪α=A‬‬ ‫‪B‬‬ ‫‪0‬‬ ‫‪C‬‬ ‫‪0‬‬ ‫‪X/Z‬‬ ‫‪-‬‬
‫‪0/0‬‬
‫‪β‬‬ ‫‪ε‬‬ ‫‪0‬‬ ‫‪γ‬‬ ‫‪0‬‬ ‫‪ε=B‬‬ ‫‪D‬‬ ‫‪1‬‬ ‫‪E‬‬ ‫‪0‬‬ ‫‪0/0‬‬ ‫יש רכיבים שבהם שינוי מצב מתאפשר רק כאשר כניסת השעון‬ ‫‪-‬‬
‫‪γ‬‬ ‫‪δ‬‬ ‫‪0‬‬ ‫‪α‬‬ ‫‪0‬‬ ‫‪δ=C‬‬ ‫‪E‬‬ ‫‪0‬‬ ‫‪C‬‬ ‫‪0‬‬ ‫‪1/1‬‬ ‫‪B‬‬ ‫‪0/1‬‬ ‫משתנה מ‪ 1 -‬ל‪.0 -‬‬
‫‪δ‬‬ ‫‪γ‬‬ ‫‪0‬‬ ‫‪δ‬‬ ‫‪0‬‬ ‫‪β=D‬‬ ‫‪B‬‬ ‫‪0‬‬ ‫‪E‬‬ ‫‪0‬‬ ‫כל עוד כניסת השעון נשארת קבועה – הרכיב "זוכר" את המצב הקיים‪.‬‬ ‫‪-‬‬
‫‪ε‬‬ ‫‪β‬‬ ‫‪1‬‬ ‫‪γ‬‬ ‫‪0‬‬ ‫‪γ=E‬‬ ‫‪C‬‬ ‫‪0‬‬ ‫‪A‬‬ ‫‪0‬‬ ‫‪A‬‬ ‫‪1/0‬‬ ‫‪0/0‬‬ ‫‪D‬‬ ‫תנאי לפעולה תקינה – זמן ההתפשטות בשער ‪ NOT‬קצר מזמן‬ ‫‪-‬‬
‫ההתפשטות ב‪ .Master -‬כלומר‪ ,‬ה‪ Slave -‬ינעל לפני שיציאת ה‪-‬‬
‫מכונה קשורה היטב‪:‬‬ ‫‪C‬‬ ‫‪ Master‬משתנה‪.‬‬
‫מכונה שבה לכל זוג מצבים ‪ A, B‬קיימת סדרת כניסה המעבירה ממצב ‪A‬‬ ‫‪1/0‬‬ ‫‪1/0‬‬
‫למצב ‪.B‬‬
‫מוצאים מה עושה המערכת ע"י הצבת מספר סדרות כניסה‪.‬‬ ‫‪.7‬‬
‫מאפייני תזמון של ‪:FF‬‬
‫‪ :TPC-Q‬זמן התפשטות‪ .‬מרגע השפה הפעילה של השעון )שינוי מצב‬ ‫‪-‬‬
‫בשעון( ועד שמוצא הרכיב מתייצב עם התוכן החדש‪.‬‬
‫סינתזה )תכנון( של מערכות עקיבה סינכרוניות‬ ‫‪ :TCC-Q‬הזמן מרגע השפה הפעילה של השעון‪ ,‬בו עדיין מובטח‬ ‫‪-‬‬
‫הגדרת מצבים‪.‬‬ ‫‪.1‬‬ ‫שמוצא הרכיב יציב בערכו הקודם‪.‬‬
‫דיאגרמת מצבים‪.‬‬ ‫‪.2‬‬
‫טבלת מצבים‪.‬‬ ‫‪.3‬‬ ‫‪TPC-Q > TCC-Q‬‬
‫עד זמן זה בטוח לא אחרי שעבר זמן זה‬
‫טבלת מעברים‪.‬‬ ‫‪.4‬‬ ‫קרה דבר לתוכן‪.‬‬
‫בטוח שהתוכן התייצב‪.‬‬
‫טבלת עירור למימוש בעזרת ‪ FF‬מסוים )לפי טב' המעברים הנ"ל(‪.‬‬ ‫‪.5‬‬
‫‪PS‬‬ ‫‪NS‬‬ ‫‪ .(Setup Time) – TS‬הכניסה ‪ D‬חייבת להיות יציבה לפחות ‪ TS‬לפני‬ ‫‪-‬‬
‫‪X=0‬‬ ‫‪X=1‬‬ ‫השפה הפעילה של השעון‪.‬‬
‫‪y1‬‬ ‫‪y2‬‬
‫‪J1 K1 J2 K2‬‬ ‫‪Z‬‬ ‫‪J1 K1 J2 K2‬‬ ‫‪Z‬‬ ‫‪ .(Hold Time) – TH‬הכניסה ‪ D‬חייבת להשאר בערכה החוקי לפחות‬ ‫‪-‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0 d 1 d‬‬ ‫‪0‬‬ ‫‪0 d 0 d‬‬ ‫‪1‬‬ ‫‪ TH‬אחרי השפה הפעילה‪.‬‬
‫‪0‬‬ ‫‪1‬‬ ‫‪1 d d 0‬‬ ‫‪0‬‬ ‫‪1 d d 1‬‬ ‫‪0‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪d 1 1 d‬‬ ‫‪0‬‬ ‫‪d 1 0 d‬‬ ‫‪0‬‬ ‫הערות‪:‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪d 0 d 0‬‬ ‫‪1‬‬ ‫‪d 0 d 1‬‬ ‫‪0‬‬ ‫‪ TS‬ו‪ TH -‬הן דרישות שהיצרן מגדיר‪.‬‬ ‫‪-‬‬
‫מפות קרנו ל‪ FF -‬ולמוצא ‪.Z‬‬ ‫‪.6‬‬ ‫‪ TS‬ו‪ TH -‬קטנים בהשוואה להשהיות אחרות‪.‬‬ ‫‪-‬‬
‫רישום משוואות העירור והתפוקה‪.‬‬ ‫‪.7‬‬ ‫בד"כ נדרוש‪.TCC-Q > TH :‬‬ ‫‪-‬‬