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

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

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

פעולה
-----

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

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

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

תכנון
-----

תצלום של שבב שער NOR כפול ששימש לבניית בלוק II של מחשב ההנחיה של החללית אפולו. חיבורים הם (בכיוון השעון מהמרכז למעלה): הארקה, כניסות (3), פלט, מתח, פלט, כניסות (3)
סכימה של שער NOR כפול בעל 3 כניסות. משערים כאלה נבנה ה־AGC
מעגלים משולבים מסיליקון במחשב ההנחיה של החללית אפולו
ה-AGC תוכנן במעבדת צ'ארלס סטארק דרייפר על ידי צ'ארלס סטארק דרייפר. את תכנון החומרה הוביל אלדון סי הול (Eldon C. Hall).

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

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

בגרסת בלוק I היו 4,100 מעגלים משולבים, שכל אחד מהם הכיל שער NOR יחיד בעל שלוש כניסות. בגרסה המאוחרת יותר, בלוק II (שבה השתמשו בטיסות המאוישות), היו כ-2,800 מעגלים משולבים, בעיקר שערי NOR כפולים עם שלוש כניסות בכל אחד ומספר קטן יותר של מַרחֵבים (expanders) ומגברי חישה.  המעגלים המשולבים, מבית פיירצ'יילד סמיקונדקטור (Fairchild Semiconductor), יושמו בלוגיקת נגד-טרנזיסטור (RTL) במארז שטוח (אנ'). הם חוברו באמצעות עיטוף חוטים. לאחר מכן, קובע החיווט באמצעות פלסטיק אפוקסי יצוק. השימוש בסוג יחיד של מעגלים משולבים (שער NOR כפול בעל 3 כניסות) בכל ה-AGC, מנע בעיות בתכנון שנוצרו במחשבים מוקדמים אחרים, כמו מחשב ההנחיה של הטיל הבליסטי מיניטמן II (D-37C), ששילב לוגיקת דיודה-טרנזיסטור (DTL) ושערי לוגיקת דיודות (Diode logic).[דרוש מקור] בניית כל המחשב מסוג מעגל משולב יחיד התאפשר משום ששערי NOR הם שערים לוגיים אוניברסליים שמהם ניתן ליצור כל שער אחר (מערכת פעולות שלמה), אם כי במחיר של שימוש בשערים נוספים.

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

### ממשק ה-DSKY

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

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

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

### תזמון

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

תדר האב חולק עוד יותר באמצעות סקלר (*scaler*), תחילה בחמישה באמצעות מונה טבעתי (Ring counter) להפקת אות של 102.4 קילו-הרץ. אות זה חולק בשניים עוד 17 פעמים. כל התדרים שנגזרו מהאות של 102.4 קילו-הרץ נקראו בשמות 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.

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

אבות טיפוס של ה־DSKY וה־AGC מוצגים במוזיאון היסטוריית המחשב שבארצות הברית. ה-AGC פתוח, כך שהמודולים הלוגיים שלו חשופים לעין
מבד האוגרים הראשיים, היו ל-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` (פקודות מורחבות). חמש עשרה הפקודות הבסיסיות הופעלו ישירות על ידי קוד הפעולה. תשע עשרה הפקודות המורחבות הופעלו על ידי ביצוע פקודת `EXTEND` (שקודדה כפקודת `TC` מיוחדת – `TC 6`) לפני הפקודה.

הפקודות של בלוק 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. אם דגל הגלישה מונף, אז הגלישה מתוקנת על ידי אחסון הסיבית השמאלית ביותר מבין 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 לוגי דרך אפיק הנתונים, ולאחר מכן הופכים את התוצאה.

### תוכנה

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

עקרונות התכנון שפותחו עבור ה-AGC ב-MIT אינסטרומנטיישן לברטורי, בהנחייתו של צ'ארלס דרייפר בסוף שנות ה-60, הפכו לבסיס להנדסת תוכנה בימינו, במיוחד בשל תכנון מערכות אמינות המבוססות על תוכנה אסינכרונית, תזמון עדיפות, בדיקות ויכולת החלטה אנושית בלולאה (Human-in-the-loop). כאשר הוגדרו דרישות התכנון של ה-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 (Unix shell).

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

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

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

הבדלים בין בלוק I לבלוק 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`). לכל פעולה מסט הפקודות המורחב הוקדמה פקודת `EXTEND`, גרסה מיוחדת של `TC` ‏(`TC 6`).

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

פרסום קוד המקור
---------------

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

ראו גם
------

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

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

ויקישיתוף מדיה וקבצים בנושא **מחשב ההנחיה של החללית אפולו** בוויקישיתוף

הערות שוליים
------------

