My initial plan was to have a robot that would have triangles as legs and then yank back and forth with them. Later on this was actually the best “walking” design. I want a minimalistic design so you could really see the interior of how the robot works. So the robot will definitely showcase it’s Popsicle sticks. Popsicle and feathers will be the building blocks for this robot. The only thing I had in mind was Boston dynamic, so yeah, definitely good inspiration.
- Take a photo or video of your initial pom-pom bot fabrication
Here is a video of the first robot: https://photos.app.goo.gl/7tX9pfPCUm2BB1Kj1
The next iteration was to be more adventurous and make the robot walkable on both sides. This kinda failed because the legs turned out to be a bit to heavy for the axis on the servos to carry.
Photo of the second design, you could see I extended the triangles legs from the first design to also be on the upper part of the robot so it could walk both upside down.
The second design turned out to be very unstable towards the sides so I wanted to make a more human like so when it fell it would have a servo that could lift it up, so it operates both straight ahead and 90 degrees around it as well.
Changing materials would remove the fun of this challenge I think because Popsicle turned out to be extremely good for fast prototypes and suited the purpose very well. But yeha, you could 3D print fancy stuff but …!
Second design with balls to keep it stable, to heavy though…
Design 2 with the fat support balls.
Final design with 4 servos and a pimp feather.
Second design without support balls.
The second iteration kinda failed because of to heavy legs, I think the last design turned out to be pretty good even though the cables to the Arudino turned out to be kinda messy and hard to keep track of so it didn’t tangle itself into the robot.
Movie of my final design: https://photos.app.goo.gl/YGXtkxIYy7w7l6qM2
The initial design was a minimalistic approach with very few details. Comparing this to the last design which had a complex set of axis made and several motors. This clearly proves that less is more.
For next time. It would be awesome to start with building a robot that with very high probability will walk from point A to point B in a decent time. Then instead of focusing on the interior design you could build a game of life simulation and see what the robot will do. It would also be interesting to put some sort of pen on the robot so you could trace the robots thinking and get a insight in the 4th dimension 😉
For the initial concept and design, we were asked to think about something that can move from point A to B. Initially, I then thought of creating an animal because of how they move but then I decided to do a baby. I initially didn’t attach anything yet because I wanted to see how the motors were going to move on their own. After I managed to do that, I then glued the Pom Poms together.
For the initial construction and prototype, I decided to mimic how a baby would look if it crawled on the floor. I then glued multiple little pom poms together to look like a baby in a diaper. After that, I glued the Pom Poms to the motors. For instance, I glued one leg to a motor and then I glued the other leg to another motor. As I was trying to figure out the movements, I had a lot of struggle trying to move it from one point to the other. I also realized that the motors weren’t as stable because there wasn’t anything really holding them steady together. Because of this I changed my design so that I could include Popsicle sticks.
For my second prototype I was actually inspired from the Popsicle sticks and decided to mimic how a surfer would look on a surf board. Because of this, I attached the two motors together under the Popsicle stick and I attached my figurine to the top of the board so that it looked like it was surfing. Additionally, since the PomPom bot still wasn’t as stable as I wanted it quite yet, I just tried to focus my movements on moving to different points.
Final pom-pom bot
For my final bot, I used my surfer pom pom bot. To make sure that my surfer was stable, I glued an additional Popsicle stick to the back of it. For my movements, I actually had a couple of them. For my first movement, I had my motors moving together at an extremely fast pace. Because of this, the surfer bot almost appeared to be vibrating across the desk. Unfortunately I missed the recording of this, but I eventually used another movement. For my final movement, my surfer moved at a much slower pace and sort of glided across the desk.
https://drive.google.com/file/d/1YuUjksvauJY8kEKXPpR6ESgYWY4lVUSO/view?usp=sharing (Might need a gmail account to view)
Overall, the project could be a little challenging when it comes to trying to make the bot move from one point to the other, but it eventually worked out a few times. If I had to change something, I would probably use glue to secure my motors to my Popsicle sticks because tape wasn’t as effective. Additionally, I probably would have added some blue pompoms or feathers so that it really looked like it was surfing, but I was unfortunately pressed for time. Other than that, it was very easy to understand how to work the Arduino and using the Pom Poms were fun.
I planned on my pom pom bot moving like someone jumping up from their knees. The motion is supposed to be similar to the guy in this video: https://www.youtube.com/watch?v=8y_WGJGaU0M
When he jumps up from his knees, he naturally moves forward. I figured if I had three motors with legs all horizontal and then simultaneously go down perpendicular to the surface it’s on, then this same effect could be created. A picture of this motion can be seen in my initial design below:
I planned on using glued together Popsicle sticks for the base and gluing the motors directly to the Popsicle sticks of the base. I wasn’t sure if the attachments the motors came with would be long enough to create any kind of movement with this motion, so I tried it out with just those for my initial design.
Here’s a video of my first prototype trying to move:
As you can see, the bot does not move at all. Also, due to the orientation of the motors, one motor rotates in a different direction than the other two initially. I wasn’t sure if this would hamper the bot’s movement, so I decided to make adjustments and then see if I needed to change the code. I planned on hot gluing two halves of Popsicle sticks together and hot gluing that to the motors so the legs would have more length. I was going to glue the two sticks together so the legs would be a little wider and more stable.
A video of my second prototype is given below:
As you heard, I was distraught when it broke. This prototype seemed to work quite well before the rear leg fell off. I think the leg fell off because there was a little bit of friction between the tops of the sticks and the base of the bot. For that reason, I decided that the only change I needed to make for the final version was to attach the little legs to the motors better. I used hot glue for this. This would help keep the legs attached despite some rubbing with the base. I tried fixing the code so that all the legs would rotate the same way, but I was not able to. I wasn’t able to get the motor to rotate in the opposite direction. I also had to make my bot pretty now that I wasn’t making more adjustments on it. I used some fuzz balls and pipe cleaners for that. Unfortunately, something happened to the video of my final version moving, but I do have a picture of what it looked like.
It moved in the same fashion as the previous model sans leg removal. All together, this is very similar to the initial design of the bot. I was lucky that my first idea for making the bot move worked.
INITIAL CONCEPT + DESIGN
This week, we had to make a walking pom-pom bot using Arduino, servo motors and everyday items. When I read this week’s assignment prompt, I knew it was going to be a challenge because I am below average when it comes to conceptualizing mechanisms. So I looked at the prompt and drew the first thing that came to mind. This initial concept consists of two servo motors taped together with one popsicle stick strapped onto each motor (Picture 1). I thought the two popsicle sticks would act like two angled legs. Will it work? ¯\_(ツ)_/¯
DESIGN UPDATE AND 2ND PROTOTYPE
It didn’t work (Video 1). The bot stayed in the same place, chopping around. At this point, I wasn’t sure what I needed to change to get it to start moving its position (because I also generally suck at physics). I looked at my friend’s bot (which was going places!) and I noticed her motors were turning very fast. It also had shorter popsicle “legs.” I then noticed that my “legs” probably needed to turn more. So for my second prototype, I decided to cut half the popsicle legs off, set the servo motors to turn faster, and set the motors to turn for a greater number of degrees. The plan was to propel my bot forward using momentum. Increasing the speed of the motor through the code wasn’t a problem. You can see in Video 2 that the updated pom-pom bot design/mechanism is an improvement from the initial design because it’s slowly going somewhere. In my head though, I thought my pom-pom-bot was going to move forward a lot more because of the alleged momentum.
I also added some decorative feathers and googly eyes to give my pom-pom-bot some personality.
FINAL POM-POM BOT
For my final pom-pom bot (Video 3), I really wanted to keep trying for that “momentum” action. I added an additional, short, popsicle “leg” on each motor. This leg is positioned between the arc of the two legs. I thought it might help with the push forward by giving the bot a bit more arc from the ground. I also changed my code so that it would iteratively push forward quickly and retract slowly. The final bot’s movements weren’t as symmetrical as the bots from the 1st and 2nd design, but this third bot certainly went farther faster than both of the previous bots. Because I didn’t want to use too many materials or take apart my first and second bots, my redesigns were relatively simple part additions or subtractions to the bot. For that reason, my final pom-pom bot looks a lot like my first design, but with a few extra legs and flair.
I wasn’t sure how to code different motors to go different speeds/positions at the same time. At the time of the project, this wasn’t essential to my pom-pom-bot design so I admittedly did not google a fix to this curiosity. If I wanted to improve or redesign my bot, I would probably have three or four motors, and at that point, I would definitely have to be more precise and strategic with the coding.
This week we used Arduino and 180-degree servo motors to construct moving robots.
I wanted to start out with a relatively simple design and make a pom-pom bot using two servos. My original idea was to attach the motors opposite each other, and place popsicle stick legs onto the motors. This way the servos would be like hips and the sticks would be like legs (with no knees). This idea was inspired by my own experience with movement (walking on two legs). I was planning for the bot to have a “general monster” look, with some pom poms and googly eyes, similar to the examples we had been shown. The bot would move by the legs hitting the ground with enough speed and coordination to cause it to move/jump forward.
Initial Construction – two motors and popsicle sticks
In my initial construction, I only focused on the mechanics of the bot and not the style. I hooked up the second servo to the board and initialized it in the code. I experimented with the servos moving in a synchronized pattern and in a mirrored pattern, and there was some directional movement but the bot mostly stayed in the same spot.
For the next prototype, I wanted to add some flair to the bot with a few pom poms and a feather. I also wanted to adjust the delay to see if I could get more movement from the bot through a more forceful downward sweep of the legs.
This bot moved pretty quickly, but it easily got tied up in the servo cords. The strategy of causing movement by jumping seemed like a good idea, but looping these movements made for a pretty wild bot. The feather on the bot combined with its irregular, jerky movement made it quite a sight! For the next design, I wanted to slow the movement down and make it more predictable and reliable. I also wanted to add the other touches on the bot like eyes, and have my final decorations fit the movement of the bot.
Video of the second prototype – 20180328_201935_1
Final pompom bot!
After I played around with the code more and slowed down + changed the motion, the bot reminded me of an airplane with a propellor at the front, so I wrapped the body in white felt and put on some red wings. I also added a few pom poms googly eyes, and the pink feather from the last iteration. The final pom pom bot is similar to my initial concept in that it uses two servos and popsicle sticks opposite each other, and it has googly eyes. It is different from my initial concept since the popsicle sticks are actually the bot’s face and tail, and the bot decoration was inspired by an airplane.
What surprised me about this design process was how long it took to get a movement pattern going that allowed the bot to travel in a consistent direction. Hooking up the servos was no problem, but getting a movement pattern that was reliable took much trial and error. In the future, I would start out by looking at more examples of bots and the code that produced them to understand the range of possibilities in terms of servo orientation and bot movement as well as aesthetics.
Video of the final bot – 20180328_201935_2
This week, I made a pom pom bot using Arduino. I was excited to do this project, since it looks ridiculous and very fun. My initial idea was to create an Arduino with two legs and two servo motors, walking like a crab slowly from left to right. It will have two eyes, one in each motors. It will also have pom poms all around it.
Here is the photo of my pom pom bot
My idea to the software design was to move left motor slowly, then right, then left, then right again.
However, with my initial code, the pom pom bot could not move, or only could move very very slowly.
Then, I did not change my bot design and/or materials at all, since I found no problems with the design. What I changed was the idea about how to make the bot move. I wanted the bot to jumping, instead of walking.
After changing the code, I managed to make the bot moving. The two motors rotates quickly so that it jumps. It looks like this:
I believe my initial pom pom bot design was successful, because it could move rapidly. The only problem that I faced was sometimes if the bot jumps too quickly, one of the sticks popped out of the bot.
Here is my final code:
My final pom pom bot appearance is the same as the initial design, but the movement is different. Instead of walking slowly, it jumps rapidly.
Using the Servo motor was a new thing for me, since I am new to Arduino. It was not difficult, but I had to find some workarounds to its limitations.
In the future, if I have to do this pom pom bot project again, I will make the bot move perfectly, and prevent the stick from popping out. The idea that came to my head was using the screw, but I could not manage to find any screw that fits with the stick and the motor.
In conclusion, I was happy to finish this project, because it’s fun and entertaining, but challenging at the same time. I believe that it is a good project for learning Arduino.
This week, I created a “walking” robot controlled by an Arduino and four servos. I went through multiple designs for this robot. For my original design, I tried to make the robot move like a worm, where it would slowly inch its way towards the destination by flopping its “belly”. To do this, I attached two motors to it, with two popsicle sticks on each side to push it forward. However, after testing, I found that it would mostly just rock back and forth, but not move forward.
I thought about ways to overcome this problem, and I came up with a four-motor design, inspired by the game “QWOP” where you have to control a character’s thighs and calves separately. To do this, I glued another motor to each side of the robot. At first, I was afraid the Arduino wouldn’t be able to power all four, but it turns out they worked just fine – I had to use a breadboard to share the voltage pins though.
After that, I wrote some code to move the two legs. For some reason, when each leg was controlled individually, it worked perfectly. However, when controlling both legs simultaneously, they became very jittery. I couldn’t find the cause of this (I think it might have to do with drawing too much current from the Arduino), so I played around with the delays until the impact of the jittering was at an acceptable level.
The next problem I ran into was having the robot stand up while moving. I believe this was caused by the tall height of the robot, so that when one leg was lifted the entire robot toppled over. I ended up adding an extra two stationary legs, kind of like crutches. Finally, the robot could move! To make it a little less slippery, I made some “shoes” out of hot glue to help it push against the table.
In the end, my design was pretty different from what I originally had in mind. My first design couldn’t move at all, while my second design would fall over as soon as it started moving. I think my final design was very successful at staying upright, though not nearly as fast as I had originally hoped. If I were to redesign this project, I would probably look into making a design that could recover from failure (like falling over), so that it would be able to move more quickly.
The code I used is available here: https://ghostbin.com/paste/jnz4j
When we initially learned about the pom-pom bots, the fact that Servo motors have a rotation limit of 180° wasn’t mentioned. So, when we got to our lab and we learned this I tried to think of different limbs that move with only 180°. My mind when to fish and their tails. Fish can swim but they don’t walk. They do however manage to flop around on land. So, I figured I would go forward with the fish movement idea.
Though the movement would be that of a fish, I didn’t want to make my bot look like a fish. We had all the supplies to make it look however we wanted at our disposal. Popsicle sticks, pom-poms, hot glue, and tape were our materials. I drew a quick sketch that used all the materials except the hot glue. It’s sticky, hard to work with, and could damage the electronics so I opted to just stick with tape. Later I would find the hot glue necessary. The initial pom-pom was an inspiration on the whim.
My initial construction of the pom-pom bot was a failure. I worked on it during our lab section but got nowhere but frustration. I tried writing the servo code from scratch to form movement that mimicked what I thought a fish moved like, but it didn’t manage to make anything move in the way I expected. I plan on returning to attempt a round two at coming up with a working, moving design. I’ll restart with the example servo code and redo everything physically. Ultimately I had nothing to show for my initial construction.
To improve the movement design I’ll be making a support structure separate from the rest of the pom-pom bot. This support structure will hold the servo and will hopefully be sufficient enough to move the bot forward. In order to make it move forward better I think I’ll experiment with sandpaper attached to the servo motor. It may create friction in one direction causing the servo arm to slip on the smooth side and move forward on the rough sandpaper side. I’ll also have to use hot glue because tape is making nothing stay secure.
Not pictured is the support structure I added. After restarting completely with a few new ideas I implemented the support structure to house the servo motor separate from the bot body. This actually worked pretty well! I used the example servo code and sped it up to create movement for the bot. It was moving but the bottom half of the bot was dragging along the table. I tried to implement what I thought was a good idea with the sandpaper, but it didn’t work. More tinkering with it could probably result in success.
In the final iteration I plan to fix my problem of the bottom half of the bot dragging along the table. I might be able to speed the bot up a little bit more as well. I’ll also attempt to use the sandpaper again.
Final pom-pom bot
I decided to call the final pom-pom bot Chomp because it sort of looks like it is chomping down every time it moves forward. The chomping and wires mimic the likes of Chain Chomp in Mario games. The last iteration of Chomp added another support structure between the main body of Chomp. This was an upgrade to the one support structure Chomp had before, allowing only one Servo motor to be attached. With the upgrade another servo motor was attached, and when they were synchronized Chomp moved forward with more power as well as moved straighter.
I didn’t expect adding a second servo motor to work in my favor. Initially it didn’t, but once I synchronized the motors inside of the Arduino software to move at the same time, it worked! If I were approaching this same problem differently in the future I would get more creative with the look and creative design of my pom-pom bot. I was so worried about actually getting Chomp to move that I disregarded much of the creativity I know I am capable of. Another experience working with servo motors interests me greatly!
The final pom-pom bot code.
This week, we used multiple servos and craft materials to make iterative pom-pom robots. It was refreshing to work on something that could be very quickly evaluated, scrapped, and redone. My initial design is shown below. The two servos are connected with duct tape at the dotted line, and each popsicle stick is hot glued to straight servo horns. Each popsicle stick has been broken in half so that the bot will have a lower center of gravity and hopefully maintain its balance more easily. The bot will start in the “unfolded” position, and then both popsicle stick legs will press down at once, lifting it off the table. My bot’s movement was not inspired by a particular animal; for the first iteration, I just wanted to see how hard the servos could press off the ground.
This prototype had a strong tendency to fall on its back and wave its legs in the air helplessly, so I tried adding some extra stability in version 1.5 below.
This was not much more successful, probably because the weight was still unevenly distributed. These iterations convinced me that I would need a robot that could stand stably before it tried to walk. Also, I wasn’t getting the results I wanted with code that tried to swing the servos back and forth by a full ~130 degrees, so I decided to narrow the range of the servo movement. I didn’t think the materials needed to be changed, since the wood was providing enough support, it just wasn’t placed correctly.
Just for experimentation, I programmed each servo to randomly pick a value within 10 degrees of its rest position, and this ended up working! One leg of the robot was slightly longer than the other, and I think the fact that it was at a slight angle allowed it to travel (or rather, jitter) sideways. This was unintentional, but surprisingly effective, and if I were to do another iteration, I would make this unevenness intentional. It’s not the fastest or most elegant bot, but it moves very reliably to the left in a fairly straight line! I added some feather decoration just for fun. The resulting bot is more stable and more reliable than my first two concepts.
I enjoyed working on a project that was quick enough for me to let go of my original design and truly focus on improving each iteration, without worrying about the time sunk into an early iteration.
I began this project by thinking about how my pop-pom bot would move, more than how it would look. The idea I settled on for my first prototype was to have 3 servo motors, 1 on either side, and one in the center. The side motors have short legs, and the center motor has a longer leg. The gait is as follows-
- The side servos both move from front to back, pushing the robot forward
- The middle servo moves down, lifting the robot up
- The side servos reset their position. Because they are raised up by the middle servo, they do not move the robot back
- The middle servo moves back up, lowering the robot
- repeat steps 1-4
I built my first prototype as a skeleton, with no adornment, as I figured there wasn’t much point in adorning a prototype I might abandon immediately. I used hot glue to build the frame of popsicle sticks, as well as to secure the motors. My frame was designed to be a 3 point contact, with the two motor legs, and a “tail” which dragged behind.
To my surprise, my initial prototype worked surprisingly well. At this point, I had the choice of sticking with my current prototype, or abandoning it in favor of a second prototype. Since the first worked relatively well, rather than scrap it, I made further iterations on the prototype in order to improve its performance. The first prototype used almost no materials, leaving much room for experimentation with regard to material choice.
The second iteration of my prototype added popsicle stick feed to the two “legs” of the robot, in order to correct the major flaw of the first iteration, whose feet slipped quite a bit on the table. The legs were made from two pieces of popsicle stick, sanded (and later cut, when I found a good cutting implement) to a flat edge, and glued perpendicular. At this point, I also began adding feathers to the side and tail and pom-poms to the bot, as well as eyes on the front. The decoration was meant to invoke a bit of a peacock, with the pom poms serving a primarily structural purpose
Unfortunately, the feet were a bit too effective at gripping the table. The extra width made the legs push the robot back when resetting its position, putting it right back where it started! At this point, I cut down the front of the feet, in order to reduce their contact with the table. However, this also failed to prevent the robot from resetting its position, and so I scrapped the wooden feet entirely.
My attempt to cut down the feet
My third iteration had pointed wooden feet attached to the robot’s legs, with a dab of hot glue put on the end of each foot to encourage traction. The glue, I figured, would provide a good grip on the table, and the pointed end of the foot would prevent the large foot surface from catching when resetting the servos. These legs were longer than the center servo’s plastic leg, so I had to make a wooden leg for the center servo, as well.
The wooden leg for one of the legs, with the glue on the end
These wooden legs with glue feet worked far better than the wooden feet, and better than the original plastic legs, too. The only downside to the new design was that the robot got more and more lopsided as the length of the middle servo’s leg increased. The robot listed far to one side as it raised up. This led to it slowly turning to one side as it moved forwards.
My fourth iteration was designed to combat this lopsidedness. I placed a fourth servo above the third, and gave it a leg long enough that it could work with the third servo, raising the robot from the other side, so both sides of the robot were lifted up at the same time. I also added a few more feathers, and a silly red feathery pom-pom to the top of the robot, giving it a bit of a mardi gras look to it.
It was at this point that I stopped iterating on my design, as the fab lab was closing for the night. The fourth servo helped lessen, though not eliminate, the problem of the robot turning as it moved forwards.
My final bot moves in much the same way as my original bot, as the original idea was sound, except that it moves much more reliably (due to the glue feet and fourth servo), and looks much better.
If I had more time, I would fine tune the program of the robot, both to increase its walking speed, now that the feet have traction, and to decrease the bit of lopsidedness that remains, a product of the two lifting servos having different length feet. I also think that the side legs could have been made longer, to make the “stride” of the robot longer without too much effort. One final change that I would make would be to redesign the center motor apparatus, to make it parallel to the other legs. In this way, I could have avoided the lopsidedness of my current design, by making the lifting servo move from front to back, rather than left to right, keeping the robot relatively balanced as it lifted.
I think that the main thing I took away from this project is the danger of iterating directly from an initial prototype. While it is true that my initial prototype worked, had I made one or two more, such as one with a parallel lifter servo like I described above, then I could potentially have made the robot work better, and avoided some of the issues that came up down the road (like the extreme lopsidedness). However, my final robot still turned out well, and I am proud of the improvements made to it. It looks pretty nice too, though I did not build it around looks.
This week we worked on creating our pom-pom bots!
We needed to use Arduinos again, which I was pretty unexcited about. However, I felt more comfortable this week because I got to experiment with a couple sensors last week. It was also a lot more interesting since we needed to create a physical object that could move, not just a sensor that could control how fast LEDs blinked.
My inspiration came from the Koi fish. I was initially confused on how I could make something that could move, and not just wobbly forward then backwards. I didn’t want something complicated like a foot so I looked up a video of how fish swim. It looked relatively simple, just two joints that move at 90 degree angles (see picture below).
Looking at this design I knew what I needed for the basic materials: 2 servos and some popsicle sticks.
I wanted to build out the framework of my bot before aesthetics, so I glued together the two servos using a popsicle stick and then tested it. Unfortunately, even though I designed it to imitate a fish, the bot just wiggled back and forth and did make a net movement. I was pretty confused at this point because it looked exactly like a fish and it was designed to imitate a fish’s movement, but it wasn’t the same. I tested it by pushing down on the servos at different times to see if it needed friction or something to push it forward, and it turned out that if I push down on the servo while it moved it would take a step forward, so if I alternated pressures on the servos it made a net movement forward – exactly like a fish.
My second design was to add a third servo on the top to alternate putting pressure down.
I added the servo in the middle to imitate a see-saw movement, where the servo would add more pressure on one side at the correct time to create more friction for the moving piece. Like my first design – it seemed good in theory but didn’t work practically. Even though it was theoretically adding pressure at the correct time, I didn’t take into account gravity or other things. My bot simply toppled over whenever it tried to move.
However, I had tested the bot my holding the middle of the see-saw steady to see if I had the correct idea, and it DID move forward. I knew I just needed something to hold it steady while it walked.
I added a bottom that attempted to stabilize the bot while it moved. You can see from the picture that it looks kind of like a see saw, but because I had to build this by hand the bottom wasn’t completely flat, and it toppled over anyways.
In this iteration, I added one more piece across the bottom of the see-saw, since a longer bottom opposing the movement the bot is trying to topple in would prevent it from falling. This solved the problem of balance, but because I had added so many sticks to the bot it was now too heavy to move. The servos couldn’t get enough friction to grip the table and pull itself forward.
I solved this by adding glue to the bottom of the servos. The glue is sticky, so it would give the bot a better grip (kind of like a web for a duck).
I finished off my adding a head to the bot for design purposes, and I was done!
I learned throughout this project that designs never really turn out the way you want them to. I thought carefully about what I wanted my bot to imitate, but there were so many other factors affecting it that my designs didn’t really work. I had to continually add ONTO my designs to account for different factors. Each iteration addressed a different problem, until it could finally move.
In my initial concept, I wanted the pom-pom bot to drag itself from point A to point B and I planned on giving it a set of legs to help move it forward. I only planned on using popsicle sticks because I never really considered it. To me, it seemed slightly unnecessary to decorate it, I wanted to focus more on the coding and the motion of the pom pom robot since I didn’t have prior coding experience. I forgot to take a picture of my initial model, however, it had two popsicle sticks taped on each motor. This didn’t work because the robot wasn’t able to balance on itself and it constantly fell over. I figured that I had to create better leg support for standing and probably a stronger grip so that it can pull itself and glide against the table. I also had to change the code so that the robot moves forward with one motor and the other motor goes the opposite way so that it works like legs in motion.
My second and final prototype worked but not exactly the way I wanted it to. I changed the code so that each leg of the robot moves at different times. I also added a popsicle between the two motors so that they stick together and works a little bit of a balance. The final prototype moves forward but also jumps upward and forward, thus dragging and bouncing the robot forward. I added more popsicle sticks to the motors so that the robot balances and stands on its own. I also added hot glue to the bottom on the sticks so that there was more traction against the table. I also ended up putting a little feather on the robot for a little bit of bedazzle. Overall, it was a fun project, I would definitely spend more time coding it and making it move more smoothly and make the robot look more finished.