Featured

Final project requirements and presentation schedule

Please post up your final project to the blog by 5pm the night before your presentation date. Please include:

  • A link to your published Instructable
  • Your video embedded/linked
  • Some photos
  • A brief description of your project’s purpose, function, form, construction, and future projections

Presentations (~20mins each) should include a live demo of your project, a video screening, tour through your process and final images by presenting your published Instructable, an explanation of what you learned from the experience, and how you could see the idea grow/change if it were taken further. There will be time for feedback, so please ask a few questions of the audience to direct the discussion.

December 5
Anna
Stephanie
Bart
Seona
–10 min break–
Wes
Hui
Yufei
Catherine

December 12
Pantea
Elvis
Felix & Ted
Shin Young
Victoria
–10 min break–
Leng
Helen
Sherry
Yuko

As a reminder, your final class dossiers are due on 12/19 (one week after our last class). They can be built around your Halloween costume or final project, it’s up to you. Don’t forget to email Alisha and me with the shareable (not private) dropbox link!

Final: Automatic Night Light

 

IMG_1314https://www.instructables.com/editInstructable/edit/E0X38G2JPINZ6L1/step/1

I made the Automatic Night Light named as SWIMCLOUD. It would detect the darkness and lights up by itself when people turn off the lights, so I do not need to turn on the night light by myself and do not need to afraid the darkness anymore.

IMG_3635

However, I used the transparent acrylic to build my model because of inspiration by below these photos. I think if I let people know what is the mechanism inside, and how it works, and it might raise the curious of this products and make it different from the common night light.

Then I laser cut the components which I want to build my model and used acrylic adhesive to stick it together.

For the circuit, I used the PIR sensor to detect the darkness on the Arduino board. And put cotton in the transparent cylinder to diffuse the lights, and make some change to let the lights suitable for the environment when people sleep.

Here is the circuit I built.

IMG_2787

And here are the process of model building.

IMG_3634IMG_3645IMG_3647IMG_3646

 

 

Here is the coding I used

#include <Adafruit_NeoPixel.h>
const int ldrPin = 5;
const int ledPin = 9;
const int brightness = 100;
#define PIN 9
Adafruit_NeoPixel strip = Adafruit_NeoPixel(8, PIN, NEO_GRBW + NEO_KHZ800);

int ldrState = 0;

void setup() {
Serial.begin( 9600 );
pinMode(ledPin, OUTPUT);
pinMode(ldrPin, INPUT);
strip.setBrightness(50);
strip.begin();
strip.show(); // Initialize all pixels to ‘off’
}

void loop() {
ldrState = analogRead(ldrPin);

if (ldrState <= brightness) {
colorWipe(strip.Color(0, 0, 0, 255), 50);
} else {
colorWipe(strip.Color(0, 0, 0, 0), 50);

}
Serial.print(“LDR Value = “);
Serial.println( ldrState );
delay(500);
}

// Fill the dots one after the other with a color
void colorWipe(uint32_t c, uint8_t wait) {
for(uint16_t i=0; i<strip.numPixels(); i++) {
strip.setPixelColor(i, c);
strip.show();
delay(wait);
}
}

Final Project: Prism Personal Dining Table

DSC_0098DSC_0093DSC_0095DSC_0071IMG_3844 2.JPG

For my final project I created an interactive dining table that senses when dishes and plates are put on top and lights up. I wanted to make something that speaks to me and my wants as a busy person who doesn’t always take time for myself. There should also be an IOT component that also posts a message to your slack group telling them that you are taking time for yourself. It uses the force sensor and neopixel strips.

Here is the link to the instructables: https://www.instructables.com/id/Prism-Personal-Dining-Table/

The biggest challenge was working with my board and neopixels and not understanding what was going wrong and why I was shorting my boards. It wasn’t until I changed neopixels that I realized there was something wrong with my neopixels.

 

Chicken Wing Clock(This name inspired by Anna)

_DSC4817.jpg

 

Good morning friends,

Are you late for today?

Are you still upset about not getting up on time every morning?

Are you still thinking about why you feel the alarm clock is not ringing every morning?

Congratulations, “your best partner ”—— the chicken wing clock is coming to you!

 

This is a clock which is named chicken wing clock. This is not an ordinary alarm clock. When the alarm is turned on, it can continually poke with the tip of the chicken wings to make you wake up. The alarm clock is turned off while the chicken wings are stopped.

 

