lignite 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 69c552fbf1d67d88480d8d1ffd3909ea41eebadf
-  data.tar.gz: c53de990e8d76b4960bfa8157f5aabb14c652fbf
+  metadata.gz: 4ffc33346a586d1761204e68f028b383303cc742
+  data.tar.gz: a57b880c420ef54dac5ea3b0023293867f5e9bdf
 SHA512:
-  metadata.gz: fb091ed264555daa9ea360e59cd3c27b097710d4d0f33105445a83d2640d8259a19f83e40cdd9625dd52588606a36a47f721384e2511b3ccf92b2dc5202b0fb2
-  data.tar.gz: 865cb7e2dadc5614708fde9aa728f7b9af07b78c5e0de4ac1642480c344026d986356a4500980ed24f15e449fefc534fb6aa69dd5b650c74f1c0da8c469a5aa8
+  metadata.gz: 41357f5c2e71a45aef56e9de73a36b2010462417210b18ea9fbd3cd654889a0103ff1aaf82ebb81f29571fa88f0f4bf43020e7dc56ac1f5862147d6b7278dd2e
+  data.tar.gz: 8a278113af2c9a7500d4ca7774dcb5e99a4ce163ad24e2446eb06e0b7ae4baddae676bbd736741b2d33491b3f52c75ec9f6b0bb2e8be05eff4386cf053292535

data/.yardopts

@@ -0,0 +1 @@
+--files NEWS.md

data/NEWS.md

@@ -0,0 +1,16 @@
+# News
+
+## unreleased
+
+- (none)
+
+## 0.2.0, 2018-02-26
+
+- DirectCommand can handle replies, allowing to read sensor data
+- Motors, for easy DirectCommands to motors
+    - with an example program for a [Tea Serving Robot][tea], which is a standard [Bobb3e][]
+- Assembler can compile global variables
+- More control flow: `if`, `loop_while_postcond`
+
+[Bobb3e]: https://www.lego.com/mindstorms/build-a-robot/bobb3e
+[tea]: https://www.youtube.com/watch?v=0KOEvz09kkA

data/README.md

@@ -41,9 +41,13 @@ section of the
 Running the built-in demo program: Connect the brick with a USB cable. Run
 
 ```sh
-sudo ev3tool run ../prjs/BrkProg_SAVE/Demo.rpf
+sudo ev3tool run BrkProg_SAVE/Demo.rpf
 ```
 
+In the usual case where the folder and the program name are the same, a
+shortcut works: `ev3tool run everstorm` is like `ev3tool run
+everstorm/everstorm.rbf`.
+
 > The `sudo` is needed to access the USB device.
 > With udev you can configure the system to allow access to all users like this:
 >

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.2.0

data/examples/bobbee.rb

