Designing dynamic folded structures?

Hello,

I'm interested in designing dynamic folded structures and robots. The fabrication process I use uses a laser cutter to make cuts in two sheets of posterboard (or composites). Then, we sandwich layer of thin plastic and adhesive between the two sheets, and everywhere where the laser cutter removed the posterboard, the plastic is exposed and forms a compliant hinge (you can see a Youtube video of the process here: https://www.youtube.com/watch?v=RLJ-FwE9KA8).

The design tools we use for this process at the moment are pretty terrible. We largely do the design manually on paper, and then map that to a flat fabrication drawing in Solidworks. The process would be a lot faster and easier if we could do 3D design in a tool that would enable us to unfold the robot or structure into a 2D fabrication plan. Ideally, the design tool that would let us do that would also allow us to visualize the kinematics of mechanisms.

Rhino + Grasshopper seems pretty promising for applications like rigid origami and folding in general, but I wonder about the ability to simulate kinematics. I've done some googling and reading of the forums, but it doesn't seem like anyone is doing anything precisely like what I've described. Can anyone recommend tutorials or existing projects that might help me get started moving in the right direction if, indeed, Grasshopper is the right tool for the job?

Thanks,

Aaron

Replies to This Discussion

Permalink Reply by Mateusz Zwierzycki on March 31, 2012 at 4:32pm

I think that you can do it with GH, just needs some scripting. Problem here is a proper order of unfolding operation. Actually it can be obtained with proper list management(brute force method : model something in 3d, explode it to single surfaces, reference it to GH in proper order -manually- then unfold it with gh).

To make it really elegant you could try to make some "topology language" - have you seen this talk by Robert Lang http://www.ted.com/talks/lang/en/robert_lang_folds_way_new_origami.... ?

