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

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. 



REFLECTION

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
http://www.themakersworkbench.com.
*/

//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:
Serial.begin(9600);
FastLED.addLeds<NEOPIXEL, DATA_PIN>(leds, NUM_LEDS);
}

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);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
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(inches);
Serial.print(“in, “);
Serial.print(cm);
Serial.print(“cm”);
Serial.println();

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

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

delay(100);
}

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: http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
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;
}

ARDUINO ADAFRUIT CODE

// 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
#endif

// 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)
clock_prescale_set(clock_div_1);
#endif
// END of Trinket-specific code.

strip.begin(); // INITIALIZE NeoPixel strip object (REQUIRED)
strip.show(); // 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);

pulseWhite(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)
strip.show(); // 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)));
}
}

strip.show(); // 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)));
strip.show();
delay(wait);
}

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

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)));
}

strip.show();
delay(wait);

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)));
strip.show();
}
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)));
strip.show();
}
}

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

 

Continue Reading

Iteration Project– Joy Shi

For my iteration project, I decided to redo the first assignment, using the laser cutter to make a name tag. My original name tag was nice and simple, though a little small. For my iteration, I wanted to make my name out of acrylic as it makes the name tag look cooler than the plywood. I noticed that when rastoring on acrylic, the print is white and I wanted something with more of a color. My original idea was to use the Silhouette cutter to make a sticker that I would then place on top of the acrylic. While also looking for inspiration on Google, I came across someone using an LED light and coin battery to light up the acrylic. The effects of the light were really cool, and it seems simple enough for me to do. While proposing my idea to Maxx, she concluded that my idea was too simple. She suggested I instead use NeoPixel strips as the base and have the light shine up that would give the rastored acrylic some color instead of placing a sticker. After showing me a few examples that were in the FabLab, I decided that this was a much better idea than what I originally thought of doing.

Original Name Tag

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Since I already had a general idea of what I wanted to put on my name tag, the designing part of the name tag was relatively easy to do. Since I wanted this name tag to be more personalized than just having my name on it, I decided to add my Bitmoji with a coffee cup since coffee plays such an essential part in my life!

I decided to print out a prototype version of the name tag on plywood, just so I can see if I liked how the designed turned out and how big it was. Right when I was about to print, Maxx noticed that the name tag was a tad too big. After adjusting the size, I was ready to print it out! The final prototype turned out pretty nice and I really liked the size and design of it.

Sketch of the design

 

 

 

 

 

 

 

 

 

 

 

 

Prototype

 

 

 

 

 

 

 

 

I went back and made a few tweaks on the design since there was a bit of blank space on the prototype. After adjusting, I decided to laser cut my design onto acrylic. Halfway through the print, I realize that I forgot to adjust the size of the design!! So in the end, the design was slightly larger than I anticipated, but it was still really nice. 

 

 

 

 

 

 

 

 

After all that fiasco, I went to search for NeoPixel strips. Sadly the only NeoPixel strips they had didn’t have the wires soldered on. After a brief tutorial, I was soldering the wires onto the NeoPixel strips. The process was pretty cool and was really easy if my hands weren’t so shaky. With the wires connected to the NeoPixel strips, it was time to test it out. Since I’m not that good with coding for the Arduino, I just found a code on Google. With the code loaded and wires connected, I tested out the NeoPixel strips.

 

 

 

 

 

 

 

 

