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

Posts Tagged ‘Section: Duncan’

Final Project, Justin Franklin

For the maker space final project, I knew sort of what I wanted to do. Earlier in the semester I had made a theremin like device, that used ultrasonic sensors to produce different pitches. I wanted to rework that idea into something that was a bit more useable by incorporating that functionality into a midi controller. I hadn’t really worked with MIDI on the hardware level, so there was a little bit to get acquainted with as far as soldering and designing a circuit and making sure the serial data was written properly.

The most challenging part about this project was the housing. I decided that I would learn to use pressfit boxes for my required learned skill. I hadn’t used them before so I didn’t realize what I was getting myself into here, and it turned out to be a surprisingly complex and time consuming thing. I really had to spend a lot of time re-thinking how I wanted to design this box, and take a lot of caution in my measuring and such. A simple box can be just that: simple. This box was customized and includes a shutter flex lid, middle wall and top lid, so there was a lot of modifications I did, as well as vectorizing the shapes for the sensors and usb jack to stick out of. I guess what I’m most proud of with this box is that it does have a nice ‘finished’ quality to it. I believe that most people probably wouldn’t know what it was, but would recognize that there are some strong and nicely crafted design choices, and it has an appealing aesthetic, even if it is kind of bizarre.

One of my original learning goals with this project was to create something that had ‘good craftsmanship’. This was hard to define, but to me that meant that I was going to force myself not to take any shortcuts or anything, but really sit down and try to make a piece of hardware as presentable as possible and also as functional and sturdy as possible. I pushed myself to achieve this in my project in different ways. With the box, I went through a prototype phase to understand how the shutterbox design worked. I then considered multiple ways of modifying the design in different ways to get the effects I wanted. I also spent a lot more time than I ever expected on making sure that everything was going to match and line up. As I said above, the box was an accomplishment in itself, and I feel like I made something satisfactory.

Another aspect was implementing a real MIDI jack. This to me makes the piece more of an actual functional piece of equipment. It’s not just an arduino project that can spit out MIDI over USB, but the fact that it is MIDI capable for physical electronic instruments adds an air of professionality to it. Something else with the circuit design That I did was abandon bread boards. Although the circuit was originally designed on a bread board, I transferred it to perf board. All of the connections are soldered as well. I had done some soldering before, but this really put my skills to the test. I’m happy with the end result, because again I feel like pushing this project past a breadboard phase and choosing to hardwire it gives it a more professional feel, or beyond just a DIY project.

My secondary learning goal with this project was to learn more about press fit boxes. I did learn a lot about them, and I think i’ve talked about them enough already, so I’ll spare whoever is reading this.

My final main learning goal with the project was to become better at implementing my ideas, and turning them into real world pieces. This is a bit hard to explain what this means, but to me this means something along the lines of: How can I get his “idea” nailed down, and turn it into a “thing”, and not just a thing that carries out the idea but a real finished product. For me, I have a lot of ideas, but many of them never actually go through the metamorphosis of becoming reality. Along the way, many things change, and sometimes you realize you have to compromise or something, and the ‘thing’ you make is sort of far away from the original idea. As someone who has been making art of different varieties for a number of years, i’ve become accustomed to ‘going with the flow’ and accepting these compromises, or using them as points of inspiration in themselves. With this project I wanted to take a more deterministic approach, to me meaning that I would pre-plan everything, and try to design each step , with no compromises or shortcuts, and maintain a consistent methodical and ‘contractor-like’ attitude rather than an ‘artist-type’ attitude.

Although this is the hardest learning goal to explain, I feel like it was important to me because as I progressed through the course, This idea of craftsmanship kept popping up. For example, a really great project for me was the textiles project. I spent a lot of time creating a plushie, and I’m extremely proud of what I made, but there were some parts that were rushed through. I know from experience that some things can be rushed through, because having a finished product is a lot more important in some cases, so I tend to just get things out fast, and focus on making it real, not perfect. The course in general has taught me that making stuff is fun, obviously, but what really pays off is iterating through different designs, or redoing parts that were not created very well, and honing into something that you can really be proud of.

