שער לוגי הוא התקן המממש פונקציית מיתוג. הוא אלקטרוני(ליטרלי חומרה)
ניתן לתאר באמצעות ציור, טבלת אמת, ביטוי מיתוג ושפות תיאור חומרה(שאותם נראה בסדנה)

שער	בינוי מיתוג	סמליל
שער $AND$	$t=a\cdot b$	​
שער $OR$	$t=a+b+c$	​
שער $NAND$	$t=\overline{a\cdot b\cdot c}$	​
שער $NOR$	$t=\overline{a+b}$	​
שער $XOR$	$t=a \oplus b$	​
שער $NOT$	$t=\overline{a}$	​

module and_gate(
	input logic a,
	input logic b,
	output logic out
);
	assign out = a & b;
endmodule

המעגל קרוי צירופי כי יציאותיו תלויות אך ורק בצירוף הערכים בכניסותיו.

​

רכיבי החלפות

בורר - Selector/multiplexer/$mux$

קלט:

• $m$ כניסות בקרה המסומנות $S_{0},\dots,S_{m-1}$
• $n=2^m$ כניסות נתונים המסומנות $D_{0},\dots,D_{n-1}$
• $E$ כניסת הפעלה($enable$)

פלט:

• אם $E=0$ אז $0$
• אחרת, הסיבית $D_{i}$ כאשר $i$ הוא המספר שיצוגו הבינארי מופיע ב-$m$ סיביות הבקרה.

​

נבחן את פונקציית הבורר:

• לא ניתן לממש $NOT$ ולכן הבורר הוא אינו מערכת שלמה $z(x,x,x)=xx+\overline{x}x=x$.
  ניתן לממש $NOT$ עם קבועים(1 ו-0)
• ננסה לממש $XOR$ כך $z=A\overline{B}+\overline{A}B=A \oplus B$:
  $D_{1}=\overline{B} \qquad D_{0}=B \qquad S=A$
  זהו בדיוק מימוש מתאים לכך.
• ננסה לממש $AND$ כך $z=AB$: לא נוכל לממש $AND$ לבד ונדרש להוסיף את הקבוע $0$

מימוש פונקציות באמצעות בוררים

נניח יש לנו את הפונקציה הבאה: $f(w,x,t,z)=\sum(3,4,9,12,13,14)$ אזי נוכל לקחת בורר עם $16$ כניסות ולקבל:
​
בנוסף, ניתן לממש את אותה הפונקציה עם בורר קטן יותר של $8$ ל-$1$ כך:
​

סיבוכיות הבורר

בורר בעל $n+1$ כניסות בקרה ו-$K=2^n$ כניסות נתונים מכיל:

• $2(n+1)$ מהפכים
• $2^n$ שערי $AND$ בעלי $n+2$ כניסות כ"א וביחד $2^n(n+1)$ שערים
• שער $OR$ בעל $2^n$ כניסות השקול ל-$2^n-1$ שערים בעלי שתי כניסות

סה"כ מחירו של הבורר הוא $O(K\log_{2}K)$ שערים.

מפענח - $Decoder$

קלט:

• $m$ כניסות בקרה $d_{0},\dots,d_{m-1}$
• כניסת הפעלה - $E$

פלט:

• יציאות $n\leq 2^m$ המסומנות $f_{0},\dots,f_{n-1}$.

אם $E=0$ מתקיים $\forall i \in \mathbb{N}:\; f_{i}=0$
אם $E=1$ אזי קיים $i$ שהוא המספר הבינרי המיוצג ע"י כניסות הבקרה ואז $f_{i}=1$ ולכל $i$ אחר מתקיים $f_{i}=0$.

​
מימוש מפענח:
​

$Demultiplexer$

זוהי הרחבה של המפענח בו אנו במקום $E$ מקבלים $Data\; in$ ובאותו האופן כמו במפענח, המוצא בעל הקוד $m$ מקבל את ערך הכניסה $Data\; in$.

בעצם מפענח הוא $Demultiplexer$ כאשר $E$ הוא בעצם כניסת המידע $D$.

העברת מידע באמצעות בורר למפענח

בורר ומפענח מבצעים פעולות הפוכות. אנו נשתמש בכניסת ה-$E$ של המפענח ככניסת המידע($Demultiplexer$)
המידע מן המסוף שנבחר יגיע למחשב המתאים אם הכתובות המוזנות לבורר ולמפענח הן תאומות.
​

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

מפענח בעל $n+1$ כניסות ו-$K=2^n$ יציאות מכיל:

