Software · Static test capture, from load cell to a and n

RustStand

Static test capture for solid rocket motors. A Raspberry Pi at the test stand records thrust, chamber pressure and video, starting and stopping on its own as the motor lights and burns out, while RustStand apps on your phone and computer watch and control it over WiFi. Every test gives impulse, motor class, burn time and chamber pressure, plus the burn-rate points that fit good a and n values for RustPEP. Measurement only: it never controls ignition. Coming soon.

Coming soonOverviewWorks with RustPEP

The RocketSalvo family

Design it, shape it, measure it, and feed the numbers back.

RustPEP’s burn-rate law and RustCore’s core are only as good as the a and n behind them. RustStand measures them from your own static tests and sends them back, so the next motor is designed from real data.

  1. RustPEP

    Design the propellant

    Predicts the recipe’s performance and holds its burn-rate law, r = a·Pⁿ.

    About RustPEP

  2. RustCore

    Shape the motor

    Designs the grain and core around that burn rate, and predicts the Kn and peak pressure.

    About RustCore

  3. RustStand

    Measure the burn

    Records the static test and fits a and n from it, then sends them back to RustPEP.

    How a test runs

↻ Measured a and n, with their pressure range and R², return to RustPEP and sit under the formulation.

Why it exists

Good a and n come from good test data.

A burn-rate fit is only as good as the thrust and pressure traces it comes from. Those traces need calibrated sensors, a steady clock, the moments before ignition, and nothing lost when the WiFi drops as the motor lights.

RustStand puts a small computer at the stand that does all of that on its own, and reduces every test the same way, so results from different days and different motors can be compared and fitted together.

  1. SensorsLoad cell, pressure transducer, thermocouple
  2. DAQLabJack T7 first, more to follow
  3. StandRaspberry Pi 5 records to its SSD
  4. AppsPhone and computer, over WiFi

At the range

A static test, start to finish.

  1. 1 · Set up

    Pick the motor

    Choose the formulation and batch from RustPEP and the grain from RustCore. The pre-test check confirms sensors live, a stable zero, current calibration, a passed check weight, the camera locked, and disk, battery and signal.

  2. 2 · Arm

    Tare, hold, walk away

    Tare with the motor loaded, then press and hold Arm. Arming arms the recording only. The stand disarms itself if nothing happens for a set time.

  3. 3 · Fire

    Use your own ignition

    Fire the motor with your club’s own ignition system. RustStand starts recording when thrust rises, keeps the seconds before it, and stops after burnout on its own.

  4. 4 · Results

    Numbers in seconds

    Results open on their own: impulse, motor class, burn time, pressure, the curve and the video. Add photos and notes; the test syncs to the desktop library and the burn-rate points go to RustPEP.

In development · running today

Already recording, against its simulator.

The desktop app and the stand software already run end to end against RustStand’s built-in motor simulator: the live view, automatic start and stop, the test library and replay, calibration against known masses, and a test setup that takes the propellant and batch from RustPEP and the motor design from RustCore. The DAQ drivers are written — a DATAQ DI-194RS and a LabJack T7 — but neither has been confirmed against real sensors, and proving them on hardware comes next, then video, reports and the phone apps.

Screenshots of the in-development desktop app on Windows, version 0.6.6 — 0.6.8 for the export shot. The traces are a real static firing — a 38 mm two-grain motor on Everclear propellant — recorded elsewhere and played back through the stand simulator. RustStand has not captured a firing through its own hardware yet.