@@ -0,0 +1,211 @@
+#!/usr/bin/ruby
+# coding: utf-8
+# https://www.lego.com/mindstorms/build-a-robot/bobb3e
+# A Bobcat® like two-tracked forklift
+
+require "lignite"
+
+class Bobbee
+  # @return [Lignite::Motors]
+  attr :drive
+  # @return [Lignite::Motors]
+  attr :lift
+  attr :dc
+
+  def initialize(drive: Lignite::PORT_B | Lignite::PORT_C,
+                 lift: Lignite::PORT_A,
+                 dc: Lignite::DirectCommands.new)
+    layer = 0
+    @drive = Lignite::Motors.new(layer, drive, dc)
+    @lift = Lignite::Motors.new(layer, lift, dc)
+    @dc = dc
+  end
+
+  # @param turn [Integer] -200..200
+  def time_sync(speed, turn, ms, brake = Lignite::BRAKE, wait: true)
+    # 1500 ms is about 1 boost square at speed 100
+    drive.time_sync(-speed, turn, ms, brake)
+  end
+
+  # @param turn [Integer] -200..200
+  def step_sync(speed, turn, degrees, brake = Lignite::BRAKE, wait: true)
+    # turn 0 (straight)
+    # -  900 (2.5 * 360) degrees is about 1 boost square
+    # turn 200 (full right)
+    # -  2400 degrees is a full turn, 600 deg is an about-right turn
+    #    where the center of rotation is the battery-cover of the brick,
+    #    or between the rear axles.
+    # turn 100 (semi right)
+    # - 4800 degrees is a full turn, about one of the rear axles
+    drive.step_sync(-speed, turn, degrees, brake)
+    drive.ready if wait
+  end
+
+  LIFT_FULL = 220
+
+  def raise(wait: true)
+    lift.step_power(30, 10, LIFT_FULL - 20, 10)
+    lift.ready if wait
+  end
+
+  def third_raise(wait: true)
+    lift.step_power(30, 10, LIFT_FULL/3 - 20, 10)
+    lift.ready if wait
+
+    beep
+    sleep 3
+  end
+
+  def lower(wait: true)
+    lift.step_power(-1, 10, LIFT_FULL - 20, 10) #, Lignite::COAST)
+    lift.ready if wait
+
+    beep
+    sleep 3
+  end
+
+  def third_lower(wait: true)
+    lift.step_power(-1, 10, LIFT_FULL/3 - 20, 10)
+    lift.ready if wait
+  end
+
+  def beep(ms = 300)
+    dc.sound_tone(20, 1760, ms)
+    dc.sound_ready
+  end
+
+  SQUARE_STEPS = 920
+  def f(steps = SQUARE_STEPS)
+    step_sync(50, 0, steps)
+    beep
+    sleep 3
+  end
+
+  def b(steps = SQUARE_STEPS)
+    step_sync(-50, 0, back_factor(steps))
+    beep
+    sleep 3
+  end
+
+  # it moves faster when going backwards!?
+  def back_factor(n)
+    (n * 0.95).to_i
+  end
+
+  ROTATION_OFFSET = 350
+  def f1
+    f(ROTATION_OFFSET)
+    beep(100)
+  end
+
+  TURN_90_AT_200_STEPS = 600
+  def l2
+    step_sync(50, -200, TURN_90_AT_200_STEPS)
+    beep(100)
+    sleep 3
+  end
+
+  def r2
+    step_sync(50, 200, TURN_90_AT_200_STEPS)
+    beep(100)
+    sleep 3
+  end
+
+  def f3
+    b(ROTATION_OFFSET)
+    beep(100)
+  end
+
+  def l
+    # a 3 part maneuver: forward, left, and back-a-little
+    # to turn 1 BS left
+    f1
+    l2
+    f3
+  end
+
+  def r
+    # a 3 part maneuver: forward, right, and back-a-little
+    # to turn 1 BS right
+    f1
+    r2
+    f3
+  end
+end
+
+bb = Bobbee.new
+# 1 BS
+# bb.time_sync(100, 0, 1500)
+
+# Put Bobb3e on the blue arrow. Move it one square left, and forward.
+# Put the container on a raised platform on the "twins" square.
+# Put a raised platform on the "fire" square
+def from_twins_to_fire(bb)
+  bb.instance_exec do
+    beep
+
+    third_raise
+    third_raise
+    r
+    f
+    third_raise
+    b
+    l
+    # we're at the starting position, but carrying the load
+
+    # move towards the recipient
+    f; f; r
+
+    # deliver and unload
+    f
+    third_lower
+    b
+
+    # resting position
+    l; b; b
+    third_lower
+    third_lower
+  end
+end
+
+def from_fire_to_twins(bb)
+  bb.instance_exec do
+    beep
+
+    third_raise
+    third_raise
+
+    # move towards the load
+    f; f; r
+
+    # load
+    f
+    third_raise
+    b
+
+    # starting position
+    l; b; b
+
+    # deliver
+    r
+    f
+    third_lower
+    b
+    l
+
+    # resting position
+    third_lower
+    third_lower
+  end
+end
+
+def calibrate_forward_and_back(bb)
+  bb.instance_exec do
+    f; f; f; f
+    b; b; b; b
+  end
+end
+
+# calibrate_forward_and_back(bb)
+from_twins_to_fire(bb)
+# from_fire_to_twins(bb)

data/examples/light-sensor.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/ruby
+require "lignite"
+
+dc = Lignite::DirectCommands.new
+
+# see 28/31 of Comm dev kit, read light sensor value on port 3
+LAYER0 = 0
+MODE = 0
+count = 1
+pct = dc.with_reply do
+  # global vars
+  dataf :light
+
+  # TODO: make the block optional if there are no locals. or #with_locals
+  block do
+    input_device_ready_si(LAYER0, Lignite::PORT_3, Lignite::TYPE_KEEP, MODE, count, :light)
+  end
+end
+puts "Light sensor percentage: #{pct}"

data/examples/motors.rb

@@ -15,5 +15,5 @@ dc.output_step_speed(layer, nos, speed,
 dc.output_ready(layer, nos)
 
 speed = -100
-dc.output_step_speed(layer, nos, speed,
-                     step_begin, step_do, step_end, brake)
+m = Lignite::Motors.new(layer, nos, dc)
+m.step_speed(speed, step_begin, step_do, step_end)

data/lib/lignite.rb

@@ -9,6 +9,7 @@ require "lignite/connection/usb"
 require "lignite/direct_commands"
 require "lignite/message"
 require "lignite/message_sender"
+require "lignite/motors"
 require "lignite/op_compiler"
 require "lignite/rbf_object"
 require "lignite/system_commands"
@@ -20,6 +21,11 @@ module Lignite
   PORT_C = 4
   PORT_D = 8
 
+  PORT_1 = 0
+  PORT_2 = 1
+  PORT_3 = 2
+  PORT_4 = 3
+
   COAST = 0
   BRAKE = 1
 

data/lib/lignite/assembler.rb

@@ -1,4 +1,7 @@
+require "lignite/variables"
+
 module Lignite
+  # Assemble a complete RBF program file.
   class Assembler
     include Bytes
     include Logger
@@ -9,12 +12,22 @@ module Lignite
         u32(global_bytes)
     end
 
-    def assemble(rb_filename, rbf_filename)
+    # @return [Array<RbfObject>]
+    attr :objects
+    # @return [Variables]
+    attr :globals
+
+    # Assemble a complete RBF program file.
+    # (it is OK to reuse an Assembler and call this several times in a sequence)
+    # TODO: redesign for Assembler.new(rb_filename).assemble(rbf_filename)?
+    # @param rb_filename [String] input
+    # @param rbf_filename [String] output
+    def assemble(rb_filename, rbf_filename, version: 109)
       rb_text = File.read(rb_filename)
       @objects = []
-      @global_bytes = 0
+      @globals = Variables.new
 
-      instance_eval(rb_text, rb_filename, 1)
+      instance_eval(rb_text, rb_filename, 1) # 1 is the line number
 
       File.open(rbf_filename, "w") do |f|
         dummy_header = image_header(image_size:0, version: 0, object_count: 0, global_bytes: 0)
@@ -28,18 +41,24 @@ module Lignite
         size = f.tell
         f.pos = 0
         header = image_header(image_size: size,
-                              version: 109,
+                              version: version,
                               object_count: @objects.size,
-                              global_bytes: @global_bytes)
+                              global_bytes: @globals.bytesize)
         f.write(header)
       end
     end
 