• $2(n+1)$ מהפכים
• $2^n$ שערי $AND$ בעלי $n+1$ כניסות כ"א וביחד $2^nn$ שערים.

סה"כ מחירו של המפענח הוא $O(K\log_{2}K)$

מתגים

מתג מנתק ומחבר את היציאה.
ליציאה 3 ערכים אפשריים: $0,1,Z$ כאשר $Z$ נקרא גם $3-state$ או "צפה"
המתג מאפשר לחבר מספר יציאות לחוט יחיד הנקרא $BUS$.
חובה לדאוג שלכל היותר רק אחד מקווי ה-$E$ יקבל את הערך 1.

המפענח חיוני למימוש ה-$BUS$ שכן הוא זה שדואג לכך שרק אחד מקווי ה-$E$ יקבל את הערך $1$.
​

מקודד - $Encoder$

קלט:

• $n$ כניסות המסומנות $F_{0},\dots,F_{n-1}$
• כניסת הפעלה - $E$

פלט:

• $m=\log n$ יציאות.

היציאה היא הקוד הבינארי של הכניסה היחידה שהיא 1.
​

הפשטה הספרתית - ממתח רציף לערכים בדידים

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

על מנת שנוכל להתמודד עם קצת הפרעות בזרם וזרם לא הכי יציב נחליט להגדיר כמה תחומים שיוכלו לייצג לנו $0$ ו-$1$. נניח כאשר יש לנו אפשרויות למתח מ-$0$ עד $5$ נחליט את הסקלה הבאה:
​
כאשר הכחול והירוק נותנים $1$ מצד ימין ו-$0$ מצד שמאל והאדום אסור!

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

בכניסה וביציאה משערים לוגיים האותות עוברים בתחום האסור במשך זמן סופי $0<$.
כלומר, נדרש "לעצום את העיניים" ולהתעלם מהיציאה. משך הזמן הוא כתלות במודל.

זמני שהייה

• $t_{cd}$ - משך הזמן בו מובטח שיציאת רכיב לא תספיק להגיב לשינוי בכניסתו.
  כדי למצוא אותו נמדוד מהמועד בו הכניסה "עזבה" את ערכה הלוגי הקודם, שכן עד אז אין כל עילה להשתנות היציאה עד הרגע בו המתח ביציאה חורג מהתחום החוקי עבור ערך היציאה הישן.
• $t_{pd}$ - משך הזמן שאחריו מובטח שהיציאה תשקף את השינוי בערך הכניסה.
  כדי למצוא אותו נמדוד מהמועד בו הכניסה "הגיעה" לערכה הלוגי החדש שכן עד אז אין כל מחיובות לשינוי היציאה עד הרגע בו המתח ביציאה נכנס לתחום החוקי עבור ערך היציאה החדש.

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

מודלים חלופיים "נוחים" לתזמון

​

סיכום מדדי זמן

מדדים והגדרות

• זמן זיהום המוצא, $t_{CD}$ (Contamination Delay)
• זמן התפשטות או שיהוי, $t_{PD}$ (Propagation Delay)
• זמן עליית האות, $t_{RISE}$ (אינו מצטבר)
• וזמן ירידתו, $t_{FALL}$ (אינו מצטבר)

​

תופעות מעבר (Hazards)

בזמן שבו האות משתנה יתכן ויעבור ממצבו ההתחלתי לסופי דרך ערכי ביניים:

• האזארד סטטי (מתייצבים על ערך ישן), למשל 0-1-0
• האזארד דינמי (מתייצבים על ערך חדש), למשל 0-1-0-1

הבהוב סטטי

נניח שהתבקשנו לתכנן מעגל שיממש את הפונקציה $f(y_{1},y_{2},y_{3})=\sum(3,4,5,7)$

​
נבחן מעבר כניסות מ-$111$ ל-$101$:
​
למה שער $d$ שאמור להישאר ב-$1$ ירד ל-$0$? רוב הרכיבים עובדים על שינוי רמה לוגית ולא על המתח שמגיע.
זה אופייני למעבר(במפת קרנו) מגורר אחד לגורר אחר והוא נגרם ע"י הבדלים בזמני ההתפשטות ברכיבים שונים.
זה למה חשוב מאוד להסתכל על יציאת המעגל הצירופי רק לאחר תום זמן ההשהיה.
אצלנו זה נוצר במעבר משני האחדים בלמטה אמצע לאחד בימין למטה+אחד בימין למעלה.

מניעת הבהובים סטטיים

ניתן למנוע הבהובים סטטיים ע"י שינוי המעגל. ראשית, יש להניח כי:

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

