hacklet 0.5.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+
+0.5.0 / 2013-05-30
+==================
+
+ * Can commission new modlets, read data from them and control them
+   through a simple utility program. This is the minimal required in
+   order to be useful.

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in hacklet.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Matt Colyer
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,50 @@
+# Hacklet [![Build Status](https://travis-ci.org/mcolyer/hacklet.png)](https://travis-ci.org/mcolyer/hacklet)
+
+A library, written in Ruby, for controlling the [Modlet] (smart) outlet.
+
+If you haven't heard of the Modlet before, it's a smart outlet cover
+which allows you to convert any outlet into your house into a smart
+outlet. This means that you can control whether a plug is on or off and
+you can also determine how much energy it's using with a sampling
+frequency of 10 seconds.
+
+There are alot of other similar products but this is the first one that
+I've see that [costs $50][amazon] and includes control as well as monitoring of
+the independent sockets.
+
+## Why
+
+So why write another client?
+
+Unfortunately the client software included with the device isn't
+available on all platforms (Linux) and it's pretty heavyweight for what
+it does.
+
+The goal of this project is provide all the same functionality of the
+bundled client but do it in a lightweight manner, to provide total
+control and availability of the data.
+
+## Getting Started
+
+Right now things are pretty rough and won't work without modifying
+`bin/hacklet`. Eventually the `hacklet` script will allow for specifying
+which Modlet and socket you'd like to read or control.
+
+```
+bundle install
+sudo modprobe ftdi_sio vendor=0x0403 product=0x8c81
+bin/hacklet
+```
+
+## Status
+
+* [X] Reading Data
+* [X] Controlling Sockets
+* [X] Multiple Modlet Support
+* [X] Commissioning New Devices
+* [X] Useful utility
+* [ ] Set time on New Devices
+* [ ] Documentation
+
+[Modlet]: http://themodlet.com
+[amazon]: http://www.amazon.com/ThinkEco-TE1010-Modlet-Starter-White/dp/B00AAT43OA/

data/Rakefile

@@ -0,0 +1,11 @@
+load "Rakefile.base"
+
+desc "Run the tests"
+task :test => :spec
+
+# desc "Run the server"
+# task :run do
+# end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new

data/Rakefile.base

@@ -0,0 +1,57 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+module Bundler
+  class GemHelper
+    # Override Bundler's concept of release.
+    def release_gem
+      with_fixed_editor {
+        guard_on_master_branch
+        return if already_tagged?
+        build_gem
+        edit_changelog
+        sh "git commit --allow-empty -a -m 'Release #{version_tag}'"
+        tag_version {
+          # Bundler's git_push pushes all branches. Let's restrict it
+          # to only the master branch since we also ensure that you
+          # always release from the master branch.
+          perform_git_push "origin master --tags"
+        }
+      }
+    end
+    def with_fixed_editor
+      editor = ENV['EDITOR'] || ""
+      abort "You must set an EDITOR to edit the changelog" if editor.empty?
+      swaps = {
+        "mate" => "mate -w",
+        "subl" => "subl -w"
+      }
+      begin
+        ENV['EDITOR'] = swaps.fetch(editor, editor)
+        yield
+      ensure
+        ENV['EDITOR'] = editor
+      end
+    end
+    def guard_on_master_branch
+      unless `git branch` =~ /^\* master$/
+        abort "You must be on the master branch to release."
+      end
+    end
+    def edit_changelog
+      unless `which git-changelog`.empty?
+        #sh "git-changelog"
+      else
+        abort "git-changelog isn't found. Install it with `brew install git-extras`"
+      end
+    end
+  end
+end
+
+desc "Run all tests"
+task :default => :test
+
+desc "Update Rakefile.base"
+task :selfupdate do
+  sh "curl -sO https://raw.github.com/rcarver/gembase/master/Rakefile.base"
+end

data/bin/hacklet

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'hacklet'
+require 'logger'
+
+logger = Logger.new(STDOUT)
+logger.level = Logger::INFO
+dongle = Hacklet::Dongle.new(logger)
+
+Hacklet::Command.run(dongle, ARGV)

