I. Introduction And Background

The Final Project for Robot Mechanism Design was to apply the concepts learned in the class to a new mechanism and to physically construct this mechanism.

To achieve this, our team chose to explore complicated ways in which a simple box can open. We brainstormed various paths that the lids of a box could follow, and filtered for ideas with the following characteristics:

• Unexpected.
• Non-obvious mechanism.
• Can be accomplished with a closed linkage.

The brainstorming resulted in a plethora of options:

The movement that we settled on was described in our proposal with the following illustration:

It was felt that this was novel and did not have an obvious implementation. Based on early feedback from the Professor, we wanted to achieve this motion with a single motor.

It is important to note that the decision for this shape of movement was made before any effort was made to research what mechanisms might achieve the movement, or even whether the movement was possible. We felt that this represented the purest purpose of the assignment: inventing a mechanism, from scratch, to meet a desired objective.

II. Design Process

Steps Along The Way

Our work consisted of an unending stream of designs, prototypes, failures and changes. Here we document the overall story arc of how we arrived at our final design, offering this as a view of what was learned.

The hardest part of the design was finding mechanisms that could make this motion. The earliest ideas were 6-bar mechanisms with folding/expanding arms on both the front and back edges of the lid. We weren't sure how we would control the arms in this motion. Presumably a further 4-bar loop would have been necessary to power these arms through their synchronized dance. 

Front Edge On A Slider

It wasn't long before we changed to having a slider to guide the front edge of the lid, as shown in this early sketch and Solidworks model:

The advantage of a slider is that the lid's motion could be kept "square", with a right-angled corner. We didn't want the front edge of the lid to dip down into the volume of the box, as this would make the box impractical for holding anything. This was the closest to the proposal movement, and guided our design trade-off decisions throughout. 

At this stage in the design, most of the mechanisms we imagined powered the back edge with the motor, and allowed the front edge to be dragged along the slider. This left us with a large problem: how to cause the front edge to turn the corner and go down the other arm of the slider? Once the slider had been pulled to the corner, and the powered back edge reversed directions to push the slider, what would make the slider choose one path over the other?

We explored ideas of mechanical toggles that would alternate the preferred direction every time the slider passed through. We considered using a second actuator (usually imagined as a solenoid pusher) to steer the slider in the right direction. None of these ideas seemed satisfactory.

Power The Front With Expanding Crank; Back Becomes A Slider

This challenge was instead solved with a change to powering the front edge of the lid around the full 90 degree motion, and making the back edge of the lid a passive follower. Being passive, the back edge would require more structure, and so it was changed to a slider.

To power the front edge, we added a crank around a low, central pivot. Which introduced a new problem: how to keep the slider path with a square corner if it was to be driven by a revolute joint with a crank? We considered ways to use a two-link crank+coupler to push the slider, but didn't find a way to make this work in our constraints. In the end, two links were used, but in a slider configuration that allowed the length of the combined crank to change, but the angle between the two component links would be kept fixed.

The first physical prototype we built used a back edge slider in a vertical channel, a front edge slider in a right angle (with a slightly rounded corner), and a crank with an expanding slider. This prototype worked, but required manual intervention to keep all parts of it moving. It had a tendency to bind with friction.

Slot Angles

The next big innovation in design was to change the back edge slider angle so that there was less resistance to the motion. In the previous design, with a vertical path, the force is initially pushing the back slider directly into the wall at 90 degrees – expecting it to move was misguided. Even once the slider was out of this initial 90 degree angle, the normal force of the slot generated excessive friction. By tilting the slot, the normal force on the side of the slot was reduced, and at least some of the driving force was in the desired direction of movement.

We continued tilting the back edge slider until the distance between the back edge of the box (the leftmost of the back edge slider) and the path of the lid (the right-angled slot) was too large to be reasonable. This would represent wasted empty space, outside the enclosure of the box, but within the bounding volume of the walls.

Crossing Sliders

Which led to the next innovation: slot paths that crossed on different z-planes. We moved the back-edge slider to the far side of the wall, and used a metal rod as the slider path instead of a slot in the wall. Now we could angle the back edge path as much as we wanted. This allowed continued reduction in the normal forces in the slider, reducing friction.

