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

Final Project– Joy Shi

For my final project, I decided to make a stained glass lamp. This is something completely new to me so I had no idea what I had in store for me. Before starting my project, I did a bit of research and watched some YouTube videos related to stained glass. In all honesty, it looked pretty easy. By the end of my project, I can confidently say that it was not easy.


There were definitely a lot of challenges that I faced while making this project. One of the challenges is having all the individual glass pieces to fit together. Since the pieces all come from a different color, it was hard to fit them together. There were some pieces too big while others were too small and left a gap. With this sizing issue, also made it hard to nail down the pieces when I was soldering.  However, later I started using tape to hold all the pieces together while I soldered. This became a very fast and efficient way for me to get the soldering done. Even with all these challenges, I was very happy with the finishing results. 

 

Learning goals for this project include learning stained glass, asking staff members for help, and keeping myself accountable by making deadlines to stay on top of the project. For the most part, I believe I did reach my goals.

I now have experience with cutting and soldering glass on. With more practice and time, I believe I could’ve made the individual glasses fit more nicely. Since all five sides were all the same design, it became easier and faster to solder everything together. If one were to analyze each side of the cube, there are definitely improvements from the first side I did. 

This project was definitely not possible without the help from Amrutha. Without her knowledge on stained glass, I would’ve been completely lost. As a completely beginner, I am very thankful that Amrutha was able to guide me and take time out of her day to come and help me with this project. With Amrutha around, we were able to conquer my challenges and both learn from it. 

I, however, underestimated the time each part was going to take so my deadlines were not always met. In the end, I did keep myself accountable and didn’t rush through this project. My deadlines became more of a checklist for me where I set goals of what I wanted to get done each time I went to the FabLab. 

This class has taught me a lot about myself. I personally likes to solve problems on my own. In a way, this class has forced me to ask for help when I am stuck. It made me realize that stuff can get done a lot faster when someone who knows what they are doing is helping you. I also realize that making things requires a lot of time and patience. I struggled with this in the beginning of the semester because I didn’t manage my time well and a lot of times had to rush towards the end. This is also why I made one of my learning goals to meet deadlines. Having set days to get things done has definitely help keep some stress away. 

I do not consider myself as a creative person at all, so I definitely struggled with some of the projects for this class. Even though my projects were never above and beyond but rather very simple, I liked learning about the process behind each project. I think a maker does not necessarily have to be creative, but someone who creates something physically or digitally. By taking this class, I have become more interested in physically making things. The programs and machines that we have learned throughout the semester has made me more interested and hopefully I will create make more projects in the future. 

Continue Reading

Daniel Shin – Final Project

Final Project

For my final project, I decided to design a stylized room in 3D using a program called Blender. Then, I recreated the room in real life using most of the tools I have learned to use in this course.

First, I made these two 3D models. The first one represents what each object is going to be made of (green means textile, blue means 3D printed, red means wood, yellow means other). The second image is a render of the room, showing what the room is going to look like in real life.

Throughout the process, I encountered so many challenges. To name a few, learning to use the resin printer, coloring the 3D printed objects, and making the tablecloth. Using the resin printer was much more complicated than I expected, so I needed to get the help of the instructors. Coloring the 3D printed objects didn’t go so well. I tried using all types of paints, such as acrylic paint, spray paint, and manicures, but the result was not satisfying. The miniature tablecloth didn’t work as a regular tablecloth because there wasn’t enough weight to keep the edges down. I had to trim the sides to solve this problem.

This was the completed version of my final product. (I recolored the golf course again to clean up the color and placed a smartphone on the window to display a scene at a later time. However, I didn’t take a photo because I wasn’t able to find a plant to display on the flower pot because of the changed weather condition.)

 

Learning goals

One of my goals was to learn how to use the resin printer. Creating a 3D model was not difficult because I was used to making them. However, transferring the model to a specific program to convert the model for 3D print-ready file was complicated, and I needed help from the instructor. Preparing to use the resin printer and cleaning up afterward was also extremely complicated for me as it was like treating a biohazardous material. Thanks to the help I got, the overall outcome was satisfying besides the small size of the product. 

