Danny Peters

Creating a Motion Sensing Light with a Spark Core - Revisited with DO IFTTT integration

Fri, 24 Apr 2015 13:00:00 +0000

original article

New in this Artice: Code Review and Adding in IFTTT Do functions.

Guide

New Code
IFTTT Do Functions
Conclusion

New Code

After posting about my experience on the spark.io forums, now particle.io. I received some great feedback and made some changes to my code to make it run smoother and decided to add the ability to toggle the lights on and off for a set amount of time. One of the big changes here are moving some functionality to seperate functions. Including functions to set the lights off (set_light_off) for a set amount of time and then a function to overwrite that setting and turn the lights on (set_light_on). Another change was to remove the delay from the loop, this removes the noticable lag between triggering the motion sensor and the light turning on. Also as recommend in the thread, there is now a flag can_turn_light_on to avoid banging away on the digital pin to write it high every time it loops. The final code that I am running at home is shown below. You can view the original article to see how the circuit is laid out as well as the supplies used.

// functions declarations
void trigger_light_on(void);
void light_off(void);
int set_light_on(String args);
int set_light_off(String args);

// variable declarations
int ledPin = D6;
volatile int state = LOW;
unsigned long current_time;
volatile unsigned long set_time;
volatile bool hold_light_off = false;
volatile bool can_turn_light_on = false;

// CONSTANTS
#define FIFTEEN_MIN_MILLIS (15 * 60 * 1000)
#define THREE_HOURS_MILLIS (3 * 60 * 60 * 1000)

void setup(){
  pinMode(D0, INPUT_PULLDOWN );
  pinMode(ledPin, OUTPUT);
  attachInterrupt(D0, trigger_light_on, RISING);
  set_time = millis(); 
  Spark.function("LightsOn", set_light_on);
  Spark.function("LightsOff", set_light_off);
}

void loop(){
  if(can_turn_light_on){
    set_time = millis();
    state = HIGH;
    digitalWrite(ledPin, state);
    can_turn_light_on = false;
  }
  current_time = millis();
  if( set_time+FIFTEEN_MIN_MILLIS < current_time ){
    light_off();
    hold_light_off = false;
  }
}

void trigger_light_on(){
  if (!hold_light_off){
    set_light_on("triggered");
  }
}

void light_off(){
  state = LOW;
  digitalWrite(ledPin, state);
}



int set_light_on(String args){
    if(args != "triggered"){
        hold_light_off = false;
    }
  can_turn_light_on = true;
  return 1;
}

int set_light_off(String args){
  hold_light_off = true;
  set_time = millis() + THREE_HOURS_MILLIS;
  light_off();
  return 1;
}

IFTTT Do Functions

I am using the Do app for iOS which provides access to spark functions. One of the keys to having access to your functions is getting them to compile correctly. To do this I had to make sure that my functions returned a value and that they took some string arguments. I am not really sure why this is required and would love some feedback on that, but I digress. below is my code striped to a single function and only the important parts. First, we have are declarations which must have a return type and take arguments. Next, in setup we must declare our function for use by the Spark API using Spark.function(call_name, function);. In this case function is whatever the name of the function you want is call is, and call_name is what you will show external systems. Sample code is shown below

// functions declarations
void light_off(void);
int set_light_off(String args);

// variable declarations
int ledPin = D6;
volatile int state = HIGH;

void setup(){
  pinMode(D0, INPUT_PULLDOWN );
  pinMode(ledPin, OUTPUT);
  Spark.function("LightsOff", set_light_off);
}

void loop(){
  light_off();
}

void light_off(){
  state = LOW;
  digitalWrite(ledPin, state);
}

int set_light_off(String args){
  light_off();
  return 1;
}

To test your function from the command line you can install the spark-cli. And use the following call assuming your spark core is called sample_core

spark call sample_core LightsOff

the key here is to use the function call name you defined as the first argument for Spark.function in setup.

Now to make things even more interesting you can use the Do app from IFTTT. The setup here is insanely easy and very useful.