Curved Slot

We were also able to improve the angle of the front-edge slider. Instead of a right angle, we introduced slope throughout, so that it was never quite vertical and never quite horizontal. We also increased the radius of the corner curve, where the prototypes tended to get stuck (because of the friction of the normal force). In practice we settled on a spline curve that kept as much of the right-angled motion as possible, while allowing the mechanism to function. Because this spline was quite complicated mathematically (we used more than 50 points on the spline), we performed our mathematical analysis with an approximation of an arc centered away from the crank pivot. This allowed a reasonable match to the spline, still allowed for the crank length to change, and included enough mathematical challenge to be interesting.

Making It A Box

This is when we first started to turn the "quarter box" we had been making for prototypes into a full box. We knew that the physical box, with interlocking fingers, was a common design, and were not concerned with it. What changed in our minds at this point was adding the third dimension – our "lid" had been represented by a flat link in all our designs up until this point.

The motor was to be directly connected to the crank pivot on one side, and the other side of the lid was to be an identical copy of the sliders but without a crank to power it. We expected these sliders to be pulled along their path by the lid itself.

The first 3D prototype disabused us of this belief. With the torsion across such a long link, with the play we would necessarily have in our joints and bearings, the passive sliders would lag behind, and would bind against the bearing/slot.

Dual Powered

We quickly changed to powering both ends of the lid. The motor was moved to a central location, and a drive shaft and gear train used to move the power to the cranks at both ends. (This made both ends of the box identical mirrors.)

Once the power was being delivered symmetrically, the sliders moved much more synchronously, which reduced torsion and binding. Despite this, the flexibility of the lid meant that the sliders were still twisting too much and continued to bind.

Rigid Cross Beams

The final major change was to add rigid steel cross beams from one side of the box to the other. These beams took on the functional role that had previously been performed by the lid, and did so with much more rigidity. It enabled us to keep the sliders in place without having retaining caps, as they were being pushed into both walls from the center, so the curved slider became a simple pin. The cross beams were also easier to integrate into the 3D printed joints, with more "one-piece" elements. 

Final Design

The final design consists of:

1. A curved slider for the front edge of the lid, implemented as a pin-in-slot.
2. A straight slider for the back edge of the lid, implemented as a moving rod sliding through bearings.
3. An expanding crank slider to power the front of the lid, implemented as a steel rod lower crank sliding through a linear sleeve on the upper crank.

This is all powered by:

1. A gear integrated with the crank pivot.
2. A gear attached to the drive shaft, and interacting with the crank gear.
3. A drive shaft running across the box to a mirrored mechanism on the other side.
4. A drive gear on the drive shaft.
5. A pinion gear on a motor, pushing the drive gear and thus the drive shaft.

And all controlled by:

1. An Arduino Uno applying simple control algorithms.
2. User buttons for "open" and "close" motions.
3. A power switch to turn power to the Arduino on and off.
4. A 9V battery power source.

And the whole thing is wrapped in an outer layer that makes up the box.

III. Kinematic Analysis and Synthesis

Note: this section is unchanged from our earlier analysis submission.

Schematic Description

The mechanism can be viewed schematically like this:

The crank is on a revolute joint with ground at point "O2". The crank contains a slider which allows the length of the crank to vary passively. For analysis, we consider this to be a fixed-length "Link 3" of length "b", and a variable-length "Link 2" of length "a", and they meet at point "A".
The crank connects to a pin in a slider at "B". The slider follows a curved trajectory instead of the usual straight line. We consider "Link 4" of length "c" to be the straight-line distance between point "B" on the slider and an imaginary ground point "O4", roughly at the bottom end of the slider's slot.
The lid of the jewelry box is also attached to the slider at "B" with a revolute joint. It makes up "Link 5" of length "f", after which it attaches to point "F" through a revolute joint.
Point "F" is on another slider, this time following a straight-line path. We imagine "Link 6" of length "g" to reach to "O6" at the bottom end of this slider path.
We imagine ground "Link 1" of length "d" between O4 and O2, and "Link 7" of length "h" between O4 and O6.

Degrees Of Freedom

Using the modified Gruebler equation and the diagram below, we calculated the degrees of freedom to be one.

