Final Project

WhatsApp-Image-2019-12-17-at-6.24.59-PM-2-450x338

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.

 

 

Share on facebook
Facebook
Share on twitter
Twitter
Share on linkedin
LinkedIn
Share on pinterest
Pinterest