hacklet 0.5.1 → 0.6.0

data/.travis.yml

@@ -2,3 +2,5 @@ language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
+before_install:
+  - sudo apt-get install libftdi1

data/CHANGELOG.md

@@ -1,4 +1,18 @@
 
+0.6.0 / 2013-06-18
+==================
+
+ * Add Cross-platform support by switching to libftdi-ruby from serialport.
+ * API Change: Hacklet::Dongle.open is now used to create a session
+   instead of #open_session.
+ * Refactor dongle communication functions into SerialConnection for
+   clarity.
+
+0.5.1 / 2013-06-02
+==================
+
+ * Bugfix: Properly sets the time on the device after commissioning.
+
 0.5.0 / 2013-05-30
 ==================
 

data/README.md

@@ -2,15 +2,18 @@
 
 A library, written in Ruby, for controlling the [Modlet][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 in 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.
+If you haven't heard of the Modlet before, it's an outlet cover which
+allows you to convert any standard US outlet into a smart outlet. This
+means that you can control whether each socket is on or off as well as
+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 seen that [costs $50][amazon] and includes control as well as
-monitoring of the both sockets independently.
+monitoring of both sockets independently.
+
+Checkout the companion project [hacklet-remote] if you're interested in
+controlling your modlet with [IFTTT].
 
 ## Why
 
@@ -21,17 +24,45 @@ 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.
+bundled client but in a lightweight manner without dependencies on
+external services.
 
-## Getting Started
+## Installation
+
+### Mac
 
 ```shell
+brew install libftdi
 gem install hacklet
+```
+
+### Linux (Ubuntu/Debian)
+
+```shell
+apt-get install libftdi1
+gem install hacklet
+echo 'ATTRS{idVendor}=="0403", ATTRS{idProduct}=="8c81", SUBSYSTEMS=="usb", ACTION=="add", MODE="0660", GROUP="plugdev"' | sudo tee /etc/udev/rules.d/99-thinkeco.rules
+```
 
-# Load the USB-to-serial kernel driver, this only works with Linux currently
-sudo modprobe ftdi_sio vendor=0x0403 product=0x8c81
+### Windows
 
+**Note**: These directions haven't been confirmed. If you can confirm
+them or improve them, please create an [issue][issues] or send a pull request.
+
+1. Install [7zip] in order to extract Zadiag.
+1. Download Zadig for [XP][zadiag-xp] or [later][zadiag-later].
+1. Extract Zadig and run it.
+1. Click `Options` -> `List all Devices` to populate the device list.
+1. Open the device dropdown and look for the "Thinkeco" device and select it.
+1. Select the libusbK driver and press the `Replace Driver` button.
+1. Download and unzip [libftdi][libftdi-win]
+1. Run `gem install hacklet`
+
+If something isn't clear here, take a look at [libFTDI under Windows][libftdi-win-post] as this was summarized from there.
+
+## Getting Started
+
+```shell
 # Add the device to the network, keep a copy of the network ids (ie 0xDEED)
 hacklet commission
 
@@ -48,24 +79,37 @@ hacklet on -n 0xDEED -s 0
 ## Contributing
 
 All contributions are welcome (bug reports, bug fixes, documentation or
-new features)!  If you're looking for something to do check the [issue]
-list and see if there's something already there. If you've got a new
-idea, feel free to create an issue for discussion.
+new features)! All discussion happens using [issues] so if you are
+interested in contributing:
+
+* Search to make sure an issue doesn't already exist.
+* If it doesn't, create a new issue and describe your proposal.
+
+If you're interested in following the status of the project, simply
+"watch" the repository on Github and you'll receive notices about all of
+the new issues.
 
-To get a general understanding of how things work, checkout the
-[developer wiki]
+If your curious about how the hardware works or the specifics of the
+protocol checkout out the [developer wiki].
 
-### Getting Started
+### Contribution Workflow
 
-* Checkout the repository
+* Fork the repository
 * Install dependencies `bundle install`
-* Create a feature branch `git checkout -b short-name`
+* Create a feature branch `git checkout -b short-descriptive-name`
 * Run tests `bundle exec rake`
 * Write your feature (and tests)
 * Run tests `bundle exec rake`
 * Create a pull request
 
 [modlet]: http://themodlet.com
-[amazon]: http://www.amazon.com/ThinkEco-TE1010-Modlet-Starter-White/dp/B00AAT43OA/
-[issue]: https://github.com/mcolyer/hacklet/issues
+[amazon]: http://www.amazon.com/gp/product/B00AAT43OA/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=B00AAT43OA&linkCode=as2&tag=matcol-20
+[issues]: https://github.com/mcolyer/hacklet/issues
 [developer wiki]: https://github.com/mcolyer/hacklet/wiki
+[hacklet-remote]: https://github.com/mcolyer/hacklet-remote/
+[IFTTT]: http://ifttt.com
+[7zip]: http://www.7-zip.org/
+[libftdi-win]: http://code.google.com/p/picusb/downloads/detail?name=libftdi1-1.0_devkit_mingw32_17Feb2013.zip
+[zadiag-xp]: http://sourceforge.net/projects/libwdi/files/zadig/zadig_xp_v2.0.1.160.7z/download
+[zadiag-later]: http://sourceforge.net/projects/libwdi/files/zadig/zadig_v2.0.1.160.7z/download
+[libftdi-win-post]: http://embedded-funk.blogspot.com/2013/03/libftdi-under-windows.html

data/bin/hacklet

@@ -8,6 +8,7 @@ require 'logger'
 
 logger = Logger.new(STDOUT)
 logger.level = Logger::INFO
-dongle = Hacklet::Dongle.new(logger)
 
-Hacklet::Command.run(dongle, ARGV)
+Hacklet::Dongle.open(logger) do |dongle|
+  Hacklet::Command.run(dongle, ARGV)
+end

data/hacklet.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency "serialport", "~>1.1.0"
+  gem.add_dependency "libftdi-ruby", "~>0.0.20"
   gem.add_dependency "bindata", "~>1.5.0"
   gem.add_dependency "slop", "~>3.4.0"
   gem.add_development_dependency "rake"

data/lib/hacklet.rb

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

data/lib/hacklet/command.rb

@@ -16,11 +16,9 @@ module Hacklet
             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
+            dongle.lock_network
+            dongle.select_network(network_id)
+            dongle.switch(network_id, socket_id, true)
           end
         end
 
@@ -35,11 +33,9 @@ module Hacklet
             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
+            dongle.lock_network
+            dongle.select_network(network_id)
+            dongle.switch(network_id, socket_id, false)
           end
         end
 
@@ -54,11 +50,9 @@ module Hacklet
             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
+            dongle.lock_network
+            dongle.select_network(network_id)
+            dongle.request_samples(network_id, socket_id)
           end
         end
 
@@ -68,9 +62,7 @@ module Hacklet
           end
 
           run do |opts, args|
-            dongle.open_session do |session|
-              session.commission
-            end
+            dongle.commission
           end
         end
 

data/lib/hacklet/dongle.rb

@@ -1,4 +1,3 @@
-require 'serialport'
 require 'logger'
 require 'timeout'
 
@@ -6,46 +5,44 @@ 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.
+    # Public: Initializes a dongle instance and yields it.
     #
-    # port - Optional string for configuring the serial port device.
+    # logger - The Logger instance to log to, defaults to STDOUT.
     #
     # Returns nothing.
-    def open_session(port='/dev/ttyUSB0')
-      @serial = open_serial_port(port)
+    def self.open(logger=Logger.new(STDOUT))
+      serial = SerialConnection.new(logger)
+      dongle = Dongle.new(serial, logger)
       begin
-        @logger.info("Booting")
-        boot
-        boot_confirm
-        @logger.info("Booting complete")
-        yield self
+        dongle.send(:boot)
+        dongle.send(:boot_confirm)
+        yield dongle
       ensure
-        @serial.close
+        serial.close
       end
     end
 
+    # serial - Serial connection to use with the dongle.
+    # logger - The Logger instance to log to.
+    def initialize(serial, logger)
+      @serial = serial
+      @logger = logger
+    end
+
     # Public: Listens for new devices on the network.
     #
     # This must be executed within an open session.
     #
     # Returns nothing.
     def commission
-      require_session
-
       response = nil
       begin
         unlock_network
         Timeout.timeout(30) do
           @logger.info("Listening for devices ...")
           loop do
-            buffer = receive(4)
-            buffer += receive(buffer.bytes.to_a[3]+1)
+            buffer = @serial.receive(4)
+            buffer += @serial.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])
@@ -70,10 +67,8 @@ module Hacklet
     #
     # Returns nothing.
     def select_network(network_id)
-      require_session
-
-      transmit(HandshakeRequest.new(:network_id => network_id))
-      HandshakeResponse.read(receive(6))
+      @serial.transmit(HandshakeRequest.new(:network_id => network_id))
+      HandshakeResponse.read(@serial.receive(6))
     end
 
     # Public: Request stored samples.
@@ -84,14 +79,12 @@ module Hacklet
     # 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)
+      @serial.transmit(SamplesRequest.new(:network_id => network_id, :channel_id => channel_id))
+      AckResponse.read(@serial.receive(6))
+      buffer = @serial.receive(4)
       remaining_bytes = buffer.bytes.to_a[3] + 1
-      buffer += receive(remaining_bytes)
+      buffer += @serial.receive(remaining_bytes)
       response = SamplesResponse.read(buffer)
 
       response.converted_samples.each do |time, wattage|
@@ -110,8 +103,6 @@ module Hacklet
     #
     # 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!
@@ -120,8 +111,8 @@ module Hacklet
         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))
+      @serial.transmit(request)
+      ScheduleResponse.read(@serial.receive(6))
     end
 
     # Public: Unlocks the network, to add a new device.
@@ -129,8 +120,8 @@ module Hacklet
     # Returns the BootConfirmResponse
     def unlock_network
       @logger.info("Unlocking network")
-      transmit(UnlockRequest.new)
-      LockResponse.read(receive(6))
+      @serial.transmit(UnlockRequest.new)
+      LockResponse.read(@serial.receive(6))
       @logger.info("Unlocking complete")
     end
 
@@ -139,8 +130,8 @@ module Hacklet
     # Returns the BootConfirmResponse
     def lock_network
       @logger.info("Locking network")
-      transmit(LockRequest.new)
-      LockResponse.read(receive(6))
+      @serial.transmit(LockRequest.new)
+      LockResponse.read(@serial.receive(6))
       @logger.info("Locking complete")
     end
 
@@ -149,8 +140,9 @@ module Hacklet
     #
     # Returns the BootResponse
     def boot
-      transmit(BootRequest.new)
-      BootResponse.read(receive(27))
+      @logger.info("Booting")
+      @serial.transmit(BootRequest.new)
+      BootResponse.read(@serial.receive(27))
     end
 
     # Private: Confirms that booting was successful?
@@ -159,8 +151,9 @@ module Hacklet
     #
     # Returns the BootConfirmResponse
     def boot_confirm
-      transmit(BootConfirmRequest.new)
-      BootConfirmResponse.read(receive(6))
+      @serial.transmit(BootConfirmRequest.new)
+      BootConfirmResponse.read(@serial.receive(6))
+      @logger.info("Booting complete")
     end
 
     # Private: Updates the time of a device.
@@ -172,66 +165,9 @@ module Hacklet
     #
     # Returns nothing.
     def update_time(network_id)
-      require_session
-
-      transmit(UpdateTimeRequest.new(:network_id => network_id))
-      UpdateTimeAckResponse.read(receive(6))
-      UpdateTimeResponse.read(receive(8))
-    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?
+      @serial.transmit(UpdateTimeRequest.new(:network_id => network_id))
+      UpdateTimeAckResponse.read(@serial.receive(6))
+      UpdateTimeResponse.read(@serial.receive(8))
     end
   end
 end

data/lib/hacklet/serial_connection.rb

@@ -0,0 +1,72 @@
+require 'ftdi'
+
+module Hacklet
+  class SerialConnection
+    def initialize(logger, port='/dev/ttyUSB0')
+      @logger = logger
+      @connection = Ftdi::Context.new
+      @connection.usb_open(0x0403, 0x8c81)
+      @connection.set_bitmode(0x00, Ftdi::BitbangMode[:reset])
+      @connection.baudrate = 115200
+      @connection.flowctrl = Ftdi::SIO_DISABLE_FLOW_CTRL
+      @connection.dtr = 1
+      @connection.rts = 1
+      @receive_buffer = ""
+    end
+
+    # Public: Closes the connection
+    #
+    # Returns nothing.
+    def close
+      @connection.usb_close
+    end
+
+    # Public: 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}")
+      @connection.write_data(command.to_binary_s)
+    end
+
+    # Public: 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)
+      response = ""
+      loop do
+        if bytes <= @receive_buffer.bytesize
+          array = @receive_buffer.bytes.to_a
+          response = array[0..(bytes - 1)].pack('c*')
+          @receive_buffer = array[(bytes)..-1].pack('c*')
+          break
+        end
+
+        chunk = @connection.read_data
+        if chunk.bytesize > 0
+          @receive_buffer += chunk
+        else
+          sleep(0.1)
+        end
+      end
+      @logger.debug("RX: #{unpack(response).inspect}")
+
+      response
+    end
+
+  private
+    # 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
+  end
+end

data/lib/hacklet/version.rb

@@ -1,3 +1,3 @@
 module Hacklet
-  VERSION = "0.5.1"
+  VERSION = "0.6.0"
 end

data/spec/hacklet/command_spec.rb

@@ -5,15 +5,12 @@ describe Hacklet::Command do
     Hacklet::Command
   end
 
-  let(:dongle) { Hacklet::Dongle.new(Logger.new("/dev/null")) }
+  let(:dongle) do
+    serial_connection = double('serial_port')
+    Hacklet::Dongle.new(serial_connection, Logger.new("/dev/null"))
+  end
 
   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)
@@ -22,12 +19,6 @@ describe Hacklet::Command do
   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)
@@ -36,13 +27,6 @@ describe Hacklet::Command do
   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)
@@ -51,13 +35,6 @@ describe Hacklet::Command do
   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'])

data/spec/hacklet/dongle_spec.rb

@@ -1,131 +1,154 @@
 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")
+    serial_port = double("Context").as_null_object
 
     # 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,
+    serial_port.should_receive(:write_data).with([0x02, 0x40, 0x04, 0x00, 0x44].pack('c*'))
+    serial_port.should_receive(:read_data).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))
+      0x2F, 0x00, 0x00, 0x00, 0x58, 0x4F, 0x80, 0x0A, 0x1C, 0x81].pack('c*'))
 
     # 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(:write_data).with([0x02, 0x40, 0x00, 0x00, 0x40].pack('c*'))
+    serial_port.should_receive(:read_data).and_return([0x02, 0x40, 0x80, 0x01, 0x10, 0xd1].pack('c*'))
 
-    serial_port.should_receive(:close)
-    subject.should_receive(:open_serial_port).and_return(serial_port)
-    subject.open_session do
+    serial_port.should_receive(:usb_close)
+    Ftdi::Context.should_receive(:new).and_return(serial_port)
+    Hacklet::Dongle.open(Logger.new('/dev/null')) do
       # noop
     end
   end
 
   it 'can find a new device' do
-    serial_port = mock("SerialPort")
+    serial_port = double("Context").as_null_object
+
+    # Boot
+    serial_port.should_receive(:write_data).with([0x02, 0x40, 0x04, 0x00, 0x44].pack('c*'))
+    serial_port.should_receive(:read_data).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*'))
+
+    # Boot Confirmation
+    serial_port.should_receive(:write_data).with([0x02, 0x40, 0x00, 0x00, 0x40].pack('c*'))
+    serial_port.should_receive(:read_data).and_return([0x02, 0x40, 0x80, 0x01, 0x10, 0xd1].pack('c*'))
 
     # 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))
+    serial_port.should_receive(:write_data).with([0x02, 0xA2, 0x36, 0x04, 0xFC, 0xFF, 0x90, 0x01, 0x02].pack('c*'))
+    serial_port.should_receive(:read_data).and_return([0x02, 0xA0, 0xF9, 0x01, 0x00, 0x58].pack('c*'))
 
     # 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,
+    serial_port.should_receive(:read_data).and_return([0x02, 0x99, 0xd1, 0x23].pack('c*'))
+    serial_port.should_receive(:read_data).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))
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcb].pack('c*'))
 
     # 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))
+    serial_port.should_receive(:read_data).and_return([0x02, 0x98, 0xc0, 0x09].pack('c*'))
+    serial_port.should_receive(:read_data).and_return([0xcc, 0x1f, 0x10, 0x00, 0x00,
+      0x58, 0x4f, 0x80, 0x00, 0x05].pack('c*'))
 
     # 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_data).and_return([0x02, 0xa0, 0x13, 0x0b].pack('c*'))
+    serial_port.should_receive(:read_data).and_return([0x66, 0xad, 0xcc, 0x1f, 0x10, 0x00,
+      0x00, 0x58, 0x4f, 0x80, 0x8e, 0xa9].pack('c*'))
 
     # 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(:write_data).with([0x02, 0xA2, 0x36, 0x04, 0xFC, 0xFF, 0x00, 0x01, 0x92].pack('c*'))
+    serial_port.should_receive(:read_data).and_return([0x02, 0xA0, 0xF9, 0x01, 0x00, 0x58].pack('c*'))
 
     # Update Time
-    serial_port.should_receive(:write).and_return([0x02, 0x40, 0x22, 0x06, 0x66, 0xAD, 0xdb, 0xb4, 0xa8, 0x51, 0x0b].pack('c'*11))
-    serial_port.should_receive(:read).and_return([0x02, 0x40, 0x22, 0x01, 0x00, 0x63].pack('c'*6))
-    serial_port.should_receive(:read).and_return([0x02, 0x40, 0xA2, 0x03, 0x66, 0xAD, 0x00, 0x2a].pack('c'*8))
+    serial_port.should_receive(:write_data).and_return([0x02, 0x40, 0x22, 0x06, 0x66, 0xAD, 0xdb, 0xb4, 0xa8, 0x51, 0x0b].pack('c*'))
+    serial_port.should_receive(:read_data).and_return([0x02, 0x40, 0x22, 0x01, 0x00, 0x63].pack('c*'))
+    serial_port.should_receive(:read_data).and_return([0x02, 0x40, 0xA2, 0x03, 0x66, 0xAD, 0x00, 0x2a].pack('c*'))
 
-    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)
+    serial_port.should_receive(:usb_close)
 
-    subject.open_session do |session|
+    Ftdi::Context.should_receive(:new).and_return(serial_port)
+    Hacklet::Dongle.open(Logger.new('/dev/null')) do |dongle|
       Timecop.freeze(Time.at(0x51a8b4db)) do
-        session.commission
+        dongle.commission
       end
     end
   end
 
   it 'can request a sample' do
-    serial_port = mock("SerialPort")
+    serial_port = double("Context").as_null_object
+
+    # Boot
+    serial_port.should_receive(:write_data).with([0x02, 0x40, 0x04, 0x00, 0x44].pack('c*'))
+    serial_port.should_receive(:read_data).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*'))
+
+    # Boot Confirmation
+    serial_port.should_receive(:write_data).with([0x02, 0x40, 0x00, 0x00, 0x40].pack('c*'))
+    serial_port.should_receive(:read_data).and_return([0x02, 0x40, 0x80, 0x01, 0x10, 0xd1].pack('c*'))
+
+    # Lock Network
+    serial_port.should_receive(:write_data).with([0x02, 0xA2, 0x36, 0x04, 0xFC, 0xFF, 0x00, 0x01, 0x92].pack('c*'))
+    serial_port.should_receive(:read_data).and_return([0x02, 0xA0, 0xF9, 0x01, 0x00, 0x58].pack('c*'))
 
     # 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))
+    serial_port.should_receive(:write_data).with([0x02, 0x40, 0x03, 0x04, 0xA7, 0xB4, 0x05, 0x00, 0x51].pack('c*'))
+    serial_port.should_receive(:read_data).and_return([0x02, 0x40, 0x03, 0x01, 0x00, 0x42].pack('c*'))
 
     # 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,
+    serial_port.should_receive(:write_data).with([0x02, 0x40, 0x24, 0x06, 0xA7, 0xB4,
+      0x00, 0x01, 0x0A, 0x00, 0x7a].pack('c*'))
+    serial_port.should_receive(:read_data).and_return([0x02, 0x40, 0x24, 0x01, 0x00, 0x65].pack('c*'))
+    serial_port.should_receive(:read_data).and_return([0x02, 0x40, 0xA4, 0x12].pack('c*'))
+    serial_port.should_receive(:read_data).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)
+      0x00, 0x1d].pack('c*'))
+
+    serial_port.should_receive(:usb_close)
+
+    Ftdi::Context.should_receive(:new).and_return(serial_port)
+    Hacklet::Dongle.open(Logger.new('/dev/null')) do |dongle|
+      dongle.lock_network
+      dongle.select_network(0xA7B4)
+      dongle.request_samples(0xA7B4, 0x0001)
     end
   end
 
   it 'can enable a socket' do
-    serial_port = mock("SerialPort")
+    serial_port = double("Context").as_null_object
+
+    # Boot
+    serial_port.should_receive(:write_data).with([0x02, 0x40, 0x04, 0x00, 0x44].pack('c*'))
+    serial_port.should_receive(:read_data).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*'))
+
+    # Boot Confirmation
+    serial_port.should_receive(:write_data).with([0x02, 0x40, 0x00, 0x00, 0x40].pack('c*'))
+    serial_port.should_receive(:read_data).and_return([0x02, 0x40, 0x80, 0x01, 0x10, 0xd1].pack('c*'))
+
+    # Lock Network
+    serial_port.should_receive(:write_data).with([0x02, 0xA2, 0x36, 0x04, 0xFC, 0xFF, 0x00, 0x01, 0x92].pack('c*'))
+    serial_port.should_receive(:read_data).and_return([0x02, 0xA0, 0xF9, 0x01, 0x00, 0x58].pack('c*'))
 
     # 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))
+    serial_port.should_receive(:write_data).with([0x02, 0x40, 0x03, 0x04, 0xA7, 0xB4, 0x05, 0x00, 0x51].pack('c*'))
+    serial_port.should_receive(:read_data).and_return([0x02, 0x40, 0x03, 0x01, 0x00, 0x42].pack('c*'))
 
     # 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)
+    serial_port.should_receive(:write_data).with(request.pack('c*'))
+    serial_port.should_receive(:read_data).and_return([0x02, 0x40, 0x23, 0x01, 0x00, 0x62].pack('c*'))
+
+    serial_port.should_receive(:usb_close)
+
+    Ftdi::Context.should_receive(:new).and_return(serial_port)
+    Hacklet::Dongle.open(Logger.new('/dev/null')) do |dongle|
+      dongle.lock_network
+      dongle.select_network(0xA7B4)
+      dongle.switch(0xA7B4, 0x0000, true)
     end
   end
 end

data/spec/hacklet/serial_connection_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Hacklet::SerialConnection do
+  subject { Hacklet::SerialConnection.new(Logger.new('/dev/null')) }
+
+  describe 'initialization' do
+    it 'creates a serial port with no flow control' do
+      serial_port = double('Context')
+      serial_port.stub(:usb_open).with(0x0403, 0x8c81)
+      serial_port.stub(:set_bitmode).with(0x00, Ftdi::BitbangMode[:reset])
+      serial_port.stub(:baudrate=).with(115200)
+      serial_port.stub(:flowctrl=).with(Ftdi::SIO_DISABLE_FLOW_CTRL)
+      serial_port.stub(:dtr=).with(1)
+      serial_port.stub(:rts=).with(1)
+
+      Ftdi::Context.should_receive(:new).and_return(serial_port)
+      subject
+    end
+  end
+
+  describe 'transmitting' do
+    subject { Hacklet::SerialConnection.new(Logger.new('/dev/null')) }
+
+    it 'is successful' do
+      serial_port = double('Context').as_null_object
+      serial_port.should_receive(:write_data).with([0x02, 0x40, 0x04, 0x00, 0x44].pack('c*'))
+
+      Ftdi::Context.should_receive(:new).and_return(serial_port)
+      subject.transmit(Hacklet::BootRequest.new)
+    end
+  end
+
+  describe 'receiving' do
+    subject { Hacklet::SerialConnection.new(Logger.new('/dev/null')) }
+
+    it 'is successful' do
+      serial_port = double('Context').as_null_object
+      serial_port.should_receive(:read_data).and_return("\x02")
+
+      Ftdi::Context.should_receive(:new).and_return(serial_port)
+      subject.receive(1).should eq("\x02")
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hacklet
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,16 +9,16 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-02 00:00:00.000000000 Z
+date: 2013-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: serialport
+  name: libftdi-ruby
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 0.0.20
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 0.0.20
 - !ruby/object:Gem::Dependency
   name: bindata
   requirement: !ruby/object:Gem::Requirement
@@ -130,10 +130,12 @@ files:
 - lib/hacklet/command.rb
 - lib/hacklet/dongle.rb
 - lib/hacklet/messages.rb
+- lib/hacklet/serial_connection.rb
 - lib/hacklet/version.rb
 - spec/hacklet/command_spec.rb
 - spec/hacklet/dongle_spec.rb
 - spec/hacklet/messages_spec.rb
+- spec/hacklet/serial_connection_spec.rb
 - spec/hacklet_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/mcolyer/hacklet
@@ -165,5 +167,6 @@ test_files:
 - spec/hacklet/command_spec.rb
 - spec/hacklet/dongle_spec.rb
 - spec/hacklet/messages_spec.rb
+- spec/hacklet/serial_connection_spec.rb
 - spec/hacklet_spec.rb
 - spec/spec_helper.rb