Experiment Concept

DoomSat uses a well-understood computational benchmark, the game Doom, to measure adaptive optimization in orbit. Radiation levels are measured during flight, and mutation behavior within the Genetic Algorithm is influenced by real-time radiation conditions” -> “DoomSat uses DOOM™ as a computational benchmark to measure genetic algorithm performance as the spacecraft experiences damaging radiation

Rather than treating radiation as a disturbance to correct, the system incorporates it as a source of variability, enabling continuous improvement in performance over time.” -> “Radiation is treated as a useful source of variability instead of an error to correct, increasing the rate of beneficial spacecraft adaptation.

This approach provides:

  • A repeatable performance metric

  • A complex but widely useful computational solution

  • Measurable improvement over time under environmental stress

How It WOrks

Space Is Radioactive

Stars across the universe blast protons, electrons, photons, and heavy ions in every direction. Earth’s magnetic field shields us from some of it, but all satellites have to deal with it.

Radiation impacts satellites in six ways:

  • Total Ionizing Dose (electrons being lost)
  • Displacement Damage Dose (nucleus effects)
  • Dielectric Charging (internal charge changes)
  • Surface Charging (exterior charge buildup)
  • Charged Particle Heating (small temperature increase)
  • Single Event Effects (circuitry problems)

Single Event Effects can cause 0’s and 1’s in computer electronics to flip, which can cause software errors.

Error Correction Codes

Spacecraft use Error Detection and Correction (EDAC) to fix this problem in both processors and memory. Fixing the memory is called scrubbing, and Error Correction Codes such as extended hamming or Reed-Solomon can be used. Fixing the processor inputs and outputs is handled by a dedicated Memory Management Unit in an On-Board Computer.

These corrections are constantly happening on spacecraft because space radiation is always corrupting the bits. Fixing the problems costs satellites time, power, and computational throughput. It’s manageable but expensive.

AI in Space

Spacecraft aren’t fantastic at executing neural-network based AI on-orbit. Neural networks are power hungry, and computers that resist space-radiation aren’t fast enough to use the algorithms effectively. As a result, spacecraft on-orbit don’t really learn or improve what they’re doing. Spacecraft can be autonomous and their software can be updated, but given the same inputs, satellites will usually give you the same outputs.

That’s where Genetic Algorithms (GA). These evolutionary computing algorithms use multiple agents with different inputs to execute a task and see which agent did the best. The parameters for all agents are shifted towards the best agent, and the process is repeated until the agents get really good at the task.

GAs need randomness to shift the agent parameters. Normally that happens by injecting the randomness into the code, which again costs time, power, and computational throughput. DoomSat leverages radiation-induced bit flips as that randomness, using the radioactive space environment as a means to improve spacecraft performance.

Playing DOOM™

First, shoutout to the VizDoom team for creating a platform that enables missions like DoomSat. It’s an awesome system that everyone should check out.

The DOOM™ games are organized by episodes and maps, where E1M1 would be Episode 1 Map 1. Each map is different, and the agent (which our student software devs named Hal) must traverse the map, beat the enemies, pick up items, and reach the goal. Navigation planning is the first step, and the team is currently using static map node generation while the state machine mechanics are polished. The file structure looks like this.

Map files are processed, and a set of nodes are defined as targets for the agent to reach while it’s playing the level. This doesn’t mean the agent always plays the level the same way.

DoomSat has to track everything about Hal’s progress, so runtime classes are defined.

The runtime sequence governs the gameplay process.

Hal must traverse the map, fight enemies, recover from fights, and generally figure out where to go. A state machine is defined to govern his behavior.

Hal must traverse the map, fight enemies, recover from fights, and generally figure out where to go. A state machine is defined to govern his behavior.

Parameters are defined to govern aspects of the state machine execution. Things like how long the agent waits in stuck mode, how long he stays in combat mode when the enemy leaves the field of view, and health or armor thresholds that trigger a recover state, to name a few. These parameters are mutated from one generation to the next, resulting in gameplay variation.

A fitness criterion is defined based on time to completion, health remaining, armor remaining, ammo remaining, enemies killed, and proximity to the end goal. Agents that performed better are considered elite, while challenger agents compete to become the elite. Each challenger and elite generation is given 5 attempts to beat a level, and a fitness score is generated for each attempt. This GA implementation only has a population of 2, meaning crossover is much less relevant than mutation.

The randomized parameters evolve over time, eventually converging on a set of parameters that best completes the task.

All data from the on-orbit runs is converted into text files and downlinked from the spacecraft. It will then be re-input to VizDoom and livestreamed on YouTube! Everyone will be able to watch space itself play DOOM™!