Coarse Sun Sensor Array

Description

A Coarse Sun Sensor (CSS) Array is a constellation of individual Coarse Sun Sensor units arranged to provide full or partial spherical coverage for sun vector determination. By combining measurements from multiple sensors with known orientations, the array enables robust sun direction estimation even when individual sensors are partially or fully shadowed. This component aggregates configuration and measurement data from all child CSS units, providing a unified interface for attitude determination algorithms such as sun pointing controllers and safe mode estimators.

Example Use Cases

Sun Vector Estimation: Combine measurements from multiple CSS units to estimate the sun direction in the spacecraft body frame.
Safe Mode Attitude Control: Provide sun presence detection and coarse pointing information for spacecraft safe mode operations.
Eclipse Detection: Monitor aggregate sensor readings to determine when the spacecraft enters or exits planetary shadow.
Sensor Redundancy Analysis: Evaluate the impact of individual sensor failures on overall sun vector estimation accuracy.

Module Implementation

The Coarse Sun Sensor Array is a Physical Object that serves as a container and aggregator for multiple Coarse Sun Sensor child components. It automatically detects child CSS units and consolidates their configuration and measurement data into array-format output messages.

Array Structure

The array maintains references to all CSS units attached as children in the simulation hierarchy. When sensors are added or removed, the array automatically updates its internal data structures to reflect the current constellation configuration.

For an array containing $N$ coarse sun sensors, the aggregated data consists of:

Parameter	Description	Dimensions
Normal Vectors	Unit direction vectors for each sensor boresight	$N \times 3$
Calibration Biases	Scale factors for each sensor measurement	$N \times 1$
Sensed Values	Current illumination readings from each sensor	$N \times 1$

Sensor Registration

The array automatically discovers child CSS units through the simulation hierarchy. When the hierarchy changes (sensors added or removed), the OnHierarchyChanged callback triggers a rescan:

S = {s_{i} : s_{i} \in children (Array), s_{i} \in CoarseSunSensor}

The number of registered sensors is updated accordingly:

N_{CSS} = ∣ S ∣

Data Aggregation

At each simulation update, the array iterates through all registered sensors and populates the output messages with their current configuration and measurement data.

For each sensor $i \in [0, N_{CSS} - 1]$ :

\hat{n}_{i} = \hat{d}_{B, i}

k_{i} = α_{i}

y_{i} = s_{i}

where:

$\hat{n}_{i}$ is the normal vector (boresight direction) of the $i^{t h}$ sensor in the body frame $B$
$k_{i}$ is the calibration scale factor of the $i^{t h}$ sensor
$y_{i}$ is the sensed illumination value from the $i^{t h}$ sensor

Output Messages

The array produces two output messages containing the aggregated constellation data:

Configuration Message

The CSSArrayConfigMessage contains static or slowly-varying parameters:

N = [\hat{n}_{0} \hat{n}_{1} \dots \hat{n}_{N - 1}]^{T}

k = [k_{0} k_{1} \dots k_{N - 1}]^{T}

where $N$ is the matrix of sensor normal vectors and $k$ is the vector of calibration biases.

Data Message

The CSSArrayDataMessage contains time-varying measurement data:

y = [y_{0} y_{1} \dots y_{N - 1}]^{T}

where $y$ is the vector of current sensor readings.

Sun Vector Estimation

The aggregated data from the CSS array can be used by downstream algorithms to estimate the sun direction vector. A common approach is the weighted least-squares method:

\hat{s}_{B} = \frac{\sum _{i = 0}^{N - 1} y _{i} n ^ _{i}}{\sum _{i = 0}^{N - 1} y _{i} n ^ _{i}}

where $\hat{s}_{B}$ is the estimated sun unit vector in the body frame. This computation is typically performed by a separate estimation algorithm that subscribes to the array’s output messages.

Dynamic Array Management

The array dynamically adjusts its internal data structures when sensors are added or removed from the hierarchy.

When a sensor is added ( $N_{new} > N_{current}$ ):

A new entry is appended to the normal vector array
A new calibration bias entry (initialised to zero) is appended
A new sensed value entry (initialised to zero) is appended

When a sensor is removed ( $N_{new} < N_{current}$ ):

The last entry is removed from each array

This approach maintains array consistency but assumes sensors are added/removed from the end of the list.

Mass Contribution

The CSS Array component is configured with MassAvailable = false, indicating that it does not contribute directly to the spacecraft mass budget. The individual CSS units may contribute their own masses independently if configured to do so.

Assumptions/Limitations

The array assumes all child CSS units are direct descendants in the simulation hierarchy; nested structures may not be detected depending on the search depth.
Sensor ordering in the output arrays follows the order returned by the hierarchy search, which may not be deterministic across simulation runs.
Dynamic array resizing adds or removes elements from the end of the arrays; this may not correspond to the actual sensor that was added or removed.
The array does not perform any validation on sensor orientations; overlapping or poorly distributed sensor boresights are not flagged.
No sun vector estimation is performed by the array itself; this must be implemented by a separate algorithm.
The array does not account for sensor faults or anomalous readings; all child sensor data is passed through without filtering.
Calibration biases are read directly from child sensors; no array-level calibration is applied.
The array does not model electrical or thermal interactions between sensors.
Changes to child sensor properties (e.g., orientation) are only reflected at the next simulation update, not immediately.
The array assumes all child sensors update synchronously at

Zendir