Connected Shadowboxes

Each of these shadowboxes will detect motion and send a message to all the others, lighting them up.

I wanted to make these for my family members. It's pretty easy, and it's my first real project with a Spark Core, which made it twenty times easier to do.

The thing that I like about this project is that it's incredibly easy for me to run updates to the firmware. I can tell who has theirs online, and I can make changes so that they blink differently on birthdays or holidays. I could even give each frame its own LED or LED pattern to distinguish which frame is being set off at any given moment.

You can make one. You should make one. Find out how below.

I made five, but two is the minimum. Here's what you would need for that.

Materials

- 2 Spark Cores

- 2 USB to micro USB cables

- 2 Power bricks

- 2 PIR sensors

- 8 white LEDs

- 100 Ohm Resistors

- 2 Breadboards or 1 Big Breadboard

- 2 Protoboards

- Wires (I like having many colors) and things to snip and strip them

- 2 drawings or photos printed on vellum paper and cut to 8"x8"

- 2 three-quarter-inch 8x8 shadowboxes

- Drill and big fat drill bit

- Hot glue gun

- Solder and soldering iron

Step 1: Power on your Cores and Flash the Firmware

Turn everything on, make sure it works, and flash the firmware below to both cores. If you need help getting started, go to docs.spark.io or to http://cmsunu28.gitbooks.io/spark-basics/ for assistance.

#define EVENT_PERIOD_SECONDS 60
#define MAX_MISSED_EVENTS 3
 
int inputPin = D0;              // choose the input pin (for PIR sensor)
int pirState = LOW;             // we start, assuming no motion detected
int val = 0;                    // variable for reading the pin status
int calibrateTime = 10000;      // wait for the thingy to calibrate
int onTime = -10000;

void setup() {
  pinMode(inputPin, INPUT);     // declare sensor as input
  pinMode(D7, OUTPUT);  // d7 LED is an output
  pinMode(A4, OUTPUT);  // set A4-A7 as output
  pinMode(A5, OUTPUT);
  pinMode(A6, OUTPUT);
  pinMode(A7, OUTPUT);
  Spark.function("circleblink", circleblink);   // define blinking function to be called when motion detected anywhere
  Spark.subscribe("motion-MYNAME-shadowbox", lightresponse); // define event to subscribe to. replace MYNAME with your name!
  Serial.begin(9600);
}

int circleblink(String command) {
    if (command.toInt()>0 && command.toInt()<15) { // blinks 4 leds in sequence starting with whichever pin is indicated. for A4-A7, this is 14.
        int startpin=command.toInt();
        for (int r = 0; r<3; r++) {
            digitalWrite(startpin,HIGH);
            for (int x = startpin; x<(startpin+4); x++) {
                delay(500);
                digitalWrite(x, LOW);
                digitalWrite(x+1, HIGH);
            }
            digitalWrite(startpin+4,LOW);
        }
        return 1;   // return 1 to show that this worked.
    }
    else {
        return -1; // return -1 to show that it did not work.
    }
}

bool calibrated() { // don't start anything until the sensor is ready
  return millis() - calibrateTime > 0;
}

void readTheSensor() { // function to read motion detector
  val = digitalRead(inputPin);
}

void reportTheData() { // function to report motion detection
  if (val == HIGH) {
    if (pirState == LOW) {
      // we have just turned on
      Serial.println("motion");
      Spark.publish("motion-MYNAME-shadowbox","motion"); // remember to replace MYNAME with your name
      digitalWrite(D7,HIGH);
      // We only want to print on the output change, not state
      pirState = HIGH;
    }
  } else {
    if (pirState == HIGH) {
      // we have just turned off
      Serial.println("quiet");
      // We only want to print on the output change, not state
      digitalWrite(D7,LOW);
      pirState = LOW;
    }
  }
}

void lightresponse(const char *event, const char *data) {
  onTime = millis();    //reset timer
}

void loop() {
  if (calibrated()) {
    readTheSensor();
    reportTheData();
  }
  if (millis() - onTime < 500) {    //only blink if spark.subscribe found something in the last 500 ms
      circleblink("14");
  }
  else {}
  double elapsedSeconds = (millis() - onTime) / 1000.0;
  if (elapsedSeconds > (MAX_MISSED_EVENTS * EVENT_PERIOD_SECONDS)) {
    Serial.println("Subscribe is dead, long live subscribe!");
    delay(500);
    System.reset();
  }
  else {
    Serial.println("things are okay... but it's been " + String(elapsedSeconds) + " since last event");
    delay(1000);
  }
}

Step 2: Test everything on the breadboard to make sure it works.

Sadly, my version of fritzing does not include a PIR sensor, but here it is without the sensor in it, as I prototyped it on the breadboard:

Here's some videos of it working...

I tested both before I soldered anything down.

Step 3: Wire everything to a protoboard and solder it!

This was super fun. I put headers onto the protoboard so that it would be removable, and I soldered the wires down in this basic conformation:

Step 4: Re-test to make sure it works...

Step 5: Prep the frames

I actually did this step earlier, as you can see in the above video. This is the part where you take the frame apart and drill a hole in the bottom for the wire. It was actually pretty easy to do with the frames I had, although I got sawdust all over the place.

The shadowboxes had a spacer in them as well that I removed for drilling and used later to hold down the LEDs, as shown below. I also used the cardboard that came in the picture as a cover so that the shadows of the wires and protoboard wouldn't show when the LEDs lit the frame.

Step 6: Put it all together

Gently press down on the spacer to secure it. Make sure the LEDs go between the spacer and the vellum paper, but that your cable and other wires are looped on the other side. Plug your Core into your cable, run the cable and the PIR sensor over the spacer, and replace the backing on the frame. Use hot glue to secure the sensor to the bottom of the frame. 

You should be good to go! Make sure you put the backs on very loosely so that you can put the cores on wifi when the frames get to their new homes.

Step 7: Plug in, connect, and enjoy!

Plug in the frame at its new home, put the core on the wifi there (you may have to hold Mode until it starts flashing blue again), and watch them go off!

Hooray!