data/hacklet.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hacklet/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "hacklet"
+  gem.version       = Hacklet::VERSION
+  gem.authors       = ["Matt Colyer"]
+  gem.email         = ["matt@colyer.name"]
+  gem.description   = %q{An Open Source client for the Modlet (smart) outlet}
+  gem.summary       = %q{A daemon, written in ruby, for controlling the Modlet outlet.}
+  gem.homepage      = "http://github.com/mcolyer/hacklet"
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "serialport", "~>1.1.0"
+  gem.add_dependency "bindata", "~>1.5.0"
+  gem.add_dependency "slop", "~>3.4.0"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rspec"
+end

data/lib/hacklet.rb

@@ -0,0 +1,4 @@
+require "hacklet/version"
+require "hacklet/messages"
+require "hacklet/dongle"
+require "hacklet/command"

data/lib/hacklet/command.rb

@@ -0,0 +1,83 @@
+require 'slop'
+require 'logger'
+
+module Hacklet
+  class Command
+    def self.run(dongle, arguments)
+      Slop.parse(arguments, :help => true) do
+        command 'on', :banner => 'Turn on the specifed socket' do
+          on :n, :network=, 'The network id (ex. 0x1234)', :required => true
+          on :s, :socket=, 'The socket id (ex. 0)', :required => true
+          on :d, :debug, 'Enables debug logging' do
+            dongle.logger.level = Logger::DEBUG
+          end
+
+          run do |opts, args|
+            network_id = opts[:network][2..-1].to_i(16)
+            socket_id = opts[:socket].to_i
+
+            dongle.open_session do |session|
+              session.lock_network
+              session.select_network(network_id)
+              session.switch(network_id, socket_id, true)
+            end
+          end
+        end
+
+        command 'off', :banner => 'Turn off the specifed socket' do
+          on :n, :network=, 'The network id (ex. 0x1234)', :required => true
+          on :s, :socket=, 'The socket id (ex. 0)', :required => true
+          on :d, :debug, 'Enables debug logging' do
+            dongle.logger.level = Logger::DEBUG
+          end
+
+          run do |opts, args|
+            network_id = opts[:network][2..-1].to_i(16)
+            socket_id = opts[:socket].to_i
+
+            dongle.open_session do |session|
+              session.lock_network
+              session.select_network(network_id)
+              session.switch(network_id, socket_id, false)
+            end
+          end
+        end
+
+        command 'read', :banner => 'Read all available samples from the specified socket' do
+          on :n, :network=, 'The network id (ex. 0x1234)', :required => true
+          on :s, :socket=, 'The socket id (ex. 0)', :required => true
+          on :d, :debug, 'Enables debug logging' do
+            dongle.logger.level = Logger::DEBUG
+          end
+
+          run do |opts, args|
+            network_id = opts[:network][2..-1].to_i(16)
+            socket_id = opts[:socket].to_i
+
+            dongle.open_session do |session|
+              session.lock_network
+              session.select_network(network_id)
+              session.request_samples(network_id, socket_id)
+            end
+          end
+        end
+
+        command 'commission', :banner => 'Add a new device to the network' do
+          on :d, :debug, 'Enables debug logging' do
+            dongle.logger.level = Logger::DEBUG
+          end
+
+          run do |opts, args|
+            dongle.open_session do |session|
+              session.commission
+            end
+          end
+        end
+
+        run do
+          puts help
+        end
+      end
+    end
+  end
+end

data/lib/hacklet/dongle.rb

