מחשב ההנחיה של החללית אפולו

מחשב ההנחיה של החללית אפולו (באנגלית: Apollo Guidance Computer, בראשי תיבות:AGC) הוא מחשב דיגיטלי שיוצר עבור תוכנית אפולו והותקן בכל תא פיקוד (CM) ובכל רכב נחיתה ירחי (LM). ה-AGC סיפק מחשוב וממשקים אלקטרוניים עבור הנחיה, ניווט ובקרה של חלליות אלו.

אורך המילה של ה-AGC הוא 16 סיביות – 15 סיביות נתונים וסיבית זוגיות אחת. רוב התוכנה ב-AGC מאוחסנת בזיכרון מיוחד לקריאה בלבד המכונה זיכרון ליבה שזור , שנוצר על ידי אריגה של חוטים דרך ליבות מגנטיות וסביבן. ל־AGC יש גם כמות קטנה של זיכרון ליבה מגנטית לקריאה וכתיבה.

אסטרונאוטים תקשרו עם ה-AGC באמצעות צג ומקלדת בשם DSKY. את ה-AGC ואת ממשק המשתמש שלו, ה־DSKY, פיתחה MIT אינסטרומנטיישן לברטורי  בתחילת שנות ה-60 עבור תוכנית אפולו. הם הוטסו לראשונה בשנת 1966. ה-AGC היה המחשב הראשון המבוסס על מעגלים משולבים מסיליקון. ביצועי המחשב היו דומים לביצועי הדור הראשון של המחשבים הביתיים מסוף שנות ה-70, כמו אפל II, TRS-80 וקומודור PET.

פעולה 
את משימות תוכנית ג'מיני, הטיסו אסטרונאוטים ידנית באמצעות מוטות בקרה; לעומת זאת, את רוב תוכנית אפולו, למעט זמן קצר במהלך הנחיתות על הירח, הטיסו מחשבים. בכל טיסה אל הירח היו שני AGC, אחד בתא הפיקוד ואחד ברכב הנחיתה הירחי, למעט משימת אפולו 8 שלא כללה נחיתה על הירח. ה-AGC היה מרכז מערכת ההדרכה, הניווט והבקרה (GNC) של תא הפיקוד. ברכב הנחיתה הירחי, הפעיל ה-AGC את ה־PGNCS (מערכת הנחיה, ניווט ובקרה ראשית). ראשי התיבות מבוטאים כ"פינגס".

בכל משימה אל הירח היו שני מחשבים נוספים, מלבד ה־AGC:
 המחשב הדיגיטלי של רכב השיגור (LVDC) שהותקן על טבעת המכשור של המשגר סטורן 5.
 מערכת הנחיית ביטול הנחיתה (AGS, מבוטא "אגְס") של רכב הנחיתה הירחי, לשימוש במקרה של כשל ב־PGNCS של רכב הנחיתה הירחי. ה-AGS יכול לשמש להמראה מהירח ולמפגש עם תא הפיקוד, אך לא לנחיתה.

תכנון 

ה-AGC תוכנן במעבדת צ'ארלס סטארק דרייפר על ידי צ'ארלס סטארק דרייפר. את תכנון החומרה הוביל אלדון סי הול .

את ארכיטקטורת המחשב תכננו בהתחלה ג'יי האלקום לנינג (J. Halcombe Laning), אלברט הופקינס (Albert Hopkins), ריצ'רד באטין (Richard Battin), רמון אלונסו (Ramon Alonso), ויו בלייר-סמית' (Hugh Blair-Smith). את חומרת הטיסה ייצרו ריית'און. הרב תלר היה גם הוא בצוות האדריכלים.

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

בגרסת בלוק I היו 4,100 מעגלים משולבים, שכל אחד מהם הכיל שער NOR יחיד בעל שלוש כניסות. בגרסה המאוחרת יותר, בלוק II (שבה השתמשו בטיסות המאוישות), היו כ-2,800 מעגלים משולבים, בעיקר שערי NOR כפולים עם שלוש כניסות בכל אחד ומספר קטן יותר של מַרחֵבים (expanders) ומגברי חישה.  המעגלים המשולבים, מבית פיירצ'יילד סמיקונדקטור , יושמו בלוגיקת נגד-טרנזיסטור  במארז שטוח . הם חוברו באמצעות עיטוף חוטים. לאחר מכן, קובע החיווט באמצעות פלסטיק אפוקסי יצוק. השימוש בסוג יחיד של מעגלים משולבים (שער NOR כפול בעל 3 כניסות) בכל ה-AGC, מנע בעיות בתכנון שנוצרו במחשבים מוקדמים אחרים, כמו מחשב ההנחיה של הטיל הבליסטי מיניטמן II , ששילב לוגיקת דיודה-טרנזיסטור  ושערי לוגיקת דיודות . בניית כל המחשב מסוג מעגל משולב יחיד התאפשר משום ששערי NOR הם שערים לוגיים אוניברסליים שמהם ניתן ליצור כל שער אחר (מערכת פעולות שלמה), אם כי במחיר של שימוש בשערים נוספים.

למחשב היה זיכרון ליבה מגנטי מחיק בגודל של 2,048 מילים וזיכרון ליבה שזור  לקריאה בלבד בגודל של 36,864 מילים. לשניהם היו זמני מחזור של 11.72 מיקרו שניות. אורך כל מילה בזיכרון היה 16 סיביות: 15 סיביות נתונים וסיבית זוגיות אחת. חלוקת הסיביות במילים בתוך המעבד הייתה 14 סיביות נתונים, סיבית גלישה אחת וסיבית סימן אחת (בייצוג המשלים ל-1).

