O software por trás da Voyager 1

Autoria: Better Stack · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: The Software Behind Voyager 1 · Canal: Better Stack · 01:31 · Assistir no YouTube

Tópicos: Dados, bancos de dados e embeddings, Engenharia de software com IA, Infraestrutura e hardware de IA, Robótica e sistemas autônomos

Resumo

Em novembro de 2023, os dados enviados pela Voyager 1 passaram a chegar como padrões repetidos de zeros e uns, embora a sonda ainda recebesse e executasse comandos. A equipe identificou uma falha no computador de dados: um chip havia morrido e corrompido cerca de 3% da memória. Como não era possível substituir o chip a 15 bilhões de milhas de distância, os engenheiros dividiram o código afetado entre espaços livres menores e atualizaram manualmente os pontos que o chamavam. Em abril de 2024, enviaram a correção em binário, e os dados voltaram a ser legíveis dois dias depois.

Pontos-chave

Em 14 de novembro de 2023, os dados da Voyager 1 deixaram de fazer sentido e passaram a exibir padrões repetidos de zeros e uns.
A falha estava no computador de dados, que reúne e envia as informações da sonda.
Um comando enviado em março de 2024 fez o computador transmitir uma cópia de toda a sua memória.
A equipe descobriu que um chip havia morrido, corrompendo cerca de 3% da memória.
O chip defeituoso afetava um bit de cada uma de 256 palavras de memória consecutivas.
Como não havia um espaço livre grande o bastante, o código foi dividido em partes e distribuído por lacunas menores.
A equipe atualizou manualmente todos os pontos do programa que chamavam o código movido.
Sem um assembler, os engenheiros converteram cada alteração em binário à mão.
Os dados de engenharia da sonda voltaram a ser legíveis dois dias após o envio da correção, em abril de 2024.

Capítulos

Início	Capítulo	Resumo
00:00	Os dados da Voyager 1 deixam de fazer sentido	A sonda continua recebendo comandos, mas o computador de dados envia padrões repetidos de zeros e uns.
00:30	A equipe identifica o chip defeituoso	Uma cópia da memória revela que um chip morreu e corrompeu parte da memória do computador.
01:01	Correção do código em binário	Os engenheiros dividem o código entre espaços menores, atualizam suas referências à mão e restauram a leitura dos dados.

Citações

O que voltava eram apenas padrões repetidos de uns e zeros. — 00:00

Um único chip havia morrido, e cerca de 3% da memória do computador estava completamente corrompida. — 00:30

A equipe dividiu o código em partes e colocou cada uma em qualquer pequena lacuna que conseguiu encontrar. — 01:01

Eles traduziram cada alteração para binário à mão. — 01:01

Dois dias depois, os dados voltaram legíveis pela primeira vez em cinco meses. — 01:31

Conceitos e entidades

Voyager 1 (conceito): Sonda espacial cujos dados deixaram de ser legíveis após uma falha em seu computador de dados.
Deep Space Network (ferramenta): Rede de grandes antenas terrestres que se comunica com sondas espaciais como a Voyager.
NASA (empresa): Agência associada à equipe e à rede que mantém comunicação com a Voyager 1.
assembler (ferramenta): Programa que a equipe não tinha disponível para converter as alterações de código em instruções de máquina.

Tradução completa (pt-BR)

00:00 Em 14 de novembro de 2023, os dados que voltavam da Voyager 1 pararam completamente de fazer sentido. A espaçonave ainda recebia comandos e os executava, mas o que voltava eram apenas padrões repetidos de uns e zeros. A falha estava no computador de dados, que empacota tudo e envia de volta. A equipe conseguia se comunicar com a Voyager, mas não conseguia ler nada do que ela enviava. Em março de 2024, enviaram um comando que chamam de cutucão, que fez o computador de dados executar partes diferentes de seu software. Dois dias depois, o sinal mudou. Um engenheiro da Deep

00:30 Space Network da NASA, que administra as grandes antenas na Terra que se comunicam com espaçonaves como a Voyager, descobriu que o novo sinal era um despejo de toda a memória do computador de dados: o código e todas as suas variáveis. A equipe comparou esse despejo com outro feito antes do início do problema e, em abril, encontrou a causa. Um único chip tinha pifado, e cerca de 3% da memória do computador estava completamente corrompida. Então, como diabos você conserta um chip pifado a 15 bilhões de milhas de distância? Bem, não dá para substituí-lo, então você simplesmente para de usá-lo. A memória do computador é dividida em espaços chamados palavras, e cada

01:01 palavra tem 16 bits. O chip quebrado continha um bit de cada uma das 256 palavras em sequência. Então, quando ele pifou, todas aquelas palavras ficaram com um bit defeituoso, e o código armazenado nelas era um conjunto de rotinas chamadas de várias partes do restante do programa. A solução foi mover o código para outro lugar, mas não havia um único espaço livre grande o bastante para acomodar todas as 256 palavras. Então, a equipe dividiu o código em partes, colocou cada parte em qualquer espaço pequeno que conseguiu encontrar e, depois, atualizou todos os pontos do programa que o chamavam. Eles tiveram que fazer isso sem um assembler. Então,

01:31 traduziram cada alteração para binário manualmente. Em 18 de abril de 2024, enviaram o código que empacota os dados de engenharia, as leituras de saúde da própria espaçonave. Dois dias depois, esses dados voltaram legíveis pela primeira vez em cinco meses.

Transcrição original

[00:00] On the 14th of November 2023, the data coming back from Voyager 1 stopped making sense at all. The spacecraft was still receiving commands and carrying them out, but what came back was just repeating patterns of ones and zeros. Fault was in the data computer that packs everything up and sends it home. The team could talk to Voyager, but they couldn’t read anything and send it back. In March 2024, they sent a command they call a poke, which nudged the data computer into running different parts of its software. 2 days later, the signal changed. An engineer at NASA’s Deep

[00:30] Space Network, which manages the big dishes on Earth that talk to spacecrafts like Voyager, worked out that the new signal was a dump of the data computer’s entire memory, the code and all of its variables. The team compared it with a dump from before the problem started, and in April, they found the cause. A single chip had died, and about 3% of the computer’s memory was completely corrupted. So, how the hell do you fix a dead chip from 15 billion miles away? Well, you can’t replace it, so you just stop using it. The computer’s memory is split into slots called words, and each

[01:01] word is 16 bits. The broken chip held one bit from each of the 256 words in a row. So, when it died, every one of those words had a bad bit, and the code stored in those words was a set of routines that got called from all over the rest of the program. The fix was to move the code somewhere else, but there wasn’t a single free gap big enough to hold all 256 words. So, the team split the code into pieces, put each piece in whatever small gap they could find, and then updated every place in the program that called it. They had to do this without an assembler. So, they

[01:31] translated every change into binary by hand. On the 18th of April 2024, they sent up the code that packs the engineering data, the health readings from the spacecraft itself. 2 days later, that data came back readable for the first time in 5 months.