For the initial concept and design, I was inspired by the movement of how a penguin waddles. Thus, for the pom pom bot, my goal was to make a penguin robot with a movement that was as close to a waddle as possible!
For the bot to walk, I planned on using 2 servo motors as the feet of the penguin. I would use the one sided attachment to the servo motors for each foot. My bot, as stated, would look like a penguin. In order to make this bot, I planned on using felt, foam, googly eyes, pipe cleaners, Popsicle sticks tape, and glue.
Below is a picture of my original notes and sketch for the initial concept.
My initial design for the bot. I had actually planned to use 4 servo motors. Two would be used for flapping the arms, but I would soon scrap this idea.
For the initial construction, I set up the two servo motors and used the attachment that had two sides, where one side was longer than the other. I made this change because I figured there would be more stability to the bot. I connected these servo motors by taping them both to a Popsicle stick. There was also a Popsicle stick attached to the middle of the connecting Popsicle stick. This second Popsicle stick would have the breadboard taped to it and, eventually, the penguin.
Below is a picture of my initial code:
My initial code for the penguin bot. It was not very complex because the two servo motors always moved at the same rate.
Below is a video of the initial construction:
The movement as seen in the video is more crab-like rather than waddling. As a result, for the redesign, my approach would be to make the movement of each servo motor to be slightly different.
The biggest challenge for this stage of the design was structuring it so that it wouldn’t fall backwards as it moved. Because the breadboard was taped to the back, the weight from it made it easy for it to fall over.
To improve it, I will mostly be focusing on improving the code so that the movement is more like waddling, and so that maybe it won’t jerk too much when it moves, which is part of what caused it to fall over. There won’t be any different materials for the 2nd prototype.
The focus for this second prototype was to correct the movement of the bot. My initial update to the code actually didn’t work as I had intended. My intention with the modified code was the have the motor for the right foot turn quickly when rotating clockwise and have the motor for the left foot turn quickly when rotating counter-clockwise. Though I correctly had the quick rotation on clockwise set for the right foot, I had the quick rotation on counter-clockwise also set on the right foot. This can be seen in the code below. There is also a video below that shows what this looked like.
Looking at the second loop in loop(), you can see that my conditional applied to servo2 (right foot) instead of servo1.
Looking at the video, you can see that the right foot has a jerky motion in both directions, whereas the left foot rotates smoothly in both directions. This is because of the errant code.
Below, you can see my corrected code and the video of the corrected movement.
Looking at this code, you can see that the left foot is now having its position set in the conditional in the second loop.
Looking at the video above, you can see that the right foot turns more sharply when it rotates clockwise, and the left foot turns more sharply when it rotates counter-clockwise, giving the bot more of a waddling motion.
In terms of improvements for the final version, the bot was still having trouble staying up when it was moving. Thus, my next objective would be to stabilize the bot more and even the weight out a little more, while also adding the final touches with the felt, foam, googly eyes, and pipe cleaners for the actual penguin.
Final Pom Pom Bot
For the final bot, I improved the stability by adding several Popsicle sticks on top of the servo motors to balance out the weight of the breadboard. I also added an additional two Popsicle sticks: one that was parallel to the vertical Popsicle stick and perpendicular to the horizontal one, and one that was lodged in between the other new vertical one and the previous one. The second one was added so that the bot would be taller and would support the full penguin that I made from the felt and foam. Below is a picture of the bot without the penguin attached and a picture with the penguin attached.
The final bot without the felt+foam penguin attached. Note the four Popsicle sticks on top of the servo motors and the additional two vertical Popsicle sticks.
The final bot with the penguin attached!
Here is the Google Drive link to the final bot video: https://drive.google.com/file/d/1xpnezsJ8GEvwFD2q6kZvsk7Tn0o7fQAW/view?usp=sharing
In the video, the orange pipe cleaner is Point A and the brown pipe cleaner is Point B. In the video, you can see that the bot successfully moves forward from Point A to Point B!
In terms of how this final bot differs from the original concept, the only real difference is that this bot does not feature the flapping arms that I originally planned to make. This was primarily because one Arduino would not be capable of sustaining 4 servo motors at the same time without an external battery as a power source.
Overall, there wasn’t anything too new about this design process for me because I am a computer science student. Thus, having to update code and improve a project’s design structure was something that I was relatively comfortable with! If I had to approach a similar problem in the future, something I would do differently is evaluate whether there is a need for additional power sources like a battery. I think I could have made a much cooler penguin if I had the battery and necessary connectors for it!
Link to the write up:
My initial thought was to create an AT-AT walker from Star Wars. The idea was to build it with an upper rectangular structure and four motors with popsicle sticks attached to act as the legs. The movement would be as follows: front left, back left, front right, back right. This came from the actual movement of an AT-AT.
Upon initially building prototype #1, I found this movement would not be possible with just four motors. The real AT-AT has many joints and re-creating it’s motion would require many more than just four motors and popsicle sticks. In the first prototype above, I tried mimicking the real AT-AT’s movement, but it just kept falling over. As for the software in the first iteration, I tried overcomplicating it at first but then nothing really worked much at all, so I simplified it greatly. It ended up as just the basic servo code, but repeated code for each of the legs to move at different times. I decided that since this still didn’t work, I should take another movement approach.
For my next prototype, I decided to completely change the movement pattern and add some weights to the upper body to stabilize the robot.
Second Iteration Video
For the movement, I thought of moving the front legs together and the back legs together. If the front legs move forward to a greater angle than the back legs, with a weight above them too, I believed that would cause the robot to move.
One problem that I encountered here was that the legs position was not being updated in the code. I asked a friend for help and we figured that it was because I was passing the position by value and not by reference.
In the case of the first iteration, it did move generally in a direction, but turned at unpredictable angles. I had to find a way to fix that for the final iteration.
Final Iteration Video
For the final iteration, my goals were to:
- fix the movement so that it moved fairly straight in a direction
- make it ‘wireless,’ in that the wires and battery would all be inside the upper body
- cover up as much of the wiring as possible, while still allowing the battery to be connected/disconnected.
To fix the movement in a random direction, I modified the code slightly and added rubber bands to the front two legs. This combined definitely helped it move in a fairly straight direction.
I also added some more popsicles to the top section of the body, so it could hold all of the electronics inside without falling out.
Once I glued that together and stuck the electronics inside, I confirmed that it still worked. It did, so I covered up most of the upper body with painter’s tape, leaving some spaces for battery connection/disconnection.
This project overall was fairly challenging. To move the four motors at the right times and the right amounts, without causing the robot to become off balance and fall over, was quite difficult. At one point it nearly fell off the table. I learned once again, that starting out simple is nearly always the way to go. When the first prototype for anything is overcomplicated, it will not be possible. Starting out with an easier design and working up from there is much more feasible.
For this assignment, we were tasked with creating a robot using Arduino with the capability of moving in a specific direction. We were allowed to make anything, so long as it moves. I decided to model my robot after a dog, since I like dogs, and planned to have its legs move individually in a specific order. I would try to place most of the weight toward the front in order to move the robot forward with each step. I had decided that I would make it using popsicle sticks, rubber bands, hot glue, and pipe cleaners.
The initial construction was not difficult. I tested to the range of motion of the servos, and then placed them on popsicle sticks in the way necessary for my preferred range of motion. I used hot glue to stick the popsicle sticks together, forming the body. While attaching the rubber bands to the bot to keep the servos in place, I decided that my robot was now based off of Clifford the big red dog.
As mentioned previously, I wanted to have each leg move individually using for loops, and then have them move together to complete the step. After finishing the program, this was the result:
As shown in the video, the robot simply fell over and did not move. In an attempt to remedy this, I shifted the weight even more forward, and attached the pipe cleaners, hoping the slight change in weight would help propel it forward.
Unfortunately, that resulted in the same problem. For my final fix, I adjusted the program in a way that caused the robot to take smaller steps. The result is below (The video is sped up to meet the file size limit):
As shown in the video, that robot managed to move forward without falling.
Although there were various points in which I was extremely frustrated, overall, I enjoyed the assignment. It was challenging, but fun to figure out a way to move the servos so that the robot could move. There are definitely areas that need improvement though. I am certain that I can make the movement smoother, and build it in a way that makes it harder for the robot to fall over. I was quite surprised by how much the size of the steps mattered in stabilizing the robot. This project has gotten me interested in trying even more new things with the Arduino kit that I bought. I’m glad that we had this assignment.
For this assignment, we had to create a pom-pom bot using Arduino and servo motors. The process was simple, but a bit challenging. This was my second time working with Arduinos, and the process went pretty smoothly, and I did not encounter a lot of difficulties. The coding part of the assignment was straightforward, and there was little to no complexity to it. The most important part was to create model of the robot, so that it can move without any difficulties.
The first part of this assignment was to come up with a concept of pom-pom bot. Initially, I thought about creating a spider, which would have six legs. I watched couple of videos on how spider walks; it helped me get a clear idea on how to design the robot. It was interesting to see that spider move its all the legs independently, and without a lot of coordination.
Sketch for Spider
To create a spider bot, its legs should move differently from the movements of other legs. I thought that the it would be bit challenging to create that, because it would need about six servo motors to create something like that.
I moved on from spider, and decided to make an ant like bot. The process was less complex than spider, because there was good coordination between the legs.
Sketch for Ant
The sketch gave me a clear idea of constructing the body of the bot.
My first prototype was basically creating a basic structure of concept that I had in mind. It took me two servo motors and few pop-sticks to construct it. Balancing the bot was a big part, because it would fall without the fall. Also the part in which motors where getting rotated, which was not what I thought of. I also had to figure correct speed and maximum and minimum angle of the servos.
For the second prototype, I tried to get rid of the problem in first prototype. I attached additional pop sticks, so that it can balance itself. I also attached two pop sticks in the middle of the bot, so that it does not fall. I also changed the speed and angle of the servo, so that it can move from one position to another. After making those changes, it worked well.
Final Pom-Pom Bot:
After getting done with the second prototype, the bot walked the way I wanted it to walk. So, for the final prototype, I focused on creating body of the bot and also trying different speeds and angles of the servo. One problem that I struggled with was that I did not note down the values for which the bot walked. So, after changes the values, I loosed the delay and position values of servo. The final bot was not able to walk like second prototype. However, the final product turned out well, and I was happy with the result.
Motivation and Initial Design:
Instead of doing something that mimicked walking, as seemed the case for most others, I decided to work with something more mechanical instead. Now, obviously wheels and propellers were out of the question, since the servo could only rotate 180 degrees at most. Instead, I happened upon the idea of a rowboat, and realized I could obtain a loop-like motion by chaining two servos together (https://www.youtube.com/watch?v=bpvC5AVfEVY for inspiration)
I wanted to use the base of a Grecian/Viking warship, with a large number of oars as propulsion. The ‘oars’ would be made using basic wooden dowels, and for lightness’s consideration I wanted to use cardboard/paper for the body. However, the main issue was the ‘slots’ for the oars to be sturdy enough to withstand the oar’s rotating motion, so I decided to stick with cardboard for the first prototype and hopefully laser-cut a housing for the second one.
The basic sketch/conception of the robot.
Build Process and Modification
There were a few things that came up on the prototype. The first was the fact that the servos had tiny extensions on the side to allow them to be screwed or bolted on external surfaces. This becomes problematic when attempting to lay the servo on its side, so I had to use some extra cardboard to elevate the servo so it stayed flat:
Padding at the bottom of the servo to allow it to lay flat
I also used thin-gauge wire to substitute in as a push rod/extension for the servo arms. The thin gauge allowed it to loop and slot into the servo arms nicely, but when placed under pressure and movement it also began to bend easily.
A good view of the arm extensions and oar mechanism. Note the bending in the extensions (green wire)
I attempted to rectify this by reinforcing the center areas with thicker-gauge steel wire, but its effect was limited. This are is probably the weakest part of the design, with the best alternative to use actual push rods found with servos.
The overall result was a bit lackluster (demo video found here: IMG_5476). The primary issues were that the servos were not properly secured to the cardboard, the extensions bent too much and the overall robot was a tad too heavy for the wooden dowels to move without sufficient leverage. I will likely transition to using paper and glue for the next iteration to help secure the servos more, as well as reduce weight. I may also have to acquire more servos and push rods in order to complete this, so until I find push rods the second iteration may have to be held back a bit.
Last week when we started designing our bots, I just doodled a snowman (Christmas may still be on my mind) and thought that it would be interesting to make something that doesn’t have feet move. The most a snowman could do if they could move would be a waddle, so I tried to replicate that throughout this process. Here’s my initial design:
I thought at first that it would give better traction to have the propeller stand on popsicle sticks, but once I tried this the whole thing either collapsed or didn’t move at all. I also thought along with this original design that I could hollow out a pom pom to fit the motor inside of it. Once I got to constructing, this also fell apart since I realized pom poms aren’t that big nor is it possible to hollow one out.
My first prototype was just the base of the bot with one motor that would be the primary movement and a ring of pom poms around the motor. I played around quite a lot here with the code to make it move the way I wanted. If the motor moved too fast or slow to go back to its original position, it would reverse the movement just made so I had to find the perfect delays and angles that the propeller would go to in order for it to move properly.
As seen above, I just did random colored pom poms for my prototype since there weren’t many white ones and I wanted to save those for my final design. Moving on, I had to decide how I would build the base up with another motor and the pom poms surrounding the entire thing. Pom poms were working pretty well, I just had to be careful about my placement of them so they would not interrupt the movement.
Once I had the primary motor functioning properly, I had to add my second motor. I wanted it on top of the previous one since it would be the least likely to interrupt the movement of the base. I didn’t want to glue the motors together obviously, so I took some putty and sealed the two motors together temporarily. The code for the second motor was easier since it didn’t effect the movement of the entire bot too much, but there was still some playing around that took place in order for it to be correct. It looks a little spastic, but I had to program it a little strange so it wouldn’t hit the pom poms as much as it could have.
Overall, I was trying to create a snowman image with my additions. The motor ended up being a broom made out of pipe cleaners, and I experimented with adding more pom poms in order for it to appear like it had three tiers, each smaller than the last.
After I had worked out the kinks with the code, my final bot design was focused on the look of it and how it moved with the extra weight on top. I got a bunch of white pom poms and hot glued them together to create the closest image of a snowman I could. I couldn’t glue the entire thing together, or else I thought I would damage the motors, so the top part is just stuck on top with some more putty and a paperclip as support. The bot definitely moved slower that it did without all the other additions, but it can still move from point a to point b – just a little slower than it did before. Overall, the final bot was not too different from my original concept, I just had to adapt to changes and be creative about fixing problems. While programming and crafting as not new to me separately, I had never done them together before which was a really interesting experience and it occurred to me just how much you can do with simple technologies like this.
google drive link: https://drive.google.com/open?id=1IDozK0A9jRfa95ccKO-WBvoDQPOqyyjX
For this design, I wanted to make a robot that dragged itself across the floor with an arm. I decided I wanted to give it an alien look, and wanted to give it a look inspired by the face huggers from the aliens movies. I think just using popsicle sticks, glue, and rubber bands will be all I need to construct the robot. Below are the bare-bones of my pompom bot I built in class, and later used in the construction of my first prototype.
Most of my different prototypes were in the different iterations of movement style, as actually getting the robot to move was much harder than I had anticipated. In my initial design I tried to make the robot move with its arm in one big sweeping motion, having the shoulder joint lower first, then having the elbow joint turn 90 degrees rapidly. This caused the bot to fall over a lot, so changes to the weight of my robot and the speeds/angles of the motors would be necessary.
For my next iteration I decided to give the bot a broader body, and to try having it push with the arm at the rear, rather than pull from the front. I also shaped the popsicle stick on the front part of the arm to be somewhat more pointed, to allow for better grip. This ended up being able to move, but not very well, and went to one side for some reason.
For my final design, I really wanted to get the forward dragging motion correct, so I used a body similar to my second design, and tried to apply that to a design with forward movement. I tuned the angles to move between 45 and 135 degrees, and that seemed to work well.
Here are some pics from the building process, I decided to use a green color and a bunch of eyes to give it a cartoony, but alien look. I also had to keep the profile lower to the ground to get it moving.
My initial tests for this design didn’t go great:
So I decided to try added some more friction to the arm with a rubber band:
And it works pretty well! The bot itself has a much larger body than my initial design, and the additional friction at the tip and changes to the angles the arm functioned at really seemed to help. I was surprised with how much difficulty I had with a lot of this design. I had figured it would be a piece of cake, but there were a lot more nuances to it than I had anticipated. In the futures I would want to try running multiple arms to further imitate my original inspiration and give it a creepier look, and maybe try for actual walking rather than dragging as a form of locomotion.
Overall I was pretty satisfied with my final design, and had a lot of fun making it to boot. Many of the issues were in minor details of the build, but just as in the first arduino lab, it was a familiar kind of process, so it wasn’t frustrating to debug these issues. Learning to use the servos was a lot of fun, and will actually be useful for me in other classes as I need to work with servo motors in my senior design class.
An additional note, I took a number of videos, but the website wouldn’t allow me to upload them to the page, so I only had the shortest videos I made available.
For this assignment we are to use arduino and some 9g servo motors to creating a robot of some kind that can move at least an inch. Over the course of the assignment we are to: design a concept, design a prototype, make a 2nd prototype, and make a final bot that moves the inch. For the concept we are to put our ideas out on paper in a sketch or in words. For the prototypes, we are to describe what challenges we face and how we plan to combat these challenges. Same goes for the 2nd prototype except we have to talk about what improvements we made from the first prototype. I went about this project a little bit differently, my robot traveled by air. Air as in it traveled along two balance beams that were held up by two tables (you’ll see in the video). This project was a bit stressful, I’ll speak more about that in the reflection.
The initial design for was air travel robot was to have a single skewer hold the servo in the air and move each end a couple degrees at a time. Basically my robot was going to look like have of the thing constructed below.
My robot would use: pipe cleaners, skewer, pom poms, Popsicle sticks, servo, and a bent paperclip. Pipe cleaners were used to hold everything in place. Skewer was used to hold the servo in the air. Pom poms would act as anchor points, these would ideally move down the balance beams. Popsicle sticks would be used to construct the beams it would balance on. Servo for movement. Finally, the bent paperclip would be weaved through the servo fin to hold the pipe cleaner skewer in place when moving.
This video shows my first prototype and the biggest issue that I would spend many hours trying to solve. That issue being the fact that the skewer and servo motor are separate entities. Since these two are independent from each other they will not move in unison. Either the servo moves or the skewer moves. If I were to pinch the servo motor with my hands the robot would travel that inch no problem. So, I started to think how I can unify these two parts. I will not change the base of my design but, I could add a couple things to the servo to hold it all together. I thought of using rubber bands and an extra pipe cleaner to hold everything more tightly together.
Here is what the 2nd version looked like. The new pink pipe cleaner is wrapped around the center of the skewer and motor. This pipe cleaner actually did a nice job of holding it all together! Next I would take two rubber band and quadruple bind both side of the skewer. The servo motor has these little notches on the side that made for great rubber band sockets. Overall the 2nd prototype was far more secure that the first one.
I don’t have footage of the testing but the same thing happened, it didn’t move. The servo was still acting as an independent body. This is where I discovered that force was not my solution so I began to look elsewhere (not force) for my final design.
I began to think back to my initial design, about why it didn’t work. I said that, if the servo didn’t move the skewer would, thus I should try to find a way to hold the servo still. I tried to work against the separate bodies when I should have been working with them. Once I thought of this, I finished the project in the next 20 min.
Side note: I will never get over hearing myself in recordings, yuck.
So, here is the final design! Like is said the problem was not the force but of holding only the servo in place. The way I did this was by putting two large Popsicle sticks right next to the motor. These Popsicle sticks would be held in place by the force of two tables pushing on them. These forcefully held Popsicle sticks would act as walls for the servo to stay in place. In the video, one of the Popsicle sticks fell. This reduced my robots movement speed to a shimmy but still got the job done. Instead of being held still the whole time, it would only stay still for a small about of time, thus the shimmy.In this assignment (I’d imagine) one would have three key components: Means of travel, motor, and a core. For the bulk of this assignment I only had the motor and core. Not until I found my means of travel, did I complete this assignment. These side sticks seem odd, but think of it like they are feet. They are a means to move not directly connect to the main body. Would a robot with just toothpick legs be able to move? That is how I justify this addition.
Once again, I made this projects leagues harder then it really needed to be. Traveling by air proved to be a bigger challenge than I initially thought. Physics and stubbornness were my biggest issues for this project.
The issue of physics was the initial problem that made this assignment harder than it needed to be. To start off, the wacky physics I had to deal with we solely because my robot was in the air. Where most would have a robot that would exude a force back on the table, keeping everything together, my robot exudes a force downward, pulling on the sticks. I do not have the physics expertise to competently explain this, but this pulling down force seems to have made the two bodies separate. Moving on, stubbornness forces me to not give up fast enough to pursue alternative solutions. I usually get so fixated on a route to the point where I end up forcing it to work. This is more of just a personality trait that gets in the way more than a specific assignment issue. Overall, stubbornness and ignorance do what they do and delay progress.
As you have noticed my robot only had one motor and not the required two. This was due to be just assuming details instead of actually reading them. I figured we just had to make a robot move, and that the two motor robot was only for class. Since learning this error, I have thought about about a couple designs that I felt I should throw in, for what it’s worth. first design would look something like this -> \_🔲|🔲_/ The boxes are the servo motors and the lines are the Popsicle sticks. This robot would employ a climbing movement along the Popsicle sticks. I would have to put notches on the outer side of the popsicle sticks and something on the ends of the arms so that the arms would have something to hook onto. Almost a sliding lock. The other model would be like the initial two motor design at the top of the post. The design would be a cross that would spin continually on top of two layers of Popsicle sticks. Once one half of the wheel crossed into the middle (where it would fall) the other half would be holding it up. Ideally, in a perfect world, this design would act like a wheel as it spins down the lines of sticks.
This week, I tried to build a machine powered by an arduino and two servos that would walk. My initial design had two servos tightly rubber banded together, with popsicle sticks glued onto the mounts. I did a lot of experimentation with getting it to move differently by changing the rates and timings of turning the sticks. I couldn’t achieve very coordinated motion with this initial design. The main issue I had to consider was how to get the bot to be able to reset the servos after they carried it forward (without the reset moving it backward too much).
I came back to the bot and decided to create a pipe cleaner tripod underneath it and shorten one of the sticks. I thought this might make the movement easier to analyze and increment off of. Unfortunately I had less time than I would have liked to spend with this because I had to go through a lengthy process of elimination of working/faulty parts, which came down to a single malfunctioning wire. I ended up with a robot that moves slowly sideways, and only when set up in a very particular way.
I don’t think the video portrays it well, but the bot almost fell off the table while I was tweaking the code and the tripod position.
Initial Pom Pom Design
After considering how different animals move, I initially decided to have my pom pom bot crawl along the ground–with 2 servos with popsicle sticks attached that would act as “arms” that dug into the ground and pulled the bot forward. The bot would have regular cycles of the arms starting in front of the body, rotating under the body and pulling the body forward, and then the arms quickly rotating the opposite direction to reset the arms back in front of the body and to start the cycle again. Before I started building the circuit or writing code, I drew a quick sketch of how the bot would move (the “Locomotion” section”) and what the final bot would look like (the “Aesthetics” section).
Initial Prototype Sketch During Lab Section
A green caterpillar, the image that comes to my mind when I think “caterpillar”
Since the bot would be crawling along the ground, I wanted the appearance of the bot to resemble an animal that crawled along the ground. Caterpillars and snakes were the first animals that came to mind, but after I saw the pipe cleaners in the lab, that reminded me of the ribbing around caterpillars and that finalized my decision to make my pom pom bot look like a caterpillar; the main body would be a felt cylinder and the ribbing of the body would be made out of pipe-cleaners that ran across the diameter of the felt cylinder to mimic the cylindrical torso of a caterpillar. The skeleton of the body would be made with popsicle sticks to provide a rigid platform to attach the servos to. Finally, the eyes would be made with googly eyes or layered cotton balls, whichever one looked sillier 😛
Initial Prototype Construction
My initial prototype was a disaster. Writing the code was easy, but I didn’t realize the servos’ 180 degree rotation restriction would be an issue. My initial design had both servos resting on top of the popsicle stick skeleton, with one servo motor on the left and right side of the bot, and each servo would sweep under the body at the same time. However, because the servos could only turn 180 degrees, there was no way to orient the servos such that they rested on top of the skeleton and both rotated under the skeleton.
If you look in the below picture, both servos rest on top of the body (Popsicle sticks). But because the servos only rotate 180 degrees, the left servo is only able to sweep from in front of the body to under the body (which i want), but the right servo can only sweep from in front of the body to above the body (which is not what I wanted).
The result was that the bot just flailed around instead of making any progress since servos could not sweep the same direction at the same time. See this Google Drive video or this video to see how the 180 degree degree rotation restriction resulted in a flailing bot.
So going forward I had to reconsider how the servos would be placed on the skeleton of the bot.
My next design was a small fix to just place the right servo on the bottom of the skeleton rather than on top–that way the right servo’s 180 degrees of motion would sweep under the body just like the left servo. As you can see in the below picture, the left servo is above the skeleton (red rubber bands) and the right servo is below the skeleton (left rubber bands), and now both servos could rotate the same direction (in the direction of the blue arrows, under the skeleton)
That small modification for v2 allowed the servos to sweep together under the main body, but after running this design I realized that the popsicle stick arms were not generating enough friction with the table to pull the body forward. At this point, I had not even added the felt body to the pom pom bot, so the weight that the arms were going to have to pull was only going to get larger and a re-design was required. After seeing the servos run for a bit, I shifted gears from the popsicle sticks pulling the bot forward as arms, to instead having the popsicle sticks pushing the bot forward as legs since this would require less friction from the servos’ attached popsicle sticks to work effectively. So the shift from v2 to v3 was adding the felt body and running the servos so that they pushed the bot forward.
However, in v3 the max angle that the servos would sweep to was too extreme and the servos swept too fast (servos swept to a maximum of 140 degrees with minimal delay), so the pom pom bot would erratically jump around rather than moving forward in a consistent manner (as you can see in this Google Drive Video).
v3.5 had the same physical construction of v3, but the maximum angle that the servos would sweep to was reduced to 65 degrees in the code. This stopped the bot from jumping around erratically like v3 did, but now the bot just moved up and down rather than making any forward progress (as you can see in this Google Drive Video)
For the final prototype I made a few mechanical adjustments from v3.5 to make the pom pom bot effectively move forward
- Changed the maximum sweep angle to 120 degrees so the legs would go underneath the body far enough to be able to push the body forward, but not sweep so far that the bot would jump around when the legs were retracted
- Added a small 250ms delay between cycles to allow the bot to settle down before rotating the legs again
- Added a popsicle stick “tongue” to the front of the the body. Before, the front of the felt body was the only other point of contact between the pom pom bot and the ground when the legs were fully rotated. But the friction between the felt and the table was too high so the bot had trouble moving forward. The addition of the popsicle stick tongue lowered the friction between the front of the pom pom bot and the ground (since popsicle sticks have lower friction than felt), so the legs had an easier time pushing the bot forward
This allowed the bot to move forward in a consistent manner. See this Google Drive Video to see the final bot in action.
And now that the pom pom bot was moving correctly, I added the rest of the aesthetic materials to the bot (pipe cleaners for ribbing and tail, and cotton balls for eyes and nose) to make it look like a caterpillar. Here are some pictures of the final bot.
Reflections on Final Prototype
My final prototype was similar in spirit to my initial design, but physical restrictions (servos only able to rotate 180 degrees, friction with the table) required me to update the mechanics design. The main change was having the servos push the bot forward rather than pull the bot forward, while the aesthetics of the bot remained the same.
I was surprised how much I enjoyed making the face of the bot. Maybe it was the relief of not dealing with the servos anymore, but I had some solid giggles when putting on the eyes and the nose of the bot…perhaps the elongated tongue and slightly off-kilter eyeballs gave the bot a derpy charm.
Most importantly, I named my pom pom bot Harrington.
Initial Idea: My initial idea was to make a caterpillar like bot that moves by rapidly shaking back and forth. The design can be seen below.
In terms of materials I wanted to use pipe cleaners for the bottom so it could grip onto the table and move. Then I would use paper, popsicle sticks and balls of fluff to make the remainder of the body.
Prototype: Before I started creating the the entire design I wanted to make a smaller prototype to test if the movement I want actually worked.
As can be seen in the video the bot did in fact move, technically. It was able to shimmy across the table ever so slightly. Even though my concept would technically work, I decided to try a completely different approach to the pom bot entirely since I wanted the bot to move in a more fluid way. I also found that in terms of code this prototype would only move if the motor was programed to run at a fast speed, with this in mind I also wanted to make the next prototype able to move with a lower motor speed.
2nd Prototype: Instead of making the bot more box shaped like my initial design, I made it lanky and upright so I could attach the motor right side up instead of outside down like the first prototype. Also unlike the first prototype I also worked to make the bot more aesthetically pleasing by making it colorful. This new design can be seen below.
To my surprise this bot worked much better than my first prototype and was able to move at a variety of motor speeds. The only issues I ended up running into with this prototype was legs becoming separated from the motor, to help mitigate this I wrapped a pipe cleaner around the servo motor itself to keep the legs close to the motor even if they fell off of the propeller. The bot in action can be seen below.
Comparing this version to the first prototype, it is easy to see that the movement is much smoother. With this in mind I felt that overall this design was pretty close to where I wanted the final product, the only improvements I wanted to explore was making the legs more stable and find a way to get the feet to not cross over each other as much.
Final Pom Bot:
I unfortunately did not have the time to completely finish the idea of my final pom bot. However, I do have an image of how I would have gone about stabilizing the feet.
While I didn’t get to test this with the motor, I feel like having one or two piper cleaners attached to the feet would help make the bot shake less violently, which would also help in keeping the bot together.
In terms of the locomotion the first bot just kinda spun in place and slightly shimmied forward, whereas the final bot actually moved forward with a very janky form of walking.
I was surprised how I made a pretty specific drawn concept, however once I actually got the hardware and started working on it I quickly threw out my initial idea and designed something very different. With this in mind for future projects, I should create more than just one initial idea so I have more to work off of if one of the ideas doesn’t pan out.