@@ -0,0 +1,217 @@
+require 'serialport'
+require 'logger'
+require 'timeout'
+
+module Hacklet
+  class Dongle
+    attr_reader :logger
+
+    # logger - Optionally takes a Logger instance, the default is to log to
+    #          STDOUT
+    def initialize(logger=Logger.new(STDOUT))
+      @logger = logger
+    end
+
+    # Public: Initializes a session so the client can request data.
+    #
+    # port - Optional string for configuring the serial port device.
+    #
+    # Returns nothing.
+    def open_session(port='/dev/ttyUSB0')
+      @serial = open_serial_port(port)
+      begin
+        @logger.info("Booting")
+        boot
+        boot_confirm
+        @logger.info("Booting complete")
+        yield self
+      ensure
+        @serial.close
+      end
+    end
+
+    # Public: Listens for new devices on the network.
+    #
+    # This must be executed within an open session.
+    #
+    # Returns nothing.
+    def commission
+      require_session
+
+      begin
+        unlock_network
+        Timeout.timeout(30) do
+          loop do
+            @logger.info("Listening for devices ...")
+            buffer = receive(4)
+            buffer += receive(buffer.bytes.to_a[3]+1)
+            if buffer.bytes.to_a[1] == 0xa0
+              response = BroadcastResponse.read(buffer)
+              @logger.info("Found device 0x%x on network 0x%x" % [response.device_id, response.network_id])
+            end
+          end
+        end
+      rescue Timeout::Error
+      ensure
+        lock_network
+      end
+    end
+
+    # Public: Selects the network.
+    #
+    # This must be executed within an open session. I'm guessing it selects the
+    # network.
+    #
+    # network_id - 2 byte identified for the network.
+    #
+    # Returns nothing.
+    def select_network(network_id)
+      require_session
+
+      transmit(HandshakeRequest.new(:network_id => network_id))
+      HandshakeResponse.read(receive(6))
+    end
+
+    # Public: Request stored samples.
+    #
+    # network_id - 2 byte identified for the network.
+    # channel_id - 2 byte identified for the channel.
+    #
+    # TODO: This needs to return a more usable set of data.
+    # Returns the SamplesResponse.
+    def request_samples(network_id, channel_id)
+      require_session
+
+      @logger.info("Requesting samples")
+      transmit(SamplesRequest.new(:network_id => network_id, :channel_id => channel_id))
+      AckResponse.read(receive(6))
+      buffer = receive(4)
+      remaining_bytes = buffer.bytes.to_a[3] + 1
+      buffer += receive(remaining_bytes)
+      response = SamplesResponse.read(buffer)
+
+      response.converted_samples.each do |time, wattage|
+        @logger.info("#{wattage}w at #{time}")
+      end
+      @logger.info("#{response.sample_count} returned, #{response.stored_sample_count} remaining")
+
+      response
+    end
+
+    # Public: Used to controls whether a socket is on or off.
+    #
+    # network_id - 2 byte identified for the network.
+    # channel_id - 1 byte identified for the channel.
+    # enabled    - true enables the socket and false disables it.
+    #
+    # Returns the SwitchResponse.
+    def switch(network_id, channel_id, state)
+      require_session
+
+      request = ScheduleRequest.new(:network_id => network_id, :channel_id => channel_id)
+      if state
+        request.always_on!
+        @logger.info("Turning on channel #{channel_id} on network 0x#{network_id.to_s(16)}")
+      else
+        request.always_off!
+        @logger.info("Turning off channel #{channel_id} on network 0x#{network_id.to_s(16)}")
+      end
+      transmit(request)
+      ScheduleResponse.read(receive(6))
+    end
+
+    # Public: Unlocks the network, to add a new device.
+    #
+    # Returns the BootConfirmResponse
+    def unlock_network
+      @logger.info("Unlocking network")
+      transmit(UnlockRequest.new)
+      LockResponse.read(receive(6))
+      @logger.info("Unlocking complete")
+    end
+
+    # Public: Locks the network, prevents adding new devices.
+    #
+    # Returns the BootConfirmResponse
+    def lock_network
+      @logger.info("Locking network")
+      transmit(LockRequest.new)
+      LockResponse.read(receive(6))
+      @logger.info("Locking complete")
+    end
+
+  private
+    # Private: Initializes the dongle for communication
+    #
+    # Returns the BootResponse
+    def boot
+      transmit(BootRequest.new)
+      BootResponse.read(receive(27))
+    end
+
+    # Private: Confirms that booting was successful?
+    #
+    # Not sure about this.
+    #
+    # Returns the BootConfirmResponse
+    def boot_confirm
+      transmit(BootConfirmRequest.new)
+      BootConfirmResponse.read(receive(6))
+    end
+
+    # Private: Initializes the serial port
+    #
+    # port - the String to the device to open as a serial port.
+    #
+    # Returns a SerialPort object.
+    def open_serial_port(port)
+      serial_port = SerialPort.new(port, 115200, 8, 1, SerialPort::NONE)
+      serial_port.flow_control = SerialPort::NONE
+      serial_port
+    end
+
+    # Private: Transmits the packet to the dongle.
+    #
+    # command - The binary string to send.
+    #
+    # Returns the number of bytes written.
+    def transmit(command)
+      @logger.debug("TX: #{unpack(command.to_binary_s).inspect}")
+      @serial.write(command.to_binary_s) if @serial
+    end
+
+    # Private: Waits and receives the specified number of packets from the
+    # dongle.
+    #
+    # bytes - The number of bytes to read.
+    #
+    # Returns a binary string containing the response.
+    def receive(bytes)
+      if @serial
+        response = @serial.read(bytes)
+      else
+        response = "\x0\x0\x0\x0"
+      end
+      @logger.debug("RX: #{unpack(response).inspect}")
+
+      response
+    end
+
+    # Private: Prints a binary string a concise hexidecimal form for debugging
+    #
+    # message - The message to parse.
+    #
+    # Returns a string of hexidecimal representing equivalent to the message.
+    def unpack(message)
+      message.unpack('H2'*message.size)
+    end
+
+    # Private: A helper to ensure that the serial port is active.
+    #
+    # Returns nothing.
+    # Raises RuntimeError if the serial port is not active.
+    def require_session
+      raise RuntimeError.new("Must be executed within an open session") unless @serial && !@serial.closed?
+    end
+  end
+end