Another learning goal was to make all sorts of materials to go along together to make one scene. In my project, I had to use 3D printed objects, wood, plastic, paper, LED light, and textiles all together to make one scene. Without any refining, all these materials weren’t going to go along very well. To solve this problem, I used several designs for the fabric, different methods of painting, and two separate types of 3D printing. Using the right method for the right objects in the scene improved how each object was in harmony within the scene while keeping each one unique. Although there were many difficulties in the process, the overall result looked great, and I felt like I met my learning goals.

 

Learned

The most significant thing I learned in this course is that working digitally and working in real life are two extremely different processes. I’m very comfortable working digitally and not so much in real life. Things I can do so easily digitally can be complicated in real life. For example, giving color to an object takes only a few clicks when using a program. However, when you want to give a color to a real object, it requires planning, picking the right method, processing, and waiting. I realized there is a massive gap between creating objects digitally and in real life. Decreasing this gap through the improvement of technology has become one of my interests.

 

Myself

Previous to taking this course, I thought I was a creator/maker even though I did not know anything about building objects in real life. I was so wrong. Creativity without knowledge of building is unrealistic. Knowledge of building without creativity is soulless. I realized true making could be achieved when you have both creativity and the knowledge of building. My plans for my designs were greatly influenced by the purpose of the product and the methods available. To be a maker, I need to know more than my interest, and I will keep this in mind when I continue to spread my creativity.

 

Continue Reading

Final Project

For my final project, I made a real life Minecraft Redstone simulator. It includes lamps, redstone torches, and various redstone path blocks. When placed in the board according to Minecraft’s rules, the torch can power the lamp using the redstone as wires. Overall, I think it turned out well. I’m especially happy that I was able to make it functional while also preserving the Minecraft look and logic.



While working on this, one of my recurring challenges was sizing. I wanted the blocks to have a snug fit into the board, but also easy to remove and put it. After lots of trial and error, the size I went with was the best I could do. It’s relatively easy to put pieces in and take them out, and usually the pieces are snug enough to make connections. Occasionally the pieces get stuck or don’t press up against the connections enough, but this iteration is far better than my previous attempts.

One of my other ongoing struggles was figuring out the best way to solder the wires to the copper tape. My first method was to solder onto the tape and then put the tape in the blocks. This made it easier to solder, put the tape kept ripping and I had to start over anyway. Eventually I started putting the tape down first and then soldering directly in each block. This had the positive effect that the tape ripped less, but occasionally the plastic blocks distorted a bit under the soldering iron’s heat. Luckily the effect on the plastic was minimal enough that I could keep using this method.


A block in progress: after soldering but before adding the LED and paint

Testing block connections in the board

One of my goals with this project was to resist solving a problem in the way I’m used to and look at it from a new perspective. When I work on projects for fun, I usually come up with solutions that feature programming heavily; any wiring is just a means to an end. That’s why I decided to work on a project that had no microcontroller, but lots of electronics.  It was quite interesting to see how some of my instincts when problem solving transferred nicely while others had to be ignored. For example, when debugging code I’m used to trying to isolate the source of the problem before fixing it. This was still effective when figuring out why a circuit wouldn’t work : I needed to figure out if it was a problem with the tape or the soldering or the board. However, once I found the error I had to change my mindset in order to fix it. With software there is always a hard, factual reason why the code isn’t doing what I want it to. With hardware, sometimes things just aren’t pressed together enough or a wire needs to be replaced. It was harder for me to figure out these errors that would pop up out of nowhere, but eventually I got better at adjusting my approach to fixing these problems. Working on a project in a different way than I normally do allowed me to both develop new skills and apply my skills in other places.

My second goal was to make at least one prototype for each component before moving on to the final piece. I was successful since I had 2 board prototypes and a number of block prototypes that I decided to change before the final product. This turned out to be very helpful in multiple ways. Obviously, it was helpful to learn from the mistakes I made while creating the prototype. I had several minor problems while using the laser cutter and while figuring out the size of pieces, and the prototypes gave me a chance to fail early so the final product looked better. I also found it was easier to foresee problems and work around them when I could hold the physical object. Being able to actually manipulate something similar to my project made the flaws clear in a way that tinkercad models and sketches couldn’t. I was also less afraid to try new things while testing my pieces since I knew it wouldn’t matter if a piece broke. Though some part of me still prefers to just jump to the final product, this has been a valuable experience in showing me the benefits of slowing down.

