lignite 0.1.0

data/lib/lignite/op_compiler.rb

@@ -0,0 +1,224 @@
+require "yaml"
+
+module Lignite
+  class OpCompiler
+    include Bytes
+    include Logger
+    extend Logger
+
+    class TODO < StandardError
+    end
+
+    def self.load_const(name, value)
+      raise "duplicate constant #{name}" if Lignite.const_defined?(name)
+      Lignite.const_set(name, value)
+    end
+
+    def self.load_op(oname, odata)
+      ovalue = odata["value"]
+      oparams = odata["params"]
+      p1 = oparams.first
+      if p1 && p1["type"] == "SUBP"
+        commands = p1["commands"]
+        commands.each do |cname, cdata|
+          cvalue = cdata["value"]
+          load_const(cname, cvalue)
+          cparams = cdata["params"]
+          define_op("#{oname}_#{cname}", ovalue, cvalue, cparams)
+        end
+        define_multiop(oname, commands)
+      else
+        define_op(oname, ovalue, nil, oparams)
+      end
+    end
+
+    def self.define_multiop(oname, commands)
+      names = commands.map do |cname, cdata|
+        csym = cname.downcase.to_sym
+        cvalue = cdata["value"]
+        [cvalue, csym]
+      end.to_h
+
+      osym = oname.downcase.to_sym
+      define_method(osym) do |*args|
+        logger.debug "called #{osym} with #{args.inspect}"
+        cvalue = args.shift
+        csym = names.fetch(cvalue)
+        send("#{osym}_#{csym}", *args)
+      end
+    end
+
+    def self.define_op(oname, ovalue, cvalue, params)
+      check_arg_count = true
+      param_handlers = params.map do |par|
+        case par["type"]
+        when "PARLAB"           # a label, only one opcode
+          raise TODO
+        when "PARNO"            # the value says how many other params follow
+          check_arg_count = false
+          ->(x) { param_simple(x) }
+        when "PARS"             # string
+          raise TODO
+        when "PARV"             # value, type depends
+          raise TODO
+        when "PARVALUES"
+          raise TODO
+        when "PAR8", "PAR16", "PAR32", "PARF"
+          ->(x) { param_simple(x) }
+        else
+          raise "Unhandled param type #{par["type"]}"
+        end
+      end
+
+      osym = oname.downcase.to_sym
+      define_method(osym) do |*args|
+        logger.debug "called #{osym} with #{args.inspect}"
+        if check_arg_count && args.size != param_handlers.size
+          raise ArgumentError, "expected #{param_handlers.size} arguments, got #{args.size}"
+        end
+
+        bytes = u8(ovalue)
+        bytes += param_simple(cvalue) unless cvalue.nil?
+
+        bytes += args.zip(param_handlers).map do |a, h|
+          h ||= ->(x) { param_simple(x) }
+          # h.call(a) would have self = Op instead of #<Op>
+          instance_exec(a, &h)
+        end.join("")
+        logger.debug "returning bytecode: #{bytes.inspect}"
+        bytes
+      end
+    rescue TODO
+      logger.debug "Could not define #{oname}"
+    end
+
+    @loaded = false
+
+    def self.load_yml
+      return if @loaded
+      fname = File.expand_path("../../../data/ev3.yml", __FILE__)
+      yml = YAML.load_file(fname)
+      op_hash = yml["ops"]
+      op_hash.each do |oname, odata|
+        load_op(oname, odata)
+      end
+
+      defines = yml["defines"]
+      defines.each do |dname, ddata|
+        load_const(dname, ddata["value"])
+      end
+
+      enums = yml["enums"]
+      enums.each do |ename, edata|
+        edata["members"].each do |mname, mdata|
+          load_const(mname, mdata["value"])
+        end
+      end
+
+      @loaded = true
+    end
+
+    def initialize(globals = nil, locals = nil)
+      self.class.load_yml
+      @globals = globals
+      @locals = locals
+    end
+
+    private
+
+    PRIMPAR_SHORT      = 0x00
+    PRIMPAR_LONG       = 0x80
+
+    PRIMPAR_CONST      = 0x00
+    PRIMPAR_VARIABEL   = 0x40
+    PRIMPAR_LOCAL      = 0x00
+    PRIMPAR_GLOBAL     = 0x20
+    PRIMPAR_HANDLE     = 0x10
+    PRIMPAR_ADDR       = 0x08
+
+    PRIMPAR_INDEX      = 0x1F
+    PRIMPAR_CONST_SIGN = 0x20
+    PRIMPAR_VALUE      = 0x3F
+
+    PRIMPAR_BYTES      = 0x07
+
+    PRIMPAR_STRING_OLD = 0
+    PRIMPAR_1_BYTE     = 1
+    PRIMPAR_2_BYTES    = 2
+    PRIMPAR_4_BYTES    = 3
+    PRIMPAR_STRING     = 4
+
+    PRIMPAR_LABEL      = 0x20
+
+    def make_lcn(n, bytes)
+      case bytes
+      when 0
+        [n & PRIMPAR_VALUE]
+      when 1
+        [PRIMPAR_LONG | PRIMPAR_1_BYTE, n & 0xff]
+      when 2
+        [PRIMPAR_LONG | PRIMPAR_2_BYTES, n & 0xff, (n >> 8) & 0xff]
+      else
+        [PRIMPAR_LONG | PRIMPAR_4_BYTES,
+         n & 0xff, (n >> 8) & 0xff, (n >> 16) & 0xff, (n >> 24) & 0xff]
+      end
+    end
+
+    def make_lc(n, bytes = nil)
+      bytes ||= if (-31 .. 31).include? n
+                  0
+                elsif (-127 .. 127).include? n
+                  1
+                elsif (-32767 .. 32767).include? n
+                  2
+                else
+                  4
+                end
+      make_lcn(n, bytes)
+    end
+
+    def make_v(n, local_or_global)
+      vartag = PRIMPAR_VARIABEL | local_or_global
+      if (0 .. 31).include? n
+        return [vartag | (n & PRIMPAR_VALUE)]
+      elsif (0 .. 255).include? n
+        return [vartag | PRIMPAR_LONG | PRIMPAR_1_BYTE, n & 0xff]
+      elsif (0 .. 65535).include? n
+        return [vartag | PRIMPAR_LONG | PRIMPAR_2_BYTES, n & 0xff, (n >> 8) & 0xff]
+      end
+      [vartag | PRIMPAR_LONG | PRIMPAR_4_BYTES,
+       n & 0xff, (n >> 8) & 0xff, (n >> 16) & 0xff, (n >> 24) & 0xff]
+    end
+
+    def make_var(sym)
+      raise "No variables declared, cannot process symbols" if @locals.nil? && @globals.nil?
+      if @locals.key?(sym)
+        o = @locals.offset(sym)
+        make_v(o, PRIMPAR_LOCAL)
+      elsif @globals.key?(sym)
+        o = @globals.offset(sym)
+        make_v(o, PRIMPAR_GLOBAL)
+      else
+        raise "Variable #{sym} not found"
+      end
+    end
+
+    # @return [ByteString]
+    def param_simple(x)
+      case x
+      when Integer
+        make_lc(x).map(&:chr).join("")
+      when Complex
+        make_lc(x.real, x.imag).map(&:chr).join("")
+      when String
+        u8(0x80) + x + u8(0x00)
+      when Float
+        u8(0x83) + f32(x)
+      when Symbol
+        make_var(x).map(&:chr).join("")
+      else
+        raise ArgumentError, "Unexpected type: #{x.class}"
+      end
+    end
+  end
+end

