Design with Just 12 Commands: The Essential Modeling Commands in Autodesk Fusion 360

PHIL EICHMILLER: Hello, and welcome to Design with Just 12 Commands: the Essential Modeling Commands in Autodesk Fusion 360. This is the Safe Harbor Statement. Because Jeff and I are both employees of Autodesk, we have to present this statement to you. This will be in the recording and you can read it later if you need to.

JEFF STRATER: Welcome. Our agenda today, we're going to do a relatively brief introduction to the topic, why we think this class will be useful, but we will spend most of the time in demonstration inside Fusion demoing these concepts. And then we will allow a half hour toward the end for Q&A.

And just a note, our entire focus today will be on the Design workspace. We're not really going to talk at all about Simulation or CAM or drawings or anything like that.

PHIL EICHMILLER: My name is Phil Eichmiller and I'm a mechanical designer by trade. I have spent 10 years with Autodesk, testing Fusion 360 as a quality assurance engineer. I work with the Fusion 360 online community, and I also teach at a local community college.

JEFF STRATER: I'm Jeff Strater. I'm a director of engineering, but I have spent most of my career here as on the development side of Fusion since the very beginning. My time has been focused on the areas we're going to talk about today in the design workspace, so general modeling, sketching assembly modeling, and so on.

Prior to that, I was a developer and architect on Inventor, and again, even before R1. So I definitely have CAD running through my veins.

PHIL EICHMILLER: So why are we putting on this class? The reason Jeff and I thought this was an important topic is that both of us spend a lot of time with customers on the Autodesk Fusion forum helping, answering questions, and a lot of times we run into new users who are telling us that Fusion is hard to use. There are so many commands, where do I start? And it takes too long to learn. And I also get some of this from my students, who may be new to CAD or new to 3D.

So Fusion can be intimidating to new users. I mean, there's a lot there to take in in any CAD tool. But you can also create a lot of geometry with just a small number of commands, and so we thought that it would be cool to show how, by focusing on just a handful of commands, you can actually get quite a lot done.

JEFF STRATER: With Fusion, as with most significant software packages, I believe that there's just a handful of concepts that you need to learn, and once you master those, the rest of the application will become obvious to you. Phil and I are big fans of analogies, and the analogy that we realized for this topic is learning a language.

When you learn a language, you don't start out by learning tens of thousands of vocabulary words. Instead, you learn about the grammar. You learn about the syntax. You learn how verbs work, how verbs are conjugated. You learn whether nouns have genders to them, things like that. And once you master the basic concepts of how to build a sentence in a language, then you go back and add all the vocabulary.

So if you've ever taken a foreign language class, you kind of start out talking about just a handful of things. You talk about a room, a table, a chair, a door, the window. And so today in our class, we're going to talk about the Fusion equivalent of the door, window, chair, table, whatever, and teach you instead about how to form a sentence in Fusion and how to use some basic set of commands to do modeling. And then you can go back and learn the rest of the commands.

PHIL EICHMILLER: One of the things I noticed when I have been using the curriculum that I created for my college classes is that the simpler I made assignments up front-- so concentrating on just the most basic things and scraping away all of the extra stuff-- I realized that by focusing on just a few core concepts and commands just at the beginning, that I could get more out of the students as they progressed through the rest of the learning.

And so this is an example. After just two sessions, this is a project that we do. There's just a handful of lines and arcs and constraints here, but learning this style of sketching and this style of modeling and after just two sessions, it might seem like a rather simple example, but then you have this after 20 sessions.

And so this would be the final project of a student of mine from my advanced class. So this is after taking Fundamentals in Advanced Fusion. They applied all of those ingredients, those basic phrases and words, as Jeff was talking about, into how to make this windmill design.

I didn't teach them how to make a windmill design. This engineer already knew how. He was a retired engineer. But once he knew the basics of the modeling commands, the windmill works. You can turn the blades. The gears all work. The little valve goes up and down. The little check valves on the right there will keep the water in place. And everything works mechanically, as intended.