You can always make only few parametric types of structures - like leg, hand etc. (this is much easier than Mr.Lang's ) which can change its sizes, but topology stays the same.

Beside - Your sandwich looks really good, i played something similiar before.... have you tried thin PE (polyethylene) sheets ? Its similiar to PP (polypropylene) but a little bit softer. It is (PP) commonly used as tic tac box cap ( http://www.absolutelynarcissism.co/wp-content/uploads/2011/09/Tic-T... ) and some say that it can fold/unfold about 1000000 times. It would really simplify the whole production (just one cnc router needed to obtain full structure). Of course bending it will require prefabrication to look like e.g. http://www.grasshopper3d.com/video/the-swarm-2012 by Mr. Wieland Schmidt.

To clear things up :

1. It certainly can be done with rhino/gh

2. You should write some more on how should it all work (what you provide as geometry)

3. You should also provide some more info how 2d drawing looks now.

EDIT : I forgot about kinematics - use kangaroo. There are forces now like bending resistance etc.

Permalink Reply by Aaron Hoover on March 31, 2012 at 5:30pm

Hi Mateusz,

Thanks a lot for your input. I'm familiar with Lang's work, but I hadn't seen that TED talk - good stuff all around.

Regarding your comment about using PE in our robots, at the moment, we're actually using PET sheets for our flexures. We try to design so that the flexures don't go through more than +/- 30 degrees of deflection. If the angular deflection is kept small, the lifetime can definitely be on the order of 1000000 cycles.

As for the design process (item 2), ideally the designer would be able to use a simple 3D CAD tool to design a model of a robot, and the geometry would be represented by dimensioning the individual parts in the model. Maybe there should be some parametric primitive kinematic building blocks like four bar linkages, box frames, etc. that a user could build up a robot from. But, the key functionality the tool needs to provide is for the designer to be able to visualize how the robot will move when it's fabricated. This could mean observing (or plotting) the motion of a leg, a wing, or a series of body segments. Ideally, then, the tool would generate an unfolding of the design. How this would work is still very vague - maybe the user would assist in the unfolding, maybe there would be an optimization routine that computes optimal unfoldings based on criteria like minimal waste, or fewest pieces (I would *not* constrain the problem to construction from a single monolithic piece as in origami). The biggest problem we have right now, is that our design process is totally divorced from fabrication. Even if we went through the trouble of extruding individual thin plates in Solidworks and creating an assembly for visualizing the kinematics of a mechanism, that particular representation doesn't transfer easily to the fabrication process because it's essentially monolithic.

Item 3: The 2D drawing is simple a drawing done manually in Solidworks. There are different layers for flexure cuts, outline cuts, and potentially any cuts to be made in the plastic flexure layer. Depending on the robot, there may be many separate pieces for different parts and linkages in a single robot. For example, the drawing for a robot containing a fourbar linkage may have the linkage laid out as a physically separate piece consisting of five rigid links connected by four flexure hinges. During assembly, the designer would then fold up that linkage and insert it into the robot wherever it's supposed to go. If you're curious you can see some sample 2D drawings for older designs here: http://robotics.eecs.berkeley.edu/~ronf/Prototype/ under the "Example Structures" heading.

I noticed Kangaroo seems to be a popular choice for physical simulations. I don't really even need to include forces like bending resistance - I'm happy to allow the design tool to approximate flexures as pin joint-type hinges. Once the design is unfolded, the details of how to cut the flexures could be worked out in a post-processing step. I wouldn't expect the tool to be able to realistically simulate the bending of the hinges.

I'm going to have to dig a lot deeper into understanding Grasshopper and Kangaroo. I only just got started with Grasshopper today by following the folding plate tutorial on wa11ace.com.au today.

Permalink Reply by Mateusz Zwierzycki on March 31, 2012 at 6:31pm

I was thinking about PE as a replacement to both PET sheets and posterboards, so flexures are integral part of "solid" parts, this approach would shorten fabrication to 3 steps - design, cnc milling, folding. The flexures would be obtained by V-carving the PE sheet. This has one disadvantage - PE sheet thickness, which will produce some problems with large angle bending. (after writing it I looked at smallest robots from your page - PE wont help there :))

Back to the software :

ad 2. Making a parametric model of e.g. body of your hexapod is not so complicated. Making a kinematic model is. (as for me, but you should probably ask about that Daniel Piker).

Unfolding, as I said before is an easiest part all of that.

ad 3. As you probably already know - after making a parametric model in gh, you need to "bake" it to rhino. One way of making it smart is to use Giulio's Piacentino bakeWithAttributes script ( http://www.giuliopiacentino.com/grasshopper-tools/#more-1033 )

This will bake geometry into layers(usually all the process is manual).

Iam just thinking right now out loud -instead of making it all with kinematic model, better would be to simulate it like we did here with deltabot ?

Please, take a look at this discussion (which was a challenge itself) http://www.grasshopper3d.com/group/coffee-and-grasshopper/forum/top...

Input data are not kinematic properties of all parts, but only input curve and proportions of deltabot parts.

Permalink Reply by Aaron Hoover on March 31, 2012 at 7:16pm

True, we could go totally monolithic using all PE, but there are some major advantages to using the posterboard (or composites for high performance robots) Laser cutting is a lot faster than CNC milling, and the difference in stiffness between the posterboard/composite and the hinge is very high. This enables us to build very dynamic robots (a six-legged robot that runs 15 body lengths/sec!) very quickly.

Thanks for the tip on talking with Daniel. I'll definitely contact him and try to get his opinion on what he thinks the best approach to creating a parametric and/or kinematic model might be.

As for baking - I had seen mentions of it in passing, but I'm only just now learning its purpose. I didn't realize that the GH representations in the Rhino window aren't actual Rhino objects until just now. I will definitely check out Giulio's baking script. It looks very useful!

That delta robot challenge is interesting. Years ago, when I was in graduate school, I derived the forward kinematics of the delta robot and solved them in Matlab (http://orb.olin.edu/past.htm) when I was working on the design of a micro-manipulator. I'll have to take a look at your and Brian's solutions to understand a bit better what you mean by simulating it as compared to having a kinematic model. My idea of a kinematic model is joining up links and then being able to drag them around dynamically subject to the constraints enforced by the their joints with the other links in the system.

Permalink Reply by Mateusz Zwierzycki on March 31, 2012 at 7:36pm

This is what I was thinking about, but remember that this is only rought sketch.

This approach is not elastic as it could be, it would always operate on similiar topology

(number of legs can be changed, other parameters too)

But it gives you e.g. possibility to play with galapagos evolutionary solver (genetic algorythms), which would be really cool as addition to robot design :D

Back to ted :

http://www.ted.com/talks/hod_lipson_builds_self_aware_robots.html

Attachments:

hexabot.gh, 10 KB

Permalink Reply by Aaron Hoover on March 31, 2012 at 8:10pm

Great - thanks for the sketch! I'm really looking forward to playing with it. Like I mentioned before, I just got started with both Rhino and Grasshopper today, and between your and Daniel's suggestions and help, I've probably got several weeks worth of ideas to play with.

I love the idea of using galapagos to evolve robot designs. Coupled with a basic simulator to evaluate fitness, I could do some really neat stuff. In fact, because our fabrication process is so simple and easy, I could build the top individual from every nth generation of evolution and evaluate its fitness empirically. That would be very cool!

Permalink Reply by Mateusz Zwierzycki on April 1, 2012 at 10:29pm

Please publish here some photos/videos after making your robots with rhino/gh. :)

Permalink Reply by Aaron Hoover on April 2, 2012 at 6:42am

I will certainly document my efforts to implement a robot design process using Rhino + GH here. I'm looking forward to the challenge.

Permalink Reply by Aaron Hoover on April 17, 2012 at 8:30pm

Mateusz,

I finally got around to checking out the Delta robot challenge files. Those are fantastic! The cool thing for me is that the files exactly implement the theoretical kinematics graphically, so now I have a better idea of how to generate kinematics of closed chains in Grasshopper. Constructing the graphical intersection of constraint curves and surfaces is equivalent to solving the inverse kinematics equations directly, which is very nice and powerful when combined with parametric design.

I need to spend some time thinking about mocking up the kinematics of one of my robot designs now, but I think I have a much better idea of how to approach the task after looking at the deltabot challenge.

Permalink Reply by Mateusz Zwierzycki on April 18, 2012 at 7:15pm

Great to know that our help is usefull :)