In order to learn a new skill, my final goal was to use soldering. The process seemed a bit intimidating at first, but I came to see that it was like using a hot glue gun, just a bit more complicated. I started practicing soldering by connecting wires before moving on to my actual project. Overall I’m glad to have learned a new skill, although the task grew a bit tedious at times. However, I was pleased to notice that it did get easier as I practiced more. I became better at figuring out the best way to place wires and the soldering iron to make a good connection, and each connection started to take less time. 

With all 3 of these goals, I noticed a common trend: they got easier to accomplish the more I did them. As I stated, approaching the problems from a new point of view was difficult at first. However, the possible problems I was with faced were glaringly obvious at the end of the project because I had spent so much time fixing them. Though prototyping instinctively felt counterproductive when I started the project. When I started making different types of blocks it became second nature to make a quick test block so I didn’t waste so much time. The first time I walked up to the soldering iron I was a bit frightened by the whole process, but the last time the whole process became natural. All I really needed to do to meet these goals was to give them a try, and it soon became no problem at all.

Reflecting back on this class as a whole, I find that this tendency for the start to be the hardest part isn’t unique to my final project. I have a tendency to shy away from hands-on work. One of the reasons I took this class is that I wanted to learn how to use these tools and I wanted something to force to do that interactive learning. Throughout this class I’ve found its gotten easier and easier to do these assignments and just start working with the tools. Much like the goals I set for myself in this final project, once I became familiar with the fab lab I felt better about using new tools and starting new projects.  

In fact, the ease with which I came up with ideas is probably the most surprising thing I’ve come away with. I’ve never considered myself a particularly creative person. However, with every assignment I had to juggle around several ideas before deciding on one.  I still have ideas for a whole bunch of projects I may or may not ever get to work on. I think these bursts of inspiration are partially due to how accessible all the tools are. I’ve never had easy and cheap access to a laser cutter before, so I didn’t really entertain ideas that would require the use of one. However, with my new knowledge where to find and how to use one, it’s quite easy for me to some up with ideas for new projects. 

This shift in how I view my own creativity leads me to see a similar shift in what it means to be a maker. Its not that I wasn’t creative or didn’t have ideas before, I just needed a different perspective to make those ideas come to light. Similarly, I think being a maker depends heavily on individual perspective. Every person who creates something is going to put a unique amount of effort, thought, time, and skill into what they create, and those measurements could vary wildly even for people working on the same project. This is combined with the experience and values which leads to each person’s opinion on what it takes to be a maker. The situation is similar to our discussion on what it means to be a gamer. There’s so many factors at play that there can be no clear cut answer. At the end it makes the most sense to say someone is a make if they say they’re a maker. Personally, I would say everyone in the class is a maker. Every week we come in go through the process of designing something, learning to use the tools, and fixing problems. To me that qualifies as making, but others may disagree.

 

Continue Reading

Final Project

  1. Video

  1. Challenges I faced – I wish that I found more of this blue acrylic. I looked in several stores to find blue translucent, but could not. And the fab lab had 1 sheet, which was not enough, so I had to use another color. Also, getting things to look neat (especially the glue underneath the acrylic and the burn marks in the wood).
  2. Most proud of – the way everything actually fits and is intended to be like that.  