I did not intend for this student to make a windmill. They brought that to the table and applied all of these basic lessons to get it done. So I think this is a good validation of this approach.

JEFF STRATER: OK, now we're going to jump into Fusion, and we will start with a bit of a confession. We lied a little. It wasn't really intentional. We weren't quite able to stick to 12 commands. We suffered a little inflation in our class, and it's more like 15 commands.

But we were fairly honest about this. We didn't use press-pull as one command and cheat by saying, oh, well, press-pull is one even though you can do extrude, fill it, surface extend, whatever. What we did do is underestimate the amount of sketching that we would need and some of the assembly workflows. And we can't count anyways.

PHIL EICHMILLER: So here's the plan for the demo. We'll stick to our 15 commands, but as we go, we'll try to bring in a few examples of why the other 1,488 commands in Fusion 360 exist. Now we don't have time to talk about all 1,488 other commands, but we'll show you a few examples where you can extend some of the concepts in these very simple commands and see how they work together in more complex commands and then you can bring those into your workflows and become more efficient once you have that basic understanding.

And we think this is a good way to learn Fusion. Once again, just restating, learning a handful of simple commands, how they work together, and then just slowly bringing in the more advanced commands.

JEFF STRATER: So this is the model we're going to build over the next 50 minutes or so. We should point out up front that this is a fully working model. All the joints operate as intended. Obviously in the space of time, we've left out a lot of the details. There's not going to be any gears in this design. We're not showing all the fasteners that you would need to build something like this.

But we chose this model because it's not a trivial model. This is not just a box with a couple of holes in it. This is an actual, workable design.

PHIL EICHMILLER: Here are the commands. So you'll see I've color-coded them. They're broken up a little bit, because Create Component really does belong at the head of this list, but you'll see that there's Assembly, Sketch, and Create commands. And the Create relates to 3D geometry. We'll come back to this when we're all done and see how we did. Let's hand this over to Jeff now.

JEFF STRATER: OK, here's the model that we're going to be building today. This is the final version of it. This is shared in the content for this class on the AU website, as is a very detailed handout that details all of the steps that we go through to build this model.

In the interest of time, we may skip over some steps today, but all those steps are in the handout and you can reproduce them yourselves if you'd like. So this is where we're going. So let's dive right in.

And to prove that we're doing this from scratch, we'll create an empty design here. The first component we're going to build is this gearbox, and we'll zoom into it a little bit. It's a fairly simple component, but we'll start with that. So let's go over to our blank design.

Now what you'll see here is a pattern that we'll repeat over and over. We're building this entire design as all internal components, so we're not going to be referencing external designs. So the first thing we'll do for each of these components is create a new component, and then we'll do a sketch and, usually, an extrusion as a way to create geometry.

So you'll see that pattern over and over and over again. So let's do that first. Our first component is the gearbox. We'll create it. And notice, we'll give it a name. And creating a component automatically activates it. This little circular UI here shows activation.

And Activated Component simply means that every new object that we create is owned by that component. And so you'll see that, as we Create the sketch, in this case, we're going to sketch on the y, z plane because that's how we want our design oriented. So there's our first two commands. Create Component, Create Sketch.

Next, the basic geometry of this gearbox is a rectangle. And there are different types of rectangles. We're going to spend a lot of time today on the center rectangle. It creates a nice, centered-- as its name implies-- rectangle. And we're going to give it some dimensions as we go.

PHIL EICHMILLER: One thing you should notice, in this case, one of the key, easy things to get is that when you're designing something symmetrical, you always try to put it around the origin to begin with, and Jeff has done that here. And you'll see this over and over again that we're working with a symmetrical design and working with these center rectangles to get our design right in the middle of the world it needs to live in.

JEFF STRATER: And that's all the geometry that we need for the outside of this gearbox. Our next command is Extrude. You'll see us use this a ton today. This is one of the more basic solid geometry creation commands. It automatically selects the profile because there's just one. This drag handle lets you add some distance. We'll use a simple distance extrude for this one, and then we'll give it a precise value.

