Published October 31, 2022 © GPL3+

Using Fitbit to Make Scary Movies Scarier

By using my wife's Fitbit, I trigger different scary events in the room based on her heart rate.

IntermediateFull instructions provided4 hours104

Using Fitbit to Make Scary Movies Scarier

Things used in this project

Hardware components

Arduino UNO

Servo Module (Generic)

Smart Dimmer

Story

The Project

One of the staples of Halloween season is to binge watch scary movies. When the stars really align and the phone rings right after The Ring ends, or lightning strikes in the distance right as the killer appears, it adds an unparalleled exciting ambience. But, what if things could happen in the room during scary movies but not by chance? By using a Fitbit, I could monitor my wife's heart rate and, as the scary part of horror movies increased her heart rate, I could make things happen in the room accordingly. What's more in the Halloween spirit than going to unnecessary lengths to scare people?

Step 1: Chattin' With Fitbit

First we have to be able to actually pull data from the Fitbit, so we need to bring over some freshly baked cookies and kickoff our communication. Start by going to https://dev.fitbit.com/apps/new to register a new app.

You'll want to login as the account associated with the Fitbit. This saves a LOT of hassle.

The main field to note is Oauth 2.0 Application type, which should be set to Personal. For your Redirect URL, you can just use http://localhost. All the names and URLs can be filled in with anything, since it's a personal app and you don't exactly need to write a Privacy Policy for yourself.

Now click the OAuth 2.0 tutorial page. This is where you're going to get your access token, as well as where you can easily see your client ID.

Click the authorization URL they generate for you. You'll set the permissions you want, and then when you press allow you'll see a "This site can't be reached" page. This is completely fine and expected. Just copy that URL and go back in to the tutorial page. Paste it into the box under Parse response, and under step 3 you can see your access token. This is all you need to get going with the next steps, where we get Fitbit data and use it to do fun things.

Step 2: Python Magic

Python is sorcery. This is one of my first encounters with Python ever and it just kind of works right away. To add anything you don't have, you just pip install it and it just works. I'm using Kasa smart dimmers so that's what I have setup in the code. Depending what you already have, you'll likely need to run the following:

pip install python-kasa

You'll also likely need to pip install playsound as well.

I've noted in the code what needs added in, but you can drop in your access token and user id from the Fitbit step in to kick things off.

The code is included. I'm certain that there's room for code improvements, but this isn't exactly an enterprise application. We're just here to have some fun with scary movies for Halloween time.

Here's how it works - every 30 seconds, we pull data from Fitbit. We look at the most recent point of data we get and see if it's new so that we don't just spam the same event over and over. As it turns out, the Fitbit will only sync data every 15 minutes, but, in standard programmer fashion, I saw that as a feature. It's no fun if scary things are constantly triggering, because you know they're coming and you get desensitized to it. Waiting between occurrences was something I wanted to do anyway, so this just kind of made that happen in a different way.

I usually like to randomize things, but in this case I decided to have different events trigger based on certain heart rates. That way the scariness would escalate as her heart rate did, and as an added for-funzies bonus I could know what my wife's heart rate was during the movie.

Beyond messing with the lights, I added in spooky sounds. To add these in, put some sound files into the same directory as your python file and it'll just work out of the box by referencing the sound file's name (eg. 'scream1.mp3').

Step 3: Room Interactions

Controlling lights and playing sounds is a solid start, but I wanted things to physically happen in the room. Cue Arduino.

I thought "what would be a scary thing to have happen in the room" and the conclusion I came to was that something randomly falling would do the trick. My setup was a bit comical, but if it works it works, right? I used a toilet paper roll around a servo that can rotate 360 degrees and attached a string to it. I ran the string to a stand of mine and set it slightly off balance to make it easier to trigger. This way, the servo pulled the string around the toilet paper roll and caused the stand to fall.

Since I only had 1 Arduino interaction setup, I went ahead and just triggered it as soon as there was something sent over serial. However, it'd be very easy to run different functions based on the serial message.

I also included a failsafe where the Arduino event would trigger after a set amount of time if it hadn't happened already, because not having things fall during a scary movie sounds tragic.

The code for Arduino is included as well.

Step 4: Break Out the Popcorn!

The lights are ready to flicker and dim, creepy sounds are ready to roll, and a surprise crash is ready to rock. It's time to start a scary movie and hope it gets spooky enough to trigger some effects.

Hopefully you can find something scary enough, or someone scared-y enough to make this work, but if not the code is easily modifiable such that you can make it run regardless of the Fitbit interaction.

It's definitely a lot of fun to have scary stuff happen in the room during the movies, and I'm more than a little curious what people can come up with to add onto this! Enjoy!

Code

import time
import requests
import sys
import oauth2 as oauth
import serial
import asyncio
from kasa import SmartDimmer
from datetime import datetime, timedelta
from playsound import playsound


ser = serial.Serial('<ADD SERIAL PORT HERE (eg. COM5)>', 9600)