Inside the App, Configure IFTTT to use the spark channel
Select Spark under Channels
Select Create a New Recipe
Select Call a Function
Select your core and the proper function in this case LightsOff on “sample_core”
provide an unused input.

now you should be able to turn the light off from your phone or anywhere you can trigger the ifttt event!

Conclusion

Nice little update with some cleaner, more readable code, and added functionaility. Really nice to have the ability to turn my lights out from my phone before starting a movie and have them stay off.

###Congratulations you can now set your light on or off from your phone. 🍻

Fixing a Mac's System Time

Mon, 09 Feb 2015 13:00:00 +0000

Quick guide to help others who have a mac who can’t seem to keep the system time correct.

The Problem

Recently at work we were deploying a update to our rails app. One of the requirements was that the app appear offline while our payment processor was offline for a server changeover.

This was all well and good, and not any big deal to implenment in the rails code, but we did notice something fishy. When we checked the system clock for the Mac server it was over a minute off of the current time of everything else we checked…

Use date to check the system clock

The Solution

Using the follow command we were able to reset the system clock for the mac from the terminal and have our downtime be exactly when we thought it would be. This uses Apple’s time server to correctly set the time. Also when changed it shows the the correct offset, in this case 75 seconds.

sudo ntpdate -u time.apple.com

And here is a screenshot from our actual server.

Congratulations you can set a clock. 🍻

Creating a Motion Sensing Light with a Spark Core

Sat, 24 Jan 2015 13:00:00 +0000

A nice guide to a simple IoT device for controlling lights. Below is a gif showing the optional connected led coming on due to the detected motion.

Supplies

Here is a list of all the things I used, hopefully you already have some of this stuff, or possbily you already have a relay you can use. Otherwise, I strongly recommend the power tail switch to avoid having to mess with life threatening power.

1. Spark Core

2. Power Tail switch

3. Human Sensor (HC-SR501)

4. Female to Male Jumper Cables

5. Preformed cables

Hardware Set Up

Here is a quick sketched layout showing how I hooked up the hardward. In this picture, the 3 pin LED is suppose to represent the HC-SR501.

Note that I had to connect HC-SR501 to the Vin of the Spark Core because the it actually wants to run at 5v.

Here is my actual layout of the electronics.

Code

There’s actually some pretty cool stuff going on here. First off, realize that the out pin for the HC-SR501 (data sheet) has to be set to a INPUT_PULLDOWN because it does not pull down otherwise and would never properly trigger the interrupt.

Also we use the idea of a interrupt, which is something close to my Computer Engineering heart, so instead of constantly polling the pin to see if the state has changed. The pin will let us know when the state changes and fire off our function light_on when the state is RISING (spark doc).

Next, to handle turning the light off after 15 mins we use the millis() function. This function returns the number of milliseconds since the spark core was powered on. So, using a two second delay in our loop() function, we are checking that our set_time + 15 mins is less then the current time every two seconds.

Finally, in our light_on() function we make sure to reset the set_time incase the interrupt is triggered again while it is areadly on.

// functions
void light_on(void);
void light_off(void);
// variables
int ledPin = D6;
volatile int state = LOW;
unsigned long current_time;
volatile unsigned long set_time;

// 15 mins
#define FIFTEEN_MIN_MILLIS (15 * 60 * 1000)

void setup()
{
  pinMode(D0, INPUT_PULLDOWN );
  pinMode(ledPin, OUTPUT);
  attachInterrupt(D0, light_on, RISING);
  set_time = millis(); 
}

void loop()
{
  digitalWrite(ledPin, state);
  current_time = millis();
  if( set_time+FIFTEEN_MIN_MILLIS < current_time ){
    light_off();   
  }
  delay(2000);
}

void light_on(){
 set_time = millis();
 state = HIGH;
}

void light_off(){
 set_time = set_time-FIFTEEN_MIN_MILLIS;
 state = LOW;
}

Conclusion

Quite simple and really easy to get set up once you have all the parts. Also its nice to have something home automated that actually is easier to use. Before I had the lights controlled by a button on a iOS app. While cool, this became impractical quick as it was a bigger inconvenience then this simple implementation.