OK, so this is the basic geometry of our gearbox, but there's one more piece that we need, and that's a hole. As I said, we're not going to model the internals of this gearbox, so you're not going to see the actual gears, but we are going to create a hole that the shaft of the assembly is going to go through, which is how the mechanism works.

PHIL EICHMILLER: You'll notice, too, that as Jeff was dragging that around the center, you can see that a white dot appears in the center of the face, and that's the Hole command showing you how to snap the hole to the center of the face. And so that's how this hole is getting located while Jeff is creating it.

JEFF STRATER: And then say we want to make the hole for the shaft 30 millimeters. So we add a hole. So now we've got this geometry. This is going to be the basic shape for our gearbox.

The last thing we do, and the fourth step in the process that you'll see over and over again, is we create the component and the geometry, and then we want to create some assembly relationships, or joints. So right now, this gearbox is free to move around. I can drag it around, but I want it to stay fixed.

So the first assembly command that we'll use today is the As Built Joint. There's two types of joint, a Simple Joint and an As Built Joint. You're going to see us a lot build components in place. When components are built in place, you can use this As Built Joint to say the components are where I want them, I just want to tell you how they're going to move.

And in this case, we want to create a joint between our gearbox and the world coordinate system. So it turns out the root of the design here is also a component. It has an origin and I can create a relationship.

In this case, we want it to be rigid, and you can see that it's rigid. I like that animation. Not everybody does. But that will fix it in place. So now I can't move this anymore. So it's fixed in place.

So we're done with our first component. We'll re-activate the root.

PHIL EICHMILLER: And this is a pattern you're going to see over and over again. Jeff is activating the level of the assembly where the next component is going to be created. So you're just thinking one step ahead there. So if the next component is created underneath the root right next to the gearbox, that's where the root is active and the next component is created.

JEFF STRATER: And that next component is one we've called the mounting plate. It plugs into the gearbox. It has a shaft that plugs into the gearbox, and then has these mounting tabs for the arms and the actuators for this robot model. So again, New Component.

PHIL EICHMILLER: I've heard that naming everything is a good practice. What do you think, Jeff?

JEFF STRATER: I like to name everything. Yes, certainly.

PHIL EICHMILLER: Yeah, it shows.

JEFF STRATER: And Sketch. This time, instead of sketching on one of the origin planes, we'll sketch on the face. You can sketch on any plane or face of the model or work plane. We're going to choose the face of the gearbox. And notice that the geometry-- and this is a setting. You can control it-- but the geometry from the face of that component has been included or projected into our sketch. This will be useful in a minute.

Next, if you remember the basic shape of this mounting plate is a circle, we'll give it a fixed diameter. And that's all the geometry that we need for this part of the mounting plate. And so again, Create Component, Sketch, Extrude. You'll see this more times than you probably want to see today.

PHIL EICHMILLER: I was going to say, I was just going to mention as you're picking through to make this extrude, you have to select all three of those profiles. So the way that Fusion broke up that geometry, it also must be reflected in how you extrude it.

JEFF STRATER: OK, so we'll give it 20 millimeters of thickness. The next piece of geometry will add to this mounting plate is that shaft. By virtue of sketching on that face, as we saw, the geometry of that face is included in the sketch. So if I go over here and turn that sketch back on, you can see we've got that sketch geometry.

And just for a minute, I'm going to turn off the gearbox, the little eye icons, turn off the box. And I will pick just the center circle, and you can see, if I turn the box back on, that that matches with the hole in the box.

Now in real life, you're going to have some tolerances and that'll have to be a little bit smaller, but for our purposes today, this will serve well. Now we could figure out exactly the depth to make this. I think 150 is what I made this. And you could type that in, but the next trick that we'll show is Extrude Supports, a two object mode. And I can pick the back face of this gearbox and make that exactly the right length.

PHIL EICHMILLER: And this is going to be the primary lesson that we show every time that Extrude comes up. Jeff is going to use different start and finish termination options. So that Extrude command, while it's one command out of our 15, it's a really powerful command.

