Inner Objective Trauma - Enchanted Alarm Clock | Project

Intention:

Our intent is simple: we want to help you wake up, get out of bed, and start your day in a positive mental state. We want to change your relationship with sleep by changing your mental state when you wake up through exposure to data streams.

This device is about our relationship with time. Often, devices interrupt us at the wrong moments. This device intervenes precisely when you need it - in the right context for the need you have in the moment. In this case, in the moment when you wake up, when you’re groggy, when you need a little nudge of your mindset to get you up (your desired behavior). This is an example of calm design. It’s about respecting the attention of the user.

We think of this as an ‘enchanted object,’ which connects ordinary objects with a bit of technology that adds magic. Our magic is the random live counts of something that’s happening in the world, that allows the user to tie the seconds and minutes to an impact outside of themselves, and thus change their internal state. And thus, get out of bed and begin their interaction with the world.

Approach

Going through the iterations of our design process, we zeroed in on the space between your hitting the snooze button on your alarm clock in the morning and when you get up. Many people struggle to get up and start their day, and we wanted to explore how we could intervene in that mental space with an IoT device to help motivate people to get out of bed and start their day right. Our device functions as a regular alarm clock - until you hit snooze and don’t get out of bed. The 'Conceptual Design' segment explains how it works.

Context

Situate the design proposal based on at least three references to past works. References to concepts, theory and methods introduced in class should also be made. These should be well-cited and illustrated.

The first picture below is the Withings Aura, an IoT alarm clock that uses light and sound to wake someone up. We were inspired the light aura as well as the pressure sensor that only turns the alarm off after the person has gotten out of bed.

The second picture below is the Arduino LED Matrix Info Display. We were inspired by the LED Matrix; it's large and easy to read, and can display multiple types of information (time, day of the week, weather). It is also a form factor that we could use.

The first picture below is the Network Clock with OLED Display. Here we were inspired by the ability to display multiple pieces of information at the same time. It also showed us we can use the internet to set the time, so it always shows the right time, including daylight savings.

Conceptual Design

You wake up, groggy, and hit that snooze button. When you do, the digital clock face snaps from showing the time to showing 00:00, while ambient lighting on the device lightly starts glowing. The device pulls a randomized data stream about an event in the world that has a count (e.g. number of birds migrating north, births in an area, packages delivered). This data stream becomes a count, and each time an occurrence happens (e.g. each time someone is born in an area) the counter goes up by 1 (00:01, 00:02, 00:03), accompanied by a subtle pulse of light. The person waking up thus connects the extra minutes they spend in bed to wonderfully-random events happening in the world; in real-time. The nature of counting forward brings the person waking up to encounter more instances of these events the longer they stay in bed, hopefully motivating a headspace that is conducive to waking up and starting the day.

The user may be too tired to look at the count directly, but he or she will still be aware of the pulses of light with each count. This may even prompt curiosity on what is being displayed on this particular day, which can help motivate the urge to look over and see, and from there feel more connected to the outside world, and - hopefully - a greater desire to get up and be a part of it.

In the prototype, we only use a dummy data stream. More on this in the process section.

If we had more time, we would have used an LED display where we could display both the count and what data is being represented.

Sketch and Storyboard

Process

We went back and forth on what data stream to use, of if we should use multiple. We decided to demo with one, but ideally this would be a random data stream about the world. We decided this to prevent the user from becoming numb to seeing only one thing every day (no matter how interesting that thing is). Variable rewards are powerful motivators for humans.

We couldn't figure out how to get the live webhook to work. So, we created a google sheet and connected it to the Particle Cloud. In the future, this sheet would be live updated with various data streams.

No matter what we tried, we could not get the LED display to output. So, we pivoted to the two 12-LED neopixels as a way to display both the time and the count.

Model Process

Choosing materials:

There were a few criteria to choosing materials:

- something sturdy enough to hold the screen and button

- something with enough transparency to allow light to flow through, but in an ambient way (so not too harsh either)