2. Learning goals

      1. # 1: Become better versed at the laser cutter and wood to control what I’m making instead of just being satisfied with what the machine ends up doing to my piece, which happens more than I would like for it to.
        1. I achieved this, because I was able to control the sizing for the acrylic and make it fight just right between the wood. I also used the templates provided in the tutorial, but some of them were wrong, so I had to tweak it myself to my own size, especially for the size of wood I was using. I learned that the laser cutter is not actually as scary as I thought it was. In the first week of the class when we did laser cutter, I did not like it at all. All the settings were confusing and I didn’t know the difference between raster and vector, and setting up the file seemed confusing and like a lot of steps. But after this project, things seemed pretty streamlined and I enjoyed setting up my file because it gave me that sense of control and confidence I was looking for. 
      2. # 2: Apply my ‘need for perfection’ side to create an art piece. This piece requires all the parts fitting together and that’s what I’m most nervous about. I’m also challenging my time management skills.
        1. I also think I achieved this. I made a timeline for myself. I think the biggest thing that helped LOL was that that I accidentally thought that this was due on Tuesday in class, which was a whole week before it was actually due. So, I put in a lot of time last weekend and finished it. The best part was that once I cut all the pieces, putting them together was a nice little break in my day – it was peaceful and I enjoyed using my hands to create something pretty. And, the parts do fit together so I think that I did achieve this goal as well.

 

  • Most significant thing you have learned over the course of these assignments – I think I learned that I am impatient when it comes to creating, and have since gained patience. At the beginning of the course, if something didn’t work, I would just toss it and do something different (instead of troubleshooting and trying to work it out). I think that changed when we did Arduinos, mostly because I couldn’t just scrap it. I was forced to sit there and figure out why it wasn’t working and to eventually make it work. I am actually thankful to have picked this up because it’s a life skill that helps me to not give up so easily and try to work around problems creatively and logically. 

 

  • 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? 
    1. Yes, I am more confident in my abilities as a maker than I was before. I am more self sufficient and able to just google things and watch videos rather than asking for help at every step, which isn’t bad, but I feel less dependent that way. I don’t know if I consider myself a maker, but I definitely like working with my hands and using my creative side to create cute things that bring me happiness in life. 
    2. I think a maker is anyone who simply creates using their hands- using tools they have at their disposal and a guide – either the internet ot a tutorial or some sort of self learning tool. It’s that like raw, prototype, non-industrial creation that makes someone a maker. 
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.

 

CODE

 

 #include <FastLED.h>

#define LED_PIN     5
#define NUM_LEDS    59
#define BRIGHTNESS  64
#define LED_TYPE    WS2811
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];

#define UPDATES_PER_SECOND 100

// 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()
{
    ChangePalettePeriodically();
    
    static uint8_t startIndex = 0;
    startIndex = startIndex + 1; /* motion speed */
    
    FillLEDsFromPaletteColors( startIndex);
    
    FastLED.show();
    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::Red,
    CRGB::Gray, // ‘white’ is too bright compared to red and blue
    CRGB::Blue,
    CRGB::Black,
    
    CRGB::Red,
    CRGB::Gray,
    CRGB::Blue,
    CRGB::Black,
    
    CRGB::Red,
    CRGB::Red,
    CRGB::Gray,
    CRGB::Gray,
    CRGB::Blue,
    CRGB::Blue,
    CRGB::Black,
    CRGB::Black
};



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

Seth Sawant Iteration Assignment

This week’s assignment was to to either build upon a previous week’s project or to start it over from scratch. Because we’re soon starting the final project, I decided this would be the perfect opportunity to combine two projects into one to create a larger more and ambitious design. I also wanted to make something that was functional and something that I think that I think would hard to find commercially, so those things with in mind I brainstormed various ideas. The final project I settled on was creating a temperature display for my apartment, as one of the first pieces of information that I need in the morning is the outside temperature so I can dress accordingly. At the same time, I wanted this to be something I would want to display in my apartment, so the means of displaying the temperature will be a mechanical display similar to that of an odometer or a mechanical counter. For the iteration project portion of this, I tackled just the electronics aspect of the piece, namely the method of acquiring the temperature information and driving a motor based on that data, leaving the mechanical (and more complex) part for my final project.

The DHT22 temperature and humidity sensor I used.

For the backbone of this project, I decided to use Adafruit’s Feather HUZZAH micro controller, which is an Internet of Things focused device with built-in support for low energy Bluetooth, WiFi, and useful power-saving features built in. The chip can be programmed numerous ways; I started by trying to use MicroPython, but got frustrated by the unreliable programming method which involved connecting to the HUZZAH over WiFi and using a web-based terminal to update the code. Instead, I used the Arduino IDE which was less effort but required a little setup by installing some special board packages.