data/lib/lignite/rbf_object.rb

@@ -0,0 +1,33 @@
+module Lignite
+  # Part of an assembled RBF file
+  class RbfObject
+    include Bytes
+    def self.vmthread(body:, local_bytes:)
+      new(owner: 0, triggers: 0, local_bytes: local_bytes, body: body)
+    end
+
+    def self.subcall(body:, local_bytes:)
+      new(owner: 0, triggers: 1, local_bytes: local_bytes, body: body)
+    end
+
+    def self.block(owner:, triggers:, body:)
+      new(owner: owner, triggers: triggers, local_bytes: 0, body: body)
+    end
+
+    def initialize(owner:, triggers:, local_bytes:, body:)
+      @owner = owner
+      @triggers = triggers
+      @local_bytes = local_bytes
+      @body = body
+    end
+
+    def header(pos_before_header = 0)
+      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/system_commands.rb

@@ -0,0 +1,103 @@
+module Lignite
+  class SystemCommands
+    include Bytes
+    include Logger
+    extend Logger
+
+    # @param conn [Connection]
+    def initialize(conn = Connection.create)
+      @message_sender = MessageSender.new(conn)
+      load_yml
+    end
+
+    def load_yml
+      fname = File.expand_path("../../../data/sysops.yml", __FILE__)
+      op_hash = YAML.load_file(fname)["sysops"]
+      op_hash.each do |oname, odata|
+        load_op(oname, odata)
+      end
+    end
+
+    # oname LIST_FILES
+    def load_op(oname, odata)
+      ovalue = odata["value"]
+
+      param_handlers, return_handlers = handlers(odata)
+
+      osym = oname.downcase.to_sym
+      self.class.send(:define_method, osym) do |*args|
+        logger.debug "called #{osym} with #{args.inspect}"
+        if args.size != param_handlers.size
+          raise ArgumentError, "expected #{param_handlers.size} arguments, got #{args.size}"
+        end
+
+        bytes = u8(ovalue)
+        bytes += param_handlers.zip(args).map do |h, a|
+          # h.call(a) would have self = Op instead of #<Op>
+          instance_exec(a, &h)
+        end.join("")
+        logger.debug "sysop to execute: #{bytes.inspect}"
+
+        reply = @message_sender.system_command_with_reply(bytes)
+
+        # TODO: parse it with return_handlers
+        replies = return_handlers.map do |h|
+          parsed, reply = h.call(reply)
+          parsed
+        end
+        raise "Unparsed reply #{reply.inspect}" unless reply.empty?
+        # A single reply is returned as a scalar, not an array
+        replies.size == 1 ? replies.first : replies
+      end
+    end
+
+    def handlers(odata)
+      oparams = odata["params"]
+      param_handlers = []
+      return_handlers = []
+      oparams.each do |p|
+        if p["dir"] == "in"
+          param_handlers << param_handler(p)
+        else
+          return_handlers << return_handler(p)
+        end
+      end
+      [param_handlers, return_handlers]
+    end
+
+    def param_handler(oparam)
+      case oparam["type"]
+      when "U8"
+        ->(x) { u8(x) }
+      when "U16"
+        ->(x) { u16(x) }
+      when "U32"
+        ->(x) { u32(x) }
+      when "BYTES"
+        ->(x) { x }
+      when "ZBYTES"
+        ->(x) { x + u8(0) }
+      else
+        raise
+      end
+    end
+
+    # the handler is a lambda returning a pair:
+    # a parsed value and the rest of the input
+    def return_handler(oparam)
+      case oparam["type"]
+      when "U8"
+        ->(i) { [unpack_u8(i[0, 1]), i[1..-1]] }
+      when "U16"
+        ->(i) { [unpack_u16(i[0, 2]), i[2..-1]] }
+      when "U32"
+        ->(i) { [unpack_u32(i[0, 4]), i[4..-1]] }
+      when "BYTES"
+        ->(i) { [i, ""] }
+      else
+        raise
+      end
+    end
+
+  end
+end

