2-D Nickel Titanium Truss FEA

MATLAB simulation (top) and Solidworks simulation (bottom)

For a graduate course on smart and intelligent materials I designed a deployable 2-D nickel titanium truss cell. Nickel titanium alloys, commonly referred to as Nitinol, can undergo incredibly high reversible strains. This is achieved via stress- or temperature-induced phase transformations. The goal of this project is to find a unit cell composed of truss members such that the total strain of the structure is maximized in a specified direction. The advantage of using truss members is that their deformation can be modeled using 1-D laws, which simplifies the analysis of the overall structure.

The only temperature in consideration is at a temperature less than so-called martensitic start, M_s, and below this temperature the phase of the Nitinol is guaranteed to be 100% martensite. In order to be useful, the geometry must be set at a temperature higher than so-called austenitic finished, A_f, where the material is purely in the austenite phase, or the geometry must be cut from a plate initially at that temperature and cooled below M_s. In any case, the truss is designed so that it is deformed below M_s then deployed by heating to some temperature above austenitic finish, A_f. The shape-memory properties of the Nitinol allow these deformation steps to occur. At temperatures below M_s, the material can be seemingly permanently deformed, but after heating to temperatures above A_f, the deformation is fully reversed.

First the nonlinear stress-strain curve is determined from material parameters and the strain is converted from Green's strain to true strain (conversion from the 2nd Piola-Kirchhoff stress isn't necessary for 1-D modeling). In this case, what appears to be the ''yield point" is simply the critical stress at which phase transformations from martensite to austenite begin. In MATLAB, the direct stiffness method (DSM) is used to solve for unknown displacements of the truss nodes as the truss is loaded. In order to handle nonlinear changes in stiffness, which result when one or members begin deforming nonlinearly, a Newton-Raphson method is employed to iteratively close so a solution where the difference between applied nodal loads and internal nodal forces is sufficiently small. This method is used to test different truss geometries before expending too much time analyzing the design in Solidworks.

A comparison between the MATLAB simulation and the Solidworks realization is shown in the first GIF. Note that the color schemes representing the stresses are different. Specifically, in the MATLAB simulation, cyan corresponds to zero stress, magenta to the critical stress, and red the maximum reversible stress. The difference in timing is due to the fact that Solidworks uses adaptive time-stepping. When I tried using the true stress-strain in Solidworks, the solver chose to unload in reverse along the stress-strain curve instead of linearly according to the material modulus. Because of this issue, a bilinear model was used to approximate the nonlinear behavior. As can be seen in the GIF, the design of the truss is realized using flexures for pinned joints. The displacement of the top node for each simulation is shown in the following figure.

Displacement of top node

Note that the Solidworks realization using a bilinear stress-strain curve provides results that closely match what was expected from MATLAB.

Total vertical engineering strain of the structure.

The total vertical strain is shown and the reason for the difference is simply that the initial vertical dimension is necessarily larger in the Solidworks realization. The final strains are -1.34 in the MATLAB simulation and -1.10 in the Solidworks simulation. The magnitude of the Solidworks simulation is more than 16 times that of the material itself.

Thanks to Prof. Carman for his direction. The 1-D constitutive model is based on Brinson's 1993 paper.

Low-Thrust (SEP) Trajectory Design

Earth-Mars trajectory

Capture at Mars to Deimos's orbit

Deimos-to-Phobos transfer

These trajectories to and around Mars were designed for UCLA's Spring 2017 Spacecraft Design course (161C). The class was taught by Dr. Dan Goebel from JPL. My group's mission consists of taking scientific measurements around Deimos (the outer moon), dropping a lander there, then proceeding to Phobos (the inner moon). I designed the trajectories to make this happen by taking orbit data from the SPICE toolkit and using MATLAB's built-in ODE solver ode23. Electric propulsion was chosen over chemical propulsion after conducting a trade study and the 25cm XIPS thruster was subsequently chosen (though the NSTAR would have been slightly better in terms of minimizing launch mass).

This is the mission timeline (1.85 years total).

The launch vehicle is a Falcon 9 Full Thrust and this is the mass breakdown.

Thanks to Nick Brown, Brandon Busbee, Justin Fedasko, Vibhav Gaur, Sunderlin Jackon, and Alvaro Pons Pelufo for making this such a fun group project.

Bonus gif