We experimented with foam core as the sturdy material and printer paper and this rougher bristol paper for the remainder of the form. Challenges included constructing seamlessly so that light illuminated the product naturally, and didn't leak or highlight seams.

There was also the challenge of where the light would glow; if the screen and button had to be secured, the face[s] they were on would have to be sturdy enough and therefore probably made of a harder material -> then, the light could not be coming from those surfaces. We also had to debate whether it made most sense to but the screen on the front or top, and what direction to secure the button as well to make it ergonomic to press. There was one point where we thought the screen would be in the front-face and the button would be at the top, which left the question of where it would make sense for light to come out of. We then considered how light would interact with a dark bedroom as a space as a whole, and considered ideas such as having the light "beat" out of the back face, reflecting off the walls.

Determining Form:

In determining the form, we wanted to make it something that prototyped the idea well (so containing light well), contained all the electronics, and still looked visually pleasing.

Final Form:

The final form we decided on was a rectangular prism, based on the measurements of the breadboard (we switched to a larger one) and the height of the wires.

By this stage, it was decided that the clock face would be shown through neopixels instead, which would be at the front of the face of the clock. The button would be on top. All sides of the form would be made of foam core.

While making the holes for the neopixels, I ran across the question of how to cover the middle of them so that there wasn't a harsh hole looking into the box. I then realized to put tracing paper there, which would also serve to dilute light and help convey that "heartbeat" light effect through the front when the clock turned off.

The button was secured as the top with two layers of foam: one layer on the inside holding the button up, and a second at the actual cover of the box to make a lid. The button was also eventually covered with tracing paper as well to make it flow with the rest of the object better.

We also ended up cutting out a small slab in the bottom side face to let the wires come out.

Craft:

To construct the foam core, I carved out channels so that no pieces of foam had to be glued together and the entire box could be built without seams. I also carved out channels on the base and lid pieces so that it could be fit into the box easily. Also, since it was so easy to take apart and put together, this made meeting with the rest of the team to fit all the technology inside easier. It was also something that the rest of my team could easily learn to build around or fix if we ever split the work up again.

prototype

Emily Liu - https://youtu.be/Kf2WHQBFR60

Prototype Video and Pictures

Final Project

TriXy737 - https://youtu.be/5VkcQhWXJ2E

Prototype

Bill of materials:

Full-size breadboard + Particle
Force-sensor
16-LED Neopixel
x2 12-LED Neopixels
Pushbutton
Peizo Sound Output
Power and power adapter
Paper and cardboard to house the device

// This #include statement was automatically added by the Particle IDE.
#include <neopixel.h>

// IMPORTANT: Set pixel COUNT, PIN and TYPE

#define PIXEL_TYPE WS2812
 
Adafruit_NeoPixel innerPixel = Adafruit_NeoPixel(16, D2, PIXEL_TYPE);
Adafruit_NeoPixel hourPixel = Adafruit_NeoPixel(12, D5, PIXEL_TYPE);
Adafruit_NeoPixel minPixel = Adafruit_NeoPixel(12, D6, PIXEL_TYPE);


//For random colors
int r;
int g;
int b;


//For Button
int buttonPin = D4;
bool lightStatus = 0;

//For Time/Snooze Tracking
int snooze = 2;
long wakeTime = 0;
long lastUpdate = 0;

//For Speaker
int speakerPin = D3;

// create an array for the notes in the melody  //C4,G3,G3,A3,G3,0,B3,C4
int melody[] = {1908,2551,2551,2273,2551,0,2024}; 
// create an array for the duration of notes.   // note durations: 4 = quarter note, 8 = eighth note, etc.:
int noteDurations[] = {4,8,8,4,4,4,4};

//For Pressure sensor
int fsrPin = A0;
int fsrReading;

int dataCount = 0;