It is funny but it is useful.

 

Now, let we see how to create this ” funny chicken wing “.

 

Material

  • a Wood board (22* 34* 0.7 inches)
  • Fish wire (40inchs)
  • Hot glues
  • Wood glues
  • Insulation tape
  • an MG995R
  • an Arduino board
  • a DS1307 Real Time Clock (RTC): I2C board
  • An LCD screen
  • two pushbuttons
  • registers (220 Ω)
  • a buzzer
  • Coin cell battery
  • an electret Microphone Amplifier – MAX9812
  • a USB wire
  • wires
  • soldering machine
  • CNC
  • Sandpapers (220)

 

The first step:

Design circuit diagram

Funky Borwo-Albar

 

The second step:

Making the chicken wing and clock box

 

 

(8inchs* 5.5inchs*0.2inchs)

 

微信图片_20181209214408

(8.5inchs*8inchs*3.5)

微信截图_20181209214618.png

 

The third step:

Testing code

Finally:

_DSC4823_DSC4813.jpg

Video

 

 

ColorTalk Headphones

For my final project, I created wearable bluetooth enabled headphones that lets you communicate through color and led animations. Whether it’s to let someone know you’re busy or flirt with someone without using words.

The earbud component is 3D printed and attached to pre-existing bluetooth headphones. Using an Adafruit Feather nRF52 BLE micro controller with the Adafruit Bluefruit LE App, colors and animations for the LEDs can be changed using pre-programmed buttons and a color picker.

Here’s the instructables link for how to make your own!

https://www.instructables.com/id/ColorTalk-Earphones

Some in progress photos:

Headphone circuit diagramIMG_6472

 

Pomodoro Lamp

For my final project, I created a Pomodoro lamp, Lucee. You can turn on the light by creating a task on your IOS reminder app. The light is turned on for 40 minutes for you to focus and it turns itself off for the 10 minutes of break time. Once you complete the task, and by hitting the complete button on the app, the light would also turn off.

 

The biggest challenge was working with the servo motor. My original intent to move the light bulb up and down was challenged. I may have to work with a lever or gear chain system to support and trigger the motor.

I enjoyed working with Arduino and the internet of things. I learned how to use the Power Relay and connecting it to AC circuit.

For the next step, I would like to dig into the mechanical engineering of the movement and play with the idea of dimming of the light as the time goes on.

Here‘s the link to my instructable.

Dish Buddy!

Hi all, hopefully most of you are already in bed by now!

Say hello to Dish Buddy:

IMG_6476

Dirty dish buddy is a simple sink grid sitting on top of a push button. This is connected to a WiFi-enabled Arduino hidden within a modest enclosure. When someone places a dish on the sink grid, this presses the button. If the dish stays there for more than 5 minutes, whoever is looking after the sink will get an email alert. Once they see this email, they can track down the culprit before too many dishes pile up.

IMG_6472

IMG_6474

IMG_6464

Here is my video:

And how’s about a link to the instructable.

And my thoughts on the project:

As far as the Arduino aspect, learning about the WiFi capabilities and seeing it work without the aid of a computer was a magical moment. Additionally, I learned how to use a variable to track when the program is in different “states” enabling multiple processes to run in tandem and be intentionally affected when specific events trigger a state change. Also using the Sugru to waterproof the button was a handy tip.

With the video, I learned a lot about how a good, thorough storyboard can streamline the whole video shooting process, making it much more enjoyable when you know everything you have to do from the start. And it makes it much easier in general because you can edit many unnecessary shots before recording a second of footage. Additionally, I was able to experiment hands-on for the first time with high quality video lighting which made a huge difference.

Jumping off questions:

Is this too invasive of a solution?

Would anyone actually be willing to track down a dirty dish culprit if they got an email about it?

Does it increase or diminish feelings of respect in a shared environment?

 

 

 

Watchful Eye – Final

DSC_0033

For my final I designed a Watchful Eye. Taking inspiration from Evil Eyes that protect you from harm, this device is designed with the intent of helping friends and loved ones look-out for on another. It uses the Adafruit io and IFTTT platforms to active the device from your phone so that it can be looking for your safe return. Once you get home it will send a text to your friend that you have made it safely.

Please see my instructable below for more information:

https://www.instructables.com/id/Watchful-Eye/

