lego_ev3 0.9.0 → 0.9.1

data/lib/lego_ev3.rb

@@ -6,8 +6,15 @@ end
 
 require_relative 'utilities'
 require_relative 'exceptions'
+
+require_relative 'commands/builder'
 require_all_relative 'commands'
+
+require_relative 'connection/base'
 require_all_relative 'connection'
+
+require_relative 'sensors/base'
 require_all_relative 'sensors'
+
 require_relative 'tacho_motor'
 require_relative 'brick'

data/lib/sensors/base.rb

@@ -1,30 +1,37 @@
 module LegoEv3
   # More info: http://www.ev3dev.org/docs/drivers/lego-sensor-class/
   class LegoSensor
+    attr_reader :value
+    
     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
+        driver_name: @driver_name
       }
     end
+
+    protected
+
+    def poll_value(parts_count)
+      raw = []
+
+      parts_count.times do |i|
+        LegoEv3::Commands::LegoSensor.send("get_value#{i}", @connection, @id) do |value|
+          raw << value
+        end
+      end
+
+      @connection.flush
+
+      raw
+    end
   end
 end

data/lib/sensors/color.rb

@@ -0,0 +1,76 @@
+module LegoEv3
+  class ColorSensor < LegoSensor
+    def initialize(connection, id, port)
+      super(connection, id, port, 'lego-ev3-color')
+
+      @supported_modes = {
+        reflect: 'COL-REFLECT',
+        ambient: 'COL-AMBIENT',
+        color: 'COL-COLOR',
+        reflect_raw: 'REF-RAW',
+        rgb: 'RGB-RAW'
+      }
+
+      @modes_value_parts = {
+        reflect: 1,
+        ambient: 1,
+        color: 1,
+        reflect_raw: 2,
+        rgb: 3
+      }
+
+      @value_to_color = [:none, :black, :blue, :green, :yellow, :red, :white, :brown]
+
+      self.mode = :reflect
+    end
+
+    def mode
+      @mode = parse_mode(LegoEv3::Commands::LegoSensor.get_mode!(@connection, @id))
+    end
+
+    def mode=(new_value)
+      to_set = @supported_modes[new_value.to_sym]
+      throw new InvalidModeException(:sensor, :color, new_value, @supported_modes.keys) unless to_set
+
+      LegoEv3::Commands::LegoSensor.set_mode(@connection, @id, to_set)
+      LegoEv3::Commands::LegoSensor.get_mode(@connection, @id) do |m|
+        @mode = parse_mode(m)
+      end
+
+      @connection.flush
+      @mode
+    end
+
+    def poll
+      @value = parse_value(poll_value(@modes_value_parts[@mode]))
+    end
+
+    def info
+      super.merge({
+        sub_type: :color,
+        mode: @mode,
+        value: @value
+      })
+    end
+
+    private
+
+    def parse_mode(raw)
+      @supported_modes.select do |key, value|
+        raw == value
+      end.first[0]
+    end
+
+    def parse_value(raw)
+      if @mode == :reflect || @mode == :ambient
+        raw.first.to_f / 100 # percent
+      elsif @mode == :color
+        @value_to_color[raw.first]
+      elsif @mode == :reflect_raw
+        raw[0..1]
+      elsif @mode == :rgb
+        raw[0..2]
+      end
+    end
+  end
+end

data/lib/sensors/infrared.rb