Two Loops

We will analyze the mechanism as two separate four-bar loops. Looking at them separately will enable us to use our trusty vector loop equations.
The first loop is between O2, A, B, O4. Schematically, it looks like this:

The second loop overlaps by sharing Link 4 (the slotted slider):

The Slot Path From The Bowels Of Hell

The biggest complicating factor in this analysis is the non-linear slotted path that point B follows. Normally we can use trigonometry to figure out the relationships between lengths and angles, and this is much easier for a straight line.
Our mechanism uses a spline curve-generated slot, so to make the analysis possible, we made the reasonable assumption that our spline path is roughly that of a quarter circle. This way we can solve the system analytically while providing results that will closely mirror reality.
Based on the diagram below, we calculated the length of r1 (the length of a+b) for any given crank angle.This will be necessary for all the subsequent analysis. We also carried out velocity and acceleration analysis on this vector loop to solve for a' and a'' which we will also need later. Our b is 60mm from Solidworks, though the division between a and b is relatively arbitrary.
The origin of our crank is offset from the center of this circle and thus creates the sliding between a and b. We calculated the varying length of r1 using a vector loop equation as follows









We solved for r1 and γ3 and then input these formulas into MATLAB to solve the next two loops. Taking the time derivative, we get the vector loop as follows:

We then solved for a' and ω3 (from this first diagram) using MATLAB. Lastly, we found the acceleration vector loop equations and solved for a'' and α3 as such:


Important to note is the Coriolis acceleration that appears as a part of Link 1 where a is both sliding and rotating. With a, a', and a'' solved for, we moved on to solving the two four bar loops to properly analyze our mechanism.

Loop 1

Position Analysis

With the changing length of (a+b) now known, we started the position analysis of the first loop. Following the diagram for the path of our mechanism below, we found the vector loop equation.


Because b is the fixed length of 60mm, we now have the length of a for every θ2 input angle. As θ2changes, the length of c also changes. Solving for the two unknowns as follows:


Again, we input these symbolic solutions into MATLAB so we can solve them for any input angle.

Velocity Analysis

We then took the derivative with respect to time for our vector loop equation to obtain the velocity loop.


We input this linear system of equations into MATLAB to solve for ω4 and c'. It is also useful to input these symbolic solutions to MATLAB as the results change with every change in input angle.

Acceleration Analysis

Lastly, we took the derivative of the velocity vector loop equation to obtain the acceleration vector loop equation. Solving the acceleration vector loop equation as follows:

Before we finish solving for the angular acceleration of the fourth link, it is important to point out the Coriolis accelerations. Highlighted in yellow above is the Coriolis acceleration of Link 1 as it slides and rotates in Link 2, and highlighted in blue is the Coriolis acceleration of Link 3 as the slider rotates and changes length in the slot of the mechanism. Finally, solving for α4 and c'':

Inputting this system of equations into MATLAB allows us to solve for the variables and vary the input crank angle.

Loop 2

For the second loop, the process was much the same. However, instead of using the crank angle as the input, θ4becomes the input angle of this loop. Still, we should note that while this is a second loop, θ4 still depends on θ2 and thus, this second loop is still dependent upon θ2.

Position Analysis

We again begin with position analysis. From the diagram below, we obtained the vector loop equation to start.

As shown, θ5 and the length g are the only unknowns. The lengths h and f are known constants taken from our Solidworks model, and θ6 and θ7 are also constants taken from Solidworks. Solving this vector loop equation as follows results in:





Where we once again input the symbolic solutions into MATLAB for future use with varying input crank angles.

Velocity Analysis

We then took the time derivative of the vector loop equation from above to obtain the velocity vector loop equation. We solved for both ω5 and g' as such:


With this system of two linear equations, we used MATLAB to solve for the variables.

Acceleration Analysis

Finally, we took the time derivative of the previous velocity vector loop equation and solved for the angular acceleration of Link 5 and g'' as such:

Before we continue, it is important to note that the term highlighted in yellow is the Coriolis acceleration of Link 3 as the slider rotates and changes length in the slot of the mechanism. It is also important to note that the slider of g does not have any Coriolis acceleration (and is crossed out as such above) as the slider does not rotate while it changes length, i.e. there is no ω6. Lastly, we used MATLAB once more to solve for the variables explicitly.

