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

Iteration Assignment

For my iteration assignment I decided to revisit the arduino Input/Output project. Previously I had used a current sensor to measure the current through an LED to determine the right resistor needed for a particular brightness.

I had used these sensors in the past, so I wanted to try a project with a sensor I had never used before. One area I had been interested in was biometrics and I had seen some of the cheaper options for pulse or muscle sensors that were on the market and figured I could explore those. The sensor I chose was the MyoWare muscle sensor, my plan was to use it to create a sort of feedback mechanism to help combat stress by detecting if one was clenching their hands which can be a sign of stress. The feedback would be provided by a group of vibrating motors where a slight innervation of the muscle fibers would cause a “low” reading and activate a single motor, a medium innervation would activate two, and a strong innervation would activate all three. 

The setup was fairly straight forward, the sensor only has 3 pins to connect, Vcc, Gnd, and Signal. The sensor operates off of an analog signal so it can be tested with the example code included with the Arduino IDE.


No clench, numbers between ~450-460

Light clench numbers ~470-480

Medium clench, numbers ~490-500

Hard Clench, numbers read ~520-530

After I prototyped it on a breadboard, I decided to try and solder a protoboard together for it and also use an Arduino Micro in the hopes that I would get to actually make it a wearable device.


The first thing I noticed was that between applications of the sensors, the numbers had a tendency to change, so the sensor had to be calibrated before each use. Then after a few uses, the sensor’s ability to detect kept worsening. I bought a pack of 50 electrode pads and used nearly all of them placing and replacing the electrodes to try and get a reading. Eventually, the sensor stopped working and I had to halt all progress on the project.

Before that happened, I was able to at least get a video of the setup working as intended.


My reflection on this project was actually fairly frustrating. The sensitivity and erratic nature of the sensor meant I had a hard time getting very reproducible results. furthermore, the sensors seem to be very picky about where on the muscle bundles you place the sensor. I am hoping this is just due to the sensor being defective, however if I were to use biometrics again, I may need to use one of the more stable sensors such as the armband.

Failure aside, it was definitely good to have worked with a different kind of sensor that actually uses the sensing of muscle action potentials to control electronics. wearing the sensor around the lab or my workshop did kind of make me feel a slight bit bionic.

Continue Reading

iteration project – Justin Franklin

Iteration Project – Justin Franklin

In the makerspace class this week we were directed to go back and redo a project in a new way, or improve upon it somehow. I thought about this for a little while, because I didn’t know what I wanted to do at first. I decided to go back and revisit my patch cable holder that I had 3D designed and printed a few weeks earlier.

I began by returning the files I had made in TinkerCad. One thing that had been a problem for me, with my first iteration was that it was too rough and not symmetrical. Also, it was was very simple. Although, I had reasons for initially designing it this way, I wanted to return and fix the details to make it better. I also thought that attaching a light to it would make it good as well, and add a new dimension to it. I began by first recreating the original design and this time making it more visually appealing by making it symmetrical. I then added some supports for the prongs so that it was  overall sturdier.

I then had this idea to create clips in the back that clip onto edges of table or such. With my first version, I didn’t have anyway of connecting it to anything, and this had become a frustration. I tried attaching velcro tape to the back of it and velcroing it to he side of cabinets, but it never seemed to work. With the clips, I wouldn’t really have to worry about this, and I could freely clip it wherever. I decided to just make them very simple hoping they would kind of latch onto something rather than actually clip, cause I wasn’t sure how I was going to design that, with the material being somewhat brittle.