RustStand desktop app Live screen with a red RECORDING status bar, readouts of 110.7 N thrust, 2.79 MPa chamber pressure, 169.3 N peak thrust and 0.8 s elapsed, a press-and-hold Disarm button, and a chart of thrust and chamber pressure on one time axis showing a sharp ignition spike just after 3.5 seconds, the pressure rising behind the thrust, and both settling near 125 N and 2.8 MPa.
LiveRecording a burn: thrust, chamber pressure and peak thrust in large type, both traces on one time axis, and Disarm behind a press-and-hold. The ignition spike, and the pressure climbing behind the thrust, are from the firing itself. Played back from a real firing, not captured live.
RustStand Results screen for test ST-0002, an H104: total impulse 186.6 N·s, peak thrust 168.2 N, average thrust 103.9 N, NFPA burn time 1.79 s, peak pressure 3.01 MPa and average pressure 2.23 MPa, Replay and 4x speed buttons, the thrust and pressure curves, and an After the firing form with boxes for throat diameter after, unburned propellant, residue and liner.
ResultsOne firing worked out on its own: total impulse, the motor designation it earns, peak and average thrust, NFPA burn time and pressure, the full curve with a replay, and the form for what you found when you took the motor apart. Played back from a real firing, not captured live.
RustStand Library listing four tests, ST-0001 to ST-0004, each with a motor label, date, duration and stand name, a sync state reading on stand and on this device, the motor designation H104, and a total impulse between 186.3 and 186.7 N·s.
LibraryEvery firing the stand has taken, each analysed by itself rather than averaged together. Four runs of the one motor here, landing between 186.3 and 186.7 N·s. Played back from a real firing, not captured live.
RustStand Export for RustCore panel, below a finished firing’s thrust and pressure curves and the After the firing form. It says the firing’s pressure trace and test record are written into one folder that RustCore’s Calibrate and Validate can open, with a RustCore design chosen as 2G Finocyl H122, a test type, three throat-before-firing boxes prefilled at 5.58, 5.57 and 5.58 mm from the design, three empty throat-after-firing boxes under a note that an opening throat reads as a slower burn rate, an ambient pressure box, and an Export for RustCore button.
Export for RustCoreA firing goes to RustCore as a folder its Calibrate and Validate can open, with the throat measured before and after — an opening throat reads as a slower burn rate, so both get recorded. Anything left blank exports as not stated rather than quietly as a number. Played back from a real firing, not captured live.
RustStand test setup before arming, with Arm recording disabled and a red line reading cannot arm, not zeroed, above two calibration reminders. Below, the firing purpose set to Base rate, a campaign name, a test plan from RustCore, a propellant chosen from RustPEP, a batch, a motor design from RustCore, the density used, and the number of grains.
Test setupBefore arming: what the firing is for, the campaign it joins, and the propellant, batch and motor design taken from RustPEP and RustCore instead of typed in again. The checklist holds Arm back until the transducer is zeroed, and says why.
RustStand Calibrate screen for the Thrust channel, noting it is using its datasheet conversion and is not calibrated yet, with Calibrate with known masses and Check weight tabs, four numbered steps covering setting the stand up as it fires and adding then removing known masses, a box for the total mass on the stand, Loading up and Unloading buttons, and a Take reading button.
CalibrationThe load cell against known masses, loading up and then unloading again so the gap between them shows its hysteresis, and a check weight before a test. A datasheet conversion is not a calibration, and the app tells you which one you are on.
RustStand Live screen ready to arm, with 0.7 N thrust, 0.00 MPa chamber pressure and 168.4 N peak thrust, a press-and-hold Arm recording button, two calibration reminders in amber, and a chart covering about 55 seconds showing two firings roughly thirty seconds apart with flat sensor noise between them.
Ready to armIdle between runs, with the stand’s own sensor noise on screen and two firings thirty seconds apart still on the chart. The calibration reminders sit beside Arm, where they are hard to walk past. Played back from a real firing, not captured live.
RustStand Find a stand screen listing two stands discovered on the network, RustStand-CDDF and RustStand-EB30, each with its local hostname, above a box for typing a stand address with a Connect button and a button to disconnect from the current stand.
StandsStands on the network turn up by themselves, and you can type an address instead. A stand names itself, so there is nothing to configure in a field to find one.
RustStand Settings screen with theme choices including Sunlight high contrast, thrust units of N or lbf, pressure units of MPa, psi or bar, the device name, a Calibrate a channel button, stand health showing the RustStand simulator running at 2000 samples per second per channel with free disk space, and a note that RustStand is measurement-only software that does not control igniters, firing or launch, never energizes an ignition circuit, and where Arm means arm recording.
SettingsUnits, a theme that includes a high-contrast one for working in sunlight, the name other apps see, and the stand’s health. The measurement-only statement is in the app itself, not buried in a manual: it records, and never energizes an ignition circuit.

What it is designed to do

Planned for the first release.

01

Good a and n from real burns