@@ -0,0 +1,142 @@
+module LegoEv3
+  # More info: http://www.ev3dev.org/docs/sensors/lego-ev3-infrared-sensor/
+  # TODO: make sense of proximity
+  class InfraredSensor < LegoSensor
+    def initialize(connection, id, port)
+      super(connection, id, port, 'lego-ev3-ir')
+
+      @supported_modes = {
+        proximity: 'IR-PROX',
+        seek: 'IR-SEEK',
+        control: 'IR-REMOTE',
+        control_alt: 'IR-REM-A'
+      }
+
+      @modes_value_parts = {
+        proximity: 1,
+        seek: 8,
+        control: 4,
+        control_alt: 1
+      }
+
+      @control_pressed_buttons = [
+        [],
+        [:red_up],
+        [:red_down],
+        [:blue_up],
+        [:blue_down],
+        [:red_up, :blue_up],
+        [:red_up, :blue_down],
+        [:red_down, :blue_up],
+        [:red_down, :blue_down],
+        [:beacon_on],
+        [:red_up, :red_down],
+        [:blue_up, :blue_down]
+      ]
+
+      self.mode = :proximity
+
+      @channel = 1
+
+      init_values
+    end
+
+    def channel
+      @channel
+    end
+
+    def channel=(new_value)
+      @channel = [1, new_value.to_i, 4].sort[1]
+
+      init_values
+    end
+
+    def mode
+      @mode = parse_mode(LegoEv3::Commands::LegoSensor.get_mode!(@connection, @id))
+    end
+
+    def mode=(new_value)
+      to_set = @supported_modes[new_value.to_sym]
+      throw new InvalidModeException(:sensor, :infrared, new_value, @supported_modes.keys) unless to_set
+
+      LegoEv3::Commands::LegoSensor.set_mode(@connection, @id, to_set)
+      LegoEv3::Commands::LegoSensor.get_mode(@connection, @id) do |m|
+        @mode = parse_mode(m)
+      end
+
+      @connection.flush
+
+      init_values
+
+      @mode
+    end
+
+    def poll
+      throw new InvalidChannelException(@channel) if @mode == :control_alt && @channel != 1
+      @last_value_raw = @value_raw
+      @value_raw = poll_value(@modes_value_parts[@mode])
+      @value = parse_value(@value_raw)
+    end
+
+    def info
+      super.merge({
+        sub_type: :infrared,
+        mode: @mode,
+        value: @value,
+        channel: @channel
+      })
+    end
+
+    private
+
+    # TODO Eventually use this to solve the "value 262" problem.
+    def init_values
+      @value = nil
+      @value_raw = nil
+      @last_value_raw = nil
+    end
+
+    def parse_mode(raw)
+      @supported_modes.select do |key, value|
+        raw == value
+      end.first[0]
+    end
+
+    def parse_value(raw)
+      if @mode == :proximity
+        raw.first.to_f / 100 # percent, [0, 1]. 100% is approximately 70cm.
+      elsif @mode == :seek
+        bit_position = (@channel - 1) * 4
+        values_at_position = raw[bit_position, bit_position + 1]
+
+        # When looking in the same direction as the sensor,
+        # -25 is far left and +25 is far right.
+        {
+          heading: values_at_position[0].to_f / 25, # percent, [-1, 1]
+          distance: values_at_position[1].to_f / 100, # percent, [0, 1]
+          activated: values_at_position[1] != -128
+        }
+      elsif @mode == :control
+        bit_position = @channel - 1
+        value_at_position = raw[bit_position]
+        @control_pressed_buttons[value_at_position]
+      elsif @mode == :control_alt
+        value = []
+
+        # TODO: Pressing an up/down button while beacon mode
+        # TODO: is activated with turn off beacon mode.
+
+        # TODO: Also, when the beacon mode is active or for
+        # TODO: about 1 second after any button is released the value is 262.
+        if raw[0] & 0x0F > 0
+          value << :blue_down if raw[0][7] == 1
+          value << :blue_up if raw[0][6] == 1
+          value << :red_down if raw[0][5] == 1
+          value << :red_up if raw[0][4] == 1
+        end
+
+        value
+      end
+    end
+  end
+end

data/lib/sensors/touch.rb

@@ -1,5 +1,4 @@
 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')
@@ -10,7 +9,7 @@ module LegoEv3
     end
 
     def poll
-      @value = LegoEv3::Commands::LegoSensor.get_value0!(@connection, @id)
+      @value = poll_value(1)[0]
     end
 
     def info

data/lib/tacho_motor.rb

@@ -60,7 +60,6 @@ module LegoEv3
       LegoEv3::Commands::TachoMotor.run_to_abs_pos!(@connection, @id)
 
       loop do
-        ap info
         break if operation_completed?(old_position)
       end
 
@@ -98,12 +97,12 @@ module LegoEv3
       sync!
     end
 
-    def ticks_per_rotation
-      @ticks_per_rotation = LegoEv3::Commands::TachoMotor.get_count_per_rot!(@connection, @id)
+    def ticks_per_rotation(sync = true)
+      get_value('@ticks_per_rotation', 'get_count_per_rot', sync)
     end
 
-    def speed
-      @speed = LegoEv3::Commands::TachoMotor.get_duty_cycle!(@connection, @id)
+    def speed(sync = true)
+      get_value('@speed', 'get_duty_cycle', sync)
     end
 
     # This is actually the desired speed but feels more natural.
@@ -118,12 +117,12 @@ module LegoEv3
       desired_speed
     end
 
-    def desired_speed
-      @desired_speed = LegoEv3::Commands::TachoMotor.get_duty_cycle_sp!(@connection, @id)
+    def desired_speed(sync = true)
+      get_value('@desired_speed', 'get_duty_cycle_sp', sync)
     end
 
-    def polarity
-      @polarity = LegoEv3::Commands::TachoMotor.get_polarity!(@connection, @id)
+    def polarity(sync = true)
+      get_value('@polarity', 'get_polarity', sync)
     end
 
     def polarity=(new_value)
