Você já lidou com o endurecimento do espaço?

Estou muito ansioso para estudar as melhores práticas quando se trata de proteção do espaço. Por exemplo, eu li (embora não consiga mais encontrar o artigo) que algumas partes principais dos rovers de Marte não usavam alocação dinâmica de memória, na verdade era proibido. Também li que a memória antiga do núcleo pode ser preferível no espaço.

Eu estava olhando para alguns dos projetos associados ao Desafio Lunar do Google e imaginando como seria obter código na Lua ou mesmo no espaço. Sei que as placas reforçadas com espaço oferecem alguma sanidade em um ambiente tão severo, mas estou me perguntando (como programador C) como precisaria ajustar meu pensamento e código se estivesse escrevendo algo que funcionaria no espaço?

Eu acho que os próximos anos podem mostrar mais crescimento nas empresas de espaço privado, eu realmente gostaria de pelo menos ter um pouco de conhecimento sobre as melhores práticas.

O que acontece com um programa se a radiação, o frio ou o calor bombardearem uma placa que sofreu danos ao seu isolamento? Eu acho que o objetivo é manter os humanos dentro de uma nave espacial (tanto quanto consertar ou trocar coisas) e evitar missões para consertar as coisas.

Além disso, se o conselho mantiver algum sistema crítico, os alertas iniciais parecerão fundamentais.

Como alguém ganha experiência nisso por meio de testes, tentativa e erro (exceto o lançamento de seu próprio satélite pessoal?)

Software espacial não é mágica arcana. Você ainda está usando zeros e zeros, não zeros e zeros. Portanto, provavelmente não há um fator uau envolvido na descrição do que é necessário para o desenvolvimento de software.

Algumas pequenas diferenças que vêm à mente no momento são:

• Extremamente orientado a processos.
• O software espacial sempre terá temporizadores de controle de software e hardware.
• Todo sistema espacial em que trabalhei era um sistema rígido em tempo real.
• Você simula (com grande precisão) todos os atores externos do sistema. Isso geralmente envolve a construção (às vezes muito caro) de hardware personalizado usado apenas para teste.
• Você gasta enorme esforço e despesa fazendo testes formais.
• O cliente (geralmente JPL) está extremamente envolvido no processo de teste.
• Você geralmente usa compiladores e ambientes de desenvolvimento antigos e conhecidos, em vez dos novos.
• Revisões de código, revisões de código e revisões de código.
• É melhor você ficar muito confortável alternando entre os mundos de hardware e software. Você não precisa saber como projetar o hardware, mas precisa saber como ele funciona.
• Uso extensivo de equipamentos de teste, como osciloscópios, analisadores lógicos, sintetizadores e analisadores de espectro.
• Pelo menos três locais para armazenar o programa aplicativo. O padrão é gravado na ROM. Isso nunca vai mudar. Os outros 2 são para a versão atual e a próxima / última versão.
• A análise de falhas (MTBF) é realmente importante.
• Sistemas redundantes e planos de failover para os componentes críticos.

Eu apenas tropecei em sua pergunta interessante.

Eu estava no Instrumentation Lab durante a Apollo, e mais tarde quando foi chamado Draper Lab durante a "guerra fria".

Para o computador de orientação Apollo, o núcleo foi usado para a RAM e um núcleo trançado especial para a ROM. A própria máquina foi feita inteiramente de portas NOR e teve um clock bastante lento, por confiabilidade.

Não trabalhei diretamente com mísseis Minuteman, mas estava ciente de alguns dos problemas. Se uma ogiva nuclear dispara na vizinhança de alguns eletrônicos, ela basicamente fica em curto. O computador de orientação possuía um sensor de radiação que desligaria instantaneamente o Vc para que nada queimasse. Então o computador reiniciaria, tendo seus registros apagados.

Para lidar com isso, o computador periodicamente capturava seus registros no núcleo e, quando reiniciado, iniciava a partir desse ponto de verificação. Para fazer isso funcionar, o software (todos no ASM) precisou ser analisado para ver se era possível receber um número grande de ocorrências, em qualquer frequência, sem obter respostas erradas. Isso foi chamado de "reinicialização protegida". Problema muito interessante, já que (graças a Deus) ele nunca teve que ser usado.