void setup() {
    
//For Alarm function
Particle.function("Wake-Up Call", WakeUpCall);

//For inner lights
innerPixel.begin();
innerPixel.clear();
innerPixel.show();

//For Clock lights

hourPixel.begin();
hourPixel.clear();
hourPixel.show();

minPixel.begin();
minPixel.clear();
minPixel.show();

//For Speaker
pinMode(speakerPin, OUTPUT );

//For Button
pinMode(buttonPin, INPUT_PULLUP);

//For Clock
Time.zone(-5.00);

//For Data updating
Particle.subscribe( "googlesheet" , DataHandler, "e00fce68d4068f92d1a5b092" );

}



void loop() {

fsrReading = analogRead(fsrPin);

if( fsrReading > 2000 ){
  

    if(snooze == 2){
        Clock();
    }


    if(millis() < wakeTime+300000 && snooze == 0){
        
//Check for snooze button press
        if(digitalRead(buttonPin) == LOW){
            AlarmSnooze();
            delay(200);
            return;
        }
        
        AlarmOn();
    }
    
    if(snooze == 1 && millis() < wakeTime){
        innerPixel.setBrightness(100);
        innerPixel.show();
    }
    
    if(snooze == 1 && millis() >= wakeTime){
        snooze = 0;
        AlarmOn();
    }
    return;
}

if(fsrReading <2000){
    
    if(snooze != 2){
        innerPixel.clear();
        innerPixel.show();
        wakeTime = 0;
        snooze = 2;
        dataCount = 0;
        }
        
//show Clock
Clock();



    if(digitalRead(buttonPin) == LOW){
            AmbientLight();
            delay(500);
                    }
        }
}



int WakeUpCall(String trigger){
    innerPixel.setBrightness(255);
    r = (rand() % 51)*5;
    g = (rand() % 51)*5;
    b = (rand() % 51)*5;
    
for(int i=0; i<16; i++){
uint32_t c = innerPixel.Color(r, g, b);
innerPixel.setPixelColor(i, c);
}
// set a color 
innerPixel.show();
hourPixel.clear();
hourPixel.show();
minPixel.clear();
minPixel.show();

wakeTime = millis();
snooze = 0;

return 1;
}




void AlarmOn(){
    
//Turn on light, pick random color, & set brightness to max
    innerPixel.setBrightness(255);
    r = (rand() % 51)*5;
    g = (rand() % 51)*5;
    b = (rand() % 51)*5;
    for(int i=0; i<16; i++){
        uint32_t c = innerPixel.Color(r, g, b);
        innerPixel.setPixelColor(i, c);
    }
    innerPixel.show();
    
    playNotes();
    
//    delay(400);
    return;
}




void AlarmSnooze(){
    snooze = 1;
    wakeTime = millis() + 540000;
    innerPixel.setBrightness(10);
    innerPixel.show();
    return;
}




void DataHandler(const char *event, const char *data){
  
    
    String dataString = String(data);
    
    dataCount = dataCount + dataString.toInt();

    hourPixel.clear();
    uint32_t h = hourPixel.Color(255,0,0);
     for(int j=0; j < (dataCount / 10 % 10); j++){
    hourPixel.setPixelColor(j, h);
    }
    hourPixel.show();
    
    minPixel.clear();
    uint32_t m = minPixel.Color(255,200,200);
    for(int i=0; i < (dataCount % 10); i++){
    minPixel.setPixelColor(i, h);
    }
    minPixel.show();
    //Pulse Light
    for(int i=101; i<142; i++){
    innerPixel.setBrightness(i);
    innerPixel.show();
    delay(12);
    }
    
    for(int i=141; i>100; i--){
    innerPixel.setBrightness(i);
    innerPixel.show();
    delay(12);
    }
    return;
}




void playNotes(){
    
    // iterate over the notes of the melody:
    for (int thisNote = 0; thisNote < 7; thisNote++) {
      
      if(digitalRead(buttonPin) == LOW){
            AlarmSnooze();
            return;
        }  
      // to calculate the note duration, take one second
      // divided by the note type.
      //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
      int noteDuration = 1000/noteDurations[thisNote];
      tone(speakerPin, melody[thisNote],noteDuration);

      // to distinguish the notes, set a minimum time between them.
      // the note's duration + 30% seems to work well:
      int pauseBetweenNotes = noteDuration * 1.30;
      delay(pauseBetweenNotes);
      // stop the tone playing:
      noTone(speakerPin);
    }
      return;
}