ממשק ה-DSKY 

ל-AGC היה ממשק משתמש בשם DSKY (ראשי תיבות של display and keyboard – צג ומקלדת, מבוטא "דיסקי"). הוא נבנה ממערך נורות לחיווי, צגים ספרתיים ומקלדת הדומה ללוח מקשים של מחשבון. הפקודות הוזנו כמספרים דו ספרתיים. מספרים אלו כונו "פועל" ו"שם עצם". ה"פועל" תיאר את סוג הפעולה שיש לבצע ו"שם עצם" ציין אלו נתונים יושפעו מהפעולה שצוינה בפקודת ה"פועל".

כל ספרה הוצגה בצבע ירוק (530 ננומטר) בתצוגת שבעה מקטעים  של אלקטרולומינציה במתח גבוה; אלה הופעלו על ידי ממסרים אלקטרומכניים שהגבילו את קצב עדכון הספרות. ניתן היה להציג ב-DSKY שלושה מספרים באורך של חמש ספרות, בבסיס אוקטלי או עשרוני, והם הציגו בדרך כלל וקטורים כגון כיוון החללית או שינוי המהירות הנדרש (ΔV). אף על פי שהנתונים אוחסנו בזיכרון המחשב ביחידות מטריות, הם הוצגו ביחידות המקובלות בארצות הברית. ממשק זה, הדומה בסגנונו למחשבון, היה הראשון מסוגו.

בתא הפיקוד היו שני ממשקי DSKY המחוברים ל-AGC; אחד בלוח הבקרה הראשי והשני באגף הציוד התחתון, ליד הסקסטנט ששימש לכיול מערכת ההנחיה האינרציאלית. ברכב הנחיתה הירחי היה DSKY יחיד. מחוון גישת מנחה טיסה (FDAI), בו שלט ה-AGC, מוקם מעל ה-DSKY בלוח הבקרה של המפקד וברכב הנחיתה הירחי.

תזמון 
התייחסות התזמון של AGC הגיעה משעון קריסטל בתדר של 2.048 מגה-הרץ. תדר השעון חולק בשניים כדי לייצר אות שעון ארבע פאזי בתדר של 1.024 מגה-הרץ שבו השתמש ה-AGC לביצוע פעולות פנימיות. גם תדר שעון זה חולק בשניים כדי לייצר אות של 512 קילו-הרץ הנקרא תדר אב; אות זה שימש לסנכרון מערכות חיצוניות של החללית אפולו.

תדר האב חולק עוד יותר באמצעות סקלר (scaler), תחילה בחמישה באמצעות מונה טבעות להפקת אות של 102.4 קילו-הרץ. אות זה חולק בשניים עד 17 שלבים רצופים שנקראו F1 (51.2 קילו-הרץ) עד F17 (0.78125 הרץ). שלב F10 (100 הרץ) הוזן בחזרה ל-AGC כדי להגדיל את שעון הזמן האמת ומונים לא רצוניים אחרים באמצעות PINC (ראו בהמשך). שלב ה-F17 שימש להפעלת ה-AGC לסירוגין כאשר הוא פעל במצב המתנה.

אוגרים ראשיים 
ל-AGC היו ארבעה אוגרים ראשיים, כל אחד מהם בגודל של 16 סיביות, ששימשו לחישובים כלליים:
 A – צובר ראשי לחישובים כלליים
 Z – מונה התוכנית – כתובת הפקודה הבאה שתתבצע
 Q – שומר את כתובת החזרה לאחר פקודות TC
 L – המילה מהסדר הנמוך של המכפלה לאחר פקודת כפל (MP)

בנוסף, היו ארבע כתובות בזיכרון הליבה, כתובות 20–23, שכונו מיקומי עריכה משום שכל מידע שהיה מאוחסן בהן היה מוזז או מסובב במיקום סיביות אחד, למעט כתובת 23 שהמידע שנכתב אליה הוזז ימינה בשבע מיקומי סיביות. דבר זה היה משותף לבלוק I ולבלוק II.

אוגרים נוספים 

מבד האוגרים הראשיים, היו ל-AGC אוגרים נוספים:
 S – אוגר כתובת זיכרון באורך של 12 סיביות
 Bank/Fbank – אוגר 5 סיביות המשמש לבחירת בנק ROM של 1 קילו-מילים בעת פנייה לכתובת בזיכרון הקבוע
 Ebank – אוגר 3 סיביות המשמש לבחירת בנק RAM של 256 מילים בעת פנייה לכתובת בזיכרון המחיק
 Sbank ("סופר-בנק") – הרחבה של סיבית יחידה ל-Fbank. סיבית זו נדרשת משום שלא ניתן לגשת ל-4 קילו-מילים האחרונות מתוך ה-36 קילו-מילים של ה-ROM באמצעות Fbank בלבד.
 SQ – אוגר פקודה של 4 סיביות. מכיל את הפקודה הנוכחית שמתבצעת
 G – אוגר חוצץ הזיכרון, באורך של 16 סיביות, המשמש לאחסון מילות נתונים המגיעות אל הזיכרון וממנו
 X – אחד משתי הכניסות של המחבר הלוגי (המחבר מבצע את כל הפעולות האריתמטיות בשיטת המשלים ל-1) או 1 שמתווסף למונה התוכנה (אוגר Z)
 Y – הקלט השני של המחבר הלוגי
 U – לא ממש אוגר, אלא הפלט של המחבר הלוגי (סכום תוכן אוגרים X ו-Y בשיטת המשלים ל-1)
 B – אוגר חוצץ לשימוש כללי. משמש גם לקדם-הבאה (pre-fetch) של הפקודה הבאה. בתחילת הפקודה החדשה, הסיביות העליונות של אוגר B (המכילות את קוד הפעולה הבא) מועתקות לאוגר SQ, והסיביות התחתונות (הכתובת) מועתקות לאוגר S.
 C – לא אוגר בפני עצמו, אלא המשלים של אוגר B

