Joints in Fusion 360: A Guide to Assembly Position and Motion

JEFF STRATER: Hello, everyone, and welcome to our class on Joints in Fusion 360. We're going to talk today about all things assembly modeling-- component position, motion, joints, things like that. My name is Jeff Strater. I'm a senior software architect. I've been with the Fusion project since the very beginning, focusing on all types of modeling. My partner today is Phil.

PHIL EICHMILLER: Hi, everybody. I'm Phil Eichmiller. I also work on Fusion with Jeff. I'm a principal quality assurance engineer, and what I do is I test Fusion from a customer perspective. So I used to be a customer for a long time and using Inventor, and now I'm working on Fusion with Jeff.

JEFF STRATER: OK, so here's what we're going to talk about today. We're going to start with some assembly modeling basics. We don't have a ton of time today, so we're going to keep it to just a couple of topics. Then we'll move into the main part of the talk and talk about joints. We'll talk a little bit about what they are, how they work in Fusion, why we decided to go with this paradigm, and then we'll talk about some types of joints-- the basics, some advanced topics, and a little bit on debugging your assembly.

So first, let's start with our assembly modeling review. We feel like this is a 201 class, so we're going to go back and review a bit from the 101 class. The two topics we'll talk about is subassemblies and capture position. So let's start first with subassemblies. A Fusion subassembly pretty much corresponds to exactly what you think of in the real world with a subassembly-- something that is assembled somewhere else and inserted into a top level design.

But more specifically, in Fusion, it really means that it's a component that itself has child components inserted into a top level design. And in Fusion, one of the things that's unique among CAD applications you may have used in the past is that all subassemblies are what we call flexible. And what that really means is child components of multiple instances of that subassembly can be in different orientations than each other. There is a way that you can get a rigid subassembly if you want. That's called rigid group. We'll cover that later.

A couple of tips when dealing with subassemblies-- creating joints to subassemblies. So it's always better to create the joints directly to the part level components in your design, not to the subassembly itself. And that's just a tip that I find useful. And then a second recommendation is to make sure that you fully connect all the components in your subassembly before you insert it into the higher level design. And I usually test this by just picking the thing up and dragging it in Fusion, and if all the bits and fasteners and washers come with it, then I know it's fully assembled.

So let's look at a quick demo inside Fusion itself of this flexible subassembly concept. So here we have a design of a part of a room. We've got a component that is the wall and two instances of a subassembly-- and you can tell it's an assembly by the icon here-- that have two child components, a frame and a door, and, most importantly, has a joint here. That joint is owned by the subassembly. And so even though all instances of a component share the same geometry, they can be in different positions. So I can open the door different amounts in each instance-- have one closed and one opened. So this illustrates the point of the flexible subassemblies.

PHIL EICHMILLER: So one of the reasons why this is important to bring up early on here is just one of the core things about how Fusion acts perhaps differently than what you may be used to, or, if you're new to this thing entirely, you need to understand that when you are using subassemblies that have joints in them, which is very common in modeling, this is the kind of behavior you're going to get. It sort of sets up the table for almost everything else you're going to be doing with joints.

JEFF STRATER: OK. Next topic is capture position, and this is another place where Fusion is somewhat unique in the CAD industry. Fusion assemblies are parametric; that is, they're history-based. They're based on the timeline inside Fusion. And this is a bit unusual and takes some getting used to, but is powerful. So things like inserting a component, making a new instance of a component, restructuring a component, making a joint-- those are all timeline entry things. So they are executed in order, and components then can come and go over time.

So one of the ways that this shows itself is with movement. So movement for components is different than movement of any other object type in Fusion. If you move a body, you get a move body feature in the timeline immediately. Components don't work that way. Components have this idea of a home position. So when you do Compute All, or some other compute operation, components tend to return to that home position.

If you move them-- and you can move them by dragging them, you just saw me drag the door there-- you can use the Move command, a line, drive joint, et cetera. Anytime a component is moved, all of them have the same effect, and that's this UI pops up in the upper right hand corner that we call capture position pending. And this basically says some components have moved.

PHIL EICHMILLER: Now, when you see this dialogue-- so this would be the result of, after you've after you've created that condition that Jeff just described in the timeline-- or, excuse me, in the toolbar-- this dialogue would appear if you created a command or started a command that references other components, such as starting a sketch. And it's worth mentioning because I think some people just don't read it, but it says capture the current position or continue in the previous position. The word "continue"-- what that refers to is the Revert command.

So think of this as you're about to do something that changes your model history. Do you want to capture it or revert it? The number one tip would be, if you don't have a modeling purpose for what you're doing, so you're just moving things around to look at them or something like that, always revert or continue in the previous position.