I believe this course has really given me more confidence with making things in general. Before this course, I had known how some of these things worked, and had assumed they were within my grasp. Things like arduino I felt like I could learn when I got a round to it, But with this class, it just kind of throws you into the pool and you have to learn to start swimming. So now that I’ve dealt with these things, I feel like I really can tackle bigger projects, that I know I wouldn’t be thinking about If I hadn’t had my experience. I suppose I do consider myself a maker, and I think I’ve sort of always been one. I’ve loved creating and making things my entire life, but I didn’t realize what makerspace or being a maker meant before having took the class. To me, being a maker is about really striving to do your best to create the things you want to make, the best that you can make them and committing your ideas to reality. Many people might think of something and say, “yeah, but I could never do that”, and shrug it off. I feel like a maker is someone that would say, “Hey, I can do something like that, using this tool I learned about before” or “Maybe so and so knows something about this, and they can help me make something”. I think that’s the most important thing about the makerspace community is the idea that anybody can come in and make their thoughts a reality. Not only this, but it can also be fun and easier than you might’ve thought.


Continue Reading

Final Project – Charis Ryu


Question 1

I made a cat(pet) house for my final project. First, I made a comfortable bed that goes inside the house with a blanket and sewing machine. Then, I made the house with baltic birch wood and power tools (Neil helped me with the tools). 

The biggest challenge I faced was wood kerfing. I wanted to make round edges for the house, and in order to do that I had to make small cuts on the wood and bend the wood. It was not just a time consuming process, but also a very difficult process that required concentration and accurate calculations. First, I had to measure the outer and inner radius of the round corners and divide the difference by the depth of the cuts. Neil explained to me the measuring and calculation methods. We used autoCAD to calculate and create the prototype for the kerfing. After creating the cuts however, the wood would not bend as desired, so we had to create additional cuts in between the original cuts. I realized that there still could be errors like this even when we have calculated and done everything accurately. 

<prototyping on AutoCAD>

<wood kerfing>

Second challenging part about wood kerfing was bending the wood after creating cuts. It required a lot of patience. As the wood was kind of thick, I had to heat/steam it with an iron and wet cloth. However, after an hour of heating and slowly bending the wood, the wood broke as one cut was totally bent in while other cuts were not bending it and sharing the pressure. I later glued the broken parts together, however the whole process of bending was pretty stressful as I had to be careful and hold the iron and wood for a very long time.

What I am proud of is successfully kerfing the wood. Although it was my biggest challenge, it turned out great at the end. It was such an advanced method to try on my first time ever working with woods, but I am very proud of my effort and the outcome.


Question 2

My first learning goal was to successfully learn about the materials and the tools used in woodworking. I learned a lot about wood and tools through research and Neil’s explanations. I visited the wood shop to get a desirable wood material for building a cat house and learned that birch woods are cat friendly and also eco-friendly as birch tree grows fast so when the wood fell there is no disruption of biodiversity. Neil taught me general knowledge of woods such as the fillings on the wood board and grain direction. He also taught me the wood kerfing method and how it works (e.g., measuring the radius and creating cuts).

My second learning goal was to improve my sewing/textiles skills. It was challenging stitching through the thick blanket textile, so I had to use both auto and manual (to go slow and accurate) methods with the sewing machine. Also, I had to hand sew several parts of the bed such as the openings for the stuffing to go inside of. My sewing skills have improved overall as I have worked on several different projects involving sewing throughout this course.

My final learning goal was to apply and incorporate my creative design and usability ideas on an actual tangible object. I am pretty much satisfied with the design of the cat house as first, it has round edges for aesthetics and also safety, and second, it has good usability for the cats. I created two windows along with the door for the cats sneak through or put their hands through. Also, I wanted to make the cat house that could also be a good furniture in my house, so I made color choices that were modern (black and white) and not too fancy or noticeable.


Question 3

