lego_ev3 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5b2fb90c9305d336e5d81ec1a7d7ac242542c1cc
+  data.tar.gz: fcc6149efda2798a9e3c1cfff391812511cf9e14
+SHA512:
+  metadata.gz: 2eb2ba5f4c07fa9e387845ff5d1d27d89114294f94a4f2482456ba3142f4f25f23c5bb302e3dfa39b21ff0bf4a2e42c6447be2c32ab8e4a6689728e693d91f39
+  data.tar.gz: 43e8cab0d3c77082c7ba1eab43c6f5d3299f9c939df5434f2aff32ba7976ee012101b018b49e6261350b9a4b825f37c048ca32c50873c61038762da40348769b

data/Gemfile

@@ -0,0 +1,8 @@
+source 'http://rubygems.org'
+
+gem 'net-ssh-simple'
+
+group :development do
+  gem 'awesome_print'
+  gem 'pry'
+end

data/README.md

@@ -0,0 +1,46 @@
+# Lego EV3
+
+## Getting started
+
+### Make sure you have the necessary Ruby dependencies
+
+The [ev3dev.org](http://www.ev3dev.org) distribution contains Ruby 2 but some libraries are missing to build native extensions. *This lib requires native extensions to work*.
+
+Solution #1: Use [RVM](https://rvm.io).
+Solution #2: Install those dependencies:
+
+```
+apt-get install build-essential bison openssl libreadline6 libreadline6-dev curl git-core zlib1g zlib1g-dev libssl-dev libyaml-dev libxml2-dev autoconf libc6-dev ncurses-dev automake libtool ruby-dev
+```
+
+### Install the gem
+
+```
+gem install lego-ev3
+```
+
+### A simple script
+
+```
+require 'lego_ev3'
+
+# The connection class look at the hostname of the machine to determine
+# if the connection to establish must be local or remote (ssh).
+# machine.hostname != config.hostname => remote.
+connection = LegoEv3::Connection.new('ssh' => {
+  'host' => '192.168.2.3',
+  'hostname' => 'ev3dev',
+  'username' => 'root',
+  'password' => 'r00tme'
+})
+
+brick = LegoEv3::Brick.new(connection)
+
+# Plug the touch sensor in any input and run this script by pressing
+# or not the sensor. The 'pressed' value should change accordingly.
+s = brick.sensors.first
+s.poll
+puts s.info.inspect
+
+connection.close
+```

data/bin/lego-ev3

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+require 'lego_ev3'
+require 'optparse'
+
+options = {
+  user_config: LegoEv3::default_user_config
+}
+
+OptionParser.new do |opt|
+  opt.on('-u', '--upload PROJECT', 'Upload everything under ./.../PROJECT to /home/PROJECT on the brick.') do |project|
+    options[:mode] = :upload
+    options[:project] = project
+  end
+
+  opt.on('-c, --config PATH', 'Use the provided configuration at PATH.') do |path|
+    options[:user_config].merge!(LegoEv3::load_config(path))
+  end
+end.parse!
+
+puts
+puts "Config used:"
+puts
+ap options
+puts
+
+LegoEv3::Uploader
+  .new(
+    options[:user_config]['ssh']['host'],
+    options[:user_config]['ssh']['username'],
+    options[:user_config]['ssh']['password'],
+    options[:project])
+  .upload

data/lib/brick.rb

@@ -0,0 +1,96 @@
+module LegoEv3
+  class Brick
+    def initialize(connection)
+      @connection = connection
+      @ports = []
+      @devices = []
+      @motors = []
+      @sensors = []
+
+      refresh!
+      motors.each{ |m| m.reset }
+    end
+
+    def motors
+      @motors
+    end
+
+    def sensors
+      @sensors
+    end
+
+    def refresh!
+      @ports = LegoEv3::Commands::LegoPort.list!(@connection).map do |port|
+        { id: port }
+      end
+
+      # Retrieve name and status in batch.
+      @ports.each do |port|
+        LegoEv3::Commands::LegoPort.get_port_name(@connection, port[:id]) do |name|
+          port[:name] = name
+        end
+
+        LegoEv3::Commands::LegoPort.get_status(@connection, port[:id]) do |status|
+          port[:status] = status
+        end
+      end
+
+      # Retrieve Port name -> Tacho motor in batch.
+      tacho_motors = {}
+      LegoEv3::Commands::TachoMotor.list!(@connection).each do |motor|
+        LegoEv3::Commands::TachoMotor.get_port_name(@connection, motor) do |port_name|
+          tacho_motors[port_name] = motor
+        end
+      end
+
+      # Retrieve Port name -> Lego sensor in batch.
+      lego_sensors = {}
+      LegoEv3::Commands::LegoSensor.list!(@connection).each do |sensor|
+        LegoEv3::Commands::LegoSensor.get_port_name(@connection, sensor) do |port_name|
+          lego_sensors[port_name] = sensor
+        end
+      end
+
+      @connection.flush
+
+      # Assemble port info.
+      @ports.each do |port|
+        status = port.delete(:status)
+        connected =
+          status != 'no-sensor' &&
+          status != 'no-motor' &&
+          status != 'error'
+
+        port[:type] = port[:name].start_with?('in') ? :sensor : :motor
+        port[:connected] = connected
+        port[:error] = status == 'error'
+        port[:driver] = connected ? status : nil
+      end
+
+      @motors = @ports
+        .select{ |p| p[:type] == :motor && p[:connected] }
+        .map{ |p| LegoEv3::TachoMotor.new(@connection, tacho_motors[p[:name]], p) }
+
+      @sensors = @ports
+        .select{ |p| p[:type] == :sensor && p[:connected] }
+        .map do |p|
+          id = lego_sensors[p[:name]]
+          driver_name = LegoEv3::Commands::LegoSensor.get_driver_name!(@connection, id)
+
+          if driver_name == 'lego-ev3-touch'
+            LegoEv3::TouchSensor.new(@connection, id, p)
+          else
+            nil
+          end
+        end.compact
+    end
+
+    def info
+      {
+        ports: @ports,
+        motors: @motors.map(&:info),
+        sensors: @sensors.map(&:info)
+      }
+    end
+  end
+end

data/lib/commands/builder.rb

@@ -0,0 +1,106 @@
+module LegoEv3
+  module Commands
+    module CommandBuilder
+      private
+
+      def base_path(path)
+        self.define_singleton_method "get_base_path" do
+          path
+        end
+
+        self.define_singleton_method "get_path" do |id|
+          get_base_path + "/#{id}"
+        end
+
+        self.define_singleton_method "get_command_path" do |id|
+          get_base_path + "/#{id}/command"
+        end
+      end
+
+      def get(alias_name, type = String, command_name = nil, processor = nil)
+        command_name ||= alias_name
+
+        self.define_singleton_method "get_#{alias_name}" do |connection, id, &callback|
+          connection.send("cat #{get_path(id)}/#{command_name}") do |response|
+            sanitized = (response || '').strip
+
+            if type == Integer
+              sanitized = sanitized.to_i
+            elsif type == Symbol
+              sanitized = sanitized.to_sym
+            end
+
+            sanitized = processor.call(sanitized) if processor
+            callback.call(sanitized) if callback
+          end
+        end
+
+        self.define_singleton_method "get_#{alias_name}!" do |connection, id|
+          return_value = nil
+
+          self.send("get_#{alias_name}", connection, id) do |response|
+            return_value = response
+          end
+
+          connection.flush
+
+          return_value
+        end
+      end
+
+      def set(alias_name, command_name = nil)
+        command_name ||= alias_name
+
+        self.define_singleton_method "set_#{alias_name}" do |connection, id, value|
+          connection.send("echo #{value} > #{get_path(id)}/#{command_name}")
+        end
+
+        self.define_singleton_method "set_#{alias_name}!" do |connection, id, value|
+          self.send("set_#{alias_name}", connection, id, value)
+          connection.flush
+        end
+      end
+
+      def get_set(alias_name, type = String, command_name = nil, processor = nil)
+        get(alias_name, type, command_name, processor)
+        set(alias_name, command_name)
+      end
+
+      def command(alias_name, command_name = nil)
+        command_name ||= alias_name
+
+        self.define_singleton_method alias_name do |connection, id|
+          connection.send("echo #{command_name} > #{get_command_path(id)}")
+        end
+        
+        self.define_singleton_method "#{alias_name}!" do |connection, id|
+          self.send(alias_name, connection, id)
+          connection.flush
+        end
+      end
+
+      def has_list
+        self.define_singleton_method :list do |connection, &callback|
+          connection.send("ls -C #{get_base_path}") do |response|
+            # TODO: Bug? The folder is not created if no sensor plugged in once.
+            entries_raw = response || ''
+            entries = entries_raw.include?('No such file or directory') ? [] : entries_raw.split(' ').map(&:strip)
+            callback.call(entries)
+          end
+        end
+
+        self.define_singleton_method :list! do |connection|
+          entries = nil
+
+          list(connection) do |response|
+            entries = response
+          end
+
+          connection.flush
+
+          entries
+        end
+      end
+    end
+  end
+end

data/lib/commands/lego_port.rb

@@ -0,0 +1,8 @@
+module LegoEv3::Commands::LegoPort
+  extend LegoEv3::Commands::CommandBuilder
+
+  base_path '/sys/class/lego-port'
+  has_list
+  get :port_name
+  get :status
+end

data/lib/commands/lego_sensor.rb

@@ -0,0 +1,18 @@
+module LegoEv3::Commands::LegoSensor
+  extend LegoEv3::Commands::CommandBuilder
+
+  base_path '/sys/class/lego-sensor'
+  has_list
+  get :port_name
+  get :driver_name
+  get :decimals, Integer
+  get :num_values, Integer
+  get :value0, Integer
+  get :value1, Integer
+  get :value2, Integer
+  get :value3, Integer
+  get :value4, Integer
+  get :value5, Integer
+  get :value6, Integer
+  get :value7, Integer
+end

data/lib/commands/tacho_motor.rb

@@ -0,0 +1,25 @@
+module LegoEv3::Commands::TachoMotor
+  extend LegoEv3::Commands::CommandBuilder
+
+  base_path '/sys/class/tacho-motor'
+  has_list
+  get :port_name
+  get :count_per_rot, Integer
+  get :duty_cycle, Integer
+  get :states, String, 'state', -> response { response.split(' ').map{ |s| s.strip.to_sym } }
+  get_set :duty_cycle_sp, Integer
+  get_set :position, Integer
+  get_set :position_sp, Integer
+  get_set :speed_sp, Integer
+  get_set :polarity, Symbol
+  get_set :time_sp, Integer
+  get_set :stop_command, Symbol
+  get_set :speed_regulation, Symbol, nil, -> (response) { response == :on }
+  command :run_forever, 'run-forever'
+  command :run_to_abs_pos, 'run-to-abs-pos'
+  #command :run_to_rel_pos, 'run-to-rel-pos' # not used.
+  command :run_timed, 'run-timed'
+  command :run_direct, 'run-direct'
+  command :stop
+  command :reset
+end

data/lib/connection/base.rb

@@ -0,0 +1,37 @@
+module LegoEv3
+  class BaseConnection
+    def initialize
+      @to_send = []
+    end
+
+    def send(command, &callback)
+      @to_send << [command, callback]
+    end
+
+    def flush
+      @connection ||= create_connection
+
+      joined_command = @to_send
+        .map{ |(c, _)| c }
+        .join(';')
+
+      callbacks = @to_send
+        .map{ |(_, c)| c }
+
+      joined_response, time = LegoEv3::with_timer do
+        call_connection(joined_command)
+      end
+
+      puts "#{joined_command}. #{time} ms."
+
+      # We assume that one command output one line of result.
+      responses = joined_response.split("\n")
+
+      callbacks.each_with_index.each do |c, i|
+        c.call(responses[i]) if c
+      end
+
+      @to_send.clear
+    end
+  end
+end

data/lib/connection/connection.rb

@@ -0,0 +1,50 @@
+require 'optparse'
+
+module LegoEv3
+  class Connection
+    def initialize(user_config = {})
+      options = {
+        user_config: LegoEv3::default_user_config.merge(user_config)
+      }
+
+      OptionParser.new do |opt|
+        opt.on('-c, --config PATH', 'Use the provided configuration at PATH.') do |path|
+          options[:user_config].merge!(LegoEv3::load_config(path))
+        end
+      end.parse!
+      is_local = `hostname`.strip == options[:user_config]['ssh']['hostname']
+
+      @inner_connection = if is_local
+        LegoEv3::LocalConnection.new
+      else
+        LegoEv3::RemoteConnection.new(
+          options[:user_config]['ssh']['host'],
+          options[:user_config]['ssh']['username'],
+          options[:user_config]['ssh']['password']
+        )
+      end
+    end
+
+    def send(command, &callback)
+      @inner_connection.send(command, &callback)
+    end
+
+    def flush
+      @inner_connection.flush
+    end
+
+    def close
+      @inner_connection.close
+    end
+
+    protected
+
+    def create_connection
+      @inner_connection.create_connection
+    end
+
+    def call_connection(command)
+      @inner_connection.call_connection(command)
+    end
+  end
+end

data/lib/connection/local.rb

@@ -0,0 +1,14 @@
+module LegoEv3
+  class LocalConnection < BaseConnection
+
+    def close; end
+
+    protected
+
+    def create_connection; end
+
+    def call_connection(command)
+      `command`
+    end
+  end
+end

data/lib/connection/remote.rb

@@ -0,0 +1,39 @@
+require 'net/ssh/simple'
+
+module LegoEv3
+  class RemoteConnection < BaseConnection
+    attr_accessor :timeout
+
+    def initialize(host, user, password)
+      super()
+
+      @host = host
+      @user = user
+      @password = password
+      @timeout = 10
+    end
+
+    def close
+      @connection.close if @connection
+      @connection = nil
+    end
+
+    protected
+
+    def create_connection
+      Net::SSH::Simple.new(host_name: @host, user: @user, password: @password, timeout: @timeout)
+    end
+
+    def call_connection(command)
+      begin
+        @connection.ssh(@host, command).stdout
+      rescue => e
+        if e.wrapped.kind_of?(Timeout::Error)
+          raise RemoteConnectionException.new(@host, @user, @password)
+        else
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/connection/upload.rb

@@ -0,0 +1,52 @@
+require 'net/ssh/simple'
+
+module LegoEv3
+  class Uploader
+    def initialize(host, user, password, project)
+      @host = host
+      @user = user
+      @password = password
+      @project = project
+    end
+
+    def upload
+      Net::SSH::Simple.sync({ host_name: @host, user: @user, password: @password, timeout: 600 }) do
+        puts "Creating folder #{project_folder}..."
+        ssh('ev3', "rm -rf #{project_folder}")
+
+        puts "Upload project..."
+        upload_folder(@project)
+
+        puts "Downloading dependencies from Gemfile..."
+        ssh('ev3', "cd #{project_folder} && gem install bundler && bundle install")
+      end
+    end
+
+    private
+
+    def upload_file(src_relative, dst_relative)
+      file_remote = "#{project_folder}/#{dst_relative}"
+      puts "Sending #{src_relative} to #{file_remote}..."
+      scp_put('ev3', src_relative, file_remote)
+    end
+
+    def upload_folder(src_relative)
+      folders = Dir.glob("#{src_relative}/**/*/")
+      files = Dir.glob("#{src_relative}/**/*").select { |f| File.file?(f) }
+
+      folders.each do |path_relative|
+        folder_remote = "#{project_folder}/#{path_relative}"
+        puts "Creating folder #{folder_remote}..."
+        ssh('ev3', "mkdir -p #{folder_remote}")
+      end
+
+      files.each do |path_relative|
+        upload_file(path_relative, path_relative)
+      end
+    end
+
+    def project_folder
+      "/home/#{@project.split('/').last}"
+    end
+  end
+end

data/lib/exceptions.rb

@@ -0,0 +1,11 @@
+module LegoEv3
+  class RemoteConnectionException < Exception
+    def initialize(host, user, password)
+      super(
+        "Could not connect to the brick. " +
+        "Make sure these command works: " +
+        "[ping #{host}]" +
+        "[ssh #{user}@#{host} + enter your password]")
+    end
+  end
+end

data/lib/lego_ev3.rb

@@ -0,0 +1,13 @@
+def require_all_relative(directory)
+  Dir[File.join(File.dirname(__FILE__), directory, '**', '*.rb')].each do |file|
+    require file
+  end
+end
+
+require_relative 'utilities'
+require_relative 'exceptions'
+require_all_relative 'commands'
+require_all_relative 'connection'
+require_all_relative 'sensors'
+require_relative 'tacho_motor'
+require_relative 'brick'

data/lib/sensors/base.rb

@@ -0,0 +1,30 @@
+module LegoEv3
+  # More info: http://www.ev3dev.org/docs/drivers/lego-sensor-class/
+  class LegoSensor
+    def initialize(connection, id, port, driver_name)
+      @connection = connection
+      @id = id
+      @port = port
+      @driver_name = driver_name
+
+      LegoEv3::Commands::LegoSensor.get_decimals(@connection, @id) do |response|
+        @decimals = response
+      end
+
+      LegoEv3::Commands::LegoSensor.get_num_values(@connection, @id) do |response|
+        @value_parts_count = response
+      end
+
+      @connection.flush
+    end
+
+    def info
+      {
+        id: @id,
+        port: @port,
+        driver_name: @driver_name,
+        decimals: @decimals
+      }
+    end
+  end
+end

data/lib/sensors/touch.rb

@@ -0,0 +1,23 @@
+module LegoEv3
+  # More info: http://www.ev3dev.org/docs/drivers/lego-sensor-class/
+  class TouchSensor < LegoSensor
+    def initialize(connection, id, port)
+      super(connection, id, port, 'lego-ev3-touch')
+    end
+
+    def pressed?
+      @value == 1
+    end
+
+    def poll
+      @value = LegoEv3::Commands::LegoSensor.get_value0!(@connection, @id)
+    end
+
+    def info
+      super.merge({
+        sub_type: :touch,
+        pressed: pressed?
+      })
+    end
+  end
+end

data/lib/tacho_motor.rb

@@ -0,0 +1,255 @@
+module LegoEv3
+  # More info: http://www.ev3dev.org/docs/drivers/tacho-motor-class/
+  # TODO: ramp_up_sp, ramp_down_sp
+  # TODO: handle 'run_direct' and 'run_forever' states
+  # TODO: speed_regulation by default?
+  class TachoMotor
+    def initialize(connection, id, port)
+      @connection = connection
+      @id = id
+      @port = port
+
+      @speed = 0
+      @desired_speed = 0
+      @ticks_per_rotation = 0
+      @polarity = :normal
+      @position = 0
+      @desired_position = 0
+      @desired_time_ms = 0
+      @stop_mode = :coast
+      @running = false
+      @ramping = false
+      @holding = false
+      @stalled = false
+      @regulated_speed = false
+
+      sync!
+    end
+
+    # Run the motor indefinitely, until another command is sent.
+    def run_forever
+      ensure_valid_speed
+
+      LegoEv3::Commands::TachoMotor.run_forever!(@connection, @id)
+    end
+
+    # Run to an absolute position specified by *desired_position*.
+    # Then stop using the current stop behavior.
+    def run_to_absolute_position(desired_position)
+      ensure_valid_speed
+      old_position = position
+
+      LegoEv3::Commands::TachoMotor.set_position_sp!(@connection, @id, desired_position)
+      LegoEv3::Commands::TachoMotor.run_to_abs_pos!(@connection, @id)
+
+      loop do
+        break if operation_completed?(old_position)
+      end
+
+      position
+    end
+
+    # Run to a position relative to the current position.
+    # The new position will be *position* + *desired_position*.
+    # Then stop using the current stop behavior.
+    def run_to_relative_position(desired_position)
+      ensure_valid_speed
+      old_position = position
+
+      LegoEv3::Commands::TachoMotor.set_position_sp!(@connection, @id, old_position + desired_position)
+      LegoEv3::Commands::TachoMotor.run_to_abs_pos!(@connection, @id)
+
+      loop do
+        ap info
+        break if operation_completed?(old_position)
+      end
+
+      position
+    end
+
+    # Run the motor for the amount of time specified in *desired_time_ms*.
+    # Then stop using the current stop behavior.
+    def run_timed(desired_time_ms)
+      ensure_valid_speed
+      old_position = position
+
+      LegoEv3::Commands::TachoMotor.set_time_sp!(@connection, @id, desired_time_ms.to_i)
+      LegoEv3::Commands::TachoMotor.run_timed!(@connection, @id)
+
+      loop do
+        break if operation_completed?(old_position)
+      end
+
+      position
+    end
+
+    # Run the motor at the *desired_speed*.
+    # Unlike other run commands, changing *desired_speed* take immediate effect.
+    def run_direct
+      LegoEv3::Commands::TachoMotor.run_direct!(@connection, @id)
+    end
+
+    def stop
+      LegoEv3::Commands::TachoMotor.stop!(@connection, @id)
+    end
+
+    def reset
+      LegoEv3::Commands::TachoMotor.reset!(@connection, @id)
+      sync!
+    end
+
+    def ticks_per_rotation
+      @ticks_per_rotation = LegoEv3::Commands::TachoMotor.get_count_per_rot!(@connection, @id)
+    end
+
+    def speed
+      @speed = LegoEv3::Commands::TachoMotor.get_duty_cycle!(@connection, @id)
+    end
+
+    # This is actually the desired speed but feels more natural.
+    def speed=(new_value)
+      sanitized = [[new_value.to_i, -100].max, 100].min
+
+      # I will probably learn why this is not right but for now,
+      # I sync those 2 values to keep it simple.
+      LegoEv3::Commands::TachoMotor.set_speed_sp!(@connection, @id, sanitized)
+      LegoEv3::Commands::TachoMotor.set_duty_cycle_sp!(@connection, @id, sanitized)
+
+      desired_speed
+    end
+
+    def desired_speed
+      @desired_speed = LegoEv3::Commands::TachoMotor.get_duty_cycle_sp!(@connection, @id)
+    end
+
+    def polarity
+      @polarity = LegoEv3::Commands::TachoMotor.get_polarity!(@connection, @id)
+    end
+
+    def polarity=(new_value)
+      unless [:normal, :inversed].include?(new_value.to_sym)
+        raise Exception.new('Invalid polarity. Possible values: :normal, :inversed.')
+      end
+
+      LegoEv3::Commands::TachoMotor.set_polarity!(@connection, @id, new_value)
+      polarity
+    end
+
+    def position
+      @position = LegoEv3::Commands::TachoMotor.get_position!(@connection, @id)
+    end
+
+    def position=(new_value)
+      LegoEv3::Commands::TachoMotor.set_position!(@connection, @id, new_value.to_i)
+      position
+    end
+
+    def desired_position
+      @desired_position = LegoEv3::Commands::TachoMotor.get_position_sp!(@connection, @id)
+    end
+
+    def desired_time
+      @desired_time = LegoEv3::Commands::TachoMotor.get_time_sp!(@connection, @id)
+    end
+
+    def stop_mode
+      @stop_mode = LegoEv3::Commands::TachoMotor.get_stop_command!(@connection, @id)
+    end
+
+    def stop_mode=(new_value)
+      unless [:coast, :brake, :hold].include?(new_value.to_sym)
+        raise Exception.new('Invalid stop behavior. Possible values: :coast, :brake, :hold.')
+      end
+
+      LegoEv3::Commands::TachoMotor.set_stop_command!(@connection, @id, new_value)
+      stop_mode
+    end
+
+    def states
+      @states = LegoEv3::Commands::TachoMotor.get_states!(@connection, @id)
+    end
+
+    def running
+      update_states
+      @running
+    end
+
+    def ramping
+      update_states
+      @ramping
+    end
+
+    def holding
+      update_states
+      @holding
+    end
+
+    def stalled
+      update_states
+      @stalled
+    end
+
+    def regulated_speed
+      @regulated_speed = LegoEv3::Commands::TachoMotor.get_speed_regulation!(@connection, @id)
+    end
+
+    def regulated_speed=(new_value)
+      LegoEv3::Commands::TachoMotor.set_speed_regulation!(@connection, @id, new_value.kind_of?(TrueClass) ? 'on' : 'off')
+      regulated_speed
+    end
+
+    def sync!
+      ticks_per_rotation
+      speed
+      desired_speed
+      polarity
+      position
+      desired_position
+      desired_time
+      stop_mode
+      update_states
+
+      info
+    end
+
+    def info
+      {
+        id: @id,
+        port: @port,
+        ticks_per_rotation: @ticks_per_rotation,
+        speed: @speed,
+        desired_speed: @desired_speed,
+        position: @position,
+        desired_position: @desired_position,
+        polarity: @polarity,
+        desired_time_ms: @desired_time_ms,
+        stop_mode: @stop_mode,
+        running: @running,
+        ramping: @ramping,
+        holding: @holding,
+        stalled: @stalled
+      }
+    end
+
+    private
+
+    def ensure_valid_speed
+      throw Exception.new('Speed is set to 0.') if desired_speed == 0
+    end
+
+    def update_states
+      states = LegoEv3::Commands::TachoMotor.get_states!(@connection, @id)
+
+      @running = states.include?(:running)
+      @ramping = states.include?(:ramping)
+      @holding = states.include?(:holding)
+      @stalled = states.include?(:stalled)
+    end
+
+    def operation_completed?(old_position)
+      update_states
+
+      !@running || @holding
+    end
+  end
+end

data/lib/utilities.rb

@@ -0,0 +1,33 @@
+require 'yaml'
+
+module LegoEv3
+  # bar, time = with_timer do
+  #   foo()
+  # end
+  #
+  def self.with_timer(&block)
+    start = Time.now
+
+    return_value = block.call
+
+    finish = Time.now
+    diff = finish - start
+
+    [return_value, (diff * 1000).to_i] # in ms.
+  end
+
+  def self.default_user_config
+    {
+      'ssh' => {
+        'host' => '192.168.2.3', # I'm working on Mac OS X, eh.
+        'hostname' => 'ev3dev',
+        'username' => 'root',
+        'password' => 'r00tme'
+      }
+    }
+  end
+
+  def self.load_config(path)
+    YAML::load(File.open(path))
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: lego_ev3
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Jodi Giordano
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: net-ssh-simple
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+description: Uses the amazing ev3dev.org stuff to interface with the Lego EV3 starter
+  kit
+email: giordano.jodi@gmail.com
+executables:
+- lego-ev3
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- bin/lego-ev3
+- lib/brick.rb
+- lib/commands/builder.rb
+- lib/commands/lego_port.rb
+- lib/commands/lego_sensor.rb
+- lib/commands/tacho_motor.rb
+- lib/connection/base.rb
+- lib/connection/connection.rb
+- lib/connection/local.rb
+- lib/connection/remote.rb
+- lib/connection/upload.rb
+- lib/exceptions.rb
+- lib/lego_ev3.rb
+- lib/sensors/base.rb
+- lib/sensors/touch.rb
+- lib/tacho_motor.rb
+- lib/utilities.rb
+homepage: https://github.com/jodigiordano/lego_ev3
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Library to interface with Lego EV3 starter kit
+test_files: []