geppeto 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b855dd87a61a67b608fe4a597415da91b7d195c5
-  data.tar.gz: 45f40b4054fd0944be4b1f46910a724379f956a8
+  metadata.gz: f338448313065fa0b431a489d521f284d2a0cc34
+  data.tar.gz: eb1459535f6430a18769d5db66f08c2f01f0e284
 SHA512:
-  metadata.gz: e5128825cc150972dd20da7b10cec5600acc1759aad837c11a8ec40793b89f304d0482f84f01d1f2c43624e42f9c79196cd0a63d6f33bf6dbfb149cf979140cc
-  data.tar.gz: c6e0de6d7c18b1080d155b49476db67ec5005655ec00076c8a6275e59c155fa2d57da3311966b3ee1028f83b2c34134864b57b1d4ba5d205b938860e958c8381
+  metadata.gz: c36ea309872190f52aac21dd622bcdc83175301b397f31dc05e9d8f52e7d3d964506092e7ce5439c544f8c9a3c38f81330e2a82c70b02f97ea4269b5b0976f90
+  data.tar.gz: 950a9f443a72c1b1118e02a30d208688be90963be74a0d5b5c630ad8b95d9f53de9492a551a6020ca1338b446fd3ae5bf43f6b0b429cb50f02646fd3cf4b611b

data/.gitignore

@@ -0,0 +1,37 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# rbenv
+.rbenv-gemsets
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+gem 'celluloid-io', '~>0.16'
+gem 'serialport', '~>1.2.3'
+gem 'revolver', '~> 1.1.1'
+
+group :test do
+  gem 'rspec'
+end

data/Gemfile.lock