The lesson really for all of the commands in Fusion, extending this into all 1,488 commands, is that every one of them has some sort of options-- or most of them do, I should say-- and those options are meaningful in terms of how the command functions. So as you're learning these basic commands, look for the options, find out what they do, and see how those options work in other commands like Revolve instead of Extrude, for instance.

JEFF STRATER: OK, now we're going to make those mounting bosses for the arms and the actuators. The first thing we're going to do is use yet another command, Sketch Line, and we're going to make a couple lines to make centering the geometry easy.

Now, informally we call them construction lines, but if you select them, you can actually make them be construction lines. It makes them dotted and not as prominent. Next, we're going to use our friend the center rectangle again, and we're going to set a height and width.

PHIL EICHMILLER: So while Jeff is doing this, you might notice that inside the center rectangle, you'll see some familiar shapes now. Those are also construction lines. The center rectangle has that x that's orange at the moment. Those are just construction lines connecting the corners, and it has to do with how that geometry is formed.

So as Jeff is working here, you'll notice also that the construction lines do not create profiles, and that's the reason they exist. Solid lines create profiles, and construction lines do not create profiles, but you can think of them as sort of the things that you're hanging the geometry of your model onto, these construction lines. They're like a framework for the geometry that's creating profiles.

JEFF STRATER: OK, so the next thing, up until now, we've only typed in values for the rectangles. That's where these dimensions come from. But sometimes you want to dimension things directly. There is a Sketch Dimension command. And so we want to fully constrain our sketch. And you can tell that when all the geometry turns black.

PHIL EICHMILLER: And this is something that I get asked by students a lot. It's like, well, why is it necessary to fully constrain your geometry? And I turn it back on them and say, well, it's about defining your design intent. So the shapes aren't here randomly, so they have to be defined. And if they can move around on the screen by being dragged, it means that you haven't added dimensions or constraints to fully capture your design intent.

JEFF STRATER: So the next thing we'll do is actually create some divisions in these rectangles, because those mounting bosses, there were two at the top and there were three at the bottom. So we're going to add a couple lines to break up our rectangle. And I'm going to come back and Dimension them in a minute so that they're precise.

And we want this to be symmetric, so we'll Dimension to that center line. That's what it's there for. Oops, I got the wrong geometry there. Be careful about what you pick. I want this to be the same as this 20. I could type in 20 and that would work, but there's a trick. If I click on the 20, it actually creates a parametric reference to that dimension so that if I change this to, say, 25, notice how it's keeping that symmetry.

Do the same thing down here. And a couple more dimensions and we're ready to go.

PHIL EICHMILLER: And so if this is starting to look like an awful lot of stuff to remember, just remember that there is a handout. Basically it's a tutorial with all of these sizes and shapes and every step that we're taking, or Jeff is taking here, to get this drawn. So if you want to recreate this whole thing yourself, there will be a handy dandy guide for that included in the handout.

JEFF STRATER: Sorry, I keep picking the wrong line here.

PHIL EICHMILLER: Oh, that's all right. You're new. We'll forgive you.

JEFF STRATER: Yeah. There we go. OK, now we've got the geometry we need for our mounting bosses. We'll use Extrude again, and we'll pick the geometry regions that we want to create our bosses from. Let's make it a little bit bigger.

Now, if you've paid attention, you'll say, that doesn't look like the geometry we wanted to create at all. They were nice and rounded. What happened to that? So that is our next command, Fill It.

Fill It usually is used for doing what we call edge fillets, picking an edge, doing a nice blend there, but we're not going to use it for that. We're going to use a special mode. And in any command, there can be these multiple types of options. We're going to use one we call Full Round Fillet.

PHIL EICHMILLER: So while Jeff is doing this, I want you to notice that the highlighting that appears on the box faces really determines which face is rounded and which faces sort of participate. So if you're going to try the Full Round Fillet, have a little patience, get used to where you need to click to get the curve to go in the direction that you want it to go. I promise you it'll work, but it does depend on your clicks.

JEFF STRATER: And the last thing we need is some holes. And as Phil pointed out earlier, you get these nice dots to snap to. So here's a case where we use the center of that. In this case, we want the diameter to be a little bit smaller because all our pins are 15 millimeters. And then we'll need one more.