Once I had my refined desgin I sent into the MakerLab at the Gies Business College to print overnight and I could pick it up the next morning, check it out and attempt to reiterate on it, and see exactly what I would need to do about making the clips better. I felt pretty good at this stage and waited until the next day, when I recieved an email that it would be ready to pick up at 2pm. Upon arrival, I found that what had been printed was a reprint of my first version, not my new redesign. Apparently I had accidently uploaded the incorrect file for some reason, and I would have to try again, so I did. The second time, I arrived and it was not printed at all! The problem was that the project file kept failing everytime they had to print. They couldn’t tell me why. So I reuploaded the file to the printer and tried a third time. The third time, I went to pick it up and although it had printed this time, An employee was trying to remove the supports and had accidentally broke it. I was getting frustrated at this point, even though someone had mistakenly broken it, the print itself looked very weird. There were all sorts of gaps and weird defects. I had to have it printed one last time, and by this time it was already Thursday, the night before I had to present this project, and still had nothing done, because I had expected to have it printed much sooner in the week. Luckily, the last time it worked, and I rushed to the fablab to work out how to create a circuit with a button and light for my cable


Unfortunately, this print was also pretty bad, but at least all the pieces where there so I had to work with it. Also, I didn’t have time at this point to redo the clips or anything so I just went on to  the next thing, the light. I began by just making a very basic light circuit and lighting an LED, with a breadboard. I quickly learned that a single LED would not do the job. I asked, Emelie about it and she suggested neopixels. I wasn’t a fan of this Idea because I thought that introducing an arduino device, would make this unnecessarily complicated. Instead I wanted to do a small lightbulb, but since there were none at the fablab, I had to go the neopixel route. I began by tinkering with some of the code, and quickly stumbled across some test coed for neopixel strips. at first this wasn’t working at all. After talking to Brandon, I found that the code was fine, but the neopixel strips really needed to be soldered first to have a secure useable connection. 

This part was tricky, because although I had soldered before, I really didn’t have a ton of experience. Eventually I had to ask for some soldering tips, and learned a got a ton of great advice from Neil about it. Soon enough, after some effort, I managed to get everything soldered and my neopixels began to work. I had originally planned to use a coathanger as the bendable ‘post’ for my light, but I realized that the wires I had used were fairly sturdy by themselves. I also originally planned to use rubber tubing to cover them, but settled on a straw, and then wrapped electrical tape around them.

Below is the final product, which I was ultimately pretty pleased with. I didn’t get to work on this as much as I had wanted, because of the printing errors I kept running into, but I think I will continue to refine it. One thing I especially want to do, is incorporate clips with springs in them for better options when hanging it up onto something. I’m glad I got to work with more arduino stuff, even though I hadn’t planned to use any at first. I also learned much about soldering here, I feel more comfortable with that skill now.

Continue Reading

Christian Amato Iteration Assignment

For this assignment, I was inspired by Emilie’s idea that she was going to make a lit-up acrylic sign in layers using neo-pixels and a 3D base. I decided I wanted to go one step further and add an ultrasonic sensor to the front of the base to light up the sign based upon the distance away from you.



This was my nametag, to begin with, and from there I decided I wanted to display the information in sequence, with my hobbies at the front, my information in the middle and my name at the back. 



I also kept the same original bear, as that’s my favorite animal but I made it much larger, to approximately 4.5 inches to stay within the realm of the 3D printer base. 





This was the overall design I created through Tinkercad with my measurements to scale. 



But some of my measurements were not correct and were actually in millimeters instead of centimeters, which led me to have holes that were too small to hold the acrylic, and a cavity that was too narrow to house the ultrasonic sensor and the Arduino. 



As you can tell, the dimensions for the acrylic cut-outs were way too small which could have been a big problem if I had not had access to a Dremel to widen the holes.


Thankfully, even with scaling issues, the Neopixel cavity was still wide enough to house the pixels and the perfect length to carry four pixels without any hanging off the edges. This took 8.5 hours to print. 





At first, I decided that I wanted to drill out the holes for the Neopixels, but the drill bit and the plastic combination was making it extremely difficult to make consistent cuts without falling into a previous hole. 



I have used a Dremel in the past and really did not want to use it, but it was my only option at that point. The Dremel’s friction heated the plastic so hot that I was able to rip out the melted strands of plastic with the needle-nose pliers. It was arduous and honestly a huge waste of my time because it could have so easily been avoided with proper measurements 