@@ -135,8 +134,8 @@ module LegoEv3
       polarity
     end
 
-    def position
-      @position = LegoEv3::Commands::TachoMotor.get_position!(@connection, @id)
+    def position(sync = true)
+      get_value('@position', 'get_position', sync)
     end
 
     def position=(new_value)
@@ -144,16 +143,16 @@ module LegoEv3
       position
     end
 
-    def desired_position
-      @desired_position = LegoEv3::Commands::TachoMotor.get_position_sp!(@connection, @id)
+    def desired_position(sync = true)
+      get_value('@desired_position', 'get_position_sp', sync)
     end
 
-    def desired_time
-      @desired_time = LegoEv3::Commands::TachoMotor.get_time_sp!(@connection, @id)
+    def desired_time(sync = true)
+      get_value('@desired_time', 'get_time_sp', sync)
     end
 
-    def stop_mode
-      @stop_mode = LegoEv3::Commands::TachoMotor.get_stop_command!(@connection, @id)
+    def stop_mode(sync = true)
+      get_value('@stop_mode', 'get_stop_command', sync)
     end
 
     def stop_mode=(new_value)
@@ -199,15 +198,17 @@ module LegoEv3
     end
 
     def sync!
-      ticks_per_rotation
-      speed
-      desired_speed
-      polarity
-      position
-      desired_position
-      desired_time
-      stop_mode
-      update_states
+      ticks_per_rotation(false)
+      speed(false)
+      desired_speed(false)
+      polarity(false)
+      position(false)
+      desired_position(false)
+      desired_time(false)
+      stop_mode(false)
+      update_states(false)
+
+      @connection.flush("Updated motor state")
 
       info
     end
@@ -237,9 +238,17 @@ module LegoEv3
       throw Exception.new('Speed is set to 0.') if desired_speed == 0
     end
 
-    def update_states
-      states = LegoEv3::Commands::TachoMotor.get_states!(@connection, @id)
+    def update_states(sync = true)
+      if sync
+        update_states_part_2(LegoEv3::Commands::TachoMotor.get_states!(@connection, @id))
+      else
+        LegoEv3::Commands::TachoMotor.get_states(@connection, @id) do |states|
+          update_states_part_2(states)
+        end
+      end
+    end
 
+    def update_states_part_2(states)
       @running = states.include?(:running)
       @ramping = states.include?(:ramping)
       @holding = states.include?(:holding)
@@ -251,5 +260,17 @@ module LegoEv3
 
       !@running || @holding
     end
+
+    def get_value(variable_name, command, sync = true)
+      if sync
+        instance_variable_set(
+          variable_name,
+          LegoEv3::Commands::TachoMotor.send("#{command}!", @connection, @id))
+      else
+        LegoEv3::Commands::TachoMotor.send(command, @connection, @id) do |value|
+          instance_variable_set(variable_name, value)
+        end
+      end
+    end
   end
 end

data/lib/utilities.rb

@@ -1,4 +1,5 @@
 require 'yaml'
+require 'optparse'
 
 module LegoEv3
   # bar, time = with_timer do
@@ -16,13 +17,44 @@ module LegoEv3
     [return_value, (diff * 1000).to_i] # in ms.
   end
 
+  def self.user_config_overrides
+    @@user_config_overrides
+  end
+
+  def self.user_config_overrides=(new_value)
+    @@user_config_overrides = new_value
+  end
+
+  # 1. Start from a default config + programatic config
+  # 2. If a config is found in the command parameters, apply overrides.
+  # 3. If a config is found in LegoEv3::resolved_config, apply overrides.
+  def self.resolve_user_config(user_config = nil)
+    config = default_user_config.merge(user_config || {})
+
+    OptionParser.new do |opt|
+      opt.on('-c, --config PATH', 'Use the provided configuration at PATH.') do |path|
+        config.merge!(LegoEv3::load_config(path))
+      end
+    end.parse!
+
+    config.merge!(user_config_overrides || {})
+
+    user_config_overrides = config
+
+    config
+  end
+
   def self.default_user_config
     {
-      'ssh' => {
+      'entry_point' => 'script.rb',
+      'remote' => {
         'host' => '192.168.2.3', # I'm working on Mac OS X, eh.
         'hostname' => 'ev3dev',
         'username' => 'root',
-        'password' => 'r00tme'
+        'password' => 'r00tme',
+        'ssh' => 22,
+        'tcp' => 13603,
+        'service' => 'ssh'
       }
     }
   end
@@ -30,4 +62,8 @@ module LegoEv3
   def self.load_config(path)
     YAML::load(File.open(path))
   end
+
+  private
+
+  @@user_config_overrides = nil
 end