סט פקודות 
סט הפקודות כלל 3 סיביות עבור קוד הפעולה ו-12 סיביות עבור הכתובת. לפי מבנה זה, יש לכל היותר 8 פקודות, שכל אחת מהן יכולה לפעול על כל מקום בזיכרון (בהנחה שהזיכרון מורכב מ-4,096 מילים). עם זאת, מכיוון שמספר הפקודות הנדרשות עלה, הוצג קידוד מורכב יותר לפקודות, והוצגו כמה סוגי קידוד חדשים:
פקודות הפועלות רק על זיכרון מחיק (כמו כתיבה לזיכרון או החלפה) יכולות להשתמש במרחב כתובות של 10 סיביות בלבד, לפיכך ניתן לקודד פקודות כאלו ב-5 סיביות. שתי הסיביות הנוספות כונו "קוד רבעון" או "QC".

לבלוק II היו 34 פקודות: TC, CCS, TCF, DAS, LXCH, INCR, ADS, CA, CS, INDEX, DXCH, TS, XCH, AD ו-MASK (פקודות בסיסיות), ו-READ, WRITE, RAND, WAND, ROR, WOR, RXOR, EDRUPT, DV, BZF, MSU, QXCH, AUG, DIM, DCA, DCS, SU, BZMF ו-MP (פקודות מורחבות). חמש עשרה הפקודות הבסיסיות הופעלו ישירות על ידי קוד הפעולה. תשע עשרה הפקודות המורחבות הופעלו על ידי ביצוע פקודת TC מיוחדת (הנקראת EXTEND) לפני הפקודה.

הפקודות של בלוק II כללו את הפקודות הבאות:

פקודות בסיסיות 
 TC (העבר שליטה)
 פקודת הסתעפות ללא תנאי לכתובת המצוינת בפקודה. כתובת החזרה נשמרת אוטומטית באוגר Q, כך שניתן להשתמש בפקודת TC לקריאה לתת-שגרות.
 CCS (ספור, השווה ודלג)
 פקודת הסתעפות מותנית מורכבת. הערך המוחלט המופחת (DABS) של המספר שאוחזר מכתובת הזיכרון שצוינה בפקודה חושב ואוחסן באוגר A: אם המספר היה גדול מאפס, ה-DABS מקטין את ערכו ב-1. אם המספר היה שלילי, כל הסיביות שלו נהפכות (הפיכת המספר לחיובי) ולאחר מכן ערכו מופחת באחד. אם המספר היה אפס, ערכו נשמר כפלוס אפס.
 השלב האחרון ב-CCS הוא דילוג לאחת מארבע אפשרויות בהתאם למספר שאוחזר מהזיכרון. אם המספר היה גדול מ-0, CCS מדלג לפקודה שנמצאת בזיכרון מיד לאחר ה-CCS. אם המספר הוא פלוס אפס, CCS מדלג לפקודה השנייה שאחרי ה-CCS. מספר קטן מאפס גורם לדילוג לפקודה השלישית שאחרי ה-CCS, ומינוס אפס גורם לדילוג לפקודה הרביעית אחרי CCS.
 המטרה העיקרית של הספירה הייתה לאפשר ללולאה רגילה, הנשלטת על ידי מונה חיובי, להתחיל בפקודת TC ולהסתיים בפקודת CCS (מקביל ל-BCT ב-IBM 360).
 INDEX
 מוסיף לפקודה הבאה את המספר שאוחזר מהכתובת שצוינה בפקודה. ניתן להשתמש ב-INDEX כדי להוסיף או להחסיר ערך אינדקס מכתובת בסיס שמציין אופרנד הפקודה שאחרי פקודת ה-INDEX. שיטה זו משמשת לחיפוש במערכים ובטבלאות. מכיוון שההוספה חלה על שתי מילים שלמות, פקודה זו שימשה גם לשינוי קוד הפעולה בפקודה הבאה (פקודות מורחבות).
 RESUME
 מקרה מיוחד של INDEX (INDEX 17). פקודה זו מחזירה את המחשב לתוכנית הראשית, מהמקום בו היא הופסקה לאחר פסיקה.
 XCH (החלף)
 החלפת תוכן הזיכרון עם תוכן אוגר A. אם כתובת הזיכרון נמצאת בזיכרון קבוע (לקריאה בלבד), תכולת הזיכרון אינה מושפעת, ופקודה זו פשוט מעתיקה לאוגר A את תוכן כתובת הזיכרון. אם הכתובת נמצאת בזיכרון המחיק ודגל הגלישה מונף, אז הגלישה מתוקנת על ידי אחסון הסיבית השמאלית ביותר מבין 16 הסיביות של אוגר A כסיבית סימן בזיכרון.
 CS (נקה וחסר)
 טוען את אוגר A עם המספר הנגדי (המשלים ל-1) של הנתונים הנמצאים בכתובת הזיכרון שצוינה.
 TS (העבר לאחסון)
 שומר את אוגר A בכתובת הזיכרון שצוינה. TS גם מזהה ומתקן גלישות. אם דגל הגלישה מונף, אוגר A מאוחסן בזיכרון וסיבית הסימן בזיכרון מועתקת מהסיבית השמאלית ביותר של אוגר A. לאחר מכן אוגר A משתנה ל-+1 או -1 בהתאם לסוג הגלישה (גלישה כתוצאה מחיבור או מחיסור, בהתאמה), והתוכנה מדלגת על הפקודה הבאה.
 בכל פעם שגלישה היא אירוע אפשרי אך חריג, המתכנת כתב לאחר ה-TS פקודת TC (קריאה לתת-שגרה) לקוד המטפל בנתונים ללא גלישה. כאשר זוהי אפשרות שכיחה (כמו בחיבור וחיסור בדיוק גבוה), נכתבה לאחר ה-TS פקודת CAF 0 להשלמת היווצרות הנשא (+1, 0 או -1) לתוך המילה הבאה. זוויות נשמרו בדַיִק יחיד; מרחקים ומהירויות בדיק כפול; וזמן בדיק שָלוּש.
 AD (חיבור)
 חיבור תוכן כתובת הזיכרון ואוגר A ושמירת התוצאה ב-A. 2 הסיביות השמאליות ביותר של A עשויות להיות שונות לפני או אחרי ה-AD, דבר המורה על גלישה.
 MASK
 שומר באוגר A את תוצאת הפעולה הבוליאנית AND של תוכן הזיכרון בכתובת הנתונה ואוגר A.