By widening the holes for the acrylic, it also allowed for larger amounts of light to illuminate the acrylic pieces, which was overall a great thing. 



Next, I used a soldering iron and soldered the Neopixels in series. I thought it would be generally easy to do but soldering with such small contacts my first time took a ton of trial and error.


After a failed first attempt after wiring them from the wrong side of the arrow, Brandon generously helped me rewire from the front side. 




From that point, I wired up the ultrasonic sensor by drilling two holes in the front, along with the Neopixels and as you can see from the picture, the housing was very snug. 











This is how it looked without any illumination. 



I think it could have looked much cleaner without the hot glue, but it was necessary to keep it sturdy. 



Here is the video of the Neopixels in action without the ultrasonic sensor. I really thought this looked a lot better than the plain colors that I found on the ultrasonic sensor. 

Then, I also decided I wanted to use the Ultrasonic sensor to trigger the lights. 


I thought this project really used a culmination of all the skills I have developed over this course. I utilized the knowledge I had from the 3D printing unit to create a 3D model that would serve as the base for the entire project using Tinkercad. From there I expanded my knowledge of the Arduino and the code that would end up controlling the entire device. I used the laser cutter again, learned what Neopixels are and the practically unlimited potential for different use. I honed my soldering skills and understood the danger behind lead poisoning. I utilized the drill and the Dremel to cut the housing unit to larger specs. I think this project was great because it allowed me to really use a wide array of devices and in the end it actually functioned. 

What went well?

I think the fact that Adafruit has a large array of test codes for Neopixels aided in the overall aesthetic of the design. The coincidence that I was using white 3D printing plastic was also a huge surprise to see how the Neopixels lit up the honeycomb designs on the inside. I thought it really looked great at the end. I think the soldering took a lot of patience but was worth it when it worked on the second try. Brandon was very helpful in showing me how to properly solder, and talking about the importance of cleaning the solder tip to make the solder go down more smoothly. 

What could I have done differently?

I think the 3D printing of the base was the hardest part of the project. From the beginning, the dimensions were really not right, and it forced me to rip it apart and use a Dremel to try and accommodate the larger components. I got really lucky with the base cavities somehow being the exact right length for the Arduino and the Neopixels being the exact width to fit in the cavities. But as you can see the base is not flat at all. Its curved on all sides and I noticed this after only 10 minutes of printing. I should have put something that would stick all the plastic to the base of the forge so that it would have been nice and neat. My number one takeaway from this project is to measure twice and cut once. Because of this, I bought a digital caliper for use in my future projects!

Arduino Code-

// Turning NeoPixels on and off using a HC-SRO4 Ping Sensor


This sketch reads a HC-SR04 ultrasonic rangefinder and returns the

distance to the closest object in range. To do this, it sends a pulse

to the sensor to initiate a reading, then listens for a pulse

to return. The length of the returning pulse is proportional to

the distance of the object from the sensor.

The Arduino then takes this information and illuminates a strip of
NeoPixel’s based on the distance of the object from the sensor.

This code was developed partially from Ping))) code found in the public domain
written by David A. Mellis, and adapted to the HC-SRO4 by Tautvidas Sipavicius,
while other portions were written by Charles Gantt and Curtis Gauger from

//Tell the Arduino IDE to include the FastLED library
#include <FastLED.h>

//Setup the variables for the HC-SR04
const int trigPin = 8;
const int echoPin = 7;

//Setup the variables for the NeoPixel Strip
#define NUM_LEDS 12 // How many leds in your strip?
#define DATA_PIN 6 // What pin is the NeoPixel’s data line connected to?
CRGB leds[NUM_LEDS]; // Define the array of leds

