lignite 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b479941700df01dc46fa526001f014920e528ad3
-  data.tar.gz: 00d321b86f44d215261ad1bfbe1d88158c62f3e5
+  metadata.gz: 3fef446a97c670acf0bfc1944d3287d80e40799a
+  data.tar.gz: 034b4f841c015e98af6b1776b1705a3f20905936
 SHA512:
-  metadata.gz: 1c9836db38d2bc17c096e3e73e1e26f54d6701f8be6cec34d0450dd79a6752afabd9db1b20087c7839df612799b5e3c02a5450740576759eaa75e651fc0b6aa4
-  data.tar.gz: fb64659ace34de87e7b133e704eb7577b07aadcd20e80868cc02871c7e5f4725d69b197d319821152b20ef42cf721fab9ef471832384e6a776e228cc504f0634
+  metadata.gz: fd4a8eaaf713aef7ca9081a4755ff953b24aaba900c4c22b6547d90392390c7563125fc874f926cc6179aecc2428e8209f17df5799285fefda7b500c35d33c6a
+  data.tar.gz: f257ff8520fd6b5b124eb824a0869aac56c94db788c7b245cd116284e09a7a4cee20d467f634215329ffc37a664d738d419e934d768202172c3c7a6022d161d0

data/.rubocop.yml

@@ -32,10 +32,14 @@ Metrics/BlockLength:
     - spec/**/*.rb
 
 Metrics/ClassLength:
+  Max: 120
   Exclude:
     - lib/lignite/ev3_tool.rb
     - lib/lignite/motors.rb
 
+Metrics/CyclomaticComplexity:
+  Max: 8
+
 Metrics/MethodLength:
   Max: 25
 

data/NEWS.md

@@ -2,6 +2,16 @@
 
 ## unreleased
 
+## 0.6.0, 2018-03-25
+
+- Fixed silent corruption of files obtained by `ev3tool download`
+- Added `ev3tool asm foo.rb foo.rbf`
+- Added SimpleAssembler
+- Added BodyCompiler#if_else, #loop_until_pre
+- Implemented array_init* (PARVALUES)
+- Added JumpOffset, replacing the Complex hack
+- Variables are now aligned automatically; subroutine argument alignment is checked
+
 ## 0.5.0, 2018-03-05
 
 - Ev3Ops: added missing array_* ops (with PARV in the signature).

data/VERSION

@@ -1 +1 @@
-0.5.0
+0.6.0

data/examples/bobbee.rb

@@ -13,14 +13,20 @@ class Bobbee
   # Interface to all other commands
   # @return [Lignite::DirectCommands]
   attr_reader :dc
+  # The robot is built with a https://en.wikipedia.org/wiki/Worm_drive
+  # lift mechanism
+  # @return [Boolean]
+  attr_reader :worm_lift
 
   def initialize(drive: Lignite::PORT_B | Lignite::PORT_C,
                  lift: Lignite::PORT_A,
-                 dc: Lignite::DirectCommands.new)
+                 dc: Lignite::DirectCommands.new,
+                 worm_lift: false)
     layer = 0
     @drive = Lignite::Motors.new(layer, drive, dc)
     @lift = Lignite::Motors.new(layer, lift, dc)
     @dc = dc
+    @worm_lift = worm_lift
   end
 
   # @param speed [Integer] -100..100
@@ -43,34 +49,51 @@ class Bobbee
   end
 
   LIFT_FULL = 220
+  WORM_LIFT_FULL = 2400
 
   # Raise the fork from the ground up
   def raise(wait: true)
-    lift.step_power(30, 10, LIFT_FULL - 20, 10)
+    if worm_lift
+      lift.step_power(-30, 10, WORM_LIFT_FULL - 20, 10)
+    else
+      lift.step_power(30, 10, LIFT_FULL - 20, 10)
+    end
     lift.ready if wait
   end
 
   # Raise the fork one third of the way from the ground up
   def third_raise(wait: true)
-    lift.step_power(30, 10, LIFT_FULL / 3 - 20, 10)
+    if worm_lift
+      lift.step_power(-30, 10, WORM_LIFT_FULL / 3 - 20, 10)
+    else
+      lift.step_power(30, 10, LIFT_FULL / 3 - 20, 10)
+    end
     lift.ready if wait
 
     beep
-    sleep 3
+    ready
   end
 
   # Lower the fork from above to the ground
   def lower(wait: true)