Para obter confiabilidade de ambiente difícil especificamente em C, aqui estão algumas coisas realmente concretas que eu já vi fazer.

MISRA-C: O subconjunto Automotive C. Um pouco como Ravenscar ADA / Java.

cães de guarda: verifique se o programa não trava

memória ecc (às vezes)

somas de verificação: procurando bits de inversão. Eu já vi todos esses três em um sistema:

1) soma de verificação do programa continuamente (estava na EPROM, mas ainda recebia bits invertidos).

2) soma de verificação de determinadas estruturas de dados periodicamente.

3) A integridade da CPU verifica periodicamente.

4) verifique se os registros de E / S têm o que deveriam ter neles.

4b) leia novamente as saídas em entradas independentes e verifique.

Muito mais importantes que a linguagem de programação são os requisitos no sistema subjacente (SO e Hardware). Basicamente, você precisa garantir (e provar) o comportamento determinístico e previsível de todo o sistema. Muitas pesquisas relacionadas foram feitas na comunidade em tempo real. Eu recomendo fortemente a leitura de dois livros se você realmente quer estudar este assunto: sistemas de tempo real por Jane Liu e um livro com o mesmo nome por Hermann Kopetz . O primeiro abrange a programação de uma maneira muito teórica, enquanto o último coloca os pés no chão e praticamente cobre todos os aspectos relacionados ao design do sistema (em tempo real), por exemplo, tolerância a falhas.

Além disso, os dois incidentes a seguir ilustram bem a qualidade dos problemas que os engenheiros de software precisam enfrentar ao enviar algo para o espaço:

• Ariane 5 (Reutilização de software comprovado sob diferentes restrições)
• Mars Rover Pathfinder Reboot (inversão de prioridade)

Encontrei este documento (por volta de 2009) para o JPL Institutional Coding Standard para a Linguagem de Programação C no Laboratório de Software Confiável (LaRS) no site do Jet Propulsion Laboratory .

Aqui está um resumo das regras documentadas:

1. Conformidade de idioma

   • Não se desvie para fora da definição de idioma.
   • Compile com todos os avisos ativados; use analisadores estáticos de código-fonte.

2. Execução Previsível

   • Use limites de loop verificáveis ​​para todos os loops que devem terminar.
   • Não use recursão direta ou indireta.
   • Não use alocação de memória dinâmica após a inicialização da tarefa.
   • * Use mensagens IPC para comunicação de tarefas.
   • Não use atrasos nas tarefas para sincronização de tarefas.
   • * Transferir explicitamente permissão de gravação (propriedade) para objetos de dados compartilhados.
   • Coloque restrições ao uso de semáforos e bloqueios.
   • Use proteção de memória, margens de segurança, padrões de barreira.
   • Não use goto, setjmp ou longjmp.
   • Não use atribuições de valor seletivo para elementos de uma lista de enumerações.

3. Codificação defensiva

   • Declarar objetos de dados no menor nível possível de escopo.
   • Verifique o valor de retorno das funções não nulas, ou faça a conversão explicitamente para (nula).
   • Verifique a validade dos valores passados ​​para as funções.
   • Use asserções estáticas e dinâmicas como verificações de sanidade.
   • * Use U32, I16, etc, em vez de tipos de dados C predefinidos, como int, short etc.
   • Torne explícita a ordem da avaliação em expressões compostas.
   • Não use expressões com efeitos colaterais.

4. Code Clarity

   • Faça apenas um uso muito limitado do pré-processador C.
   • Não defina macros dentro de uma função ou bloco.
   • Não indefinir ou redefinir macros.
   • Coloque #else, #elif e #endif no mesmo arquivo que o #if ou #ifdef correspondente.
   • * Coloque não mais que uma declaração ou declaração por linha de texto.
   • * Use funções curtas com um número limitado de parâmetros.
   • * Não use mais do que dois níveis de indireção por declaração.
   • * Não use mais do que dois níveis de desreferenciamento por referência de objeto.
   • * Não oculte operações de desreferência dentro de macros ou typedefs.
   • * Não use ponteiros de função não constantes.
   • Não coloque ponteiros de função em outros tipos.
   • Não coloque código ou declarações antes de uma diretiva #include.

