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

Arduino Servo Bots

The first bot I made with an arduous servo motor is a fish with a motor attached to the back. The thought process for this was that the servo motor would act as a propeller and would propel the fish forward. However, the arduous servo motor has limitations, which is that the motor can only rotate up to 180 degrees. Also this idea may have worked underwater, but on ground, all it does it make the fish look like it is flapping around.

For our improved project, I wanted to make an actual walking robot instead of a fish that just flaps around. The idea for this was that using two servo motors that are sweeping and since the front servo motor is tilted, it would be enough force for the robot to move forward from the motion of its legs. The difficulties for this project came from imprecise materials. The popsicle stick and the laundry clips which I thought were all the same size, are actually not, creating problems making a level leg. The code for this project are simple for loop with the variable x that acts as the angle for the servo motor to be at.

#include <Servo.h>
Servo servo1,servo2;
char forward[] = {60,100,100,100,100,60,60,60};
void setup()
{
servo1.attach(5);
servo2.attach(6);
}
void loop()
{
for(int x=0;x<4;x++)
{
servo1.write(forward[2*x]);
servo2.write(forward[(2*x)+1]);
delay(200);
}

 

What I learned from this project is how hard it is to make a walking robot. Walking is a simple action that requires so many complex components that with materials that are incapable such as laundry clips and Popsicle sticks there is only so much that is possible for make the robot do. Design wise, I could have made the arduino bot move like an AT-AT from star wars by getting a battery so the wires do not limit what I could have attached to the robot and how far the robot could walk. If had to improve this project, I think I would try laser printing wood materials and use it to make a robot, just like a 3D wooden puzzle toys stores sell.

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: 

https://uofi.box.com/s/drqpg93heog8vtk9ppsp046zupinbcj0

 

 

 

 

Continue Reading

Arduino Bots – Scott Kim

For the in-class assignment, I thought a hatchet + log would be a cute and simple thing to create. 

Using some cardstock and gray/black sharpies, I managed make a fairly accurate hatchet and a brown log.

Then, I glued the log onto a large popsicle stick as well as the servo and hatchet. It was through some trial & error that I got the angles right. The Arduino program was mostly similar to the Sweep program with modified angles & delays in it, with the final result:

 

And then for the out-of-class project, I wanted to make a rowboat! It would have a boat base, and two grippy oars that it would “row” itself with.

I realized that a repeated back and forth of the 180 degree servos might not let it move anywhere, but looking at the videos of previous bots, it looked like it might not be a problem.

In many of the videos, a slow forward motion and a rapid “reset” motion seemed to work in consistently moving the bot forwards. I thought that the reason for this might be because the slow forward motion lets the feet grip onto the floor better, while the rapid backward motion causes some slipping.

I trusted that the issue might not be something that needs solving, and began a prototype build.

 

This part was where I made the mistake of not taking many photos – but I originally had imagined this boat using only one servo. Since the two oars will make a symmetric motion, I thought about connecting the two oars in the middle, and letting one servo move both oars. 

It was about an hour into this idea that I realized it’s a bad idea. It adds a lot of complexity, cramps the space, and requires a lot of precise holes and measurements.

So, crapping that idea, I kept the frame and attached two servos. Each oar has a dab of glue at the ends to keep it from slipping. Then the prototype/proof-of-concept was complete!

Then, I made someone to row the boat with some pipe cleaner, attached some actual paddles to the ends of the oars. I glued the little guy’s hands so that it can actually grab the oars :’)

And here’s the pretty simple circuitry:
Yellow: 5V
Blue: Ground
Orange: Control

The actual code wasn’t too different from the regular Sweep code either. After changing some delays, I just had to make sure that one motor goes from 0->180 while the other one goes from 180->0 since each servo is rowing on the opposite side of the other. Then, here was the final rowboat in action!

 

 

And by then I had already gotten out the googly eyes and then decided against putting them on the stick figure. So:

 