CA (נקה והוסף)
העתקת הנתונים מהכתובת שצוינה בפקודה לאוגר A.
TCF (העבר שליטה לזיכרון הקבוע)
הסתעפות ללא תנאי לכתובת המצוינת בפקודה (כתובת הנמצאת בזיכרון הקבוע).
DAS (חיבור כפול ושמירה בזיכרון)
חיבור שני מספרים בדַיק כפול. כלומר, כל אחד משני המספרים מורכב משתי מילים; המספר הראשון נמצא באוגרים A ו-L והמספר השני בנמצא בזיכרון בכתובת המצוינת בפקודה ובכתובת העוקבת לה. הסכום נשמר באותו מיקום בזיכרון. לאחר החיבור, אוגר L משתנה לפלוס אפס. אם יש גלישה, היא נשמרת באוגר A כ־1 או -1, לפי סוג הגלישה. אם אין גלישה, אוגר A משתנה גם הוא לפלוס אפס.
LXCH (החלף את אוגר L)
בדיוק כמו XCH רק שמחליפה את תוכן אוגר L עם תוכן כתובת הזיכרון.
INCR (הגדל)
מגדיל ב-1 את תוכן הזיכרון בכתובת המצוינת.
ADS
חיבור תוכן הזיכרון לאוגר A ושמירת התוצאה בזיכרון.
DXCH (החלפה בדיק כפול)
החלפת שני מספרים בדיק כפול. המספר הראשון נמצא באוגרים A ו-L והמספר השני בנמצא בזיכרון בכתובת המצוינת ובכתובת העוקבת לה.

פקודות מורחבות 
 MP (כפל)
 הכפלת תוכן אוגר A בתוכן כתובת הזיכרון. המכפלה היא באורך של שתי מילים; המילה מהסדר הגבוה של המכפלה מאוחסנת באוגר A והמילה מהסדר הנמוך מאוחסנת באוגר L. לשני חלקי המכפלה יש סימן זהה.
 DV (חילוק)
 חילוק תוכן המספר המאוחסן באוגרים A ו-L במספר המאוחסן בכתובת הזיכרון הנתונה. המנה אוחסנה באוגר A והערך המוחלט של השארית אוחסן באוגר L.
 SU (חיסור)
 חיסור (חיבור המספר הנגדי) של הנתונים בכתובת הזיכרון מתוכן אוגר A. התוצאה נשמרת באוגר A.
