*****Got something real special for you at the end of this post: A Construction Manual for the Daedalus's little sister, the DBeta. Ever wonder what it takes to build a spacecraft? This manual will tell you how! Serious, serious. *****

You can find the main page for this project at:

https://ssaerospace.wordpress.com/daedalus-psc-fundraiser/

There is also a link for a free set of the plans (electronic only, science version) so you can make your own Daedalus PSC (US residents only for now).

Drogue and Flight Control Module: https://ssaerospace.wordpress.com/daedalus-psc-plans-free/

Here are the videos in my video log for the project:

*NOTE: I need someone (or a few people) else to replicate this project. I'll even pony up the engineering prints for it for free (but I do need your contact information in case the FAA comes around). It only uses about $200 in Walmart foamboard and EVA resin. I need an informal version of something called "peer review" to double-check my numbers because I'm moving fast. *

*Inertial, GPS, glue chips (including up/downhill optoisolators), MCU's, programmer, teathers, UNIX host SBC with super-high-speed UARTS. Communicates with host Windows 10 PC environment via TCP-IP (SSH shell).*

**Flight Stabilization Unit Issues*** (gets around dicey issues by just implementing roll neutralization and keeps the suborbital point straight up during thrust and coast phase. Water recovery with a random touch-down point caused by wind and such keeps it from colliding with the launch platform).*

**I want you guys to check this out. There is a sentiment out there that iMEM's (ie. piezo) gyros are drifty and unreliable. This turns out the be untrue (for small time scales). I WANT YOU TO CHECK OUT THIS VIDEO :D**

The thrust phase of a Daedalus PSC is only **70 seconds** (even though it burns about 10 tons of propellant in this time) and an iMEMs gyro seems to be MORE than sufficient to keep a tight fix. Issues like vibration and such I think could be addressed by polybutadine mounting of the sensor elements themselves.

**MatBeta FEM/FEA Model for Daedalus PSC**

### X3D of an ouput of MATBETA of a Daedalus PSC

### D-Beta Construction Manual

### Airframe Analysis

C/C++If you don't have a C compiler this is all coded in ANSI/Posix-compliant C so you can cut and paste the code and run it here:

https://www.tutorialspoint.com/compile_c_online.php

...just go to compiler options and put a "-lm" that includes C's standard math library, compile it first, then Execute.

