lignite 0.1.0

data/lib/lignite/body_compiler.rb

@@ -0,0 +1,42 @@
+module Lignite
+  # Extends {OpCompiler} by
+  # - variable declarations: {VariableDeclarer}
+  # - high level flow control: {#loop}
+  class BodyCompiler
+
+    # {#locals} are {Variables}
+    module VariableDeclarer
+      def data32(id)
+        locals.add(id, 4)
+      end
+
+      def datas(id, size)
+        locals.add(id, size)
+      end
+    end
+
+    include VariableDeclarer
+    attr_reader :bytes
+    attr_reader :locals
+
+    def initialize(locals)
+      @bytes = ""
+      @locals = locals
+      @op_compiler = OpCompiler.new(nil, @locals)
+    end
+
+    def loop(&body)
+      subc = BodyCompiler.new(@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 method_missing(name, *args)
+      super unless @op_compiler.respond_to?(name)
+
+      @bytes += @op_compiler.send(name, *args)
+    end
+  end
+end

data/lib/lignite/bytes.rb

@@ -0,0 +1,35 @@
+module Lignite
+  module Bytes
+    def u8(n)
+      (n & 0xff).chr
+    end
+
+    def u16(n)
+      u8(n & 0xff) + u8(n >> 8)
+    end
+
+    def u32(n)
+      u16(n & 0xffff) + u16(n >> 16)
+    end
+
+    def f32(float)
+      [float].pack("e")
+    end
+
+    def unpack_u8(s)
+      s.unpack("C").first
+    end
+
+    def unpack_u16(s)
+      s.unpack("S<").first
+    end
+
+    def unpack_u32(s)
+      s.unpack("L<").first
+    end
+
+    def hexdump(s)
+      s.unpack("H*").first
+    end
+  end
+end

data/lib/lignite/connection.rb

@@ -0,0 +1,13 @@
+module Lignite
+  class Connection
+    # @return [Connection] Try a {Usb} connection first, then a {Bluetooth} one.
+    def self.create
+      @c ||= begin
+               Usb.new
+             rescue NoUsbDevice
+               Bluetooth.new
+             end
+    end
+    # FIXME: how to close and reopen a connection?
+  end
+end

data/lib/lignite/connection/bluetooth.rb

@@ -0,0 +1,37 @@
+require "socket"
+
+module Lignite
+  class Connection
+    class Bluetooth < Connection
+      AF_BLUETOOTH = 31
+      BTPROTO_RFCOMM = 3
+
+      # @param address [String] "11:22:33:44:55:66"
+      def initialize(address = address_from_file)
+        @sock = Socket.new(AF_BLUETOOTH, :STREAM, BTPROTO_RFCOMM)
+        addr_b = address.split(/:/).map { |x| x.to_i(16) }
+        channel = 1
+        sockaddr = [AF_BLUETOOTH, 0, *addr_b.reverse, channel, 0].pack("C*")
+        # common exceptions:
+        # "Errno::EHOSTUNREACH: No route to host": BT is disabled;
+        #   use `hciconfig hci0 up`
+        # "Errno::EHOSTDOWN: Host is down": Turn the brick on, enable BT
+        @sock.connect(sockaddr)
+      end
+
+      def address_from_file
+        fn = "#{ENV['HOME']}/.config/lignite-btaddr"
+        s = File.read(fn)
+        s.lines.grep(/^[0-9a-fA-F]/).first.strip
+      end
+
+      def read(n)
+        @sock.recv(n)
+      end
+
+      def write(s)
+        @sock.write(s)
+      end
+    end
+  end
+end

data/lib/lignite/connection/usb.rb

@@ -0,0 +1,74 @@
+# https://github.com/larskanis/libusb
+require "libusb"
+
+module Lignite
+  class NoUsbDevice < RuntimeError
+  end
+
+  class Connection
+    class Usb < Connection
+      include Logger
+
+      # To get to the endpoint we need to descend down the hierarchy of
+      # 1) Device
+      VENDOR_LEGO = 0x0694
+      PRODUCT_EV3 = 5
+      # 2) Configuration, 1-based
+      CONFIGURATION_EV3 = 1
+      # 3) Interface, 0-based
+      INTERFACE_EV3 = 0
+      # 4) Alternate setting, 0-based
+      SETTING_EV3 = 0
+      # 5) Endpoint, 0-based
+      ENDPOINT_EV3 = 1
+
+      attr_reader :device, :interface, :out_ep, :in_ep
+
+      def initialize
+        usb = LIBUSB::Context.new
+        @device = usb.devices(idVendor: VENDOR_LEGO, idProduct: PRODUCT_EV3).first
+        raise Lignite::NoUsbDevice if @device.nil?
+
+        ## Because multiple configs are rare, the library allows to omit this:
+        ## device.set_configuration(CONFIGURATION_EV3)
+        @interface = @device.interfaces[INTERFACE_EV3]
+        eps = @interface.endpoints
+        @out_ep = eps.find { |e| e.direction == :out}
+        @in_ep = eps.find { |e| e.direction == :in}
+      end
+
+      # @return [Integer] number of bytes written
+      def write(data)
+        written = nil
+        @device.open do |devh|
+          devh.auto_detach_kernel_driver = true
+          devh.claim_interface(@interface) do
+            written = devh.interrupt_transfer(endpoint: @out_ep, dataOut: data)
+          end
+        end
+        written
+      end
+
+      # @return [String]
+      def read(bytes = nil)
+        got = nil
+        @device.open do |devh|
+          devh.auto_detach_kernel_driver = true
+          devh.claim_interface(@interface) do
+            begin
+              got = devh.interrupt_transfer(endpoint: @in_ep, dataIn: bytes)
+            rescue LIBUSB::Error => e
+              if e.transferred.is_a? String
+                got = e.transferred
+              else
+                raise
+              end
+            end
+          end
+        end
+        logger.debug "Read returning #{got.bytesize} bytes"
+        got
+      end
+    end
+  end
+end

data/lib/lignite/direct_commands.rb

@@ -0,0 +1,26 @@
+module Lignite
+  # FIXME: cannot handle replies
+  class DirectCommands
+    # @param conn [Connection]
+    def initialize(conn = Connection.create)
+      @op_compiler = OpCompiler.new
+      @sender = MessageSender.new(conn)
+    end
+
+    def block(&body)
+      locals = Variables.new
+      bodyc = BodyCompiler.new(locals)
+      bodyc.instance_exec(&body)
+      @sender.direct_command(bodyc.bytes, local_size: locals.bytesize)
+    end
+
+    def method_missing(name, *args)
+      if @op_compiler.respond_to?(name)
+        insb = @op_compiler.send(name, *args)
+        @sender.direct_command(insb)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/lignite/logger.rb

@@ -0,0 +1,15 @@
+require "logger"
+
+module Lignite
+  module Logger
+    def self.default_logger
+      logger = ::Logger.new(STDERR)
+      logger.level = $VERBOSE ? ::Logger::DEBUG : ::Logger::INFO
+      logger
+    end
+
+    def logger
+      @logger ||= Logger.default_logger
+    end
+  end
+end

data/lib/lignite/message.rb

@@ -0,0 +1,100 @@
+module Lignite
+  # A Message has 3 common parts:
+  # - length u16, (not including the length itself);
+  #   this is added by {MessageSender#send}
+  #   and stripped by {MessageSender#receive}
+  # - msgid, u16
+  # - type, u8
+  # and then a type-specific body.
+  # It is sent or received via {MessageSender}
+  class Message
+    include Bytes
+    extend Bytes
+    extend Logger
+    @msg_counter = rand(65535)
+
+    def self.msgid
+      @msg_counter += 1
+      logger.debug "MSGID #{@msg_counter}"
+      @msg_counter
+    end
+
+    attr_reader :msgid, :type, :body
+
+    def initialize(type:, body:)
+      @msgid = self.class.msgid
+      @type = type
+      @body = body
+    end
+
+    # not including the length
+    def bytes
+      u16(@msgid) + u8(@type) + @body
+    end
+
+    def self.system_command_with_reply(body)
+      new(type: 0x01, body: body)
+    end
+
+    def self.system_command_no_reply(body)
+      new(type: 0x81, body: body)
+    end
+
+    def self.direct_command_with_reply(body)
+      new(type: 0x00, body: body)
+    end
+
+    def self.direct_command_no_reply(body)
+      new(type: 0x80, body: body)
+    end
+
+    # @param bytes [ByteString] does not include the length field
+    def self.reply_from_bytes(bytes)
+      msgid = unpack_u16(bytes[0..1])
+      type = unpack_u8(bytes[2])
+      body = bytes[3..-1]
+      case type
+      when 0x03               # SYSTEM_REPLY
+        SystemReply.new(msgid: msgid, error: false, body: body)
+      when 0x05               # SYSTEM_REPLY_ERROR
+        SystemReply.new(msgid: msgid, error: true, body: body)
+      when 0x02               # DIRECT_REPLY
+        DirectReply.new(msgid: msgid, error: false, body: body)
+      when 0x04               # DIRECT_REPLY_ERROR
+        DirectReply.new(msgid: msgid, error: true, body: body)
+      else
+        raise "Unexpected reply type %x" % type
+      end
+    end
+  end
+
+  class SystemReply < Message
+    def initialize(msgid:, error:, body:)
+      @msgid = msgid
+      @error = error
+      @command = unpack_u8(body[0])
+      @status = unpack_u8(body[1])
+      @data = body[2..-1]
+    end
+
+    attr_reader :msgid, :error, :command, :status, :data
+
+    def error?
+      @error
+    end
+  end
+
+  class DirectReply < Message
+    def new(msgid:, error:, body:)
+      @msgid = msgid
+      @error = error
+      @globals = body
+    end
+
+    attr_reader :msgid, :error, :globals
+
+    def error?
+      @error
+    end
+  end
+end

data/lib/lignite/message_sender.rb

@@ -0,0 +1,92 @@
+module Lignite
+
+  # FIXME: Possibly merge with Connection (UsbConnection)
+  class MessageSender
+    include Bytes
+    include Logger
+
+    def initialize(connection)
+      @c = connection
+      @buf = ""
+    end
+
+    def direct_command(instr_bytes, global_size: 0, local_size: 0)
+      body = u16(var_alloc(global_size: global_size, local_size: local_size)) +
+             instr_bytes
+      cmd = Message.direct_command_no_reply(body)
+      send(cmd.bytes)
+    end
+
+    def direct_command_with_reply(instr_bytes, global_size: 0, local_size: 0)
+      body = u16(var_alloc(global_size: global_size, local_size: local_size)) +
+             instr_bytes
+      cmd = Message.direct_command_with_reply(body)
+      send(cmd.bytes)
+
+      reply = Message.reply_from_bytes(receive)
+      assert_match(reply.msgid, cmd.msgid, "Reply id")
+      if reply.error?
+        raise "VMError"         # no details?
+      end
+
+      reply.data
+    end
+
+    def system_command_with_reply(instr_bytes)
+      cmd = Message.system_command_with_reply(instr_bytes)
+      send(cmd.bytes)
+
+      reply = Message.reply_from_bytes(receive)
+      assert_match(reply.msgid, cmd.msgid, "Reply id")
+      assert_match(reply.command, unpack_u8(instr_bytes[0]), "Command num")
+      if reply.error?
+        raise "VMError, %u" % reply.status
+      end
+
+      reply.data
+    end
+
+    private
+
+    def send(payload)
+      packet = u16(payload.bytesize) + payload
+      logger.debug "-> #{packet.inspect}"
+      @c.write(packet)
+    end
+
+    # read must not be called with a too low value :-/
+    def bufread(n)
+      while n > @buf.bytesize
+        @buf += @c.read(10000)
+      end
+      ret = @buf[0, n]
+      @buf = @buf[n..-1]
+      logger.debug "R<-(#{ret.bytesize})#{ret.inspect}"
+      ret
+    end
+
+    def receive
+      size = nil
+      loop do
+        lenbuf = bufread(2)
+        size = unpack_u16(lenbuf)
+        break unless size.zero?
+        # leftover data?
+        @buf = ""
+      end
+
+      res = bufread(size)
+      res
+    end
+
+    def var_alloc(global_size:, local_size:)
+      var_alloc = global_size & 0x3ff
+      var_alloc |= (local_size & 0x3f) << 10
+    end
+
+    def assert_match(actual, expected, description)
+      return if actual == expected
+      raise "#{description} does not match, expected #{expected}, actual #{actual}"
+    end
+  end
+end