Apollo Guidance Computer: Um Mergulho Profundo na Tecnologia que Conquistou a Lua

Pessoal,

Há alguns anos atrás eu falei sobre o programa espacial tripulado da NASA, focando nas missões Mercury, Gemini e Apollo (veja aqui).

Entretanto, todo blog de tecnologia que se preste tem que falar, em algum momento, do Apollo Guidance Computer. E hoje é dia da gente falar dele!

Apollo Guidance Computer: Um Mergulho Profundo na Tecnologia que Conquistou a Lua

O Apollo Guidance Computer (AGC) foi o coração digital das missões Apollo, que levaram o ser humano à Lua entre 1969 e 1972. Desenvolvido pelo MIT Instrumentation Laboratory, sob a liderança de Eldon C. Hall (hardware) e Margaret Hamilton (software), o AGC era um computador embarcado responsável por navegação, orientação e controle do Módulo de Comando (CM) e do Módulo Lunar (LM). 

Este post oferece uma análise técnica detalhada, explorando o hardware revolucionário, a programação em assembly, a interação via DSKY, os erros críticos 1201 e 1202, os easter eggs e comentários no código-fonte, e como experimentar o AGC com simuladores, porém ser ser excessivamente técnico. Afinal de contos, eu sou um entusiasta por informática e tecnologia, não um professor no assunto! As referências utilizadas no final do post para que, quem quiser, complete ou aprofunde no assunto.

Inovações Tecnológicas do AGC Comparadas à Época

Na década de 1960, os computadores eram máquinas massivas, como o IBM System/360 (usado em bancos e universidades) ou o CDC 6600 (para cálculos científicos), que ocupavam salas inteiras, consumiam kilowatts de energia e dependiam de válvulas ou transistores discretos. Operavam modo batch, processando tarefas sequencialmente, com interfaces rudimentares (cartões perfurados, fitas magnéticas), além de exigir toda uma equipe de manutenção.

IBM System/360

CDC 6600

Essas características tornavam inviáveis sua utilização no espaço. Então, como falaremos abaixo, a NASA precisou começar do zero!

Hardware do AGC: Uma Obra-Prima de Engenharia

O AGC, projetado para o espaço, enfrentava restrições únicas: tamanho reduzido, baixo consumo de energia, resistência a vibrações, radiação e temperaturas extremas. Suas inovações o tornaram um marco.

O AGC operava com apenas 55 W, ocupando 0,06 m³ e pesando 32 kg. Sua inovação começou com o uso pioneiro de circuitos integrados (ICs) da Fairchild Semiconductor, uma tecnologia então experimental, inventada por Jack Kilby em 1958. Cada chip, com portas lógicas NOR de 3 entradas, integrava seis transistores em 1 cm², permitindo que o AGC Block I usasse 4.100 ICs e o Block II, mais otimizado, apenas 2.800. Comparado ao IBM 7094, com 50.000 transistores soldados manualmente, o AGC era uma façanha de densidade e eficiência, consumindo 1% da energia de um mainframe típico. Essa aposta nos ICs, defendida pelo MIT contra a desconfiança inicial da NASA, acelerou sua adoção em setores como aviação e eletrônicos de consumo.

O famoso "dual NOR" do AGC Block II

Armazenamento de Dados e Informações

A construção do AGC exigia robustez extrema. Suas conexões usavam wire-wrap, uma técnica onde fios eram enrolados em pinos para contatos firmes, resistindo a vibrações do lançamento do Saturn V. O calor gerado, dissipado passivamente por um chassi de alumínio no vácuo espacial, era cuidadosamente gerenciado, já que ventiladores eram inviáveis. Testes de qualificação, realizados em câmaras de vácuo e acelerômetros, simulavam as condições do espaço, incluindo radiação ionizante e choques térmicos. Comparado a outros sistemas embarcados da época, como o computador do míssil Minuteman II, que também usava ICs mas exigia menos interatividade, o AGC era único por combinar navegação autônoma, controle em tempo real e interface com astronautas. Nenhum AGC falhou em missões Apollo, um testemunho de sua engenhosidade.

Wire Wrap!

No coração do AGC estava sua memória, dividida em duas tecnologias inovadoras. A core rope memory, uma ROM de 36.864 palavras de 16 bits (~72 KB), armazenava os programas Colossus (Módulo de Comando) e Luminary (Módulo Lunar).

Core Rope Memory!

Cada núcleo magnético codificava até 64 bits, com fios tecidos manualmente para representar 1 (passando pelo núcleo) ou 0 (desviando). Esse processo, realizado por trabalhadoras da Raytheon apelidadas de "Little Old Ladies", era tão meticuloso que um erro exigia meses para retrabalhar. Imune a radiação e quedas de energia, a core rope era ideal para o espaço, superando as fitas magnéticas dos mainframes em confiabilidade, embora sua natureza fixa tornasse atualizações lentas. Para dados dinâmicos, como coordenadas orbitais ou comandos, o AGC usava uma core memory de 2.048 palavras (~4 KB), com núcleos magnéticos magnetizados para 0 ou 1. Apesar de sua leitura destrutiva, que exigia reescrita, a RAM era rápida (11,7 µs por acesso) e protegida contra radiação por blindagem magnética. Comparada aos 144 KB de RAM do IBM 7094, a memória do AGC era minúscula, mas otimizada para eficiência, armazenando apenas os dados essenciais, como vetores de estado orbital ou ângulos de gimbal.

Programação do AGC: A Arte do Assembly

A maravilha do AGC não era apenas em hardware, mas também em software! O sistema operacional do AGC, criado por J. Halcombe Laning, introduziu a multitarefa em tempo real, algo inédito na década de 1960. Enquanto mainframes processavam jobs sequencialmente, o AGC alternava entre tarefas como cálculos de trajetória, controle de motores e interação com astronautas. O componente Exec gerenciava até oito tarefas, atribuindo prioridades de 1 a 7, garantindo que funções críticas, como o controle de pouso, fossem priorizadas. A Waitlist, por sua vez, lidava com interrupções curtas, como leituras de sensores a 100 Hz, acionadas por um temporizador de hardware. Ocupando apenas 5% da ROM, esse sistema era uma façanha de otimização, essencial para um ambiente onde milissegundos podiam ser decisivos. A arquitetura de 16 bits, com um acumulador, um program counter e um registrador Q, operava a 0,043 MHz, executando 40.000 instruções por segundo. Embora mais lenta que o IBM 7094, sua eficiência para tarefas específicas, como resolver equações keplerianas, minimizava overhead.

A programação do AGC era um exercício de precisão, escrita em linguagem de montagem (AGC assembly) para caber nos 72 KB de ROM e 4 KB de RAM. Com apenas 11 instruções nativas, os programadores criavam rotinas densas. Para comparação, um chip CISC atual (Complex Instruction Set Computer), como os x86/64 da Intel e AMD, podem ter milhares de instruções e os RISC (Reduced Instruction Set Computer), como os ARM de celular ou Apple Silicon, contêm centenas de instruções!

Um trecho do arquivo LUNAR_LANDING_GUIDANCE.agc mostra o programa de pouso lunar (P63):

TC     BANKCALL   # Chama subrotina em outro banco
CADR   P63GO      # Endereço do programa P63
CA     TIME1      # Carrega tempo atual
TS     MPAC       # Armazena no registrador multiuso
TCF    LOOP       # Volta ao loop principal

Outro exemplo, de NAVIGATION.agc, calcula a órbita:

CA     VELX      # Carrega velocidade X
AD     DELTAV    # Adiciona correção
TS     VELNEW    # Armazena nova velocidade

Essas rotinas, com instruções como ADD, TC e CAF, exigiam otimização extrema. Para cálculos complexos, o AGC usava um interpretador virtual, suportando aritmética de ponto flutuante, funções trigonométricas (seno, cosseno) e operações matriciais, essenciais para navegação. O interpretador, ocupando ~5 KB, compactava algoritmos que, sem ele, exigiriam centenas de instruções nativas. A memória era dividida em bancos de 8 KB, acessados por BANKCALL, superando o limite de 12 bits dos operandos. Comparado ao Fortran ou COBOL, linguagens de alto nível e com alto grau de abstração do hardware dos mainframes, o assembly oferecia controle total, mas exigia paciência e criatividade.

Margaret Hamilton liderou uma equipe de até 350 programadores, desenvolvendo práticas que moldaram a engenharia de software.

Margaret Hamilton ao lado de listas de códigos dos programas do AGC

Testes unitários verificavam cada subrotina, simulações replicavam voos reais, e revisões cruzadas minimizavam erros.

TS PRIORITY   # Define prioridade da tarefa
TCF EXEC      # Chama o Executive

O sistema de priorização (visto acima), crucial nos erros 1201/1202, descartava tarefas de baixa prioridade em sobrecargas, enquanto comentários detalhados, como # COMPUTE DELTA-V FOR BURN, explicavam a lógica. Um exemplo de comentário em P63.agc detalha o pouso:

# COMPUTE DELTA-V FOR BURN
# ITERATE UNTIL ERROR < 0.01 FT/SEC
# ADJUST THRUST VECTOR FOR LANDING

O desenvolvimento, custando US$150 milhões (~US$1 bilhão hoje), envolveu 1.400 pessoa-anos, com colaboração intensa entre programadores, engenheiros e astronautas, garantindo zero falhas em missões tripuladas. A pressão da corrida espacial, contra a URSS, exigia prazos apertados, mas a equipe do MIT, com muitos na faixa dos 20 anos, entregou um software impecável. É ou não uma façanha?

Interação dos Astronautas: O DSKY e o Sistema Verbo-Substantivo

Os astronautas interagiam com o AGC pelo DSKY (Display and Keyboard), uma interface compacta com teclado numérico, displays de 7 segmentos e luzes indicadoras, projetada para uso com luvas espaciais e vibrações.

 

Diagrama da interface do DSKY do Módulo Lunar

O sistema verbo-substantivo simplificava comandos em códigos de dois dígitos.

• Verbos definiam ações, como:

  • 06: Exibir dados no display.

  • 16: Monitorar dados continuamente.

  • 37: Selecionar um programa.

  • 21: Inserir dados manualmente.

  • 05: Acionar alarme visual.

• Substantivos especificavam dados, como:

  • 62: Velocidade, taxa de descida e altitude.

  • 18: Tempo até ignição (TIG).

  • 43: Latitude e longitude de referência.

  • 09: Código de alarme.

Alguns exemplos incluem:

• V06N62: Exibe velocidade (ex.: 1500 ft/s), taxa de descida (-70 ft/s) e altitude (5000 ft).

• V16N18: Monitora o tempo até a ignição (ex.: 45 segundos).

• V37N01: Seleciona o programa P01 (navegação orbital).

• V21N43: Insere latitude (+12345) e longitude (-54321).

• V05N09: Exibe códigos de alarme (ex.: 1202).

O teclado tinha:

• Teclas numéricas (0-9).

• VERB e NOUN para iniciar comandos.

• ENTER para confirmar.

• + e - para valores.

• CLEAR para corrigir erros.

• PRO (proceed) para avançar ou aceitar resultados.

• KEY REL (key release) para liberar o teclado.

O teclado, com teclas como VERB, NOUN, ENTER e PRO, era intuitivo após treinamento, apoiado por uma folha de referência plastificada. Astronautas treinavam por meses em simuladores no MIT e em Houston, dominando comandos como V06N62 para monitorar a descida, mas ainda assim tinham uma "cola" no painel para qualquer emergência:

Para a saída de resultados, três displays de 7 segmentos (R1, R2, R3) mostravam até 5 dígitos em octal ou decimal. Cada display tinha um sinal (+ ou -) e suportava números como +12345 ou -00789.

• Exemplo de saída para V06N62:

  • R1: 01500 (1500 ft/s, velocidade).

  • R2: -0070 (-70 ft/s, taxa de descida).

  • R3: 05000 (5000 ft, altitude).

Além disso, luzes indicadoras alertavam sobre estados:

• COMP ACTY: Computador processando.

• PROG: Alarme de programa (ex.: 1201/1202).

• UPLINK ACTY: Dados recebidos da Terra.

• NO ATT: Falta de dados de atitude.

• GIMBAL LOCK: Alinhamento inválido dos gimbais.

• TEMP: Superaquecimento (raro).

O DSKY, com displays verdes brilhantes e teclas robustas, é visível em close-ups e no painel do Módulo Lunar Eagle.

Comparado às interfaces do programa Gemini, que usavam mostradores analógicos, o DSKY era um salto digital, inspirando o Space Shuttle.

A robustez do AGC foi testada na Apollo 11, em 20 de julho de 1969, quando os erros 1201 e 1202 surgiram a 30.000 pés do solo lunar. Esses alarmes, indicando sobrecarga, foram causados pelo radar de rendezvous, ligado fora de fase com o sistema de energia do Módulo Lunar, gerava um "phase skew" que produzia dados inválidos e isso causava interrupções a cada 0,64 segundos. O erro 1201 sinalizava falta de espaço no Exec, e o 1202, na Waitlist, consumindo 15-20% do tempo de CPU. Buzz Aldrin, monitorando o DSKY, relatou: “Program Alarm. It’s a 1202”. Neil Armstrong, pilotando manualmente, manteve a descida, enquanto o Controle da Missão, liderado por Gene Kranz, avaliava. Jack Garman, com 24 anos, reconheceu os erros como gerenciáveis, usando uma folha de referência de alarmes. O sistema de priorização de Margaret Hamilton reiniciava o AGC em 2-3 segundos, descartando dados do radar e preservando cálculos críticos, retornando ao programa P63, de pouso, sem perda de contexto. A ordem “GO” permitiu o pouso com 30 segundos de combustível. Transcrições mostram a tensão:

102:38:25 ALDRIN: Program Alarm. 102:38:28 CAPCOM: It’s a 1202.

102:38:32 CAPCOM: We’re GO on that alarm.

102:38:42 ALDRIN: 1201.

102:38:44 CAPCOM: 1201 alarm. We’re GO.

A equipe de suporte, incluindo Steve Bales, foi premiada por sua resposta rápida. Após a Apollo 11, a NASA revisou os procedimentos do radar, aplicando lições em missões como a Apollo 12, onde verificações extras evitaram erros semelhantes.

Easter Eggs e Comentários no Código-Fonte

O código-fonte do AGC, disponível no GitHub (aqui) e Virtual AGC (aqui), revela a criatividade da equipe.

Easter eggs incluem “BURN, BABY, BURN!” em BURN_BABY_BURN--MASTER_IGNITION_ROUTINE.agc, celebrando a ignição do motor, e “PINBALL” em PINBALL_GAME_BUTTONS_AND_LIGHTS.agc, comparando o DSKY a um arcade. Referências mitológicas, como “LATONA”, aparecem em rotinas de navegação, enquanto erros de digitação, como “WTIH” por “WITH”, adicionam charme. Comentários humorísticos refletem a pressão:

• “TEMPORARY, I HOPE HOPE HOPE” (EXECUTIVE.agc): Uma solução improvisada.

• “THIS BETTER WORK OR WE’RE ALL IN TROUBLE” (LUNAR_LANDING_GUIDANCE.agc): Sobre o pouso.

• “WHO WROTE THIS MESS?” (INTERPRETER.agc): Autocrítica.