#To get new access token, click the tutorial link in the api - https://dev.fitbit.com/apps
access_token ='<TOKEN HERE>'
user_id = '<USER ID HERE>'

p = SmartDimmer("<PUT YOUR DIMMER'S IP ADDRESS HERE>")

minuteAdjustment = timedelta(minutes=15)
mostRecentTime = datetime.now() - minuteAdjustment #just a starting place

async def setBrightness(brightness):
    await p.update()  # Request the update
    print(p.alias)  # Print out the alias
    await p.set_brightness(brightness)

async def turnOn(isOn):
	await p.update()  # Request the update
	print(p.alias)  # Print out the alias
	if isOn:
		p.turn_on
	else:
		p.turn_off

def getFitbitData():
	try:
		date = datetime.now()
		start_time = date - minuteAdjustment
		end_time = date


		strDate = date.strftime("%Y-%m-%d")
		strStart = start_time.strftime("%H:%M")
		strEnd = end_time.strftime("%H:%M")


		hr_request = requests.get('https://api.fitbit.com/1/user/'+ user_id +'/activities/heart/date/' + strDate  + '/1d/1sec/time/' + strStart + '/' + strEnd + '.json', headers={'Authorization': 'Bearer ' + access_token})
		print("Status Code "+str(hr_request.status_code))
        #This means you're spamming fitbit and they don't like it - time to take a break
		if hr_request.status_code == 429:
			print("Retry after" + hr_request.headers["Retry-After"])
			time.sleep(int(hr_request.headers["Retry-After"]))
		# Store intraday heart data
		intraday_hr_data = hr_request.json()['activities-heart-intraday']['dataset']
		print(intraday_hr_data)
		if len(intraday_hr_data)>0:
			val = intraday_hr_data[len(intraday_hr_data)-1]['value']
			eventTime = intraday_hr_data[len(intraday_hr_data)-1]['time']	#don't trigger the same event over and over
			print(eventTime)
			global mostRecentTime
			print(mostRecentTime)
			if eventTime != mostRecentTime:
				mostRecentTime = eventTime
				print(val)
				ser.write(val)

				#Non-random - that way we also get to know the heart rate exactly for fun :)  (all higher than resting, tho)
				#Scurry sounds -
				if val >90:
					ser.write(val.encode())
				if val <80:
					asyncio.run(setBrightness(30))
					print("Option 1")
				else:
					if val <85:
						asyncio.run(setBrightness(15))
						print("Option 2")
					else:
						if val <90:
							asyncio.run(setBrightness(5))
							print("Option 3")
                #You'll obviously need to adjust this based on the sounds you've picked
				if val == 94 or val == 84 or val == 104:
					playsound('blehNoise.mp3')
					print("Option 4")
				if val == 95 or val == 85 or val == 105:
					playsound('Straw Squeak.mp3')
					print("Option 5")
				if val == 96 or val == 86 or val == 106:
					playsound('scream1.mp3')
					print("Option 6")
				if val == 97 or val == 87 or val == 107:
					playsound('scream2.mp3')
					print("Option 7")
				if val == 102 or val == 88 or val == 108:
					playsound('Swoosh.mp3')
					print("Option 8")
				if val >98 and val != 105:
					print("Option 9")
                    #Flicker the lights (this one is fun)
					asyncio.run(setBrightness(1))
					time.sleep(1)
					asyncio.run(setBrightness(100))
					time.sleep(1)
					asyncio.run(setBrightness(1))
					time.sleep(1)
					asyncio.run(setBrightness(100))
					time.sleep(1)
					asyncio.run(setBrightness(1))
				if val == 101:
					playsound('weKillU.mp3')
					print("Option 10")
				if val == 105:
					asyncio.run(turnOn(False))
					print("Option 11")
	except Exception as e: print(e)
		#nothing needs to happen - just don't want the program to stop running



#Loop indefinitely, fetching fitbit data every 30 seconds
while True:
	getFitbitData()
	time.sleep(30)

#include <Servo.h>

Servo name_servo;

int servo_position = 0;
int incomingByte = 0;   // for incoming serial data
bool hasRun = false;
long triggerTime;

void setup() {

  Serial.begin (9600);
  name_servo.attach (3);
  triggerTime= millis()+(1000L*60L*90L);  //Failsafe - ensure the servo is triggered at least once regardless of fitbit
}

void loop() {

  //Since there's only 1 option, if anything comes in on serial, we trigger the event
  if (Serial.available() > 0) {
    // read the incoming byte:
    incomingByte = Serial.read();
  
    //Decode from python - 
    Serial.print("I received: ");
    Serial.println(incomingByte, DEC);

    if(!hasRun)
      runServo();
  }
  
  //The failsafe
  if(!hasRun && millis()>=triggerTime){
    runServo();
  }
}

void runServo(){

  //Spin the servo
  for (servo_position = 0; servo_position <=360; servo_position +=1){
    name_servo.write(servo_position);
    delay(10);
  }
  hasRun=true;
}