lignite 0.2.0 → 0.3.0

data/lib/lignite.rb

@@ -5,10 +5,11 @@ require "lignite/assembler"
 require "lignite/body_compiler"
 require "lignite/connection"
 require "lignite/connection/bluetooth"
+require "lignite/connection/replay"
+require "lignite/connection/tap"
 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"
@@ -33,4 +34,7 @@ module Lignite
   class ByteString < String
     # empty class, just for documentation purposes
   end
+
+  class VMError < RuntimeError
+  end
 end

data/lib/lignite/assembler.rb

@@ -6,16 +6,16 @@ module Lignite
     include Bytes
     include Logger
 
-    SIGNATURE = "LEGO"
+    SIGNATURE = "LEGO".freeze
     def image_header(image_size:, version:, object_count:, global_bytes:)
       SIGNATURE + u32(image_size) + u16(version) + u16(object_count) +
         u32(global_bytes)
     end
 
     # @return [Array<RbfObject>]
-    attr :objects
+    attr_reader :objects
     # @return [Variables]
-    attr :globals
+    attr_reader :globals
 
     # Assemble a complete RBF program file.
     # (it is OK to reuse an Assembler and call this several times in a sequence)
@@ -30,7 +30,7 @@ module Lignite
       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)
+        dummy_header = image_header(image_size: 0, version: 0, object_count: 0, global_bytes: 0)
         f.write(dummy_header)
         @objects.each do |obj|
           h = obj.header(f.tell)
@@ -40,8 +40,8 @@ module Lignite
         end
         size = f.tell
         f.pos = 0
-        header = image_header(image_size: size,
-                              version: version,
+        header = image_header(image_size:   size,
+                              version:      version,
                               object_count: @objects.size,
                               global_bytes: @globals.bytesize)
         f.write(header)

data/lib/lignite/body_compiler.rb

@@ -51,5 +51,9 @@ module Lignite
 
       @bytes += @op_compiler.send(name, *args)
     end
+
+    def respond_to_missing?(name, _include_private)
+      @op_compiler.respond_to?(name) || super
+    end
   end
 end

data/lib/lignite/connection.rb

@@ -1,13 +1,71 @@
 module Lignite
   class Connection
+    include Bytes
+    include Logger
+
     # @return [Connection] Try a {Usb} connection first, then a {Bluetooth} one.
     def self.create
+      @c ||= Replay.new(ENV["LIGNITE_REPLAY"]) if ENV["LIGNITE_REPLAY"]
+
       @c ||= begin
                Usb.new
              rescue NoUsbDevice
                Bluetooth.new
              end
+
+      @c = Tap.new(@c, ENV["LIGNITE_TAP"]) if ENV["LIGNITE_TAP"]
+      @c
+    end
+
+    def self.reset
+      @c = nil
+    end
+
+    def initialize
+      @buf = ""
+    end
+
+    def close
+      Connection.reset
+    end
+
+    # @param payload [ByteString]
+    def send(payload)
+      packet = u16(payload.bytesize) + payload
+      logger.debug "-> #{packet.inspect}"
+
+      write(packet)
+    end
+
+    # @return [ByteString] a complete message
+    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
+
+    # @!group Subclasses must implement
+    # @!method read(maxlen)
+    # @!method write(data)
+    # @!method close
+
+    private
+
+    # read must not be called with a too low value :-/
+    def bufread(n)
+      @buf += read(10000) while @buf.bytesize < n
+      ret = @buf[0, n]
+      @buf = @buf[n..-1]
+      logger.debug "R<-(#{ret.bytesize})#{ret.inspect}"
+      ret
     end
-    # FIXME: how to close and reopen a connection?
   end
 end

data/lib/lignite/connection/bluetooth.rb

@@ -8,6 +8,7 @@ module Lignite
 
       # @param address [String] "11:22:33:44:55:66"
       def initialize(address = address_from_file)
+        super()
         @sock = Socket.new(AF_BLUETOOTH, :STREAM, BTPROTO_RFCOMM)
         addr_b = address.split(/:/).map { |x| x.to_i(16) }
         channel = 1
@@ -24,7 +25,7 @@ module Lignite
       end
 
       def self.config_filename
-        "#{ENV['HOME']}/.config/lignite-btaddr"
+        "#{ENV["HOME"]}/.config/lignite-btaddr"
       end
 
       def self.template_config_filename
@@ -44,6 +45,11 @@ module Lignite
       def write(s)
         @sock.write(s)
       end
+
+      def close
+        @sock.shutdown
+        super
+      end
     end
   end
 end

data/lib/lignite/connection/replay.rb

@@ -0,0 +1,57 @@
+require "yaml"
+
+module Lignite
+  class Connection
+    class ReplayError < RuntimeError
+    end
+
+    # Replays a recorded communication.
+    # It checks that #send matches the stored sends, replays the #receive.
+    class Replay < Connection
+      def initialize(filename)
+        @filename = filename
+
+        # [
+        #  {"SEND" => "foo"},
+        #  {"SEND" => "foo2"},
+        #  {"RECV" => "adfafd"},
+        #  {"SEND" => "foo2"},
+        #  {"RECV" => "adfafd"}
+        # ]
+        @stream = YAML.load_file(filename)
+      end
+
+      # @param payload [ByteString]
+      def send(payload)
+        recorded = @stream.shift
+        raise ReplayError, "Nothing left in the recording" if recorded.nil?
+        hex = recorded["SEND"]
+        raise ReplayError, "Called SEND but the recording says RECV" if hex.nil?
+        data = hex_to_bin(hex)
+        raise ReplayError, "Called SEND but the recorded data does not match" if data != payload
+      end
+
+      # @return [ByteString] a complete message
+      def receive
+        recorded = @stream.shift
+        raise ReplayError, "Nothing left in the recording" if recorded.nil?
+        hex = recorded["RECV"]
+        raise ReplayError, "Called RECV but the recording says SEND" if hex.nil?
+        hex_to_bin(hex)
+      end
+
+      def close
+        super
+        raise ReplayError, "Called close but the recording has leftover data" unless @stream.empty?
+      end
+
+      private
+
+      # @param hex [String] "413432"
+      # @return [ByteString] "A42"
+      def hex_to_bin(hex)
+        [hex].pack("H*")
+      end
+    end
+  end
+end

data/lib/lignite/connection/tap.rb

@@ -0,0 +1,45 @@
+require "yaml"
+
+module Lignite
+  class Connection
+    # An adapter that delegates to another connection
+    # and records the communication
+    class Tap < Connection
+      def initialize(conn, filename)
+        raise "File #{filename} exists, will not overwrite" if File.exist?(filename)
+        @conn = conn
+        @filename = filename
+        @packets = []
+      end
+
+      # @param payload [ByteString]
+      def send(payload)
+        r = @conn.send(payload)
+        @packets << { "SEND" => bin_to_hex(payload) }
+        r
+      end
+
+      # @return [ByteString] a complete message
+      def receive
+        s = @conn.receive
+        @packets << { "RECV" => bin_to_hex(s) }
+        s
+      end
+
+      def close
+        y = YAML.dump(@packets)
+        File.write(@filename, y)
+        super
+        @conn.close
+      end
+
+      private
+
+      # @param bin [ByteString] "A42"
+      # @return [String] "413432"
+      def bin_to_hex(bin)
+        bin.unpack("H*").first
+      end
+    end
+  end
+end

data/lib/lignite/connection/usb.rb

@@ -25,6 +25,7 @@ module Lignite
       attr_reader :device, :interface, :out_ep, :in_ep
 
       def initialize
+        super
         usb = LIBUSB::Context.new
         @device = usb.devices(idVendor: VENDOR_LEGO, idProduct: PRODUCT_EV3).first
         raise Lignite::NoUsbDevice if @device.nil?
@@ -33,8 +34,8 @@ module Lignite
         ## 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}
+        @out_ep = eps.find { |e| e.direction == :out }
+        @in_ep = eps.find { |e| e.direction == :in }
       end
 
       # @return [Integer] number of bytes written
@@ -58,17 +59,19 @@ module Lignite
             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
+              got = e.transferred
+              raise unless got.is_a? String
             end
           end
         end
         logger.debug "Read returning #{got.bytesize} bytes"
         got
       end
+
+      def close
+        super
+        # do nothing: read and write open and close the handle each time
+      end
     end
   end
 end

data/lib/lignite/direct_commands.rb

@@ -1,12 +1,24 @@
 module Lignite
   class DirectCommands
+    include Bytes
+
+    def self.run(conn = Connection.create, &block)
+      dc = new(conn)
+      dc.instance_exec(&block)
+      dc.close
+    end
+
     # @param conn [Connection]
     def initialize(conn = Connection.create)
       @op_compiler = OpCompiler.new
-      @sender = MessageSender.new(conn)
+      @conn = conn
       @globals = nil
     end
 
+    def close
+      @conn.close
+    end
+
     def variables
       @globals
     end
@@ -17,7 +29,7 @@ module Lignite
       ret_bytes = instance_exec(&body)
       ret = @globals.unpack(ret_bytes)
       @globals = nil
-      ret # TODO decode according to type
+      ret # TODO: decode according to type
     end
 
     def block(&body)
@@ -28,19 +40,58 @@ module Lignite
       bs = bodyc.bytes
       lsize = locals.bytesize
       if @globals
-        @sender.direct_command_with_reply(bs, global_size: @globals.bytesize, local_size: lsize)
+        direct_command_with_reply(bs, global_size: @globals.bytesize, local_size: lsize)
       else
-        @sender.direct_command(bs, global_size: 0, local_size: lsize)
+        direct_command(bs, global_size: 0, local_size: lsize)
       end
     end
 
     def method_missing(name, *args)
       if @op_compiler.respond_to?(name)
         insb = @op_compiler.send(name, *args)
-        @sender.direct_command(insb)
+        direct_command(insb)
       else
         super
       end
     end
+
+    def respond_to_missing?(name, _include_private)
+      @op_compiler.respond_to?(name) || super
+    end
+
+    private
+
+    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)
+      @conn.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)
+      @conn.send(cmd.bytes)
+
+      reply = Message.reply_from_bytes(@conn.receive)
+      assert_match(reply.msgid, cmd.msgid, "Reply id")
+      if reply.error?
+        raise VMError # no details?
+      end
+
+      reply.globals
+    end
+
+    def var_alloc(global_size:, local_size:)
+      var_alloc = global_size & 0x3ff
+      var_alloc |= (local_size & 0x3f) << 10
+      var_alloc
+    end
+
+    def assert_match(actual, expected, description)
+      return if actual == expected
+      raise "#{description} does not match, expected #{expected}, actual #{actual}"
+    end
   end
 end

data/lib/lignite/message.rb

@@ -1,17 +1,20 @@
 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}
+  #   this is added by {Connection#send}
+  #   and stripped by {Connection#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.reset_msgid
+      @msg_counter = 0
+    end
+    reset_msgid
 
     def self.msgid
       @msg_counter += 1
@@ -63,7 +66,7 @@ module Lignite
       when 0x04               # DIRECT_REPLY_ERROR
         DirectReply.new(msgid: msgid, error: true, body: body)
       else
-        raise "Unexpected reply type %x" % type
+        raise format("Unexpected reply type %x", type)
       end
     end
   end