And here's another trick. If you right click, you can repeat the last command.

PHIL EICHMILLER: And Hole will do you a favor by remembering what was the last hole you created.

JEFF STRATER: Yeah, the other trick we'll show here is a Through All option, which just says find all the geometry you can in that direction and cut through it.

OK, so our next component is done. Again, the pattern will create a relationship. We can use As Built Joint, because this was built in place again, only this time we don't want to rigid relationship. We want it to spin. So it's asking for what geometry you want it to spin around and you can see that it's got the right motion.

PHIL EICHMILLER: So when you add a joint that gives motion so it's not a rigid joint-- I suppose if you try a rigid joint, you should also do the preview-- but really, when you're trying to design in motion to capture design intent, use that preview. Make sure the joint is doing what you think you were creating when you designed it, but give it that check. That's really worth it.

JEFF STRATER: Exactly. Yep.

OK, so the next component, we're going to create these upper arms, but before we do that, one trick that I like, under the Inspect menu, there's an option called Display Component Colors and what that does is sort of put the default colors-- so everything is steel by default-- put the default color away and give it these what we call skill colors. And that applies to your entire session, so if I go back to my reference design, you can see now this whole thing has these nice neon colors.

The next command-- component-- I keep calling them commands. Why am I doing that, Phil?

PHIL EICHMILLER: We're thinking about commands here. We can't help it.

JEFF STRATER: I guess so-- is we're going to create these hockey stick-looking arms here.

Again, we're going to do our same pattern. We're going to Create a Component.

PHIL EICHMILLER: An internal component, you'll notice.

JEFF STRATER: An internal component, yep. And we'll create a sketch. This time we're going to sketch on this face of that top mounting boss. And again, the geometry is projected into the sketch.

And again, we want to create some construction geometry. That is a significant piece. And then also we want to give it some length. These arms are actually pretty long. And we'll create the angled part. We want this to be 30 degrees and, say, 250 millimeters long.

And as before, we'll make those things construction just so that they're not quite in our face.

PHIL EICHMILLER: This is where you'll really start to see that construction line being kind of like a skeleton for some other geometry to support it and help give it a position. You'll see that really come into play over the next few steps Jeff takes.

JEFF STRATER: So I'm using a Center Rectangle again to give some width to our arms and typing in values. Right, so now we get to add some geometry for the lower end of the arms. I will use a line for this. And you can see, we're snapping to a parallel with our construction line.

PHIL EICHMILLER: Did you have to do that trick where you get the one line interested in the next one?

JEFF STRATER: Correct. And you do that by touching it. And once you've touched it, it's in the list of things to be interested in, and gets that parallel constraint. And then as before, we want to add some dimensions to get nice and fully constrained.

And the last thing we'll need, we need some circles. We could do these as holes, but since we're in the sketch, another way to do that is to just draw circles.

And again, we use Extrude. Now because we sketched on the face of the mounting boss, we need to select an extra profile there and then a profile for the bottom of the arm. And then we'll give it some width, some thickness.

OK, next we're going to add the slots. So we'll create another sketch on the base of this. And we could have done this all in one sketch, but it would have made a pretty busy sketch. So instead, we'll make a separate sketch. So in some sense, this construction geometry is duplicate, but it's OK.

PHIL EICHMILLER: Well it certainly is easy enough to put in there.

JEFF STRATER: Yeah.

PHIL EICHMILLER: Yeah, and another idea that Jeff is showing here is that to get more than one feature into a component, it's OK to continually sketch and add new extrudes or, in this case, it's going to be a cut, but it will be an extrude. So that's just a common workflow if you're new to this sort of thing. Sketching and extruding, it doesn't have to be all in one sketch. You can actually make multiple sketches for every part.

JEFF STRATER: So we've created a couple rectangles here, and then it's just a matter of cutting through the geometry. Just like we showed before, you can do two object and select the back face of the arm.

PHIL EICHMILLER: So another one of those Extrude options coming into play right there.