READ
קריאה מערוץ קלט/פלט.
WRITE
כתיבה לערוץ קלט/פלט.
RAND
הפעלת AND על ערוץ קלט/פלט ואוגר A, ושמירת התוצאה באוגר A.
WAND
הפעלת AND על ערוץ קלט/פלט ואוגר A, ושמירת התוצאה באוגר A ובערוץ הנתון.
ROR
הפעלת OR על ערוץ קלט/פלט ואוגר A, ושמירת התוצאה באוגר A.
WOR
הפעלת OR על ערוץ קלט/פלט ואוגר A, ושמירת התוצאה באוגר A ובערוץ הנתון.
RXOR
הפעלת XOR על ערוץ קלט/פלט ואוגר A, ושמירת התוצאה באוגר A.
EDRUPT
פסיקה מלאכותית שניתנת להפעלה דרך התוכנה עצמה, ללא אות פסיקה אמיתי שמגיע אל המעבד. הפקודה נקראת על שם אד סמלי שביקש שתהיה פקודה כזו. מעולם לא השתמשו בפקודה זו מלבד פעם אחת בתוכנת הבדיקה של אד.
BZF (אם 0, קפוץ לזיכרון הקבוע)
הסתעפות מותנית. אם אוגר A שווה ל-0, המעבד קופץ לכתובת הנתונה. אם לא, התוכנה ממשיכה כרגיל.
MSU
מחסרת שני מספרים חיוביים לא מסומנים ומחזירה תוצאה עם סימן בשיטת המשלים ל-1.
QXCH
בדיוק כמו XCH רק שמחליפה את תוכן אוגר Q עם תוכן כתובת הזיכרון.
AUG
מגדיל את הערך המוחלט של תוכן תא הזיכרון הנתון. כלומר, אם הוא חיובי, הוא גדל ב-1, ואם הוא שלילי, הוא קטן ב-1.
DIM
מקטין את הערך המוחלט של תוכן תא הזיכרון הנתון. כלומר, אם תוכנו חיובי, הוא קטן ב-1, ואם הוא שלילי, הוא גדל ב-1. אם הוא שווה ל-+0 או -0, הוא נשאר ללא שינוי.
DCA
העתקת מספר בדיק כפול מהזיכרון בכתובת המצוינת ובכתובת העוקבת לה, לאוגרים A ו-L.
DCS
העתקת מספר בדיק כפול, הנגדי למספר בכתובת המצוינת ובכתובת העוקבת לה, אל אוגרים A ו-L.
BZMF (קפוץ אם 0 או שלילי לזיכרון הקבוע)
הסתעפות מותנית. אם אוגר A שווה ל-0 או למספר שלילי, המעבד קופץ לכתובת הנתונה. אם לא, התוכנה ממשיכה כרגיל.

הפקודות בוצעו בקבוצות של 12 שלבים, הנקראים פעימות תזמון (TP1 עד TP12). כל קבוצה של 12 פעימות תזמון נקראה רצף משנה (subsequence) של הפקודה. פקודות פשוטות, כגון TC, מבוצעות ברצף בודד של 12 פעימות. פקודות מורכבות יותר דורשות מספר רצפי משנה. פקודת כפל (MP), לדוגמה, אורכת 3 רצפי משנה: רצף משנה ראשוני שנקרא MP0, ואחריו רצף משנה MP1, ולאחר מכן רצף משנה MP3 שסיים את הפקודה. בבלוק I פקודה זו ארכה 8 רצפי משנה.

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

זיכרון 
זיכרון בלוק I היה מאורגן בבנקים של קילו-מילים. הבנק הנמוך ביותר (בנק 0) היה זיכרון מחיק (RAM). כל הבנקים הבאים היו בנקי זיכרון קבוע (ROM). לכל פקודה של ה-AGC היה שדה כתובת באורך של 12 סיביות. הסיביות התחתונות (1–10) התייחסו לזיכרון שבתוך כל בנק. סיביות 11 ו-12 קבעו איזה בנק יבחר: 00 עבור בנק הזיכרון המחיק; 01 עבור הבנק הנמוך ביותר (בנק 1) של הזיכרון הקבוע; 10 עבור הבנק הבא (בנק 2); ו-11 עבור אוגר הבנקים, שניתן להשתמש בו כדי לבחור כל בנק מעל בנק 2. בנקים 1 ו-2 נקראו זיכרון קבוע-קבוע, מכיוון שהם היו זמינים תמיד, ללא קשר לתוכן אוגר הבנקים. בנקים 3 ומעלה נקראו זיכרון קבוע הניתן להחלפה מכיוון שהבנק הנבחר נקבע על ידי תוכן אוגר הבנקים.

בבלוק II הורחב מרחב הכתובות על ידי בחירת בנק באמצעות אוגרים: Fbank (לזיכרון הקבוע) ו-Ebank (לזיכרון המחיק). הזיכרון היחיד מכל סוג שניתן היה לגישה בכל זמן נתון היה הבנק הנוכחי (על פי תוכן האוגרים), בתוספת זיכרון קבוע וזיכרון מחיק שהיה ניתן לגשת אליהם תמיד, בלי קשר לתוכן האוגרים. בנוסף, האוגר Fbank היה יכול לגשת ל-32 קילו-מילים לכל היותר, כך שנדרש אוגר נוסף – Sbank ("סופר-בנק") – כדי לגשת ל-4 קילו-מילים האחרונים.

בתחילה היו בבלוק I 12 קילו-מילים של זיכרון קבוע, אך מאוחר יותר הוגדל הזיכרון ל-24 קילו-מילים. בבלוק II היו 36 קילו-מילים של זיכרון קבוע ו-2 קילו-מילים של זיכרון מחיק.

ה-AGC העביר נתונים אל הזיכרון וממנו דרך אוגר G בתהליך שנקרא מחזור זיכרון. מחזור הזיכרון ארך 12 פעימות תזמון (11.72 מיקרו-שניות). המחזור מתחיל בפעימת תזמון 8 של רצף המשנה הקודם, כאשר ה-AGC טוען לאוגר S את כתובת הזיכרון הקבוע שממנה יש להביא את הנתונים. אם צריך להביא נתונים גם מהזיכרון המחיק, הכתובת עבורם נטענת לאוגר S בפעימת תזמון 1. חומרת הזיכרון שולפת את מילת הנתונים מהזיכרון בכתובת שציין אוגר S; נתונים שהגיעו מהאוגרים המרכזיים נשמרו באוגר G בפעימת תזמון 2; נתונים מהזיכרון המחיק נשמרו באוגר G בפעימת תזמון 4; ונתונים מהזיכרון הקבוע נשמרו באוגר G בפעימת תזמון 6. מילת הזיכרון שאוחזרה מהזיכרון הייתה זמינה באוגר G במהלך פעימות תזמון 7 עד 10. לאחר פעימת תזמון 10, הנתונים באוגר G נכתבו בחזרה לזיכרון.