Multi-stage flash desalinator (MSFD) optimization

For a class project, I used MATLAB to optimize the multi-stage flash desalinator in the solar desalination plant described in the following figure.



Each component within the system contributes to the overall efficiency and cost effectiveness of the plant. Heat exchanges occur in the closed feedwater heater and in the multi-stage flash desalinator, while the thermal reservoir stores excess heat for the night.

The work that I did to optimize the desalinator is detailed in this pdf.

Thanks to Cindy Chou, Zachary Gateley, and Austin Park for being some of the best group members I've worked with.

UCLA FSAE Chassis/Suspension 2016-2017 | Part 2

This is a quick overview of the design and management I did while working on Mk. III, UCLA's entry for the 2017 FSAE competition in Lincoln, Nebraska.

Mk. III at competition

I designed the chassis to 1) follow the rules 2) accommodate the suspension 3) accommodate the other subsystems and 4) to be lighter than the previous chassis.

The driver cell (where the driver sits) was extended significantly from the previous year's so the stiffness of the chassis suffered somewhat, but to an acceptable degree. Nonetheless, all the goals were met, though there is always room for improvement.

CAD of the chassis/suspension subsytems

In addition to the chassis, I designed these pushrod/bell crank/shock assemblies.

Front suspension

Rear suspension

Apart from directly designing these parts of the car, I assigned tasks to other members and helped them complete them when needed. For example, I had a member (Bryce Williamson) determine the geometry of the pushrod/bell crank/shock assemblies based on motion ratios we had decided on. We also went through running the FEA of the bell cranks. The a-arms and their tabs were given to another member (Ben Gerber) to design. Later in the process, Kate Margevicius helped touch up the chassis and ensure it was unequivocally rules-compliant.

In addition to managing the chassis/suspension subteam members, I handled the naming conventions and organization of our Solidworks files.

After the 2016 Winter break, I left the team to focus on other things. In the past year and a half or so, the subteam members had grown fully capable of handling the manufacturing and testing phases of the car. They proved this in successfully bringing UCLA's third car to the competition in Lincoln.

UCLA FSAE Chassis/Suspension 2016-2017 | Part 1

For UCLA's 2016 Formula SAE vehicle, Mk. III, as Chassis/Suspension Lead I determined target suspension parameters (weight distribution, spring rate distribution, damping rates), suspension geometry (wishbone arrangements, motion ratios, shock placement), and I designed the bulk of the chassis. In the previous two years, I focused more on the hardware aspects of the suspension and chassis.

The determination of vehicle parameters was split into three steps:

1. Finding acceptable wishbone geometry
2. Using a pseudo steady-state MATLAB model to find weight and wheel rate distributions
3. Using a five mass, five degree-of-freedom MATLAB model to determine damping rates

Step 1.

I used vsusp.com to find suspension geometries that minimize lateral roll center movement. Camber gain was only lightly considered since the Hoosier LC0 tires we planned to run are fairly insensitive to any gain. Here is a screenshot of the front suspension geometry used.

Step 2.

To characterize the vehicle's cornering characteristics, a pseudo steady-state model was derived. Only lateral acceleration is considered so this amounts to summing all the external forces and setting them equal to the vehicle mass times the lateral acceleration. The external forces acting at the tires induce a yawing moment on the vehicle which is generally not the same as that required to take the constant radius corner at constant speed, which are assumed at the beginning. Hence, the model is only a pseudo-state model. Tire data for the Hoosier 6.0/18.0-10 LC0 is parsed and interpolated to get lateral forces from the tires given the load, slip angle, pressure and inclination.

The process went as follows:

1. Import car parameters
2. Assume body angle, steering angle, and cornering scenario
3. Guess input lateral acceleration
4. Compute tire forces to compute output lateral acceleration
5. Analyze output
6. Return to step 2 or 3 unless an acceptable solution is found

If the output lateral acceleration matches the input acceleration and nothing weird has happened (like a tire lifting off), then the following parameters are checked:

1. Normalized yawing moment
2. The stability and control derivatives, dN/dB and dN/dδ
3. Tire saturation
4. Ride rates