JEFF STRATER: So let's talk a bit about the Capture Position feature itself. So when you hit Capture, either in that dialogue or in the Capture Pending UI, this creates a Capture Pending feature in the timeline. And this feature stores the position of all the components that have been moved at the time it was created. And this feature can enable what we call position-dependent modeling. We'll see an example in a second. And a lot of people don't know, but you can actually edit that feature and adjust the position as captured. So it's easier to do that than to create a second capture position.

So let's look at a real quick example here. Here we have one of those emergency flashlights, where it has a crank on it. You can twist it around. It has a little generator, and can generate power without batteries. So this is kind of early in the design, and I want to be able to close the handle. And you can see that the black rubber part is going to interfere with the case. So I need to create an inset for that so I can close the handle all the way.

Notice you capture position here. I can choose to capture that position, and now I've created a feature in the timeline that captures it. So if I go back before, it's open. If I go forward, it's closed.

And now I want to do a combine-- let me turn off the crank here-- and I want to subtract the rubber handle from the case, and I want to keep the tools. And now you can see, if I turn the rubber thing off, I've got a nice, form-fitting recess for it. And then to illustrate the fact that this can be edited-- say I want to, for some reason, model that handle in a different position. So I can rotate this by, say, 90 degrees. And finish that, and then you can see, now that recess has been created in that new position. So this is position-dependent modeling.

PHIL EICHMILLER: All right, so what are some caveats for capture position? So it is sort of a unique state, compared to other modeling states in Fusion, and it's not a stable condition. You're allowed to save while you're in this position, or while the model is in this state, and you see the position revert or capture up on your toolbar, just so that you could continue working after you saved it or something like that. But if you insert this into another design or do anything that causes a Compute All, that state is discarded. So capture pending will just go away, and then the model seems to fly apart at that point.

So in the example on the right, somebody has moved the bolts into place, using probably a Move or a Line command, and has not captured the position. They save the model and inserted it into another design, and they take a look at it, and all the bolts seem to be in a previous place. So it's just important to capture the position if you have a modeling purpose for it.

Another reason to be a little wary of capture position is that, if you have extra positions in your timeline, they can lead to slow performance, if they involve moving a lot of things around. So taking your entire model and moving it around in your design space and capturing the position at every place, for instance-- if there's no modeling purpose for those positions, then you really shouldn't capture them and just revert them, so you don't incur that cost every time the model computes.

JEFF STRATER: Yep. It's important. OK, that's it for our review. Let's talk about joints.

So joints in Fusion-- what are they and why are they? So when we started developing Fusion, we wanted to, specifically in the area of assembly modeling, to raise the language around assembling components away from the more traditional, mathematical, tangent, align, mate language, and so joints are an attempt to position and define motion of components with more real world, compound concepts. So what is a joint? As it's implemented, it's a relationship between two fixed coordinate systems on two different components. And you can see in the image there the two coordinate systems, and we call those coordinate systems joint origins.

PHIL EICHMILLER: So as you can see, it looks like a coordinate system. So it's got the XYZ. It's got the RGB color, so everybody knows that XYZ is RGB. That's how you identify the axes.

And these really form the basis of connections for all joints. So they are coordinate systems, and you can create them either implicitly or explicitly. So inside the Joint command, what you'll find is that you'll see these things for just a brief instant while you're picking the places where you want to connect things. They actually are attached to those places, and that becomes part of the parametric compute. And the Joint command will consume them, and so you won't see them after that, unless you do some editing or something like that.

Explicitly, you can actually add joint origins to your models before you want to assemble them. So if you feel like it's easier for a component, let's say, that gets reused all the time, and you don't want to mess around with a complicated place to put a joint, you can add a joint origin and get it positioned just right and then reuse that joint origin. Every time you use a joint, you just connect up two of those things, and you've made a joint between two components.

There's plenty of options to position the joint origin when you create it. And there's actually three modes circled right here in the dialogue, which is just the regular placement, between two faces, or the option of at the intersection of two edges.

So now that you know what a joint is and what it does and what it's made of, let's just cover a couple of joint basics. Joints really have two purposes in Fusion. The first is to position components, and the second is to provide motion. So joints are based on how many degrees of freedom that something has. So that's what provides the motion, and the position is provided by the connection of the two joint origins.

There's some different methods for creating joints. There's what we would just call the regular joint, using the Joint command. There's a command called As-Built Joint that's used for when you've done your modeling, where all your components are in one place, and they're already related to each other, and you just need to make those relationships. So instead of tearing it all apart, you add a joint with the As-Built Joint command that deals with the geometry where it sits.

And sort of a special case-- because regular joints are between two components, but there's rigid group, which is a joint that essentially glues together a whole bunch of components. It could be two or 100 or whatever you want to use. Think of an imported design, where you just want it to act like a pump or something, or you just want it to act like one group of objects. Rigid group is a very quick way to quickly glue them all together.