For acquiring the temperature data, I used two methods: one was to use a temperature sensor to get the ambient temperature of the room, and the second was to pull the weather data from the internet to get the outside temperature. The thinking behind this is that for my final design, I want the display to periodically switch between the inside and outside temperature to highlight  the ccool transition between digits that mechanical displays have. For the ambient temperature I used another piece of Adafruit kit, a DHT22 temperature and humidity sensor, which comes with an Arduino library which makes getting readings from the device easy. Although I didn’t use the humidity readings in this project, I’m thinking of adding the ability in the final project to alternate between showing the temperature and the humidity. To get the outside temperature from the internet, I used a weather API called OpenWeather which gives basic weather information for free, and used the Arduino HTTP library to send the API requests. Finally, to display the temperature data to the user I made a simple dial out of cardboard and a servo to act as a stand-in for the final, more complex display. Although the servo worked in this case, I realized that because servos can’t rotate more than one full rotation it probably won’t work for my final design; I’m considering other options like using a stepper motor or a regular DC motor, which can rotate indefinitely in one direction.

 

#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <ArduinoJson.h>
#include <Servo.h>
#include <Adafruit_Sensor.h>
#include <DHT.h>
#include <DHT_U.h>

#define WIFI_TIMEOUT 5

const char* ssid = "NETWORK_NAME";
const char* password = "NETWORK_PASSWORD";

HTTPClient http; //Declare an object of class HTTPClient

double outside_temp_k = 273.15;
double outside_temp_c = 0;
double outside_temp_f = 32;

double inside_temp_c = 0;

Servo dial;
DHT_Unified dht(14, DHT22);
sensor_t sensor;

void setup () {
dial.attach(2); //attach servo object to pin 2 of the Feather
dial.write(0);
dht.begin();
Serial.begin(115200);
WiFi.begin(ssid, password);

int timeout = 0;
Serial.print("Connecting");
while (WiFi.status() != WL_CONNECTED && timeout < WIFI_TIMEOUT) {
delay(1000);
Serial.print(".");
timeout++;
}
}

void loop() {
dht.temperature().getSensor(&sensor);
if (WiFi.status() == WL_CONNECTED) { //Check WiFi connection status
http.begin("http://api.openweathermap.org/data/2.5/weather?id=4887158&appid=API_KEY"); //Specify request destination
int httpCode = http.GET();
if (httpCode > 0) { //Check the returning code
String payload = http.getString(); //Get the request response payload
DynamicJsonDocument doc(1024);
DeserializationError error = deserializeJson(doc, payload);
if (!error) {
outside_temp_k = doc["main"]["temp"]; // gets the temperature in kelvin
outside_temp_c = outside_temp_k - 273.15; // convert to celcius
outside_temp_f = (outside_temp_c*1.8) + 32; // convert to fahrenheit
}
} else {Serial.println("Error contacting OpenWeather API!");}
http.end(); //Close connection
delay(2500);
} else {
Serial.println("No network connection!");
}

dial.write((int)outside_temp_f); //-20 to 120 to 0 to 180 range.

sensors_event_t event;
dht.temperature().getEvent(&event);
if (isnan(event.temperature)) {
Serial.println(F("Error reading temperature!"));
}
else {
if ((int)event.temperature != (int)inside_temp_c) {
inside_temp_c = event.temperature;
dial.write((int)inside_temp_c);
}
}

// ESP.deepSleep(2000000); connect GPIO pin 16 to RST for this to work
delay(500);

}

Continue Reading

Arduino Iteration Adventures

My iteration project was built as a stepping-stone from my newly-acquired Arduino skills to my final project. To do so, I built a box with a map of my local area on the front, and a number of LEDs that lit up at 13 different bus stop locations to indicate where certain buses where. 

before we dive into the process, here’s the final result:

The three lines near my house are green, gold, and silver, as pictured above. 

 

My previous project for Arduino was a strip of NeoPixel LEDs that could be controlled using a joystick:

Arduino Adventures

 