data/lib/hacklet/messages.rb

@@ -0,0 +1,238 @@
+require 'bindata'
+
+module Hacklet
+  class Message < BinData::Record
+    def calculate_checksum
+      checksum_fields = @field_names - [:header, :checksum]
+      buffer = StringIO.new
+      io = BinData::IO.new(buffer)
+      checksum_fields.each do |field|
+        send(field).do_write(io)
+      end
+      buffer.rewind
+
+      buffer.read.bytes.inject(0) { |s,x| s^x }
+    end
+  end
+
+  class BootResponse < Message
+    endian :big
+
+    uint8  :header, :check_value => lambda { value == 0x02 }
+    uint16 :command, :check_value => lambda { value == 0x4084 }
+    uint8  :payload_length, :check_value => lambda { value == 22 }
+
+    # TODO: Determine what's in here
+    string :data, :length => 12
+
+    uint64 :device_id
+
+    # TODO: Determine what's in here
+    uint16 :data2
+
+    uint8 :checksum, :check_value => lambda { calculate_checksum == checksum }
+  end
+
+  class BootConfirmResponse < Message
+    endian :big
+
+    uint8  :header, :check_value => lambda { value == 0x02 }
+    uint16 :command, :check_value => lambda { value == 0x4080 }
+    uint8  :payload_length, :check_value => lambda { value == 1 }
+
+    uint8  :data, :check_value => lambda { value == 0x10 }
+
+    uint8 :checksum, :check_value => lambda { calculate_checksum == checksum }
+  end
+
+  class BroadcastResponse < Message
+    endian :big
+
+    uint8  :header, :check_value => lambda { value == 0x02 }
+    uint16  :command, :check_value => lambda { value == 0xA013 }
+    uint8  :payload_length, :check_value => lambda { value == 11 }
+
+    uint16 :network_id
+    uint64 :device_id
+
+    # TODO: Not sure why this is here.
+    uint8 :data
+
+    uint8 :checksum, :check_value => lambda { calculate_checksum == checksum }
+  end
+
+  class LockResponse < Message
+    endian :big
+
+    uint8  :header, :check_value => lambda { value == 0x02 }
+    uint16 :command, :check_value => lambda { value == 0xA0F9 }
+    uint8  :payload_length, :check_value => lambda { value == 1 }
+
+    uint8be :data, :check_value => lambda { value == 0x00 }
+
+    uint8 :checksum, :check_value => lambda { calculate_checksum == checksum }
+  end
+
+  class HandshakeResponse < Message
+    endian :big
+
+    uint8  :header, :check_value => lambda { value == 0x02 }
+    uint16 :command, :check_value => lambda { value == 0x4003 }
+    uint8  :payload_length, :check_value => lambda { value == 1 }
+
+    uint8be :data, :check_value => lambda { value == 0x00 }
+
+    uint8 :checksum, :check_value => lambda { calculate_checksum == checksum }
+  end
+
+  class AckResponse < Message
+    endian :big
+
+    uint8  :header, :check_value => lambda { value == 0x02 }
+    uint16 :command, :check_value => lambda { value == 0x4024 }
+    uint8  :payload_length, :check_value => lambda { value == 1 }
+
+    uint8be :data, :check_value => lambda { value == 0x00 }
+
+    uint8 :checksum, :check_value => lambda { calculate_checksum == checksum }
+  end
+
+  class SamplesResponse < Message
+    endian :big
+
+    uint8  :header, :check_value => lambda { value == 0x02 }
+    uint16 :command, :check_value => lambda { value == 0x40A4 }
+    uint8  :payload_length
+
+    uint16   :network_id
+    uint16   :channel_id
+
+    # TODO: Confirm this is actually the device id
+    uint16   :data
+
+    uint32le :time
+    uint8    :sample_count
+    uint24le :stored_sample_count
+    array    :samples, :type => [:uint16le], :initial_length => :sample_count
+
+    uint8 :checksum, :check_value => lambda { calculate_checksum == checksum }
+
+    def converted_samples
+      t = time - 10
+      samples.map { |s| t += 10; [Time.at(t), (s/13.0).round] }
+    end
+  end
+
+  class ScheduleResponse < Message
+    endian :big
+
+    uint8  :header, :check_value => lambda { value == 0x02 }
+    uint16 :command, :check_value => lambda { value == 0x4023 }
+    uint8  :payload_length, :check_value => lambda { value == 1 }
+
+    uint8be :data, :check_value => lambda { value == 0x00 }
+
+    uint8 :checksum, :check_value => lambda { calculate_checksum == checksum }
+  end
+
+  class BootRequest < Message
+    endian :big
+
+    uint8  :header, :initial_value => 0x02
+    uint16 :command, :initial_value => 0x4004
+    uint8  :payload_length
+
+    uint8 :checksum, :value => :calculate_checksum
+  end
+
+  class BootConfirmRequest < Message
+    endian :big
+
+    uint8  :header, :initial_value => 0x02
+    uint16 :command, :initial_value => 0x4000
+    uint8  :payload_length
+
+    uint8 :checksum, :value => :calculate_checksum
+  end
+
+  class UnlockRequest < Message
+    endian :big
+
+    uint8  :header, :initial_value => 0x02
+    uint16 :command, :initial_value => 0xA236
+    uint8  :payload_length, :initial_value => 4
+
+    # TODO: What is this?
+    uint32 :data, :initial_value => 0xFCFF9001
+
+    uint8 :checksum, :value => :calculate_checksum
+  end
+
+  class LockRequest < Message
+    endian :big
+
+    uint8  :header, :initial_value => 0x02
+    uint16 :command, :initial_value => 0xA236
+    uint8  :payload_length, :initial_value => 4
+
+    # TODO: What is this?
+    uint32 :data, :initial_value => 0xFCFF0001
+
+    uint8 :checksum, :value => :calculate_checksum
+  end
+
+  class HandshakeRequest < Message
+    endian :big
+
+    uint8  :header, :initial_value => 0x02
+    uint16 :command, :initial_value => 0x4003
+    uint8  :payload_length, :initial_value => 4
+
+    uint16 :network_id
+    # TODO: What is this?
+    uint16 :data, :initial_value => 0x0500
+
+    uint8 :checksum, :value => :calculate_checksum
+  end
+
+  class SamplesRequest < Message
+    endian :big
+
+    uint8  :header, :initial_value => 0x02
+    uint16 :command, :initial_value => 0x4024
+    uint8  :payload_length, :initial_value => 6
+
+    uint16 :network_id
+    uint16 :channel_id
+    # TODO: What is this?
+    uint16 :data, :initial_value => 0x0A00
+
+    uint8 :checksum, :value => :calculate_checksum
+  end
+
+  class ScheduleRequest < Message
+    endian :big
+
+    uint8  :header, :initial_value => 0x02
+    uint16 :command, :initial_value => 0x4023
+    uint8  :payload_length, :initial_value => 59
+
+    uint16 :network_id
+    uint8  :channel_id
+    array  :schedule, :type => [:uint8], :initial_length => 56
+
+    uint8 :checksum, :value => :calculate_checksum
+
+    def always_off!
+      bitmap = [0x7f]*56
+      bitmap[5] = 0x25
+      schedule.assign(bitmap)
+    end
+
+    def always_on!
+      bitmap = [0xff]*56
+      bitmap[5] = 0xa5
+      schedule.assign(bitmap)
+    end
+  end
+end