+    def variables
+      globals
+    end
+    include VariableDeclarer
+
     def vmthread(id, &body)
       @locals = Variables.new
-      bodyc = BodyCompiler.new(@locals)
+      bodyc = BodyCompiler.new(@globals, @locals)
       bodyc.instance_exec(&body)
       bodyc.instance_exec { object_end }
+      # FIXME: id is not written?!
       logger.debug "VMTHREAD #{id}"
       logger.debug "  size #{bodyc.bytes.bytesize}"
       logger.debug "  " + hexdump(bodyc.bytes)

data/lib/lignite/body_compiler.rb

@@ -3,36 +3,49 @@ module Lignite
   # - variable declarations: {VariableDeclarer}
   # - high level flow control: {#loop}
   class BodyCompiler
+    # @return [ByteString]
+    attr_reader :bytes
+    # @return [Variables]
+    attr_reader :locals
 
-    # {#locals} are {Variables}
-    module VariableDeclarer
-      def data32(id)
-        locals.add(id, 4)
-      end
-
-      def datas(id, size)
-        locals.add(id, size)
-      end
+    def variables
+      locals
     end
-
     include VariableDeclarer
-    attr_reader :bytes
-    attr_reader :locals
 
-    def initialize(locals)
+    def initialize(globals, locals)
       @bytes = ""
+      @globals = globals
       @locals = locals
-      @op_compiler = OpCompiler.new(nil, @locals)
+      @op_compiler = OpCompiler.new(@globals, @locals)
+    end
+
+    def if(flag8, &body)
+      subc = BodyCompiler.new(@globals, @locals)
+      subc.instance_exec(&body)
+
+      jr_false(flag8, Complex(subc.bytes.bytesize, 2))
+      @bytes << subc.bytes
     end
 
     def loop(&body)
-      subc = BodyCompiler.new(@locals)
+      subc = BodyCompiler.new(@globals, @locals)
       subc.instance_exec(&body)
       @bytes << subc.bytes
       # the jump takes up 4 bytes: JR, LC2, LO, HI
       jr(Complex(- (subc.bytes.bytesize + 4), 2))
     end
 
+    def loop_while_postcond(flag8, &body)
+      subc = BodyCompiler.new(@globals, @locals)
+      subc.instance_exec(&body)
+      @bytes << subc.bytes
+      # the jump takes up 4 bytes: JR_TRUE, LV0(flag8), LC2, LO, HI
+      jr_true(flag8, Complex(- (subc.bytes.bytesize + 5), 2))
+    end
+
+    # Delegate the ops to the {OpCompiler},
+    # but also aggregate the result in @bytes.
     def method_missing(name, *args)
       super unless @op_compiler.respond_to?(name)
 

data/lib/lignite/bytes.rb

@@ -1,4 +1,5 @@
 module Lignite
+  # Shortcut methods to convert between data and their byte representation
   module Bytes
     def u8(n)
       (n & 0xff).chr
@@ -28,6 +29,10 @@ module Lignite
       s.unpack("L<").first
     end
 
+    def unpack_f32(s)
+      s.unpack("e").first
+    end
+
     def hexdump(s)
       s.unpack("H*").first
     end

data/lib/lignite/direct_commands.rb

@@ -1,17 +1,37 @@
 module Lignite
-  # FIXME: cannot handle replies
   class DirectCommands
     # @param conn [Connection]
     def initialize(conn = Connection.create)
       @op_compiler = OpCompiler.new
       @sender = MessageSender.new(conn)
+      @globals = nil
+    end
+
+    def variables
+      @globals
+    end
+    include VariableDeclarer
+
+    def with_reply(&body)
+      @globals = Variables.new
+      ret_bytes = instance_exec(&body)
+      ret = @globals.unpack(ret_bytes)
+      @globals = nil
+      ret # TODO decode according to type
     end
 
     def block(&body)
       locals = Variables.new