This iteration project began with a sketch of some ideas I was considering:

Option (A) was the one I decided to construct, with the integrated LEDs. Option (B) would have involved a sort of clock/timer with rotating servos to indicate approximately when the next bus would arrive. Options (C) and (D) involved using LCD screens, which were a little too advanced for what I was looking to work with for this project.

To design the front of the box, I found a site call snazzy maps that could modify the look of google maps to be whatever I wanted. So I took a screenshot of my local area with just the roads visible and converted it to an SVG for the engraving process. I then found a different online tool to construct the SVG files for my wood-engraved box.

The initial SVG for my local area

The final SVG for the front-facing part of my box, with holes designating bus stops

 

 

I was initially looking to use individual LED bulbs for each bus stop, but if I wanted to use a multicolor LED, I would have 4 pins on each bulb, and 13bulbs in total… so I decided to change my approach and use NeoPixels. Since I was primarily concerned with accuracy on the map for the bus stops, I hadn’t considered the troubles I might experience when attaching NeoPixels to the board. this resulted in a bit of a haphazard setup, with the NeoPixel strip contorted in order to line up each hole in the board:

 

I then went over to the Makerspace and learned how to solder! I tried looking at a few youtube tutorials to help me along, but it was still quite a time-consuming process. I asked Niel about how he goes about soldering, and he showed me a technique that involved applying solder to each component separately, and then bringing them together and heating to attach them securely. This made the process much easier, and I was able to successfully attach all of the neopixel strips together. In particular, I made sure that I had the data line all heading in the same direction to avoid trouble later down the line.

 

My first attempt at soldering NeoPixels

First set of LEDs attached, and they work!

The completed soldering job, with Clear tape in place to secure the pixels onto the board

 

Now that the LEDs were setup, I began programming the device! Since I would need to connect to the cuMTD servers to get bus data, I decided to use a Wifi-enabled Arduino. I then installed Postman onto my laptop so I could test my API calls to MTD, and then implemented them into the arduino code once I felt confident. 

 

I ran into some trouble when making API calls through the university wifi, as they likely have security measures in place. With that said, the project is working successfully at my apartment! Here’s the code I used, which utilized a mix of NeoPixels, HTTP requests, and WIFI connectivity code:

https://pastebin.com/SNyX4EuR 

Some issues that I was facing with the implementation is that random LEDs would light up for colors that I haven’t even programmed in, as seen here:

My best guess as to the source of this problem was due to power surges in the data signal for the LEDs. After getting access to a resistor and a capacitor, I was able to mitigate this issue. 

 

Here’s a video of the final product in action:

 

 

 

Continue Reading

Iteration Assignment

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

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

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

 

No clench, numbers between ~450-460

Light clench numbers ~470-480

Medium clench, numbers ~490-500

Hard Clench, numbers read ~520-530

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

 

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

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

 

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

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

Continue Reading

Iteration Assignment

Ideation: For this week, I wanted to improve my sewing skills because while I had a lot of fun during sewing week, I saw my technique had abundant room for improvement. So, I went back to the google drive folder of patterns and picked a plushie. I made bags last time, a drawstring one and one with a zipper (which was more difficult than the drawstring one). So, I decided to challenge myself and work with stretchier fabrics like felt and plush, which was a jump from working with pure cotton on the bags. The plushie also was more of a sewing challenge because it had a variety of strokes used (zigzag, straight, and basting). While I am not iterating the exact bags I made from that week, I am taking my sewing skills and techniques further by creating something more difficult and considerably different than last time. 

Images of previous project:

Construction: Unfortunately, I didn’t take many pictures of my build process, but I can describe the process in detail. I first cut out the pattern, and there were a lot of pieces. Then, I started sewing together the face. After that, I went ahead and put the sides and bottom together, which brought the squares to 3D. The places I had difficulty were the legs, because the fabric had to be squished a little to get lined up on both sides, so it came out a little frayed. 