1. ↑  Interbartolo, Michael (בינואר 2009). "Apollo Guidance, Navigation and Control Hardware Overview" (PDF). `{{cite web}}`:  (עזרה)
2. ↑  The Apollo guidance computer: Hardware
3. ↑  "How did the Apollo flight computers get men to the moon and back ?". 11 במרץ 2017. `{{cite web}}`:  (עזרה)
4. ↑  Hall, Eldon C. (1996), *Journey to the Moon: The History of the Apollo Guidance Computer*, Reston, Virginia, USA: AIAA, p. 196, ISBN 1-56347-185-X
5. ↑  "Ramon Alonso's introduction", *AGC History Project (Caltech archive, original site closed)*, MIT, 27 ביולי 2001, נבדק ב-2009-08-30 `{{citation}}`:  (עזרה)
6. ↑  "Ramon Alonso's interview (Spanish)", *Ramón Alonso, el argentino que llevó a la Apollo 11 a la Luna*, Diario La Nacion, 7 במרץ 2010 `{{citation}}`:  (עזרה)
7. ↑  "Hugh Blair-Smith biography", *AGC History Project (Caltech archive, original site closed)*, MIT, בינואר 2002, נבדק ב-2009-08-30 `{{citation}}`:  (עזרה)
8. ↑  "Herb Thaler introduction", *AGC History Project (Caltech archive, original site closed)*, MIT, 14 בספטמבר 2001, נבדק ב-2009-08-30 `{{citation}}`:  (עזרה)
9. ↑  Butrica, Andrew J. (2015). "Chapter 3: NASA's Role in the Manufacture of Integrated Circuits". In Dick, Steven J. (ed.). *Historical Studies in the Societal Impact of Spaceflight* (PDF). NASA. pp. 149–250. ISBN 978-1-62683-027-1.
10. ↑  "Apollo Guidance Computer and the First Silicon Chips". *National Air and Space Museum*. Smithsonian Institution. 14 באוקטובר 2015. נבדק ב-1 בספטמבר 2019. `{{cite web}}`:  (עזרה)
11. 1 2 3 4 5  Hall, Eldon C. (1972). *MIT's Role in Project Apollo: Final report on contracts NAS 9-163 and NAS 94065* (PDF). Cambridge, MA: MIT. נבדק ב-15 ביוני 2021. `{{cite book}}`:  (עזרה)
12. ↑  Peirce, C. S. (manuscript winter of 1880–81), "A Boolian Algebra with One Constant", published 1933 in *Collected Papers* v. 4, paragraphs 12–20.
13. ↑  "Apollo DSKY panel relight: The full story". *YouTube*.
14. ↑  קוד הפקודה של כל אחת מפקודות המפרש היה באורך של 7 סיביות; בכל מילה מהזיכרון, שאורכה 16 סיביות, אוחסנו שתי פקודות למפרש. כדי לחלץ את קוד הפעולה השני ממילת הזיכרון (להביא את הקוד לתחילת המילה), היו כותבים אותה אל מיקום 23 וקוד הפעולה השני היה מועבר 7 סיביות ימינה – לתחילת המילה.
15. ↑  מכיוון שה-AGC השתמש בשיטת המשלים ל-1 כדי לייצג מספרים, יש שני ייצוגים של אפס: **פלוס אפס** כאשר כל הסיביות הן אפס, ו**מינוס אפס** אם כל הסיביות הן אחד.
16. ↑  Mindell 2008, pp. 154, 157.
17. ↑  NASA Press Release "NASA Honors Apollo Engineer" (September 03, 2003)
18. 1 2 3  Hoag, David (בספטמבר 1976). "The History of Apollo On-board Guidance, Navigation, and Control" (PDF). Charles Stark Draper Laboratory. `{{cite web}}`:  (עזרה)
19. 1 2  Mindell 2008, p. 149.
20. ↑  Fong, Kevin (2019). "13 minutes to the moon: Episode 5 The fourth astronaut". *bbc.co.uk*. BBC World Service.
21. 1 2  Harvey IV, Harry Gould (13 באוקטובר 2015). "Her Code Got Humans on the Moon—And Invented Software Itself". *WIRED* (באנגלית אמריקאית). נבדק ב-2018-11-25. `{{cite journal}}`:  (עזרה)
22. ↑  NASA Office of Logic Design "About Margaret Hamilton" (Last Revised: February 03, 2010)
23. ↑  By *A.J.S. Rayl* "NASA Engineers and Scientists-Transforming Dreams Into Reality"
24. ↑  Burkey, Ron. "VirtualAGC". *iBiblio*. נבדק ב-10 באפריל 2021. `{{cite web}}`:  (עזרה)
25. ↑  "AGC source code collection on Github, maintained by iBiblio". *GitHub*. אורכב מ-המקור ב-7 במאי 2021. `{{cite web}}`:  (עזרה)
26. ↑  Collins, Keith. "The code that took America to the moon was just published to GitHub, and it's like a 1960s time capsule". *Quartz*. נבדק ב-19 באוגוסט 2016. `{{cite web}}`:  (עזרה)
27. ↑  Garry, Chris. "Original Apollo 11 Guidance Computer (AGC) source code for the command and lunar modules". *GitHub*. אורכב מ-המקור ב-12 באפריל 2021. `{{cite web}}`:  (עזרה)
28. ↑  O'Brien, Frank (2010-06-25). *The Apollo Guidance Computer: Architecture and Operation* (באנגלית). Springer Science & Business Media. ISBN 978-1-4419-0877-3.
29. ↑  "Archiving and referencing the Apollo source code". *www.softwareheritage.org* (באנגלית אמריקאית). נבדק ב-2021-09-09.
30. ↑  "Virtual AGC Home Page". *ibiblio.org*. נבדק ב-2021-09-09.
31. ↑  "GitHub - chrislgarry/Apollo-11: Original Apollo 11 Guidance Computer (AGC) source code for the command and lunar modules". *GitHub* (באנגלית). נבדק ב-2021-09-09.
32. ↑  "Apollo 11's source code is now on GitHub". *Engadget* (באנגלית אמריקאית). נבדק ב-2021-09-09.