-    lift.step_power(-1, 10, LIFT_FULL - 20, 10) # , Lignite::COAST)
+    if worm_lift
+      lift.step_power(30, 10, WORM_LIFT_FULL - 20, 10)
+    else
+      lift.step_power(-1, 10, LIFT_FULL - 20, 10)
+    end
     lift.ready if wait
 
     beep
-    sleep 3
+    ready
   end
 
   # Lower the fork one third of the way from above to the ground
   def third_lower(wait: true)
-    lift.step_power(-1, 10, LIFT_FULL / 3 - 20, 10)
+    if worm_lift
+      lift.step_power(30, 10, WORM_LIFT_FULL / 3 - 20, 10)
+    else
+      lift.step_power(-1, 10, LIFT_FULL / 3 - 20, 10)
+    end
     lift.ready if wait
   end
 
@@ -87,14 +110,14 @@ class Bobbee
   def forward(steps = SQUARE_STEPS)
     step_sync(50, 0, steps)
     beep
-    sleep 3
+    ready
   end
 
   # Drive backward 1 square on the Boost mat
   def back(steps = SQUARE_STEPS)
     step_sync(-50, 0, back_factor(steps))
     beep
-    sleep 3
+    ready
   end
 
   # Compensation factor when moving backward
@@ -121,37 +144,49 @@ class Bobbee
 
   # Motor degrees needed to turn the robot 90 degrees when using turn=200
   TURN_90_AT_200_STEPS = 600
+  # Similar, but when we're carrying 100 grams, turning becomes harder!
+  LOADED_TURN_90_AT_200_STEPS = 750
 
   # Turn 90 degrees left, simply by moving tracks in opposite directions
-  def left_immediate
-    step_sync(50, -200, TURN_90_AT_200_STEPS)
+  def left_immediate(loaded: false)
+    steps = loaded ? LOADED_TURN_90_AT_200_STEPS : TURN_90_AT_200_STEPS
+    step_sync(50, -200, steps)
     beep(100)
-    sleep 3
+    ready
   end
 
   # Turn 90 degrees right, simply by moving tracks in opposite directions
-  def right_immediate
-    step_sync(50, 200, TURN_90_AT_200_STEPS)
+  def right_immediate(loaded: false)
+    steps = loaded ? LOADED_TURN_90_AT_200_STEPS : TURN_90_AT_200_STEPS
+    step_sync(50, 200, steps)
     beep(100)
-    sleep 3
+    ready
   end
 
   # Turn 90 degrees left, starting and ending inside a Boost mat square
-  def left
+  def left(loaded: false)
     align_centers_for_turning do
-      left_immediate
+      left_immediate(loaded: loaded)
     end
   end
 
   # Turn 90 degrees right, starting and ending inside a Boost mat square
-  def right
+  def right(loaded: false)
     align_centers_for_turning do
-      right_immediate
+      right_immediate(loaded: loaded)
     end
   end
-end
 
-bb = Bobbee.new
+  # Wait until the previous motor movements are complete
+  def ready
+    return unless @dc.is_a? Lignite::DirectCommands
+
+    print "Ready... "
+    drive.test
+    lift.test
+    puts "OK"
+  end
+end
 
 # Put Bobb3e (B) on the blue arrow (^). Move it one square left, and forward.
 # Put the container on a raised platform on the "twins" square (T).
@@ -169,18 +204,18 @@ def from_twins_to_fire(bb)
 
     right
     forward
-    third_raise
+    2.times { third_raise }
     back
-    left
+    left(loaded: true)
     # we're at the starting position, but carrying the load
 
     # move towards the recipient
     2.times { forward }
-    right
+    right(loaded: true)
 
     # deliver and unload
     forward
-    third_lower
+    2.times { third_lower }
     back
 
     # resting position
@@ -202,17 +237,17 @@ def from_fire_to_twins(bb)
 
     # load
     forward
-    third_raise
+    2.times { third_raise }
     back
 
     # starting position
-    left
+    left(loaded: true)
     2.times { back }
 
     # deliver
-    right
+    right(loaded: true)
     forward
-    third_lower
+    2.times { third_lower }
     back
     left
 
@@ -228,6 +263,17 @@ def calibrate_forward_and_back(bb)
   end
 end
 