With the acrylic design ready, and NeoPixel strips working, it was time to determine how to make the stand I was going to put my acrylic on. Google had many ideas, from using a box to 3D printing to using the laser cutter. Since I was already using the laser cutter, it only seems reasonable to continue using the laser cutter. The design of the stand was relatively easy to format. Drawing out the stand on Inkscape was relatively easy since they were all rectangles cut into different shapes. I specifically was very careful when it came to the measurements of the slit for where I was going to place the acrylic. The lasering of the stand was also straight forward. However, when I attempted to put the acrylic into the slit I made, the acrylic wouldn’t fit!! I was slightly disappointed since I specifically paid attention to make sure that this wouldn’t happen:( Thankfully it was only slightly off, so I used some sandpaper to remove the excess part. Surprisingly this took a while since the pieces were small, and I didn’t want to break it. After finally being able to have all the pieces fit through the slit, I worked on placing the NeoPixel strips. With the help of some double-sided tape, I placed the NeoPixel strips on the base of the stand. I then glued the top part of the stand with the acrylic on top of the NeoPixel strips.

Using sandpaper to make the acrylic fit:(

finally with all the slits lining up with the acrylic

In the end, I really liked how the whole project turned out, even though now it’s more like a nameplate than a name tag!!!

 

Code used:

https://forum.arduino.cc/index.php?topic=282769.0

 

Inspiration used for base: 

https://www.xstron.com/how-to-make-custom-dimension-wood-led-base-for-acrylic-plate

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.

 

 

Reflection

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 – Scott Kim

 

Iterating on the first Arduino project.

The project was something that could definitely work well in theory, but ran into a lot of issues and shortcomings that I didn’t initially expect. The original idea was to be able to type out words without the use of fingers or fine motor skills. It would be used in a way like this:

  1. Once the ultrasonic sensor detects your hand, it keeps measuring the distance. It uses this distance select a letter.
  2. Once the sensor detects a sudden change in the distance (in that, you moved your hand away from the sensing area), it would select and type the letter corresponding to the most recent letter.

 

But it had a lot of problems.

This seemed like a good idea in theory, but a lot of its shortcomings can be summarized through this:

(sorry for the dark video, the screen was just too bright in comparison)

Digging into what might be the problem for it being inconsistent, I printed out what the sensor measured as distance and got this:

Despite its errors, it did work well enough for a short demonstration and video for the assignment, but it really was nowhere near what I imagined. The whole thing needed a better frame to make the hardware more reliable, and an entire software rewrite to accommodate for the small errors. Even with that, I found some oversimplifications in my original description of the project.

So immediately, the distance measurements are unreliable. I saw three sources of this, and three solutions to them that I would try to implement first:

  1. When you’re really far out (the letter Z is ~50cm away from the sensor) you can’t really tell if the sensor is facing in your hand’s direction.
    • I need to make some solid frame that holds the sensor perpendicular to some ruler/surface
  2. “A sudden change in distance” is really vague and hard to quantify. Especially with an unreliable sensor like this.
    • Once I get the frame, have something at the end so I can tell exactly when a hand is/isn’t on the sensor path.
  3. “Hands” are oddly shaped and aren’t always detected too well.
    • Use a 90 degree reflector instead

 

First, making more reliable hardware

I knew that about 2cm per letter was a good amount of room where it doesn’t take too much space, but you also don’t have to be too precise. So, I started preparing a ~55cm long scaffold to hold the sensor and display. I created a cutting pattern for an open box using Boxes.py, and added a few more cutouts of my own for the sensor, screen, and wires.

The pieces at the top will make up the open box, while the 4 bottom pieces in the cut pattern will be used to solve problem #4 and create 90 degree reflectors.

Once cut, I started putting together the pieces!

 

My proudest part of this, really.

The ultrasonic sensor was a amazing fit, with 10/10 positioning of the wiring hole. I was honestly way too happy for just getting this one bit so perfectly 🙂


 

Downhill from there

The display might look like an almost perfect fit, but the cut hole was just barely too small because of a tiny part of it I didn’t account for. I amend this later.

The 90 degree reflector! I heard that using angled pieces like this more reliably reflect lights and sounds back to the source, so I thought it would help a lot.

I made the mistake of cutting a little too big a piece because I didn’t correctly tolerance it when measuring, cutting, and Pythagorean Theorem-ing.  

And then finally, it’s all coming together! Some last things to fix though.

 

Measure once, cut twice

Now as I mentioned before, the screen was not fitting perfectly, and the reflector was cut too big. I quickly fixed those issues.

The oversized reflector was marked, cut, then put back:

 

And then for the screen, this tiiiny part of the screen/wires were getting caught in the wood and would not let it fit.

 

And so, a bit of careful carving out the wood later, I managed to make some room. (There’s a pretty guilty-looking utility knife in the background)

After some hot gluing, taping, and writing the letters on the board as a guide, it came together pretty well! From a hardware perspective, it had everything to make the ultrasonic sensor as reliable as possible, addressing all 4 of the problems.

 

Actually writing good code this time

It was now time for the software rework.

After toying with the old version of the code, I saw several issues that I should address similarly:

 

Issue #1: No matter how reliable everything is, I’ll get the occasional outlier from the ultrasonic sensor.

The first method used the statistical mean of ~30 samples, but outliers affected that a lot.

Instead of using the mean, I now used median. That way, huge outliers won’t have any affect as long as they’re not the majority. 

 

Issue #2: As I move my hand away to “select” a letter, I might accidentally select an adjacent letter instead.

For example, say the user wants to select ‘h’ which is between 18cm and 20cm. The sensor might return series of numbers like this:

  • 19.3cm (h)
  • 18.8cm (h)
  • 19.1cm (h)
  • 21.2cm (i)
  • 57.8cm (hand completely moved away)

Once the sensor realizes the hand completely moved away, it needs to select the letter that was most present in the last few seconds (which is ‘h’), not just the most recent measurement (which would be ‘i’).

I solved this by keeping track of the ~7 most recent measurements, and then taking the median value once it realizes the hand moved away.

I set a delay at the end so that the user gets some moment to see that the letter they want has been selected.

 

Issue #3: There’s no good way to tell if you’re in the ‘border’ between two letters.

If you take a look at the past video or images, you can say it displays a “Distance”. This was meant to serve the above purpose, but it only really works for me because I know roughly where the letters are supposed to land. But even then, it’s not very useful because I don’t know the thresholds memorized of course.

I had all this screen space to work with, so I thought I could put a pretty intuitive indicator of how “centered” you are on the letter! It would work like this:

If you’re currently selected on the letter ‘c’, and perfectly centered, the display would show something like this:

  • b          c          d

Otherwise, if you’re selected on the letter ‘c’ but a little over to the left:

  • b   c                 d

Or if you’re a little over to the right:

  • b                 c   d

Hopefully that would indicate that you should move your hand a little over to the right to get a more precise selection of the letter ‘c’. 

 

And with that, we’re done!

I’ll let the video speak for itself 🙂

 

 

Most of the trial-and-error in this project was really in the programming. Seeing what seems like would intuitively or theoretically work, trying to make it work, and not being sure if my method is bad or if the program is buggy. There was one hour where everything was working fine, but it would inexplicably type “z” no matter what. I was completely sure I was writing the correct letter to the LCD, and then I realized I was just overwriting the correct letter with “z” just a couple milliseconds later because of a bad if statement 🙁

It was also a lot of tinkering with how many samples I should take for a reliable median, many samples I should “remember” for the selection, as well as how much space to give per letter. If these numbers were too big then the system felt sluggish, but too small would lead to more mistakes.

Then, there was the reorganizing and commenting everything, because holy moly the original code I wrote was awful.

When I saw how well it was working in the end, I was genuinely so happy with its consistency and reliability. The typing, the “Ready” notice, as well as the visual guide and feedback for each letter was all exactly how I imagined it to be. (Almost) everything fits together perfectly, and there’s so little about it that feels hacked together or improvised. I really can’t express just how “complete” this project feels, really having made no compromises in terms of quality, accuracy, or usability. 

One thing I considered was laser cutting the letters onto the board, but I thought it would be better to hand-write them on so that I can fiddle with the letter spacing and locations in the code. Next time though!

Continue Reading

Iteration project: Sean White

For my Iteration project I decided to iterate on the game I made with the LCD. I wanted to use a screen that offered more pixels and had an easier interface to work with in Arduino. The main issue with the LCD screen that I originally used was that there were very little pixels and everything was broken into blocks. With this new OLED screen I used, it was 128×64 pixels and it was all located on one area. The coding interface was also much easier since the ADAFRUIT libraries allowed for drawing bitmaps based on x and y coordinates. This made it much easier to code the moving blocks.

A few problems I ran into had to deal with, like last time, making it show the walls would spawn in a way where it was possible to avoid them. I spent a while trying to figure out all of the conditions for the walls, but in the end, I used the same method before which was brute forcing and checking the different options for when a wall spawned. Unfortunately, I wasn’t able to take a picture of this, but this is a image of what it looked like:

I had also originally had each box move 16 pixels at a time. However, the look of it was very choppy. As a result, I decided to increase the amount of times the screen refreshed since this OLED screen could handle a faster refresh rate. This allowed the look of the game to look much smoother compared to the original LCD.

In order to improve upon this, I decided to make a housing for it as well as use a joystick instead, since that is more intuitive to control. I also added a scoring system based on the total time the player survived, and I made it so every five seconds the walls would speed up a little bit. This made it more challenging to overtime.

I at first wanted to design this like an arcade system, but once I received the screen, I realized it was too small to make it something like that. Instead, I created a box using boxes.py in order to hold the arduino and I made cutouts for the screen and the joystick. Overall, I am happy with how it turned out, but If I were to redo it, I would probably make the case more ergonomic to hold. I would do this by using an arduino nano to make the overall form factor smaller and use smaller wires. I would also solder the wires together too.

This was the original lcd project:

This was the new improved project:

Continue Reading

Iteration Project

I decided to re-do the textile assignment for my iteration project. I made the plush owl for the first sewing project. However, I did not really understand how to sew. It was my first sewing project. I also discovered on this project that I did not understand that I needed to combine the different cutouts into one. Therefore, I embroidered a patch that ultimately never made it to my wallet. I received a lot of help from Maxx.the first assignment, with the plush owl.

I had cut out the fabric, but into several different pieces. I ended up having to place those items back and used a giant roll of the shiny, satiny green fabric. I got tripped up a lot on this wallet because I did not really understand the instructions. They were not as well written as the plush owl ones. 

I had to cut out the fabric twice. My first attempt was tripped up by the zipper. I cut the wallet part too much, although in hindsight, I am sure that this could have been salvaged. I just was panicked because I could not come in to finish the sewing until Thursday evening. 

I found the satin to be a much better fabric in terms of hiding how often I poked it with a needle and needed to pull the threads. For instance, when I was trying to put the entire wallet together, I had flipped the sides so that the zipper was on the outside instead of the inside and flipped. 

I do enjoy the sewing. I just need to remember that the template needs to be taped together before I cut the material. Also, I was missing the interfacing. I think it would have helped it not be as lopsided in the end, but I really think I did not a bad job.

Trying to get the folds right by using the template.

This section was the hardest. I had messed up the mountain folds three or four times and had to constantly pull the thread out. I got turned around and kept using the wrong sides to make the folds.

 I lost my contrast band when I sewed the item together. I managed to keep it when I temporarily hand-stitched it, but with the machine, I ended up sewing it all together. 

Temporarily hand-stitched to pIMG_5201 IMG_5199resent in class. 

IMG_5199

IMG_5201

Continue Reading

Iteration Project

Planning

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.

 

Construction

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.

 

 

Testing

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.

 

Reflection

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

Iteration Assignment

Designing/Thought Process

I knew I wanted to work on my laser nametag project because it was the project I had the most fun with and put most effort into. I also had a better idea than other projects on how to improve my laser name tag project, so I knew what to choose for my iteration project. My original nametag, I styled it into a GPU name tag using trace bitmap,and using draw lines effectively on inkscape. For my iteration project, I wanted a nametag that was actually 3D, instead of several wooden pieces glued together. I also wanted the several sides to each accurately portray the sides of a GPU. There would also be a red glow coming from the box in a pulsing effect, to reflect the name of my GPU, the Sapphire 5700xt “Pulse.”

The original name tag

Iteration Project Design Process

 

 

 

 

 

 

    

Third time was not the charm…

 

Failures making boxes

At first, what I tried doing was designing my own box following after learning how to make notches using a youtube video. Using the grid lines, and having the nodes attach to the corners automatically, it was rather simple to create the notches for the individual sides of the box. I foolishly thought this was all I needed to do in order for me to create a box. The first printed pieces however, seemed not to match, and some notches were going into the right place. At this point, all I thought was I must have put some notches in the wrong place as the box was not holding it self. I continued to make the same mistake of trying to fix the notches when the problem was that I was not thinking of the extra dimensions needed to the box to be assembled in the place. I repeated these procedures three times more before I realized I am stupid and asked Max for advice.

Improved Box

Max directed me to a box making tool online that I could then download as a svg file easily, which I could then edit on inkscape. Using the improved box, I made different vector images for different sides, and most importantly, instead of rastering my name like my original project, I chose to vector the name. I then put a red tissue paper behind the name so when a light shines through it, it will glow red.

Behind the name is a LED light using arduino circuits. It is using the code set called “pulse” that uses the delay function and a for loop so the light slowly increases intensity and decreases continuously.

Reflection.

Overall, I think there is much more I can improve with this project, if given more time. I could paint the whole wood black before lasering so it looks more realistically like a GPU, which I was in the process of doing before running out of time. I could also find a way to add mini fans to the case. The side designs of the box I could put more on inkscape to be improved. I think my overall idea was good and if given more time, I can find more ways to improve my design.

Continue Reading

Iteration assignment

For my iteration assignment, I decided to combine my name tag with lights to create a light box. My original name tag had a leaf at the centre of it to represent my love for nature and my name tag was in black and brown on an acrylic sheet. I wanted to add colors green and yellow to it so I decided to create a light box with lights in them with my initials and a leaf on top of the clear acrylic sheet as my name tag. The idea was to iterate on the original name tag to add color that was otherwise missing on the original name tag by using lights.

All of the sides of the box were in wood except the top which was in clear acrylic. I started out by creating a smaller box to test that it wouldn’t break under the pressure when put together. For that I got the prototypes from ‘boxes py’ for a small box.

The  wooden sides and acrylic top got put together nicely and so I decided to laser cut the bigger pieces too. I went on to the next step to build a circuit that would light up led’s on an Arduino. 

But I decided to replace these led’s with neopixels as I wanted to create dancing lights and give the lights nicer colors. I soldered the neopixel to jump wires and connected it to my Arduino board. I downloaded the neopixels library from Adafruit and played around with a few examples to get the pixels to light up in a way I wanted. I used green and yellow colors to represent nature. I added green cloth inside the box with some green, yellow and white feathers to represent more of the nature I wanted to portray in my light box. 

Finally I made the neopixels light up by connecting the Arduino board to the source. I initially was going to put the lights very close to the leaf but I realized later that acrylic can disperse light, so I put it lower than the surface of it. I changed the lights to go from one level of brightness to another consecutively and changed the colors from green to yellow one after the other. Here is a video of the light box with the dancing lights. 

On my second iteration, I changed the code further to include different effects on the lights. I added a fast flicker, a simple plain light up without any effects, all in green and yellow and a rainbow effect to include more color. 

CODE

// When setting up the NeoPixel library, we tell it how many pixels,
// and which pin to use to send signals. Note that for older NeoPixel
// strips you might need to change the third parameter — see the
// strandtest example for more information on possible values.
Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

#define DELAYVAL 500 // Time (in milliseconds) to pause between pixels
Adafruit_NeoPixel strip(2, PIN, NEO_GRB + NEO_KHZ800);

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)
clock_prescale_set(clock_div_1);
#endif
// END of Trinket-specific code.

pixels.begin(); // INITIALIZE NeoPixel strip object (REQUIRED)
}

