pinoccio 0.1.0

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+pkg/*

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gem "faraday"

data/Gemfile.lock

@@ -0,0 +1,12 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    faraday (0.9.0)
+      multipart-post (>= 1.2, < 3)
+    multipart-post (2.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  faraday

data/README.md

@@ -0,0 +1,46 @@
+Pinoccio Ruby API
+=================
+
+This library gives access to the pinoccio REST API to configure and manage Troops & Scouts. It additionally bundles all the built in ScoutScript commands so that you can command your Scouts straight from Ruby.
+
+Example
+-------
+
+    require "pinoccio"
+
+    # Login to the API
+    client = Pinoccio::Client.new(USERNAME, PASSWORD) # or alternatively a valid API token
+    puts client.account.inspect
+
+    # get a handle to the first Troop (You'll most likely only have one)
+    troop = client.troops.first
+
+    # get the lead scout in this troop
+    lead_scout = troop.scouts.lead
+
+    # dump out some data about the scout
+    puts lead_scout.get('led.report')
+    puts lead_scout.power.charging?.inspect
+    puts lead_scout.power.percent.inspect
+    puts lead_scout.power.voltage.inspect
+    puts lead_scout.power.report
+
+    # create a new 'blink' function and print a list off all registered functions
+    lead_scout.functions.add(:blink, "if (led.isoff) { led.cyan; } else { led.off; }")
+    puts lead_scout.functions.list.inspect
+
+    # run the blink function every 250ms for 3 seconds
+    lead_scout.functions.repeat(:blink, 250)
+    puts lead_scout.functions.running.inspect
+    sleep(3)
+
+    # stop the blink function and ensure the LED is off when we finish
+    lead_scout.functions.stop(:blink)
+    lead_scout.led.off
+
+
+Notes
+-----
+- I've not implemented the full API yet, only really enough to read data so far.
+- sometimes the API throws timeout errors, you can rescue and retry these by catching Pinoccio::TimeoutError
+- This is just a little playground, no tests yet, use at your own risk.

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/client.rb

@@ -0,0 +1,60 @@
+module Pinoccio
+  class Client
+    attr_reader :token
+
+    def initialize(email_or_token, password=nil)
+      @connection = Faraday.new(:url => 'https://api.pinocc.io/')
+      if password.nil?
+        @token = email_or_token
+      else
+        login(email_or_token, password)
+      end
+    end
+
+    def login(email, password)
+      response = post("login", email: email, password: password)
+      @token = response.token
+    end
+
+    def account
+      get "account"
+    end
+
+    def troops
+      TroopCollection.new(self)
+    end
+
+    def get(path, data={})
+      data = {token:@token}.merge(data) if @token
+      response = @connection.get("/v1/#{path}", data)
+      handle_response(response)
+    end
+
+    def post(path, data={})
+      data = {token:@token}.merge(data) if @token
+      response = @connection.post("/v1/#{path}", data)
+      handle_response(response)
+    end
+
+    private
+
+    def handle_response(response)
+      hsh = JSON.parse(response.body)
+      handle_error(hsh['error']) if hsh['error']
+      data = hsh['data']
+      if data.is_a? Array
+        data.map {|d| OpenStruct.new(d) }
+      else
+        OpenStruct.new(data)
+      end
+    end
+
+    def handle_error(err)
+      if err['message'] && (err['message'] =~ /timeout/ || err['message'] =~ /timed out/)
+        raise Pinoccio::TimeoutError.new(err)
+      else
+        raise Pinoccio::Error.new(err)
+      end
+    end
+  end
+end

data/lib/commands.rb

@@ -0,0 +1,351 @@
+module Pinoccio
+  module Commands
+    def lead?
+      @is_lead ||= get("scout.isleadscout", :boolean)
+    end
+
+    def report
+      get("scout.report", :json)
+    end
+
+    def daisy!
+      execute("scout.daisy")
+      execute("scout.daisy")
+    end
+
+    def boot
+      execute("scout.boot")
+    end
+
+    def temperature
+      get("temperature", :integer)
+    end
+
+    def random_number
+      get("randomnumber", :integer)
+    end
+
+    def uptime
+      get("uptime", :integer)
+    end
+
+    def power
+      PowerCommands.new(self)
+    end
+
+    def led
+      LedCommands.new(self)
+    end
+
+    def wifi
+      WifiCommands.new(self)
+    end
+
+    def mesh
+      MeshCommands.new(self)
+    end
+
+    def pin
+      PinCommands.new(self)
+    end
+
+    def events
+      EventsCommands.new(self)
+    end
+
+    def functions
+      FunctionCommands.new(self)
+    end
+  end
+
+
+
+  class CommandCollection
+    def initialize(target)
+      @target = target
+    end
+
+    def get(command, type=nil)
+      @target.get(command, type)
+    end
+
+    def run(command, type=nil)
+      @target.run(command)
+    end
+
+    def execute(command)
+      @target.execute(command)
+    end
+  end
+
+
+
+  class PowerCommands < CommandCollection
+    def charging?
+      get("power.ischarging", :boolean)
+    end
+
+    def percent
+      get("power.percent", :integer)
+    end
+
+    def voltage
+      get("power.voltage", :integer)
+    end
+
+    def enable_vcc
+      execute("power.enable_vcc")
+    end
+
+    def disable_vcc
+      execute("power.disable_vcc")
+    end
+
+    def report
+      run("power.report", :json)
+    end
+  end
+
+
+
+  class LedCommands < CommandCollection
+    def blink(r, g, b, ms=nil, continuous=nil)
+      if ms.nil?
+        execute("led.blink(#{r}, #{g}, #{b})")
+      elsif continuous.nil?
+        execute("led.blink(#{r}, #{g}, #{b}, #{ms})")
+      else
+        continuous = (continuous == 1)
+        execute("led.blink(#{r}, #{g}, #{b}, #{ms}, #{continuous})")
+      end
+    end
+
+    def off; execute("led.off"); end
+    def red; execute("led.red"); end
+    def green; execute("led.green"); end
+    def blue; execute("led.blue"); end
+    def cyan; execute("led.cyan"); end
+    def purple; execute("led.purple"); end
+    def magenta; execute("led.magenta"); end
+    def yellow; execute("led.yellow"); end
+    def orange; execute("led.orange"); end
+    def white; execute("led.white"); end
+    def torch; execute("led.torch"); end
+
+    def hex=(value)
+      execute(%[led.sethex("#{value}")])
+    end
+
+    def rgb=(r, g, b)
+      execute(%[led.setrgb(#{r}, #{g}, #{b})])
+    end
+
+    def torch=(r, g, b)
+      execute(%[led.savetorch(#{r}, #{g}, #{b})])
+    end
+
+    def report
+      run("led.report", :json)
+    end
+  end
+
+
+
+  class WifiCommands < CommandCollection
+    def report
+      run("wifi.report", :json)
+    end
+
+    def status
+      get('wifi.status')
+    end
+
+    def list
+      get('wifi.list')
+    end
+
+    def config(name, password)
+      execute(%[wifi.config("#{name}", "#{password}")])
+    end
+
+    def reassociate
+      execute("wifi.reassociate")
+    end
+
+    def connect(name, password)
+      config(name, password)
+      reassociate
+      report
+    end
+
+    def command(cmd)
+      get(%[wifi.command("#{cmd}")])
+    end
+  end
+
+
+  class MeshCommands < CommandCollection
+    def config(scout_id, troop_id, channel=20)
+      get(%[mesh.config(#{scout_id}, #{troop_id}, #{channel})])
+    end
+
+    def power=(level)
+      execute("mesh.setpower(#{level})")
+    end
+
+    def datarate=(rate)
+      execute("mesh.datarate(#{rate})")
+    end
+
+    def key=(k)
+      execute(%[mesh.setkey("#{k}")])
+    end
+
+    def key
+      get("mesh.getkey")
+    end
+
+    def reset_key
+      execute("mesh.resetkey")
+    end
+
+    def join_group(group_id)
+      execute("mesh.joingroup(#{group_id})")
+    end
+
+    def leave_group(group_id)
+      execute("mesh.leavegroup(#{group_id})")
+    end
+
+    def in_group?(group_id)
+      execute("mesh.ingroup(#{group_id})")
+    end
+
+    def send_message(scout_id, msg)
+      execute(%[mesh.send(#{scout_id}, "#{msg}")])
+    end
+
+    def report
+      run("mesh.report", :json)
+    end
+
+    def routing
+      get("mesh.routing")
+    end
+
+    def announce(group_id, msg)
+      execute(%[mesh.announce(#{group_id}, "#{msg}")])
+    end
+
+    def signal
+      get('mesh.signal', :integer)
+    end
+  end
+
+  class PinCommands < CommandCollection
+    INPUT         = "INPUT"
+    OUTPUT        = "OUTPUT"
+    INPUT_PULLUP  = "INPUT_PULLUP"
+    DISABLED      = "DISABLED"
+    HIGH          = "HIGH"
+    LOW           = "LOW"
+
+    def make_input(pin, pullup=INPUT_PULLUP)
+      execute(%[pin.makeinput("#{pin}", #{pullup})])
+    end
+
+    def make_output(pin)
+      execute(%[pin.makeoutput("#{pin}")])
+    end
+
+    def disable(pin)
+      execute(%[pin.disable("#{pin}")])
+    end
+
+    def set_mode(pin, mode)
+      execute(%[pin.setmode("#{pin}", #{mode})])
+    end
+
+    def read(pin)
+      get(%[pin.read("#{pin}")], :integer)
+    end
+
+    def write(pin, value)
+      execute(%[pin.write("#{pin}", value)], :integer)
+    end
+
+    def report_digital
+      get('pin.report.digital', :json)
+    end
+
+    def report_analog
+      get('pin.report.analog', :json)
+    end
+  end
+
+  class EventsCommands < CommandCollection
+    def start
+      execute("events.start")
+    end
+
+    def stop
+      execute("events.stop")
+    end
+
+    def set_cycle(digital_ms=50, analogue_ms=60_000, peripheral_ms=60_000)
+      execute("events.setcycle(#{digital_ms}, #{analogue_ms}, #{peripheral_ms})")
+    end
+  end
+
+  class FunctionCommands < CommandCollection
+    def list
+      ls = run('ls')
+      ls.split(/\r?\n/).reduce({}) do |hsh, fn|
+        matches = fn.match(/function ([a-z0-9]+) \{/)
+        hsh[matches[1]] = fn
+        hsh
+      end
+    end
+
+    def remove(fn)
+      execute("rm #{fn}")
+    end
+
+    def remove_all
+      execute("rm *")
+    end
+
+    def repeat(fn, delay)
+      execute("run #{fn}, #{delay}")
+    end
+
+    def stop(pid)
+      pid = pid_for(pid) unless pid.is_a?(Integer)
+      execute("stop #{pid}") if pid
+    end
+
+    def add(name, body=nil)
+      body = name if body.nil?
+      body = "function #{name} { #{body} }" unless body =~ /^function /
+      execute(body)
+    end
+
+    def startup(body)
+      add(:startup, body)
+    end
+
+    def pid_for(fn)
+      process = running.find {|p| p[:function].to_s == fn.to_s }
+      return process[:pid] if process
+      nil
+    end
+
+    def running
+      ps = run("ps")
+      ps.split(/\r?\n/).map do |line|
+        pid, fn = *line.split(": ")
+        {pid: pid.to_i, function: fn}
+      end
+    end
+  end
+end

data/lib/pinoccio.rb

@@ -0,0 +1,17 @@
+require "faraday"
+require "json"
+require "ostruct"
+
+require_relative "./client"
+require_relative "./troop_collection"
+require_relative "./troop"
+require_relative "./scout_collection"
+require_relative "./scout"
+
+module Pinoccio
+  class Error < StandardError
+  end
+
+  class TimeoutError < Error
+  end
+end

data/lib/scout.rb

@@ -0,0 +1,37 @@
+require_relative "./commands"
+
+module Pinoccio
+  class Scout
+    include Commands
+
+    attr_reader :troop, :id
+
+    def initialize(client, troop, props)
+      @client = client
+      @troop = troop
+      @id = props.id
+    end
+
+    def get(command, type=nil)
+      run("print #{command}", type)
+    end
+
+    def run(command, type=nil)
+      result = execute(command).reply.strip
+      case type
+        when :boolean
+          result == "1"
+        when :integer
+          result.to_i
+        when :json
+          JSON.parse(result)
+        else
+          result
+      end
+    end
+
+    def execute(command)
+      @client.get("#{@troop.id}/#{@id}/command", command: command)
+    end
+  end
+end

data/lib/scout_collection.rb

@@ -0,0 +1,27 @@
+module Pinoccio
+  class ScoutCollection
+    def initialize(client, troop)
+      @client = client
+      @troop = troop
+    end
+
+    def first
+      all.first
+    end
+
+    def lead
+      all.find {|scout| scout.lead? }
+    end
+
+    def all
+      result = @client.get("#{@troop.id}/scouts")
+      result = [result] unless result.is_a?(Array)
+      result.map {|s| Scout.new(@client, @troop, s) }
+    end
+
+    def get(scout_id)
+      result = @client.get("#{@troop.id}/#{scout_id}")
+      Scout.new(@client, @troop, result)
+    end
+  end
+end

data/lib/troop.rb

@@ -0,0 +1,41 @@
+require_relative "./commands"
+
+module Pinoccio
+  class Troop
+    include Commands
+
+    attr_reader :account, :id, :online, :name
+
+    def initialize(client, props)
+      @client = client
+      @account = props.account
+      @id = props.id
+      @online = props.online
+      @name = props.name
+    end
+
+    def scouts
+      ScoutCollection.new(@client, self)
+    end
+
+    def run(command, type=nil)
+      collect_across_all { |scout| scout.run(command, type) }
+    end
+
+    def get(command, type=nil)
+      collect_across_all { |scout| scout.get(command, type) }
+    end
+
+    def execute(command)
+      collect_across_all { |scout| scout.execute(command) }
+    end
+
+    private
+    def collect_across_all(&blk)
+      scouts.all.reduce({}) do |hsh, scout|
+        hsh[scout.id] = yield(scout)
+        hsh
+      end
+    end
+  end
+end

data/lib/troop_collection.rb

@@ -0,0 +1,22 @@
+module Pinoccio
+  class TroopCollection
+    def initialize(client)
+      @client = client
+    end
+
+    def first
+      all.first
+    end
+
+    def all
+      result = @client.get("troops")
+      result = [result] unless result.is_a?(Array)
+      result.map {|t| Troop.new(@client, t) }
+    end
+
+    def get(troop_id)
+      result = @client.get("troops/#{troop_id}")
+      Troop.new(@client, result)
+    end
+  end
+end

data/pinoccio.gemspec

@@ -0,0 +1,15 @@
+Gem::Specification.new do |gem|
+  gem.authors       = ["Andy Kent"]
+  gem.email         = ["andy.kent@me.com"]
+  gem.description   = %q{This library gives access to the pinoccio REST API to configure and manage Troops & Scouts. It additionally bundles all the built in ScoutScript commands so that you can command your Scouts straight from Ruby.}
+  gem.summary       = %q{Pinoccio Ruby API}
+  gem.homepage      = "https://github.com/andykent/pinoccio"
+
+  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.name          = "pinoccio"
+  gem.require_paths = ["lib"]
+  gem.version       = '0.1.0'
+  gem.add_dependency('faraday', '~> 0.9.0')
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: pinoccio
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Andy Kent
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+description: This library gives access to the pinoccio REST API to configure and manage
+  Troops & Scouts. It additionally bundles all the built in ScoutScript commands so
+  that you can command your Scouts straight from Ruby.
+email:
+- andy.kent@me.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- lib/client.rb
+- lib/commands.rb
+- lib/pinoccio.rb
+- lib/scout.rb
+- lib/scout_collection.rb
+- lib/troop.rb
+- lib/troop_collection.rb
+- pinoccio.gemspec
+homepage: https://github.com/andykent/pinoccio
+licenses: []
+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: Pinoccio Ruby API
+test_files: []