Falling Finances

Problem & Solution

People don't like opening their banking apps. Even when they do it's often very annoying to login, and obtaining basic information like remaining budget for the month is a complicated process.

As part of this project, we are trying to make an ambient device meant to provide this information in a glanceable, yet fun manner. Thus, we introduce Falling Finances, a painting-style ambient device that hooks up to your bank account, and drops coins based on your remaining monthly budget.

Process

We began by brainstorming different forms of data we could try to represent. Among others, we looked at weather, health, personal finances, economics, etc. In the end, we chose personal finances since we felt that it would be the easiest to work with in terms of the kind of the data we would have to deal with.

At this point, we then starting focusing on ways we could symbolize some aspect of personal finances. We all ended up focusing on budgeting - and how difficult it is to actually do. So we chose to try a slightly more psychological approach to helping people do so - a small, continuous reminder of the overall amount of your month's budget you've spent so far.

Once we achieved this point, we chose to focus on different visualization techniques we could implement to help us achieve this goal. We thought of a variety of approaches ranging from simple LED balls to a piggy bank that made the sound of falling coins when a transaction occurred. In the end, we chose to keep it simple, and simply have pennies that fell, with the amount remaining a symbolic reminder of the remainder of your monthly budget.

We iterated over a couple of designs for this, considering the use of pennies, and a basic servomotor. Initially, we began with a relatively simple design, essentially a flat funnel at whose mouth waited the servomotor. As transactions linked to the account occur, the motor releases coins based on pre-planned spending thresholds.

One issue we ran into in this design was that the pennies kept getting jammed at the mouth of the funnel. We brainstormed a few changes, including making the frame asymmetrical, so pennies would not get stuck against each other. In the end, we reduced the space the pennies could take to be a simple zig-zag path, one at a time. This simplified the process for us a lot, since we could control the exact way the pennies left the frame. We also chose to give the path a back of acrylic above the wood when we realized that it would help the coins move more smoothly. To achieve the proper open time of the servo at the bottom of the funnel (4 coins per boundary for 16 coins, we created a separate program) that did not rely on a transaction to activate the servo.

From a software side, we initially ran into issues on preventing the coins from deploying on a continuous basis. We needed it to continuously check Buxfer, but we couldn't have the software pulling data & implementing a coin-drop continuously. Thus, we chose to set up borders (in the example case, with a budget of $1000, borders of $750, $500, $250 & $0), and implemented flags to ensure that these borders would only be crossed with any effect the first time it happened. This also ensured that if multiple boundaries were crossed, the servo would open that number of times.

Another issue was occurred was related to asynchronous tasks in the code. Essentially code was executing before the Particle cloud webhook had a chance to return data and update the budget balance. This was solved by putting our conditional boundary logic that activated the servo into"void handleBudgetReceived(const char *event, const char *data)", which had the effect of only evaluating the budget state once the webhook returned data.

Bill of Materials

Mechanical Components:

- Transparent Acrylic

- Plywood

- Screws

- Pennies

Electronics:

- Servomotor

- Breadboard

- Particle Photon

Software:

- Particle Web Services (Webhook) + Particle Dev

- Buxfer (Link to personal finances)

Refactoring the budget boundaries to handles when multiple boundaries are triggered simultaneously.

(2018)

// GLOBALS
Servo myservo;
// create servo object using the built-in Particle Servo Library
int servoPosClose = 30;
int servoPosOpen = 8;
int servoDelay = 240;


int servoPin = D0;  // declare variable for servo
int pos = 0;        // variable to keep track of the servo's position
int open_time = 5000;
int remaining = NULL;

// Borders
int low_q = 250;
int mid_q = 500;
int hi_q = 750;
// checks to ensure that the borders only open once
int check_low = 0;
int check_mid = 0;
int check_hi = 0;

// Essentially a multiplier & check
int timer = 0;

void setup()
{

  Serial.begin(9600); //Start the Serial port @ 9600 baud
  // seen_transactions = [];    // Declare seen_transactions to empty every reset
  // seen_count = 0;
  myservo.attach(servoPin);  //Initialize the servo attached to pin D0
  myservo.write(servoPosClose);        //set servo to furthest position

Particle.subscribe("hook-response/budget", handleBudgetReceived, MY_DEVICES); // listening for data that p cloud grabbed
// this is the subscriptions
//"hook-response/budget" defined in particle console

}

void loop()
{

getData(); // int reamining value set here

delay(30000);

}


void getData()
{
	// Publish an event to trigger the webhook - tell p cloud to go get budget
  Particle.publish("budget", PRIVATE);
  Serial.println("run getdata()");
}

// This function will handle data received back from the webhook
void handleBudgetReceived(const char *event, const char *data) {
  // Handle the integration response


  String budgetRemaining =  String( data );
  remaining = budgetRemaining.toInt();

  Serial.println("amount remaining is");
  Serial.println(remaining);

  if (remaining <= hi_q && check_hi == 0) {
     check_hi = 1;
     Serial.println("budget less than high");
     releaseCoin();
     delay(servoDelay*1.5);
   }

   // tracking the 500 line
   if (remaining <= mid_q && check_mid == 0) {
     check_mid = 1;
     Serial.println("budget less than mid");
     releaseCoin();
     delay(servoDelay*1.5);
   }

   // tracking the 250 line
   if (remaining <= low_q && check_low == 0) {
     check_low = 1;
     Serial.println("budget less than low");
     releaseCoin();
     delay(servoDelay*1.5);
   }

   if (remaining <= 0) {
     timer ++;
     Serial.println("over budget");
     releaseCoin();
     delay(servoDelay*1.5);
   }

}


int releaseCoin() {
  myservo.write(servoPosClose);
  delay(servoDelay);
  myservo.write(servoPosOpen);
  delay(servoDelay);
  myservo.write(servoPosClose);

}

Click to Expand