Figures

Below we have added the results of our position, velocity, and acceleration analysis as well as any plots containing points of interest.

IV. Manufacturing and Assembly

Constructing the Parts

The box itself was laser cut from 1/4" Baltic birch plywood. While we explored using a pattern from makercase.com, we ultimately decided to place the interlocking fingers ourselves, for greater control. This allowed for better kerf adjustment, which would have been hardcoded in the makercase sketches we could get. Care was taken to ensure proper calibration of the laser kerf for the interlocking fingers, oversizing the positive/male components to accommodate what the laser burns away. Before cutting, test fingers with different amounts of kerf were printed, and their tight fit verified. We have repeated this process enough times that we have mastered it, and can quickly churn out a new box with a perfect fit quite quickly.

The lid and the "topper" fixed top piece were exceptions, in that they were 1/8" plywood. This was done to both reduce the moving mass, and because these parts are largely cosmetic.

The functional inner walls with slots cut for the curved slider were laser cut from 1/4" acrylic. Early versions used 1/8", but this proved not to be stiff enough. These parts included interlocking fingers to attach to the bottom and walls (and therefore more kerf adjustments), and also included cutouts to precisely locate the gears and the back slider rod holders.

The slider for the curved slot was a 3mm steel rod that extends across the width of the box, acting as a cross beam. It was designed to extend about 1mm beyond the acrylic walls on each side to prevent it from leaving the slot. In practice, we have not seen it derail, so this seems to be sufficient.

The two-part crank is made of: a 3D printed PETG pivot attached through the acrylic by a steel pin to a gear on the other side, a 3mm steel rod that is attached with adhesive to a hole in the pivot, and a 3D printed PETG sleeve that receives the rod and attaches to the front cross beam rod with a revolute joint.

The straight slider for the back edge of the lid is a 3mm steel rod. The rod is held in place by two 3D printed bushings of PETG (which we found to have lower friction than PLA), which are precisely located by the laser cut holes. The rod is kept a few millimeters from the wall, so that there is clearance for the front-edge pin, but we minimized this distance as much as possible to reduce twisting. A steel cross beam across the back of the lid keeps the two sides in sync and reduces unwanted torsion by netting the twisting force.

The lid is attached via 3D printed PLA pivots to the front and back cross beams. Their only functional purpose is to keep the separation between the front and back edge sliders, as the left and right sides are attached more soundly by the cross beams.

The gears are all 3D printed in PLA, because PETG wasn't available for us. They followed a template provided by the RMD course in previous years. Initially, we used the preprogrammed dimensions and only changed the number of teeth. Looking at the equations more closely, we realized the pressure angle was 25°. This was rather large and led to increased slipping. We reduced this angle to 20° for all of our gears to allow for better contact and force transmission.

The 28-tooth gear at the crank pivot is attached via 3x3 square steel pin to the pivot holder. This is driven by a 16-tooth gear that is attached to the end of the drive shaft. The drive shaft is a 3x3mm square steel rod going the width of the box. Around the middle of the rod is a 40-tooth spur gear, which accepts input from the 30-tooth pinion gear which is attached to the motor.

These gears, and their sizes, are mostly chosen based on translating rotation from place to place, rather than force/velocity choices. For example, the drive shaft has to clear the body of the servo to reach both sides. The original design intended a false floor in the box, and the drive shaft would hide under that, necessitating the two-gear arrangement on each end to bring power up to the crank. Even though we were mostly focused on relocating power, there is a modest 28/16 * 40/30 = 2.33 gear ratio to increase torque. This also means we will use about 210 degrees of servo rotation to cause our approximately 90 degrees of crank rotation.

The pinion gear is 3D printed with an integrated servo horn cutout, which wraps the provided servo horn very closely and screws onto it, allowing for low-backlash transmission. Unfortunately the servo horn that was available had a very long arm, which required paying attention to clearance as it rotated.

The motor is held in place by a 3D printed housing, which is both glued and screwed to the floor. The housing clamps the motor using a nut and bolt, keeping it steady.

The Arduino is mounted on a 3D printed PLA plate with registration pins through the Arduino screw holes, and the plate is then glued to the top of the motor housing. The battery is held in place against the walls using a 3D printed angle bracket that is glued to the floor.

The buttons and switches were cheap commercial parts from an electronics starter kit. But each was augmented with a 3D printed holder that allowed us to mount each of them in a drilled hole in the front and back of the box.

Most wires and components were soldered in place, without use of a breadboard or PCB. This was done to conserve space and reduce points of failure, since the circuit was so simple. However the connections to the Arduino could not be soldered without ruining the school's Arduino, and are therefore prone to falling out. Without using solder, we didn't have a better way to make this interface reliable.

Assembly

While several of our design iterations made it to the assembly stage, we will discuss only how we assembled the final version as most aspects were repeated with minor improvements and adjustments between versions.

We started with the laser cut pieces of wood and acrylic. As these were the entire structure of our box, we made sure the fits were tight and secure. We wanted to avoid using glue for these joints as part of our demonstration was to take the sides of the box off to make the mechanism visible. It also allowed for a cleaner, more impressive finish if we could achieve a sturdy construction with simple press fits. We only joined the two functional acrylic walls, the bottom, and the back to start as we needed to assemble the mechanism before closing the box. 

Next, we inserted the two 16-tooth gears on the outside of the functional walls keeping the inside of the box free from clutter (aside from the electronics, which in a final product would be much more compact and hidden under a false floor). These two gears are joined axially by a square rod that is also attached to the 40-tooth spur gear in the middle of the box. This is the main means of power transmission and how we were able to power two mechanisms with one motor. After pressing these gears snug to the walls, we inserted the two 24-tooth gears that would end up being the output gears connected to Link 1 on the inside of the box. To actually connect the round metal rod that is Link 1 to the gear, we had to 3D print a holder. This holder did not directly connect to the 24-tooth gear, instead, they were axially joined with another square rod to allow for one-to-one torque transmission. It should also be noted that initially we joined these two components (the gear and the Link 1 holder) with a 3D printed integral connector, however, the forces produced sheared that connection. Upgrading our designs to slide onto and share the metal rod was a necessary improvement. Link 1 was then pressed into the holder with glue for extra measure.

We then assembled the lid and the many components attached to it. First, we glued the lid rings into the laser cut lid. All four of these rings had two supports to glue into the lid which made the connections more secure and removed any twisting that could lead to binding of the rods. With these glued in, we slide the front and back support rods into place. The front rod is round as it also functions as the slider for both sides of the box. This was a particularly clever design as the small round steel rod had much less friction than our original 3D printed pins, and it helps further reduce the torsion possible in the lid as both pins sliding together helps maintain their alignment. Initially, we had two separate pins connected solely at the corners of the lid. This led to twisting, binding, and unsuccessful operation. With the front rod in place, we glued it to the lid rings to make sure it did not slide horizontally out of position. The rear rod is a square metal rod (as that is the only metal rod we had remaining in our supplies). It simply acts as another support beam mainly there to minimize torsion of the lid and help both rear rods (Link 4) rise and descend together. This worked remarkably well and only required gluing a 3D printed connector to both ends to allow joining both Link 4’s to the rod. Once this lid and link sub assembly was together, we slid the two rear links into the slider holders and then fit the front sliding rod into the PETG printed extending links of Link 1 and then into the acrylic sliding slots. This completed the dry assembly of the mechanism. 

To once again reduce the friction, we added the only lubricant we managed to obtain, petroleum jelly, to the sliders and the gears where needed. After this, we positioned the motor that we fit into a 3D printed holder next to the spur gear. We aligned the pinion and spur and then screwed the motor mount into the floor of our box. This was a secure connection and we thought would allow for a smooth transmission of power between the two gears. Unfortunately, after completing the box, we noticed the main square steel shaft was bending away from the motor due to the force as the gears turned which led to the gears skipping. This would have been easily correctable if we knew to buy a stiffer shaft or could have reinforced the one we had. Regardless, once we mounted the motor to the box, we put the electronics together and aligned the button and switch holes of our walls. We finally joined our final walls together and glued the “topper” piece on, finishing the box. We added a velvet cover to the bottom of the box to cover the ground-down nubs of the motor housing screws that were protruding – they were the only screws available.