The most significant thing I have learned that is not technical was being deeply involved in and enjoying the entire process of making. I have participated partially in art-related or creative projects before such as prototyping for an app development project, but being responsible for the whole process was a very cool experience and practice for me. From making design decisions, planning and prototyping to making, completing, and presenting the process and the outcome to a group of people required a lot of time and effort, but I really enjoyed doing it. Owning it, I’d say, gave me a passion for making, design thinking, and sharing.


Question(s) 4

First of all, I became more passionate about exploring and trying out new areas of making. Throughout the course, I learned a lot of different topics such as sewing, woodworking, arduino, and 3D printing. The more techniques and methods I learned, the more I gained interest in makerspace. I think being a maker is being able to apply your knowledge and skills on your work and sharing with the community. By sharing with the community doesn’t necessarily mean giving or donating your skills or products, but can simply mean sharing your thoughts, creativity, and passion with other people. I felt like the staff members of the fablab are doing a good job at this. I would like to consider myself as a maker if I participate in creative activities more often, which I am definitely planning on doing so. I was inspired a lot by my classmates’ projects, and I want to try out new areas of making.



Continue Reading

Final Project

Question 1. Show us what you made for your final project. Include at least two in-process photos and two final photos (or videos!) of your final project. Include a couple sentences about what challenges you faced and what you are most proud of but do not write a full step-by-step report of what you did.

 Here’s a video of what I made:


I created a decoration piece for my final project. The shelves were made from 12”X24” plywood and the wooden engravings were made on a piece of natural wood. I hand-painted on the wooden carvings as well. When I was carving, I faced the challenge of making the carvings go from rough to smooth. I had to do a lot of sanding to make the engravings smooth. Chiseling was also hard because you could only do it in one direction mainly. The wood runs in one direction so when you chisel, it is very easy to remove parts you did not intend to. So sometimes it becomes a design decision as to what to do when you have chiseled a part you didn’t mean to. I spent a lot of labor doing chiseling and then sanding.


Building the wooden shelf turned out to be a bigger challenge than I had expected. First I had to assemble the parts. The shelf was kind of wobbly, so I decided to 3d-print brackets to make the shelf sturdy. I placed one bracket on the left side of the centre(horizontal) shelf and one on the same shelf on the right. This made the shelf rather sturdy. Gluing the back of the wooden shelf was also pretty challenging because the wooden shelf was rather large so I had to lay down the two back pieces of plywood and glue the shelf onto it flat.


Programming the neopixels was challenging yet fun. I started off with an Adafruit library that was using rainbow cycling colors, however the code for that was sending the colors in one cycle and that’s it. So I struggled to figure out what was wrong with my code, however could not tell what was causing the loop to not go infinitely. So I switched to a different library and changed the code there to make the colors go in a cycle only as there were other variations also happening to the neopixels in that code.


I am most proud of the project because I picked up a very new skill and made things work. I wasn’t scared to try something new and made my peace with the uncertainty that came with doing something new and uncomfortable, so I am most happy about that.




Question 2: What were your learning goals for your final project? Write at least one paragraph per learning goal about what you hoped to learn as you worked on this final project and what you actually learned. 


  • To learn wood work and to apply new techniques of wood work. My goal with this was to try working with hands mainly as I enjoy doing handicrafts. I had gone into this class hoping to learn to do stuff without too much use of machines, so I wanted to learn how to do work with hands. I definitely learned to use chisels to do hand work with chiseling. I really enjoyed it and was very focused as I did the work. Creating the wooden shelf was my favorite part of this project though. I decided last minute to use brackets to make the wooden shelf sturdy. I learned that we do need machines after all also to make the things we need to complete a project. In this case, I needed the 3d printer so that was a good learning experience. I love nature so I was glad I was working with wood. It was satisfying.


  • To create something of meaning to me and to use my creative license to combine my passion for lighting and togetherness. I wanted to use lights because I love lights. I think using my passion creatively was the best thing for me because it kept me invested in the project and kept me going. I was attaching meaning to my work and was happy.


  • To try picking up a new technique altogether for a large portion of my project so as to step out of my comfort zone and do something beyond what I know will be possible. This was definitely the best learning goal. I was able to step out of my comfort zone for sure and learned that I tend to be anxious because I am afraid I might not be able to carry out the tasks. However, once I get down to the work, the anxiety also begins to go away because I see myself making progress and I feel like I am able to do the task at hand. It’s the initial anxiety that is the biggest challenge, however with this project I have realized that planning and making yourself realize that the execution is happening can help alleviate anxiety.


  • To extend working with lights from the iteration project and to learn how to program the neopixels and try different kinds of techniques with programming neopixels. The initial code I borrowed from the tutorial did not work. I was unable to figure out why the cycle was happening only once for the code I had. However, I switched to a different library and saw the different ways the neopixels were being lit in that code. Finally, I changed that code to only give me the effect I wanted.