Por Que o AGC Era Inovador e Adequado?

Comparado a dispositivos modernos, o AGC era muito, muito limitado. Seus 4 KB de RAM e 72 KB de ROM contrastam com os 8 GB de RAM e 512 GB de armazenamento de um iPhone 15. Operando a 0,043 MHz, executava 40.000 instruções por segundo, contra bilhões a 3,4 GHz, 100.000 vezes mais rápido. O DSKY, com displays de 7 segmentos, lembra um terminal Linux, enquanto smartphones têm telas OLED. Contudo, o AGC era robusto e funcional, resistindo a radiação e lidando com erros como o 1202. Sua latência de 11,7 µs para RAM era competitiva para a época, e sua eficiência inspirou sistemas embarcados modernos, como os de satélites e drones [14].

O AGC era ideal por sua eficiência e confiabilidade. Cada byte era usado com precisão, e zero falhas em missões Apollo comprovam sua robustez. Inovações como ICs, multitarefa em tempo real e engenharia de software moldaram tecnologias futuras.

Simulador do AGC: Revivendo a História

Simuladores permitem reviver essa história:

• Moonjs (aqui): Executa Colossus 249 no navegador

• Virtual AGC (aqui). Que permite emular o AGC das missões Apollo (8 a 17) e Gemini. 

O código-fonte, com 2 MB, é um legado aberto . Arquivos como LUNAR_LANDING_GUIDANCE.agc mostram a lógica do pouso, e o assembler yaYUL permite modificações. O Apollo Guidance Computer combina inovação e humanidade, com erros 1201/1202 e easter eggs como “BURN, BABY, BURN!”.

Bom, por enquanto é isso!

Até o próximo post, pessoal!

Fontes:

1. Wikipedia. "Apollo Guidance Computer." https://en.wikipedia.org/wiki/Apollo_Guidance_Computer

2. GitHub. "Apollo-11: Original Apollo 11 Guidance Computer (AGC) source code." https://github.com/chrislgarry/Apollo-11

3. NASA. "Apollo 11 Lunar Surface Journal." https://www.nasa.gov/history/alsj/a11/a11.html

4. Museu Capixaba. "Hoje: Computador Apollo Guidance Computer (AGC) de 1968." https://museucapixaba.com.br/hoje/computador-apollo-guidance-computer-agc-de-1968/

5. IEEE Computer. "The Apollo Guidance Computer: A Review." https://csdl-downloads.ieeecomputer.org/mags/mi/2021/06/09623432.pdf

6. YouTube. "Apollo Guidance Computer - How it Worked?" by CuriousMarc. https://www.youtube.com/watch?v=ge6zfKaMfAQ

7. YouTube. "Apollo DSKY: The Human Interface to the Moon" by David Woods. https://www.youtube.com/watch?v=B1J2RMorJXM

8. ABC News. "Apollo 11's Source Code Has Tons of Easter Eggs." https://abcnews.go.com/Technology/apollo-11s-source-code-tons-easter-eggs-including/story?id=40515222

9. Viva o Linux. "Código Fonte Original da Missão Apollo 11." https://www.vivaolinux.com.br/dica/Codigo-Fonte-Original-da-Missao-Apollo-11

10. Space Today. "O Código que Levou a Apollo 11 para a Lua é Disponibilizado para Acesso Público." https://spacetoday.com.br/o-codigo-que-levou-a-apollo-11-para-a-lua-e-disponibilizado-para-acesso-publico/

11. Diolinux. "Código Fonte da Apollo 11 Disponível no GitHub para Download." https://diolinux.com.br/open-source/codigo-fonte-apollo-11-github-download.html

12. Virtual AGC Project. "Apollo Guidance Computer Documentation and Software." https://www.ibiblio.org/apollo/

13. GitHub. "Virtual AGC: Apollo Guidance Computer Emulator." https://github.com/virtualagc/virtualagc