Bear in mind

About

Bear in Mind focuses on the idea of 'Connected Intimacy.' Each partner can place his or her object in her room . Our intimacy objects consists of a teddy bear and glass dome that contains cherry blossom petals. When a partner thinks of the other person, he or she squeezes the hand of their teddy bear which sends a signal to their partner's glass dome. A simulated current of air will make the petal move inside the glass dome. The simulated movement of the petals will bring back the couples memory of walking and holding hands through cherry blossom's fields. If the partner is next to the object, he or she will be able to see it and reply to the signal, indicating that as a couple they are not only thinking of each other but also keeping a tradition that the couple has alive. Bear in Mind was created by a team of four Carnegie Mellon students. My role on the team was developing the code for operating the blower, compiling the code developed by other team members for the flex sensor and communication between devices with my own code into a cohesive program, designing the circuitry for the prototype, and creating the video demonstrating a scenario use case.

Goal

The goal of this project is to strengthen couples rituals beyond boundaries. We focused on a particular ritual of holding hands while walking through cherry blossom fields. Our motivation for making this project is to support our classmates that are in long distance relationships and don't have the opportunity to continue to practice meaningful rituals that they have with their partners.

Components

(for one intimacy object)

1 x Particle Photon

1 x Blower

1 x TIP120 Transitor

1 x LED

1 x 220 Ohm Resistor

1 x 10K Ohm Resistor

1 x 1K Ohm Resistor

1 x Diode

1 x Flex Sensor

1 x 12V Power Supply

(for outer shell)

1 x Black Foam Board (for base)

1 x Plastic Dome

1 x Cloth Mesh

1 x Faux Rose Petals

1 x Teddy Bear

Process

Our team was really interested in exploring how we could incorporate movement and touch to our intimacy object. We brainstormed different rituals that we thought couples or families cared about and were difficult to replicate because of long distances. We really enjoyed the story that one of our team members shared around cherry blossom festivals.

Once we aligned on a scenario, we explored how we could create movement inside the glass dome and how we could incorporate touch as the trigger for our intimacy object. We tested different servos and fans to determine the best option for our object. Once the code, the input (squeeze sensor) and output (blower) were incorporated, we developed the base to host the glass dome.

Challenges:

As we developed our prototype, we encountered the following challenges:

Learning to work with a transistor. It was challenging to understand how to properly create the circuit for the transistor.
Code: In order to have the blower blow for a couple of seconds we learned that we needed to create a loop using the while function vs an if statement
the importance of grounding: the 12 V rails needed to be grounded to the particle in order for the blower to work properly
Blower wind force was not displacing the petals correctly. We had to create several adjustments to alter the angles of the created current so that the petals would continually rotate and not stagnate in the edges of the dome.

Resources

Tutorial for Flex Sensor

Circuit Tutorial for Transistor

Particle Publish and Subscribe Function

Code

// Define a pin we'll place an LED on
int ledPin = D2;

// Pin locations on the Particle
int buttonPin = D0;
int flexPin = A0;
int fanPin = D1;

int flexReading = 0;
int flexValue = 0;

long lastPublishedAt = 0; //not sure what this is for?
// from this device
int publishAfter = 10000;

unsigned long duration;
unsigned long timeLength = 10000; // run blower for 10 seconds.

void setup()
{
  pinMode(ledPin, OUTPUT);
  pinMode(buttonPin , INPUT_PULLUP);
  pinMode(flexPin, INPUT_PULLUP);
  pinMode(fanPin, OUTPUT);

  Particle.variable("flex", &flexReading, INT);
  Particle.variable("brightness", &flexValue, INT);

  Particle.subscribe(  "diot/2018/connected/bearinmind" , handleSharedEvent );
}

void loop()
{
    // find out if the button is pushed
    // or not by reading from it.
    int buttonState = digitalRead( buttonPin );
    flexReading = analogRead(flexPin);
    flexValue = map(flexReading, 3246, 3680, 0, 255);

    if( abs(flexValue) >= 175 )
    {
      int loopTime = millis();
      publishMyEvent();
      while(millis() <= loopTime + timeLength){
        digitalWrite( ledPin, HIGH);
        digitalWrite( fanPin, HIGH);
      }
    }else{
     digitalWrite( ledPin, LOW);
     digitalWrite( fanPin, LOW);
    }
}
void publishMyEvent()
{
  // check that it's been 10 secondds since our last publish
  if( lastPublishedAt + publishAfter < millis() )
  {
      String eventName = "diot/2018/connected/bearinmind" + System.deviceID();
      // then we share it out
      Particle.publish( eventName, "Thinking of you..." );
      lastPublishedAt = millis();
  }

}

void handleSharedEvent(const char *event, const char *data)
{
    // Now we're getting ALL events published using "diot/2018/connected/bearinmind"
    // This includes events from this device.
    // So we need to ignore any events that we sent.

    // Let's check the event name
    String eventName = String( event ); // convert to a string object
    // This gives us access to a bunch of built in methods
    // Like indexOf()
    // Locates a character or String within another String.
    // By default, searches from the beginning of the String,
    // but can also start from a given index,
    // allowing for the locating of all instances of the character or String.
    // It Returns: The index of val within the String, or -1 if not found.

    // We can use this to check if our event name contains the
    // id of this device

    String deviceID = System.deviceID();

    if( eventName.indexOf( deviceID ) != -1 )
    {
      // if we get anything other than -1
      // the event came from this device.
      // so stop doing stuff
      return;
    }

    // otherwise do your stuff to respond to
    // the paired device here
    int loopTime = millis();
    duration = loopTime - millis();
    while(millis() <= loopTime + timeLength){
      digitalWrite( ledPin, HIGH);
      digitalWrite( fanPin, HIGH);
    }
}