data/lib/hacklet/version.rb

@@ -0,0 +1,3 @@
+module Hacklet
+  VERSION = "0.5.0"
+end

data/spec/hacklet/command_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe Hacklet::Command do
+  subject do
+    Hacklet::Command
+  end
+
+  let(:dongle) { Hacklet::Dongle.new(Logger.new("/dev/null")) }
+
+  it 'can turn on a socket' do
+    serial_port = mock('serial_port')
+    serial_port.should_receive(:close)
+
+    dongle.should_receive(:open_serial_port).and_return(serial_port)
+    dongle.should_receive(:boot)
+    dongle.should_receive(:boot_confirm)
+    dongle.should_receive(:lock_network)
+    dongle.should_receive(:select_network).with(16)
+    dongle.should_receive(:switch).with(16, 1, true)
+
+    subject.run(dongle, ['on', '-n', '0x0010', '-s', '1'])
+  end
+
+  it 'can turn off a socket' do
+    serial_port = mock('serial_port')
+    serial_port.should_receive(:close)
+
+    dongle.should_receive(:open_serial_port).and_return(serial_port)
+    dongle.should_receive(:boot)
+    dongle.should_receive(:boot_confirm)
+    dongle.should_receive(:lock_network)
+    dongle.should_receive(:select_network).with(16)
+    dongle.should_receive(:switch).with(16, 0, false)
+
+    subject.run(dongle, ['off', '-n', '0x0010', '-s', '0'])
+  end
+
+  it 'can read a socket' do
+    serial_port = mock('serial_port')
+    serial_port.stub(:closed?).and_return(false)
+    serial_port.should_receive(:close)
+
+    dongle.should_receive(:open_serial_port).and_return(serial_port)
+    dongle.should_receive(:boot)
+    dongle.should_receive(:boot_confirm)
+    dongle.should_receive(:lock_network)
+    dongle.should_receive(:select_network).with(16)
+    dongle.should_receive(:request_samples).with(16, 1)
+
+    subject.run(dongle, ['read', '-n', '0x0010', '-s', '1'])
+  end
+
+  it 'can commission a device' do
+    serial_port = mock('serial_port')
+    serial_port.stub(:closed?).and_return(false)
+    serial_port.should_receive(:close)
+
+    dongle.should_receive(:open_serial_port).and_return(serial_port)
+    dongle.should_receive(:boot)
+    dongle.should_receive(:boot_confirm)
+    dongle.should_receive(:commission)
+
+    subject.run(dongle, ['commission'])
+  end
+end