IMG_0976IMG_0941IMG_0906Acrylic layout


#define LED_PIN 13
#define MOTION_PIN 23

//Including NeoPixel Library
#include

#define PIXELS_PIN 13
#define NUM_LEDS 16
#define BRIGHTNESS 50
#define PIXEL_TYPE NEO_GRB + NEO_KHZ800 // Type of the NeoPixels
Adafruit_NeoPixel strip = Adafruit_NeoPixel (NUM_LEDS, LED_PIN, NEO_GRB + NEO_KHZ800);

//Including WIFI configuration
#define WIFI_SSID “Wifi name”
#define WIFI_PASS “Wifi_password”
#define IO_USERNAME “IO_username”
#define IO_KEY “IO_key”

#include “AdafruitIO_WiFi.h”
#include
#include

AdafruitIO_WiFi io(IO_USERNAME, IO_KEY, WIFI_SSID, WIFI_PASS);
#include
#include

// Variables for sensor, arming, feed
int current = 0;
int last = 0;
int armedSensor = 0;
int message = 0;

//Color variables
uint32_t low = strip.Color(0, 0, 0);
uint32_t high = strip.Color(41,196,204);
uint32_t armed = strip.Color(20,20,20);

// set up the ‘Watchful’ feed
AdafruitIO_Feed *Watchful = io.feed(“Watchful”);

//Wifi and IO set up code
void setup() {
//set up LEDs
strip.setBrightness(BRIGHTNESS);
for( int i = 0; i<NUM_LEDS; i++){
strip.setPixelColor(i, low);
}
strip.begin();
strip.show(); //Initialize all the pixels to “off”

//Set up sensor for reading
pinMode(MOTION_PIN, INPUT);
pinMode(LED_PIN, OUTPUT);

// start the serial connection
Serial.begin(9600);

//connect to Wifi
WiFi.begin(WIFI_SSID, WIFI_PASS);
while (WiFi.status() != WL_CONNECTED){
delay(500);
Serial.println(“Connecting to WiFi..”);
}

Serial.println(“Connected to the Wifi network”);
Serial.println(WiFi.localIP());
delay(500);
// connect to io.adafruit.com
Serial.print(“Connecting to Adafruit IO”);
io.connect();

// wait for a connection
while(io.status() < AIO_CONNECTED) { Serial.print(“.”); delay(500); } // we are connected Serial.println(); Serial.println(io.statusText()); } //Main functions void loop() { // io.run(); is required for all sketches. // it should always be present at the top of your loop // function. it keeps the client connected to // io.adafruit.com, and processes any incoming data. io.run(); // set up a message handler for the feed. // the handleMessage function (defined below) // will be called whenever a message is // received from adafruit io. Watchful->onMessage(handleMessage);

//Tells you device is on standby and pixels off
if(message == 0 && armedSensor == 0){
Serial.println(“Unarmed – Standby”);
for( int i = 0; i<NUM_LEDS; i++){
strip.setPixelColor(i, low);
//strip.show();
}
strip.show();
delay(10000);
}

//Arms sensor when widget button is pressed
if(message == 1 && armedSensor == 0){
Serial.println(“Arming sensor”);
for( int i = 0; i<NUM_LEDS; i++){
strip.setPixelColor(i, armed);
//strip.show();
}
strip.show();
armedSensor = 1;
delay(2000);
}

//If armed and senses motion, turn on LEDs
if(message == 1 && armedSensor == 1){
// grab the current state of the button.
if(digitalRead(MOTION_PIN) == HIGH){
current = 1;
Serial.println(“Motion detected!”);
for( int i = 0; i<NUM_LEDS; i++){
strip.setPixelColor(i, high);
//strip.show();
}
strip.show();
delay(5000);
Serial.println(“Disarming sensor”);
armedSensor = 0; //disarms
message = 0; //resets IO feed
for( int i = 0; i<NUM_LEDS; i++){ strip.setPixelColor(i, low); //strip.show(); } strip.show(); } delay(1000); armedSensor == 0; //Serial.println(“Unarmed”); } } // this function is called whenever a ‘Watchful’ message // is received from Adafruit IO. it was attached to // the Watchful feed in the setup() function above. void handleMessage(AdafruitIO_Data *data) { message = data->toInt();

//if (Watchful == 0){ //light up the LED
Serial.print(“received <- “);
Serial.println(message);
//}

}