מחזור הזיכרון של ה-AGC התרחש ברציפות לאורך כל פעילות ה-AGC. בפקודות הזקוקות לנתונים מהזיכרון, המחשב ניגש לאוגר G במהלך פעימות תזמון 7–10. אם ה-AGC שינה את מילת הזיכרון שבאוגר G, המילה שהשתנתה נכתבה בחזרה לזיכרון לאחר פעימת תזמון 10. בדרך זו, מילות נתונים עברו מהזיכרון לאוגר G ובחזרה לזיכרון.

15 הסיביות התחתונות של כל מילת זיכרון הכילו פקודות או נתונים, כאשר על כל מילה מכילה סיבית נוספת שמוודאת שהמילה נקראה כמו שצריך מהזיכרון – סיבית זוגיות. ערכה של סיביות זו, 0 או 1, נקבע כך שמספר ה-1 בכל מילת זיכרון יהיה תמיד מספר אי-זוגי (כולל סיבית הזוגיות). מעגל בדיקת זוגיות בדק את סיבית הזוגיות במהלך כל מחזור זיכרון; אם הביט לא תאם את הערך הצפוי, המחשב הבין שמילת הזיכרון פגומה ונורית אזעקת זוגיות נדלקה.

פסיקות ומונים בלתי רצוניים 
ל-AGC היו חמישה סוגי פסיקות:
 Dsrupt – הופעלה במרווחי זמן קבועים כדי לעדכן את תצוגת המשתמש, ה־DSKY.
 Erupt – נוצרה כתוצאה מכשלי חומרה או מאזעקות שונות.
 Keyrupt – הורתה על לחיצה על מקש בלוח המקשים של ה־DSKY.
 T3Rrupt – נוצרה במרווחי זמן קבועים על פי טיימר בחומרת המחשב כדי לעדכן את שעון הזמן אמת של ה-AGC.
 Uprupt – נוצרה בכל פעם שנטענה מילה של 16 סיביות של נתוני כינוס (uplink data) לתוך ה-AGC.

ה-AGC הגיב לכל פסיקה על ידי הפסקה זמנית של התוכנית הנוכחית, ביצוע שגרת שירות קצרה עבור הפסיקה, וחידוש התוכנית שהופסקה.

ל-AGC היו גם 20 מונים לא רצוניים, כלומר מונים שהוגדלו או הוקטנו, אך לא לפי קוד התוכנה, אלא כתוצאה מאותות חיצוניים למחשב. מונים אלו היו מיקומי זיכרון שמנו כלפי מעלה או מטה, או אוגרי זיזה. המונים גדלו, קטנו או הוזזו בתגובה לאותות פנימיים. פעולות הגדלה (PINC), הפחתה (MINC) או הזזה (SHINC) טופלו על ידי רצף מיקרו־פקודות יחיד שהיה יכול לפעול בין כל שתי פקודות רגילות.

פסיקות עלולות להיות מופעלות כאשר המונים עלו על גדותיהם. הפסיקות T3rupt ו-Dsrupt נוצרו כאשר המונים שלהם, המופעלים על ידי שעון בתדר של 100 הרץ, גלשו לאחר ביצוע רצפי משנה רבים של PINC. הפסיקה Uprupt הופעלה לאחר שהמונה שלה, המבצע את הרצף SHINC, העביר 16 סיביות של נתוני כינוס לתוך ה-AGC.

מצב המתנה 
ל-AGC היה מצב חיסכון בחשמל שנשלט על ידי מתג אַפשר המתנה. מצב זה כיבה את החשמל ל-AGC, למעט שעון ה-2.048 מגה-הרץ והסקלר (scaler). אות F17 מהסקלר הפעיל את החשמל ל-AGC ואת ה-AGC מחדש במרווחים של 1.28 שניות. במצב זה, ה-AGC ביצע פונקציות חיוניות, בדק את המתג אפשר המתנה, ואם הוא היה עדיין מופעל, כיבה את החשמל וחזר למצב שינה עד לאות F17 הבא.

במצב המתנה, ה-AGC ישן רוב הזמן; לכן הוא לא היה ער כדי לבצע את פקודת PINC הדרושה כדי לעדכן את שעון הזמן אמת של ה-AGC במרווחים של 10 מילי־שניות. כדי לפצות, אחת הפונקציות שביצע ה-AGC בכל פעם שהוא התעורר במצב המתנה הייתה לעדכן את שעון הזמן אמת ב-1.28 שניות.

מצב המתנה תוכנן להפחית את ההספק ב-5 עד 10W (מ-70W) במהלך טיסה באמצע המסלול כאשר לא היה צורך ב-AGC. עם זאת, בפועל, ה-AGC נותר דולק במהלך כל שלבי המשימה והתכונה הזו מעולם לא הייתה בשימוש.