I didnt try, but I would say that this IK approach would not work well with more degrees of freedom ;/ But for your purpose it seems to be fine. (please remember that I'am not an IK specialist ;))

I would recommend you also firefly plugin + arduino stuff.

http://www.grasshopper3d.com/group/fireflyplugin

With this combination youll be able to control your robots directly from gh. So to complicate things more:

you can find some solution with galapagos (digital)
fabricate it (real)
control real model with firefly
use galapagos again to find best solution for real robot movement (robot would make e.g. 10 steps, measure travelled distance, then return measured distance back to galapagos...so the distance= fitness to make it clear)

"...Because the mass of a robot is proportional to its volume, the increase in this ratio means that surface forces (electrostatic attraction, for example) become large compared to inertial forces..."

In my neither professional nor scientific mind, I can imagine that problem you're solving has to be defeated with design of "hardware" rather than "software". If so, firefly would be useless(?) for you, but for me it would be first thing to try :).

I watched a TED video where someone (I really dont remember who) made a human kinematic model and with genetic algorithm it "learned" to walk...

Permalink Reply by Daniel Piker on March 31, 2012 at 7:48pm

Hi Aaron - Very interesting project, and I'd love to see if Kangaroo can help.

It is possible to take any mesh and automatically unfold it. The example on this page:

http://www.grasshopper3d.com/group/kangaroo/page/example-files

called 'shell_and_plate_example' contains a slider for the rest dihedral angles between faces. When it is at one, the mesh will try and keep its shape, and when it is at zero, it will flatten out. If the mesh is developable then it will maintain areas and lengths during unfolding, but if not it will have to stretch

I also just uploaded this video of some recent experiments with adjusting shapes in 3d while keeping them developable:

By bidirectionally linking the dimensions of a flat and a folded version of the mesh, it is possible to manipulate either one and see its effects on the other.

Generally if we start with a 3d model of a folded shape, such as a piece of origami, and move its vertices around arbitrarily, we destroy this condition of developability, and it can no longer be unfolded to a flat sheet.

In the plane, angles around each internal vertex obviously always add to 360°, so if we triangulate the mesh and make sure the folded and flat versions always have the same edge lengths, we can ensure it is always unfoldable.

You might also be interested in the 'Walker' example contained in the SimpleKangarooExamples zip on the same example page linked above. it contains a SodaPlay style walking creature modeled as a simple linkage with dynamic rest length springs as 'muscles'.

It is late here now, but I'll try and post some more examples tomorrow.

Permalink Reply by Aaron Hoover on March 31, 2012 at 8:15pm

Wow. This is all really great stuff - thank you. I'm a complete newbie to Rhino/Grasshopper/Kangaroo, so I've got a lot of options to play with here. My requirements are pretty specific, based on my target application and our fabrication process, but I'm hoping with the help of the Grasshopper community I can make something work.

Over the next week or so, I'm going to try to dive deeper into these tools, and I will keep you all posted on my progress. I'll undoubtedly have more questions going forward!