מוסיפים למעגל גורר נוסף $Y_{1}\cdot Y_{3}$ המכסה את החץ שהופיע במפת קרנו - ערכו של גורר זה אינו משתנה כאשר $Y_{2}$ משתנה מ-$0$ ל-$1$.

​

מעגל נקרא Hazard-Free אם הוא מממש ביטוי בצורת סכום מכפלות כך שכל זוג משבצות שכנות במפת קרנו המכילות 1 מכוסה ע"י אחת המכפלות(לפחות)

שערים לוגיים באמצעות מתגים

המימוש הטכנולוגי של שערים לוגיים נעשה באמצעות טרנזיסטורים המשמשים כמתגים. לכל מתג שלוש קצוות: כניסת כקרה($C$) ושני קצוות $A,B$ שהמתג יכול לחבר ביניהם.
נגדיר שני סוגי מתגים $P$ ו-$N$ באמצעות טבלת אמת:

​

נבנה מהפך($NOT$) באמצעות מתגים:

• זוג מתגים המחוברים בטור בין הקבועים $1$ ו-$0$ ($V_{plus},V_{minus}$)
• כאשר $A=0$ מתג $N$ מנותק ומתג $P$ מחובר וכך עובר הקבוע $1$ ליציאה $B$
• כאשר $A=1$ מתג $N$ מחובר ומתג $P$ מנותק וכך עובר הקבוע $0$ ליציאה $B$

​

נביט גם בשער $NAND$ המורכב מארבעה מתגים:
​

חיבור מספרים בינאריים

בכל עמודה מחברים שלוש סיביות: נשא "נכנס"(אשר נושאת את השארית מפעולה קודמת) ושתי רשומות.
בכל עמודה מחשבים שתי תוצאות: סיבית סכום העמודה(ברור) וסיבית נשא "יוצא"(אשר נושאת את השארית לפעולה הבאה)

מחבר מלא

מחבר מלא מוסיף עמודה אחת לתוצאה.
נסתכל על טבלת האמת ובכך נבנה את המעגל:

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

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

module FullAdder2(
	input a, b, cin,
	output wire cout, s // carry and sum
);
	assign s = a ^ b ^ cin;
	assign cout = (a & b) | (a & cin) | (b & cin);
endmodule

עד כה למדנו לחבר סיבית יחידה. איך נוכל לחבר מספר גדול של סיביות? פשוט שרשור של הרכיבים הללו אחד אחרי השני.
​
כמה זמן לוקח לנו לבצע זאת? מהרגע ש-$A,B$ נכנסים עד ש-$S$ מוכן הם צריכים לעבור 2 יחידות זמן של שער $XOR$. אבל יש לנו $n$ רכיבים כאלו משורשרים אחד אחרי השני ולכן הם כולם תלויים אחד בשני - בעצם, הם תלויים ב-$C_{out}$ אחד של השני כדי להתקדם. עד שה-$C_{out}$ יוצא יש $2$ יחידות זמן של שערים לוגיים שונים וזה קורה גם כן $n-1$ פעמים ולכן:

נבנה כזה בשפת תיאור חומרה:

module RCA #(paramterer n = 8) (
	input logic [n-1:0] a, b,
	input logic cin,
	output logic [n-1:0] s,
	output logic cout
);
	assign {cout, s} = a + b + cin;
endmodule

מחבר מסתכל קדימה

ראינו כי $A_{i},B_{i}$ מגיעים ברגע אפס, זמן רב לפני שיגיע $C_{i}$.
אם $g(i)\equiv A(i)B(i)=1$ אזי $C(i+1)=1$ ואין צורך לחכות ל-$C(i)$.
גם אם הנשא לא נוצר ביחידה $i$ הוא "יעבור" אם $C(i)=1$ וגם $p(i)=A(i)+B(i)=1$.

התוצאה ביחידה $i$ תהיה: $C(i+1)=g(i)+p(i)C(i)$.
נתקדם עוד כמה צעדים:

וכך הלאה.
נשים לב כי $p(i),g(i)$ תלויים רק בכניסות $A,B$ בעלות אותם אינדקסים.
באותו הזמן $C$ מסוים ממתין רק ל-$C$ הנוצר ארבעה שלבים קודם.
כאן אנו רואים במדוייק למה השיטה החדשה הזאת(שלא הוסברה טוב ע"י ניר) הרבה יותר עדיפה :)

איך זה נראה בפועל?
​
כעת נראה זאת כתוב בשפת תיאור חומרה:

module Adder2 #(parameter n = 8) (
	input logic [n-1:0] a, b,
	input logic cin,
	output logic [n-1:0] s,
	output logic cout
);
	logic [n-1:0] p = a ^ b;
	logic [n-1:0] g = a & b;
	logic [n:0]   c = {g | }