In general, the input tire spring rates must be close to the output rates, but they are not particularly sensitive to changes in other parameters. (1) is used to characterize the ''under/oversteering" of the vehicle. (2) is used to determine whether changes in body or steering angle that pull the car into a tighter corner correspond to decreases in the yawing moment. (3) is used to check that the front tires saturate before the rears so that the driver can feel the front tires loose grip first and therefore have an easier time making corrections. (4) is used to make sure the car does not get too close to bottoming out.

In general, the most important parameters to tweak were the weight distribution and wheel rate distribution. The final weight distribution was around 50/50 rear-to-front and the wheel rates we ran were 23000/18000 N/m front-to-rear.

Step 3.

The final thing to do was to estimate the damping rates. This was done by determining the dynamics of a five mass, five degree-of-freedom representation of the car then simulating the response of the car to bumps and cornering. The following is a graphic showing the five masses and their connections.

 
Dynamic model

The linearized 2nd-order ODE system of five equations is put into state-space form and the MATLAB command lsim() is used to pass bump and cornering inputs.

Constant high speed damping was used in bump simulations, while constant low speed damping was used for cornering simulations. The following is a plot of the front wheel's response to being bumped (y-axis in meters). The Bode plots generated were also used to determine the damping rates by trying to minimize their peaks.

Bump response

Search Results

Chassis step response

The high damping rates were fiddled with to lower the peaks of the Bode response plots and the low damping rates were adjusted to minimize the settling time. The wheel damping rates were converted to spring damping rates so that they could be compared with the dyno plots produced by Ohlins, the manufacturer of the shocks were were using.

Arduino Camera Dolly (Update)

This summer I finished the second iteration of my programmable camera dolly. Everything worked relatively predictably and from the process I gained a deeper understanding of what sort of programming, design, and manufacturing processes work for a reasonably small project such as this.

Through testing my C++ menu library, I discovered that there was an increase in unpredictable behavior after adding a large number of menu objects. I'm not sure if this is due to the limitations of the Arduino or simply a lack of an extensive understanding of it's memory usage.

With respect to design and manufacturing, there were a number of simplifications that could have been made. For one, getting current to the servo that panned the camera up and down should have been approached differently. Without going into to much detail, this iteration used a copper contact plate that required CNC milling. Instead of milling such a contact plate, perhaps conductive washers fitted around the vertical axle could have been used instead. Essentially, without needing a CNC mill, the manufacturing process becomes cheaper and faster. Secondly, a number of parts should have been 3D printed instead of laser-cut from acrylic. Time should not have been spent making 3D assemblies by gluing the edges of flat acrylic. Instead, the laser-cut acrylic should have been reserved for completely 2D components. Finally, a digital servo should have been used instead of an analogue servo. In this case I overlooked a very simple and avoidable mistake.

The following test was filmed on my roof.




This next video shows the machining of the contact plate on a Haas Mini Mill.

A pictorial documentation of the manufacturing process can be found >>> here <<<.

There are a few things I'd like to note. Firstly, 400 step steppers was definitely overkill – 200 steps would have sufficed. Secondly, I just want to mention that the process for fixing the bearings was pretty cool. In most applications, the holes for which bearings are meant are heated (so as to expand the fitting space) and usually the placing material is metal. In this case, the same process worked equally effectively using a lighter near each plastic placing hole. Finally, I would like to release a final design. I want to polish the code further, make a Solidworks parts list and a laser cutting AI file, and include full directions for creating such a dolly. Essentially, I want anyone who has an interest in time-lapse photography to be able to produce a programmable camera dolly at low cost and add a new dimension to their work.

Arduino Library for Adafruit's 2X16 LCD Shields

In order to make programing my camera dolly's user interface easier, I decided to create my own Arduino library. While there were a couple navigation libraries for Adafruit's 2X16 LCD Shields, I wanted to learn how to write a library, something that I haven't done before. Additionally, I had in mind a simpler interface than what I found online and wanted to make numerical input more efficient by entering numbers by place value.

Here are a few features:

• Intuitive menu navigation
• Supports selection of multiple options
• Numerical input of integer and decimal values
• Optional delay for static menus
• Optional menu headings

The .zip file containing the library itself, examples, and documentation can be found here (Last update: Oct. 11, 2014). To get started, go to the "documentation" folder and open "home.html". From here, you can learn how to install the library. Additionally, the page can direct you to several examples and the library's function list.

Many thanks to Prof. Silvan Linn, Grant Paul and Cheng Cheng for their generous help.