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

מערכת סגורה בעלת שני רכיבים היא יציבה. זאת לעומת מערכת בעלת 3 רכיבים שמשנה את ערכה כל כמה זמן.
לכן, מערכת בעלת 2 רכיבים היא רכיב זיכרון אשר מאפשרת לנו לשמור בה ערכים.
​
אך איך נוכל להכניס אליה ערכים? נשתמש בטריק מגניב: נהפוך את שעך ה-$NOT$ שלנו לשער $NOR$ כאשר כניסה אחת שלו היא $0$.
​
כעת, אם נשנה את הערך $0$ בכל אחד מהם נוכל לשנות את הערך בתוך רכיב הזכרון שלנו. איזה יופי, אה?
נתן לרגליים שמות: $S$ לרגל השמאלית ו-$R$ לרגל הימנית. למה? כי הכנסת 1 ל-$S$ משנה את הערך ל-$1$ והכנסת $1$ ל-$R$ עושה $Reset$ לזכרון.
​
לרכיב הזה קוראים:

נראה כיצד הוא עובד:

בעצם הכנסת $0,0$ מאפשרת שמירה של הערך הקודם שנכנס.
האם אנו באמצת צריכים להכניס את ה-$1,1$ הזה? לא ממש כי כבר יש לנו אפס - אבל באמת איכפת לנו שיהיה אותו? כן! זאת מכיוון ש-(1) קשה להוריד בדיוק באותו זמן את הערך בשני חוטים שונים ובנוסף, גם אם הצלחנו אז (2) אנו לא יודעים אילו מהרכיבים מהיר יותר ואז אחד מהם יתעדכן קודם ונקבל את אחד המצבים האחרים שזה לא מה שאנו רוצים.
לכן, הכנסת $1,1$ ל-$SR\,Latch$ היא פעולה לא חוקית.

עדיין יש לנו בעיה. אם נניח לאחד החוטים לוקח יותר זמן להתעדכן מהשני או שיש איזה עיכוב או משהו כזה, התוצאה תצא לא נכונה, שכן העדכון הוא מיידי. נרצה דרך להחליט מתי הרכיב שלנו יוכל לקבל מידע נוסף ומתי הוא יוכל להתעדכן. לכניסה חדשה זו נקרא $Gate$ והיא תחליט מתי ה-$Latch$ שלנו יתעדכן:

​

נוצרה לנו כעת בעיה חדשה - אנו נדרשים להכניס שלושה חוטים כדי לשמור על ערך אחד. כדי לפתור זאת, נחבר את $S$ ו-$R$ ע"י שער $NOT$ ונקרא לרגל הזאת $D$. נקבל:

​

דְּלַגְלַג (Flip Flop)

יש לנו בעיה, היא מאוד דומה לבעיה שבגללה הוספנו את רגל ה-$G$. הבעיה הינה שכל עוד $G=1$ המערכת שלנו יכולה להשתנות. אנו רוצים שברגע מסויים היא תשתנה ולא תשתנה עוד. לשם כך נוסיף יצור בשם $Clock$ אשר ברגע שהוא עולה מ-$0$ ל-$1$ הוא משנה את המצב פעם אחת ותו לא.

אנחנו נבנה רכיב $flip-flop$ עם שני רכיבי $D-Latch$ אשר ישמשו כמעין כספת עם שני מנעולים.
לפני שהשעון יהפוך ל-$1$ הרכיב הראשון ידגום את הקלט, וברגע שהוא יהפוך ל-$1$ הרכיב הראשון ינעל והשני יפתח ואז מה שאנו רוצים לשמור יעבור מהראשון לשני. אחרי זה, הרכיב השני ינעל מחדש והראשון יפתח מחדש כדי לקלוט עוד מידע לצורכינו.
כך זה יראה:
​
נסמן אותו כך:
​

הרכיב הזה דורש זמן כדי לעבוד. אנו נדרשים לזמן טעינה $t_{SU}$ אשר מאפשר ל-$Latch$ הראשון לקבל את הערך הרצוי ובנוסף נדרש גם לזמן החזקה - $t_{H}$ אשר מאפשר לערך להינעל לפני שאנו פותחים את השער מחדש.
​

נעילת Flip Flop

ניתן להוסיף רגל נוספת אשר תאפשר לנו לנעול את הזכרון שלנו. את רגל זו נוסיף באמצעות בוחר שכזה והיא תראה כך:
​

קישורים של Flip Flop-ים

​
לפני עליית השעון:

• בכניסה $in$ ישנו ערך $a$.
• ה-$DFF$ השמאלי שומר את הערך $b$ וה-$DFF$ הימני שומר את הערך $c$.

לאחר עליית השעון:

• ה-$DFF$ השמאלי קיבל ושומר את $a$.
• ה-$DFF$ הימני קיבל ושומר את $b$.
• הערך $c$ לא נשמר יותר

סוגים של מעגלים

ניתן להסתכל כעת על שני סוגים שונים של מעגלים:

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

אוגר - $Register$

ה-$Flip\; Flop$ שראינו מאפשר לנו לבנות רגיסטרים המאפשרים כתיבה או קריאה בו זמנית של מספר סיביות.
רגיסטר אשר שומר על ביט אחד הוא פשוט מעגל $Flip\; Flop$ והוא נראה כך:
​
כאשר נרצה לשמור מילים של $32$ ביטים זה יהיה חיבור של $32$ מעגלים כאלו אשר להם יהיו להם כניסות ויציאות שונות חוץ מכניסת ה- וכניסת ה- אשר יהיו זהות לכל המעגלים.
כעת, לאחר שבנינו רגיסטר שיכול לשמור $32$ ביטים, נבנה מערכת זכרון של מחשב עם $32$ רגיסטרים:
​
במערכת זו יש לנו מפענח אחד המאפשר לכתוב, שני בוררים אשר בעזרתם אנו בחורים מאיזה 2 רגיסטרים לקרוא.
למה אנו קוראים מ-2 רגיסטרים בו זמנית? כדי לאפשר לנו לבצע פקודות כמו add אשר לוקחות ערכים משני רגיסטרים. אנו נטען את הערכים הללו באותו הזמן ואז נחזיר אותם לרגיסטר שלישי באמצות כתיבה אליו.

איך כותבים דבר כזה בשפת תיאור חומרה?

module registerfile (Read1,Read2,WriteReg,WriteData,RegWrite,Data1,Data2,clock);
	input logic [4:0] Read1,Read2,WriteReg; // reg numbers to read or write
	input logic [31:0] WriteData; // data to write 
	input logic RegWrite, // the write control 
		clock; // the clock to trigger write
	output logic [31:0] Data1,Data2; // the register values read
	logic [31:0] RF [31:0]; // 32 registers each 32 bits long
	assign Data1 = RF[Read1]; // 32->1 selector x 32 (asynchronous)
	assign Data2 = RF[Read2]; // 32->1 selector x 32
	
	always_ff begin 
		// write the register with new value if Regwrite is high
		@(posedge clock) if (RegWrite) RF[WriteReg] <= WriteData; // Decoder(synch)
	end 
endmodule