-      bodyc = BodyCompiler.new(locals)
+      bodyc = BodyCompiler.new(@globals, locals)
       bodyc.instance_exec(&body)
-      @sender.direct_command(bodyc.bytes, local_size: locals.bytesize)
+
+      bs = bodyc.bytes
+      lsize = locals.bytesize
+      if @globals
+        @sender.direct_command_with_reply(bs, global_size: @globals.bytesize, local_size: lsize)
+      else
+        @sender.direct_command(bs, global_size: 0, local_size: lsize)
+      end
     end
 
     def method_missing(name, *args)

data/lib/lignite/message.rb

@@ -85,7 +85,7 @@ module Lignite
   end
 
   class DirectReply < Message
-    def new(msgid:, error:, body:)
+    def initialize(msgid:, error:, body:)
       @msgid = msgid
       @error = error
       @globals = body

data/lib/lignite/message_sender.rb

@@ -31,7 +31,7 @@ module Lignite
         raise VMError # no details?
       end
 
-      reply.data
+      reply.globals
     end
 
     def system_command_with_reply(instr_bytes)

data/lib/lignite/motors.rb

@@ -0,0 +1,165 @@
+module Lignite
+  # Send {DirectCommands} to motors.
+  # It's called Motors instead of Motor because some methods are designed
+  # to work on a pair if motors driving a vehicle.
+  class Motors
+    # do the DCs spawn independent threads??
+    # must run ready in the same block?
+
+    attr :layer
+    attr :nos
+    # @return [Lignite::DirectCommands]
+    attr :dc
+
+    # 0x02 | 0x04 | 0x08 -> [1, 2, 3]
+    def nos_as_indices
+      [0, 1, 2, 3].find_all do |n|
+        (nos & (1 << n)) != 0
+      end
+    end
+
+    def initialize(layer, nos, dc = Lignite::DirectCommands.new)
+      @layer = layer
+      @nos = nos
+      @dc = dc
+    end
+
+    # TODO filter out support: official: no
+
+    # the type is an OUT param so the VM SETs and we GET to learn the type?
+    def set_type
+      layer = @layer
+      nos_as_indices.map do |no|
+        type = dc.with_reply do
+          data8 :type
+          block do
+            output_set_type(layer, no, :type)
+          end
+        end
+        type
+      end
+    end
+
+    # TODO: direct commands can do outputs? not yet
+
+    # ATTR tacho, like degrees
+    def reset
+      dc.output_reset(lay, nos) # tacho counts
+    end
+
+    # ATTR running
+    def stop(brake = Lignite::BRAKE)
+      dc.output_stop(layer, nos, brake)
+    end
+
+    # ATTR power ~ speed ?
+    def power(power)
+      dc.output_power(layer, nos, power) # does this start them also?
+    end
+
+    def speed(speed)
+      dc.output_speed(layer, nos, speed) # does this start them also?
+    end
+
+    def start
+      dc.output_start(layer, nos)   # apparently not
+    end
+
+    # ATTR ~polarity
+    def polarity(pol)
+      dc.output_polarity(layer, nos, pol)
+    end
+
+    def read
+      layer = @layer
+      nos_as_indices.map do |no|
+        speed_tacho_pair = dc.with_reply do
+          data32 :tacho
+          data8 :speed
+          block do
+            output_read(layer, no, :speed, :tacho)
+          end
+        end
+        speed_tacho_pair
+      end
+    end
+
+    # ATTR running?
+    def test
+      layer = @layer
+      nos_as_indices.map do |no|
+        busy = dc.with_reply do
+          data8 :busy
+          block do
+            output_test(layer, no, :busy)
+          end
+        end
+        busy
+      end
+    end
+
+    # which commands are affected? not output_start they say
+    def ready
+      dc.output_ready(layer, nos)
+    end
+
+    # @param power [Integer] -100..100
+    # TODO better param protocol?
+    def step_power(power, deg1, deg2, deg3, brake = Lignite::BRAKE)
+      dc.output_step_power(layer, nos, power, deg1, deg2, deg3, brake)
+    end
+
+    # @param power [Integer] -100..100
+    # msec
+    def time_power(power, ms1, ms2, ms3, brake = Lignite::BRAKE)
+      dc.output_time_power(layer, nos, power, ms1, ms2, ms3, brake)
+    end
+
+    # @param speed [Integer] -100..100
+    # tachos
+    def step_speed(speed, deg1, deg2, deg3, brake = Lignite::BRAKE)
+      dc.output_step_speed(layer, nos, speed, deg1, deg2, deg3, brake)
+    end
+
+    # @param speed [Integer] -100..100
+    # msec
+    def time_speed(speed, ms1, ms2, ms3, brake = Lignite::BRAKE)
+      dc.output_time_speed(layer, nos, speed, ms1, ms2, ms3, brake)
+    end
+
+    # @param speed [Integer] -100..100
+    # @param turn [Integer] -200..200:
+    #   0 straight, 100 stops the right motor, -100 stops the left motor
+    #   > 100 reverses the right motor, < -100 reverses the left motor
+    def step_sync(speed, turn, tachos, brake = Lignite::BRAKE)
+      dc.output_step_sync(layer, nos, speed, turn, tachos, brake)
+    end
+
+    def time_sync(speed, turn, ms, brake = Lignite::BRAKE)
+      dc.output_time_sync(layer, nos, speed, turn, ms, brake)
+    end
+
+    # zero tachos, for use as sensor
+    def clr_count
+      dc.output_clr_count(layer, nos)
+    end
+
+    def get_count
+      layer = @layer
+      nos_as_indices.map do |no|
+        tachos = dc.with_reply do
+          data32 :tachos
+          block do
+            output_get_count(layer, no, :tachos)
+          end
+        end
+        tachos
+      end
+    end
+
+    # WTF?
+    def prg_stop
+      dc.output_prg_stop
+    end
+  end
+end

