loading

How do you take a perfectly good beer or wine fridge and make it awesome? A good start is to have your refrigerator tell you how many bottles are in it, when the door is open or closed, and the temperature inside your fridge. What is even better is to have that information available to you at all times on your laptop, tablet, and phone. You can know when your 17-year-old nephew steals your beer. You can know just how many beers you drank last month. You can know if you need to restock while you are walking down the store aisle.

Thanks to new, simple-to-use Internet of Things (IoT) technologies, anyone can transform their beer or wine fridge into the envy of the neighborhood in a matter of minutes.

Project level: Beginner

Approximate time to complete: 30 Minutes

(increases linearly with amount of beer consumed)

Data points produced per month: 50,000

In this step-by-step tutorial, you will:

- Setup a Wii balance board as a scale to detect the number of bottles inside your refrigerator

- Wire up a door sensor to detect when your refrigerator door is open or closed

- Wire up a temperature sensor to capture the temperature inside your refrigerator

- Use a Raspberry Pi (http://www.raspberrypi.org) to stream this captured information to a cloud service

- Turn that information into your personal refrigerator dashboard that you can access on your laptop or mobile device using Initial State

- Setup your own beer inventory alerts (email+SMS)

What you'll need to complete this tutorial:

CanaKit Raspberry Pi 2 Ultimate Starter Kit or equivalent components:

Raspberry Pi 2 (or higher) w/ Raspbian loaded SD card

WiFi Adapter/Dongle (can use ethernet cord for hard connection instead. You also don't need this if you have a Raspberry Pi 3)

Breadboard

40-pin GPIO Ribbon Cable (can use 5 individual male-to-female jumper cables instead)

40-pin T-Shaped GPIO to Breadboard Interface Board (not necessary if using jumper cables)

2 Breadboard Tie Lines

2 10K Ohm Resistors (to use with the buttons; 5K-100K Ohms is generally a safe range)

HDMI cable + HDMI Monitor + Bluetooth Keyboard/Mouse unless you can SSH into your Pi

Wii Balance Board

Wii Fit Rechargeable Battery Pack

Bluetooth Adapter (Unless you have a Pi 3)

Waterproof DS18D20 Digital Temperature Sensor

Magnetic Contact Switch

3/8″ Felt Pads

Pencil

Compact Refrigerator

Initial State Account

Step 1: A Wii Balance Board Scale

The first step of this project is to find an easy, reliable way to detect how many bottles are in our refrigerator. If we assume that only bottles of the same type are inside the refrigerator, then we can use a scale to weigh the refrigerator and all of its contents. Once we know the weight of the refrigerator and the weight of a bottle, simple math will tell us how many bottles are present.

We need more than just a scale. We need a scale that we can control and read with a single-board computer like a Raspberry Pi. We need a scale that is either always on or turns on automatically on command. We need a scale that will fit neatly under our refrigerator without sticking out but has enough surface area to keep the refrigerator balanced and not wobbly.

The Wii Balance Board is almost the perfect solution (with two simple tweaks that we will discuss in a bit). Measuring in at 20.44" wide by 12.44" deep, the surface area of the Board fits nicely under a compact refrigerator, which typically measures 21.5" wide by 24" deep. Ideally, we would have a scale that is identical in width and depth as our refrigerator. The surface area of the Board provides just enough stability to work. The Wii Balance Board has a weight limit of 330 lbs, more than enough for a compact refrigerator full of beer/wine bottles.

The Wii Balance Board uses bluetooth for all communications. We will just need a bluetooth adapter plugged in to our Raspberry Pi and a little Python magic to control it.

Step 2: Bluetooth Setup

For Raspberry Pi 3

The Raspberry Pi 3 comes with bluetooth built on-board, all we need to communicate with the Wii Balance Board.

Power on your Pi (I am assuming you have already installed Raspbian and it boots up) and go to your Raspberry Pi terminal window. You can see the address of your bluetooth dongle with the "hcitool dev" command:

$ hcitool dev
Devices:
    hci0    00:1A:7D:DA:71:13 

Install the bluetooth modules that we will be using in our Python scripts:

$ sudo apt-get install python-bluetooth 

After installation completes, we are ready to connect and communicate with the Wii Balance Board. We will not be permanently pairing our Board with our Pi like we do with most of our bluetooth devices. The Wii Balance Board was never intended to be paired with anything other than a Wii, and permanent pairing proved to be quite the confusing challenge (if you find an elegant solution for permanent pairing of the Wii Balance Board, please let me know). Pairing will happen every time we run our Python script.


For Raspberry Pi 2

Raspberry Pi 2 does not come with a built-in bluetooth adapter, something we need to communicate with the Wii Balance Board. We will have to use one of our USB ports to plug in an adapter such as this inexpensive iAnder USB Bluetooth 4.0 Low Energy Adapter (http://www.amazon.com/gp/product/B00JN5Y5E0).

Once you have your adapter plugged in, go to your Raspberry Pi terminal window and install the bluetooth modules that we will be using in our Python scripts:

$ sudo apt-get install python-bluetooth bluez python-gobject 

You can see the address of your bluetooth dongle with the "hcitool dev" command:

$ hcitool dev
Devices:
    hci0    00:1A:7D:DA:71:13 

We are now ready to connect and communicate with the Wii Balance Board. We will not be permanently pairing our Board with our Pi like we do with most of our bluetooth devices. The Wii Balance Board was never intended to be paired with anything other than a Wii, and permanent pairing proved to be quite the confusing challenge (if you find an elegant solution for permanent pairing of the Wii Balance Board, please let me know). Pairing will happen every time we run our Python script.

Step 3: Reading the Scale

It is time to connect our Wii Balance Board to our Raspberry Pi. We will do this by modifying a version of Stavros Korokithakis' Gr8W8Upd8M8.py script (https://github.com/skorokithakis/gr8w8upd8m8). The python script we will be using is located at https://github.com/InitialState/beerfridge/blob/master/wiiboard_test.py. You can copy the contents of this file to a file you create on your Raspberry Pi or you can clone all of the python files we will be using for this entire project. Let's do the latter. Type the following commands into a terminal on your Raspberry Pi:

$ cd ~
$ git clone <a href="https://github.com/InitialState/beerfridge.git" rel="nofollow"> https://github.com/InitialState/beerfridge.git </a> beerfridge
Cloning into 'beerfridge'...
remote: Counting objects: 9, done.
remote: Compressing objects: 100% (7/7), done.
remote: Total 9 (delta 1), reused 6 (delta 1), pack-reused 0
Unpacking objects: 100% (9/9), done.
Checking connectivity... done. 

You should see four python files in the new beerfridge directory - beerfridge.py, switch_test.py, temperature_test.py, and wiiboard_test.py.

$ cd beerfridge
$ ls
README.md       beerfridge.py       switch_test.py      temperature_test.py wiiboard_test.py 

Run the wiiboard_test.py script to test communication and take weight readings from the Wii Balance Board:

$ sudo python wiiboard_test.py 

You will see the following response:

Discovering board...
Press the red sync button on the board now 

Remove the battery cover underneath the Board to locate the red sync button. Make sure you press the button within a few seconds of running the script or a timeout will occur. Once successful, you will see something similar to the following:

Found Wiiboard at address 00:23:CC:2E:E1:44
Trying to connect...
Connected to Wiiboard at address 00:23:CC:2E:E1:44
Wiiboard connected
ACK to data write received
84.9185297 lbs
84.8826412 lbs
84.9275927 lbs 

The wiiboard_test.py script is taking the number of weight measurements specified on line 10 and outputting the average:

# --------- User Settings ---------
WEIGHT_SAMPLES = 500
# ---------------------------------

You can play with this number by changing the value and re-running the script to see the variation in weight measured and time required for each measurement. Weigh yourself, weigh your dog, weigh whatever and see if the measurements make sense. To stop the script, press CTRL+C. You have now successfully converted your Wii Balance Board into a Raspberry Pi connected scale. Let's get it ready to start taking measurements of our refrigerator.

Step 4: Prepping and Placing the Wii Board

Nintendo assumed you would always power your Wii Balance Board with four AA batteries and included no AC power adapter. Having only battery power would be a non-starter for this project considering the inconvenience of getting to the battery pack once it is under an 80+ lb refrigerator. Luckily, there are several third-party adapters made for the Wii Balance Board that we can use to provide constant power from a wall outlet. The Wii Fit Rechargeable Battery Pack (http://www.amazon.com/gp/product/B001D21F58) is a perfect solution to our power problem. Replace the batteries with this battery pack, and plug the ac adapter into a wall outlet.

Having to pair the Wii Balance Board and Raspberry Pi every time we run our Python script presents a problem due to the location of the sync button. The sync button is inaccessible with a refrigerator sitting on top of it. We can fix this by making a hacky little lever using a pencil and three 3/8" felt pads as shown above. The rechargeable battery pack exposes the sync button to the underneath surface of the Board. Tape a pencil (or something similar) that spans from the sync button to the outside front of the Board. Stack three 3/8" felt pads (or something similar) on the center (ish) of the pencil to create a stationary pivot. Be careful to not expose too much of the pencil out from the Board as you don't want someone to accidentally kick it out. Flip the Board over and you can press the sync button by simply pressing down on the lever. Hacky but effective.

Depending on the surface that your refrigerator sits on, you may need to remove the rubber grip pads from the feet of the Board (the pads are simply stickers you can pry off). If you slide your refrigerator on a hardwood or tile floor to put it into place, the 3/8" felt pads can be placed on the Board's feet for easy sliding.

Final Destination

Place the empty refrigerator on top of the Wii Balance Board and plug the AC adapter from the battery pack into a wall outlet. Run the wiiboard_test.py script from a terminal on your Raspberry Pi to get the base weight of the refrigerator.

$ sudo python wiiboard_test.py
Discovering board...
Press the red sync button on the board now
Found Wiiboard at address 00:23:CC:2E:E1:44
Trying to connect...
Connected to Wiiboard at address 00:23:CC:2E:E1:44
Wiiboard connected
ACK to data write received
83.011212 lbs
82.962819 lbs
83.165323 lbs
83.068293 lbs
83.182738 lbs
82.981102 lbs 

The measurements are a bit noisy varying +/- .25 lbs. To get the base weight of your refrigerator, allow the script to run and take several measurements. Each measurement output is really 500 measurements (or whatever you changed the WEIGHT_SAMPLES variable to in the script). After 10,000 measurements, my refrigerator averaged 83.04 lbs according to my Wii Balance Board. Write down your refrigerator's base weight (we will use it in Part 4).

Fill your refrigerator up with as many bottles as you have (do not mix wine and beer bottles b/c they have very different weights; we are making the assumption that each bottle has approximately the same weight). Observe the average weight of the refrigerator plus the additional bottles. Subtract the base weight of the refrigerator from the full weight and divide this weight by the number of bottles in the refrigerator. This is the average weight of a bottle. I measured an average weight of 1.266 lbs for each bottle using 30 beer bottles. Write down your measured average bottle weight.

We have everything we need to detect the number of bottles of beer in our refrigerator. Next, let's add a couple of important sensors to our refrigerator and then put it all together.

Step 5: Wiring the Circuits

Now we are going to take advantage of one of the coolest aspects of the Raspberry Pi - the ability to wire up simple circuits and control them with simple software scripts. We will use a small breadboard, a couple of resistors, and a few jumper wires to connect a magnetic contact (door) sensor and a temperature sensor to our Pi. Once everything is wired up, we will run a couple of test scripts to ensure both sensors are working correctly before putting it all together in Part 4.

Shut down and unplug power from your Raspberry Pi before wiring up any circuit!!

Follow the diagram above to wire up both the door and the temperature sensor circuits. Both circuits are very simple. The door sensor circuit simply connects a 10K ohm pull-up resistor to GPIO 17 and one of the wires of the sensor while the second sensor wire is connected to GND. The temperature sensor circuit connects the power (red) wire to 3.3V, the ground (black or blue) wire to GND, and the data (yellow) wire to GPIO 4 and a pull-up resistor. Power on your Pi once the circuits are wired up and the ribbon cable is plugged into the Canakit cobbler and Pi.

Step 6: Door Sensor

First, let's test the door sensor to make sure it is working. We will run the following Python script to test the door sensor:

https://github.com/InitialState/beerfridge/blob/ma...

<p>import RPi.GPIO as io </p><p>io.setmode(io.BCM) 
doorPin = 17 
io.setup(doorPin, io.IN) </p><p>doorStatusPrev = -1</p><p>## Event loop
while True:
    doorStatus = io.input(doorPin)
    if doorStatus != doorStatusPrev:
        if doorStatus:
            print "Open"
        else:
            print "Closed"
    doorStatusPrev = doorStatus</p>

If you ran the "git clone https://github.com/InitialState/beerfridge.git beerfridge" command in Part 2, you already have this script on your Pi (otherwise, you need to create a switch_test.py script on your Pi from the above code). Run the following commands at a Pi terminal:

$ cd ~
$ cd beerfridge
$ sudo python switch_test.py
Open
Closed
Open
Closed
Open 

Once this script is running, touch the flat ends of the switch together and pull them apart. The script should write "Open" or "Closed" to the prompt each time you do this. Notice that the switch does not have to make contact to be detected as "Closed".

NOTE: The reason you need to prefix "sudo" to the command that runs this script is because access to the general purpose input/output (GPIO) pins requires super users access. sudo (pronounced soo-doo) is short for "super user do"

Use two-sided tape or mounting tape to connect the door sensor to your refrigerator door. Make sure the side with the connected wires is on the frame of the refrigerator and the side without wires is on the door itself. With the switch_test.py script running, make sure the sensor accurately detects when the door is open and closed. CTRL+C stops the script.

Step 7: Temperature Sensor

Next, let's test the temperature sensor. The current version of Raspbian as of the writing of this tutorial (kernel 3.18) requires an addition to your /boot/config.txt file for the Pi to communicate with the DS18B20. Run the following to edit this file:

$ sudo nano /boot/config.txt 

If the following line is not already in this file (if it is, it is likely at the bottom of the file), add it and save the file.

dtoverlay=w1-gpio,gpiopin=4 

Restart your Pi for the changes to take effect.

$ sudo reboot 

To start the temperature sensor read interface we need to run two commands. Go to a command prompt on your Pi or SSH into your Pi. Type the following commands:

$ sudo modprobe w1-gpio 
$ sudo modprobe w1-therm 

The output of your temperature sensor is now being written to a file on your Pi. To find that file:

$ cd /sys/bus/w1/devices 

In this directory, there will be a sub-directory that starts with “28-“. What comes after the “28-” is the serial number of your sensor. cd into that directory. Inside this directory, a file named w1_slave contains the output of your sensor. The contents of this file will look something like this (you can use nano to view the contents of the file):

a2 01 4b 46 7f ff 0e 10 d8 : crc=d8 YES 
a2 01 4b 46 7f ff 0e 10 d8 t=26125 

The number after “t=” is the number we want. This is the temperature in 1/1000 degrees Celsius (in the example above, the temperature is 26.125 C). We just need a simple Python script that reads this file and parses out that number.

Tip: if you don't see a sub-directory that starts with "28-" but see multiple sub-directories that start with "00-", you might have the resistor plugged into ground instead of into power. If your circuit is wired correctly and you continue to get "00-" sub-directories, you might have a bad temperature sensor.

Assuming you ran the "git clone https://github.com/InitialState/beerfridge.git beerfridge" command in Part 2, you have a script called temperature_test.py in your ~/beerfridge directory. https://github.com/InitialState/beerfridge.git

<p>import os<br>import glob
import time</p><p>os.system('modprobe w1-gpio')
os.system('modprobe w1-therm')</p><p>BASE_DIR = '/sys/bus/w1/devices/'
DEVICE_FOLDER = glob.glob(BASE_DIR + '28*')[0]
DEVICE_FILE = DEVICE_FOLDER + '/w1_slave'</p><p>def readTempRaw():
    f = open(DEVICE_FILE, 'r')
    lines = f.readlines()
    f.close()
    return lines</p><p>def readTemp():
    lines = readTempRaw()
    while lines[0].strip()[-3:] != 'YES':
        time.sleep(0.2)
        lines = readTempRaw()
    equalsPos = lines[1].find('t=')
    if equalsPos != -1:
        tempString = lines[1][equalsPos+2:]
        tempC = float(tempString) / 1000.0
        return tempC</p><p>while True:
    tempC = readTemp()
    tempF = tempC * 9.0 / 5.0 + 32.0
    print str(tempF) + " F"
    time.sleep(.5)</p>
This script will simply read the number after "t=" in the w1_slave file, convert that number to Fahrenheit, and return the result to the prompt. Run the following commands at a Pi terminal: 
$ cd ~
$ cd beerfridge
$ sudo python temperature_test.py
72.331 F
72.331 F
73.248 F
73.913 F
74.612 F 

If you are seeing valid temperature readings output to the prompt, then the temperature sensor is working. Heat up the sensor by holding it in your hand or cool it down by sticking it in ice (it is waterproof).

nce you are done playing, kill the script with CTRL+C. Place the end of the probe inside the refrigerator. I used longer jumper wires so that the door could close on the skinnier jumper wires instead of the thicker DS18B20 cable. We are now ready to put everything together.

Step 8: Initial State

We have the three components of our project together and working - the Wii Balance Board scale, door sensor, and temperature sensor. Remember, you can test each component with the wiiboard_test.py, sensor_test.py, and temperature_test.py scripts if you need to troubleshoot a problem. It is time to put everything together. The next step is to find a home for all of our beer/wine fridge data and turn that data into an easy-to-access dashboard.

Initial State

We want to stream all of our refrigerator data to a cloud service and have that service turn our data into a nice dashboard that we can access from our laptop or mobile device. Our data needs a destination. We will use Initial State as that destination.


Step 1: Register for Initial State Account Go to https://app.initialstate.com/#/register/ and create a new account. Step 2: Install the ISStreamer

Install the Initial State Python module onto your Pi:

At a command prompt (don’t forget to SSH into your Pi first), run the following command:

<p>$ cd /home/pi/<br>$ \curl -sSL https://get.initialstate.com/python -o - | sudo bash</p>

Security Note: The above command has some important anatomy that the user should be aware of. 1) There is a preceding \ before curl. This is important to ensure no alias of curl gets run if one was created. This helps mitigate risk of the command doing more than intended. 2) The command is a piped command, so when running, you are piping the output of a script that is being retrieved from https://get.initialstate.com/python into the command sudo bash. This is done to simplify installation, however, it should be noted that https is important here for helping ensure no man-in-the-middle manipulation of the install script, especially since the script is being run with elevated privileges. This is a common way to simplify install and setup, but if you are a little more weary there are some slightly less convenient alternatives: you can break the command out into two steps and investigate the bash script being downloaded from the curl command yourself to insure it's fidelity OR you can follow the pip instructions, you just wont get an automatically generated example script.

Step 3: Make some Automagic

After Step 2 you will see something similar to the following output to the screen:

<p>pi@raspberrypi ~ $ \curl -sSL https://get.initialstate.com/python -o - | sudo bash<br>Password:
Beginning ISStreamer Python Easy Installation!
This may take a couple minutes to install, grab some coffee :)
But don't forget to come back, I'll have questions later!</p><p>Found easy_install: setuptools 1.1.6
Found pip: pip 1.5.6 from /Library/Python/2.7/site-packages/pip-1.5.6- py2.7.egg (python 2.7)
pip major version: 1
pip minor version: 5
ISStreamer found, updating...
Requirement already up-to-date: ISStreamer in /Library/Python/2.7/site-packages
Cleaning up...
Do you want automagically get an example script? [y/N]</p>

(the output may be different and take longer if you have never installed the Initial State Python streaming module before) When prompted to automatically get an example script, type y. This will create a test script that we can run to ensure that we can stream data to Initial State from our Pi.

You will be prompted:

    Where do you want to save the example? [default: ./is_example.py]: 

You can either type a custom local path or hit enter to accept the default. You will be prompted for your username and password that you just created when you registered your Initial State account. Enter both and the installation will complete.

Step 4: Access Keys Let’s take a look at the example script that was created.

    $ nano is_example.py 

On line 15, you will see a line that starts with streamer = Streamer(bucket_ .... This lines creates a new data bucket named “Python Stream Example” and is associated with your account. This association happens because of the access_key=”...” parameter on that same line. That long series of letters and numbers is your Initial State account access key. If you go to your Initial State account in your web browser, click on your username in the top right, then go to “my account”, you will find that same access key at the bottom of the page under “Streaming Access Keys”.

Every time you create a data stream, that access key will direct that data stream to your account (so don’t share your key with anyone).

Step 5: Run the Example Run the test script to make sure we can create a data stream to your Initial State account.

Run the following:

    $ python is_example.py 

Step 6: Profit

Go back to your Initial State account in your web browser. A new data bucket called “Python Stream Example” should have shown up on the left in your log shelf (you may have to refresh the page). Click on this bucket and then click on the Waves icon to view the test data.

You will want to step through the Waves tutorial to familiarize yourself with how to use this data visualization tool.

Next, view the data in Tiles to see this same data in dashboard form.

You are now ready to start streaming real data from your refrigerator.

Step 9: The Final Script

Assuming you ran the "git clone https://github.com/InitialState/beerfridge.git beerfridge" command in Part 2, the final script that puts everything together is called beerfridge.py in your ~/beerfridge directory. (https://github.com/InitialState/beerfridge/blob/master/beerfridge.py)

A few settings need to be set in the script before you can run it. Open up beerfridge.py in your favorite text editor such as nano.

$ cd ~
$ cd beerfridge
$ nano beerfridge.py 

Near the top of this file, there is a User Settings section.

# --------- User Settings ---------
WEIGHT_SAMPLES = 1500
WEIGHT_BASE = 83.04
WEIGHT_BOTTLE = 1.266
FRIDGE_GETTING_LOW = 32
FRIDGE_EMPTY = 22
TEMPERATURE_DELAY = 60
TEMPERATURE_TOO_HIGH_F = 50
TEMPERATURE_TOO_LOW_F = 27
BUCKET_NAME = "Beer Fridge"
BUCKET_KEY = "INSERT_BUCKET_KEY_HERE"
ACCESS_KEY = "INSERT_ACCESS_KEY_HERE"
# --------------------------------- 

WEIGHT_SAMPLES sets how many weight measurements the Wii Balance Board takes and averages before computing how many bottles are present. 1500 seemed to provide a nice balance of accuracy while not taking too long to complete. Feel free to tweak this setting to your liking.

WEIGHT_BASE specifies the weight of your empty refrigerator in pounds. Use the value that you wrote down in the Part 2: Final Destination section.

WEIGHT_BOTTLE specifies the average weight of a bottle in pounds. Use the value that you wrote down in the Part 2: Final Destination section.

FRIDGE_GETTING_LOW specifies the number of bottles present that is deemed to be few enough that a warning status should be displayed.

FRIDGE_EMPTY specifies the number of bottles present that is deemed to be few enough that a severe warning status should be displayed.

TEMPERATURE_DELAY specifies the delay in seconds between temperature measurements. If you stream a temperature measurement every 60 seconds, this will be ~44,000 data points per month.

TEMPERATURE_TOO_HIGH_F specifies the temperature (in Fahrenheit) that is high enough that a warning status should be displayed.

TEMPERATURE_TOO_LOW_F specifies the temperature (in Fahrenheit) that is low enough that a warning status should be displayed.

BUCKET_NAME specifies the name of the data bucket that will show up in your Initial State account.

BUCKET_KEY should be set to a unique name. The BUCKET_KEY parameter allows you to append to an existing bucket or create a new bucket. Simply pick a name for this parameter (i.e. beerfridge1234).

ACCESS_KEY is your Initial State account key that you used in the Part 4: Initial State section.

Once you have specified each parameter in this section and saved your changes, you are ready to run the final script. Before we run the script, let's go through what it is going to do.

- At the start of the script, you will be asked to pair your Wii Balance Board with your Raspberry Pi. Use the lever that you hacked together in section Part 2: Hardware Tweaks to press the sync button when prompted.

- Once the script is running, the number of bottles present in your refrigerator will be calculated only when the door closes. This value will be streamed to your Initial State account when it changes.

- Every time a bottle is removed from your refrigerator, a bottle removed event will be streamed to your Initial State account.

- Every time the door opens or closes, a door status event will be streamed to your Initial State account.

- The temperature inside your refrigerator will be streamed to your Initial State account at the interval specified by TEMPERATURE_DELAY.

Run the script to start the magic.

$ sudo python beerfridge.py

Step 10: Your Personal Dashboard

Go to your Initial State account and click on the new data bucket with the name corresponding to the BUCKET_NAME parameter (i.e. Beer Fridge). Click on Tiles to view your beer/wine fridge dashboard. You should see four tiles once you have opened up your refrigerator and removed bottles from it - Temperature(F), Bottles Present, Bottle Removed, and Door. Open and close the door, remove bottles, and watch the dashboard update in real-time. This dashboard gives you the ability to see what is happening with your refrigerator at-a-glance, very handy when you are at the store or out-of-town.

If you want to know how many bottles have been removed since you made your beer/wine fridge awesome, you can see that in the Bottle Removed tile. In my dashboard above, I drank 4 bottles of beer by the time I took that screenshot. I can see that I have 39 bottles left in my refrigerator, and the door is currently closed. It is interesting to see how much my temperature changes. The temperature fluctuates between 36 and 43 degrees regularly. The LED on my refrigerator tells me that the temperature is constant at 39 degrees. In other words, my refrigerator lies!

Switch to the Waves visualization to better see the history of your refrigerator data. With Waves you can take measurements and dig through your data to see when things happened. I can see that I drank two beers, 91 minutes apart on May 25 at 7:57 pm and 9:28 pm.

I can see that while I was out-of-town on May 28, my roommate opened up my beer fridge at 1 am only to realize that those new electronic gizmos sitting near the refrigerator might just be snooping on his beer thievery habits. He thought better of taking a beer and simply closed the door. Ha!

<p>Awesome project! My one questions is how/if you compensate for canned beer? I figure it could be written into the code to measure a certain range of weight changes? </p>
<p>Thanks! I haven't tried that yet, but if you figure out a way then I'd love to see it! I'm pretty sure that cans and bottles should both register as long as they are both 12oz. I believe the problem comes into play when you start having different sizes (Bombers, Growlers, etc...)</p>
whats the fridge model?
<p>Here you go: http://www.lowes.com/pd/Frigidaire-4-6-cu-ft-Stainless-Steel-Freestanding-Beverage-Center/50160175</p>

About This Instructable

7,321views

160favorites

License:

More by JeffreyLoucks:Update a Real Time Dashboard with Google Sheets Create a Scoreboard with the DO Button Create an Interactive Fitbit Dashboard With IFTTT 
Add instructable to: