​

Quickstart (10 minutes)

​

Step 1: Create a New Model

​

Step 2: Define Requirements

Requirement: The Attitude Control and Determination Subsystem (ACDS) shall settle to within 0.1 degrees of the commanded attitude within 120 seconds after maneuver initiation.

​

Step 3: Build the Structure

1. Add the Satellite as the root part of your model.
2. Double-Click into the Satellite and add these subparts:
   • Reaction Wheels (x3): Add three reaction wheel components to represent the 3-axis control system.
   • Attitude Control & Determination System (ACDS): Add the Attitude Control and Determination Subsystem as a separate part.

​

Step 4: Add Part Attributes

​

Step 5: Configure an Action (Analysis)

1. First, switch to the Action view in the Dalus interface. This will allow you to create and configure actions for your model, in this case, for the Satellite part.
2. Add an action and name it “Point Satellite”.
3. Double-click on the action and copy and paste this python code inside, which implements a simple Proportional-Derivative controller in 3 axes:

import numpy as np

# -- Satellite inertia (from attributes) --
I_xx = float(getAttribute(""))
I_yy = float(getAttribute(""))
I_zz = float(getAttribute(""))
I = np.array([I_xx, I_yy, I_zz])

# Control gains and limits
Kp = np.array([0.1, 0.1, 0.1])
Kd = np.array([1.5, 1.5, 1.5])
torque_cmd_max = 0.02

# Reaction wheel parameters
J_rw_x = 1.0  # example value, kg·m²
J_rw_y = 1.0  # example value, kg·m²
J_rw_z = 1.0  # example value, kg·m²
J_rw = np.array([J_rw_x, J_rw_y, J_rw_z])
efficiency = 0.9  # example value

# Initial attitude
a_x, a_y, a_z = 0, 0, 0  # deg
a_cmd_x, a_cmd_y, a_cmd_z = getInput("a_cmd_x"), getInput("a_cmd_y"), getInput("a_cmd_z")

attitude = np.deg2rad([a_x, a_y, a_z])
desired_attitude = np.deg2rad([a_cmd_x, a_cmd_y, a_cmd_z])

# Simulation settings
dt = 0.1
t_final = 200
times = np.arange(0, t_final, dt)

# Preallocate histories
error_norm = np.zeros_like(times)
torque_history = np.zeros((len(times), 3))
omega = np.zeros(3)
omega_rw = np.zeros(3)
power_history = np.zeros((len(times), 3))

# Initial error
prev_error = desired_attitude - attitude
initial_error_norm = np.linalg.norm(prev_error)
settling_time = None

settling_threshold = 0.1  # deg

# Simulation loop
for i, t in enumerate(times):
    error = desired_attitude - attitude
    error_dot = (error - prev_error) / dt
    prev_error = error

    # PD control and saturation
    torque_cmd = Kp * error + Kd * error_dot
    torque_cmd = np.clip(torque_cmd, -torque_cmd_max, torque_cmd_max)
    torque_history[i] = torque_cmd

    # Update satellite dynamics
    alpha = torque_cmd / I
    omega += alpha * dt
    attitude += omega * dt

    # Reaction wheel dynamics & power
    alpha_rw = torque_cmd / J_rw
    omega_rw += alpha_rw * dt
    power = np.abs(torque_cmd * omega_rw) / efficiency
    power_history[i] = power

    # Record error norm & settling time
    error_norm[i] = np.linalg.norm(error)
    if settling_time is None and np.rad2deg(error_norm[i]) < settling_threshold:
        settling_time = t

# Calculate rise time (10% to 90% of initial error)
e0 = initial_error_norm
rise_time = np.nan # Default to NaN

# Find indices where error crosses the thresholds
indices_start = np.where(error_norm <= 0.9 * e0)[0]
indices_end = np.where(error_norm <= 0.1 * e0)[0]