It is important to mention that we went through scores of 3D printed parts testing tolerances, changing designs, altering dimensions, and finding the perfect fit. We eventually realized the best method was to print the part with a slightly tighter fit than perfect and sand and file until perfect. This proved to be the most efficient as the 3D printing needed to be less precise and the end result was always exactly what we wanted. Every piece of our box was sanded or filed to either allow for a tight, no glue needed fit or to minimize friction while maintaining secure, stable motion. On the acrylic slots alone, we sanded from 320 grit up to 3000 grit to help minimize friction. While we wanted to use aluminum for these functional walls, the time requirements limited what we could feasibly accomplish as neither of us had any experience with the CNC machines or other methods of smoothly and accurately cutting the holes and slots we needed.  

V. Electronics And Software

Arduino

An Arduino Uno was used for control. It was mounted to a special 3D printed plate, with registration pins to go through the Arduino screw holes, and the plate was glued to the motor housing. This kept it in place, but left it removable for making modifications (like updating the software). It was powered through a 9V battery, also held in place by a 3D printed bracket.

Motor

In order to achieve the required torque to turn our crank, we switched from the default servo motor to the "high torque" servo motor available from the course supplies. It had two advantages: higher torque (while keeping the same speed), continuous rotation instead of a ~180 degree limit. But it also had a big disadvantage: it offered only velocity control, and not position control. This meant that we would be unable to create accurate "open" and "closed" positions for the servo that we could toggle between.

We discussed running the motor for a fixed length of time, calibrated to take the motor from the "open" to "closed" position, and the reverse. However we expected this to be inaccurate, and would result in sometimes exceeding the safe range of the crank.

Buttons

Instead, we opted for two user buttons. One would open the box while the user holds the button, and one would close the box while the user holds the button. This is not as friendly a UX as a single-press open/close toggle button, but it was what we could achieve without position control. These buttons were 3D printed to wrap around a cheap push button from a starter electronics kit. An extending plunger was adhered to the button's surface, so that it would protrude from the side of the box when mounted from the inside.

Each button was connected to 3.3V source from the Arduino on one end, and to both a digital Arduino input pin (we used 7 and 8) as well as a 10k Ohm pull-down resistor to ground on the other end. The pull-down keeps the voltage at the input pin low, instead of floating in an unpredictable way. The 10k Ohm resistor is large enough that the voltage drop across the input pin is still near 3.3V when the button is pressed.

Power Switch

To prevent the Arduino from draining the battery when not in use, we added a power switch. This is easier than unplugging the battery every time, especially since our Arduino is buried on the inside of the box. This simple SPST switch (actually SPDT, but with one side not connected) can be turned on to allow voltage to flow from the battery to the Vin pin of the Arduino. The switch was then mounted with a 3D printed part to a hole in back side of the box.

Servo Wiring

The servo was a standard 3-wire hobby servo, with power, ground, and PWM. The Arduino motor shield was not necessary, and it ran on the 5V supply from the Arduino. The PWM signal was provided by Arduino pin 6.

Software

Arduino code was written to control the system (this code is available in the Appendix). We used the "Servo.h" header to simplify the servo control. Since that library is designed for position control, its use is a little counterintuitive, but still easier than managing ourselves. Essentially writing "0 degrees" to the servo would make it turn CCW at full speed, writing "90 degrees" would make it stand still, writing "180 degrees" would make it turn CW at full speed. After some trial and error, we decided on a 25 "degree" speed, so we used 65 and 115 "degrees" as our speeds.

The software loop watches for one button (but not both!) to be pressed, in which case it writes the appropriate open or close speed to the motor. If neither button (or both) is pushed, it writes to the motor to stop moving. Debouncing the buttons was not necessary, since the user is expected to hold the button down for the entire movement.

VI. Final Product

Pictures

The final product works as expected. Here is a video of it opening and closing. (Note that the electronics had not been mounted at the time of this video.)

Here is the same operation, but with the sides of the box removed, so that the internal mechanism can be seen.

Here are photos of the final product:

A picture of the insides, showing the gears, drive shaft, and electronics. Due to time constraints, no false floor could be installed in the box, which would have hidden the wires. The wires are also messier than they would otherwise be because they are interfacing with an Arduino through headers, instead of being soldered together.

The front and back of the box show the buttons ("open" on top, "close" below) and the power switch.

What Went Right In The Final Build

There were lots of iterations of prototypes, but the final build was notable for:

• Box sturdiness. The box itself is quite sturdy and is entirely press fit. We sanded down two walls so that it was possible to remove them for demonstration purposes, otherwise it would be even more solid. While an interlocking-finger box from a laser cutter is not new, it was new to us, and we executed well. Adjusting for kerf was the key to this.
• Small gaps. Small and symmetrical gaps between the lid and the box, which shows precise construction, like a luxury car.
• Gear train. The gear train is quite good, with very little backlash. We were impressed with how well 3D printed gears could work and how strong they are.
• Low play. The lid and the links do not shift from side to side at all. This is largely due to having identical mechanisms on both sides of the box, and the solid connecting rods that keep them aligned.
• It works!

What Went Wrong In The Final Build

The final build had some flaws that could have been resolved in just improving our execution of the same design.

• Gear skipping. When the torque gets too high, the pinion and drive shaft gear will skip, getting the servo horn misaligned with the lid, which requires manual intervention to repair. Two possible explanations are the drive shaft bending or the motor housing shifting. Since the skipping got progressively worse with time, perhaps the wood screws might be loosening. If we were to do it again, we'd find better screws and/or a better way to attach the mount to the box. We'd also mount the servo higher, so it was possible for it to rotate 360 degrees, which would avoid the need for a manual fix after gears skip.
• Friction. There is still a lot of friction. This is a design issue, mostly, and would require design changes to improve, but getting perfect alignment during assembly can help.
• Lubricant. We tried to lubricate away the friction, to no avail. The final version was lubricated with Vaseline (all we had the night before the presentation) and "turbine oil" from Inventionworks. Vaseline helped more than you'd think, but neither lubricant was great. If we were to do it again, we'd look for a PTFE spray lubricant.
• Insufficient torque. Even with the torque increase from the motor change, it still often needs a little nudge to get the lid to start opening. If the gear skipping was fixed, we could increase the torque through a greater gear ratio. We had room for a greater ratio, but did not think it necessary.

VII. Conclusions and Future Work

Future Design Changes

Torque

It appears that higher torque would have helped us operate more smoothly. More torque was available: we were not operating the servo at full speed, not for a large range, and we did not use a very high gear ratio. A redesign could raise the servo, or change its long metal horn, to allow for 360 rotation. We could operate the servo at full speed to extract more of its power. And then we could convert this higher power and greater travel into the same ~90 degree crank rotation via a higher gear ratio.

Commercial Bushings

