Today in class we open our new kits and started to go over them and label the parts for the next class where we were going to do our new project, making a gaming controller. The picture to the left shows all the labeling for the kit and the date of the labeling.
The goal of this phase in the design process is to plan out and lay out all of your requirement for the project and what you are going to do for the project.
Today in class we took out drawings to be a little more complicated and drew a newer version of the controller. We drew a later generation of the Xbox controller with the wire. We learned how to perfect our buttons and keypad while also learning how to draw a joystick and a thick and curved controller to fit the hands.
Today is class we started our controller drawings by first drawing the late Nintendo controller with the wire. We learned how to draw buttons and a keypad properly.
Here is a picture of my PS4 controller drawing.
I like this these because it has many different designs and attributes that differentiate them from each other.
I like this these because they are a lot more modern and have really cool designs.
I like this one because it's simple but at the same time its thin and easy to fit into your hand and anywhere really.
I love this one because of the design, the lights and how well thought out this was.
The goal of this phase in the design process is to get an idea for something that you might want to do or something like it.
To the left is a picture of my design, that I drew for my controller.
The goal of this phase in the design process is to help visualize your project. For this one specifically, it would help get your thoughts together and bringing it to life through a sketch of what u want to make or do.
Above is a picture of my first 3-D prototype.
Above is a picture of my first 3-D prototype.
The goal of this phase in the design process is to bring your drawing or idea to life through a small prototype, like a small model to get a realistic idea of what the final model will be like.
Above is me testing the far left and far right for buttons for each side of the controller, with the game Fireboy and Watergirl.
Above is me testing all the buttons for the whole controller, with a google document.
The goal of this phase in the design process is to check to see if everything works before it's finalized. This also helps with mistakes that might have happened in the process, and this part helps point those out to show that something is wrong and it needs to be fixed.
Above is a picture of my final controller project
Above is a picture of my final controller project
The goal of this phase in the design process is to express you finalized project and show it to others. To also be proud of your work.
Today in class we started to open our Engineering Kits and started to go over them and label the Engineering Kits for the next class where we were going to do our first project together. The picture to the left shows all the labeling for the kit and the date of the labeling.
I really liked this project since it was really hands on and interactive. It was very easy to me but also very fun. We learned how the positive side of a LED matches with the positive side of the coin battery. Also how the negative side of the LED matches with the negative side of the coin battery for the LED to light up.
This is our Project Brief, which is the description of the project that we will be doing.
This page describes all the requirements and things that will be need to be met when in process of the project.
This page describes the background knowledge/research we will be doing for the project. Like a change-impowering movement.
int LED = 2;
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(LED, OUTPUT);
}
// the loop function runs over and over again forever
void loop() {
digitalWrite(LED, HIGH); // turn the LED on (HIGH is the voltage level)
delay(500); // wait for a second
digitalWrite(LED, LOW); // turn the LED off by making the voltage LOW
delay(500); // wait for a second
}
This is a representation of our circuit. You can see that the LED legs go into D2 and GND that are on the Arduino.
Above is a mini video of the Arduino using the code to make the red LED blink rapidly.
Here is a picture of one LED plugged into the breadboard that is connected to the Arduino to turn the LED on.
Above is a picture of the wiring for three LEDs in the breadboard.
Above is a video of three LEDs blinking at different times, using the Arduino to command to LEDs.
int LED2 = 2;
int LED3 = 3;
int LED4 = 4;
int LED10 = 10;
int LED11 = 11;
int LED12 = 12;
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(LED2, OUTPUT);
pinMode(LED3, OUTPUT);
pinMode(LED4, OUTPUT);
pinMode(LED10, OUTPUT);
pinMode(LED11, OUTPUT);
pinMode(LED12, OUTPUT);
}
// the loop function runs over and over again forever
void loop() {
digitalWrite(LED2, HIGH); // turn the LED on (HIGH is the voltage level)
delay(250); // wait for a second
digitalWrite(LED2, LOW); // turn the LED off by making the voltage LOW
delay(250); // wait for a second
digitalWrite(LED3, HIGH); // turn the LED on (HIGH is the voltage level)
delay(250); // wait for a second
digitalWrite(LED3, LOW); // turn the LED off by making the voltage LOW
delay(250); // wait for a second
digitalWrite(LED4, HIGH); // turn the LED on (HIGH is the voltage level)
delay(250); // wait for a second
digitalWrite(LED4, LOW); // turn the LED off by making the voltage LOW
delay(250); // wait for a second
digitalWrite(LED10, HIGH); // turn the LED on (HIGH is the voltage level)
delay(250); // wait for a second
digitalWrite(LED10, LOW); // turn the LED off by making the voltage LOW
delay(250); // wait for a second
digitalWrite(LED11, HIGH); // turn the LED on (HIGH is the voltage level)
delay(250); // wait for a second
digitalWrite(LED11, LOW); // turn the LED off by making the voltage LOW
delay(250); // wait for a second
digitalWrite(LED12, HIGH); // turn the LED on (HIGH is the voltage level)
delay(250); // wait for a second
digitalWrite(LED12, LOW); // turn the LED off by making the voltage LOW
delay(250);
}
This is a representation of our circuit. You can see that the positive side of the LED legs go into D2, D3,D4, D10, D11, and D12. The negative side of the LED legs are in GND that are on the Arduino.
Above is a picture of the wiring for 6 LEDs in the breadboard.
To the left is a video of the 6 LED circuitry working and blinking at different times.
// A basic everyday NeoPixel strip test program.
// NEOPIXEL BEST PRACTICES for most reliable operation:
// - Add 1000 uF CAPACITOR between NeoPixel strip's + and - connections.
// - MINIMIZE WIRING LENGTH between microcontroller board and first pixel.
// - NeoPixel strip's DATA-IN should pass through a 300-500 OHM RESISTOR.
// - AVOID connecting NeoPixels on a LIVE CIRCUIT. If you must, ALWAYS
// connect GROUND (-) first, then +, then data.
// - When using a 3.3V microcontroller with a 5V-powered NeoPixel strip,
// a LOGIC-LEVEL CONVERTER on the data line is STRONGLY RECOMMENDED.
// (Skipping these may work OK on your workbench but can fail in the field)
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h> // Required for 16 MHz Adafruit Trinket
#endif
// Which pin on the Arduino is connected to the NeoPixels?
// On a Trinket or Gemma we suggest changing this to 1:
#define LED_PIN 6
// How many NeoPixels are attached to the Arduino?
#define LED_COUNT 17
// Declare our NeoPixel strip object:
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);
// Argument 1 = Number of pixels in NeoPixel strip
// Argument 2 = Arduino pin number (most are valid)
// Argument 3 = Pixel type flags, add together as needed:
// NEO_KHZ800 800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
// NEO_KHZ400 400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
// NEO_GRB Pixels are wired for GRB bitstream (most NeoPixel products)
// NEO_RGB Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
// NEO_RGBW Pixels are wired for RGBW bitstream (NeoPixel RGBW products)
// setup() function -- runs once at startup --------------------------------
void setup() {
// These lines are specifically to support the Adafruit Trinket 5V 16 MHz.
// Any other board, you can remove this part (but no harm leaving it):
#if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
clock_prescale_set(clock_div_1);
#endif
// END of Trinket-specific code.
strip.begin(); // INITIALIZE NeoPixel strip object (REQUIRED)
strip.show(); // Turn OFF all pixels ASAP
strip.setBrightness(255); // Set BRIGHTNESS to about 1/5 (max = 255)
}
// loop() function -- runs repeatedly as long as board is on ---------------
void loop() {
// Fill along the length of the strip in various colors...
colorWipe(strip.Color(255, 0, 0), 200); // Red
colorWipe(strip.Color(255, 77, 0), 200); // Orange
colorWipe(strip.Color(255, 247, 0), 200); // Yellow
colorWipe(strip.Color(13, 255, 0), 200); // Green
colorWipe(strip.Color(0, 255, 85), 200); // Teal
colorWipe(strip.Color(0, 174, 255), 200); // Cyan Blue
colorWipe(strip.Color(212, 0, 255), 200); // Purple
colorWipe(strip.Color(30, 3, 46), 200); // Black Purple
// Do a theater marquee effect in various colors...
// theaterChase(strip.Color(127, 127, 127), 50); // White, half brightness
// theaterChase(strip.Color(127, 0, 0), 50); // Red, half brightness
// theaterChase(strip.Color( 0, 0, 127), 50); // Blue, half brightness
rainbow(20); // Flowing rainbow cycle along the whole strip
//theaterChaseRainbow(50); // Rainbow-enhanced theaterChase variant
}
// Some functions of our own for creating animated effects -----------------
// Fill strip pixels one after another with a color. Strip is NOT cleared
// first; anything there will be covered pixel by pixel. Pass in color
// (as a single 'packed' 32-bit value, which you can get by calling
// strip.Color(red, green, blue) as shown in the loop() function above),
// and a delay time (in milliseconds) between pixels.
void colorWipe(uint32_t color, int wait) {
for(int i=0; i<strip.numPixels(); i++) { // For each pixel in strip...
strip.setPixelColor(i, color); // Set pixel's color (in RAM)
strip.show(); // Update strip to match
delay(wait); // Pause for a moment
}
}
// Theater-marquee-style chasing lights. Pass in a color (32-bit value,
// a la strip.Color(r,g,b) as mentioned above), and a delay time (in ms)
// between frames.
void theaterChase(uint32_t color, int wait) {
for(int a=0; a<10; a++) { // Repeat 10 times...
for(int b=0; b<3; b++) { // 'b' counts from 0 to 2...
strip.clear(); // Set all pixels in RAM to 0 (off)
// 'c' counts up from 'b' to end of strip in steps of 3...
for(int c=b; c<strip.numPixels(); c += 3) {
strip.setPixelColor(c, color); // Set pixel 'c' to value 'color'
}
strip.show(); // Update strip with new contents
delay(wait); // Pause for a moment
}
}
}
// Rainbow cycle along whole strip. Pass delay time (in ms) between frames.
void rainbow(int wait) {
// Hue of first pixel runs 5 complete loops through the color wheel.
// Color wheel has a range of 65536 but it's OK if we roll over, so
// just count from 0 to 5*65536. Adding 256 to firstPixelHue each time
// means we'll make 5*65536/256 = 1280 passes through this outer loop:
for(long firstPixelHue = 0; firstPixelHue < 5*65536; firstPixelHue += 256) {
for(int i=0; i<strip.numPixels(); i++) { // For each pixel in strip...
// Offset pixel hue by an amount to make one full revolution of the
// color wheel (range of 65536) along the length of the strip
// (strip.numPixels() steps):
int pixelHue = firstPixelHue + (i * 65536L / strip.numPixels());
// strip.ColorHSV() can take 1 or 3 arguments: a hue (0 to 65535) or
// optionally add saturation and value (brightness) (each 0 to 255).
// Here we're using just the single-argument hue variant. The result
// is passed through strip.gamma32() to provide 'truer' colors
// before assigning to each pixel:
strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(pixelHue)));
}
strip.show(); // Update strip with new contents
delay(wait); // Pause for a moment
}
}
// Rainbow-enhanced theater marquee. Pass delay time (in ms) between frames.
void theaterChaseRainbow(int wait) {
int firstPixelHue = 0; // First pixel starts at red (hue 0)
for(int a=0; a<30; a++) { // Repeat 30 times...
for(int b=0; b<3; b++) { // 'b' counts from 0 to 2...
strip.clear(); // Set all pixels in RAM to 0 (off)
// 'c' counts up from 'b' to end of strip in increments of 3...
for(int c=b; c<strip.numPixels(); c += 3) {
// hue of pixel 'c' is offset by an amount to make one full
// revolution of the color wheel (range 65536) along the length
// of the strip (strip.numPixels() steps):
int hue = firstPixelHue + c * 65536L / strip.numPixels();
uint32_t color = strip.gamma32(strip.ColorHSV(hue)); // hue -> RGB
strip.setPixelColor(c, color); // Set pixel 'c' to value 'color'
}
strip.show(); // Update strip with new contents
delay(wait); // Pause for a moment
firstPixelHue += 65536 / 90; // One cycle of color wheel over 90 frames
}
}
}
To the left is a picture of my neopixel to show that it works and that it turns on.
To the left is a video of my neopixel going through its coded pattern course.
Here is a video of my Window light work and going through through programmed sequence of colors, during the day.
Here is a video of my Window light work and going through through programmed sequence of colors, during the night.
Here is a link to the start of our research and a bigger opening to the Window Light project: Leaders of empowerment and change - Google Slides
Here is a link to the research I did of Martin Luther king for my Window Light: Kellsey Yarbrough - Empowerment and Change Research Collection - Google Docs
This is a picture of the research that I did that went through lots of editing and back and forth feedback
The 3D prototyping was a very big struggle while also very promising at the end.
Here is a picture of me plugging in the charger, that is connected to the Window light, into my computer to see if it works.
In the production phase of the design process, we have finalized our design , it meet all of the constraints, and we are building it for the end user. This often involves manufacturing. Above you can see my finalized Window Light Project that is ready for production (design is totally finished and functional per the constraints).
Today in class we practiced drawing Cube and shading with the cubes and where the light would be coming from to decide where the shading would be most and least.
Today in class we took shading and making 3-D objects a little further and we decided to make 3-D curves and zigzags. Plus with more dimension with the help of shading and light perspective.
Today in class we drew the basics of our new Desk Organizer Project and made the 3-D version to make it seem more realistic.
This is a picture of a 3-D cardboard cube that we were assigned to make as an example of what we will do for the Desktop Organizer and to get a feel for the process.
This is a picture of a 3-D word that we had to draw. The word have to be specifically important to us. The word I chose is "Love". I specifically chose "Love" because I feel as if love is a very powerful thing. It is most enjoyable when your loved by others and its even better to make someone else feel love. It can be taken many ways and I like to see it as a feeling that makes you feel really warm inside when someone else that you hold dear to you loves you.
Today our teacher introduced a new project to us - A Desktop Organizer.
This is the problem we are solving with this project and what we will do throughout the project,
These are the requirements for the project and what is needed for the project to be a success.
I like this one because it has a sleek and uniform look. It has dimension.
I like this one because it can hold multiple things on the inside of it, and hold things on top of it.
I like this one because it is see-through it holds your pencils, phone and glasses or something else in replacement of the glasses.
I love this one because it is very modern and up to date with more things like the USB charging quarters of the right side for charging your phone and other things. Plus it has a built-in monitor to use when typing and for other things.
This one is very similar to #5 but it has different attributes that I love. Like how it has a mini drawer, you can place you laptop or monitor there . And it holds things like notebooks and miscellaneous things under and around it.
I like this one because it is small transportable and doesn't take up a lot of space on your desk. It easily holds your phone pencils and pens, and miscellaneous things like erasers, and stickers.
The idea development phase of the engineering design process is two main parts: 1)Brainstorming--generating a list or a group of thumbnail sketches of potential solutions to the problem. 2) Narrowing down your ideas based on preference, feasibility, or constraints and then solidify our plan.
This is a picture of what I am thinking about making my Desktop Organizer like.
Here is my final decision as to what I would want my Desktop organizer to be like.
In the picture above I am cutting the cardboard and measuring for length and
Putting it together
In this picture I was putting everything in the slots and
In this picture I was spray painting my whole project black for color.
Here is the right side view of my Desktop Organizer.
Here is the top view of my Desktop Organizer.
Here is the back side view of my Desktop Organizer.
Here is the left side view of my Desktop Organizer.
Here is the bottom side view of my Desktop Organizer.
Here is a front view of my Desktop Organizer.
Here is the Front view of my Desktop Organizer with everything filled in it.
Here is the left side view of my Desktop Organizer with everything filled in it.
Here is the right side view of my Desktop Organizer with everything filled in it.
Here is the back side view of my Desktop Organizer with everything filled in it.
Here is the top view of my Desktop Organizer with everything filled in it.
Here is the bottom side view of my Desktop Organizer with everything filled in it.