+mode = ARGV.first || "direct"
+dc = if mode == "rbf"
+  Lignite::SimpleAssembler.new
+else
+  Lignite::DirectCommands.new
+end
+
+bb = Bobbee.new(dc: dc, worm_lift: true)
+
 # calibrate_forward_and_back(bb)
 from_twins_to_fire(bb)
 # from_fire_to_twins(bb)
+
+dc.write("bobbee.rbf") if mode == "rbf"

data/examples/gyro-sensor.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/ruby
+require "lignite"
+
+dc = Lignite::DirectCommands.new
+
+# Read gyro sensor angle on port 2
+LAYER0 = 0
+MODE = 0
+pct = dc.with_reply do
+  # global vars
+  dataf :angle
+
+  block do
+    input_device_ready_si(LAYER0, Lignite::PORT_2, Lignite::TYPE_GYRO, MODE, :angle)
+  end
+end
+puts "Gyro sensor angle: #{pct}"
+
+dc.close

data/lib/lignite.rb

@@ -4,11 +4,13 @@ require "lignite/logger"
 require "lignite/assembler"
 require "lignite/body_compiler"
 require "lignite/connection"
+require "lignite/condition"
 require "lignite/connection/bluetooth"
 require "lignite/connection/replay"
 require "lignite/connection/tap"
 require "lignite/connection/usb"
 require "lignite/direct_commands"
+require "lignite/jump_offset"
 require "lignite/message"
 require "lignite/motors"
 require "lignite/op_compiler"
@@ -17,7 +19,10 @@ require "lignite/system_commands"
 require "lignite/variables"
 require "lignite/version"
 
+# The main namespace
 module Lignite
+  LAYER_0 = 0
+
   PORT_A = 1
   PORT_B = 2
   PORT_C = 4
@@ -39,4 +44,11 @@ module Lignite
   # Represents an error returned by the robot
   class VMError < RuntimeError
   end
+
+  def program(&block)
+    p = Assembler.new
+    p.compile(&block)
+    p
+  end
+  module_function :program
 end

data/lib/lignite/assembler.rb

@@ -17,6 +17,7 @@ module Lignite
   class Assembler
     include Bytes
     include Logger
+    include Lignite # for constants
 
     HEADER_SIZE = 16
     SIGNATURE = "LEGO".freeze
@@ -26,9 +27,14 @@ module Lignite
     end
 
     # @return [Array<RbfObject>]
-    attr_reader :objects
+    attr_accessor :objects
     # @return [Variables]
-    attr_reader :globals
+    attr_accessor :globals
+
+    def initialize
+      @objects = []
+      @globals = Variables.new
+    end
 
     # Assemble a complete RBF program file.
     # (it is OK to reuse an Assembler and call this several times in a sequence)
@@ -36,9 +42,8 @@ module Lignite
     # @param rb_filename [String] input
     # @param rbf_filename [String] output
     def assemble(rb_filename, rbf_filename, version: 109)
+      initialize
       rb_text = File.read(rb_filename)
-      @objects = []
-      @globals = Variables.new
 
       @declarer = RbfDeclarer.new
       @declarer.instance_eval(rb_text, rb_filename, 1) # 1 is the line number
@@ -47,7 +52,13 @@ module Lignite
       write(rbf_filename, version)
     end
 
-    def write(rbf_filename, version)
+    def compile(&block)
+      @declarer = RbfDeclarer.new
+      @declarer.instance_exec(&block)
+      instance_exec(&block)
+    end
+
+    def write(rbf_filename, version = 109)
       image_size = HEADER_SIZE + @objects.map(&:size).reduce(0, :+)
 
       File.open(rbf_filename, "w") do |f|
@@ -99,4 +110,36 @@ module Lignite
                                     local_bytes: @locals.bytesize)
     end
   end
+
+  # Acts like DirectCommands but instead of executing, assembles them to a RBF file
+  class SimpleAssembler
+    def initialize
+      @globals = Variables.new
+      @locals = Variables.new
+      @declarer = RbfDeclarer::Dummy.new
+
+      @interp = BodyCompiler.new(@globals, @locals, @declarer)
+    end
+
+    def write(rbf_filename)
+      @interp.object_end
+      vmthread = RbfObject.vmthread(body: @interp.bytes, local_bytes: @locals.bytesize)
+
+      asm = Assembler.new
+      asm.objects = [vmthread]
+      asm.globals = @globals
+      asm.write(rbf_filename)
+    end
+
+    # Delegate the ops to the {BodyCompiler},
+    def method_missing(name, *args, &block)
+      super unless @interp.respond_to?(name)
+
+      @interp.public_send(name, *args, &block)
+    end
+
+    def respond_to_missing?(name, _include_private)
+      @interp.respond_to?(name) || super
+    end
+  end
 end