Reflection: This project was actually fun to make. The hard part was understanding some of the directions actually, which the lab assistants helped to explain and show. Also the good part was that I didn’t have to start over on any of the pieces this time. I learned what y-seams, basting, and gathering / gathering stitches are. So, I feel like a more sophisticated sewer (not sure if that is the word for someone who sews yikes) than when I first began. Of course, my most favorite part was stuffing. The end result came out pretty good! I was impressed with my abilities and now I have a cute little plushie to put on my bed. 

Continue Reading

Iteration Project – Record Streamer – Isaac Iyengar

Intro:

The goal of this project was to extend my nametag project from the beginning of the semester. That project was a simple press-fit box with stained plywood, and a black acrylic hot glued on top. The black acrylic was cut and rastered to resemble a standard vinyl record. 

I started collecting records once I was gifted a record player from a friend, and it helped me explore a lot of old Jazz and Soul music and collect some of my favorite Hip-Hop albums as well. I like listening to music on my record player and even just seeing the motion of the record, however, I also use Spotify a lot, so I wanted to have a record player that would instead play Spotify.

I wanted to iterate on this project because I wanted to make a motorized version that would spin the record and also function as a music streaming box. The Raspberry Pi fits this specific use case. Essentially its a smart speaker in the form of a record player. 

Here’s a link to the original project: http://cucfablab.org/isaac-iyengar-nametag/

Rotating Record:

Unfortunately, the Raspberry Pi was not able to drive the DC motor on its own, so I used an Arduino instead which received bytes of data via serial indicating whether to spin the record or halt from the Raspberry Pi. I used a DC Motor following the circuit schematic shown below. The Arduino code would simply wait for signals to spin or stop spinning sent via Serial and write to the motor accordingly. 

 


Completed Circuit for DC Motor Control:

Music Streaming:

I explored using the Spotify Web API for this since it allowed for a lot of different functionality with the music such as receiving the current song playing, album art, and various playback functions. However, the Web API for my use case required authentication for every single API call, which is impossible to do in a headless setup of the Pi. Instead, I opted to use Raspotify which allows the Pi to function as a connectable device from Spotify Connect. This essentially made the device a connectable speaker. This worked perfectly and audio would seamlessly play through the speaker connected to the Raspberry Pi. 

 

Below is Demo Video from before the project was in the enclosure and synchronization between playing music and motion of the record was setup.

 

Enclosure:

To design the enclosure I used an online press-fit box generator and cut out holes for the speaker, cords, and ventilation. I sprayed plywood black and etched a pattern into the design to expose the bare wood where the wood was rastered. This created a really cool white on black look to the record case. I also attached a clear acrylic laser cut record to the DC motor so you could see the record spinning. The enclosure also has a slot that currently contains a computer speaker that was taken from a computer monitor. 

Below is a photo of the finished laser cut job.

Speaker inside enclosure:

 

Improvements to Current Design + Reflection:

This implementation requires WiFi, which isn’t great to use in a headless RPi setup since this would require SSH from another laptop to modify the file that specifies which network the device connects to. This works fine from my room, so I’m going to modify this design to work as a Bluetooth device. 

Spotify Connect is fairly limited as a means of streaming music, I’d like to be able to incorporate an LCD display into the record player that shows the current song playing, and push buttons that allow the user to have playback control. One design feature I really want to investigate is incorporated some sort of accelerometer into the record to determine if a user places there hands on the record or spinning the record, and have this be the means of playback functionality. For example, a user could stop the movement of the record with there hand and this would pause the playing. This would be similar to an actual record player.  There are services like Mopidy that I’ll need to investigate some more which allow for much better streaming of music, and incorporation with SoundCloud Last.Fm and other streaming services, all in a really nice UI that I could display on an LCD touch screen. 

 

Mopidy Front End:

One improvement I really want to do is to take apart a record player, and put the hardware inside this enclosure and control it through the Pi. This would be a really cool improvement since this project would then be able to stream music and play records as well. 

Overall though, given the time constraints for this project, I’m really pleased with the results. It’s definitely a significant improvement from the original record player nametag project. I was successful in playing music through the Pi, while rotating the record. My favorite part about this project is definitely the enclosure which turned out really nicely with the black etched wood. 

 

Here’s the Final Product:

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! 

 

Reflection

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

holder.

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