אפיקי נתונים 
ל-AGC היו אפיקי קריאה וכתיבה של 16 סיביות. המחשב היה יכול להעביר נתונים מאוגרים מרכזיים (A, Q, Z או L) או מאוגרים פנימיים אחרים לאפיק הקריאה באמצעות אות בקרה. אפיק הקריאה חובר ישירות לאפיק הכתיבה, כך שכל הנתונים המופיעים באפיק הקריאה הופיעו בו זמנית גם באפיק הכתיבה. אותות בקרה אחרים יכולים להעתיק נתונים מאפיק הכתיבה בחזרה לאוגרים וכדומה.

העברות נתונים פעלו כך: לדוגמה, כדי להעביר את כתובת הפקודה הבאה מאוגר B לאוגר S, ניתן אות הבקרה RB (קרא את אוגר B); אות זה גרם לכתובת לעבור מאוגר B לאפיק הקריאה, ולאחר מכן לאפיק הכתיבה. אות בקרה WS (כתוב באוגר S) העתיק את הכתובת מאפיק הכתיבה אל אוגר S.

ניתן היה לקרוא את תוכנם של מספר אוגרים לתוך אפיק הקריאה בו זמנית. כאשר דבר זה התרחש, בוצעה פעולת OR לוגי על הנתונים מהאוגרים. תכונת OR זו שימשה ליישום פקודת MASK – פקודת AND לוגי. ל-AGC אין יכולת מקורית לבצע AND לוגי, אבל הוא יכול לבצע OR לוגי דרך אפיק הכתיבה ולהפוך את הנתונים דרך אוגר C, וכך, על ידי משפט דה מורגן, ניתן לבצע AND לוגי – הופכים את שני האופרנדים, מבצעים עליהם OR לוגי דרך אפיק הנתונים, ולאחר מכן הופכים את התוצאה.

תוכנה 

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

עקרונות התכנון שפותחו עבור ה-AGC ב-MIT אינסטרומנטיישן לברטורי, בהנחייתו של צ'ארלס דרייפר בסוף שנות ה-60, הפכו לבסיס להנדסת תוכנה בימינו, במיוחד בשל תכנון מערכות אמינות המבוססות על תוכנה אסינכרונית, תזמון עדיפות, בדיקות ויכולת החלטה אנושית בלולאה . כאשר הוגדרו דרישות התכנון של ה-AGC, לא היו קיימות תוכנות וטכניקות תכנות נחוצות ולכן היה צריך לתכנן אותו מאפס.

ל-AGC הייתה מערכת הפעלה בזמן אמת פשוטה פרי תכנונו של ג'. הלקום ליינינג , הכוללת מנהל עיבוד אצוות ("Exec") בשיטת ריבוי משימות שיתופי וזַמנן (scheduler) מונחה פסיקות הפועל בשיטת ריבוי משימות מוסדר – "רשימת המתנה" (Waitlist). רשימת ההמתנה יכלה לתזמן מספר משימות (tasks) מונחות טיימר. ב־AGC, משימות הן תהליכונים קצרים שיכולות לתזמן הפעלה נוספת של עצמם באמצעות רשימת ההמתנה, או להתחיל פעולה ארוכה יותר על ידי התחלת "עבודה" (job) באמצעות המנהל. מחשב ההנחיה של החללית אפולו כונה "האסטרונאוט הרביעי" בשל תפקידו הקריטי בסיוע לשלושת האסטרונאוטים שסמכו עליו.

ל-AGC היה גם מפרש תוכנה מתוחכם שפותח ב-MIT אינסטרומנטיישן לברטורי. המפרש מימש מכונה וירטואלית הכוללת פקודות מורכבות ומתקדמות הרבה יותר מפקודות ה-AGC המקוריות. פקודות אלו פִשטו מאוד את תוכניות הניווט; באמצעות פקודות המפרש היה ניתן לחשב חישובי אריתמטיקה טריגונומטרית, סקלרית ווקטורית בדַיק כפול (מספרים בני 16 ו-24 סיביות), ואפילו פקודת MXV (כפל מטריצה בווקטור), ולשלבן עם קוד AGC מקורי. אף על פי שזמן הביצוע של הפקודות המדומות ארוך מהפקודות המקוריות (עקב הצורך לפרש פקודות אלו בזמן ריצת התוכנה), המפרש סיפק פקודות רבות שה-AGC לא הכיל באופן טבעי, ודרישות הזיכרון שלו היו נמוכות בהרבה מאשר אילו היה צריך להוסיף פקודות אלו לשפת האסמבלי המקורית של ה-AGC, ובאותה תקופה הזיכרון היה יקר מאוד. זמן הריצה של פקודה מדומה היה כ-24 אלפיות השנייה בממוצע. האסמבלר, YUL, אכף מעבר תקין בין קוד מקורי לקוד מפורש.

התוכנה הכילה קבוצה של שגרות ממשק משתמש מונחות פסיקות בשם "פינבול" (Pinball), שסיפקה שירותי מקלדת וצג עבור העבודות והמשימות הפועלות ב-AGC. קבוצה עשירה של שגרות נגישות אפשרה למפעיל – האסטרונאוט – להציג את תוכן מיקומי זיכרון שונים בבסיס אוקטלי או עשרוני, בקבוצות של 1, 2 או 3 אוגרים בכל פעם. שגרות מוניטור אפשרו למפעיל ליזום משימה כדי להציג מדי פעם את תוכן מיקומי זיכרון מסוימים. ניתן היה ליזום עבודות באמצעות שגרות אלו. שגרות "פינבול" ביצעו את המקבילה הגולמית מאוד של מעטפת Unix .