data/lib/lignite/op_compiler.rb

@@ -1,11 +1,21 @@
 require "yaml"
 
 module Lignite
+  # Dynamically constructs methods for all the instructions in ev3.yml
+  # The methods return the {ByteString}s corresponding to the ops.
   class OpCompiler
+    # TODO: doing it dynamically
+    # - is slow
+    # - makes the implementation harder to understand
+    # - means we cannot use YARD to document the API
+    # Therefore we should generate (most of) op_compiler.rb statically from
+    # ev3.yml ahead of the time.
+
     include Bytes
     include Logger
     extend Logger
 
+    # A marker for features that are not implemented yet
     class TODO < StandardError
     end
 
@@ -118,6 +128,8 @@ module Lignite
       @loaded = true
     end
 
+    # @param globals [Variables,nil]
+    # @param locals  [Variables,nil]
     def initialize(globals = nil, locals = nil)
       self.class.load_yml
       @globals = globals
@@ -190,6 +202,8 @@ module Lignite
        n & 0xff, (n >> 8) & 0xff, (n >> 16) & 0xff, (n >> 24) & 0xff]
     end
 
+    # Reference a variable.
+    # (For declaring, see {VariableDeclarer}.)
     def make_var(sym)
       raise "No variables declared, cannot process symbols" if @locals.nil? && @globals.nil?
       if @locals.key?(sym)
@@ -209,6 +223,7 @@ module Lignite
       when Integer
         make_lc(x).map(&:chr).join("")
       when Complex
+        # a Complex number: real: just like an Integer above, but imag tells how many bytes to use for it
         make_lc(x.real, x.imag).map(&:chr).join("")
       when String
         u8(0x80) + x + u8(0x00)

data/lib/lignite/rbf_object.rb

@@ -2,18 +2,24 @@ module Lignite
   # Part of an assembled RBF file
   class RbfObject
     include Bytes
+    # @return [RbfObject] make a Vmthread object
     def self.vmthread(body:, local_bytes:)
       new(owner: 0, triggers: 0, local_bytes: local_bytes, body: body)
     end
 
+    # @return [RbfObject] make a Subcall object
     def self.subcall(body:, local_bytes:)
       new(owner: 0, triggers: 1, local_bytes: local_bytes, body: body)
     end
 
+    # @return [RbfObject] make a Block object
     def self.block(owner:, triggers:, body:)
       new(owner: owner, triggers: triggers, local_bytes: 0, body: body)
     end
 
+    # @return [ByteString] an already assembled body of the object
+    attr :body
+
     def initialize(owner:, triggers:, local_bytes:, body:)
       @owner = owner
       @triggers = triggers
@@ -25,9 +31,5 @@ module Lignite
       u32(pos_before_header + 12) + # size of header
         u16(@owner) + u16(@triggers) + u32(@local_bytes)
     end
-
-    def body
-      @body
-    end
   end
 end

data/lib/lignite/variables.rb

@@ -1,27 +1,70 @@
 module Lignite
   # Allocate local or global variables
+  # FIXME: the user can make bad alignment, resulting in VMError at runtime
+  # bad:  data8 :speed; data32 :tacho; output_read(...)
+  # good  data32 :tacho; data8 :speed; output_read(...)
   class Variables
     def initialize
       @offset = 0
+      # for proper decoding of direct replies according to declared types
+      @unpacker = ""
       @vars = {}
     end
 
-    def add(id, size)
+    # declare
+    def add(id, size, unpacker)
       raise "Duplicate variable #{id}" if @vars.key?(id)
       @vars[id] = {offset: @offset, size: size}
       @offset += size
+      @unpacker += unpacker
     end
 
-    def bytesize
-      @offset
-    end
-
+    # use
     def key?(sym)
       @vars.key?(sym)
     end
 
+    # use
     def offset(sym)
       @vars[sym][:offset]
     end
+
+    # compile
+    def bytesize
+      @offset
+    end
+
+    # decode reply
+    def unpack(buf)
+      values = buf.unpack(@unpacker)
+      values.size == 1 ? values.first : values
+    end
+  end
+
+  # {#variables} are {Variables}
+  module VariableDeclarer
+    def data8(id)
+      variables.add(id, 1, "C")
+    end
+
+    def data16(id)
+      variables.add(id, 2, "S<")
+    end
+
+    def data32(id)
+      variables.add(id, 4, "L<")
+    end
+
+    def dataf(id)
+      variables.add(id, 4, "e")
+    end
+
+    def datas(id, size)
+      variables.add(id, size, "a#{size}")
+    end
+
+    def array8(id, count)
+      variables.add(id, count * 1, "C#{count}")
+    end
   end
 end