@@ -0,0 +1,36 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    celluloid (0.16.0)
+      timers (~> 4.0.0)
+    celluloid-io (0.16.1)
+      celluloid (>= 0.16.0)
+      nio4r (>= 1.0.0)
+    diff-lcs (1.2.5)
+    hitimes (1.2.2)
+    nio4r (1.0.1)
+    revolver (1.1.1)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+    serialport (1.2.3)
+    timers (4.0.1)
+      hitimes
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  celluloid-io (~> 0.16)
+  revolver (~> 1.1.1)
+  rspec
+  serialport (~> 1.2.3)

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2014 Matt Heitzenroder
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,143 @@
+# Geppeto
+Geppeto provides a Ruby API over two different transports, either a TCPSocket
+or a serial connection, to the [Pinoccio microcontroller](https://pinocc.io). It
+was created for Pinoccio applications that do not use Pinoccio's `hq.pinocc.io`
+or `api.pinocc.io`. In my case, the Pinoccio microcontrollers existed on a LAN
+that did not have an uplink or gateway to the internet.
+
+## Install
+
+`gem install geppeto`
+
+or add it to your bundler file
+
+`gem "geppeto", `~>0.1.0`
+
+## Usage
+
+The goal with Geppeto is to provide an API that feels like Ruby. Here's an
+example:
+
+```ruby
+require 'geppeto'
+
+serial = Geppeto::Connection::Serial.new
+lead = Geppeto::Scout.new serial
+lead.report
+=> {"type"=>"scout", "lead"=>true, "version"=>1, "hardware"=>1, "family"=>1000, "serial"=>3001731, "sketch"=>"Custom", "build"=>-1, "revision"=>"unknown", "at"=>12642}
+```
+
+Here's an even better example:
+
+```ruby
+lead.pin.digital
+=> {"type"=>"digital", "mode"=>[1, -3, -3, -3, -3, -3, -3], "state"=>[1, -1, -1, -1, -1, -1, -1], "at"=>9303}
+```
+
+You can even issue commands to all or others
+```ruby
+lead.all.led.on
+=> nil
+lead.others.led.off
+=> nil
+lead.led.report
+=> {"type"=>"led", "led"=>[0, 255, 0], "torch"=>[0, 255, 0], "at"=>106676}
+```
+
+If that wasn't exciting enough, you can also delay commands
+```ruby
+lead.delay(5000).led.on
+=> nil
+# 5 seconds later... the led turned on.
+```
+
+### Creating a Scout
+
+```ruby
+id = 2
+serial = Geppeto::Connection::Serial.new
+scout = Geppeto::Scout.new serial, id
+scout.report
+=> nil
+```
+
+That's all well and good, but scout's that are accessible over a `Serial`
+connection return `nil` all requests by result.  One way to obtain data is to
+use a socket server.
+
+### Socket Server
+
+```ruby
+socket = Geppeto::Connection::Server.new
+=> #<Celluloid::CellProxy(Geppeto::Connection::Server:0x3fd00c8cb18c) @history=#<Revolver:0x007fa01918fe00 @array=[], @size=10, @unique=false> @logger=#<Logger:0x007fa01918fd88 @progname=nil, @level=0, @default_formatter=#<Logger::Formatter:0x007fa01918fd60 @datetime_format=nil>, @formatter=nil, @logdev=#<Logger::LogDevice:0x007fa01918fd10 @shift_size=nil, @shift_age=nil, @filename=nil, @dev=#<IO:<STDOUT>>, @mutex=#<Logger::LogDevice::LogDeviceMutex:0x007fa01918fce8 @mon_owner=nil, @mon_count=0, @mon_mutex=#<Mutex:0x007fa01918fc98>>>> @server=#<Celluloid::IO::TCPServer:0x007fa01918f950 @server=#<TCPServer:fd 11>>>
+```
+
+Now we have a socket server that will capture and parse the JSON responses.  
+
+```ruby
+lead.hq.setaddress("10.0.1.22")
+=> nil
+lead.wifi.reassociate
+=> nil
+socket.history
+=> #<Revolver:0x007fee22ac9fa0
+ @array=[{"type"=>"report", "from"=>2, "report"=>{"type"=>"temp", "c"=>31, "f"=>88, "offset"=>0, "at"=>3540003}}],
+ @size=10,
+ @unique=false>
+
+```
+
+Note that the socket server has a `history` attribute. Because of the limitations
+with socket communication with pinoccio, we're capturing all of the responses in
+a fixed sized LIFO array.
+
+Nowe we can have our scout send us a report
+
+```ruby
+scout.hq.print("Hello, world!")
+socket.history
+=> #<Revolver:0x007fee22ac9fa0
+ @array=
+  [{"type"=>"report", "from"=>2, "report"=>{"type"=>"temp", "c"=>31, "f"=>88, "offset"=>0, "at"=>3540003}},
+   {"type"=>"report", "from"=>1, "report"=>{"type"=>"temp", "c"=>32, "f"=>90, "offset"=>0, "at"=>197667}},
+   {"type"=>"report", "from"=>2, "report"=>{"type"=>"temp", "c"=>30, "f"=>88, "offset"=>0, "at"=>3600003}},
+   {"type"=>"announce", "from"=>2, "announce"=>[0, "Hello, world!"]}],
+ @size=10,
+ @unique=false>
+ ```
+
+ ### Constants
+
+ Most of the time, arguments sent to the scouts are just strings and integers;
+ however occasionally we may need to send a constant. This can be achieved by
+ sending a ruby `Symbol` instead. Such is the case with pins, as seen here:
+
+ ```ruby
+ scout.pin.save("d2", :OUTPUT, :HIGH)
+ socket.history.pop
+=> {"type"=>"report",
+ "from"=>2,
+ "report"=>{"type"=>"digital", "mode"=>[1, -3, -3, -3, -3, -3, -3], "state"=>[1, -1, -1, -1, -1, -1, -1], "at"=>3938541}}
+```
+
+## What about...
+
+### Tests
+Well this is embarrassing... If I knew how to mock out a Pinoccio, Serial, or
+Socket connection, I'd provide tests.  If you're interested in contributing, and
+you know how to test this library, by all means, please send a pull request.
+
+### Where did the "t" go?
+Yes, Geppeto is purposely misspelled. If you're familiar with Pinoccio, you might
+recognize that the "h" is missing.  This is explained on [Pinoccio's website](https://pinocc.io/faq#faq-wheres-the-h).
+
+### What's missing?
+Besides tests... a few things:
+
+* [Events Callback Support](https://docs.pinocc.io/scoutcommands.html#event-callbacks)
+* [Scout Acknowledgement Callback](https://docs.pinocc.io/scoutcommands.html#command-scout-ack)
+* [Keys](https://docs.pinocc.io/scoutcommands.html#keys-deprecated)
+
+### What's next?
+Should there be a `Thor` backed CLI executable to manage a standalone socket server?
+Or maybe I'll figure out how to write tests.

data/Rakefile

@@ -0,0 +1,9 @@
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec)
+
+  task :default => :spec
+rescue LoadError
+  # no rspec available
+end

data/geppeto.gemspec

@@ -0,0 +1,23 @@
+Gem::Specification.new do |s|
+  s.name        = 'geppeto'
+  s.version     = '0.1.1'
+  s.date        = '2014-10-29'
+  s.summary     = "Geppeto makes Pinoccio into Ruby."
+  s.description = "Geppeto provides a Ruby API to Pinoccio microcontrollers by means of a TCPsocket or a Serial connection, forgoing the need to use api.pinocc.io."
+  s.authors     = ["Matt Heitzenroder"]
+  s.email       = 'mheitzenroder@gmail.com'
+  s.homepage    =
+    'http://github.com/roder/geppeto'
+  s.license       = 'Apache-2.0'
+
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ['lib']
+
+  s.add_runtime_dependency 'serialport', '~> 1.2'
+  s.add_runtime_dependency 'celluloid-io', '~> 0.16'
+  s.add_runtime_dependency 'revolver', '~> 1.1'
+  s.add_development_dependency 'bundler', '~> 1.7'
+  s.add_development_dependency 'rake', '~> 10'
+end

data/lib/commands/commands.rb

@@ -0,0 +1,16 @@
+require 'commands/events'
+require 'commands/hq'
+require 'commands/led'
+require 'commands/memory'
+require 'commands/mesh'
+require 'commands/pin'
+require 'commands/power'
+require 'commands/uptime'
+require 'commands/wifi'
+
+module Geppeto
+  module Commands
+    class NotLeadScout < Exception
+    end
+  end
+end

data/lib/commands/events.rb

@@ -0,0 +1,21 @@
+module Geppeto
+  module Commands
+    class Events
+      def initialize(scout)
+        @scout = scout
+      end
+
+      def start
+        @scout.request("events.start")
+      end
+
+      def stop
+        @scout.request("events.stop")
+      end
+
+      def setcycle(digitalMs, analogMs, peripheralMs)
+        @scout.request("events.setcycle", digitalMs, analogMs, peripheralMs )
+      end
+    end
+  end
+end

data/lib/commands/hq.rb

@@ -0,0 +1,29 @@
+module Geppeto
+  module Commands
+    class Hq
+      def initialize(scout)
+        @scout = scout
+      end
+
+      def setaddress(host, port = nil)
+        @scout.request("hq.setaddress", host, port)
+      end
+
+      def print(str)
+        @scout.request("hq.print", str)
+      end
+
+      def settoken(token)
+        @scout.request("hq.settoken", token)
+      end
+
+      def gettoken
+        @scout.request("hq.gettoken")
+      end
+
+      def report(report_name, value)
+        @scout.request("hq.report", report_name, value)
+      end
+    end
+  end
+end

data/lib/commands/led.rb

@@ -0,0 +1,89 @@
+module Geppeto
+  module Commands
+    class Led
+      def initialize(scout)
+        @scout = scout
+      end
+
+      def on?
+        isoff().to_i != 1
+      end
+
+      def off?
+        isoff().to_i == 1
+      end
+
+      def on
+        @scout.request("led.on")
+      end
+
+      def off
+        @scout.request("led.off")
+      end
+
+      def red(ms = nil, continuous = nil)
+        @scout.request("led.red", ms, continuous)
+      end
+
+      def green(ms = nil, continuous = nil)
+        @scout.request("led.green", ms, continuous)
+      end
+
+      def blue(ms = nil, continuous = nil)
+        @scout.request("led.blue", ms, continuous)
+      end
+
+      def cyan(ms = nil, continuous = nil)
+        @scout.request("led.cyan", ms, continuous)
+      end
+
+      def purple(ms = nil, continuous = nil)
+        @scout.request("led.purple", ms, continuous)
+      end
+
+      def magenta(ms = nil, continuous = nil)
+        @scout.request("led.magenta", ms, continuous)
+      end
+
+      def yellow(ms = nil, continuous = nil)
+        @scout.request("led.yellow", ms, continuous)
+      end
+
+      def orange(ms = nil, continuous = nil)
+        @scout.request("led.orange", ms, continuous)
+      end
+
+      def white(ms = nil, continuous = nil)
+        @scout.request("led.white", ms, continuous)
+      end
+
+      def torch(ms = nil, continuous = nil)
+        @scout.request("led.torch", ms, continuous )
+      end
+
+      def blink(red, green, blue, millis=500, continuous = nil)
+        @scout.request("led.blink", red, green, blue, millis, continuous)
+      end
+
+      def sethex(hex_value)
+        @scout.request("led.sethex", hex_value)
+      end
+
+      def gethex
+        @scout.request("led.gethex")
+      end
+
+      def setrgb(red, green, blue)
+        @scout.request("led.setrgb", red, green, blue)
+      end
+
+      def isoff
+        @scout.request("led.isoff")
+      end
+
+      def report
+        @scout.request("led.report")
+      end
+    end
+  end
+end

data/lib/commands/memory.rb

@@ -0,0 +1,13 @@
+module Geppeto
+  module Commands
+    class Memory
+      def initialize(scout)
+        @scout = scout
+      end
+
+      def report
+        @scout.request("memory.report")
+      end 
+    end
+  end
+end

data/lib/commands/mesh.rb

@@ -0,0 +1,49 @@
+module Geppeto
+  module Commands
+    class Mesh
+      def initialize(scout)
+        @scout = scout
+      end
+
+      def config(scout_id, troop_id, channel=20)
+        @scout.request("mesh.config", scout_id, troop_id, channel)
+      end
+
+      def setpowerlevel(level)
+        @scout.request("mesh.setpowerlevel", level.to_i)
+      end
+
+      def setdatarate(rate)
+        @scout.request("mesh.setdatarate", rate.to_i)
+      end
+
+      def setkey(key)
+        @scout.request("mesh.setkey", key)
+      end
+
+      def resetkey
+        @scout.request("mesh.resetkey")
+      end
+
+      def joingroup(group)
+        @scout.request("mesh.joingroup", group.to_i)
+      end
+
+      def leavegroup(group)
+        @scout.request("mesh.leavegroup", group.to_i)
+      end
+
+      def ingroup?(group)
+        @scout.request("mesh.ingroup").to_i == 1
+      end
+
+      def report
+        @scout.request("mesh.report")
+      end
+
+      def routing
+        @scout.request("mesh.routing")
+      end
+    end
+  end
+end

data/lib/commands/pin.rb

@@ -0,0 +1,57 @@
+module Geppeto
+  module Commands
+    class Pin
+      def initialize(scout)
+        @scout = scout
+      end
+
+      def makeinput(pin_name, input_type=:INPUT_PULLUP)
+        @scout.request("pin.makeinput", pin_name, input_type)
+      end
+
+      def makeoutput(pin_name)
+        @scout.request("pin.makeoutput", pin_name)
+      end
+
+      def makepwm(pin_name)
+        @scout.request("pin.makepwm", pin_name)
+      end
+
+      def disable(pin_name)
+        @scout.request("pin.disable", pin_name)
+      end
+
+      def setmode(pin_name, input_type=:INPUT_PULLUP)
+        @scout.request("pin.setmode", pin_name, input_type)
+      end
+
+      def read(pin_name)
+        @scout.request("pin.read", pin_name)
+      end
+
+      def write(pin_name, pin_value)
+          @scout.request("pin.write", pin_name, pin_value)
+      end
+
+      def save(pin_name, pin_mode, pin_value = nil)
+        @scout.request("pin.save", pin_name, pin_mode, pin_value)
+      end
+
+      def status
+        @scout.request("pin.status")
+      end
+
+      def report
+        self
+      end
+
+      def analog
+        @scout.request("pin.report.analog")
+      end
+
+      def digital
+        @scout.request("pin.report.digital")
+      end
+    end
+  end
+end

data/lib/commands/power.rb

@@ -0,0 +1,45 @@
+module Geppeto
+  module Commands
+    class Power
+      def initialize(scout)
+        @scout = scout
+      end
+
+      def charging?
+        @scout.request("power.ischarging").to_i == 1
+      end
+
+      def battery?
+        @scout.request("power.hasbattery").to_i == 1
+      end
+
+      def percent
+        @scout.request("power.percent").to_i
+      end
+
+      def voltage
+        @scout.request("power.voltage").to_i
+      end
+
+      def enablevcc
+        @scout.request("power.enablevcc")
+      end
+
+      def disablevcc
+        @scout.request("power.disablevcc")
+      end
+
+      def vcc?
+        @scout.request("power.isvccenabled").to_i == 1
+      end
+
+      def sleep(ms, command = nil)
+        @scout.request("power.sleep", ms, command)
+      end
+
+      def report
+        @scout.request("power.report")
+      end
+    end
+  end
+end

data/lib/commands/temperature.rb

@@ -0,0 +1,29 @@
+module Geppeto
+  module Commands
+    class Temperature
+      def initialize(scout)
+        @scout = scout
+      end
+
+      def c
+        @scout.request("temperature.c")
+      end
+
+      def f
+        @scout.request("temperature.f")
+      end
+
+      def report
+        @scout.request("temperature.report")
+      end
+
+      def setoffset(offset)
+        @scout.request("temperature.offset", offset)
+      end
+
+      def calibrate(current_temp_c)
+        @scout.request("temperature.calibrate", current_temp_c)
+      end
+    end
+  end
+end

data/lib/commands/uptime.rb

@@ -0,0 +1,47 @@
+module Geppeto
+  module Commands
+    class Uptime
+
+      def initialize(scout)
+        @context = nil
+        @scout = scout
+      end
+
+      def micros
+        context ||= ".#{@context}" unless @context.nil?
+        command = "uptime#{context}.micros"
+        @scout.request(command)
+        @context = nil
+      end
+
+      def seconds
+        context ||= ".#{@context}" unless @context.nil?
+        command = "uptime#{context}.seconds"
+        @scout.request(command)
+        @context = nil
+      end
+
+      def report
+        @scout.request("uptime.report")
+      end
+
+      def getlastreset
+        @scout.request("uptime.getlastreset")
+      end
+
+      def status
+        @scout.request("uptime.status")
+      end
+
+      def awake
+        @context = :awake
+        self
+      end
+
+      def sleeping
+        @context = :sleeping
+        self
+      end
+    end
+  end
+end

data/lib/commands/wifi.rb

@@ -0,0 +1,41 @@
+module Geppeto
+  module Commands
+    class Wifi
+      def initialize(scout)
+        @scout = scout
+      end
+
+      def report
+        @scout.request("wifi.report")
+      end
+
+      def status
+        @scout.request("wifi.status")
+      end
+
+      def list
+        @scout.request("wifi.list", ms: 5)
+      end
+
+      def config(ssid, psk = nil)
+        @scout.request("wifi.config", ssid, psk)
+      end
+
+      def dhcp(hostname)
+        @scout.request("wifi.dhcp", hostname)
+      end
+
+      def static(ip, netmask, gateway, dns)
+        @scout.request("wifi.static", ip, netmask, gateway, dns)
+      end
+
+      def reassociate
+        @scout.request("wifi.reassociate")
+      end
+
+      def command(wifi_cmd)
+        @scout.request("wifi.command", wifi_cmd)
+      end
+    end
+  end
+end

data/lib/connections/connections.rb

@@ -0,0 +1,9 @@
+require 'connections/serial'
+require 'connections/server'
+
+require 'json'
+
+module Geppeto
+  module Connection
+  end
+end

data/lib/connections/serial.rb

@@ -0,0 +1,60 @@
+require 'serialport'
+
+module Geppeto
+  module Connection
+    class Serial
+      attr_accessor :logger
+
+      def initialize(port = false, baud = 115200, logger = nil)
+        @logger = logger.nil? ? Logger.new(STDOUT) : logger
+        port ||= `ls /dev`.split("\n").grep(/tty.usb/i).map{|d| "/dev/#{d}"}.first #TODO: Check that this works on RPi/Begalbone OSs
+        @serial = SerialPort.new(port, baud)
+        @serial.read_timeout = 100
+        sleep 1
+        begin
+          @logger.debug(@serial.read_nonblock(4096))
+        rescue EOFError
+          # no data
+        end
+        @logger.info("Pinoccio Serial Connection started: #{port}")
+      end
+
+      def shutdown
+        @serial.close if @serial
+      rescue IOError
+        @logger.warn("Pinoccio Serial Connection closed.")
+      end
+
+      def write(command, ms = nil)
+        @serial.write command+"\n"
+        ms ||= 0.1
+        sleep ms
+        read command
+      end
+
+      def read(command = nil)
+        begin
+          raw_result = @serial.read_nonblock(4096)
+          if command.nil?
+            raw_result
+          else
+            cmd = Regexp.escape(command)
+            matches = /#{cmd}\r\n(?<response>.*)\r\n>\s.*/m.match(raw_result)
+            if matches[:response]
+              begin
+                JSON.parse(matches[:response])
+              rescue
+                matches[:response]
+              end
+            else
+              raw_result
+            end
+          end
+        rescue
+          nil
+        end
+      end
+
+    end
+  end
+end

data/lib/connections/server.rb

@@ -0,0 +1,73 @@
+require 'celluloid/io'
+require 'revolver'
+
+module Geppeto
+  module Connection
+    class Server
+      include Celluloid::IO
+      finalizer :shutdown
+
+      attr_accessor :logger
+      attr_accessor :history
+
+      def initialize(host="0.0.0.0", port = 22756, logger = nil)
+        @history = Revolver.new(10)
+        @logger = logger.nil? ? ::Logger.new(STDOUT) : logger
+        @logger.info("Starting Pinoccio Server on #{host}:#{port}")
+        @server = TCPServer.new(host, port)
+        async.run
+      end
+
+      def shutdown
+        @server.close if @server
+      rescue IOError
+        @logger.warn("Pinoccio Server shutting down")
+      end
+
+      def format_cmd(scout, command)
+        cmd = {
+          :to => scout.to_i,
+          :command => command.to_s,
+          :id => 1,
+          :timeout => 10000,  # TODO: Make this configurable.
+          :type => "command",
+        }
+        cmd.to_json + "\n"
+      end
+
+      def send(scout, command)
+        @logger.debug("Scout #{scout}: #{command}")
+        if @socket.nil?
+          @logger.warn("No socket connected")
+        else
+          @socket.write format_cmd(scout, command)
+        end
+      end
+
+      def run
+        loop { async.handle_connection @server.accept }
+      end
+
+      def handle_connection(socket)
+        _, port, host = socket.peeraddr
+        @logger.info("Connected: #{host}:#{port}")
+        chunk = socket.gets
+        data = JSON.parse(chunk)
+        token = data["token"]
+        @socket = socket
+        @logger.debug("Connected token: #{token}")
+        loop {
+          chunk = @socket.gets.chomp!
+          data = JSON.parse(chunk)
+          @history << data
+          @logger.debug("Received: #{data}")
+        }
+      rescue
+        @logger.info("Disconnected: #{host}:#{port}")
+        @socket.close
+        @logger.debug("Removed token: #{token}")
+        @socket = nil
+      end
+    end
+  end
+end

data/lib/geppeto.rb

@@ -0,0 +1,9 @@
+require 'commands/commands'
+require 'connections/connections'
+require 'scout'
+
+require 'logger'
+
+
+module Geppeto
+end

data/lib/scout.rb

@@ -0,0 +1,127 @@
+module Geppeto
+  class Scout
+    attr_reader :id
+    attr_accessor :last_report
+    attr_accessor :logger
+
+    attr_reader :events
+    attr_reader :hq
+    attr_reader :led
+    attr_reader :memory
+    attr_reader :mesh
+    attr_reader :pin
+    attr_reader :power
+    attr_reader :temperature
+    attr_reader :uptime
+    attr_reader :wifi
+
+    def initialize(connection, id = nil)
+      @id = id
+      @conn = connection
+      @options = Array.new
+      @logger = @conn.logger ? @conn.logger : Logger.new(STDOUT)
+
+      @events = Geppeto::Commands::Events.new(self)
+      @hq  = Geppeto::Commands::Hq.new(self)
+      @led = Geppeto::Commands::Led.new(self)
+      @memory = Geppeto::Commands::Memory.new(self)
+      @mesh = Geppeto::Commands::Mesh.new(self)
+      @pin = Geppeto::Commands::Pin.new(self)
+      @power = Geppeto::Commands::Power.new(self)
+      @uptime = Geppeto::Commands::Uptime.new(self)
+      @wifi = Geppeto::Commands::Wifi.new(self)
+    end
+
+    def all
+      @options << :all
+      self
+    end
+
+    def others
+      @options << :others
+      self
+    end
+
+    def report
+      request("scout.report")
+    end
+
+    def lead?
+      request("print scout.isleadscout").to_i == 1
+    end
+
+    def randomnumber
+      request("randomnumber")
+    end
+
+
+
+    def delay(ms = nil)
+      @options << :delay
+      @_ms = ms
+      self
+    end
+
+    def boot
+      request("scout.boot")
+    end
+
+    def request(command, *args, ms: nil)
+      args_string = join_args(args)
+      command, args_string = process_options(command, args_string)
+
+      if args_string.empty?
+        unless @id.nil?
+          command = "command.scout(#{@id}, \"#{command}\")"
+        else
+          command = "#{command}()"
+        end
+      else
+        unless @id.nil?
+          command = "command.scout(#{@id}, \"#{command}\", #{args_string})"
+        else
+          command = "#{command}(#{args_string})"
+        end
+      end
+
+      @logger.debug("Issuing: #{command}")
+      @conn.write(command, ms)
+    end
+
+    private
+    def process_options(command, arg_string)
+      arg_string = "\"#{command}(#{arg_string})\"" unless @options.empty?
+      case @options.shift
+      when :all
+        command = "command.all"
+        process_options(command, arg_string)
+      when :others
+        command = "command.others"
+        process_options(command, arg_string)
+      when :delay
+        command = "scout.delay"
+        arg_string = "#{@_ms}, #{arg_string}"
+        @_ms = false
+        process_options(command, arg_string)
+      else
+        arg_string.gsub(/"/, "\\\"") unless arg_string.empty?
+        return command, arg_string
+      end
+    end
+
+    def join_args(args)
+      arg_str = String.new
+      n = 0
+      args.each { |arg|
+        if arg.class == String
+          arg_str << "\"#{arg}\""
+        else
+          arg_str << arg.to_s
+        end
+        n += 1
+        arg_str << ", " if n < args.length && args[n].class != NilClass
+      }
+      arg_str
+    end
+  end
+end

data/spec/geppeto_spec.rb

@@ -0,0 +1,10 @@
+require './spec/spec_helper.rb'
+require 'rspec'
+
+RSpec.describe Geppeto do
+  # TODO:
+  # Listen, I know, it's bad.  I just don't know how to test this.  Maybe since
+  # you're looking at it, you could help - let me know.  I just didn't know where 
+  # to start.
+  #
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require_relative '../lib/serial'
+require_relative '../lib/server'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: geppeto
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Matt Heitzenroder
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-11 00:00:00.000000000 Z
+date: 2014-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: serialport
@@ -86,7 +86,32 @@ email: mheitzenroder@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- geppeto.gemspec
+- lib/commands/commands.rb
+- lib/commands/events.rb
+- lib/commands/hq.rb
+- lib/commands/led.rb
+- lib/commands/memory.rb
+- lib/commands/mesh.rb
+- lib/commands/pin.rb
+- lib/commands/power.rb
+- lib/commands/temperature.rb
+- lib/commands/uptime.rb
+- lib/commands/wifi.rb
+- lib/connections/connections.rb
+- lib/connections/serial.rb
+- lib/connections/server.rb
+- lib/geppeto.rb
+- lib/scout.rb
+- spec/geppeto_spec.rb
+- spec/spec_helper.rb
 homepage: http://github.com/roder/geppeto
 licenses:
 - Apache-2.0
@@ -107,8 +132,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.1
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Geppeto makes Pinoccio into Ruby.
-test_files: []
+test_files:
+- spec/geppeto_spec.rb
+- spec/spec_helper.rb