Summary
​
This gripper was a reintroduction to coding and an exploration of Fusion 360's Python API. My goal was to create custom functions that would allow a user to easily modify the design of a robot gripper.
​
I chose this project because it presented a twofold challenge:
-
Designing to withstand changing parameters
-
Making changing the design accessible
​
Through the design of the gripper and coding for the user interface I became much more confident in my ability to navigate large APIs and learned about the considerations for designing for modularity. ​
Goals for Plane
​
-
Must work for 2, 3, and 4 arms
-
Accessible User Interface
-
Legible Code and Commenting
Initial Design
​
I decided to design the grippers using Fusion's built-in parameters, which made accessing the model with code much simpler. Instead of needing to enter components and sketches to modify sketches, I could assign them a parameter and modify the parameter through code. With that in mind, I developed a basic idea for the components and parameters of the design before going into CAD.
General Research Findings
​
Grippers: There are numerous types of robotic grippers such as rigid link grippers, compliant grippers, and even inflatable grippers. The considerations for compliant mechanisms vary greatly based on application, material choice, and more, so to simplify the project and limit the number of parameters I decided to design a gripper with parallel motion linkage assemblies instead. Using linkages would provide the stability of a rigid design while possessing more flexibility in design than a gripper with linearly or directly driven appendages.
​
Current Designs of Robotic Arm Grippers: A Comprehensive Systematic Review by Jamie Hernandez et al.
Fusion 360 API: To refresh my python and understand the basics of Fusion 360's Python API, I watched Everything About Design's YouTube playlist, Intro to API in Fusion 360. After watching the videos, I spent a couple hours exploring Fusion 360's API Reference Manual (I'd be spending MANY more hours between this and ChatGPT later).
Design: Base
​
The base consists of a motor with a steel worm affixed to the shaft and a platform for the linkages to pivot off of. There are two parameters controlling the base:
​
1. Base_ArmQuantity - Controls the number of linkage assemblies that can mount to the platform
2. Base_PinchAngle - Controls the angle at which the linkage pivots
The mounting points for the arm were designed as separate bodies so that the Base_ArmQuanity parameter could directly drive a circular pattern function using the bodies.
The sketch using the Base_PinchAngle was also carefully constrained so all the concentric and tangential constraints are maintained when the angle changed.
Design: Arm
The arm consists of the three components that make up the linkage. There are three parameters controlling the dimensions of the arm:
​
1. Link1Length - Controls the length of Links 1 & 2 (the link right above)
​
2. Link3Length - Controls the length of Link 3
​
3. LinkThickness - Controls the thickness of the linkages
​
The link with the gear (Link 2) is built off an existing worm gear which is compatible with the steel worm attached to the motor shaft.
​
The assembly was designed to be symmetrical along its thickness so regardless of the number of arms, the linkages will be aligned and the grippers will converge over the shaft. This is important for applications where curved grippers must pick up cylindrical objects. If the linkages don't meet at a point, the object would not rest in the arcs of the grippers.
Function: Robot_Gripper_Arm
​
This function controls the length of the links, the angle of the links, and the links' thickness (for tolerancing with the base).
Link1Length = 40 mm
Link3Length = 50 mm
Base_PinchAngle = 100 deg
Link1Length = 30 mm
Link3Length = 60 mm
Base_PinchAngle = 130 deg
Link1Length = 40 mm
Link3Length = 40 mm
Base_PinchAngle = 180 deg
Code: Robot_Gripper_Arm
​
This code reads the current values of the parameters and creates a dialog box with inputs carrying those values. Changing the values and clicking 'OK' updates the expressions for the parameters and those changes propagate to the design.
​
This was my first time using the API and there are limited examples online so I struggled to get the syntax right and understand what methods / attributes applied to which classes. For example, I followed a tutorial to create the sliders (class= SliderValueInput), which uses the method ".expressionOne" to retrieve the value of an input from a separate function. However, the value inputs (class= ValueInputs) use ".expression" instead, which I didn't realize until I stumbled upon it in some sample code.
Design: Gripper
​
The gripper is what comes into contact with the object being handled. Each gripper mounts to a linkage assembly with an M2 bolt and is programmed so the contacting surface remains vertical regardless of the value of Base_PinchAngle. There are 3 configurations for the gripper, and different parameters depending on which is chosen:
Flat
Curved
Textured
Not all parameters apply to each type. Details can be found below in the 'Function: Robot_Gripper_Gripper' section
​
1. Gripper_Width - Controls the width of the gripper​
​
2. Gripper_Length - Controls the length of the gripper
​​
3. Gripper_Thickness - Controls the thickness of the gripper
​
4. Gripper_Radius - Controls the radius of the arc for the curved type​
​
5. Gripper_RadiusDepth - Controls the depth of the arc into the gripper for the curved type
​​
6. Gripper_Flange - Controls the width of the flange on either side of the arc for the curved type
​
7. Gripper_RippleHeight - Controls the height of the ripples for the textured type
​
The grippers were designed so that their profiles could be adjusted by modifying just one sketch. This simplifies the design and eliminates the need to add additional sketches and extrusions for curved or textured grippers.
​
Also, since the design imported one arm and then copied and pasted it to create the others, changes to the gripper propagate to the other arms. Therefore, editing the one sketch is sufficient to change the design of all grippers. This makes the code dynamic, enabling functionality for grippers with 2, 3, or 4 arms.
Function: Robot_Gripper_Gripper
​
This function allows the user to select which type of gripper they'd like and set the new gripper's dimensions. Since there are multiple options for grippers, I created a dropdown in the command dialog which offers a unique image and different inputs based on the type of gripper selected. This way, the user only edits the parameters which are necessary for their choice of gripper.
Flat Parameters
Gripper_Length
Gripper_Width
Gripper_Thickness
Gripper_Length = 20 mm
Gripper_Width = 15 mm
Gripper_Thickness= 4 mm
Curved Parameters
Gripper_Length
Gripper_Thickness
Gripper_Radius
Gripper_RadiusDepth
Gripper_Flange
Gripper_Length = 20 mm
Gripper_Thickness= 4 mm
Gripper_Radius = 20 mm
Gripper_RadiusDepth = 3mm
Gripper_Flange = 3 mm
Grooved Parameters
Gripper_Length
Gripper_Width
Gripper_Thickness
Gripper_Ripple_Height
Gripper_Length = 20 mm
Gripper_Width = 15 mm
Gripper_Thickness= 4 mm
Gripper_RippleHeight = 1 mm
Gripper_Length = 30 mm
Gripper_Width = 10 mm
Gripper_Thickness= 6 mm
Gripper_Length = 10 mm
Gripper_Thickness= 6 mm
Gripper_Radius = 10 mm
Gripper_RadiusDepth = 2mm
Gripper_Flange = 2 mm
Gripper_Length = 25 mm
Gripper_Width = 10 mm
Gripper_Thickness= 3 mm
Gripper_RippleHeight = 0.5 mm
Code: Robot_Gripper_Gripper
​
This function's code begins the same way as Robot_Gripper_Arm, pulling current values for parameters and creating a command dialog. Unlike the arm, the input from the dropdown is constantly monitored and changes the image and visible value inputs whenever there is a change to the selected dropdown input.
​
To modify the gripper, the code first activates the gripper component and enters the sketch which contains the profile for the gripper. The code then searches for and deletes specific lines and replaces them with new lines / arcs to create the modified profile based on the user's inputs. Finally, the root component is reactivated.
​
However, there is one major improvement I'd make if I were to do this project again. The code is only capable of searching for and deleting lines from flat grippers. The code is incapable of modifying a curved or textured gripper. If the design contains a curved or textured gripper, the user must undo any changes to the design until they have a flat gripper again (the default) and then use the gripper function. In the future I could expand the search for lines so that it identifies the ripples and curved designs or completely delete and recreate the sketch (and associated extrusion) each time the function is called.