data/lib/lignite/variables.rb

@@ -0,0 +1,27 @@
+module Lignite
+  # Allocate local or global variables
+  class Variables
+    def initialize
+      @offset = 0
+      @vars = {}
+    end
+
+    def add(id, size)
+      raise "Duplicate variable #{id}" if @vars.key?(id)
+      @vars[id] = {offset: @offset, size: size}
+      @offset += size
+    end
+
+    def bytesize
+      @offset
+    end
+
+    def key?(sym)
+      @vars.key?(sym)
+    end
+
+    def offset(sym)
+      @vars[sym][:offset]
+    end
+  end
+end

data/lib/lignite/version.rb

@@ -0,0 +1,4 @@
+module Lignite
+  # Lignite version (uses [semantic versioning](http://semver.org/)).
+  VERSION = File.read(File.dirname(__FILE__) + "/../../VERSION").strip
+end

data/lignite.gemspec

@@ -0,0 +1,74 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path(File.dirname(__FILE__) + "/lib/lignite/version")
+
+Gem::Specification.new do |s|
+  s.name        = "lignite"
+  s.version     = Lignite::VERSION
+  s.summary     = "Program LEGO Mindstorms EV3 in Ruby"
+  s.description = <<TXT
+Lignite is a set of Ruby tools to interact with LEGO Mindstorms EV3.
+It uses the original LMS2012 firmware, so ev3dev is not required.
+TXT
+
+  s.author      = "Martin Vidner"
+  s.email       = "martin@vidner.net"
+  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 }'
+  s.files       = [
+    ".gitignore",
+    "COPYING",
+    "Gemfile",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "bin/ev3tool",
+    "data/ev3.yml",
+    "data/lignite-btaddr",
+    "data/sysops.yml",
+    "examples/hello.rb",
+    "examples/lights.rb",
+    "examples/motors.rb",
+    "examples/sound.rb",
+    "examples/sys_list_files.rb",
+    "lib/lignite.rb",
+    "lib/lignite/assembler.rb",
+    "lib/lignite/body_compiler.rb",
+    "lib/lignite/bytes.rb",
+    "lib/lignite/connection.rb",
+    "lib/lignite/connection/bluetooth.rb",
+    "lib/lignite/connection/usb.rb",
+    "lib/lignite/direct_commands.rb",
+    "lib/lignite/logger.rb",
+    "lib/lignite/message.rb",
+    "lib/lignite/message_sender.rb",
+    "lib/lignite/op_compiler.rb",
+    "lib/lignite/rbf_object.rb",
+    "lib/lignite/system_commands.rb",
+    "lib/lignite/variables.rb",
+    "lib/lignite/version.rb",
+    "lignite.gemspec",
+    "spec/assembler_spec.rb",
+    "spec/data/HelloWorld-subop.rb",
+    "spec/data/HelloWorld-subop.rbf",
+    "spec/data/HelloWorld.lms",
+    "spec/data/HelloWorld.rb",
+    "spec/data/HelloWorld.rbf",
+    "spec/data/VernierReadout.lms",
+    "spec/data/VernierReadout.rb",
+    "spec/data/VernierReadout.rbf",
+    "spec/spec_helper.rb"
+  ]
+
+  s.executables = s.files.grep(/^bin\//) { |f| File.basename(f) }
+
+  s.required_ruby_version = ">= 2.1" # mandatory keyword arguments
+  s.add_dependency "libusb", "~> 0.6"
+
+  s.add_development_dependency "coveralls", "~> 0"
+  s.add_development_dependency "simplecov", "~> 0"
+  s.add_development_dependency "rspec", "~> 3"
+  s.add_development_dependency "yard", "~> 0"
+end