חזור לתיקייה: תרגול

6 - רכיבי זכרון

חיפוש בתיקיה
Ctrl K
לחץ כאן או הקש Ctrl K כדי לחפש בכל התיקיה
  • רכיבי זכרון
  • אילוצי זמנים
  • חיבור בטור
  • תרגול
  • שיטה לזכור

6 - רכיבי זכרון

00440252

מערכות ספרתיות ומבנה המחשב

רשימות תרגול לקריאה בשבת

רכיבי זכרון

הופק מתוך תקיית התואר של שקד

uni-folder.vercel.app

אם המחשב היה כולו מעגל צירופי אחד גדול, היינו צריכים לחכות נצח בין פעולה לפעולה.
אנו רוצים לחלק לפעולות קטנות שיקרו אחת אחרי השנייה, כמו פס ייצור, בשביל זה צריך לבנות D−FFD-FFD−FF.

רכיבי זכרון

אנו נחזור לבסיס ביותר. זהו SR−LatchSR-LatchSR−Latch.
​ספרתיות הרצאה 5 - 4.png
הוא מורכב משני שערי NORNORNOR והוא מאפשר 444 פעולות:

  1. הכנסת S=1,R=0S=1,R=0S=1,R=0 היא פעולת SETSETSET אשר משימה את QQQ ל-111 אשר נשמר במערכת.
  2. הכנסת S=0,R=1S=0,R=1S=0,R=1 היא פעולת RESETRESETRESET אשר משימה את QQQ ל-000 אשר נשמר במערכת.
  3. הכנסת S=0,R=0S=0,R=0S=0,R=0 היא פעולת שמירה אשר פשוט שומרת את הערך הקודם שהוכנס.
  4. הכנסת S=1,R=1S=1,R=1S=1,R=1 יצור מצב שהוא לא נכון לוגית ולכן לא עושים את זה.

כדי למנוע מצב אסור אנו נרצה למנוע מצב בו שניהם 000. לשם כך, נוכל להוסיף שער NOTNOTNOT אשר דואג ששניהם לא יכולים להיות 111 באותו הזמן ושערי ANDANDAND אשר דואגים שנוכל להכניס 0,00,00,0.
​ספרתיות הרצאה 5 - 6.png

נסתכל כעת על מצב בו יש לנו שני D−LatchD-LatchD−Latchים המחוברים אחד לשני - הלוגיקה לפני הראשון פשוטה והלוגיקה אחרי השני מאוד מורכבת ולוקחת זמן.
אז החישוב של הראשון מסתיים מהר מאוד ורכיב הזכרון יתעדן מה שיגרום לכך שרכיב הזכרון השני יתעדכן לפני שלוגיקה בו תוכל לסיים לפעול ובכך, לא נקבל את הערך של החישוב המסובך שכן הערך החדש יהרוס אותו.

לשם כך נשתמש בשעון שהוא פשוט חוט אשר משתנה במחזור קבוע והוא מחובר ל-GGG-ים. על מנת שנוכל לשמור מידע מבלי לדאוג לזמנים יותר מדי, נשתמש בשני LatchLatchLatch-ים כאלו מחוברים אחד אחרי השני כך שהחלק הצירופי נמצא לפניהם כך:
​ספרתיות הרצאה 5 - 7.png

זה בדיוק D−FFD-FFD−FF שהוא רכיב הזכרון הבסיסי. עקרון הפעולה שלו הינו:
​ספרתיות תרגול 6 - 1.png

QQQ זוכר תמיד מה היה קודם ב-DDD.

אילוצי זמנים

הערה (תזכורת - tcd,tpdt_{cd},t_{pd}tcd​,tpd​)

tcdt_{cd}tcd​ אומר הכניסה השתנתה אך המוצא עוד לא התחיל להשתנות(כמה זמן יקח לו להתחיל להשתנות)
tpdt_{pd}tpd​ הוא הזמן מהשינוי בכניסה עד שהיציאה מתייצבת(לא מדוייק ב-100%100\%100% אבל מספיק טוב לקורס)

הגדרה 1 (tsetupt_{setup}tsetup​)

משך הזמן לפני עלית השעון שבו המידע חייב להיות יציב יקרא tsetupt_{setup}tsetup​.

setupsetupsetup תמיד הולך עם tpdt_{pd}tpd​ שכן זה הזמן בו אנו רוצים שהכל יתייצב.

הגדרה 2 (tholdt_{hold}thold​)

משך הזמן לאחר עליית השעון שבו המידע חייב להמשיך להיות יציב יקרא tholdt_{hold}thold​

holdholdhold תמיד הולך עם tcdt_{cd}tcd​ שכן זה הזמן עד שבו דברים מתחילים להשתנות.

הערה

