Dish Buddy!

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

Say hello to Dish Buddy:


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.




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


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.

Watchful eye from Stephanie Gamble on Vimeo.


Please see my instructable below for more information:

IMG_0976IMG_0941IMG_0906Acrylic layout

#define LED_PIN 13
#define MOTION_PIN 23

//Including NeoPixel Library

#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”


// 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
for( int i = 0; i<NUM_LEDS; i++){
strip.setPixelColor(i, low);
strip.begin();; //Initialize all the pixels to “off”

//Set up sensor for reading

// start the serial connection

//connect to Wifi
while (WiFi.status() != WL_CONNECTED){
Serial.println(“Connecting to WiFi..”);

Serial.println(“Connected to the Wifi network”);
// connect to
Serial.print(“Connecting to Adafruit IO”);

// 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() { //; is required for all sketches. // it should always be present at the top of your loop // function. it keeps the client connected to //, and processes any incoming data.; // 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);

//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);
armedSensor = 1;

//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);
Serial.println(“Disarming sensor”);
armedSensor = 0; //disarms
message = 0; //resets IO feed
for( int i = 0; i<NUM_LEDS; i++){ strip.setPixelColor(i, low); //; }; } 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 <- “);


GEOFF – the key reminder

So the key reminder is here. It combines the function of reed switch, distance sensor, speaker and IO provided by Adafruit. It simply reminds you when you open the door but forget to take the keys. More details can be found in the Instructables link above.

It’s a box (and Allan doesn’t like it) where you can put your keys on it. No it’s definitely not the best looking thing I have ever made, but hey, it means I have a lot of space to improve in the future. And giving more time (two weeks I spent on this project, one and half of them spent waiting for parts being delivered. Good job UPS!)

On Time Intelligent Light Switch

Presenting the final for my On Time Intelligent Light Switch. The process was a pretty fun ride with a few twists, turns, and mishaps along the way. The Code was more complex than I expected going in. I AM happy with how its functioning, but I am learning so many different ways of getting to the same result, that I believe this code could be written in a few different ways which would leave it more open to easier modifications and distinct separate states of operation.

The final cluster of components is also larger than I originally envisioned. A little too large to cleanly fit into the wall as an at home switch replacement. Have already been looking into some alternative boards to do the dimming which I hope will drive the next update to the concepts to actually find a home within the walls of my home.

My very first Instructable post can be found below.  :

Some Photos from the construction process. :

Wiring Diagram.jpeg



3b-Wired Breadboard.jpg

5-AC in Wallbox.jpg

6a-All Wired.jpg

6b-All Wired.jpg




Final project: Fridge Guard

Sometimes when I take a lot of things out of the fridge, I have no free hand to close the door and then the door is just left open for a long time. Sometimes when I use too much strength to close the fridge door, it bounces off but I can’t notice it. When I realize it is still open, several hours or maybe the whole night has passed by. The food went bad and a large amount of electricity was wasted.


The Fridge Guard is a close door reminder designed for people who do not notice the fridge door is still slightly open or may forget to close the fridge door. The reminder can stick on the door and one of the polar bear’s hand will stick on the frame of the door, detecting whether the door is being left open and no one notices it.

It uses the Force sensor, IFTTT and Adafruit IO to gather the information from your fridge and sends a reminder to you through the message and piezo buzzer.


Here is the link of Instructables tutorial.

Here is the video:

The whole process to making Fridge Guard was challenging and also interesting and I really enjoyed that. At the very beginning, I used temperature sensor to detect whether the door is open or closed. After I built the circuit and test it at fridge, it didn’t change the temperature when the fridge door was slightly open. So I changed to force sensor, I also met some problem here. Because the sensor is too thin, when the door is closed, there is no pressure on the sensor. Finally I found that I need to make it thicker so that the sensor can detect the pressure when door is closed.

For the shape of Fridge Guard, I made the design and shape to fit the context. Polar bears live in cold area, so I chose this shape. I used to put them outside the fridge at the side of door, but it not quite fit well. So I chose to put it inside the fridge.

For the future, I think I want to change the material of Polar bear to soft rubber which is more fit for the environment inside the fridge.

Final Project: Hey Pillow


For the final project, I have decided to design a pillow that you can give to that special someone that constantly struggle to get out of bed and is late to classes, meetings, and dates.

Introducing the HEY Pillow.


It uses the ESP8266 Board to connect to the Wi-fi so that you can receive a notification that someone is still on the pillow and also send a trigger back to the pillow to initiate the Buzzer that will wake that person up.

Screen Shot 2018-12-02 at 3.41.43 PM

Screen Shot 2018-12-02 at 3.41.21 PM

Here is the link to the Instructables of the steps it took to building the HEY Pillow Prototype


Here is the Video

Overall I throughly enjoyed the whole process of building HEY Pillow. Definitely there were a lot of moment where I almost wanted to give up because the code just would not work the way I wanted it to. This project has taught me to be more confident in tackling in brand new areas such as Arduino and better problem solving techniques. I can confidently say that I can make a light blink and buzzer make noise and create a Hey Pillow. It was a lot of fun.

Going forward I want to make the branding and packaging more refined and through the story can bring out interest of the Pillow more.



! [exclamation mark]

So this is my big exclamation mark for Halloween.

It started from soldering the sound board, which was, well, quite painful.

(this is how it looks like after two days of soldering – unsoldering – soldering again 😦

This it is time for testing how the sensor works. It turns out it works without any driver, just plug in TWO power cables and TWO ground cables and one data cable, the result can be viewed immediately in the monitor.

Then to combine the different parts and let it work. The basic idea is, let the distance sensor detect the distance and when it reaches a value (here it is actually the value of 1000/d, since the noise is plentiful and it has an exponential growth), it turns the light on and sound board starts playing the music preset in the sd card.

The 3d printed exclamation marks has 0.8 mm walls so in dark environment it can be easily seen when the led is on.

The problem here is that the sound board cannot work simultaneously with other components, so when it starts to work, the light will stay on after the music is off.

Here is the code.

#include <Adafruit_NeoPixel.h>

#ifdef __AVR__

  #include <avr/power.h>


#define PIN            6

#define NUMPIXELS      16

Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRBW + NEO_KHZ800);

int delayval = 1;

#include <WaveHC.h>

#include <WaveUtil.h>

SdReader card;

FatVolume vol;

FatReader root;

WaveHC wave;

uint8_t dirLevel;

dir_t dirBuf;

#define error(msg) error_P(PSTR(msg))

void play(FatReader &dir);

void setup() {

#if defined (__AVR_ATtiny85__)

  if (F_CPU == 16000000) clock_prescale_set(clock_div_1);




  putstring_nl(“\nWave test!”);

  putstring(“Free RAM: “);


  //  if (!card.init(true)) {

  if (!card.init()) {

    error(“Card init. failed!”);



  uint8_t part;

  for (part = 0; part < 5; part++) {

    if (vol.init(card, part))



  if (part == 5) {

    error(“No valid FAT partition!”);


  putstring(“Using partition “);

  Serial.print(part, DEC);

  putstring(, type is FAT”);

  Serial.println(vol.fatType(), DEC);

  if (!root.openRoot(vol)) {

    error(“Can’t open root dir!”);


  putstring_nl(“Files found (* = fragmented):”); | LS_FLAG_FRAGMENTED);


void loop() {

  int sensorValue = analogRead(A5);

  if (1000/sensorValue < 2){

    for(int i=0;i<NUMPIXELS;i++){

      pixels.setPixelColor(i, pixels.Color(255,0,0));;






    else {

       for(int i=0;i<NUMPIXELS;i++){

      pixels.setPixelColor(i, pixels.Color(0,0,0));;





void error_P(const char *str) {

  PgmPrint(“Error: “);





void sdErrorCheck(void) {

  if (!card.errorCode()) return;

  PgmPrint(“\r\nSD I/O error: “);

  Serial.print(card.errorCode(), HEX);


  Serial.println(card.errorData(), HEX);



void play(FatReader &dir) {

  FatReader file;

  while (dir.readDir(dirBuf) > 0) {

    if (!DIR_IS_SUBDIR(dirBuf)

         && strncmp_P((char *)&[8], PSTR(“WAV”), 3)) {




    for (uint8_t i = 0; i < dirLevel; i++) {

       Serial.write(‘ ‘);


    if (!, dirBuf)) {

      error(“ failed”);


    if (file.isDir()) {

      putstring(“Subdir: “);



      dirLevel += 2;


      dirLevel -= 2;


    else {

      putstring(“Playing “);


      if (!wave.create(file)) {

        putstring(” Not a valid WAV”);

      } else {


        uint8_t n = 0;

        while (wave.isplaying) {


          if (!(++n % 32))Serial.println();