Champaign-Urbana Community Fab Lab
University of Illinois at Urbana-Champaign
Champaign-Urbana Community Fab Lab

Posts Tagged ‘Assignment 7: Pom Bots’

Arduino Pom-Bot

For the in-class project I used one servo motor to create a simple flower in a pot. I cut a hole through the back of the cup to feed the wire through and created a flower to attach to the motor arm. The trickiest part was making sure the motor stayed put inside the cup while moving, which I ended up resolving by poking two holes through the bottom and fastening a pipe cleaner around the motor. The final result can be viewed here: IMG_0530

Getting the final project off the ground proved much more difficult in comparison. After getting some help from my roommate in ECE, I managed to successfully hook up the two servos. I originally wanted to try making a fish or snake-like robot. My attempt to create the skeleton of it consisted of stringing a pipe-cleaner between two servos, but after doing some further tinkering and research it turned out that more than two motors would be needed, and I have no idea how to easily replicate simple harmonic motion in Arduino code. Therefore I ended up scrapping that idea. 

an example of a failed attempt

I kept trying to come with ideas, but many of them didn’t work. The ideas made were not based on the objects that were actually created, but rather on how I could program the servo to make it move. For some reason I really just couldn’t come up with a way to make the object move, even though I understood that the servo motion could not be symmetric and one motor had to be stronger or have a wider range of motion than the other in order to propel the object in a direction.

I finally just tried going through with a standard toy robot. The image to the right is not particularly descriptive, but basically the idea was to put servomotors into each leg, connect a long bar to the servo motor arm and leg interior, and the motors would simple rotate between 0-45 degrees to move one leg in front of the other. The code for this was pretty simple, just two for loops oscillating between 0 to 45 degrees and writing the angle to the two motors. I used the Arduino online IDE to edit and push my code to the board. 
 I only had brown cardstock lying around at home, so I used that to create each leg; the connecting rod between the motor arm and the cardstock is a pipe-cleaner twisted around the motor head. Overall the idea was pretty simple; however as seen here: IMG_0533 there were some issues getting the leg to move. Throughout the whole project my greatest frustration with the motors was that fact that often they were too weak or light to move the object attached to their arms, but rather the motor bodies themselves would move X degrees relative to the object. So as you can in the video, if the leg was resting on the table it wouldn’t move; the motor would just rotate on the inside of it. Even when I tried connecting both legs, neither of them would move: IMG_0535. I couldn’t think of a way to weigh down the motors such that the object would move relative to them instead of the other way around. 

As you can tell, the last hyperlink is the closest thing I have to a final product and it’s not finished. However considering the large amount of time already taken to get this much done I decided to go ahead and submit what I have. This project was actually pretty frustrating in that I just kept seeing none of my ideas actually work, and working with the servos was tedious as well. Often I had to keep “zero-ing out”, ie. resetting the motor head to zero, in order to make sure I had the correct start and end points for the motor’s range of motion. And as mentioned, I couldn’t figure out a way to get the whole objects to move as I had envisioned them. From this project and the previous Arduino unit I was able to learn how to use the Arduino IDE and work with basic hardware. But it’s convinced me.. I think I should stick to software hahah. 

Continue Reading

pom bot – justin franklin

This week in the maker 490 class, we continued our use of arduinos and created a little mini robot called a pom pom bot. I looked at some of the examples of ones that had been made in the past, and from what I saw it looked pretty straightforward and relatively simple. Unfortunately, I was sick the day we were given this assignment, so I was at a severe disadvantage as far as knowing where to start or what exactly to do.

I started by just getting the servos to move, so I downloaded the simplest servo test code for arduino I could find and uploaded it to the board. Then I knew that the board was supposed to be sending the right information, but I didn’t know how the servo connected to it. Looking at schematics on the internet, it appeared that the three wires were positive, negative, and a wire that received information as to how to move. I didn’t know which ones were which on my servo though, so I had to try random configurations. It took a little bit of time, but I got it, and my servo started moving. To get two moving, I copy and pasted much of the code and added ”2″ to the end of the variables, and assigned them to write values to a new pin on the arduino. This was encouraging, the code was much simpler than I had imagined it would be, and I was glad I got this far. The actual design of the thing took more time.

From the example videos, I had seen a pom bot that was very simple and was really just two servos connected together and two popsicle sticks. It walked very awkwardly and lopsided, but it did work. I was inspired by the minimalism of this design and decided to try something similar, so I connected two servos directly together. I then attempted to attache popsicle arms to the servos, and quickly learned that attaching popsicle sticks to a servo and telling it to move did not equate to a walking robot.