JEFF STRATER: Right. And again, we wanted to create nice, rounded geometry, so we'll reuse our Full Round Fillet trick to do that.

PHIL EICHMILLER: I don't want to jinx you, Jeff, but you're pretty good with this where you put the mouse on these things. There you go. It's really just a matter of understanding which face it's going to highlight. Well, there you go. I did jinx it.

JEFF STRATER: Yeah, you did. Exactly. Thanks. Thanks for that.

PHIL EICHMILLER: Well, I want to give users and customers, I should say, confidence that when they see you having so much fun with it, that they know they too will have a lot of fun with it. So there you go.

JEFF STRATER: OK so see, in just a single feature, we've turned that from a very blocky, ugly thing into a much more pleasing shape. So this is one of the cases that Phil talked about where we're going to show you an easier way to do it. Because this operation of creating these slots is common enough, there's actually a command for that. So again, we'll put in a construction line.

PHIL EICHMILLER: So full disclaimer, what you're about to see is not on our list of 15 commands. This is an extension of that, but you'll see why in just a second. So if anything Jeff has done so far felt a tiny bit repetitive, watch what happens. This is almost CAD magic compared to what you just saw.

JEFF STRATER: Right, so that's another way to create the slots. So that's technically 16 commands.

OK, we're done with this. So again, we're going to create a joint, in this case between the arm and the mounting plate. And we want this to be revolute so that we get rotation. And that looks good.

PHIL EICHMILLER: Because it already had position, all you had to do is add the motion to that.

JEFF STRATER: Exactly.

PHIL EICHMILLER: That's what As Built is great at.

JEFF STRATER: But we need two arms. We could go through that whole process again, sketch on the other face, create all that geometry again to create the second arm, but there's no reason to do that. Instead, we can Copy and Paste this, which creates what we call a component instance. This is another copy of the arm component.

But now, we need to create that revolute joint, and in this case, the arm is not in place. So we're going to bring out our other type of joint. This thing needs a better name, Phil. I keep calling it Regular Joint or Simple Joint. It's just a Joint.

PHIL EICHMILLER: You could call it a position joint. The other one is As Built. The only difference is this one has position and motion included in it. So that's a good way to keep track of it. The icon even tells the story.

JEFF STRATER: And so first we'll describe the position. We'll pick the hole on each side, and now we describe the motion. So why didn't I have to pick the circle? Phil, why didn't I have to pick the circle?

PHIL EICHMILLER: I don't know. Tell us, Jeff.

JEFF STRATER: Because the geometry, we'd already defined the axis by picking the circles the first time, so there's no reason to pick them again.

PHIL EICHMILLER: That sounds right.

JEFF STRATER: The last step for these arms-- now we've got two arms. They move right, but they move independently from each other. We don't really want that. There's plenty of ways to do this, but our friend, As Built Joint, can come into play here, too.

These components are in position with respect to each other, so we can create an As Built Joint and, in this case, we want them rigid. Now you can tell from that animation what's going on. So rigid does not mean fixed in space. It means rigid with respect to each other. So now that I've done that, they move together.

PHIL EICHMILLER: And the use of As Built Rigid Joint is-- you'll see pairs of other things coming up here. And this is going to be something that Jeff does over and over again. So this is a good concept to latch onto there.

JEFF STRATER: OK, next we're going to create a sub-assembly, the lower arm assembly. And it's this hydraulic looking thing where the shaft slides in and out of an outer tube.

So this is the first component that we're going to create that we can't create in place. And why? Remember, our pattern is Create Component, Create Sketch, Extrude. These things need to be attached to kind of this end of these arms. There's no plane to sketch on here. So we're going to create our first Out of Position Component. So first, we're going to create the sub-assembly.

PHIL EICHMILLER: Well, it's another key distinction. Watch what Jeff's doing here. Because this component is called a sub-assembly is active, another component created while it's active will turn it into an assembly. And as soon as Jeff hits OK, you'll notice the little icon changes to a stack of boxes. And so now there is an internal sub-assembly with an active new component.