אם לא נקפיד על הדברים האלו, התנהגות המערכת תהא בלתי צפוייה.
למה? כי גם בתוך ה-D−FFD-FFD−FF יש זמני tpd,tcdt_{pd},t_{cd}tpd​,tcd​ שלוקח לדברים להשתנות ולהתעדכן.
אם במיידי בירידת שעון נשנה את ה-DataDataData יכול להיות שה-DataDataData החדשה תשמר במקום הישנה.

​ספרתיות תרגול 6 - 2.png
המצב שאנו יכולים לראות פה קורה לאור מה שדיברנו עליו קודם בהערה, והוא הסיבה מדוע אסור לנו לשנות את הערך DDD עם עליית/ירידת השעון.

נשים לב כי גם ל-DFFDFFDFF יש tcdt_{cd}tcd​ ו-tpdt_{pd}tpd​ רק שב-DFFDFFDFF קוראים ל-tpdt_{pd}tpd​ בשם המפוצץ tpc−qt_{pc-q}tpc−q​.

חיבור בטור

משפט (תנאי הכרחי לחיבור בטור)

אם אין לוגיקה צירופית בין הדלגדגים:

tcd(FF1)≥thold(FF2)t_{cd}(FF1)\geq t_{hold}(FF2)tcd​(FF1)≥thold​(FF2)

אם יש לוגיקה צירופית בין הדלגדגים:

tcd(FF1)+tcd(logic)≥thold(FF2)t_{cd}(FF1)+t_{cd}(logic)\geq t_{hold}(FF2)tcd​(FF1)+tcd​(logic)≥thold​(FF2)
משפט (תנאי הכרחי 2 לחיבור בטור)

אם אין לוגיקה צירופית בין הדלגדגים:

tpd(FF1)+tsetup(FF2)<tclockt_{pd}(FF1)+t_{setup}(FF2)< t_{clock}tpd​(FF1)+tsetup​(FF2)<tclock​

אם יש לוגיקה צירופית בין הדלגדגים:

tpd(FF1)+tpd(logic)+tsetup(FF2)<tclockt_{pd}(FF1)+t_{pd}(logic)+t_{setup}(FF2)< t_{clock}tpd​(FF1)+tpd​(logic)+tsetup​(FF2)<tclock​
הערה (שימוש נפוץ ב-DFFDFFDFF הוא מחלק תדר)

מחלק תדר לוקח תדר מסויים ונותן לו מחזור של שני מחזורי שעון ובכך מחלקים את התדר.
​ספרתיות תרגול 6 - 3.png

תרגול

תרגיל

​תרגול ספרתיות 6 - תרגילים 1.png
נתונים:

tpd(XOR)=10tpdC−Q(FF)=15tsetup(FF)=5tcd(XOR)=1tcdC−Q(FF)=2\begin{matrix} t_{pd}(XOR)=10 & t_{pdC-Q}(FF)=15 & t_{setup}(FF)=5 \\ t_{cd}(XOR)=1 & t_{cdC-Q}(FF)=2 \end{matrix}tpd​(XOR)=10tcd​(XOR)=1​tpdC−Q​(FF)=15tcdC−Q​(FF)=2​tsetup​(FF)=5

א. מהו זמן המחזור המינימלי?
ב. מהו ה-tholdt_{hold}thold​ המקסימלי שיאפשר עבודה תקינה של המעגל?

פתרון א':
יש לנו פה שני מסלולים, מכיוון שהם סימטריים נוכל לחשב רק את המקרה הגרוע באחד מהם, אך אם הם לא היו, אז היינו צריכים לבדוק את שניהם.

tpdC−Q(FF)+tpd(XOR)+tsetup(FF)≤tclockt_{pdC-Q}(FF)+t_{pd}(XOR)+t_{setup}(FF)\leq t_{clock}tpdC−Q​(FF)+tpd​(XOR)+tsetup​(FF)≤tclock​ 30=15+10+5≤tclock30=15+10+5\leq t_{clock}30=15+10+5≤tclock​

לכן, tclockmin⁡=30t_{clock_{\min}}=30tclockmin​​=30.

פתרון ב':

tcdC−Q(FF)+tcd(XOR)≥tholdt_{cdC-Q}(FF)+t_{cd}(XOR)\geq t_{hold}tcdC−Q​(FF)+tcd​(XOR)≥thold​ thold≤2+1=3t_{hold}\leq 2+1=3thold​≤2+1=3

לכן, tholdmax⁡=3t_{hold_{\max}}=3tholdmax​​=3.

תרגיל

​תרגול ספרתיות 6 - תרגילים 2.png

tcdtpd/CQtsetuptholdAND610NOT68FF5102010\begin{array}{|c|cccc|} \hline & t_{cd} & t_{pd/CQ} & t_{setup} & t_{hold} \\ \hline AND & 6 & 10 \\ NOT & 6 & 8 \\ FF & 5 & 10 & 20 & 10 \\ \hline \end{array}ANDNOTFF​tcd​665​tpd/CQ​10810​tsetup​20​thold​10​​