```
#include <stdio.h>
#include <string.h>
#include <math.h>
#define PI 3.14159 //just define pi for use
#define d_steel 0.283 //mass desity of mild steel in lbs/in^3
#define d_aluminum 0.098 //mass density of aluminum in lbs/in^3
#define d_carbon_fiber_epoxy 0.054 //mass density of carbon fiber/epoxy in lbs/in^3
#define d_epdm_rubber 0.039 //mass density of EPDM rubber (vulcanized) in lbs/in^3
#define d_paper_phenolic 0.047 //mass density of Paper/Phenolic in lbs/in^3 (verified)
#define d_ap_al_mg_r45 0.06346 //mass density of hot composite propellant in lbs/in^3
#define d_plywood 0.0196 //mass density of plywood in lbs/in^3
//General Design Constants
double or=48.000; //outer radius of airframe (a constant within the design)
double ir=40.000; //inner radius of airframe (a constant within the design)
double pw=4.000; //pilar width (a constant within the design....usually 4"x4")
double rm_length=65.000; //length of rm module
double esm_length=65.000; //length of esm module
double fcm_length=24.000; //length of fcm module
double dm_length=12.000; //length of drogue module (using revised design)
double mc_length=288.000; //length of motor casing (in inches)
double liner_length=42.000*6.0; //length of insulating liner in motor (in inches)
double grain_length=42.000; //length of a single propellant grain (in inches)
double num_grains=6.0; //number of grains in motor
double pm_bolt_diameter=0.375; //the diameter of the bolts that affix the bulkheads to the casing
double num_bulkhead_bolts=12.0*2.0; //the number of bolts retaining the bulkhead
double operating_pressure=500.0; //chamber pressure in psi
double maximum_operating_pressure=650.0; //maximum tolerable chamber pressure in psi
double maximum_bulkhead_force; //maximum tolerable pressure on bulkhead in lbs
double nosecone_length=59.000; //the length of the nosecone measure from base to apex in inches
//PART WEIGHTS
double ib1_mass; //convenient variable to hold weight of IB1 part (in pounds)
double p_area; //convenient variable to hold pillar cross-sectional area value
double p_mass; //convenient variable to hold weight per unit length of P part (in pounds)
double t_mass; //convenient variable to hold weight per unit length of T part (in lbs)
double pc_mass; //convenient variable to hold weight of stanard plywood circle (in lbs)
// (Subcomponent Weight and Other Variables)
double ib1_cph=1.000; //IB1 curved inner plate height
double mc_mass; //PM motor casing weight
double il_mass; //insulating liner weight for motor
double nozzle_carrier_mass; //steel turned cylender housing PP nozzle insert on PM
double rear_bulkhead_mass; //rear bulkhead part on PM
double front_bulkhead_mass; //front bulkhead part on PM
double nozzle_mass; //Paper/Phenolic truned nozzle slug
double retaining_ring_mass; //steel retaining ring on read bulkhead
double rear_section_mass; //mass of entire read bulkhead assembly on PM
//MODULE/UNIT WEIGHTS
double rm_mass; //convenient variable to hold weight of Recovery Module
double esm_mass; //convenient variable to hold weight of Extended Science Module
double fcm_mass; //convenient variable to hold weight of Flight Control Module
double dm_mass; //convenient variable to hold weight of Drogue Module
double pm_mass; //convenient variable to hold weight of Propulsion Module
double fa_mass; //convenient variable to hold weight of rear Fin Assembly
//ROCKET WEIGHTS
double r_mass; //Rocket total weight (EMPTY)
double prop_mass=20422.95; //mass of propellant (import manually from FPRED)
double lr_mass; //Rocket Total Weight (Launch Ready)
//GENERIC USAGE VARIABLES
double a,b,c,d,e,f,g,h,i,j; //generic variables for use
double m1,m2,m3,m4,m5,m6,m7,m8,m9; //generic mass variables for use
double l1,l2,l3,l4,l5,l6,l7,l8,l9; //generic mass variables for use
double a1,a2,a3,a4,a5,a6,a7,a8,a9; //generic area variables for use
double v1,v2,v3,v4,v5,v6,v7,v8,v9; //generic volume variables for use
double pl; //pillar length variable for use
//*** WALL THICKNESS PARAMETERS ***
// Note: all design changes to affect weight and performance should be "driven"
// to these thickness variables.
double wt=0.125; //overall wall thickness constant
double ib1_wt=0.125; //IB1 wall thickness
double mc_wt=0.800; //Motor Casing wall thickness
double liner_wt=0.500; //motor insulating liner wall thickness
double nosecone_wt=0.250; //wall thickness of nosecone shell
double pc_wt=0.750; //thicness of plywood circles
//technical constants
double ss_high_speed_steel=80000000000; //shear strenth in Pa (N/m^2)
double bolts_shear_strength; //calculated value for combined holding power of bulkhead bolts (in lbs)
double carbon_fiber_epoxy_tensile_strength=1185000000; //tensile strenght of carbon-fiber/epoxy
double pm_axial_tensile_stress; //variable to contain calculated tensile stress axially on motor casing wall
double mc_tensile_strength; //variable to contain calculates tensile strenght axially on motor casing wall
calculateitemmasses()
{
//IB1: I-Beam 1
//calculate top plate
a1=pow(or,2.0)*PI-pow(ir,2.0)*PI; //gives area of a circular area
a2=a1-(8.0*pw*pw); //cuts the pillars out of the circular area
a3=a2/8.0; //gives us the area for the top pate in an IB1
//calculate curved inner plate
l1=2.0*(or+ir/2.0)*PI; //gives us a hoop the size we need
l2=l1-pw*8.0; //cut out the pillar widths
l3=l2/8.0; //gives us the lenght of an individual curved inner plate for an IB1
v1=a3*ib1_wt; //multiply by wall thickness and we get the volume of the top plate
v2=v1*2.0; //there is a top and bottom plate so multiply by 2
v3=l3*ib1_cph*ib1_wt; //multiply length by height by thickness to get ICP volume
v4=v2+v3; //add all the subcomponent volumes to get the total volume for the
//weight saver: drill holes in top and bottom plates (11 x 1.000" holes)
v5=PI*1.000*11.0*2.0*ib1_wt;
m1=(v4-v5)*d_steel; //obtain mass of an IB1 part by multiplying my its material's unit density
ib1_mass=m1; //store in convenient variable
//P: Pillar (by Length)
//calculate the weight of pillar material by length (inches)
a1=(pw*pw)-((pw-wt*2.0)*(pw-wt*2.0));
p_area=a1; //pillar crosssectional area....need this to do compressive loading calculations
p_mass=a1*d_steel; //to use just multiply this value by the length of the pillar in inches to give mass of pillar
//T: aluminum Tubing (by length)
//calculate the weight of tubing material by length (inches)
//this standard aluminum tubing is 1"x2"x3/8" thick
a1=(1.000*2.000)-((1.000-0.375*2.0)*(2.000-0.375*2.0));
t_mass=a1*d_aluminum;
//PC: plywood circle
a1=pow(or,2.0)*PI-8.0*(pw*pw);
v1=a1*pc_wt;
pc_mass=v1*d_plywood;
}
main()
{
int design_status=1;
double max_velocity, max_drag_force;
double min_yield_strength=36000.0; //in psi
double compressive_force; //in lbs
double maximum_compressive_force; //in lbs
calculateitemmasses();
//preamble
printf("***PART WEIGHTS ***\n");
printf("The weight of an IB1 part is %.3f lbs\n",ib1_mass);
printf("The weight of 1 foot (12 inches) of pillar is %.3f lbs\n\n",p_mass*12.0);
printf("\n");
//calculate the weight of a RM (Recovery Module/Nosecone)
//nosecone shell
v1=4.0/3.0*PI*or*or*nosecone_length;
v2=4.0/3.0*PI*(or-nosecone_wt)*(or-nosecone_wt)*(nosecone_length-nosecone_wt);
v1=v1/2.0; //the nosecone is HALF of an elipsoid
v2=v2/2.0;
v3=v1-v2;
m1=v3*d_carbon_fiber_epoxy; //mass of nosecone shell
printf("\n RM: nosecone shell: %.3f lbs\n",m1); //debug
//streamer subassembly
m2=pow(37.250/2.0,2.0)*PI*1.000*d_plywood; //mass of upper plywood circle; 37" diameter, 1" thick
m3=15.000*PI*15.000*0.25*d_aluminum; //mass of streamer aluminum cylinder; 15" diameter, 15" high, wt=0.25"
printf(" RM: streamer assembly: upper plywood circle: %.3f lbs\n",m2); //debug
printf(" RM: streamer assembly: aluminum streamer can: %.3f lbs\n",m3); //debug
//streamer
m4=30.000; //guestimation of streamer/drogue required for decent stabilization
//REPLACE WITH BETTER NUMBER AS NEEDED!!!
//parachute subassembly
m5=(pow(47.500/2.0,2.0)*PI-pow(30.000/2.0,2.0)*PI)*1.000*d_plywood; //mass of lower plywood circle: 47" OD, 30" ID, 1" thick
m6=30.000*PI*34.500*0.25*d_aluminum; //mass of parachute aluminum cylinder; 30" diameter, 34" high, wt=0.25"
printf(" RM: parachute assembly: lower plywood circle: %.3f lbs\n",m5); //debug
printf(" RM: parachute assembly: aluminum parachute can: %.3f lbs\n",m6); //debug
printf("\n"); //debug
//cargo parachute
m9=125.000; //weight of a military G-12 cargo parachute
rm_mass=m1+m2+m3+m4+m5+m6+m9;
//calculate the weight of an ESM
m1=8.0*5.0*ib1_mass; //mass of ESM I Beams
m2=8.0*esm_length*p_mass; //mass of ESM's pillars
m3=4.0*pc_mass; //mass of plywood circles
m9=200.0*2.0; //two space pilots
esm_mass=m1+m2+m3+m9;
printf(" CM: I-Beams is %.3f lbs\n",m1); //debug
printf(" CM: Pilars is %.3f lbs\n",m2); //debug
printf(" CM: Plywood circles is %.3f lbs\n",m3); //debug
printf(" CM: Space Pilots is %.3f lbs\n",m9); //debug
printf(" CM (Crew Module) TOTAL is %.3f lbs\n\n",esm_mass); //debug
//calculate the weight of an FCM
m1=8.0*2.0*ib1_mass; //mass of FCM I-Beams
m2=8.0*fcm_length*p_mass; //mass of FCM's pillars
m3=4.0*21.000; //mass of monopropellant types (small SQUBA tank - aluminum - weight 21 lbs empty)
m4=8.000*PI*20.000*0.25*4.0*d_aluminum; //mass of instrumentation cans
m5=pow(4.000,2.0)*PI*1.000*0.20*d_carbon_fiber_epoxy*8; //aproximate mass of intrumentation bulkheads (the 0.20 is 20% due to ribbing)
m6=248.000*t_mass; //mass of instumentation frame aluminum tubing
m7=40.000*p_mass; //aproximation of steel supports that connect to intramentation frame
fcm_mass=m1+m2+m3+m4+m5+m6+m7;
printf(" FCM: I-Beams is %.3f lbs\n",m1); //debug
printf(" FCM: Pillars is %.3f lbs\n",m2); //debug
printf(" FCM: Monopropellant tanks is %.3f lbs\n",m3); //debug
printf(" FCM: Instrumentation Cans is %.3f lbs\n",m4); //debug
printf(" FCM: Instrumentation Bulkheads is %.3f lbs\n",m5); //debug
printf(" FCM: Instrumentation Frame is %.3f lbs\n",m6); //debug
printf(" FCM: Steel Supports is %.3f lbs\n",m7); //debug
printf("\n");
//calculate the weight of an DM
m1=8.0*2.0*ib1_mass; //mass of DM I-Beams
m2=8.0*dm_length*p_mass; //mass of DM's pillars
m3=(14.000*PI*10.000*0.25+pow(7.000,2.0)*PI*0.25)*d_aluminum*2.0; //mass of both drogue cans (14" diameter, 10" length, 0.25" thickness)
//Alternate Drogue Module design that uses very flat module and hardpoints for stabilzation
//comment this section out to use original design; this one weights less
m1=8.0*ib1_mass; //mass of DM I-Beams
m2=8.0*dm_length*0.666*p_mass; //mass of DM's pillars
m3=(14.000*PI*8.000*0.125+pow(7.000,2.0)*PI*0.125)*d_aluminum*2.0; //mass of both drogue cans (14" diameter, 8" length, 0.125" thickness)
m9=30.000*2.0; //guestimating weight of two drogue chutes appropriate for controlled descent of spent PM
dm_mass=m1+m2+m9+m3;
//calculate the weight of an PM (Propulsion Module)
//front bulkhead
m1=pow(or-mc_wt,2.0)*PI*0.500*d_carbon_fiber_epoxy; //mass of upper circle; aprox. 46" diameter, 1.0" thick
m2=2.500*0.250*229.000*2.0*2.0*0.8*d_carbon_fiber_epoxy; //close aproximation of honeycomb mass based on a "length" of the plate bein 229" long total
m3=(pow(or-mc_wt,2.0)*PI-pow(or-mc_wt-0.500,2.0)*PI)*3.000*d_carbon_fiber_epoxy; //ring around bulkhead (wall thickness:1.000")
front_bulkhead_mass=m1+m2+m3;
printf(" PM: front bulkhead: %.3f lbs\n",front_bulkhead_mass); //debug
printf("\n");
//rear bulkead
m1=pow(or-mc_wt,2.0)*PI*0.500*d_carbon_fiber_epoxy; //mass of lower circle; aprox. 46" diameter, 0.750" thick
m2=2.500*0.250*165.000*2.0*2.0*0.75*d_carbon_fiber_epoxy; //close aproximation of honeycomb mass based on a "length" of the plate being 165" long total
m3=(pow(or-mc_wt,2.0)*PI-pow(or-mc_wt-0.500,2.0)*PI)*3.000*d_carbon_fiber_epoxy; //ring around bulkhead (wall thickness:")
m3=(pow(24.750,2.0)*PI-pow(24.000,2.0)*PI)*2.000*d_carbon_fiber_epoxy; //ring around nozzle carrier (wall thickness:0.750")
rear_bulkhead_mass=m1+m2+m3;
printf(" PM: rear bulkhead is %.3f lbs\n",rear_bulkhead_mass); //debug
//nozzle carrier
m1=(pow(23.000,2.0)*PI-pow(22.500,2.0)*PI)*16.000*d_steel; //carrier casing (wall thickness:")
m2=(pow(23.000,2.0)*PI-pow(19.000,2.0)*PI)*0.250*d_steel; //carrier rear ring (wall thickness:")
m3=(pow(30.000,2.0)*PI-pow(22.000,2.0)*PI)*0.250*d_steel; //carrier front ring (wall thickness:")
nozzle_carrier_mass=m1+m2+m3;
printf(" PM: rear bulkhead: nozzle carrier is %.3f lbs\n",nozzle_carrier_mass); //debug
//nozzle
//IMPORTANT: requires revision of design from slug diameter down 2->4"
//7.5" nozzle throat diamter indicates usage of AP/Al/R45 propellant
v1=pow(18.000,2.0)*PI*16.000; //start with a solid cylindar
v2=PI*16.000/3*(pow(16.000,2.0)+16.000*6.5+pow(7.500,2.0)); //calculate a negative volume of the frustrum hole thru it
v3=v1-v2; //subtract to get the slug's actual volume of material
nozzle_mass=v3*d_paper_phenolic;
printf(" PM: rear bulkhead:nozzle slug is %.3f lbs\n",nozzle_mass); //debug
//retaining ring
retaining_ring_mass=(pow(35.000,2.0)*PI-pow(16.000,2.0)*PI)*0.250*d_steel; //carrier rear ring (wall thickness:0.375")
printf(" PM: rear bulkhead: retaining ring is %.3f lbs\n",retaining_ring_mass); //debug
rear_section_mass=retaining_ring_mass+nozzle_mass+nozzle_carrier_mass+rear_bulkhead_mass;
printf(" PM: rear bulkhead section TOTAL is %.3f lbs\n",rear_section_mass); //debug
printf("\n");
//motor casing
a1=(pow(or,2.0)*PI)-(pow(or-mc_wt,2.0)*PI); //cross-sectional area of casing
v1=a1*mc_length; //multiply by casing length to give total volume
m1=v1*d_carbon_fiber_epoxy; //multiply by unit density of casing material to give weight
mc_mass=m1;
printf(" PM: motor casing is %.3f lbs\n",mc_mass); //debug
//insulating liners (EPDM)
a1=(pow(or-mc_wt,2.0)*PI)-(pow(or-mc_wt-liner_wt,2.0)*PI); //cross-sectional area of casing
v1=a1*liner_length; //multiply by casing length to give total volume
m1=v1*d_epdm_rubber; //multiply by unit density of casing material to give weight
v2=pow(or-mc_wt,2.0)*PI-pow(16.0,2.0)*PI*1.0; //gives volume of bottom insulator of a circular area
v3=pow(or-mc_wt,2.0)*PI*0.8; //gives volume of top insulator
m2=(v2+v3)*d_epdm_rubber;
il_mass=m1+m2;
printf(" PM: insulating liners are %.3f lbs\n",il_mass); //debug
printf("\n");
pm_mass=mc_mass+il_mass+front_bulkhead_mass+rear_section_mass; //add all the part/subocompent weights together to get PM total weight
//printf(" PM is %.3f lbs\n",pm_mass); //debug
printf("\n");
printf("*** MODULE WEIGHTS ***\n");
printf("The weight of a RM (Recovery Module/Nosecone) is %.3f lbs\n",rm_mass);
printf("The weight of a bare ESM (Crew Module - WITH PILOTS) is %.3f lbs\n",esm_mass);
printf("The weight of a FCM (Flight Control Module) is %.3f lbs\n",fcm_mass);
printf("The weight of a DM (Drogue Module - loaded) is %.3f lbs\n",dm_mass);
printf("The weight of a PM (Propulsion Module) (EMPTY) is %.3f lbs\n",pm_mass);
printf("The weight of a PM (Propulsion Module) (FUELED) is %.3f lbs\n",pm_mass+prop_mass);
printf("The weight of a bare Fin Assembly is %.3f lbs\n",fa_mass);
//calculate total rocket weight by adding stack weights together
r_mass=rm_mass+esm_mass+fcm_mass+dm_mass+pm_mass+fa_mass;
lr_mass=r_mass+prop_mass;
printf("ROCKET TOTAL WEIGHT (EMPTY) is %.3f lbs\n",r_mass);
printf("Propellant Weight is %.3f lbs\n",prop_mass);
printf("ROCKET TOTAL WEIGHT (LAUNCH-READY) is %.3f lbs\n",lr_mass);
printf("\n");
printf("Summary:\n\n");
printf("Airframe Total Mass (LAUNCH READY) is %.3f lbs\n",rm_mass+esm_mass+fcm_mass);
printf("Booster Total Mass (EMPTY) is %.3f lbs\n",dm_mass+pm_mass);
printf("Booster Total Mass (LAUNCH READY) is %.3f lbs\n",dm_mass+pm_mass+prop_mass);
printf("Daedalus Total Mass (DRY) is approximately %.3f lbs\n",rm_mass+esm_mass+fcm_mass+dm_mass+pm_mass);
printf("Daedalus Total Mass (LAUNCH READY) is %.3f lbs\n",rm_mass+esm_mass+fcm_mass+dm_mass+pm_mass+prop_mass);
printf("\n");
//calculate the maximum compressive force due to drag
max_velocity=340.0; //hardcode daedalus maximum velocity in (m/s)
a1=pow(or*0.0254,2.0)*PI;
max_drag_force=0.5*1.225*pow(max_velocity,2.0)*0.022*a1;
//printf("The cross-sectional area of the daedalus is: %.3f m^2\n",a1);
printf ("The maximim drag force is %.3f kg\n",max_drag_force);
compressive_force=max_drag_force*2.2; //in pounds
maximum_compressive_force=min_yield_strength*p_area; //in pounds
printf("Compressive force is %.3f, maximum compressive force is %.3f\n",compressive_force,maximum_compressive_force); //debug
//calculate force on 1" band around motor casing to give axial tensile stress
m1=2.0*PI*pow(or-mc_wt,2.0)*maximum_operating_pressure*1.000;
pm_axial_tensile_stress=m1;
//calculate tensile strength of carbon-fiber epoxy at current mc_wt (times 1.000" so comparing apples and apples)
a1=mc_wt*1.000;
mc_tensile_strength=a1*carbon_fiber_epoxy_tensile_strength;
printf("axial tensile stress (1\" band) is %.3f, mc_tensile_strength (1\" band) is %.3f\n",pm_axial_tensile_stress,mc_tensile_strength); //debug
//calculate maximum force on pm bulkhead
a1=PI*pow(or-mc_wt,2.0); //area of top bulkhead
maximum_bulkhead_force=a1*maximum_operating_pressure; //multiply area by pressure to give force on bulkhead (in lbs)
//do check on shear on the bulkhead bolts
bolts_shear_strength=PI*pow(pm_bolt_diameter,2.0)*num_bulkhead_bolts*ss_high_speed_steel;
printf("Force on bulkhead is %.3f lbs, Bolts combined shear strength is %.3f lbs\n",maximum_bulkhead_force,bolts_shear_strength); //debug
design_status=1; //start at GREEN
//compressive drag forces on Airframe (longitudinal) check
if (maximum_compressive_force<compressive_force)
{
printf("Error: drag force exceeds maximum compressive force of pillars\n");
design_status=0; //it is now RED
}
//bulkhead ejection check (longitudinal)
if (maximum_bulkhead_force>bolts_shear_strength)
{
printf("Error: maximum operating pressure exceeds capacity of retaining bolts to hold bulkhead in place (longitudinally)\n");
design_status=0; //it is now RED
}
//motor casing integrity check (axial)
if (pm_axial_tensile_stress>mc_tensile_strength)
{
printf("Error: maximum operating pressure puts too much stress on motor casing walls (axially)\n");
design_status=0; //it is now RED
}
//RED or GREEN to fly
if (design_status==1)
{
printf("\nThe design is a GREEN...you are good to go.\n\n");
}
else
{
printf("\nThe design is a RED...you need to change your design in order to fly bird. See errors for which constraints were violated.\n\n");
}
}
// CHECK THAT THE DRAG FORCE EQUATION IS GOOD OVER SUPERSONIC DOMAINS (might be the classical version) !!! CHECK THE CODE LATER!!!
```

## Comments