Question 3:After rereading your lab assignment write-ups, what is the most significant thing you have learned over the course of these assignments? This is not a question about tool learning, but rather a question about yourself as a learner.


I have become more comfortable with executing ideas. I have learned that I am capable of coming up with an idea and turning it into a solid project. I have also learned to plan before I make something. I have surprised myself with the fact that I enjoy working with the Arduino. I have always been intimidated by programming but I liked working with the Arduino a lot. I have developed my confidence as a maker as I feel capable of now coming up with an idea and executing the plan I have for it in my head. I have also learned that I am a slow learner and I learn best by doing. So practice is what gives me most confidence in myself.


Question(s) 4:Has this course spurred you to think about yourself differently? And/or future goals and interests in life? Do you consider yourself a maker? What does that mean to you now that it didn’t at the beginning of the semester? What does it mean to you to call yourself a maker (or not)? Who do you think should call themselves a maker? 


This course has made me think differently about myself in that it has made me come to terms with my anxiety for the sake of my future. I have realized that I can overcome my anxiety but for that I need to figure out what’s causing it to begin with. I think I have learned that I am scared of not being able to perfect a task and that’s what makes me anxious. For the future, I will try to use this knowledge to change my expectations from myself. After this class, I definitely consider myself a maker and it means that I can use different kinds of machinery and software and hand work to make something I want. At the beginning of the semester, I thought it was going to be like art and craft work to be a maker. However, I have learned that it’s something much more than that. To call yourself a maker, you have to be able to be daring enough to be creative, skillful with machinery, adept at software and most of all confident about your ideas. Someone who is unafraid of failing at executing their ideas can call himself or a herself a maker for sure.




 #include <FastLED.h>

#define LED_PIN     5
#define NUM_LEDS    59
#define BRIGHTNESS  64
#define LED_TYPE    WS2811


// This example shows several ways to set up and use ‘palettes’ of colors
// with FastLED.
// These compact palettes provide an easy way to re-colorize your
// animation on the fly, quickly, easily, and with low overhead.
// USING palettes is MUCH simpler in practice than in theory, so first just
// run this sketch, and watch the pretty lights as you then read through
// the code.  Although this sketch has eight (or more) different color schemes,
// the entire sketch compiles down to about 6.5K on AVR.
// FastLED provides a few pre-configured color palettes, and makes it
// extremely easy to make up your own color schemes with palettes.
// Some notes on the more abstract ‘theory and practice’ of
// FastLED compact palettes are at the bottom of this file.

CRGBPalette16 currentPalette;
TBlendType    currentBlending;

extern CRGBPalette16 myRedWhiteBluePalette;
extern const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM;