And the last thing on joint basics that's really important to know is that there's the joint snap point. So if you look at the figure to the right there, in mid-joint workflow, you'll see the important, or what I call interesting, places on the face, where you're trying to place the joint. You'll see a little triangle for midpoints, a circle for endpoints, and a crosshair for the center of arcs. A good tip is that if you hold down Control and Command, it allows you to lock onto these interesting points on a face at any one time and move the mouse into, let's say, the center of that circle, to pick the center crosshair on that circle right there-- use Control or Command for that.

JEFF STRATER: There's seven types of joints in Fusion that all describe different types of motion. As Phil just said, these motions are defined in terms of the axes of the coordinate systems of the joint origins involved. The most common one is rigid, which is like a weld or a glue joint, and it doesn't expose any motion. A revolute is like a hinge. It describes rotation around one axis.

Cylindrical is rotation and translation about the same axis. Slider is translation around one of those axes. A pin slot is also rotation and translation, but around different axes. A planar is translation about a plane. Some people like-- beginners, especially, like to think of planar as a mate constraint. It is not, and I wouldn't recommend assembling your design that way. And finally, ball describes rotational degrees of freedom about all three axes.

So we're going to play IKEA here and assemble this robot arm to illustrate some of these points about joints and the basic operation here.

PHIL EICHMILLER: What I want you to notice here is how many different methods Jeff uses.

JEFF STRATER: Right. So first thing to notice is this component. And a tip when dealing with assemblies is double click on a face or edge will select the owning component. So in this case, we've got one called gearbox that is grounded. You can see the little ground pin there. I'll try to drag him. He's not going to move.

So the first thing we're going to do is assemble this mounting bracket into the gearbox And I'll often revert to avoid capturing position. So the first thing we want to do is to create a regular joint between that set of components and this gearbox. So you'll notice the gearbox is sort of dimmed out. That means it's grounded and can't be selected as the component one here.

On the Motion tab, as Phil said, there's two purposes. There's position and motion, and it corresponds to the UI. So we want this to be rigid, and now we want to describe the position. In this case, you can select the face. You can select an edge. We want the center of that circle on one side. And you'll notice, in our gearbox component, someone has conveniently put an explicit joint origin here.

So you could pick geometry, or you could pick the joint origin. I'll pick the joint origin. And one thing to notice-- only one component seems to come along. What happened to all these guys? And the answer is, this is just an optimization for the command to make it faster. And not to worry-- as soon as you hit OK, all of the other components come with it.

All right. So that's step one. Step two, let's assemble this hydraulic cylinder. There's two components here, and they're not joined together yet. So we'll revert them. And as Phil indicated, As-Built joint is used for components whose home position-- remember, every component has a home position-- are correct. So we'll use one of those. As-Built joint, pick the rod and the cylinder here, and then it wants to know what type of joint to create. In this case, we want a slider, translation along one axis, and we just have to tell it what that axis is.

So we've done that. And earlier I said to make sure that your subassemblies jointed. Pick it up, drag it around, the whole thing comes with it, it's good. So next, we want to join this hydraulic cylinder onto our bracket. We'll create another joint. This time, though, we want a revolute joint, and we want it about the center of this cylindrical hole here.

So this is where Phil's hint about holding down the Control key while you're over the cylinder lets you pick the center of that. So now we've got a joint origin-- you can see the glyph here-- that's centered on that cylindrical hole. And then for the other side, we want the center of this rod. We don't need Control here, because the center is visible. And there, you've defined that.

So one thing I like to do whenever I create a joint is to try it out. So drag components around, and it seems to be functioning correctly, so I'll revert. Next, we want to join these two components. And those two are independent, but also notice that they're in the correct position relative to each other. So I can create a rigid group between the two of them, and now they move as one unit, which is how we want them to move anyways. And then create another revolute joint here. Notice that these things now rotate around the same point.

OK, last step is this pre-assembled arm. We want to join it to here. It also is a revolute joint, and we want that position to connect to this position on the arm. Looks right. So again, try out, make sure everything works.

One thing I like to do is to get things into roughly the right position before I assemble them. In this case, you don't really need to capture, because the joint command is smart enough to know what you're-- that it's not a position-dependent command. So we'll use the Control trick there. Select the center here.

Now, in this case, we really want this joint origin to match up with in between these two plates of this component, but there's no geometry there to pick. So that's what between two faces is good for. I'll pick the two faces. And now it needs one more input, which is where, in between those faces, to put the joint origin.

And there you go. Now we've got a fully assembled assembly, and you can see, when I rotate that joint, it behaves correctly.