data/spec/hacklet/dongle_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+describe Hacklet::Dongle do
+  subject do
+    Hacklet::Dongle.new(Logger.new("/dev/null"))
+  end
+
+  it 'can open a new session' do
+    serial_port = mock("SerialPort")
+
+    # Boot
+    serial_port.should_receive(:write).with([0x02, 0x40, 0x04, 0x00, 0x44].pack('c'*5))
+    serial_port.should_receive(:read).and_return([0x02, 0x40, 0x84, 0x16, 0x01,
+      0x00, 0x00, 0x87, 0x03, 0x00, 0x30, 0x00, 0x33, 0x83, 0x69, 0x9A, 0x0B,
+      0x2F, 0x00, 0x00, 0x00, 0x58, 0x4F, 0x80, 0x0A, 0x1C, 0x81].pack('c'*27))
+
+    # Boot Confirmation
+    serial_port.should_receive(:write).with([0x02, 0x40, 0x00, 0x00, 0x40].pack('c'*5))
+    serial_port.should_receive(:read).and_return([0x02, 0x40, 0x80, 0x01, 0x10, 0xd1].pack('c'*6))
+
+    serial_port.should_receive(:close)
+    subject.should_receive(:open_serial_port).and_return(serial_port)
+    subject.open_session do
+      # noop
+    end
+  end
+
+  it 'can find a new device' do
+    serial_port = mock("SerialPort")
+
+    # Unlock Network
+    serial_port.should_receive(:write).with([0x02, 0xA2, 0x36, 0x04, 0xFC, 0xFF, 0x90, 0x01, 0x02].pack('c'*9))
+    serial_port.should_receive(:read).and_return([0x02, 0xA0, 0xF9, 0x01, 0x00, 0x58].pack('c'*6))
+
+    # Ignored packet #1
+    serial_port.should_receive(:read).and_return([0x02, 0x99, 0xd1, 0x23].pack('c'*4))
+    serial_port.should_receive(:read).and_return([0x01, 0xcc, 0x1f, 0x10, 0x00,
+      0x00, 0x58, 0x4f, 0x80, 0x00, 0x77, 0x2a, 0x8a, 0x33, 0xa7, 0xf4, 0xf6,
+      0x80, 0xd0, 0x9c, 0x5d, 0x3c, 0x84, 0xf5, 0x2b, 0x43, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcb].pack('c'*36))
+
+    # Ignored packet #2
+    serial_port.should_receive(:read).and_return([0x02, 0x98, 0xc0, 0x09].pack('c'*4))
+    serial_port.should_receive(:read).and_return([0xcc, 0x1f, 0x10, 0x00, 0x00,
+      0x58, 0x4f, 0x80, 0x00, 0x05].pack('c'*10))
+
+    # Useful response
+    serial_port.should_receive(:read).and_return([0x02, 0xa0, 0x13, 0x0b].pack('c'*4))
+    serial_port.should_receive(:read).and_return([0x66, 0xad, 0xcc, 0x1f, 0x10, 0x00,
+      0x00, 0x58, 0x4f, 0x80, 0x8e, 0xa9].pack('c'*12))
+    serial_port.should_receive(:read).and_raise(Timeout::Error)
+
+    # Lock Network
+    serial_port.should_receive(:write).with([0x02, 0xA2, 0x36, 0x04, 0xFC, 0xFF, 0x00, 0x01, 0x92].pack('c'*9))
+    serial_port.should_receive(:read).and_return([0x02, 0xA0, 0xF9, 0x01, 0x00, 0x58].pack('c'*6))
+
+    serial_port.should_receive(:close)
+    serial_port.stub!(:closed?).and_return(false)
+    subject.should_receive(:open_serial_port).and_return(serial_port)
+    subject.should_receive(:boot)
+    subject.should_receive(:boot_confirm)
+
+    subject.open_session do |session|
+      session.commission
+    end
+  end
+
+  it 'can request a sample' do
+    serial_port = mock("SerialPort")
+
+    # Selecting the network
+    serial_port.should_receive(:write).with([0x02, 0x40, 0x03, 0x04, 0xA7, 0xB4, 0x05, 0x00, 0x51].pack('c'*9))
+    serial_port.should_receive(:read).and_return([0x02, 0x40, 0x03, 0x01, 0x00, 0x42].pack('c'*6))
+
+    # Requesting the sample
+    serial_port.should_receive(:write).with([0x02, 0x40, 0x24, 0x06, 0xA7, 0xB4,
+      0x00, 0x01, 0x0A, 0x00, 0x7a].pack('c'*11))
+    serial_port.should_receive(:read).and_return([0x02, 0x40, 0x24, 0x01, 0x00, 0x65].pack('c'*6))
+    serial_port.should_receive(:read).and_return([0x02, 0x40, 0xA4, 0x12].pack('c'*4))
+    serial_port.should_receive(:read).and_return([0xA7, 0xB4, 0x00, 0x01, 0x0A,
+      0x00, 0x69, 0x8D, 0x44, 0x51, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x1d].pack('c'*19))
+
+    serial_port.should_receive(:close)
+    serial_port.stub!(:closed?).and_return(false)
+    subject.should_receive(:open_serial_port).and_return(serial_port)
+    subject.should_receive(:boot)
+    subject.should_receive(:boot_confirm)
+    subject.should_receive(:lock_network)
+
+    subject.open_session do |session|
+      session.lock_network
+      session.select_network(0xA7B4)
+      session.request_samples(0xA7B4, 0x0001)
+    end
+  end
+
+  it 'can enable a socket' do
+    serial_port = mock("SerialPort")
+
+    # Selecting the network
+    serial_port.should_receive(:write).with([0x02, 0x40, 0x03, 0x04, 0xA7, 0xB4, 0x05, 0x00, 0x51].pack('c'*9))
+    serial_port.should_receive(:read).and_return([0x02, 0x40, 0x03, 0x01, 0x00, 0x42].pack('c'*6))
+
+    # Switching
+    request = [0xff]*56
+    request[5] = 0xA5
+    request = [0x02, 0x40, 0x23, 0x3B, 0xA7, 0xB4, 0x00] + request + [0x11]
+    serial_port.should_receive(:write).with(request.pack('c'*request.length))
+    serial_port.should_receive(:read).and_return([0x02, 0x40, 0x23, 0x01, 0x00, 0x62].pack('c'*6))
+
+    serial_port.should_receive(:close)
+    serial_port.stub!(:closed?).and_return(false)
+    subject.should_receive(:open_serial_port).and_return(serial_port)
+    subject.should_receive(:boot)
+    subject.should_receive(:boot_confirm)
+    subject.should_receive(:lock_network)
+
+    subject.open_session do |session|
+      session.lock_network
+      session.select_network(0xA7B4)
+      session.switch(0xA7B4, 0x0000, true)
+    end
+  end
+end