This phase was the most frustrating part because it seemed like whatever I did, it did not work. Originally, I had attached short popsicle sticks as arms, about a half an inch, and then put big flaps of tape on them that looked like fins. The idea was to be kind of like a seal, that uses its fins to flap forward. This might have worked, but the servos were always moving backwards to reset themselves at their original starting position. I tried to overwrite this in the code, and get them to move 360 degrees continuously, but it didn’t work. I tinkered with this design for probably too long, trying to get it to work and running into more and more problems. At one point it seemed like it could work, but it kept flipping itself over. So I attempted to make “braces” for it, which were just more popsicle sticks that were supposed to stabilize it as it pushed itself. Ultimately, this didn’t work out, and at this point I was about to run out of time. I had 15 minutes left at the fablab, and the project was due the next day. I couldn’t work on this project at home, because the arduino board wasn’t a true arduino board and it wasn’t compatible with my macbook. At this point, I felt pretty lost, like I just wasn’t going to figure it out.

I decided to start fresh with my design, and attempt a more ‘bug’ shape like I had seen. I started by attaching the servos together with two popsicle sticks, so that they were more spread out. This would be the body, and one servo would control the front legs, and the other the back legs. The original reason I had avoided this style, is because it seemed sort of complicated as to how to design the legs. Especially with just using popsicle sticks. I wasn’t sure what to do about them. What i did was just attach a popsicle stick flat to each servo. This made it look like a pair of skis, and when the servos moved, they moved back and forth in a bow tie shape, but because it was flat, it just sweeped the ground and did not move. I adjusted the code at this point, because the servos were moving 180 degrees and their popsicle sticks were whacking into each other, so I made them move much smaller, like 30 degrees. I made the back one move twice and the front one move once, hoping that the offset would help push it forward, but it did not work either.

At this point, I really had to pack up and go, and I was really discouraged about the whole thing. Some of the other bots I had seen designed by other students, were really cool, and decorated really nicely. I was frustrated I couldn’t get mine to walk, and I felt like the aesthetic of my bot  looked terrible, just a bunch of popsicle sticks taped together, it looked far from a finished piece like the others.

The next day after class I decided to work on it some more. I wasn’t sure what I was going to do at first. I grabbed some materials at random out of the craft drawers. I grabbed a bag of clothespins without knowing what I might use them for. I had originally wanted to make little feet for my bot so far, so that it wasn’t laying flat on the ground. I started clipping the clothespins on in random spots, until all the sudden I realized that I could simply attach the clothes pin onto the popsicle sticks I had and it would act as a leg. After that, I put some hot glue on the bottom of the back pair of legs, to give it some grip. I also attached some pom poms at the bottom of the front pair of legs, to help the front slide. I was hoping that the back legs would grip and push the front ones. I also tilted the back legs at an angle which helped seem to push it forward a little.

All in all this project was actually really fun. I wish I had known a little bit more about what I was getting into before I went into it, but sometimes you gotta just figure it out. I underestimated how much it would take to get the design to actually walk. I’m glad I grabbed the clothespins, or else I may not have ever figured it out.

here’s video:





Continue Reading

Pom Bot- Christian Amato

This week we learned how to program Arduinos and use them to operate inputs and outputs further than the previous week. 

In class, I created this squirrel with a wagging tail by manipulating the delay sequences in the Arduino itself. I was pretty impressed with the overall result, considering it only took me the class period to finish it, and the servo was built right into the animal. I think it was a great introduction to using motors in the Arduino application. Here is a video below.  


From then on, we were tasked with creating something that utilized more than one motor, to create a pom bot that utilized many motors and moved in a similar fashion to an actual living creature. 

This led me to think of some intricate movement, and an animal that I really like is the penguin. I thought to create the waddle was something that could be achieved with servo motors so I decided to go for it. I looked up some pictures of penguins online and the waddle they do involves lifting their feet ever so slightly off the ground. I thought that this could be mimicked using a total of 4 servos acting as the legs, and the Arduino over-top of the servos acting as the torso. 

The circuitry involved in this was pretty straight forward, but I chose to make it as compact as possible by zip tieing a breadboard atop the Arduino and using breadboard wires so the entire torso was as flat as possible. I also liked the breadboard wires better than the traditional pin wiring that came in the kit because they seemed to have a better connection. 

As you can see in the diagram above, I wired a connection for 4 servo motors, wired in parallel using the breadboard. This was very intuitive, and unlike the Arduino where ports matter, a breadboard is free to interpretation so long as all the wires make it to their respective rows. 