Each test gives burn-rate points, pressure against burn rate, for the fit r = a · Pn. Three or more tests at different throat sizes give the full fit; a single test gives an early estimate by Nakka’s pressure–time method. Every fit shows its pressure range, R² and propellant temperature, and goes back to RustPEP to sit under the formulation.

02

Hands-off recording

Arm the stand and walk away. It keeps the last few seconds in memory, starts recording when thrust rises clear of the noise, stops when thrust has stayed below 5% of the peak, and keeps the moments before ignition. Nobody has to press start during the countdown.

03

The test survives a WiFi dropout

The Pi writes every sample to its own SSD as it arrives, and the apps are never in the data path. If the WiFi drops at ignition you lose the live view, not the test; the apps reconnect and catch up.

04

Numbers you can compare

Total impulse, motor class and designation, burn time per NFPA 1125, peak and average thrust and chamber pressure, and delivered Isp, c* and thrust coefficient against RustPEP’s theoretical values. Flags for clipping, signal dropout, a pressure spike that looks like a CATO, chuffing and a baseline shift after burnout.

05

Calibrated end to end

Each channel is calibrated through its whole chain of sensor, amplifier and DAQ input: a guided wizard with known masses for load cells, a reference gauge for pressure, and a check weight before each test. Every test keeps a copy of the calibration it used, and the raw voltages, so it can be reprocessed later.

06

Video on the same clock

A USB camera at the stand records at up to 120 frames a second, timestamped on the same clock as the data, with a live preview in the apps. Scrub the thrust curve and the video follows. The desktop app exports a video with the curve and readouts burned in.

07

Part of the RocketSalvo family

Each test links to its RustPEP formulation and RustCore grain design. RustCore’s predicted peak sets the input ranges and gives the Kn curve; RustPEP supplies the theory to measure efficiency against, and gets the measured a and n back.

08

A test library that keeps everything

One folder per test, with the raw data, video, photos, setup and results. Raw data is never edited: re-analysis saves a new results version. Search by motor, formulation or grain, overlay tests on one chart, and export .eng, .rse, CSV and a PDF report.

09

Built for the range

The stand makes its own WiFi network, needs no internet or account, and pairs with a one-time code. One app controls the stand at a time while others watch. A high-contrast sunlight theme, large touch targets, and press-and-hold to arm.

Specifications

Technical details

Planned; subject to change before release.

Status
AvailabilityComing soon. In development; not yet available
ScopeMeasurement only. RustStand never controls igniters or firing; “Arm” arms the recording
Price and licensingTo be determined
Release dateTo be determined
At the stand (planned)
Stand computerRaspberry Pi 5, Raspberry Pi OS 64-bit, with an NVMe SSD; or a laptop with the DAQ plugged in
First DAQLabJack T7, which reads a load cell directly
More DAQsLabJack T4 with LJTick-InAmp, MCC 118 and 128 DAQ HATs, MCC USB, PhidgetBridge, and the Waveshare ADS1256 HAT
ThrustLoad cell, as a raw strain-gauge bridge or through a signal conditioner
Chamber pressureTransducer with 0.5–4.5 V, 0–5 V, 0–10 V, 4–20 mA or millivolt output
TemperatureType K thermocouple or PT100 RTD
CameraUSB (UVC) camera with JPEG output, such as 720p at 120 frames a second
NetworkIts own WiFi hotspot, an existing network, or Ethernet
Apps and results (planned)
AppsWindows, macOS and Linux, and iOS and Android, from one codebase
Burn timeNFPA 1125: from rising through 5% of peak thrust to falling below it
Burn rater = a · Pn fitted from 3 or more tests, or estimated from one
Exports.eng, .rse, CSV, PDF report, and video with the curve overlaid
Works withRustPEP (formulation in, measured a and n out) and RustCore (grain and nozzle in)

Measurement only

It watches the motor. It never lights it.

RustStand never controls igniters, relays or a countdown, and never drives an output that could energize an ignition circuit. “Arm” means arm the recording. To line the video up with the data, an LED in your own ignition circuit can be wired to a spare input; RustStand only senses it.

Start with the propellant.

RustPEP holds the burn-rate law that RustStand will measure, and fits it from test firings today.

About RustPEPRustStand overview