void loop() {
pixels.clear(); // Set all pixel colors to ‘off’

// The first NeoPixel in a strand is #0, second is 1, all the way up
// to the count of pixels minus one.
for(int i=0; i<NUMPIXELS; i++) { // For each pixel…

// pixels.Color() takes RGB values, from 0,0,0 up to 255,255,255
// Here we’re using a moderately bright green color:

pixels.setPixelColor(i, pixels.Color(0, 250, 0));

pixels.show(); // Send the updated pixel colors to the hardware.

delay(DELAYVAL); // Pause before next pass through loop

pixels.setPixelColor(i, pixels.Color(0, 200, 0));

pixels.show(); // Send the updated pixel colors to the hardware.

delay(DELAYVAL); // Pause before next pass through loop

pixels.setPixelColor(i, pixels.Color(0, 150, 0));

pixels.show(); // Send the updated pixel colors to the hardware.

delay(DELAYVAL); // Pause before next pass through loop

pixels.setPixelColor(i, pixels.Color(0, 100, 0));

pixels.show(); // Send the updated pixel colors to the hardware.

delay(DELAYVAL); // Pause before next pass through loop

pixels.setPixelColor(i, pixels.Color(0, 50, 0));

pixels.show(); // Send the updated pixel colors to the hardware.

delay(DELAYVAL); // Pause before next pass through loop

pixels.setPixelColor(i, pixels.Color(250, 250, 0));

pixels.show(); // Send the updated pixel colors to the hardware.

delay(DELAYVAL); // Pause before next pass through loop

pixels.setPixelColor(i, pixels.Color(250, 250, 0));

pixels.show(); // Send the updated pixel colors to the hardware.

delay(DELAYVAL); // Pause before next pass through loop

pixels.setPixelColor(i, pixels.Color(200, 200, 0));

pixels.show(); // Send the updated pixel colors to the hardware.

delay(DELAYVAL); // Pause before next pass through loop

pixels.setPixelColor(i, pixels.Color(150, 150, 0));

pixels.show(); // Send the updated pixel colors to the hardware.

delay(DELAYVAL); // Pause before next pass through loop

pixels.setPixelColor(i, pixels.Color(100, 100, 0));

pixels.show(); // Send the updated pixel colors to the hardware.

delay(DELAYVAL); // Pause before next pass through loop

}


for(int i = 0; i<50; i++){
pixels.setPixelColor(0, pixels.Color(0, 250, 0));
pixels.setPixelColor(1, pixels.Color(250, 250, 0));
pixels.show(); // Send the updated pixel colors to the hardware.

delay(50);

pixels.setPixelColor(0, pixels.Color(0, 200, 0));
pixels.setPixelColor(1, pixels.Color(200, 200, 0));
pixels.show(); // Send the updated pixel colors to the hardware.

delay(20); // Pause before next pass through loop

pixels.setPixelColor(0, pixels.Color(0, 150, 0));
pixels.setPixelColor(1, pixels.Color(150, 150, 0));
pixels.show(); // Send the updated pixel colors to the hardware.

delay(10); // Pause before next pass through loop

pixels.setPixelColor(0, pixels.Color(0, 100, 0));
pixels.setPixelColor(1, pixels.Color(100, 100, 0));
pixels.show(); // Send the updated pixel colors to the hardware.

delay(2); // Pause before next pass through loop

pixels.setPixelColor(0, pixels.Color(0, 50, 0));
pixels.setPixelColor(1, pixels.Color(50, 50, 0));
pixels.show(); // Send the updated pixel colors to the hardware.

delay(1); // Pause before next pass through loop
}

for(int i = 250; i>100; i–){
pixels.setPixelColor(0, pixels.Color(0, 255, 0));
pixels.setPixelColor(1, pixels.Color(255,255, 0));
pixels.show(); // Send the updated pixel colors to the hardware.

delay(50); // Pause before next pass through loop
}

for (long firstPixelHue = 0; firstPixelHue < 5 * 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):
int 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 single-argument hue variant. The result
// is passed through strip.gamma32() to provide ‘truer’ colors
// before assigning to each pixel:
strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(pixelHue)));
}
strip.show(); // Update strip with new contents
delay(15); // Pause for a moment
}


}