JEFF STRATER: So it doesn't really matter where we create the sketch. So we're just going to create it on one of the origin planes. And what we're going to create is a couple of circles. Remember, we're creating a tube.

PHIL EICHMILLER: So this geometry is going to end up floating in space, because there's no engineering need to give it a location right now. So Jeff is fully capturing the design intent of this part by the sizes of these the circles and the lines. All the sizes that are being entered in here, but there is no location because once this is created, location will be handled by the assembly commands. So as long as the design intent is captured, that sketch is fully defined.

JEFF STRATER: So we're going to end up doing two extrusions. We're going to do one for the outer tube. It's a bit longer than we need, I'd say.

Now I don't know if you noticed. When I created that sketch, I added an extra vertical line there. What was that for? If you kind of go back to the model here, you can see there's a flat mounting plate here. That's what that's for. So we'll just select a different set of profiles.

PHIL EICHMILLER: And this is also another case where you're reusing a sketch. So making it visible and extruding again, that's pretty common. And again, we're finding that center point for the hole here. There it is. Just dragging it around, it'll light up that face.

JEFF STRATER: OK, so that's the outer tube. So now we want to create the inner tube. So we'll activate the assembly again, create another new component.

This time we're going to sketch on the end face, but as before, the geometry from that face has been projected into the sketch, and that's all the geometry that we need. We don't really need to draw anything here. And that's a useful trick as well.

PHIL EICHMILLER: When parts fit together, sometimes the geometry is already there for you.

JEFF STRATER: We're going to show a different feature of the Extrude command, and that's the ability to extrude in two directions. So I can go back this way 700 millimeters and go this way say 200.

PHIL EICHMILLER: And if you're looking closely at the Extrude dialog there, a whole bunch of new things just opened up just based on that choice. So different options will appear in the dialog if you make a different termination or start condition.

JEFF STRATER: And finally, we'll create another hole. One of the things that the Hole command can do is reference other geometry. So if we want this to be 20 millimeters from the end of that shaft, we can do that.

OK, again, we want to create an assembly relationship here. We can use our As Built Joint. We're going to relate the two parts of the sub-assembly to each other. This time we want it to be a slider, because this will slide in and out. And

Then the last thing we want to do is hook it to the arms. It was not built in place, so we use a regular joint, specifying position and motion. And notice that the preview doesn't show both pieces moving, but as soon as we hit OK, they do.

OK then the last thing we'll do is create another instance of that lower arm assembly.

PHIL EICHMILLER: Does anybody watching remember how this is going to happen? It's our good old friends, Copy and Paste.

JEFF STRATER: This time we need it rotated because it mounts the other way, which you can kind of see here.

PHIL EICHMILLER: Yep, immediately upon getting pasted, the Move Copy command comes up to give you a chance to position something, and that's what Jeff just did there. That actually happened automatically upon Paste.

JEFF STRATER: OK, at this point, we're running a little short on time, so we're going to have to jump ahead a couple of chapters in this story. The next set of components are another sub-assembly, exactly the same set of steps, slightly different geometry. We create those actuators, and the next component that we want to make is this bracket here that holds the actuator from above tightly onto the model below.

PHIL EICHMILLER: Let's go to the Skip Ahead.

JEFF STRATER: Right. Yes, thank you. That's a little too far ahead. OK, so we want to create a new component. Again, this is the R1 bracket. We'll use another new command, Offset Plane, because we want the sketch in this case to be located at a point where there's no existing planes. We've got to make one. Create a sketch on that plane.

The other new command will show here is in the Project menu called Intersect. Intersect does exactly what it says. It creates an intersection with the thing you select and the sketch, itself. In this case, we want the bodies. We want the bodies of the actuator and the two lower arms to create some nice geometry here.

PHIL EICHMILLER: Oh, I was just going to point out, so first we needed to sketch where there wasn't a place to sketch, so we created the Offset Plane, the work geometry. Then we needed stuff in the sketch that was not already in the sketch, and so we used projection.

