The main point of this studio was to use a linear actuator to make various devices, so we decided to make two projects: a catapult and a robotic arm.
The catapult we designed is portable and launches ping-pong balls using springs placed under the arm.
There were 2 catapults in this studio. Both of them had the same idea: to pull down one end of the pivot with a linear actuator, but they had different designs. One catapult tried to use the actuator to pull down quickly, whereas this catapult’s arm is loaded by pulling back a string, compressing the springs. The string has a ball on it, which slided off of the arm when it’s time to launch so it doesn’t interfere. A motor pulls the string backwards until it’s in place, at which point a hook clamps onto the arm, and the string slackens. When it is time to launch, the hook would move backwards a little, and boom.
All of the motors were wired up to an Arduino microcontroller with a remote control card to let us shoot it from afar. The catapult did have some problems, like not shooting very far, and having a high reload time, but with more work, springs, and time, those problems could be solved. For now, however, having a working catapult is reward enough.
The robotic arm has three joints: a “shoulder”, an “elbow”, like ours, and a “hand” at the end of it. The arm is placed on a rotating base, so we could turn the whole arm 360 degrees.
The part of the arm that connected to the base was straight up and down, but had an important function. It would raise and lower the arm. This enabled the next part of the arm to raise and lower the rest of the arm; for precision work. Finally, at the end, was the hand. The hand was a linkage that was connected to an actuator, so when the actuator pulled back, the hand would close as to grab something. All of the actuators were wired up to an arduino with a R/C shield, which allowed it to be controlled by a remote control.
This studio had two goals; to make something using the new linear actuators and to stress test the linear actuators for the coaches who were developing a new product. Using the linear actuators, we created Hexabot, which is essentially a six-legged spider robot. We used one linear actuator and one servo per leg to control the height and the rotation. We wanted to build a walking robot by the end of the studio.
The robot can easily lift itself and a payload of about 2 kilograms. Each of the legs is attached to the central hexagonal base using loose pin hinges. The servo on each of the legs is linked to the base using a four bar linkage. Since the linkage is in the shape of a parallelogram, the servo horn will always stay parallel to the side of the base. This makes it easier to program and control the rotation of each leg.
Each leg is also made using a four bar linkage in the shape of a parallelogram. This shape is beneficial because the part of the leg that is hitting the ground does not rotate. If it did rotate, the robot would have difficulty balancing. The actuator is attached to the upper point on the side closest to the base and to the lower point on the side furthest away from the base. When the actuator pulls, the leg is lowered, effectively lifting the robot. Likewise, when the actuator is released and goes back to its normal state, the leg is raised, lowering the robot.
While building this robot, we tested, broke, and helped make improvements to the linear actuators brought in by our coaches. This was one of the few studios where breaking what we were given was a “good” thing. With each break, they sought to create a shield from it happening again. Whether it needed a stronger motor, higher torque gears, or redesigning break points, the process of building Hexabot allowed them to create a more complete product. Though it slowed the overall process of building the Hexabot, we were able to give them a proper amount of feedback.
In the end, the Hexabot was built to spec. Six linear actuators, six servos, six legs, and a six-sided base made up our walking spider robot. Improvements can most definitely still be made, but where it stands, or squats rather, we have a fully functioning Hexabot.
Programming the hexabot was more difficult than anticipted. Across the experience, the largest recurring issue was interference. Each leg had to be controlled individually so that they would not bump into eachother. Another significant issue was friction with the ground, and the general physics involved such as how strong our materials needed to be, and how much torque the servos would require. The first sequence designed moved three legs at a time, in two groups, and then rotated them all back to the central position. The legs move were alternating so that the robot could balance on the remaining three. This sequence did propel it forwards, however the friction with the ground translated through the legs into the main body, creating tensions in opposite directions. This tension could potentially tear the robot apart, so the code had to be redesigned.
The next coding sequence was identical, however instead of moving all legs back to the central position in one group, it moves in two. This prevents the tension, but results in more of a waddling motion. This causes the robot to wiggle back and forth, resulting in the robot moving in unexpected directions.
The final coding sequence works differently. The very front, and very back legs are lifted for the movement process, but place down to provide stability when legs are being lifted. While those legs are down, the remaining move in two groups where they lift and rotate forward. Then, they return to the ground and rotate together back to the central position. This prevents any unnescesary tension, and also moves the rotbot directly forwards.
The linear actuators that we were given as part of this studio pulled with a force of 30 Newtons. Since we had decided to build a hexabot, a six legged spider robot, we needed to build the legs so that they would have enough strength to lift the robot.
At any given time, at lease three of the robots six legs would be touching the ground, so we needed to design the legs so that three of them could lift the entire robot.
We designed the robot to weigh 4.5 kilograms total, so each of the legs needed to be able to lift 1.5kg. We used equations, such as torque = force * distance, and force = mass * acceleration, to calculate the exact diamentions that the leg needed to be.
We then started 2D modeling the parts of the leg in rhino and laser cut them out of plywood. In the initial designs there were many interference issues. The linear actuators got stuck on the pieces of laser cut wood. To solve this, we made the wooden linkages different shapes so that the linear actuators would not catch on them.
After redesigning to eliminate interference issues multiple times, we finally made a model that had no interference issues and did not break the linear actuators. While we were working on the legs, the linear actuators went some through evolutions. The motors were swapped out for motors that were five times stronger. This made it so that our robot was able to lift much more than its own weight.
We then made five more linear actuators and began attaching them to the base of the robot. After we attached all of them, we started making a linkage that would span from a servo to the body of the robot.
A few intereference issues later, we had a linkage system that allowed the legs to rotate about the body.
After assembling the entire robot, we tried to make it walk, however, we found that the hinges that we used bent in the wrong direction. We ordered a new set of hinges, which should be sturdier and allow the robot to walk.
All of the linkages used in this project were parallelograms, since the pieces that were attached stayed parallel. This made both programming and designing the robot easier.
The Hexabot project was designed to test a new version of linear acuators built by our coaches Arron and Toomas.
The Hexabot has six legs with a linear actuator in each one them which allowed them to lift. Each linear actuator is connected to an arduino that is powered by a battery similar to a remote control car. The arduino was placed in the middle on the Hexabot while the wires to the linear actuators were put through small holes at the bottom of the Hexabot to keep them in order.
To make the legs rotate we used servos at the end of each leg attached to the base of the robot. The wires to the servos were also put through holes at the bottom of the robot to keep things in order.
The hardest challenage was keeping everything working. once we fixed one prolem another issue we had to fix, rather the linear actuator breaking or a servo rotating in the wrong direction. However fixing each problem made us more aware of things that can go wrong which is a good thing.