void setup() {
    delay( 3000 ); // power-up safety delay
    FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
    FastLED.setBrightness(  BRIGHTNESS );
    currentPalette = RainbowColors_p;
    currentBlending = LINEARBLEND;

void loop()
    static uint8_t startIndex = 0;
    startIndex = startIndex + 1; /* motion speed */
    FillLEDsFromPaletteColors( startIndex);;
    FastLED.delay(1000 / UPDATES_PER_SECOND);

void FillLEDsFromPaletteColors( uint8_t colorIndex)
    uint8_t brightness = 255;
    for( int i = 0; i < NUM_LEDS; i++) {
        leds[i] = ColorFromPalette( currentPalette, colorIndex, brightness, currentBlending);
        colorIndex += 3;

// There are several different palettes of colors demonstrated here.
// FastLED provides several ‘preset’ palettes: RainbowColors_p, RainbowStripeColors_p,
// OceanColors_p, CloudColors_p, LavaColors_p, ForestColors_p, and PartyColors_p.
// Additionally, you can manually define your own color palettes, or you can write
// code that creates color palettes on the fly.  All are shown here.

void ChangePalettePeriodically()
  //  uint8_t secondHand = (millis() / 1000) % 60;
  //  static uint8_t lastSecond = 99;
   // if( lastSecond != secondHand) {
     //   lastSecond = secondHand;
       // if( secondHand ==  0)  {
       currentPalette = RainbowColors_p;      //   currentBlending = LINEARBLEND; }
       // if( secondHand == 10)  { currentPalette = RainbowStripeColors_p;   currentBlending = NOBLEND;  }
       // if( secondHand == 15)  { currentPalette = RainbowStripeColors_p;   currentBlending = LINEARBLEND; }
       /* if( secondHand == 20)  { SetupPurpleAndGreenPalette();             currentBlending = LINEARBLEND; }
        if( secondHand == 25)  { SetupTotallyRandomPalette();              currentBlending = LINEARBLEND; }
        if( secondHand == 30)  { SetupBlackAndWhiteStripedPalette();       currentBlending = NOBLEND; }
        if( secondHand == 35)  { SetupBlackAndWhiteStripedPalette();       currentBlending = LINEARBLEND; }
        if( secondHand == 40)  { currentPalette = CloudColors_p;           currentBlending = LINEARBLEND; }
        if( secondHand == 45)  { currentPalette = PartyColors_p;           currentBlending = LINEARBLEND; }
        if( secondHand == 50)  { currentPalette = myRedWhiteBluePalette_p; currentBlending = NOBLEND;  }
        if( secondHand == 55)  { currentPalette = myRedWhiteBluePalette_p; currentBlending = LINEARBLEND; }

// This function fills the palette with totally random colors.
void SetupTotallyRandomPalette()
    for( int i = 0; i < 16; i++) {
        currentPalette[i] = CHSV( random8(), 255, random8());

// This function sets up a palette of black and white stripes,
// using code.  Since the palette is effectively an array of
// sixteen CRGB colors, the various fill_* functions can be used
// to set them up.
void SetupBlackAndWhiteStripedPalette()
    // ‘black out’ all 16 palette entries…
    fill_solid( currentPalette, 16, CRGB::Black);
    // and set every fourth one to white.
    currentPalette[0] = CRGB::White;
    currentPalette[4] = CRGB::White;
    currentPalette[8] = CRGB::White;
    currentPalette[12] = CRGB::White;

// This function sets up a palette of purple and green stripes.
void SetupPurpleAndGreenPalette()
    CRGB purple = CHSV( HUE_PURPLE, 255, 255);
    CRGB green  = CHSV( HUE_GREEN, 255, 255);
    CRGB black  = CRGB::Black;
    currentPalette = CRGBPalette16(
                                   green,  green,  black,  black,
                                   purple, purple, black,  black,
                                   green,  green,  black,  black,
                                   purple, purple, black,  black );

// This example shows how to set up a static color palette
// which is stored in PROGMEM (flash), which is almost always more
// plentiful than RAM.  A static PROGMEM palette like this
// takes up 64 bytes of flash.
const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM =
    CRGB::Gray, // ‘white’ is too bright compared to red and blue

// Additional notes on FastLED compact palettes:
// Normally, in computer graphics, the palette (or “color lookup table”)
// has 256 entries, each containing a specific 24-bit RGB color.  You can then
// index into the color palette using a simple 8-bit (one byte) value.
// A 256-entry color palette takes up 768 bytes of RAM, which on Arduino
// is quite possibly “too many” bytes.
// FastLED does offer traditional 256-element palettes, for setups that
// can afford the 768-byte cost in RAM.
// However, FastLED also offers a compact alternative.  FastLED offers
// palettes that store 16 distinct entries, but can be accessed AS IF
// they actually have 256 entries; this is accomplished by interpolating
// between the 16 explicit entries to create fifteen intermediate palette
// entries between each pair.
// So for example, if you set the first two explicit entries of a compact 
// palette to Green (0,255,0) and Blue (0,0,255), and then retrieved 
// the first sixteen entries from the virtual palette (of 256), you’d get
// Green, followed by a smooth gradient from green-to-blue, and then Blue.








Continue Reading

Iteration Project: Papercut Lightbox

For this iteration project, I wanted to redo my papercut lightbox from Assignment 3: Paper Circuits. The first project can be found here: 

The final product wasn’t too bad, but there were definitely some issues and snags I would’ve liked to have done better. Some of these included:

  • I originally attempted to put layers of styrofoam in between the layers, but even after laboring with a hot kitchen knife and the wrong kind of foam for an hour, the foam would simply crumble. Therefore I had to use pieces of cardboard instead.
  • There was no frame around the layers so you could see all of the inside, and it looked unfinished and messy. 
  • As the project was supposed to be focused on the paper circuits and LEDs, there were only three lights within the backdrop. The three LEDs showed through as discrete light points instead of the collective diffused ambience as I wanted them to be. 

Because I had these distinct points of improvement, I thought this project would be a good choice to iterate on. My improved plan was to create the lightbox with papercut layers as before, but with the right kind of foam, a wooden frame, and a string of lights around the backdrop border. 

I brought my proposal up to the instructors, and they gave me the helpful suggestions to use Arduino NeoPixels instead of fairy lights, and Duralar sheets to diffuse the light more than regular paper. Also since the previous type of foam I used was extremely difficult to cut and quickly crumbled, the instructors gave me foam core to use this time around. 

For the paper art, I chose to recreate the artwork of one of my favorite albums. This part took a lot of thinking through the layout of the art and breaking up the components into paper layers. After some time I managed to reduce everything to ten layers, which I then outlined in dark pen to better distinguish what to cut out. I got several sheets of plain white cardstock and added a .5 inch border around the image. To trace the art onto each sheet of cardstock, I came up with a makeshift tracing lightbox using my phone flashlight and my empty sock drawer lol.

The foam core ended up working perfectly; it was MUCH easier to cut, and the cuts were very clean. The thin bars were firm and easy to work with. I reinforced each layer with .5 x .5 inch squares on the corners and 3 inch bars along the sides, as seen on the right.




I cut each of the paper layers by hand using a thin box cutter; this part definitely took the longest time (an all-nighter!) and the most labor intensive. However after everything was cut out and finished, it worked out pretty well! The right image is the final product after assembling and gluing all the layers together. 

Next were the NeoPixels. I had never sautered before, so I got some help from my ECE roommate to show me how to use a sautering iron and solder. We successfully sautered the three wires to the end of the NeoPixel strip. However, when I wrote and uploaded the code to make the strip shine white to the Arduino, nothing happened. After talking to an instructor I found that it was because I had sautered the wires to the wrong end of the strip; apparently they were supposed to be joined at the DI end following the arrows, where I sautered them to the DO end. (Another great learning experience from this project.) After removing the old sauter and trying again, I finally got the NeoPixels to properly light up. 

Lastly, the wooden frame. Another instructor suggested the Box Maker site to me, where you simply input your desired dimensions and the site exports an SVG of the design for a press-fit box. I opened the SVG in good old Inkscape and, as I learned during the first week of class, I edited the layout to fit on a 15 x 30 inch wooden board and for the laser to cut straight through the wood. Uploading the file to the printer, cutting the pieces out, and assembling them was a quick process, and easily enough I had my frame. 


I finally had all of my parts, and it was pretty quick to setup everything up. I cut out a huge square for the front frame, and a small hole in the back panel to feed the Arduino wires through. I’m not really sure why the lights ended up being orange instead of white even though the code had values for white, but that wasn’t too much of an issue. 


I didn’t have a hammer to completely press the sides together, and plus it was 1 in the morning so I didn’t want to make too much noise doing so. So the box sides are a little loose in the pictures, but otherwise here’s my final product! 



Overall I’m pretty happy with how this turned out, considering how much work I put into it. Only nitpicky things I would fix are how gluing paper layers directly on top of each other, e.g. the lion and the man, makes certain pieces look darker which I wasn’t expecting. The sun in the top middle also is rather faint and not as pronounced as I would like it to be, so perhaps there’s a solution for that. Outside the scope of this project I would like to paint the frame white and keep it. 

Even though this project took a lot of work and time, because it was over something I really wanted to do, none of what I put in felt like a lot at all. I had a lot of fun doing this and see how much the iteration project improved from the original, and I also got to learn the new skill of sautering. 



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

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. 


// 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)
// 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));; // Send the updated pixel colors to the hardware.

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

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

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

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

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

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

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

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

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

pixels.setPixelColor(i, pixels.Color(250, 250, 0));; // Send the updated pixel colors to the hardware.

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

pixels.setPixelColor(i, pixels.Color(250, 250, 0));; // Send the updated pixel colors to the hardware.

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

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

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

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

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

pixels.setPixelColor(i, pixels.Color(100, 100, 0));; // 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));; // Send the updated pixel colors to the hardware.


pixels.setPixelColor(0, pixels.Color(0, 200, 0));
pixels.setPixelColor(1, pixels.Color(200, 200, 0));; // 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));; // 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));; // 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));; // 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));; // 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)));
}; // Update strip with new contents
delay(15); // Pause for a moment



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

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 – 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 justin franklin

arduino intro – Justin Franklin

Discrete pitch theremin

For this week’s assignment in the makerspace 490 class, we were introduced to arduinos and the arduino IDE. I have some experience programming, but not with arduinos. It was something that i’ve been meaning to get into, so I was definitely excited to get started working with them.

The first thing we did in class was get comfortable using the arduino IDE. We worked off of a program that caused an LED to blink on and off. Then we began changing the code to create an SOS signal. Then we attempted to control the light of the LED with a touch sensor. This was all very fun, and I was sort of surprised how simple it was.

I thought about what I could do for my project but I wasn’t sure for the longest time. I wanted to make a car alarm at first, but one of the requirements was to have multiple thresholds, and I couldn’t think of how to incorporate that. The sensor that came in my kit was an ultrasonic sensor, one that uses doppler to detect the distance of an object from the sensor. I thought it might make a good way to control sound just by waving your hand.

The Theremin is instrument that produces sound without the player touching it. It uses two antennas to detect the proximity of a players hand to the instrument, and changes pitch and volume accordingly.  Although very interesting, the theremin is a notably difficult instrument to play, due to its lack of discrete pitches. This means that as you move your hand you continuously sweep through the frequency spectrum, without ever locking onto a tuned note. The only way to stop on a note is to do so by ear, and playing a string of notes or a melody, is exponentially more difficult.

My idea was to use the ultrasonic sensor of the arduino to create a similar instrument to the theremin but one that utilized discrete pitch values, thus being easier to play, while maintaining the novelty of playing an instrument without actually touching it.


So, I decided to get to work and begin tinkering with this thing. I first attempted to do this on my macbook at home. To my dismay, it didn’t work. My macbook would not recognize the arduino was plugged into it. After some research I found that although there was a fix to this, it required a little too much for me to be comfortable with, so I decided to go to the fablab and use the computers there. Once there, I began looking for some code from others that where using the sensor. Luckily, there was a lot, and I decided to use some of it to test the supersonic sensor. From the code, I could see which pins were being sent to different parts of the sensor. I assembled the sensor accordingly. I then took a look through the code to see what was going on. I have a vague familiarity with the details of how doppler works, so i felt like I understood pretty much what was going on. I also grabbed a piezo speaker to use for sound output.

My first go at this just made a sustained beep noise that was very unpleasant, and I quickly unconnected the speaker. But I was actually pretty excited by that, because honestly just getting sound on my first try was sort of a milestone. Something wasn’t working quite right though. The sensor didn’t seem to be changing values at all. This problem took me a while to figure out until I realized I had placed my variables in the setup loop instead of the main loop. This meant that the sensor only polled one value at setup time, but never refreshed it. Once I moved the variables down to the correct place, things were looking nice. Then I just included a big IF ELSE statement that determines what to do if the object in front of the sensor is so many inches away from it. I made seven separate states, depending on distance of the object, each state corresponding to a different note of an A major scale. Unfortunately the tone() function of the arduino only takes integers for its frequency input value, so the tuning is not exact, because I had to round to the nearest integer. The difference is not very substantial.


  int trigPin = 11; // Trigger
int echoPin = 12; // Echo
long duration, cm, inches;
int piezoPin = 8;

void setup() {
  // put your setup code here, to run once:
Serial.begin (9600);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
duration = pulseIn(echoPin, HIGH);
inches = (duration/2) / 74; 


void loop() {
  // put your main code here, to run repeatedly:

digitalWrite(trigPin, LOW);
digitalWrite(trigPin, HIGH);
digitalWrite(trigPin, LOW);

duration = pulseIn(echoPin, HIGH);
inches = (duration/2) / 74; 


if(inches < 4){
tone(piezoPin, 440,100);
else if(inches<5){
tone(piezoPin, 494,100);
else if(inches<6){
else if(inches<7){
else if(inches<8){
else if(inches<9){
else if(inches<10){

tone(piezoPin, 0, 100);
//The ultrasound sensor code is by the Rui Santos
 created by Rui Santos,
After messing with this I’m actually considering moving the variables back to the setup loop, so that the user can refresh the arduino manually, and better control the playing of it. But that’s for another time heres some pics of the device.
I’m really surprised by how well it worked out. Usually with these types of things, it can take a while to debug your code and get things working. I did run into a few snags, but it only took some time to remedy them. As an instrument, It’s not super impressive. It makes a horrible beep at a consistent volume, and also produces it at a steady rhythm. In the future it would be better to make one that plays a sample of something more pleasant, and also have some form of rhythmic control of it, and maybe volume control as well. I had a lot of fun making this project.


Continue Reading

Scheduled Brightness Adjusting Lamp Prototype – Charis Ryu

For this assignment, I created a prototype of a touch lamp that has the functionality that allows the user to schedule and automatically adjust the brightness based on the current time, based on their lifestyle. For example, there is a user who studies everyday 6-9pm, reads book/get ready to go to bed 9-12am, and sleep 12-8am everyday. The user will want a study lamp while studying, a reading/bed lamp while reading book on the bed, and a night lamp while they sleep before the sun rises. This lamp I designed can adjust the brightness based on the time schedule set by the user, and when the user turns on the lamp with the touch sensor, the lamp will set the brightness based on the hour when the user turned it on. Then, when left on, the lamp will automatically change the brightness. Below is the low-fidelity prototype of a possible usability scenario I drew. 


The arduino set up I had for the assignment was basically the same as the touch sensor setting. For the code, I imported two libraries called Time Library and DS1307RTC Library to get the current time.

The basic logic of the code is to check the current time when the lamp is turned on, and if the time equals to a certain hour (ex. 4, 9, 14), set the brightness of the LED to a certain value.  Below is the code I wrote.


The aluminum foil worked as the touch switch for the lamp. The LED did not successfully follow the algorithm of the code however, and I tried to debug the code while making sure each part of Arduino was connected. Although I thought the code and hardware seemed simple enough, as it was my first time using Arduino, it was not a familiar process. Next time, I think I will make sure to give enough time for the debugging process. 



Continue Reading