Friction remained a problem through the entire process, including in our final product. Some of this friction was from the curved slider, but some was from our two straight-line sliders (in the expanding crank, and the lid's back-edge). We made our own bushings out of PETG, and we finally tuned our printings and sanded the result to get as close a fit as we could. But a quality commercial linear bearing would have been lower friction. The bearings we were able to obtain were of a low enough quality that we didn't believe they were better than what we were printing (and wouldn't have been directly integrated into the 3D printer parts around them). But higher quality bushings – perhaps on a larger diameter shaft – would have helped.

Metal

Ideally we would have machined the functional walls out of metal, instead of acrylic. We even purchased the aluminum plate to do this, but it would have required CNC milling (in order to achieve a smooth curved path), and we did not have the time to develop this experience. Metal functional walls would have been more rigid, have a lower coefficient of friction, and also could have been thinner, further reducing the friction on the slider pin.

Ideally, all of the gears would have been metal, so that they could handle more torque. It's possible some of the gear skipping is due to the PLA deforming, even with our current low torque.

Gear Skipping

Since gear skipping was our biggest problem in the final build, we would make design changes just to address this. We would switch to metal gears, in case the PLA was deforming. We would increase the stiffness of the drive shaft (better steel or larger) to prevent it from bending. We would redesign the motor mount to attach more rigidly to the floor.

Allowing the servo to rotate the full 360 degrees (by giving clearance for the servo horn, or shortening the servo horn) would have made gear skipping less problematic even when it did happen. In the current design, once a number of teeth have been skipped, the servo horn interferes with the floor and the box will no longer open.

Two Lids

We had explored the idea of making the box with two lids, working as mirror images and parting down the center of a larger box. We have prototypes of this design, and had solved the problem of mirroring the power transmission – having the crank gears directly interacting at the mirror plane, which reverses the direction of rotation in the mirror. This design was ultimately not used in the final build only because it took twice as much time to assemble, twice as much 3D printing time, twice as much plywood, twice as much steel, and would have required twice as much torque. We decided the benefit of demonstrating this trivial power transmission wasn't worth the costs. But in a redesign, with more time and refreshed raw materials, this would be an easy improvement.

Cosmetics

The original design included a false floor, hiding the motor, gears, drive shaft and wiring away from the user. There was nothing preventing this in the final build, but time did not allow us to properly space everything. A redesign would increase the height of the box a little, to allow room for the false floor, and some supports. With this newly-clean interior, we would be able to use the velvet adhesive material we purchased to make the box much nicer on the inside.

The exterior of the box was fine, but a more beautiful product could be achieved with a hardwood outer layer, whether solid or veneer. This could hide the finger joints and allow applying a stain and/or varnish.

Remove The Curved Slider

Many of our challenges stemmed from the choice to use a slider for the front edge of the box. At first it was a right angle, then it became sloped, then it became curved. But throughout the process it was a source of friction and binding. Part of this stems from being unable to buy a commercial solution for a customized curved slider. This meant we had to manufacture our own slider. The final choice of a steel pin in an acrylic slot was the best we found, but still offered considerable friction.

If we were to repeat the design process from the beginning, we might revisit the original ideas of having the lid connected to the box with two links on either end. It's unclear whether a suitable motion can be achieved, but more exploration is warranted.

Final Thoughts

Ultimately, our prototype functioned how we imagined and it worked. The operation was not as smooth as we would have liked, but the box did open and close, with one motor, using a closed loop mechanism.

Not only did we create a functional prototype, we created the mechanism to produce this unique motion by ourselves. We cannot stress enough how proud we are that we designed our own mechanism that achieved the motion we set out to achieve from the beginning of this project. We did not deviate from the proposed motion, even though that would have made the project easier. We wanted to stay true to this course: Robot Mechanism Design.

In designing our own mechanism, we had to apply many of the topics taught throughout the course, from simple closed four bar mechanisms, to understanding gears, to sliders, to Coriolis acceleration. We went through several designs on how to achieve our motion until we reached our final design which has two sliders with Coriolis accelerations, another slider in the back, rotations throughout, and a gear train driving two separate mechanisms.

VIII. Appendix

Arduino Code

#include <Servo.h>

const int OPEN_BUTTON = 7;
const int CLOSE_BUTTON = 8;
const int SERVO_PIN = 6;

const int SPEED = 25;
const int NEUTRAL_SPEED_COMMAND = 90;
const int OPEN_SPEED_COMMAND = NEUTRAL_SPEED_COMMAND - SPEED;
const int CLOSE_SPEED_COMMAND = NEUTRAL_SPEED_COMMAND + SPEED;

Servo myservo;

void setup() {
  pinMode(OPEN_BUTTON, INPUT);
  pinMode(CLOSE_BUTTON, INPUT);
  myservo.attach(SERVO_PIN);
  Serial.begin(9600);
}

void loop() {
  int openButtonState = digitalRead(OPEN_BUTTON);
  int closeButtonState = digitalRead(CLOSE_BUTTON);
  if (openButtonState == HIGH && closeButtonState == LOW) {
    Serial.println("open");
    myservo.write(OPEN_SPEED_COMMAND);
  }
  else if (openButtonState == LOW && closeButtonState == HIGH) {
    Serial.println("close");
    myservo.write(CLOSE_SPEED_COMMAND);
  }
  else {
    //Serial.println("neutral");
    myservo.write(NEUTRAL_SPEED_COMMAND);
  }
}

Solidworks

Attached are the Solidworks files for the final version we created. This mostly aligns with the parts that were printed and cut for the final version.

Box Solidworks V21.zip