חשבו את:

thold_newtsetup_newtpd_newt_{hold\_{new}} \qquad t_{setup\_new} \qquad t_{pd\_new}thold_new​tsetup_new​tpd_new​

נתחיל מהקל: tpd_newt_{pd\_new}tpd_new​.
ברגע שיש לנו flopflopflop הדבר הזה יעבוד כמו flopflopflop. אם יש לנו כניסה, כבר דאגו שהיא תהיה יציבה ותעבוד עם הזמן holdholdhold ולכן ה-tpdt_{pd}tpd​ החדש יהיה:

tpd_new=tpd(NOT)+tpdC−Q(FF)=18t_{pd\_new}=t_{pd}(NOT)+t_{pdC-Q}(FF)=18tpd_new​=tpd​(NOT)+tpdC−Q​(FF)=18

כעת נחשב את tsetup_newt_{setup\_new}tsetup_new​. החלק שבפועל דוגם הוא ה-FFFFFF ונדרש ש-setupsetupsetup לפני עליית שעון היציאה של ה-ANDANDAND תהיה יציבה.

tsetup_new=tsetup(FF)+tpd(AND)=30t_{setup\_new}=t_{setup}(FF)+t_{pd}(AND)=30tsetup_new​=tsetup​(FF)+tpd​(AND)=30

לבסוף, נחשב את thold_newt_{hold\_new}thold_new​. כעת, יש לנו דילי מובנה בכניסה לאור ה-ANDANDAND ולכן זמן ה-holdholdhold יכול להיות קטן יותר.

thold_new=thold(FF)−tcd(AND)=4t_{hold\_new}=t_{hold}(FF)-t_{cd}(AND)=4thold_new​=thold​(FF)−tcd​(AND)=4
תרגיל

​תרגול ספרתיות 6 - תרגילים 4.png
נתון כי:

tpdtsetupFFO12FF1/FF222A/B/C1\begin{array}{|c|cc|} \hline & t_{pd} & t_{setup} \\ \hline FFO & 1 & 2 \\ FF1/FF2 & 2 & 2 \\ A/B/C & 1 \\ \hline \end{array}FFOFF1/FF2A/B/C​tpd​121​tsetup​22​​

חשבו את TminT_{min}Tmin​ בהנחה שתנאי holdholdhold מתקיים והכניסות מקיימות תנאי holdholdhold ו-setupsetupsetup.

כל מה שעשינו עכשיו בזה שהוספנו את ה-FFFFFF-ים למערכת הצירופית הזו הוא שיצרנו שלבים למערכת הזו אשר יכולים להתעדכן אחד אחרי השני.
ניתן לחשוב על FFFFFF-ים מחיצות ולכן לא צריך לחשב את כל המסלול הארוך, שכן כבר ברגע שהערך הקודם הגיע ל-FFFFFF הבא ניתן להכניס ערך חדש.

לכן, נדרש לחשב את התנאים לכל מקטע ונקח את ההכי גרוע שכן הוא יכתיב את הקצב של המערכת.
FF0→FF1FF0\to FF1FF0→FF1:

T≥tpC−Q(FF0)+tpd(B)+tsetup(FF1)=4T\geq t_{pC-Q}(FF0)+t_{pd}(B)+t_{setup}(FF1)=4T≥tpC−Q​(FF0)+tpd​(B)+tsetup​(FF1)=4

FF1→FF2FF1\to FF2FF1→FF2:

T≥tpC−Q(FF1)+tpd(C)+tsetup(FF2)=5T\geq t_{pC-Q}(FF1)+t_{pd}(C)+t_{setup}(FF2)=5T≥tpC−Q​(FF1)+tpd​(C)+tsetup​(FF2)=5

FF2→FF0FF2\to FF0FF2→FF0:

T≥tpC−Q(FF2)+tpd(A)+tsetup(FF0)=5T\geq t_{pC-Q}(FF2)+t_{pd}(A)+t_{setup}(FF0)=5T≥tpC−Q​(FF2)+tpd​(A)+tsetup​(FF0)=5

לכן, Tmin=5T_{min}=5Tmin​=5.

שיטה לזכור

ציירו את הציור הבא:
​6 - רכיבי זכרון 2026-06-15 10.11.40.excalidraw.svg
ואז נסביר במילים ונקבל:

tsetup(FF2)+tpd(FF1)+tpd(CL)≤T+tskewt_{setup}(FF_{2})+t_{pd}(FF1)+t_{pd}(CL)\leq T+t_{skew}tsetup​(FF2​)+tpd​(FF1)+tpd​(CL)≤T+tskew​ tskew+thold≤tcd(FF1)+tcd(CL)t_{skew}+t_{hold}\leq t_{cd}(FF1)+t_{cd}(CL)tskew​+thold​≤tcd​(FF1)+tcd​(CL)