Missions

1. Overview

A Flightkit Mission is the top-level description of the system. A Mission defines the following collections:

  • The Assets in the system

  • The Targets where flight software can be executed within each Asset, along with their associated Deployment instances

A Mission is the "universe" that the model works in, encapsulating every spacecraft in the constellation. As with many other artefacts in a Flightkit library, Missions are model-based and their definition is described within a mission.xml file. However, Missions are fundamentally different in that a single Mission is expected to be used for each project; they cannot be reused. It is not possible for anything in one Mission to refer to instances outside of that Mission.

The Mission contains instances from the various model domains and connects them to form complete flight software systems. For example, a Mission creates instances of functional Deployments - comprising the Components which make up the software for the Mission - and identifies on which physical Targets they run.

The Mission workflow follows similar steps to other model elements. The Flightkit hfk tooling can be used to create, generate and build a Mission, as well as generating its documentation. Building a Mission produces two valuable outputs: the executable software binary and the Mission Database that can be used to integrate with other HELIX products.

2. Deployments, Targets and Assets

Deployment instances are instantiations of Deployment Types that can be run as part of the Mission. They are executable pieces of GenOne software, constructed by connecting a set of Components together. Deployments are built to be run on a specific Target.

Targets bind specific Deployment Types to Hosts within an Asset. They are used to define the various Deployment instances that need to be built to run on a particular Host, usually to fulfil a particular functional role within the Mission. A Target may hold one or more Deployment instances, for example, a primary and a failsafe image. However, only one Deployment is reachable on that Target at any one time. Because of this, a Mission describes the potential for executing software in a system, rather than the actual running software in a system. All Deployment instances for a particular Target are of the same Deployment Type, but can be configured differently via initialisation data to produce different behaviour.

Hosts in turn represent individual physical or virtual resources on which software can be executed. By assigning a Target to a Host, we are saying it is capable of executing a specific type of software. It is possible to associate multiple Targets with a Host, but that does not necessarily mean they can all be accessed at the same time or that any of them are currently running.

An Asset represents a standalone hardware unit. In a flight system, they are most commonly spacecraft, but they can also be ground stations or servers. Assets may be given further structure by decomposing them into {Subsystem}s. Both Assets and {Subsystem}s may contain Hosts.

Mission elements cannot contain child elements with the same full name. For example, a Mission cannot have a top-level Asset and a top-level Target with the same name.

3. Mission Workflow

3.1. Creating a Mission

A new Mission can be created with the following command:

hfk mission create <MissionName>

This command generates a directory structure in the Workspace's missions directory containing a template mission.xml. Inside is an example Mission (below) designed to use the BasicLinuxAsset Asset. The Mission has one Target defined with a single generic.linux.BasicCommsDemo Deployment instance attached to it that has specified the {OSAL}, {Board} and BuildConfig it will use.

Example mission.xml
<?xml version="1.0" encoding="UTF-8"?>
<!--
    This file defines the MyMission mission.

    A mission is a collection of deployment instances and a description of the
    assets they run on. The deployment instances in a mission can be built and
    executed on target hardware.

    Copyright (c) Bright Ascension Ltd, 2026
    Licensed Material - Property of Bright Ascension Ltd
-->
<ModelElement xmlns="http://www.brightascension.com/schemas/gen1/model"
              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <Mission name="MyMission">
    <!-- Note: The order of the tags is important and should not be changed. -->
    <Description>
      The MyMission mission.
    </Description>
    <Assets>
      <!--
        TODO If required, update the name and type of your asset. In Flightkit
        or Groundkit, assets are typically spacecraft, but may be used to represent
        any physical environment which can host flight software.

        If you change the name of your asset here, remember to update your
        Targets to refer to the new name.
      -->
      <Asset name="MyMissionAsset" type="generic.BasicLinuxAsset"/>
    </Assets>
    <Targets>
      <!--
        TODO If required, update the name of your Target and its deployment
        type. Targets bind deployments to hosts. Hosts are the parts of Assets
        capable of running flight software.

        All deployments which run on the same target must be instances of the
        same type.

        Targets should typically be named to identify the role which the given
        host fulfils in the mission. For example, "FlightComputer",
        "CommsRelay" and "SupervisorProcess" all reflect the role which a
        physical host could fulfil within the mission.
      -->
      <Target name="MyMissionTarget" deploymentType="generic.linux.BasicCommsDemo" hostAsset="MyMissionAsset" hostName="LinuxProcess">
        <Deployments>
          <!--
            TODO If required, update the name of your Deployment instance.
            Deployment instances are the individual flight software binaries
            which can run within your mission.

            Their names have target scope, so typically should be chosen to
            describe how they are configured. For example, "Failsafe" and
            "EMEAFrequencies" reflect how the particular deployment instance is
            set up to carry out its job.
          -->
          <Deployment name="MyMissionDeployment">
            <Architecture>
              <Board name="Linux"/>
              <OSAL name="Pthreads"/>
            </Architecture>
            <BuildConfig name="LinuxPthreads"/>
          </Deployment>
        </Deployments>
      </Target>
    </Targets>
  </Mission>
</ModelElement>

A Mission description and documentation can be added, to be used by an operator or systems engineer to understand more about the system. Descriptions are used to summarise what the Mission is and what it is used for, whereas documentation is used for a more in-depth description of how to use it. Documentation can also be written for each Deployment on each Target to make a record of when and how to use each Deployment.

3.2. Generating a Mission

Once you have written the mission.xml, the next thing to do is to generate it with the following command:

hfk mission generate <MissionName>

For each Target in the Mission, a new directory will be created. In there is the DeploymentName/init directory for each specified Deployment - use this to specify the initialisation (init) data for all of the Component instances. Each Component's init data structure is defined in the Component Type's corresponding header file. The init data in the Mission simply needs to populate the fields already specified.

Each Component's init data structure is defined in the Component Type's corresponding header file located at: library/component_types/COMPONENT_TYPE_NAME/include from the root of the Workspace or Bundle.

By specifying initilisation values at the Mission level, the same Component Types can be used mutiple times within the same Deployment intance and across the whole Mission.

If initialisation files are already present within the Mission directory, the hfk mission generate command will not overwrite these files.

For more information on the directory structure of a Mission, consult the Mission Layout reference material.

To generate HTML and Markdown documentation for the Mission and its dependencies, use the following command:

hfk mission generate-docs <MissionName>

By default this will create model documentation in the Workspace's output directory.

3.3. Building a Mission

The final thing to do is to build the Mission using the following command:

hfk mission build <MissionName>

This command does two things. First, it creates the executable software binary for each Deployment to be flashed on to the Target(s). These can be found in the Workspace's ouput directory. Second, it creates a Mission Database, a portable description of the Mission that can be used by ground software such as HELIX Lab to interact with the flight software.

Optional arguments can be provided to the hfk mission build command to build only specific Targets or Deployments within the Mission. For example, hfk mission build MyMission MyTarget.