data/lib/lignite/body_compiler.rb

@@ -1,30 +1,4 @@
 module Lignite
-  # Less-than (32 bit)
-  class Lt32 # < Condition
-    def initialize(a, b)
-      @a = a
-      @b = b
-    end
-
-    def not
-      Ge32.new(@a, @b)
-    end
-
-    def jump_forward(compiler, body_size)
-      compiler.jr_lt32(@a, @b, Complex(body_size, 2))
-    end
-
-    def jump_back(compiler, body_size, self_size = nil)
-      if self_size.nil?
-        fake = compiler.clone_context
-        jump_back(fake, body_size, 0)
-        self_size = fake.bytes.bytesize
-      end
-
-      compiler.jr_lt32(@a, @b, Complex(- (body_size + self_size), 2))
-    end
-  end
-
   # Extends {OpCompiler} by
   # - variable declarations: {VariableDeclarer}
   # - high level flow control: {#loop}
@@ -62,28 +36,39 @@ module Lignite
       BodyCompiler.new(@globals, @locals, @declared_objects)
     end
 
-    def if(flag8, &body)
-      subc = BodyCompiler.new(@globals, @locals, @declared_objects)
+    def if(cond, &body)
+      cond = Flag.new(cond) unless cond.is_a? Condition
+
+      subc = clone_context
       subc.instance_exec(&body)
 
-      jr_false(flag8, Complex(subc.bytes.bytesize, 2))
+      cond.not.jump_forward(self, subc.bytes.bytesize)
       @bytes << subc.bytes
     end
 
+    def if_else(flag8, body_true, body_false)
+      truec = clone_context
+      falsec = clone_context
+      truec.instance_exec(&body_true)
+      falsec.instance_exec(&body_false)
+
+      # 4 is the unconditional jump size
+      jr_false(flag8, JumpOffset.new(truec.bytes.bytesize + 4))
+      @bytes << truec.bytes
+      jr(JumpOffset.new(falsec.bytes.bytesize))
+      @bytes << falsec.bytes
+    end
+
     def loop(&body)
-      subc = BodyCompiler.new(@globals, @locals, @declared_objects)
+      subc = clone_context
       subc.instance_exec(&body)
       @bytes << subc.bytes
       # the jump takes up 4 bytes: JR, LC2, LO, HI
-      jr(Complex(- (subc.bytes.bytesize + 4), 2))
+      jr(JumpOffset.new(- (subc.bytes.bytesize + 4)))
     end
 
     def loop_while_postcond(flag8, &body)
-      subc = BodyCompiler.new(@globals, @locals, @declared_objects)
-      subc.instance_exec(&body)
-      @bytes << subc.bytes
-      # the jump takes up 5 bytes: JR_TRUE, LV0(flag8), LC2, LO, HI
-      jr_true(flag8, Complex(- (subc.bytes.bytesize + 5), 2))
+      loop_while(body, Flag.new(flag8))
     end
 
     def loop_while(a, b)
@@ -95,18 +80,31 @@ module Lignite
     end
 
     def loop_while_post(condition, &body)
-      subc = BodyCompiler.new(@globals, @locals, @declared_objects)
+      subc = clone_context
       subc.instance_exec(&body)
       @bytes << subc.bytes
       body_size = subc.bytes.bytesize
       condition.jump_back(self, body_size)
     end
 
+    def loop_until_pre(condition, &body)
+      subc = clone_context
+      subc.instance_exec(&body)
+      ofs1 = @bytes.bytesize
+      condition.jump_forward(self, subc.bytes.bytesize + 4)
+      ofs2 = @bytes.bytesize
+      fw_jump_size = ofs2 - ofs1
+      @bytes << subc.bytes
+      jr(JumpOffset.new(-(fw_jump_size + subc.bytes.bytesize + 4)))
+    end
+
     def call(name, *args)
       obj_id = declared_objects.index_of(name)
       raise "Name #{name} not found" if obj_id.nil?
 
       # TODO: check that args match their declaration
+      # In particular, mixing up data32 with dataf passes the VM validity check
+      # but then misinterprets the bits.
       super(obj_id, *args) # Ev3Ops::call
     end