I felt that the hardest part of this project was the “getting it off the ground.” I especially felt this when going with my original design of using a single servo, but when I was trying to figure out how big, how far apart, or how narrow things should be. It felt like everything depended on everything else, and I couldn’t find a way to “incrementally” create what I had in mind without creating the whole thing at once. This was mainly because of the issue of not only moving parts, but parts that would swivel and slide past each other. I knew I could make drawings and measurements, After that though, I’m really glad that I opted for a two servo design. 

Another difficulty was, really, just getting the boat to go straight. One oar kept getting better contact than the other, making it turn rather sharply to the right. I tried fixing this problem by adding shims to the bottom of one end, but that made it begin to turn the other way. After some iterations of trial and error, I finally got it moving straight enough for a 9 second 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.  

squirrel

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

 

 

REFLECTION

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

Isaac Iyengar – Cookie Monster Robot

 

Normally my experience with Arduino robots is using 360o Servo Motors, so I was more used to wheels and liked the functionality of pivot turns that come with having 2, 360o Servo Motors. However using 180o Servo Motors, wheels are not possible (robot would just go forward then back and have no net gain. I opted instead for a walker design similar to 4-Legged Animals. 

For the first iteration, I wanted to make the robot entirely out of laser-cut 1/8″ Plywood. This was to ensure precise measurements for the construction and sleek design. For the legs I drew inspiration from the way press-fit boxes have slots that are able to fit the 1/8″ ply. I did rush the design of the base and it was a simple rectangle. If I were to redo the base I would make the shape much for sleep and resembling the torso of cookie monster.

Below is the Inkscape for the robot frame.

 

 

After laser cutting the pieces, I marked where I wanted the motors to be attached to the base was balanced, then hot glued the motors to the base. I then wired the Arduino according to the diagram below:

 

My first iteration of the robot was not successful in moving forward on it’s own. With numerous code iterations the result below still would just jerk forward and backward and have no positive net movement. 

 

 

For my second iteration, I wanted to preserve the use of the frame, but instead noticed that as a result of gluing one of the motors slightly higher there was an inconsistency between the two separate legs. So I rewrote the code so that the robot would move in what was the side direction (and I just treated this as the new forward). I also reglued the motor so it was slightly in a better position.  The result of these changes was a much better motion of the robot. I also increased the delay in the code and added a bit of hot glue to the bottom of the legs to have more grip on the surface. Below is the result of these changes:

 

The next portion of the iteration was modifying the robot to be more visually appealing. In the previous class, I enclosed a motor in fabric to resemble Cookie  Monster, and have the upper portion bite up and down on a felt fabric cookie. Unfortunately, the Arduino is unable to power three servo motors with the 5V onboard power supply, so for now it is just attached to the top. I wrapped the legs in blue pipecleaners, and the base in fabric and pipecleaners to resemble Cookie Monster. I added small fuzz-ball feet as well. Below is video of the final robot with the visual and functionality changes:

 

 

Overall I’m really pleased with the final result of this assignment. While the robot itself is horrific, it does resemble Cookie Monster and is able to move fairly well. For future iterations, I definitely want to include a power source to have the head movement as well. I also want to modify the code to support turns.

 

 

Continue Reading

PomBot- Joy Shi

This week in class, we learned to make a simple bot using a servo motor. This was relatively simple since we already had a code ready for us to use. I decided to make a mouse with its tail moving.

 

For my assignment, I originally had no idea of what to make. So I started with making and coding the 2 servo motors  to make it move. To get so ideas, I researched on ways to make two motors move. After making sure that the motors moved, I started to brainstorm on what my bot should be.

Sketch of pombot

 

 

 

 

 

 

 

With the supplies given in the FabLab, I decided to make an airplane using a toilet paper roll and some popsicle sticks. To make it prettier, I placed some pipe cleaners and pompoms. After designing the airplane, I placed the two motors on the bottom-front of the plane. While testing it out, I realized that I made the front of the plane too heavy, while the back of the airplane had nothing to hold it down. When I tested the motors, the head of the airplane basically tipped forward. To resolve this issue, I placed two pennies on the tail end of the airplane to balance out the weight. This helped, as the plane did not tip forward again.

After solving this first problem, my second problem quickly became apparent. Since I placed the plane on top of the two motors, it became a bit heavy for the two legs of the motor to make the bot move. I quickly realized that I could just place rubber on the leg of the motor to help it grip the surface of the table.

 

 

 

 

 

 

 

 

 

 

 

 

 

Sadly, the plane does not move far and if I were to improve on this project, I would try to figure out how to make it move farther.

Final Product!

 

 

Code Used: 

#include <Servo.h>

Servo servoLeft;
Servo servoRight; 

void setup() {
servoLeft.attach(10); 
servoRight.attach(9); 
}

void loop() { 
forward(); 
delay(900); 
reverse();
delay(900);
move1();
delay(900);
move2();
delay(900);
stopRobot();
delay(900);
}

void forward() {
servoLeft.write(0);
servoRight.write(180);
}

void reverse() {
servoLeft.write(180);
servoRight.write(0);
}

void move1() {
servoLeft.write(90);
servoRight.write(0);
}
void move2() {
servoLeft.write(90);
servoRight.write(90);
}

void stopRobot() {
servoLeft.write(90);
servoRight.write(180);
}

Continue Reading

Pom Bot Walker

Started drawing in classPlanned diagram after class

I am not a computer science major and this is pretty much Greek. I knew that I wanted to make a monster that moved his head and wobbled at the same time. I did a google search for codes that could help me do this. I found a book called, “The Best of Make: Vol 2,” which had a whole chapter dedicated to servomotors. The book listed a few codes and I copied them with the intention of combining the different items into one giant code. However, I made a few errors. 

One, I did not differentiate between servos. I wrote myservo and servoPan, but I did not specify which servo was meant to be servoPan in the upper portions of the code. 

Ultimately, when I attempted to run the code, it did not work. I kept getting various error messages. I ended up deleting portions of the code after trying to troubleshoot by using the Arduino.cc FAQs. Then, I reached out to Duncan as I could not understand, after doing research, what was wrong. It ended up being an issue with the void setup and void loop. 

Here are the codes I tried to use. The first one is using the Best of Make.

// Servo – Version: 1.1.5 #include <Servo.h> Servo myservo; // create servo object to control a servo

Servo servoPan; // servo to pan

void setup() { myservo.attach(10); // attaches the servo on pin 9 to the servo object

servoPan.attach(9); //pan servo is on pin 9

servoPan.write(90); // home both servos to center

myservo.attach(9); // servo is on pin 9

myservo.write(90); // set servo to 90 degree position

pinMode(servoPin; OUTPUT); }

void loop() {

for(pos = 90; pos >= 0; pos -= 2){ // goes from 0 degrees to 180 degrees // in steps of 2 degree

myservo.write(pos); // tell servo to go to position in variable ‘pos’

delay(20); // waits 15ms for the servo to reach the position }

for(pos = 90; pos >= 0; pos -= 2){ // goes from 0 degrees to 180 degrees

servoPan.write(pan); //move pan servo

myservo.write(servoPin, HIGH); // tell servo to go to position in variable ‘pos’

delay(15); // waits 15ms for the servo to reach the position

myservo.write(servoPin, LOW); } }

After I was having issues with the code. I decided to try to tweak the code from the Arduino library, the SWEEP and KNOB, and still ran into issues. This is because I was not thinking about the integer numbers. I chose an integer that would ensure that my robot would never run.  I started at 0 and said as long as it was <=90, which zero is, the Arduino would not move because it fulfills the function of the code.

/*
Controlling a servo position using a potentiometer (variable resistor)
by Michal Rinott <http://people.interaction-ivrea.it/m.rinott>

modified on 8 Nov 2013
by Scott Fitzgerald
http://www.arduino.cc/en/Tutorial/Knob
*/

#include <Servo.h>

Servo myservo; // create servo object to control a servo

int potpin = 10; // analog pin used to connect the potentiometer
int val; // variable to read the value from the analog pin
int pos = 90; // variable to store the servo position

void setup() {
myservo.attach(9); // attaches the servo on pin 9 to the servo object
}

void loop() {
val = analogRead(potpin); // reads the value of the potentiometer (value between 0 and 1023)
val = map(val, 0, 1023, 0, 180); // scale it to use it with the servo (value between 0 and 180)
myservo.write(val); // sets the servo position according to the scaled value
delay(15); // waits for the servo to get there
}


void setup() {
myservo.attach(10); // attaches the servo on pin 9 to the servo object
}

void loop() {
for (pos = 0; pos <= 90; pos += 3) { // goes from 0 degrees to 180 degrees
// in steps of 3 degree
myservo.write(pos); // tell servo to go to position in variable ‘pos’
delay(20); // waits 15ms for the servo to reach the position
}
for (pos = 90; pos >= 0; pos -= 1) { // goes from 180 degrees to 0 degrees
myservo.write(pos); // tell servo to go to position in variable ‘pos’
delay(20); // waits 15ms for the servo to reach the position
}
}

I used felt, feathers, Popsicle sticks, straws to create my pombot. I had stuffed a few of the pompons inside, but found I needed more because the felt provided no structure and thus, the pombot was too top-heavy. I did not stuff it enough at the end of the day, however, since I still had to hold the bot. 

It was suggested that to get the robot to move the way I wanted, I needed a third servo. When I put the third servo to the pom bot, it would twitch and then, not move. Brandon tried to help me get it going, but we came to conclusion that I fried the motor with three. Therefore, I decided to keep it at two only. 

Ultimately, my pombot does not wobble like I intended. It also pretty much walks by scooting. I thought the head also did not work the way I wanted. However, it does move, but I held it up since my pombot was too top heavy. 

The final code with the three servos, but discovered that three-servos does not work for the robot because the third servo stops working immediately after being plugged. Tried to get the third servo to work by plugging directly into the arduino rather than the breadboard

All of the servos plugged into the breadboard. 

IMG_5046 

head moving

IMG_5047 

Servo on the back of the cloth. I moved the servo later because it did not really move the item. 

IMG_5053

My servo trying to move across the table, moved the bottom servo to a Popsicle stick on the bottom. I had to hold up the pombot because as aforementioned, it was still too top heavy. 

 

In conclusion, if I were to do this over again, I would make a shorter monster, one that I did not need to hold. I would also maybe use two Arduinos since three servos was too much to handle. 

Continue Reading

Arduino Pom Pom Bot

For this week’s project we had to create a locomotive robot out of common craft materials, servo motors, and an Arduino. My source of inspiration was a video that I saw earlier this week of a bearded dragon trying to run on a hardwood floor, which made me think about the ways that animals move and how it could be simulated. After doing some research, I came across an article about the bio-mechanics of different animals, including common reptiles.The motion of their legs can be simplified as two sets of feet connected on a bar basically that pivot back and forth opposite of each other.

I realized that this could be replicate pretty simply by using two servos, one for each set of feet, mounted at a slight angle so that as the feet pivot, only two feet are on the ground at a time. For my material of choice in making this I decided to go with plastic straws, because of their really high strength-to-weight ratio and how easy it is to glue them together.

I started by by mounting the servos by sandwiching them both between two straws that eventually formed the main body of the robot, with a small support piece in the middle to prevent the whole thing from buckling too much. The angle I chose for the motors was arbitrary and I thought I might have had to tweak it later on, but luckily it turned out to be perfect.

For the legs, I again used straws but it took some experimenting to get right. I first tried bending them into shape and then taping them to hold it in place, but after some testing I realized it was way too flimsy for the robot to stand on. I then tried using a high temperature hot glue gun to both soften the plastic and hold it in place, which turned out be extremely strong and stable, and I also used the hot glue to create little feet that could grip flat surfaces more reliably. To attach them to the servo mounts, I just ran a bead of hot glue along the straw and held it in place while it cooled.

For my second bot iteration, I decided to try to integrate a bit of intelligence by incorporating a sensor into the robot. Since I’ve used the ultrasonic sensors before I settled on trying to get the bot to avoid running into obstacles. While I was able to get the sensor calibrated and able to detect when the robot was going to run into a object, I haven’t yet figured out a way to reliably control the two motor system to steer the bot in a way other than going in a straight line. If I had more time I think I would experiment more with different motion patterns to see if it is actually possible.

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 (https://www.youtube.com/watch?v=DWSbFfW3lC4), 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.

 

Code

 

 

 

 

 

Continue Reading

Pom-bot

This week I decided to make a penguin pom bot. I used a plastic cup, felt, eyes, and pom-poms to create my penguin. At first I was confused about how I was going to build the penguin’s feet but I decided to use orange pom-poms to create the feet. I attached servo motors to both the feet to get the motors to start rotating and for the penguin to start waddling. I decided to create a penguin because I thought about how two motors would move if put on the legs of a pom-bot and it was intuitive that the motors would waddle like a penguin. In my code, I first had both the motors rotating the same amount but later I changed one to rotate and twice the position in the for loop to get it to walk forward. For my iteration, I made the pom-bot look like a girl and made the movement of the pom-bot faster. My motor had stopped working the second time I came to the lab, so I had to switch out the motor as well. I removed the motor and pulled out the wires of the motor going through the back of the penguin out from the bottom.

Here is a video of my pom-bot moving after my iteration:

Reflection

This was one of those assignments where I did not think too hard about how I was going to use the materials to make my penguin but had a vision and was flexible with using the materials and try new things with the materials. I was very confused about how I was going to make the feet but then I just used pom-poms. There were a few things available and I learned to make the best of them in this asssigment. I wanted to make a penguin because penguins are cute when they waddle and in my head, I could see the motors making the penguin waddle. Previously, I had a plain looking penguin but I wanted to look more like a fun, girly penguin so I enjoyed making it prettier. I also tend to have the idea in my head that if something is damaged, it can take a long time to repair it like with my motor but it was rather easy to replace and reattach the motor in retrospect, so even though it seemed hard and time-consuming in my head, in reality, it wasn’t as hard or time-consuming I learned to understand. This was my favorite assignment and I am quite proud of how my penguin turned out. I had some idea about how I was going to make the penguin move so when I saw it move for the first time, I was very happy. Maybe if I had more time, it would have been interesting to see how the movement would have been made to be different if I changed the positions of the motors.

/* Sweep
by BARRAGAN <http://barraganstudio.com>
This example code is in the public domain.

modified 8 Nov 2013
by Scott Fitzgerald
http://www.arduino.cc/en/Tutorial/Sweep
*/

#include <Servo.h>

Servo myservo; // create servo object to control a servo
Servo myservo1;
// twelve servo objects can be created on most boards

int pos = 0; // variable to store the servo position

void setup() {
myservo.attach(9); // attaches the servo on pin 9 to the servo object
myservo1.attach(10);
}

void loop() {
for (pos = 0; pos <= 180; pos += 1) { // goes from 0 degrees to 180 degrees
// in steps of 1 degree
myservo.write(pos);
if(pos<90)// tell servo to go to position in variable ‘pos’
myservo1.write(pos*2);
else
myservo1.write(180);
delay(10); // waits 15ms for the servo to reach the position
}
for (pos = 160; pos >= 70; pos -= 1) { // goes from 180 degrees to 0 degrees
myservo.write(pos);
if(pos<90)// tell servo to go to position in variable ‘pos’
myservo1.write(pos*2);
else
myservo1.write(180);
delay(10); // waits 15ms for the servo to reach the position
}
}

 

Continue Reading

Textile Adventures

I was a bit nervous to make a whole textile project for this week since the last time I touched a sewing machine was in 8th grade home economics class, but if 13-year-old me could do it, so can I!

The textiles assignment began with some preliminary tutorials on how to use a sewing machine. 

Early stitching practice

 

Once I got the hang of the machine, I worked towards making a drawstring bag:

tracing and cutting bag fabric

The completed bag!

I had to take a few hours outside of class to finish up, but it turned out well! Over the course of making these objects I began to learn that if I was working too hard on a particular task, there’s probably a better way to do it. This became particularly evident when I was struggling to get the ribbon through the bag.

Onto next week: Embroidery!

My girlfriend is a big fan of the esports team G2, so I had a go at making their logo:

Original G2 logo

I was a bit concerned as to how detailed the embroidery machine would get when it dealt with thin lines, so I instead based the pattern off of a modified logo I found off of google:

the alternate logo

the embroidery in progress: looking good!

finished version

I felt pretty good about the result of the logo, although I learned that there can be some imperfections that I need to watch out for, such as the left gray part of the logo having some empty space on the right side.

 

Onto the main event!

I wanted to make a stuffed animal for my girlfriend since she really appreciates them. I also had to include embroidery for the assignment, so I decided to use the G2 logo once again! I chose to go with the fox since she likes them, and the pre-approved design looked very cute. She’s not a fan of super-soft fabrics, so I went for a material that was still somewhat soft but also had a nice variety of colors for me to choose from. nobody wants a green fox!

Between a bad phone battery and a forgetful brain, I didn’t capture as many of the in-progress photos as I would have liked. Anyway, here’s the finished head of the fox:

front view of head

side view

I was quite amazed at how the inside-out technique of sewing allows for so many mistakes and imperfections to be hidden away. I decided to not include the whiskers due to how small they were. 

The embroidery for the project turned out well, although I made the mistake of trying to use the sparkly thread that seemed to be made of plastic. It repeatedly got loose from the machine and caused trouble, but I was able to get the logo finished anyway. I included a red maple leaf since my girlfriend is Canadian.

body components attached

the tail

I chose not to sew bends in the tail for the plushie since I didn’t want the tail to be attached to the body of the fox all the way around. 

attached!

The base of the body was meant to have a weighted pouch stuffed with beads, but it seemed that the fablab didn’t have those materials on hand, so I just sewed 4 layers of felt together and used that as the base instead. 

 

I felt nervous making the final stitches to attach to the body to the head, but it turned out well, and just in time for my trip to Michigan to give this fox to my girlfriend for our 3-year anniversary!

finished plushie in all its glory

 

Continue Reading

Pom-Pom Bots — Sean White

Hello everyone, for my project this week I wanted to try and make a four legged pompom bot using only two servos. Many robot designs for each leg use multiple servos to better control the position of the leg. I originally wanted to create a robot that would stand up and walk. I realized, however, that it would have been difficult to stabilize it. As a result, I went for a one that would stand on four legs and move. The two front legs would be attached to a servo and the two back legs would be attached to a servo.

This was my initial design:

When I initially was thinking about how to create this, I looked up only and saw someone did a similar four legged robot and showed a video of it moving. What I found out was that the key to making movement with only two servos was the angled base, so I tried to mimic this with the Popsicle sticks and attached the servos to them.

This initial design was simple in order to test out the mechanism and see if it works out correctly. What I found out was that the wooden pegs for legs did not offer enough traction to pull the robot forward. As a result, I added some foam on the ends of the feet in order to make it move better. I tested it out again, but there still was not enough force to move the robot.

This is what led me to figure out that the robot was too light. If I added some more weight to it, that would increase the friction of the foot with the ground and pull it forward. This is what led me to my Final Design:

The main changes I made to it were that I added the weight of the battery back and the screw to the front leg area. This allowed to create enough friction with the ground to pull it forward while keeping it in place when it move the servos back into position. I believe if I more evenly distributed the weight I could have made it move forward when it was moving the servos back into position as well, but I am happy with how it turned out. This is a video of it moving:

Adding weight through the second iteration was able to make it move. I didn’t really have an aesthetic design in mind when I was creating this, so I just ended up putting some of the puff balls and a bottle cap nears its front to make a head.

 

Overall, I had a lot of fun tinkering with the different aspects of the robot to get it to move.

Continue Reading