CSS Aggregator Software

SWITCH TO API

Description

The CSS Aggregator Software is a flight software module that combines measurements and configuration data from multiple Coarse Sun Sensor Array units into a single unified output. This is particularly useful for spacecraft with distributed sun sensor arrays across different structural panels or when integrating sensors from multiple subsystems. By aggregating the data into a common message format, downstream algorithms such as sun vector estimators and attitude determination systems can process the complete sensor constellation without knowledge of the underlying hardware topology.

---

Example Use Cases

• Multi-Panel Sun Sensor Integration: Combine CSS arrays mounted on different spacecraft panels (e.g., +X, -X, +Y, -Y faces) into a single unified dataset.
• Redundant Sensor Fusion: Aggregate sensors from primary and backup attitude determination systems for fault-tolerant sun vector estimation.
• Modular Spacecraft Architectures: Support spacecraft designs where sun sensors are distributed across separable modules or deployable structures.
• Simplified Algorithm Interfaces: Provide a single input interface for sun vector estimation algorithms regardless of the physical sensor distribution.

---

Module Implementation

The CSS Aggregator Software is a Software component that processes multiple input CSS array messages and produces consolidated output messages containing the combined sensor constellation data.

Input Message Arrays

The aggregator accepts two parallel arrays of input messages:

Input Array	Message Type	Description
In_CSSArrayDataMsgArray	CSSArrayDataMessage	Sensor measurement data from each CSS array
In_CSSArrayConfigMsgArray	CSSArrayConfigMessage	Configuration parameters for each CSS array

These arrays must have equal length, with each index corresponding to a matched pair of data and configuration messages from the same CSS array source.

Initialisation

During the simulation begin phase, the aggregator validates input consistency and allocates output arrays. Let $M$ denote the number of input CSS arrays, and let $N_k$ denote the number of sensors in the $k^{th}$ array. The total number of aggregated sensors is:

$$N_{\text{total}}=\sum _{k=0}^{M-1}{N}_k$$

The output message arrays are sized accordingly:

$$|\mathbf{n}|=|\mathbf{k}|=|\mathbf{y}|=N_{\text{total}}$$

where $\mathbf{n}$ is the array of normal vectors, $\mathbf{k}$ is the array of calibration biases, and $\mathbf{y}$ is the array of sensed values.

Data Aggregation

At each simulation update, the aggregator iterates through all input message pairs and copies their contents into the consolidated output messages. For input arrays indexed by $k\in [0,M-1]$ and sensors within each array indexed by $j\in [0,N_k-1]$, the mapping to the output array index $i$ is:

$$i=\sum _{l=0}^{k-1}{N}_l+j$$

The aggregation operations are:

$${\hat{\mathbf{n}}}_i^{\text{out}}={\hat{\mathbf{n}}}_j^{(k)}$$ $$k_i^{\text{out}}=k_j^{(k)}$$ $$y_i^{\text{out}}=y_j^{(k)}$$

where the superscript $(k)$ denotes the $k^{th}$ input array.

Output Messages

The aggregator produces two output messages containing the combined constellation data:

Configuration Message

The CSSArrayConfigMessage contains the aggregated static parameters:

$${\mathbf{N}}^{\text{out}}={\left[\begin{array}{cccccc}{\hat{\mathbf{n}}}_0^{(0)}& \cdots & {\hat{\mathbf{n}}}_{N_0-1}^{(0)}& {\hat{\mathbf{n}}}_0^{(1)}& \cdots & {\hat{\mathbf{n}}}_{N_{M-1}-1}^{(M-1)}\end{array}\right]}^T$$ $${\mathbf{k}}^{\text{out}}={\left[\begin{array}{cccccc}{k}_0^{(0)}& \cdots & k_{N_0-1}^{(0)}& k_0^{(1)}& \cdots & k_{N_{M-1}-1}^{(M-1)}\end{array}\right]}^T$$ $$N_{\text{CSS}}^{\text{out}}=N_{\text{total}}$$

Data Message

The CSSArrayDataMessage contains the aggregated time-varying measurements:

$${\mathbf{y}}^{\text{out}}={\left[\begin{array}{cccccc}{y}_0^{(0)}& \cdots & y_{N_0-1}^{(0)}& y_0^{(1)}& \cdots & y_{N_{M-1}-1}^{(M-1)}\end{array}\right]}^T$$

Dynamic Resizing

The aggregator includes runtime validation to handle cases where the input array sizes change during simulation. If the total sensor count differs from the current output array size:

$$\left|{\mathbf{n}}^{\text{out}}\right|\ne \sum _{k=0}^{M-1}{N}_k$$

the output arrays are reallocated to match the new total sensor count. This ensures robustness against dynamic reconfiguration of the sensor constellation.

Message Management

The aggregator provides convenience methods for dynamically adding input messages:

Method	Description
AddConfigMessage	Appends a configuration message to the input array
AddDataMessage	Appends a data message to the input array

These methods allow runtime construction of the input message arrays, enabling flexible integration with various sensor topologies.

Processing Sequence

At each simulation time step, the aggregator performs the following operations:

1. Validate Array Sizes: Check that output arrays match the current total sensor count; resize if necessary.
2. Reset Index Counter: Initialise the output array index to zero.
3. Iterate Input Arrays: For each input message pair:
   • Copy normal vectors from input configuration to output configuration
   • Copy calibration biases from input configuration to output configuration
   • Copy sensed values from input data to output data
   • Increment the output array index
4. Update Output Messages: The consolidated messages are now available for downstream consumers.

---

Assumptions/Limitations

• The number of data messages and configuration messages must be equal; mismatched array lengths will raise an exception.
• Input message pairs are assumed to be correctly matched; no validation is performed to ensure data and configuration messages originate from the same physical sensor array.
• Sensor ordering in the output follows the order of input arrays and sensors within those arrays; no reordering or sorting is performed.
• The aggregator performs a shallow copy of sensor data; modifications to input messages after aggregation may affect output values.
• No filtering, calibration, or validation is applied to sensor data; all values are passed through unchanged.
• The aggregator does not detect or handle duplicate sensors across input arrays.
• Dynamic resizing during simulation may cause discontinuities in sensor indexing if downstream algorithms cache index mappings.
• The aggregator assumes all input messages are updated synchronously; asynchronous updates may result in inconsistent output data.
• No interpolation or extrapolation is performed for sensors with different update rates.
• The aggregator does not account for coordinate frame transformations; all normal vectors are assumed to be expressed in the same