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

• הפרק עוסק ביצירת שערים לוגיים המייצגים מספרים ומבצעים פעולות אריתמטיות.
• השערים הלוגיים שנבנו בפרק הקודם ישמשו לבניית Arithmetic Logical Unit - ALU.
• ה-ALU הוא צ'יפ מרכזי שמבצע את כל הפעולות האריתמטיות והלוגיות של המחשב.

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

• במערכת דצימלית הבסיס הוא 10, ובמערכת בינארית הבסיס הוא 2.
• בתבנית בינארית כמו "10011", הערך הדצימלי מחושב כך: (10011)two = 1 * 2^4 + 0 * 2^3 + 0 * 2^2 + 1 * 2^1 + 1 * 2^0 = 19
• באופן כללי, הערך של רצף ספרות x=XnXn-1...X0 בבסיס b מוגדר כך: (x)b = Σ xi * bi

חיבור בינארי

• חיבור בינארי מתבצע ע"י חיבור ספרות מימין לשמאל.
• תחילה, מחברים את שתי הספרות הימניות ביותר (Least Significant Bit - LSB).
• לאחר מכן, מוסיפים את ה-carry bit לסכום של זוג הביטים הבאים, עד לחיבור השמאליים ביותר (Most Significant Bit - MSB).
• אם יש carry של 1 לאחר החיבור האחרון, יש overflow, אחרת החיבור מסתיים בהצלחה.

Signed Binary Numbers

• במערכת בינאריות עם n ספרות, יש 2 תבניות שונות.

• לייצוג signed numbers, מחלקים את המרחב לשתי קבוצות שוות: חיוביים ושליליים.

• שיטת המשלים ל-2 (2's Complement) משמשת לייצוג מספרים חיוביים ושליליים.

• המשלים ל-2 של מספר x עם n ספרות מוגדר כך: x̄ = 2^n - x אם x≠0, אחרת 0.

• דוגמה: במערכת של 5 ביטים, המשלים ל-2 של 2- הוא (11110)two.

• בדיקה: (00010)two + (11110)two = (00000)two

• הערה: הסכום הוא למעשה two(100000), אך במערכת של 5 ביט מתעלמים מהביט השישי.

• באופן כללי, סכום של מספר וחילוץ שלו (x + (-x)) במערכת של n ביטים תמיד יהיה 2, כלומר 1 ואחריו n אפסים.

דוגמה למערכת בינארית של 4 ביטים עם שיטה המשלים ל-2

• המספרים החיוביים הם 0000 (0) עד 0111 (7).
• המספרים השליליים הם 1111 (-1) עד 1000 (-8).

תכונות מערכת בינארית של n-ביט

• ניתן לייצג 2n מספרים; המספר המקסימלי הוא 2^(n-1) - 1 והמינימלי הוא -2^(n-1).
• הייצוג הבינארי של כל החיוביים מתחיל ב-0, ושל השליליים מתחיל ב-1.
• כדי לקבל את הייצוג של x-, עוברים על הייצוג הבינארי של x משמאל לימין, משאירים את האפסים עד שמגיעים ל-1 הראשון, ואז הופכים את כל הביטים הנותרים.
• באופן שקול, הופכים את כל הביטים של x ומוסיפים 1.
• חיבור signed numbers המיוצגים בשיטת המשלים ל-2 הוא כמו חיבור של חיוביים.
• לדוגמה, (-3) + (-2) מחושב ע"י חיבור (1101)two + (1110)two, התוצאה היאtwo (1011) (לאחר התעלמות מ overflow).
• 1011 הוא הייצוג של המשלים ל-2 של 5-.
• בשיטת המשלים ל-2 השלילה האריתמטית של x היא חישוב x-, המתקבל ע"י שלילת הביטים והוספת 1: x - y = x + (-y).

Half-Adder

• מחבר שני ביטים.
• הפלט LSB נקרא sum, והפלט MSB נקרא carry.
• המימוש נובע ישירות מהשערים שבנו בפרויקט הקודם.
• sum(a,b) = Xor(a,b), carry(a,b) = And(a,b)

Full-Adder

• מחבר 3 ביטים.
• מחזיר 2 פלטים: ה-LSB של תוצאת החיבור (sum) וה-carry bit.
• ניתן לממש באמצעות שני צ'יפים של Half-Adder ושער נוסף, או לממש ישירות.

Adder

• מחבר שני מספרים של 16 ביט, מתעלם מ-overflow.

• משתמש בשיטת המשלים ל-2.

• ניתן לחבר שני signed numbers המיוצגים בשיטת המשלים ל-2 ע"י חיבור bit-wise מימין לשמאל ב-16 צעדים.

• בצעד 0 יתבצע החיבור של זוג ה-LSB, וה-carry bit יתווסף לחיבור הבאים.

• יש חיבור של 3 ביטים בכל צעד.

• אפשר לממש Adder באמצעות מערך של 16 צ'יפים של Full-Adder ופעפוע של ה-carry bits עד ל-MSB.

Incrementer

• מוסיף 1 למספר של 16-ביט.
• אפשר לממש בקלות מתוך Adder של 16 ביט.

Shift-Left

• הפלט מהצורה של הקלט כאשר כל ביט מוזז שמאלה בעמדה אחת.
• מוסיפים ביט 0 חדש מימין.
• שקולה לכפל הקלט ב-2.

Shift-Right

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

The Arithmetic Logic Unit (ALU)

• ה-ALU של מחשב Hack מחשב קבוצה של פונקציות (out = f(x,y), כאשר x ו-y הם קלטים, ו-out הוא הפלט).

• f היא פונקציה אריתמטית או לוגית מתוך 18 אפשרויות.

• ה-ALU בוחרת פונקציה לפי 6 ביטים בקלט (control bits).

• כל control bit מנחה את ה-ALU לפעולה בסיסית.

• ה-ALU יכול לחשב 2^6=64 פונקציות שונות.

• דוגמה: אם zx ו-nx הם 0, הקלט x לא משתנה.

• אם zy ו-ny הם 1, הקלט y מאופס ואז משולל bit-wise (נותן 11...11), שהוא 1-. פעולת החיבור האריתמטי גורמת לחישוב x + (-1).

• הביט no הוא 0, ולכן הפלט לא ישולל, לכן ה-ALU מחשבת x - 1.

• השלב הראשון במימוש ה-ALU הוא ליצור מעגל לוגי שמשנה קלט של 16 ביט בהתאם לביטים nx ו-zx.

• אפשר להשתמש בלוגיקה הזו כדי לשנות את הקלטים x ו-y וגם את הפלט out.

• ישנם צ'יפים מובנים עבור And וחיבור שמתבצעים bit-wise.

• יש לבנות לוגיקה שמשלבת את כל הצ'יפים ל-ALU השלם.