I do plan to add back in the functionality to turn the light off with either a siri command as sometimes you want the lights out when you watch a movie, but I’ll save that for either another blog post or an update to this one.

###Congratulations you never have to turn a light on or off again. 🍻

Deploying Jekyll With Capistrano 3 to a Digital Ocean Droplet

Thu, 22 Jan 2015 19:27:00 +0000

First post here, but yeah I thought I’d document how I got this blog up and running on a Droplet running Ubuntu 14.04.

Guide

Blog Set Up
Server (Droplet) Set Up
Capistrano 3 Set Up
Deploying

Blog Set Up

To get started with the blog, we are using awesome jekyll

now I really like to use rvm so I will assume that going forward, so if you need help setting it up locally follow that link.

gem istall jekyll

Now to get the most basic blog up and going, you can use

  $ gem install jekyll
~ $ jekyll new blog
~ $ cd blog
~/blog $ jekyll serve
# => Now browse to http://localhost:4000

and boom! We are now serving the basic jekyll blog locally on port 4000.

To set up our basic git repo for github we can use the following commands.

be sure to change your origin to the repo you create on github

$ git init
$ git add . # add all files
$ git commit -m "First Commit" # commit message
$ git remote add origin git@github.com:danmanstx/blog.git
$ git push -u origin master

Server (Droplet) Set Up

To begin, I had a preconfigued droplet with a few rails apps aready on it and rvm (guide). In this case the droplet was the 1gb for $10/month, and this seems more than enough for running 3 rails apps and hosting this blog.

To get multiple users set up and going on your droplet use this guide. Following along, my new user is named rails and I just run the apps straight out of folders in its home directory for convenience. However Common practice is to use something like www

So to start, I created another folder for my blog as the rails user, and set up some needed default folders.

# switch to rails user if you aren't already
$ sudo su - rails
~ $ mkdir blog
~ $ cd blog
~/blog $ mkdir shared
~/blog $ mkdir shared/log

Just be sure this user doesn’t have root access and only owns these folders.

Next, I got NGINX installed.

sudo apt-get install nginx

simple enough right? Well, now we need to configure it. I don’t believe i changed much in this file /etc/nginx/nginx.conf, but here it is.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
user www-data;
worker_processes 4;
pid /run/nginx.pid;

events {
  worker_connections 768;
  # multi_accept on;
}