Reflection

I was inspired by appreciation for lights in general to make this project. Lighting has a way of changing my mood and it’s my favorite thing in the world. I love different kinds of lights. They are very good mood uplifters so based on some examples of students in the previous semesters, I decided to create a light box. I was excited about using led’s to light up my light box. There are some pitfalls to avoid in the project. The wires are sensitive and the box pieces should be checked to see if they can handle pressure. I was adjusting the position of my neo-pixel after putting green cloth on top of the Arduino when one of my jump wires broke inside my Arduino. So it is important to be very nifty with the wires as the neopixels are soldered to the jump wires and tugging too hard on them can break them. I care about this because I believe lights are beautiful. The natural sunlight is my favorite type of light and I love everything about nature. I wanted to add some color to my name tag as I wanted to make the name tag more representative of nature in all of its colors also. I still need to learn how to write better code to add even more effects to the lights. If I had more time, I would experiment with more examples from Adafruit. My goal was to get the box to light up and I feel satisfied that I was able to make the light box close to what I had expected. I wasn’t expecting the light to dispense from so far but acrylic could do that. I also didn’t expect to use neopixels but they were much better than the simple led’s. The big moment that moved my project forward was when I got the led’s to light up in a dancing way. I knew then my project was going to be a success. Learning to solder was also a lot of fun. Soldering requires precision and concentration. I really liked building the whole thing and combining different techniques to make it happen. I was a little doubtful about my ability to combine the different techniques but now I am hopeful for the final project that I will be able to think up something for that as well. 

 

 

Continue Reading

Arduino Pom-Bot

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

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

an example of a failed attempt

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

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

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

Continue Reading

Iteration

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