*) Todas as regras são deve regras, exceto aqueles marcados com um asterisco.

Os sistemas de computação à prova de espaço têm a ver com confiabilidade. Uma introdução profunda ao campo pode ser encontrada nos conceitos fundamentais de confiabilidade de Algirdas Avižienis, Jean-Claude Laprie e Brian Randell.

O tempo real também é um conceito-chave para a computação espacial. Como Pankrat, eu recomendaria os sistemas em tempo real da Hermann Kopetz.

Para dar uma idéia pragmática dos desafios da computação espacial, pense em:

• condições extremas no espaço: muito quente quando orientado ao sol, muito frio do outro lado, muitos raios cósmicos que podem inverter bits de memória, enormes acelerações e vibrações ao ser lançado, ... O hardware do espaço deve ser muito mais robusto do que o hardware para militares.

• Quando ocorre uma falha, exceto na Estação Espacial Internacional ou no Telescópio Espacial Hubble, ninguém vem e substitui o sistema com falha. Tudo deve ser corrigido do solo através da máxima observabilidade e capacidade de comando e de sistemas sobressalentes para os quais mudar. Isso é fácil para os satélites da Terra. Isso é mais difícil com sondas espaciais para as quais os atrasos na comunicação podem durar uma hora. De fato, tudo deve ser o mais confiável possível em primeiro lugar.

O que aprendi com o único projeto em que estive envolvido:

Suas especificações de hardware mudarão, geralmente para pior!

Por exemplo, a CPU com proteção de espaço que estava sendo usada no design foi prometida, prometida , lembre-se de que seria executada a 20 MHz.

O resultado final foi executado em 12 MHz. O programador sênior do projeto gastou muito tempo redesenhando algoritmos para atender aos rígidos requisitos em tempo real dos sistemas de controle e grande parte do software de telemetria foi transferido para um segundo sistema em vez de ser executado na CPU principal.

Portanto, tente deixar alguns recursos extras disponíveis no design original e tente não usar toda a CPU e memória disponíveis.

Para uma perspectiva de software, escreva uma tarefa privilegiada que ocasionalmente, aleatoriamente, inverta bits no seu código e veja como ele lida com isso. Esse é o seu simulador.

Em termos de hardware, as peças serão antigas, porque leva muito tempo para que algo seja classificado no espaço. Além disso, as novas peças diminuem continuamente de tamanho e, quanto menor o recurso (pense na célula de memória de um CI), mais suscetível é a corrupção de um evento de radiação.

Eu trabalhei em um dispositivo crítico de segurança e tivemos que passar por alguns processos semelhantes.

Tivemos variáveis ​​críticas de segurança. Havia uma cópia do inverso da variável. Após cada loop, a variável foi verificada em relação à sua inversa.

Tivemos um teste de caminhada e zeros de TODOS os registros. Isso incluiu o contador de programas!

Fizemos um teste de todos os códigos de operação do conjunto de micro instruções. Tínhamos que ter certeza de que, se você adicionou 2 registros, eles foram adicionados.

Parte disso provavelmente não está relacionada a programas no espaço, mas fornece uma noção da magnitude da verificação possível.

Acredito que quanto pior um ambiente, mais códigos de correção de erros são usados ​​e há memórias de ECC que podem ser usadas até certo ponto.

Se alguém pode estimar o nível de erros, pode construir um código de correção de erros que possa lidar com os erros introduzidos.

• Sim, a memória principal está nos conselhos de pesquisa.
• A memória dinâmica não é boa para sistemas incorporados. Problemas de confiabilidade.

Eu diria que o software ECC de dados e o uso da teoria da informação e um codificador personalizado para espalhar os dados pelo sistema para gerenciar as falhas de memória seriam um começo. Porém, eu não estudo software rad-hard, então não estou familiarizado com isso, isso é apenas um palpite.