data/lignite.gemspec

@@ -16,13 +16,15 @@ TXT
   s.homepage    = "https://github.com/mvidner/lignite"
   s.license     = "GPL-3.0-only"
 
-  # ruby -e 'puts `git ls-files`.lines.map { |f| "    %s,\n" % f.strip.inspect }'
+  # ruby -e 'puts `git ls-files`.lines.map { |f| "    %s" % f.strip.inspect }.join ",\n"'
   s.files       = [
     ".coveralls.yml",
     ".gitignore",
     ".travis.yml",
+    ".yardopts",
     "COPYING",
     "Gemfile",
+    "NEWS.md",
     "README.md",
     "Rakefile",
     "VERSION",
@@ -30,7 +32,9 @@ TXT
     "data/ev3.yml",
     "data/lignite-btaddr",
     "data/sysops.yml",
+    "examples/bobbee.rb",
     "examples/hello.rb",
+    "examples/light-sensor.rb",
     "examples/lights.rb",
     "examples/motors.rb",
     "examples/sound.rb",
@@ -46,6 +50,7 @@ TXT
     "lib/lignite/logger.rb",
     "lib/lignite/message.rb",
     "lib/lignite/message_sender.rb",
+    "lib/lignite/motors.rb",
     "lib/lignite/op_compiler.rb",
     "lib/lignite/rbf_object.rb",
     "lib/lignite/system_commands.rb",
@@ -53,11 +58,17 @@ TXT
     "lib/lignite/version.rb",
     "lignite.gemspec",
     "spec/assembler_spec.rb",
+    "spec/data/ColorReadout.lms",
+    "spec/data/ColorReadout.rb",
+    "spec/data/ColorReadout.rbf",
     "spec/data/HelloWorld-subop.rb",
     "spec/data/HelloWorld-subop.rbf",
     "spec/data/HelloWorld.lms",
     "spec/data/HelloWorld.rb",
     "spec/data/HelloWorld.rbf",
+    "spec/data/NoDebug.lms",
+    "spec/data/NoDebug.rb",
+    "spec/data/NoDebug.rbf",
     "spec/data/VernierReadout.lms",
     "spec/data/VernierReadout.rb",
     "spec/data/VernierReadout.rbf",

data/spec/assembler_spec.rb

@@ -4,7 +4,7 @@ require "lignite"
 require "fileutils"
 
 describe Lignite::Assembler do
-  shared_examples "compiles" do |base|
+  shared_examples "compiles" do |base, asm_version|
     let(:datadir) { File.expand_path("../data", __FILE__) }
 
     let(:in_rb) { "#{datadir}/#{base}.rb" }
@@ -12,13 +12,15 @@ describe Lignite::Assembler do
     let(:expected_rbf) { "#{datadir}/#{base}.rbf" }
 
     it "correctly assembles #{base}" do
-      subject.assemble(in_rb, actual_rbf)
+      subject.assemble(in_rb, actual_rbf, version: asm_version)
       expect(FileUtils.compare_file(expected_rbf, actual_rbf)).to be_truthy
       FileUtils.rm actual_rbf
     end
   end
 
-  include_examples "compiles", "HelloWorld"
-  include_examples "compiles", "HelloWorld-subop"
-  include_examples "compiles", "VernierReadout"
+  it_behaves_like "compiles", "HelloWorld", 109
+  it_behaves_like "compiles", "HelloWorld-subop", 109
+  it_behaves_like "compiles", "VernierReadout", 109
+  it_behaves_like "compiles", "ColorReadout", 106
+  it_behaves_like "compiles", "NoDebug", 109
 end

data/spec/data/ColorReadout.lms

@@ -0,0 +1,75 @@
+define    PORT      1
+
+DATA16    Cmd
+DATA8     Type
+DATA8     Mode
+ARRAY8    Data 6
+
+vmthread  MAIN
+{
+  DATA32  Timer
+  DATA32  Data1
+  DATA32  Data2
+  DATA32  Data3
+  DATAS   String 8
+  DATA8   Mode
+  DATA8   State
+  
+
+  MOVE8_8(3,Mode)
+
+Loop:
+
+  UI_DRAW(FILLWINDOW,0x00,0,0)
+  UI_DRAW(SELECT_FONT,SMALL_FONT)
+  UI_DRAW(TEXT,FG_COLOR,0,10,' Color Readout  V0.00 ')
+  UI_DRAW(TEXT,FG_COLOR,0,30,'Mode ')
+
+  UI_DRAW(TEXT,FG_COLOR,0,50,'Raw 1')
+  UI_DRAW(TEXT,FG_COLOR,0,65,'Raw 2')
+  UI_DRAW(TEXT,FG_COLOR,0,80,'Raw 3')
+  UI_DRAW(TEXT,FG_COLOR,0,118,'Left = 3     Right = 4')
+  UI_DRAW(SELECT_FONT,NORMAL_FONT)
+  
+  MOVE8_32(Mode,Data1)
+  AND32(Data1,0xFF,Data1)
+  STRINGS(NUMBER_FORMATTED,Data1,'%1d',8,String)
+  UI_DRAW(TEXT,FG_COLOR,64,30,String)
+  
+  INPUT_DEVICE(READY_RAW,0,PORT,0,Mode,3,Data1,Data2,Data3)
+
+  AND32(Data1,0xFFFF,Data1)
+  STRINGS(NUMBER_FORMATTED,Data1,'%-5d',8,String)
+  UI_DRAW(TEXT,FG_COLOR,64,50,String)
+  
+  AND32(Data2,0xFFFF,Data2)
+  STRINGS(NUMBER_FORMATTED,Data2,'%-5d',8,String)
+  UI_DRAW(TEXT,FG_COLOR,64,65,String)
+  
+  AND32(Data3,0xFFFF,Data3)
+  STRINGS(NUMBER_FORMATTED,Data3,'%-5d',8,String)
+  UI_DRAW(TEXT,FG_COLOR,64,80,String)
+  
+  UI_DRAW(UPDATE)
+  
+  
+  UI_BUTTON(SHORTPRESS,LEFT_BUTTON,State)
+  JR_FALSE(State,Not3)
+  
+  MOVE8_8(3,Mode)
+  
+Not3:  
+
+  UI_BUTTON(SHORTPRESS,RIGHT_BUTTON,State)
+  JR_FALSE(State,Not4)
+  
+  MOVE8_8(4,Mode)
+  
+Not4:  
+
+  TIMER_WAIT(250,Timer)
+  TIMER_READY(Timer)
+
+	JR(Loop)
+}
+

data/spec/data/ColorReadout.rb

@@ -0,0 +1,67 @@
+PORT = 1
+
+# global vars - unused?!
+data16 :cmd
+data8  :type
+data8  :mode
+array8 :data, 6
+
+vmthread :MAIN do
+  data32 :Timer
+  data32 :Data1
+  data32 :Data2
+  data32 :Data3
+  datas :String, 8
+  data8 :Mode
+  data8 :State
+
+
+  move8_8(3, :Mode)
+
+  self.loop do
+    ui_draw(FILLWINDOW, 0x00, 0, 0)
+    ui_draw(SELECT_FONT, SMALL_FONT)
+    ui_draw(TEXT, FG_COLOR, 0, 10, ' Color Readout  V0.00 ')
+    ui_draw(TEXT, FG_COLOR, 0, 30, 'Mode ')
+
+    ui_draw(TEXT, FG_COLOR, 0, 50, 'Raw 1')
+    ui_draw(TEXT, FG_COLOR, 0, 65, 'Raw 2')
+    ui_draw(TEXT, FG_COLOR, 0, 80, 'Raw 3')
+    ui_draw(TEXT, FG_COLOR, 0, 118, 'Left = 3     Right = 4')
+    ui_draw(SELECT_FONT, NORMAL_FONT)
+
+    move8_32(:Mode, :Data1)
+    and32(:Data1, 0xFF, :Data1)
+    strings(NUMBER_FORMATTED, :Data1, '%1d', 8, :String)
+    ui_draw(TEXT, FG_COLOR, 64, 30, :String)
+
+    input_device(READY_RAW, 0, PORT, 0, :Mode, 3, :Data1, :Data2, :Data3)
+
+    and32(:Data1, 0xFFFF, :Data1)
+    strings(NUMBER_FORMATTED, :Data1, '%-5d', 8, :String)
+    ui_draw(TEXT, FG_COLOR, 64, 50, :String)
+
+    and32(:Data2, 0xFFFF, :Data2)
+    strings(NUMBER_FORMATTED, :Data2, '%-5d', 8, :String)
+    ui_draw(TEXT, FG_COLOR, 64, 65, :String)
+
+    and32(:Data3, 0xFFFF, :Data3)
+    strings(NUMBER_FORMATTED, :Data3, '%-5d', 8, :String)
+    ui_draw(TEXT, FG_COLOR, 64, 80, :String)
+
+    ui_draw(UPDATE)
+
+    ui_button(SHORTPRESS, LEFT_BUTTON, :State)
+    self.if(:State) do
+      move8_8(3, :Mode)
+    end
+
+    ui_button(SHORTPRESS, RIGHT_BUTTON, :State)
+    self.if(:State) do
+      move8_8(4, :Mode)
+    end
+
+    timer_wait(250, :Timer)
+    timer_ready(:Timer)
+  end
+end

data/spec/data/NoDebug.lms

@@ -0,0 +1,62 @@
+/*
+ * LEGO® MINDSTORMS EV3
+ *
+ * Copyright (C) 2010-2013 The LEGO Group
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+
+//  TCP 08.04.2013
+//! \page testnodebugappcode NoDebug Application
+//!
+//! <hr size="1"/>
+//!
+//! \verbatim
+//**********************************************************************
+define appv 'NoDebug V1.02'                                           //
+//**********************************************************************
+                                                                      //
+                                                                      //
+vmthread  MAIN                                                        //  void    MAIN(void)
+{                                                                     //  {
+  DATA8   ShowVersion                                                 //
+                                                                      //
+  UI_BUTTON(PRESSED,RIGHT_BUTTON,ShowVersion)                         //    UI_BUTTON(PRESSED,RIGHT_BUTTON,ShowVersion)
+  JR_FALSE(ShowVersion,DontShowVersion)                               //    if (ShowVersion)
+                                                                      //    {
+  UI_DRAW(FILLRECT,BG_COLOR,4,50,170,28)                              //      UI_DRAW(FILLRECT,BG_COLOR,4,50,170,28)
+  UI_DRAW(RECT,FG_COLOR,6,52,166,24)                                  //      UI_DRAW(RECT,FG_COLOR,6,52,166,24)
+  UI_DRAW(TEXT,FG_COLOR,13,60,appv)                                   //      UI_DRAW(TEXT,FG_COLOR,13,60,appv)
+  UI_DRAW(UPDATE)                                                     //      UI_DRAW(UPDATE)
+                                                                      //
+ShowVersionWait:                                                      //      do
+                                                                      //      {  
+  UI_BUTTON(PRESSED,RIGHT_BUTTON,ShowVersion)                         //        UI_BUTTON(PRESSED,RIGHT_BUTTON,ShowVersion)
+                                                                      //      }
+  JR_TRUE(ShowVersion,ShowVersionWait)                                //      while (ShowVersion)
+                                                                      //
+  UI_BUTTON(FLUSH)                                                    //      UI_BUTTON(FLUSH)
+DontShowVersion:                                                      //    }  
+                                                                      //
+  UI_DRAW(RESTORE,0)                                                  //    UI_DRAW(RESTORE,0)
+  UI_DRAW(TOPLINE,1)                                                  //    UI_DRAW(TOPLINE,1)
+  UI_WRITE(LED,LED_GREEN)                                             //    UI_WRITE(LED,LED_GREEN)
+                                                                      //
+  UI_WRITE(TERMINAL,0)                                                //    UI_WRITE(TERMINAL,0)
+}                                                                     //  }
+                                                                      //
+                                                                      //
+//! \endverbatim

data/spec/data/NoDebug.rb

@@ -0,0 +1,25 @@
+appv = 'NoDebug V1.02'
+
+vmthread :MAIN do
+  data8 :ShowVersion
+
+  ui_button(PRESSED, RIGHT_BUTTON, :ShowVersion)
+  self.if :ShowVersion do
+    ui_draw(FILLRECT, BG_COLOR, 4, 50, 170, 28)
+    ui_draw(RECT, FG_COLOR, 6, 52, 166, 24)
+    ui_draw(TEXT, FG_COLOR, 13, 60, appv)
+    ui_draw(UPDATE)
+
+    loop_while_postcond(:ShowVersion) do
+      ui_button(PRESSED, RIGHT_BUTTON, :ShowVersion)
+    end
+
+    ui_button(FLUSH)
+  end
+
+  ui_draw(RESTORE, 0)
+  ui_draw(TOPLINE, 1)
+  ui_write(LED, LED_GREEN)
+
+  ui_write(TERMINAL, 0)
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lignite
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Martin Vidner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-20 00:00:00.000000000 Z
+date: 2018-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: libusb
@@ -112,8 +112,10 @@ files:
 - ".coveralls.yml"
 - ".gitignore"
 - ".travis.yml"
+- ".yardopts"
 - COPYING
 - Gemfile
+- NEWS.md
 - README.md
 - Rakefile
 - VERSION
@@ -121,7 +123,9 @@ files:
 - data/ev3.yml
 - data/lignite-btaddr
 - data/sysops.yml
+- examples/bobbee.rb
 - examples/hello.rb
+- examples/light-sensor.rb
 - examples/lights.rb
 - examples/motors.rb
 - examples/sound.rb
@@ -137,6 +141,7 @@ files:
 - lib/lignite/logger.rb
 - lib/lignite/message.rb
 - lib/lignite/message_sender.rb
+- lib/lignite/motors.rb
 - lib/lignite/op_compiler.rb
 - lib/lignite/rbf_object.rb
 - lib/lignite/system_commands.rb
@@ -144,11 +149,17 @@ files:
 - lib/lignite/version.rb
 - lignite.gemspec
 - spec/assembler_spec.rb
+- spec/data/ColorReadout.lms
+- spec/data/ColorReadout.rb
+- spec/data/ColorReadout.rbf
 - spec/data/HelloWorld-subop.rb
 - spec/data/HelloWorld-subop.rbf
 - spec/data/HelloWorld.lms
 - spec/data/HelloWorld.rb
 - spec/data/HelloWorld.rbf
+- spec/data/NoDebug.lms
+- spec/data/NoDebug.rb
+- spec/data/NoDebug.rbf
 - spec/data/VernierReadout.lms
 - spec/data/VernierReadout.rb
 - spec/data/VernierReadout.rbf