רבים מאלגוריתמי המסלול וההנחיה ששימשו את ה-AGC, התבססו על עבודה מוקדמת יותר של ריצ'רד באטין (Richard Battin). חבילת תוכנה בשם קורונה (Corona), שאת פיתוחה הוביל אלכס קוסמלה (Alex Kosmala), פעלה בטיסת תא הפיקוד והשירות הראשונה (AS-202 ).

משימות אל הירח השתמשו בחבילת התוכנות "קולוסוס" (Colossus) עבור תא הפיקוד, שאת פיתוחה הוביל פרדריק מרטין (Frederic Martin), וב"לומינרי" (Luminary) עבור רכב הנחיתה הירחי, שפותחה בראשותו של ג'ורג' צ'רי (George Cherry). צוות בניהולה של מרגרט המילטון מימש את פִרטי תוכנות אלה. המילטון התעניינה מאוד כיצד האסטרונאוטים יתַקשרו עם התוכנה וחזתה את סוגי הטעויות שעלולות להתרחש עקב טעות אנוש. בסך הכל, פיתוח התוכנה בפרויקט כלל 1,400 שנות אדם של מאמץ, עם שיא כוח עבודה של 350 אנשים. בשנת 2016 קיבלה המילטון את מדליית החירות הנשיאותית על תפקידה בכתיבת תוכנת הטיסה.

תוכנת מחשב ההנחיה של החללית אפולו השפיעה על תכנון מערכות תחנת החלל סקיילאב, מעבורות החלל ומטוסי קרב שונים. בשנת 2003, החל רון בורקי לנסות לשחזר את קוד המקור שהפעיל את ה-AGC ולבנות אימולטור המסוגל להריץ אותו – VirtualAGC. חלק מהכמות הגדולה של קוד המקור שחולץ במאמץ זה, הועלה על ידי מתמחה לשעבר של נאס"א לאתר GitHub ב-7 ביולי 2016, ומשך תשומת לב תקשורתית משמעותית.

בלוק II 
גרסת בלוק II של ה-AGC תוכננה בשנת 1966. בבלוק II נשמרה הארכיטקטורה הבסיסית של בלוק I, אך כמות הזיכרון המחיק הוגדל מ-1,024 מילים ל-2,048 מילים (2 קילו-מילים). גם הזיכרון הקבוע הורחב – מ-24 קילו-מילים ל-36 קילו-מילים. מספר הפקודות עלה מ-11 ל-34 והוטמעו ערוצי קלט/פלט שהחליפו את אוגרי הקלט/פלט של בלוק I. גרסת בלוק II היא זו שטסה בפועל במשימות לירח. בלוק I שימש במהלך משימות אפולו 4 ו־6 הבלתי מאוישות, והיה על סיפונה של אפולו 1, שנשרפה.

להחלטה להרחיב את הזיכרון ואת סט הפקודות עבור בלוק II, אך לשמור על ההגבלה של שלוש סיביות לקוד ו־12 סיביות עבור הכתובת, היו השלכות תכנון מעניינות; נעשה שימוש בתחבולות שונות כדי לסחוט פקודות נוספות, כגון כתובות זיכרון מיוחדות יישמו פונקציה מסוימת כאשר ניגשו אליהן. לדוגמה, INDEX לכתובת 17 (בבסיס אוקטלי) הפעיל את פקודת RESUME שהורתה למעבד לחזור מפסיקה אל התוכנית הראשית. באופן דומה, TC 4 ביצע פקודת INHINT (מניעת פסיקות), בעוד TC 3 אִפשר מחדש את קבלתן (RELINT). לכל פעולה מסט הפקודות המורחב הוקדמה גרסה מיוחדת של TC בשם EXTEND.

בלוק II כולל גם את הפקודה EDRUPT (קיצור של Ed's Interrupt, על שם אד סמלי, המתכנת שביקש אותה). פקודה זו אינה יוצרת פסיקה, אלא מבצעת שתי פעולות המשותפות לעיבוד פסיקות; הפעולה הראשונה מונעת פסיקות נוספות (ודורשת פקודת RESUME כדי לאפשר אותן שוב). הפעולה השנייה מורה לאוגר ZRUPT לטעון לתוכו את הערך הנוכחי של מונה התוכנית (Z). פקודה זו שימשה רק פעם אחת בתוכנת ה־AGC, על מנת להפעיל את רצף סיום מחזור הטייס האוטומטי הדיגיטלי של רכב הנחיתה הירחי.

פרסום קוד המקור 
קוד המקור המקורי של מחשב ההנחיה של משימת אפולו 11 נגיש משנת 2003 על ידי ה־Virtual AGC Project ומוזיאון MIT. הוא תומלל ועבר דיגיטציה מרשימות קוד המקור המקוריות משנות ה-60. באמצע 2016, מתמחה לשעבר של נאס"א, כריס גארי, העלה את קוד המקור של AGC אל GitHub.

ראו גם 
 היסטוריה של המחשוב
 תוכנית אפולו
 תא הפיקוד והשירות של החללית אפולו

קישורים חיצוניים

הערות שוליים 

המכון הטכנולוגי של מסצ'וסטס
תוכנית אפולו
מחשבים חלוציים