void Clock(){
    
    int hour = Time.hourFormat12();
    int minute = Time.minute();
    //int min = 
    hourPixel.clear();
    hourPixel.setBrightness(5);
    uint32_t h = hourPixel.Color(255,255,255);
    hourPixel.setPixelColor(hour-1, h);
    
    minPixel.clear();
    minPixel.setBrightness(5);
    uint32_t m = minPixel.Color(100,100,255);
    
    if(minute >= 0 && minute <= 5){
        minPixel.setPixelColor(0, m);
    }
    if(minute >= 5 && minute <= 10){
        minPixel.setPixelColor(1, m);
    }
    if(minute >= 10 && minute <= 15){
        minPixel.setPixelColor(2, m);
    }
    if(minute >= 15 && minute <= 20){
        minPixel.setPixelColor(3, m);
    }
    if(minute >= 20 && minute <= 25){
        minPixel.setPixelColor(4, m);
    }
    if(minute >= 25 && minute <= 30){
        minPixel.setPixelColor(5, m);
    }
    if(minute >= 30 && minute <= 35){
        minPixel.setPixelColor(6, m);
    }
    if(minute >= 35 && minute <= 40){
        minPixel.setPixelColor(7, m);
    }
    if(minute >= 40 && minute <= 45){
        minPixel.setPixelColor(8, m);
    }
    if(minute >= 45 && minute <= 50){
        minPixel.setPixelColor(9, m);
    }
    if(minute >= 50 && minute <= 55){
        minPixel.setPixelColor(10, m);
    }
    if(minute >= 55 && minute <= 60){
        minPixel.setPixelColor(11, m);
    }
    minPixel.show();
    hourPixel.show();
    return;
}



void AmbientLight(){
    
    lightStatus = !lightStatus;
    
    if(lightStatus == 1){
    innerPixel.setBrightness(255);
    r = (rand() % 51 + 1)*5;
    g = (rand() % 51 + 1)*5;
    b = (rand() % 51 + 1)*5;
    
    for(int i=0; i<16; i++){
        uint32_t c = innerPixel.Color(r, g, b);
        innerPixel.setPixelColor(i, c);
    }
    innerPixel.show();
    delay(300);
    return;
    }
    
    if(lightStatus ==0){
        innerPixel.clear();
        innerPixel.show();
        delay(300);
        return;
    }
}

Click to Expand

Reflection and Critique

One thing we could have done better is to get on the same page about the purpose of this project. We never quite made it out of the ideation phase and each of us had a slightly different idea of what this was for. I think our idea could have been more refined if we figured this out earlier.

The biggest thing we would have liked to do differently is land on the right data stream to present to the user. We never quite got there. In addition, we think that sound may have been a better way to transmit that information rather than light flashes.

Acknowledgements:

Daragh Byrne

Kishore Kumar Perumalsamy

References:

First and foremost, the website of Daragh Byrne

The particle.io resource pages

Withings Aura

Arduino LED Matrix Info Display

Network Clock with OLED Display

Neopixel Libary

https://particle.hackster.io/peacemoon/particle-grove-lcd-rgb-backlight-realtime-clock-42151f

https://docs.particle.io/tutorials/device-cloud/webhooks/

https://www.hackster.io/TheReddest/photon-powered-lcd-forecast-and-time-display-32bab4

Start the Conversation

Share this Project

This project is only listed in this pool. Be considerate and think twice before sharing.

Found In

Thinking about Things

Courses

48675 Designing for the Internet of Things

· 12 members

About

Represent time in an abstract way, give a person context about what has happened while they were sleeping, and introduce a friendly face in the morning

Inner Objective Trauma - Enchanted Alarm Clock