From then I decided to get started on the lower portion of the body, which was glued together upside down and to a popsicle stick that I could fuse together to the bottom of the Arduino enclosure.

As you can see they closely resemble hips and legs, which is exactly what I wanted. 

Preceding this, It was important that the servos were all fused together as sturdily as possible. 




To make sure there was a strong bond between the legs, I used the helping hands and first applied superglue which took forever to dry.

I thought the superglue would be thicker, like hot glue but it kind of just bonded the small surface area of the two points together to a small degree. 

I decided to go over the joints with hot glue to ensure that they would maintain their rigidity during movements. 


bad legs


From the title of this video, these legs clearly were not the best for this case. 

So I thought about it further and decided the best course of action would be to utilize the 3D printer to make a triangular part that could connect both of the servos together, forming a rigid bond. 



This was the piece I created————>



And this is how the legs turned out after-




From this rigidity, I was able to make more forceful movements to propel the penguin forward












The legs were fully capable of holding up the entire Arduino from the bottom, and it was even balanced without really even trying. 





Here is a video of the bot walking. Pombot action




I loved this unit the most so far, it was really fun to create something that actually runs off a code that you can manipulate, and especially to see what you can do with so little in terms of money. I thought the things that were most important in this unit were understanding how to build the overall bot itself, to be efficient and strong standing. From the building, all aesthetics can be added on after the fact. 

What I would do differently

I think the possibilities with Arduinos are absolutely endless, and getting caught up in the minutia of the technical aspects is very easy to do when you are manipulating something that involves so many ins and outs. I would definitely take more time to plan out what exactly I wanted to accomplish in my time at the lab and work on tighter deadlines. I think that had the setback of the broken legs not set me back, I could have utilized the 3 hours I spent making the first legs into 20 minutes using the 3D printer which literally took 3 minutes per triangle. If I had that extra two hours, I would have been able to make my bot really stand out, I would have used black fleece and could have sewed a working body around it. I think my main distraction, in this case, is not utilizing my time outside of the lab to devise better plans on how I want to get the projects done on time. 











Continue Reading

Pom Bot – Charis Ryu

In-class: one motor bot

I created a cat bot with a wagging tail with a servo motor for the in-class project. I used a cardboard tube for the body and attached the motor inside the tube. Then, I created the bot’s face with a plastic lid and tail with wires, covering them with brown nonwovens.


Locomoting pom bot: 1st Prototype