endmodule

מחבר ומחסר

לפעמים כשאנו רוצים גם לחבר וגם לחסר אנו נרצה להשתמש באותו הרכיב, איך נעשה זאת? נרצה לקחת את $B$ ולהפוך אותו למינוס מה שיתן לנו את האפשרות להשתמש באותו הרכיב.
איך עושים $-$ בשערים לוגיים? אנו משתמשים בשער $XOR$ עם קלט אחד שהוא $B$ והקלט השני הוא זרם של $1$.

יחידת חשבון ($ALU$)

נרחיב את המחבר ליחידה אשר מסוגלת לבצע את כל הפעולות הבאות:

• חיבור - $A+B$
• חיסור - $A-B$
• גם - $AND(A,B)$
• או - $OR(A,B)$

הנה מעגל עבור סיבית אחת:
​

עבור $32$ ביטים פשוט נחבר אותם אחד אחרי השני.

נוכל גם ליצור יצור בשם $ALU\; with\; SLT$ אשר הוא מאפשר לנו לדעת איזה מספר גדול יותר - $A$ או $B$.
הפעולה מציבה $0$ בכל הסיביות חוץ מה-$LSB$ אשר בה מוצב $0/1$ תלוי בסיבית $MSB$ של החיסור.

ניתן לבנות אותו באמצעות שפת תיאור חומרה כך:

module RISCVALU (ALUctl,A,B,ALUOut,Zero); 
	input logic [3:0] ALUctl; 
	input logic [31:0] A ,B; 
	output logic [31:0] ALUOut ; // Result. 
	output logic Zero; assign Zero = (ALUOut == O); //Zero is true if ALUOut is 0
	
	always_comb@(ALUctl, A, B) begin //reevaluate if these change 
		case (ALUctl) 
			0: ALUOut <= A & B; 
			1: ALUOut <= A | B; 
			2: ALUOut <= A + B; 
			6: ALUOut <= A - B; 
			7: ALUOut <=(A < B)? 1 : 0; 
			12: ALUOut <= ~(A | B); // NOR 
			default: ALUOut <= 0; 
		endcase 
	end 
endmodule

גילוי תקלות צירופיות

כשאנו מייצרים רכיב אנו חייבים לוודא שהוא עובד לפני שאנו שולחים אותו ללקוח.

אנו נרצה למצוא דרכים לבדוק תקלות בקלות שכן אם ננסה לבדוק באופן ידני, נדרש לכל מעגל צירופי לבדוק את כל $2^n$ הצירופים האפשריים ולהשוות אותם לטבלת האמת.
זה, מאוד ארוך ולכן לא נרצה לעשות זאת בדרך הנאיבית.

נגדיר שתי סוגי בדיקת תקלות:

• בדיקה לגילוי התקלות (האם המעגל תקין או לא)
• בדיקה לאיתור התקלות (איפה בדיוק המעגל נכשל)

לעיתים קשה לקבוע בדיוק מה מיקום התקלה ואנו רק יודעים שיש אחת שכזו.

אנו נסתכל בקורס זה על שני סוגים של תקלות:

1. צומת תקועה ב-0: תקלה אשר מספרת לנו על כך שחוט מסויים תקוע במצב לוגי $0$.
2. צומת תקועה ב-1: תקלה אשר מספרת לנו על כך שטוח מסויים תקוע במצב לוגי $1$.

תיקון תקלות

כדי לתקן תקלות בתצורה הכי טובה, נתחיל בלבדוק האם יש עמודות בהן יש רק $X$ אחד - אם יש, נסמנו בצבע או בעיגול. למה? השורות האלו מסמנות בדיקות חיוניות - כאלו שחובה לעשות.
על מנת להרכיב ניסוי לגילוי התקלות, נוסיף לבדיקות החיוניות עוד בדיקות כך שבכל עמודה לפחות לאחד מה-$X$-ים תהיה בדיקה.

מגבלות השיטה

ישנן שתי מגבלות לשיטה שראינו עד כה:

• הטבלה עלולה להיות גדולה מדי עבור מעגלים גדולים ואין הבטה שלא נזדקק לכל $2^n$ השורות.
• אם נגביל את עצמנו למספר קטן של בדיקות, נרצה לדעת כיצד אנו מכסים את המספר הגבוה ביותר של תקלות.

אנו נגדיר כיסוי תקלות כאחוז התקלות שהניסוי מגלה מתוך סך כל התקלות האפשריות.