PHIL EICHMILLER: So what did we just see there? We just saw a regular joint. We saw where someone had added a joint origin. We saw the use of as-built joint, Control and Command to pick a snap point on a face, dragging components to check if what you're doing seems to be working, a rigid group, to group some stuff together that needs to be a group, and between two faces as a placement option. So seven different workflows right there.

JEFF STRATER: OK. A little bit of advanced joints here-- joints have the concept of joint limits. I don't know if you noticed, but when I was assembling that hydraulic cylinder, I could pull the pin clear out of it. That obviously doesn't reflect reality, so you can set a minimum and maximum position or rotation on a joint. Rest is sort of a home position for the joint and can simulate spring motion. We'll see an example.

Next is motion link. Motion link lets you relate the motion of two joints to each other. This is often used in gears, and, in fact, the example that we'll look at uses that.

And the last is motion study. So motion study is a more complex way to model relationships between the motion of joints. You're not limited to two. You can have as many as you want. In that robot arm, I could have made a motion study that shows extending the arm, reaching out, grabbing something, and retracting. The cool thing with motion study is that you can render a video from it, and that can be a useful thing.

So let's look at a couple of quick examples. Here, we'll show a motion link. So here we've got three gears that have been jointed, but not related to each other. So we'll create a motion link. And remember, a motion link is between two joints, so we select the joints. And it wants to know the angles and how they relate to each other. And finally, you'll notice that this thing is going backwards, so there's a nice reverse button.

So we've now related those two joints together. We can do that again. One trick-- when I pick the two joints, you'll notice that, if they're both revolutes like this, it's wanting the two angles. But you don't have to use angles, because it's a ratio. So I happen to know that these two gears are 30-tooth and 20-tooth. So I can use that fact here. And again, I want that reversed. And so you don't have to do the 180, 360, whatever. You can actually express those in terms of teeth in gears. And so now we have a fully functioning gear system.

And then finally, take a look at rest position. So here I've got some slider joints. They all have a rest position. This is a little simulation of a lock mechanism. And what rest position lets you do is this. So these slider joints all want to return to that home position, so as I insert the key into the lock, you can see that the pins all come to their home position, enabling the lock mechanism to work.

PHIL EICHMILLER: All right, so let's talk about a couple of ways to troubleshoot or debug your assembly. There's a few tools and tips here to help you out. Perhaps one of the more widely used tools is the Component Color Cycling. This is under your Inspect menu. If, let's say, everything is all made out of aluminum, and it's a little bit visually hard to distinguish the components, turn on Component Color Cycling, and you get these really bright primary type colors. They're not primary, but they're bright. And they look very basic, and it makes your model light up in a way that you haven't seen before. You can tell the components apart.

If you don't like that much color, but you do like the organizational aspects of the color swatches, you can turn those on in the timeline. There's a timeline control, settings control, and turn on Component Color Swatch. And so you get the same action in that relates the browser and timeline with little color swatches that match up, but without all the bright colors on the model.

So there's also some tools that are directly related to the joints and components themselves. So double clicking-- or, excuse me, just selecting a joint and right clicking on it-- so you can see in the top image there, a joint is selected, and if you right click, the right click menu option will be there to select components. So if you want to see which components are connected to a joint that you're working with, right click on it.

Likewise, if you want to work the other direction and find out what joints are associated with the component that you're working with, you can double click in the model. That selects the component. Right click on it at that point, and you'll see the Context menu shows Select Referencing Joints. And so the joints will all be selected. You go look for them in the browser. It should show you what folder they're in or which component they're associated with.

So those are some tools you can use there. Now, if your joint system seems stuck-- so if you're dragging it around, like Jeff said you should do, and it doesn't feel like it has the correct motion, a couple of things. Make sure that contact sets are not enabled. Contact sets are great for exploring designs and setting joint limits, but they're not recommended to be left in a running state all the time. They can cause some inconsistencies in how things are dragged.

Precision is critical in a closed joint system. So if you're having trouble, think of a physical object, where the motion seems to be locking up, and it may be because things are misaligned. So double check the alignment of holes and faces and the math that's there.

If you have motion links like the ones Jeff was just creating, sometimes those can conflict with joint movement. And sometimes adding a degree of freedom can unstick things, like converting a revolute joint to a cylindrical joint. I've also seen where someone had set the joint limits to have the same minimum and maximum value, and that will also make the joint just not move at all.

JEFF STRATER: Great. And last, a little preview of a coming attraction here. This is something that Fusion has needed for a long time. We're calling it Tangent Relationship, and it will let you do cam follower type motion. So here, we've constrained the two followers to be tangent to the cam. And that will be released later this year, so you've got that to look forward to.

So thank you for your attention.

PHIL EICHMILLER: Yeah. Thanks, everybody, for watching. And don't forget that there's a handout associated with this, so you can go look for the handout and download it. There'll be a lot more information in there. And we'll see you some other time. Thank you.