For the first prototype of my pom bot, I used ice cream sticks for the body and legs. I watched several different 2-3 motor walking bot videos, and thought creating a 4-legged 2-servo bot would be the approachable solution. I watched a video of the making of 3-servo walking bot (, which I also found interesting, however I decided to stick to the 2-servo walking bot for the project. Next time, I would like to try this approach, as it seemed like a very clever, sophisticated solution.


I used the hot glue to attach the servo motors under the body and the legs with the motors. As you can see in the photos and the video above, I had two main problems: (1) the general structure of the bot was very weak and the back of the bot was not strong enough to carry the board, and (2) it didn’t seem that the bot was walking forward properly. I had to come up with a better walking algorithm that doesn’t use the original for loop (as it didn’t seem like the best solution to make both the motors to move individually) and make the bones of the bot stronger.


2nd (Final) Prototype

In order to fix the two main issues I’ve encountered while making the 1st prototype, I used more ice cream sticks to give more structural support and changed the algorithm code that makes the motors to rotate that makes the legs to move properly. Then, I used the fabrics, feathers, and hot glue to give the bot an aesthetic look.








Continue Reading

Locomoting Pom-Bot

My in-class design for the locomoting pom-bot was based off the paper we were given with the chicken on it. I tried reconstructing the chicken with a moving piece. I chose to make the head movable to mimic the way a chicken would peck grass. For the body, I put together two cut pieces of construction paper. I used brown cloth to cover some logos and feathers for a better look. I wrapped the head in some odd jaguar print to break the pattern. Using skewers and ice cream sticks I made the legs. The servo attached between the cardboard body and connected to the head, allowing for movement.

The overall design was functional and looked pretty cool with all its different features. I wanted to add on to it, so I started thinking of how to shape it into the next model. To improve the design I cleaned up everything that was sticking out, specifically the cardboard. Then, I improved the sticks-for-legs idea with pipe cleaners to make the design more colorful and a thicker base to allow the chicken to stand on its own. I made the tail into a moving piece by attaching a servo to the back and putting feathers and pipe cleaners on it.

The final design was still unable to stand on its own. The moving pieces shook the base enough to shift the entire thing off balance. If I could improve this design it would have to be started all over. I would mainly change the frame and the base. The rest of the pieces, specifically the tail and head, are good enough but could be made to look more neat.

Continue Reading

Skiing Pom Bot

In class

     This week we got to make little robots, which was very fun. We had class on Halloween, so I decided to make a little ghost. I glued a popsicle stick to a servo and glued that into the cup so that it looked like it was waving. While working on it, I played around with how far and how fast it moved:

Admittedly, it doesn’t look very much like a ghost, but I ran out of time and it didn’t really affect the function so I never finished that part.


Final Project

     While thinking about what sort of robot I should make, I was sitting in my dorm room and my eyes wandered over my box of plastic silverware. For some reason, I was hit with the burst of inspiration to make a skiing robot, using knives as skis. I started sketching my idea:


I eventually decided to use forks for the poles since I had them on hand. I planned to have two servos act like arms to swing the poles and they would push the bot forward. I wasn’t sure exactly how I wanted to make the person, as reflected in my drawing. I wanted the bot to resemble a person skiing. However, having a figure that looks like a human balancing on skis felt like adding unnecessary complication to the bot. In the end, I used the cup from my in class assignment since he already had the googly eyes to look the part.






Adding the third servo to lift the bot


Construction wasn’t too difficult, but it took a lot of trial and error. The biggest problem was realizing that every time the arms swung back they also had to swing forward without pushing backwards. To fix this, I added a third servo to push the bot up as it swung back. This took some planning to build a piece that could support the contraption and also fit back into the cup. I also had to re-glue the servos and forks several times to get the distance from servo to ground correct. 





Holes added for the wire to sit in more convenient places


One of the frustrations I had was with the wires getting in the way of the forks, so I added holes to the cup for the wires to flow out of the top nicely. This makes the project more organized, although the angle the wires pull at sometimes stop it from locomoting unless held at a better angle.





Programming was pretty simple, too. The arms basically just had to use the sweep code. Because the servo was flipped, I did have to change the left servo to go to pos-1 while the right servo went to pos. In between the for loops, I just had to have the third servo switch between two angles that I found experimentally. In the end, I had this code:



     I’m pretty happy with my bot, though it is clearly a rough draft. For my redesign, I think I’ll keep the silverware because they sort of inspired me in the first place. However, I’d like to make the figure look a little nicer as it currently is full of random holes. I figure my second attempt will look less slapdash since I have a better idea of where things need to be glued. The coding I did for this bot wasn’t very complex, so  I’d also like to look into adding an ultrasonic sensor to make it stop if it gets close to something.

Continue Reading

Arduino Locomotion

After last class where we worked with arduinos and sensors, we then moved to using servos with the arduino to make things move. The in-class assignment was to use a single servo to animate something. My thought was to use the materials at hand to create a kind of “boogie bot”.

The idea was the servo would actuate a hinge at about waist-level of a stick-figure-ish mock-up and effectively have the character sway their hips back and forth. Draped with enough fabric, and the stick-figure look would be lost. That was the hope at least, in reality, a lack of large pieces of fabric meant I could not get the coverage I wanted, added to the fact that I made a major mistake in the beginning I did not catch until later which was that instead of creating the 3 articulation points I had planned, I instead created 4, I cut 3 sticks, not 2, so I had too much movement, and not in the places I needed it. The idea sort of worked but was overall a spectacular failure which I did not feel right taking any pictures of as I am sure Emily has it seared into her mind. Let’s say nothing more about it other than I was run over by the “struggle bus”…beep….beep…

To try and lick my wounds from the in-class assignment, I decided to try for something challenging and ambitious, and at the same time make it season appropriate. My plan was to make a crawling severed hand. The dressing would be easy to accomplish as I’d use a large work glove where I could hide the electronics. As far as how to actually make the hand crawl, I figured I’d use a sort of walking motion of two fingers to propel the hand. In addition, I figured I would take a page out of Nature’s book and design the fingers in a similar fashion to how a human hand actually works. This would involve first creating proximal and distal phalanges for my hand which I would create out of plywood. The articulation would be accomplished by using miniature bolts with washers and bolts. The washers would act as a spacer and also articulating surface to make the movement easier between two pieces of plywood. From there, the tendons would be substituted for fishing line complete with tendon sheaths (also made from fishing line). I would anchor the line to similar positions as they exist on the human hand, that being at the tip of each phalanx running under the “tendon sheaths” and secured to the arms of the servos which would be lined up with the phalanges to ensure extraneous torque would not be introduced. In order to insure that flexion and extension could be created predictably, I would run both the anterior as well as posterior tendons. Hot glue would keep everything together, and I would need to round out any sharp edges to help the assembly slide into the glove. For the wrist, I would use a short cardboard tube with a platform glued inside to provide a surface for the electronics as well as give the wrist a arm-like shape. As a first pass, I only articulated one finger to see if the process would work. The build was a bit arduous especially when it came to maintaining tension on the lines to allow for proper articulation. However, it did have some life:


It seemed to have some promise, and I figured with having the other finger to provide support as well as the grip of the leather fingers of the glove it would move. The code changes would be a mirror of the same steps I had for the single finger. So I sallied forth and built out the second finger as well as the code for it, and the result was as follows:

A little tweaking of the movements was in order, but otherwise, it was starting to look like it could walk. placed in the glove finally with the “arm” as well as another arduino shield to make the connections much cleaner, and I had this…

Ok, so I won’t be going to work for the imagineers at Disney anytime soon. The biggest drawback I found was that the servos are not very powerful, at least not for the application I used. It kind of shows you the kinds of crazy forces your own hands go through to do something as simple as typing this post on a keyboard. Add a glove to all of that, and I’m pretty sure I can hear the servos crying trying to move inside there. The glove does move, albeit at a glacial pace and the design of the fingers actually makes it seem like there is a skeletal hand inside the glove every time they print against the fabric. That being said it looked creepy enough that my girlfriend threatened to kick it if she sees it coming for her. I wonder if using either a stiff “tendon” instead of fishing line would make the movement stronger as well and allow more transfer of force as well as make it easier to calibrate. Otherwise, perhaps just some stronger servos are in order can can really move the heavy fabric of the glove and allow the fingers to flex more.

Continue Reading

Daniel Shin – Assignment 7: Pom Bots

This week, I learned how to use a servo motor with Arduino to create objects moving in loops. In class, I made a paper bunny with waving ears to practice the use of the servo motor.

The main issue to the design was that the moving ear had to be on a different layer than the head of the bunny, so the ear doesn’t collide with the head when waving. I came up with the following design to prevent the ear from colliding and still be connected with the head.

Overall, it functioned as I intended.

For this week’s final assignment, I did not know I was supposed to improve upon the in-class activity because the assignment prompt was uploaded after I finished my product. Therefore, I came up with an entirely new design based on a game I played before.



In a game called Metal Gear Solid, the main character walks around in a cardboard box as a sneaking device. Although it sounds like a joke, it is considered a famous meme in the gaming community. When figuring up with a design, I did not want to make an ordinary animal, so I decided to create a walking cardboard box as a fan of Metal Gear Solid.



This is the sketch of my initial design. The two motors are going to be glued together side by side to resemble the human feet. Also, they were going to be hidden inside the box so they can not be seen. The motors would be connected with the top of the box so the motors can move around the entire box.

The first step to the production of the bot was to make the motors to walk. After gluing the motors together and tweaking the initial example code, I was able to make the bot advance forward.

I looked up the template for an amazon box since that was the standard box design I was looking for. I cut out the template on a standard cardboard to create a mini version of an Amazon box.

The first problem I encountered was that the box was too small for the two motors to fit in. I had to build a bridge that can hold the motors together with the box so it would have enough space to move the legs.

After gluing all the parts together, the bot was walking forward as I intended.


Once I was done with the functioning part of the box, I had to design the box to make it look similar to what it looks like in the game. I used the image on the top as a reference and looked for patterns and symbols I can use to create the design.

I found these three images that are used in the game.

I created the above image in photoshop so I can simply print out the image, and it would fit nicely with the box.

I glued the printed image to the box and created a hole that is usually used as a handle of the box, so there is space for the cords to leave the box instead of having them dangling under the box. 



There were two main parts to this week’s project: making the bot move and designing the visual appearance. Both parts were equally difficult and consumed a lot of time. If I were to do this project again, I would use a thinner material for the box instead of using cardboard to make a sharper-looking box. Overall, it was a great opportunity to create moveable fan art.

Continue Reading

Locamoting Arduino Pom Pom Robot

Initial Concept/Design

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.

Initial Construction/Prototype

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.

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:

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!

Continue Reading

Drew Zelac – Arduino2

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.

Continue Reading

Arduino 2: Locomoting Bots

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.

Continue Reading