data/spec/hacklet/messages_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe 'Messages' do
+  describe 'responses' do
+    let(:bad_checksum) { "\x02\x40\x80\x01\x10\x01" }
+
+    describe Hacklet::BootConfirmResponse do
+      it 'detects an invalid checksum' do
+        expect { Hacklet::BootConfirmResponse.read(bad_checksum) }.to raise_error(BinData::ValidityError)
+      end
+    end
+  end
+
+  describe 'requests' do
+    describe Hacklet::BootRequest do
+      it 'has a proper checksum' do
+        subject.checksum.should eq(0x44)
+      end
+    end
+  end
+end

data/spec/hacklet_spec.rb

@@ -0,0 +1,5 @@
+describe Hacklet do
+  it 'should have a version number' do
+    Hacklet::VERSION.should_not be_nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'hacklet'

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: hacklet
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+  prerelease: 
+platform: ruby
+authors:
+- Matt Colyer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: serialport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: bindata
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+- !ruby/object:Gem::Dependency
+  name: slop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An Open Source client for the Modlet (smart) outlet
+email:
+- matt@colyer.name
+executables:
+- hacklet
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- Rakefile.base
+- bin/hacklet
+- hacklet.gemspec
+- lib/hacklet.rb
+- lib/hacklet/command.rb
+- lib/hacklet/dongle.rb
+- lib/hacklet/messages.rb
+- lib/hacklet/version.rb
+- spec/hacklet/command_spec.rb
+- spec/hacklet/dongle_spec.rb
+- spec/hacklet/messages_spec.rb
+- spec/hacklet_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/mcolyer/hacklet
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A daemon, written in ruby, for controlling the Modlet outlet.
+test_files:
+- spec/hacklet/command_spec.rb
+- spec/hacklet/dongle_spec.rb
+- spec/hacklet/messages_spec.rb
+- spec/hacklet_spec.rb
+- spec/spec_helper.rb