void setup() {
// initialize serial communication:

void loop()
// establish variables for duration of the ping,
// and the distance result in inches and centimeters:
long duration, inches, cm;

// The sensor is triggered by a HIGH pulse of 10 or more microseconds.
// Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
pinMode(trigPin, OUTPUT);
digitalWrite(trigPin, LOW);
digitalWrite(trigPin, HIGH);
digitalWrite(trigPin, LOW);

// Read the signal from the sensor: a HIGH pulse whose
// duration is the time (in microseconds) from the sending
// of the ping to the reception of its echo off of an object.
pinMode(echoPin, INPUT);
duration = pulseIn(echoPin, HIGH);

// convert the time into a distance
inches = microsecondsToInches(duration);
cm = microsecondsToCentimeters(duration);

Serial.print(“in, “);

if (inches <= 20) {fill_solid( &(leds[0]), NUM_LEDS /*number of leds*/, CRGB::Blue); //{whitestrobe(30);;

else if (inches >= 21) {fill_solid( &(leds[0]), NUM_LEDS /*number of leds*/, CRGB::Black);;


long microsecondsToInches(long microseconds)
// According to Parallax’s datasheet for the PING))), there are
// 73.746 microseconds per inch (i.e. sound travels at 1130 feet per
// second). This gives the distance travelled by the ping, outbound
// and return, so we divide by 2 to get the distance of the obstacle.
// See:
return microseconds / 74 / 2;

long microsecondsToCentimeters(long microseconds)
// The speed of sound is 340 m/s or 29 microseconds per centimeter.
// The ping travels out and back, so to find the distance of the
// object we take half of the distance travelled.
return microseconds / 29 / 2;


// NeoPixel test program showing use of the WHITE channel for RGBW
// pixels only (won’t look correct on regular RGB NeoPixel strips).

#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h> // Required for 16 MHz Adafruit Trinket

// Which pin on the Arduino is connected to the NeoPixels?
// On a Trinket or Gemma we suggest changing this to 1:
#define LED_PIN 6

// How many NeoPixels are attached to the Arduino?
#define LED_COUNT 12

// NeoPixel brightness, 0 (min) to 255 (max)
#define BRIGHTNESS 50

// Declare our NeoPixel strip object:
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRBW + NEO_KHZ800);
// Argument 1 = Number of pixels in NeoPixel strip
// Argument 2 = Arduino pin number (most are valid)
// Argument 3 = Pixel type flags, add together as needed:
// NEO_KHZ800 800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
// NEO_KHZ400 400 KHz (classic ‘v1’ (not v2) FLORA pixels, WS2811 drivers)
// NEO_GRB Pixels are wired for GRB bitstream (most NeoPixel products)
// NEO_RGB Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
// NEO_RGBW Pixels are wired for RGBW bitstream (NeoPixel RGBW products)

void setup() {
// These lines are specifically to support the Adafruit Trinket 5V 16 MHz.
// Any other board, you can remove this part (but no harm leaving it):
#if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
// END of Trinket-specific code.

strip.begin(); // INITIALIZE NeoPixel strip object (REQUIRED); // Turn OFF all pixels ASAP
strip.setBrightness(50); // Set BRIGHTNESS to about 1/5 (max = 255)

void loop() {
// Fill along the length of the strip in various colors…
colorWipe(strip.Color(255, 0, 0) , 50); // Red
colorWipe(strip.Color( 0, 255, 0) , 50); // Green
colorWipe(strip.Color( 0, 0, 255) , 50); // Blue
colorWipe(strip.Color( 0, 0, 0, 255), 50); // True white (not RGB white)

whiteOverRainbow(75, 5);


rainbowFade2White(3, 3, 1);

// Fill strip pixels one after another with a color. Strip is NOT cleared
// first; anything there will be covered pixel by pixel. Pass in color
// (as a single ‘packed’ 32-bit value, which you can get by calling
// strip.Color(red, green, blue) as shown in the loop() function above),
// and a delay time (in milliseconds) between pixels.
void colorWipe(uint32_t color, int wait) {
for(int i=0; i<strip.numPixels(); i++) { // For each pixel in strip…
strip.setPixelColor(i, color); // Set pixel’s color (in RAM); // Update strip to match
delay(wait); // Pause for a moment

void whiteOverRainbow(int whiteSpeed, int whiteLength) {

if(whiteLength >= strip.numPixels()) whiteLength = strip.numPixels() – 1;

int head = whiteLength – 1;
int tail = 0;
int loops = 3;
int loopNum = 0;
uint32_t lastTime = millis();
uint32_t firstPixelHue = 0;

for(;;) { // Repeat forever (or until a ‘break’ or ‘return’)
for(int i=0; i<strip.numPixels(); i++) { // For each pixel in strip…
if(((i >= tail) && (i <= head)) || // If between head & tail…
((tail > head) && ((i >= tail) || (i <= head)))) {
strip.setPixelColor(i, strip.Color(0, 0, 0, 255)); // Set white
} else { // else set rainbow
int pixelHue = firstPixelHue + (i * 65536L / strip.numPixels());
strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(pixelHue)));
}; // Update strip with new contents
// There’s no delay here, it just runs full-tilt until the timer and
// counter combination below runs out.

firstPixelHue += 40; // Advance just a little along the color wheel

if((millis() – lastTime) > whiteSpeed) { // Time to update head/tail?
if(++head >= strip.numPixels()) { // Advance head, wrap around
head = 0;
if(++loopNum >= loops) return;
if(++tail >= strip.numPixels()) { // Advance tail, wrap around
tail = 0;
lastTime = millis(); // Save time of last movement

void pulseWhite(uint8_t wait) {
for(int j=0; j<256; j++) { // Ramp up from 0 to 255
// Fill entire strip with white at gamma-corrected brightness level ‘j’:
strip.fill(strip.Color(0, 0, 0, strip.gamma8(j)));;

for(int j=255; j>=0; j–) { // Ramp down from 255 to 0
strip.fill(strip.Color(0, 0, 0, strip.gamma8(j)));;

void rainbowFade2White(int wait, int rainbowLoops, int whiteLoops) {
int fadeVal=0, fadeMax=100;

// Hue of first pixel runs ‘rainbowLoops’ complete loops through the color
// wheel. Color wheel has a range of 65536 but it’s OK if we roll over, so
// just count from 0 to rainbowLoops*65536, using steps of 256 so we
// advance around the wheel at a decent clip.
for(uint32_t firstPixelHue = 0; firstPixelHue < rainbowLoops*65536;
firstPixelHue += 256) {

for(int i=0; i<strip.numPixels(); i++) { // For each pixel in strip…

// Offset pixel hue by an amount to make one full revolution of the
// color wheel (range of 65536) along the length of the strip
// (strip.numPixels() steps):
uint32_t pixelHue = firstPixelHue + (i * 65536L / strip.numPixels());

// strip.ColorHSV() can take 1 or 3 arguments: a hue (0 to 65535) or
// optionally add saturation and value (brightness) (each 0 to 255).
// Here we’re using just the three-argument variant, though the
// second value (saturation) is a constant 255.
strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(pixelHue, 255,
255 * fadeVal / fadeMax)));

if(firstPixelHue < 65536) { // First loop,
if(fadeVal < fadeMax) fadeVal++; // fade in
} else if(firstPixelHue >= ((rainbowLoops-1) * 65536)) { // Last loop,
if(fadeVal > 0) fadeVal–; // fade out
} else {
fadeVal = fadeMax; // Interim loop, make sure fade is at max

for(int k=0; k<whiteLoops; k++) {
for(int j=0; j<256; j++) { // Ramp up 0 to 255
// Fill entire strip with white at gamma-corrected brightness level ‘j’:
strip.fill(strip.Color(0, 0, 0, strip.gamma8(j)));;
delay(1000); // Pause 1 second
for(int j=255; j>=0; j–) { // Ramp down 255 to 0
strip.fill(strip.Color(0, 0, 0, strip.gamma8(j)));;

delay(500); // Pause 1/2 second


Continue Reading

Daniel Shin – Assignment 8: Iteration

For the iteration project, I decided to iterate upon the sculpture I made on the 3d printing session. Some difficulties I had with the 3d printing project was that it was difficult to salvage all the small details from a complicated object. Therefore, I decided to simplify the 3d printed object and combine it with other techniques such as laser cutting and LED lighting to improve the visuals of the final product.

The planning process included the basic idea of how each part was going to be put together to function as one. Also, I had to put effort into getting the sizes of the parts right since the 3d printed objects had to fit perfectly with the laser cut objects.

While I was still in the workshop, I made the template for the box according to the planned sizes within Inkscape and laser cut them.


Once I got home, I focused on getting all the digital works done so I can finish all the works once I get back to the workshop. I used the 3d model I created on my previous project and made it much more simple. For the front design of the box, I found an image of a horn from the internet and combined that with a design of a helmet and patterns that I drew it myself on photoshop. Once I was done with the design, I imported into Inkscape so it was ready for laser cutting.

The first thing I did when I got back to the workshop was to start running the 3d printing and the laser cutting process. All processes went smoothly without an issue, so I was able to focus on the LED building right away.

While I was scavenging the workshop to find a battery, I found this battery holder that comes with a switch and cables. I was wondering how I was going to make the switch, copper tape circuit, and a battery holder before I found this. Discovering this solved everything, and all I had to do was connect the cables with the LED, and it worked perfectly.

Once the 3D printing was done, I sanded the outcome and glued the parts together. I didn’t have to color the sculpture because the sculpture was going to function as a silhouette. Then I placed the sculpture within the box and glued the box together.

I made three more patterns of the horn design to add more visual aspects to the box. Once I glued them to the box, I was done with the project.

This is how it looks in the dark.




Overall, I didn’t face many difficulties throughout this project. I was comfortable using all the tools I used in the process, and the thorough planning made the process easy. The only problem I was worried about was getting the electric circuit working for the LED, but it was resolved easier than I expected, thanks to finding the battery holder I used. If I were to do this project again, I would probably make the whole thing slightly larger.

Continue Reading

Iteration Project


I decided to iterate my pombot from last week. I had made a skiing robot that pushed itself along on fork ski poles:

My plan for iteration had two parts. First, I wanted to add an ultrasonic sensor. The whole point of the robot is locomotion, which it can’t do if there is a wall in the way. So, I wanted to add a sensor and code to make it turn when it got close to a wall. My other objective was to make it look nicer, since part of the project was that the robot should look like the motion its emulating. For this I planned to give it a little skiing outfit with coat and hat:


Adding Sensors

I started by working to add the sensor. It was easy enough to write the code, harder to debug. Initially, I had some trouble getting anything except 0 from the ultrasonic. After adding print statements and rearranging, I figured out that it was a bad wire. Once I got it to read values, I had to get the bot to turn. My initial plan was to have only one arm rotate when the ultrasonic measured below a threshold. However, testing this on the original bot showed I needed to rethink a little:


It seemed like one arm wasn’t enough force to move the whole thing, so I changed the code to have the arms swing in opposite directions. This worked much better.



I worked off the same cup as the original, but made several changes. Most significantly, I changed out the forks because the original ones had random bits of wood on the bottom to make them taller. I also inverted the way the forks faced because it felt more stable that way.

I moved on to making the skiing outfit. I added a coat made of construction paper and a scarf made of fabric. Since the ultrasonic sensor already kind of looks like goggles, I put them in place of the eyes. Lastly, I made a little hat out of fabric. I didn’t attach the hat permanently because it got in the way when I needed to trace wires, so I didn’t want it to interfere until it worked. During this process, I also rearranged where the wires came out in the hope that they would pull back less. While thinking about the wires, I decided to make a sled, hoping that it could contain all the wiring that doesn’t fit in the cup.




Once everything was finalized, I did a bit more testing to see if my aesthetic changes affected how it worked. For better or for worse, the answer was no. My rewiring and sled didn’t fix the fact that the heavy electronic pull on the bot and stunt it’s progress quite a bit. This is why I’m holding the sled above the ground in the video. On the other hand, it still works even with new forks in a new direction, so at least it didn’t get worse. While testing, I was a bit frustrated trying to keep everything lined up correctly and sitting the right distance from the computer. Since I had a battery pack from a different arduino project, I disconnected from the computer and powered it with that. This had the disadvantage of making the electronics heavier but the advantage that it doesn’t need a computer to run.



At the end, I’m happy with my iteration. I think it moves just as well as the original but looks nicer and has more complexity. It was fun messing with the sensors and constructing the decorations, which were both things I thought about doing in the original project but didn’t have time to. I’m still a bit disappointed that the electronics present such a big barrier to it’s movement, but perhaps that can be worked on in the next iteration.

Continue Reading

Iteration Project – iPad Pouch/Clutch

 I created a pouch for my iPad and other belongings for the iteration assignment. 


For the previous sewing/textile assignment, I made a tiny box pouch. The reason I decided this assignment for the iteration is because I found the making process very enjoyable and wanted to make a different type of object with different textile, and also because I wanted to improve the overall quality of the product, especially focusing on the quality of the embroidery.


This is the box pouch I made for the previous assignment. It is very cute, however the biggest mistake I made was the position and the quality of the embroidery. Also, I used cotton fabric for this pouch, which made it hard for the pouch to maintain its shape. Thus, I focused on two big things for the iteration project: (1) embroidery, (2) fabric.

This is the initial prototype I created for this assignment. I wanted have an embroidery in the middle of the pouch, and have an inner pocket for my belongings.

I used the felt fabric for my electronic device as it wasn’t stretchy and also it is widely used for making big pouches/clutches. After selecting the color of felt fabric I planned on using, I measured and cut all the pieces I needed. Then, I moved on to designing the suitable embroidery for the pouch, and since I chose red as the color of my pouch, it was not easy to come up with the right color scheme for the embroidery. 

I first thought of doing red & pink combination, which I’ve always thought was pretty cute. I designed 4 pixelized hearts with different shades of pink. I embroidered a piece of felt fabric with the hearts, however, I did not like the outcome. 



First of all, the hearts were so tiny. Also, the shades of pink were too light and undistinguishable. So, I just started over and created a new design. I still liked doing a heart shape embroidery, so I thought about what heart design I would want on my pouch. I’ve been a huge fan of oldschool, traditional designs/illustration/tattoos, so I found an image of a traditional heart design. With Inkscape, I changed the colors of each section of the design with the colors that I wanted. I was satisfied with the new embroidery design as well as the outcome after an hour of the embroidery process. 



Next steps were just sewing all the pieces together. I wanted an inner pocket as I designed in the initial prototype, so I sewed in the pocket first to an inside piece. One thing I realized while sewing was that sewing a larger objects was more difficult than small pieces like the box pouch I made. I tried my best not to make mistakes and to sew as straight as possible. 


Below is the video of the entire process. 








Continue Reading


For my iteration project, I decided to improve my final design from our 3-D printing assignment. The design was a bathroom organizer for my friend and I. Since I did not have a large budget, I cut the project short. It was not scaled the way I wanted it to be, nor was it sturdy enough because of the low fill. I realized the organizer could have more features than I previously thought. The second time around, I cleaned the overall shape and added more features. Here is the original design for reference.

I improved my skills on Tinkercad and Meshmixer, and I wanted to put them to the test. Using only the 3-D printer seemed lackluster, especially since it made prints all with one color. I usually cannot stay in class long enough for a print to finish, so I could not change filament to add colors. The next step was to decorate the organizer. I planned on using vinyl stickers for color, but since it would be exposed to water in the bathroom, I had to be careful. Vinyl made cleaner cuts than paint and the different colors stood out.

The print was done using black filament and it turned out better than the previous one in white. Unfortunately, the file was too big for one print. After printing two separate pieces, I hot glued the halves back together. The soap dispenser base was removed to show our names more clearly.

I took vinyl cuts from older projects and placed them around the organizer. Then, I made specific cuts for our names and the heart. First, I removed all the shapes that were not getting a sticker covering. Then, I brought the shapes down on the plane and exported them as an .svg file. I chose the color orange on top of black since it was bold and aesthetically pleasing.

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


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:


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
This example code is in the public domain.

modified 8 Nov 2013
by Scott Fitzgerald

#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

void loop() {
for (pos = 0; pos <= 180; pos += 1) { // goes from 0 degrees to 180 degrees
// in steps of 1 degree
if(pos<90)// tell servo to go to position in variable ‘pos’
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
if(pos<90)// tell servo to go to position in variable ‘pos’
delay(10); // waits 15ms for the servo to reach the position


Continue Reading

Arduino Intro

For my Arduino Introduction project, I decided to create an alarm that will tell me when to turn on the heater in my house. My house is weird in that the coldest room in the house is the bathroom, rather than the living room which has the windows and is closest to the door. This creates a weird dilemma for me, as I do not know whether to turn on the heater or put an extra layer of clothes on. This device will let me know when it is too cold and it is time for me to turn the heater on. Below is the storyboard for my idea.

For this to work I went with a speaker and a KY-028 temperature sensor module. Since I am not using the analog aspect of the module, I did not connect any power line for the analog to the arduino board. I found a tutorial online for connecting the KY-028 temperature module and what it can actually do. The tutorial also gave me the code for a different project than turns on a led if the temperature is too high, and turns the led off if temperature is normal. The Code is shown below.

int led = 13; // define the LED pin
int digitalPin = 2; // KY-028 digital interface
int analogPin = A0; // KY-028 analog interface
int digitalVal; // digital readings
int analogVal; //analog readings

void setup()
  pinMode(led, OUTPUT);
  pinMode(digitalPin, INPUT);
  //pinMode(analogPin, OUTPUT);
void loop()
  // Read the digital interface
  digitalVal = digitalRead(digitalPin); 
  if(digitalVal == HIGH) // if temperature threshold reached
    digitalWrite(led, HIGH); // turn ON Arduino's LED
    digitalWrite(led, LOW); // turn OFF Arduino's LED

  // Read the analog interface
  analogVal = analogRead(analogPin); 
  Serial.println(analogVal); // print analog value to serial


Above is a picture of the serial monitor to show that the code is working. For me to play a buzzer sound when the temperature is low, I added conditions and made it so instead of turning off the led, it makes a sound. The edited code is shown below.

int led = 13; // define the LED pin
int digitalPin = 2; // KY-028 digital interface
int analogPin = A0; // KY-028 analog interface
int digitalVal; // digital readings
int analogVal; //analog readings

void setup()
pinMode( 8, OUTPUT);
pinMode(led, OUTPUT);
pinMode(digitalPin, INPUT);
//pinMode(analogPin, OUTPUT);


void loop()
// Read the digital interface
digitalVal = digitalRead(digitalPin);
if(digitalVal == LOW) // if temperature threshold reached
tone( 8, 33, 500);//C1
noTone( 8);
analogVal = analogRead(analogPin);
Serial.println(analogVal); // print analog value to serial



Overall, this project was a lot of googling, and knowing what exactly I want to do beforehand. What materials I want to work with, what kind of devices I need, and what kind of conditional statements I will be using. I got baited by the fact that we are coding and how we were given a kit, so the project is all doable from home. I thought we did not need to borrow any devices, which proved to be wrong very quickly. If I had to redo this project, I think I would make it so the device plays music I like, instead of a buzz.

Below are the tutorial I used for the temperature module and the speaker.

KY-028 Digital Temperature Sensor Module

Continue Reading