http {
  # Basic Setting
  sendfile on;
  tcp_nopush on;
  tcp_nodelay on;
  keepalive_timeout 65;
  types_hash_max_size 2048;

  server_names_hash_bucket_size 64;
  # server_name_in_redirect off;

  include /etc/nginx/mime.types;
  default_type application/octet-stream;

  # SSL Setting
  ssl_protocols TLSv1 TLSv1.1 TLSv1.2; # Dropping SSLv3, ref: POODLE
  ssl_prefer_server_ciphers on;

  # Logging Setting
  access_log /var/log/nginx/access.log;
  error_log /var/log/nginx/error.log;

  # Gzip Setting
  gzip on;
  gzip_disable "msie6";

  # Virtual Host Config
  include /etc/nginx/conf.d/*.conf;
  include /etc/nginx/sites-enabled/*;
}

However, I did have to create a site configuration file in sites-available using the following command:

sudo vi /etc/nginx/sites-available/<your_site_name>.conf

be sure to note that you probably don’t want to use <your_site_name>

Next, I just created a basic server block that looks at a directory named for my blog in the rails user’s home directory.

1
2
3
4
5
6
7
8
9
10
11
12
server {
  listen 80;
  server_name dannypeters.me www.dannypeters.me;

  access_log /home/rails/blog/shared/log/nginx.access.log;
  error_log /home/rails/blog/shared/log/nginx.access.log;

  location / {
    root /home/rails/blog/current/public/;
    index index.html index.htm;
  }
}

Now to follow nginx convention i symlinked this config file to the sites-enabled folder

ln -s /etc/nginx/sites-available/<your_site_name>.conf /etc/nginx/sites-enabled/<your_site_name>.conf

Capistrano Set Up

this is done on your local machine

To begin we need to make sure that Capistrano is installed, if not

gem install capistrano

and then set up a Gemfile to monitor the gems we will be using.

~/blog $ vi Gemfile

1
2
3
4
5
6
7
8
source 'https://rubygems.org'

ruby '2.1.5'
gem 'jekyll'
gem 'capistrano-rvm'
gem 'capistrano-bundler'

gem 'rvm1-capistrano3', require: false

Next, we need to capify our blog. Just run the following command from your blog directory.

with capistrano 2.x this command was capify

$ cap install

Now we need to edit some of the files it created.

First, Capfile, we need to add require 'rvm1/capistrano3' because we are using rvm, and also uncomment some things.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# Load DSL and set up stages
require 'capistrano/setup'

# Include default deployment tasks
require 'capistrano/deploy'

require 'capistrano/rvm'
require 'rvm1/capistrano3'
# require 'capistrano/rbenv'
# require 'capistrano/chruby'
require 'capistrano/bundler'
# require 'capistrano/rails/assets'
# require 'capistrano/rails/migrations'
# require 'capistrano/passenger'

# Load custom tasks from `lib/capistrano/tasks' if you have any defined
Dir.glob('lib/capistrano/tasks/*.rake').each { |r| import r }

Next, Our config/production.rb file, be sure to edit the server line with your settings.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
set :stage, :production

# Extended Server Syntax
# ======================
# This can be used to drop a more detailed server definition into the
# server list. The second argument is a, or duck-types, Hash and is
# used to set extended properties on the server.

server 'xxx.xxx.xxx.xxx', user: 'rails', port: 22, roles: %w{web app}

set :bundle_binstubs, nil

set :bundle_flags, '--deployment --quiet'
set :rvm_type, :user


SSHKit.config.command_map[:rake]  = "bundle exec rake"
SSHKit.config.command_map[:rails] = "bundle exec rails"

namespace :deploy do

  desc "Restart application"
  task :restart do
    on roles(:app), in: :sequence, wait: 5 do
      # execute :touch, release_path.join("tmp/restart.txt")
    end
  end

  after :finishing, "deploy:cleanup"

end

Finally, We need to set up the deploy.rb file.

The key here is this bit of code which builds your jekyll blog into the public folder so you don’t need to compile and commit before each deploy. It’s my build_public task below.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
# config valid only for Capistrano 3.1
# lock '3.2.1'

set :application, 'blog'
set :repo_url, "git@github.com:danmanstx/#{fetch(:application)}.git"

# Default deploy_to directory is /var/www/my_app
set :deploy_to, "/home/rails/#{fetch(:application)}"

# Default value for :scm is :git
set :scm, :git

# Default value for :log_level is :debug
set :log_level, :debug

# Default value for keep_releases is 5
set :keep_releases, 5

namespace :deploy do

  desc 'Restart application'
  task :restart do
    on roles(:app), in: :sequence, wait: 5 do
      # Your restart mechanism here, for example:
      # execute :touch, release_path.join('tmp/restart.txt')
    end
  end

  before :restart, :build_public do
    on roles(:app) do
      within release_path do
        execute '/home/rails/.rvm/gems/ruby-2.1.5/wrappers/jekyll',  "build --destination public"
      end
    end
  end

  after :publishing, :restart

end

At fist I was getting the following error:

remote: /usr/bin/env: ruby_executable_hooks: No such file or directory

So I switched from using the following command calling jekyll directly and ended up using the rvm wrapper, with help from this stack overflow answer

1
execute :jekyll, "build --destination public"`

became:

1
execute '/home/rails/.rvm/gems/ruby-2.1.5/wrappers/jekyll',  "build --destination public"

Deploying

Finally, any new post or updates can be commited and deployed using the following commands.

$ git add .
$ git commit -m "new post"
$ git push
$ cap production deploy

###Congratulations you are now a blogger. 🍻