# Check if both thresholds were crossed
if len(indices_start) > 0 and len(indices_end) > 0:
    t_rise_start = times[indices_start[0]]
    t_rise_end = times[indices_end[0]]
    # Ensure start time is before end time (error is decreasing)
    if t_rise_end >= t_rise_start:
        rise_time = t_rise_end - t_rise_start
    else:
        # This case might happen if error oscillates around the threshold
        print("Warning: Could not determine a valid rise time (end time before start time).")

elif len(indices_start) == 0:
    print("Warning: Attitude error never reached 90% of the initial value.")
elif len(indices_end) == 0:
    print("Warning: Attitude error never reached 10% of the initial value.")


# Total energy consumed by wheels
total_power = np.sum(power_history, axis=1)
total_energy = np.trapz(total_power, times)  # Joules

# Results
print(f"Rise time: {rise_time:.1f} s" if not np.isnan(rise_time) else "Rise time: N/A (threshold not met)")
print(f"Settling time: {settling_time:.1f} s" if settling_time is not None else "Settling time: N/A (threshold not met)")
setAttribute("", settling_time if settling_time is not None else -1.0) # Use -1 or similar for unset value
# Set new attitude (for use in further analysis)
roll_deg, pitch_deg, yaw_deg = np.rad2deg(attitude)
print(f"Final attitude: roll={roll_deg:.2f} deg, pitch={pitch_deg:.2f} deg, yaw={yaw_deg:.2f} deg")

• After running the simulation, the script will calculate the settling_time and set it for the Satellite’s attribute.

​

Step 6: Add a Requirement Constraint and Test

1. Go to the requirements view and locate the ACDS settling time requirement.
2. Click on its status, then under Add constraint, select the Attributes dropdown.
3. Choose settling_time and set the limit to < 120 seconds.
4. You’ll see the requirement status immediately update based on its current value.

​

Step 7: Create a Simple State Machine

1. Switch to the State view.
2. Define two states: STANDBY and SURVEILLING.
3. Connect them to add a transition between them. Name it anything.
4. In the Point Satellite transition, select the Point Satellite action as an effect. This causes the action to execute whenever you transition from Standby to Surveilling.
5. Use the states dropdown to first enter STANDBY. Then, switch to the Action view and transition to SURVEILLING to observe the effect taking place.

1. transition triggers - boolean expressions that automatically execute the transition if ALL evaluate to true.
2. transition guards - boolean expressions that prevent the transition if ANY evaluate to true.

​

Next Steps

1. Parameterize Control Gains & Reaction Wheel Moments:
   • Add the proportional (Kp) and derivative (Kd) gains as attributes to the ACDS subsystem instead of hard-coding them in the Point Satellite script.
   • Similarly, add the Reaction Wheel moments (J_rw_x, J_rw_y, J_rw_z) as attributes of the Reaction Wheels .
   • Update the Point Satellite script to fetch these values using getAttribute. This is to organize your parameters logically, making them easy to find and tune as your model grows in complexity.
2. Model Command Inputs from Ground Control:
   • Add a new part called Ground Control at the same level as the Satellite.
   • Connect the parts together to form an interface and add connections for a_cmd_x, a_cmd_y, and a_cmd_z instead of assigning them as inputs to the action.
   • In your script, use getConnection (passing in the ID) to access these command variables instead of getInput.
3. Set and Reset the Satellite’s Current Attitude:
   • Add attitude_x, attitude_y, and attitude_z attributes (0 deg) to the Satellite in the Right Sidebar → Attributes.
   • Update the Point Satellite script to fetch these values and use them as our initial attitude instead of hard-coding the initial attitude to (0,0,0) (see line 22).
   • At the bottom of the Point Satellite script, use setAttribute(id, value) to write back the final attitude_x, attitude_y, and attitude_z (degrees).
   • In the actions view inside Satellite, create an action named “Reset Attitude” that sets the three attitude attributes back to 0.
   • In the states view inside Satellite, add a Reset Satellite transition from SURVEILLING to STANDBY, and set STANDBY’s Entry Action to execute Reset Attitude.
   • Now, transition the Satellite back and forth between SURVEILLING and STANDBY to see its attitude change.