And so while those commands are completely different, they work together in this case to bring a bunch of stuff into the sketch for us to use and to be able to put a sketch where we want it. So that's a pretty good skill to learn as you're working through this sort of stuff as you're learning Fusion.

JEFF STRATER: The last thing we did is to create a couple of rectangles on top, which will serve as places for the arms to attach, and we want to dimension them.

PHIL EICHMILLER: So Jeff, why not use some construction geometry here? Every other time you've done this, you use some construction geometry.

JEFF STRATER: You could. This is just another way to do it.

PHIL EICHMILLER: Yep. I just wanted to highlight that, because rather than placing the construction geometry, you just dimension directly to the center of the sketch, which if you move the dimension in the right way, it's essentially the same result.

JEFF STRATER: And as before, we're going to Extrude this. It doesn't need to be that big. So this is how you make that bracket. And again, we're going to skip ahead a little bit, but. The last thing you'll do is to create As Built Joint between the bracket. And it really doesn't matter, one of those geometries, but we want it to be rigid so that when the arms move, the bracket moves the arms move.

OK, now we'll skip ahead. So the next thing is hooking some of these things together. We've hooked the actuator from the upper mounting boss to the bracket, and now we want to hook these lower arms, or these lower actuators, in as well in this case, they're going to amount to this pin.

PHIL EICHMILLER: And notice how they move together? Because as we saw earlier, there is a rigid relationship between the actuator bodies. And so if one of them moves, the other one will move.

JEFF STRATER: And so here's a trick when you're placing a joint. If you hold down the Control key, you can snap to geometry that you can't actually pick. In this case, we want the middle in the middle.

The look what happens, though? We got a joint conflict. Why is that? It has to do with alignment. You can kind of see this shaft chef needs to fit inside this actuator body, but the position that we specified is not going to allow that. So a trick that you can use is to use a different kind of joint, in this case a cylindrical joint which allows rotation and translation. Notice that got rid of the warning.

PHIL EICHMILLER: It really just needed an additional degree of freedom. So part of the lesson here is don't over-constrain the joint system, if those parts were already controlled in a planar manner, and they didn't need that control in this direction. So you could relax that, and then it allows the model to be built.

JEFF STRATER: OK, again, in the interest of time, we have some time for questions. We're going to skip ahead to having created a couple more brackets. Nothing new here. Same thing.

Component, Sketch, Extrude, Holes, and Full Round Fillets.

PHIL EICHMILLER: And As Built Joints.

JEFF STRATER: As Built Joints, right. And you can see here that all these things are properly jointed. And the next component that we're actually going to work on is this bracket here. It's called the Gripper Bracket.

And so we've created the component, and we've already created the sketch. And as you can see, one of the reasons why we skip some steps here there's a fairly lot of tedious sketching.

PHIL EICHMILLER: I call that Captured Design Intent, Jeff.

JEFF STRATER: Exactly, exactly.

PHIL EICHMILLER: I think you've done a fantastic job of that. It's quite precise. And don't forget that all of this stuff is going to be in the handout. So every one of these steps that we're skipping over that's a little bit repetitive for this demonstration is all spelled out in great detail. So you'll enjoy that if you're trying to build this at home.

JEFF STRATER: So Component Sketch and Extrude. Give it some thickness. We want this to be accurate, so we can use our To Object and we can pick that face, and that creates a parametric relationship so that if we ever changed the width of that bracket this one will change, too.

But we need a slot in it. So we can do that a number of ways, but one of the ways is to create a sketch on the End Face, make a rectangle. It's overbuilt. This is a common technique. And then create some dimensions to the face geometry.

PHIL EICHMILLER: Using that same technique again to refer to the other dimension so they work together?

JEFF STRATER: And then we want to create a fully-constrained, so get this a value. Likewise here.

And now we use our friend Extrude to not build geometry, but to cut geometry. Now we want it to--

PHIL EICHMILLER: Is this yet another Extrude option, Jeff?

JEFF STRATER: It is, yes. So we will use our To Object. But see what happens when you do that? It splits the whole thing into two. That's not what we want. We actually want some material left on the back.