farmbot-serial 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 968bffc9904f9b3d733c91107ec83caeb632353a
-  data.tar.gz: 0eb0a17a2e6923e3e0ef2ec8228c5ebf2d99cd09
+  metadata.gz: 52d9fa1d6b06912cce708e6ef54f9b07035678d1
+  data.tar.gz: 665482bd2b934eea96f01a820b886f07df5c3170
 SHA512:
-  metadata.gz: fd10320b1219e6001c2e5bb73ffc3cada2e4bd5e9efcaa35ba72476a2667c8969cf3b18eb3c493937c57c37605b5855b52606fd4c38bed5b2395eae0a68a7cd4
-  data.tar.gz: fe5fc6bead0a8fb4d39ab7a1235f3436f3730b2505d2b01e94f9792258136b6ba8bd29b5a884e1c2d09938eefc2de34a286c1a86b7f37b1e58ffe82771c40387
+  metadata.gz: 75aefd6382c999e9af8d5417cfbb540122c2bcbe3808c522bef641731ba586ec9fbb4452a1cc42f1356a765b219318f37c8208fc5c31c74581b05070dcd08f73
+  data.tar.gz: 09c86b75932a49c9dbd486e15b906a3ce7982dd243bfcee092584014c6910e3fd8e59fcca3d1f1cac88fda5c8f128f615d0d6fe2d9f581f4c95e7682d774f590

data/README.md

@@ -9,22 +9,38 @@ gem install farmbot-serial, '0.0.5'
 ```
 
 ```ruby
+require 'farmbot-serial'
+
 bot = FB::Arduino.new # Defaults to '/dev/ttyACM0', can be configured.
 
 EM.run do
   FB::ArduinoEventMachine.connect(bot)
 
   # Example 1: Writing to the serial line the "correct way" every 1.5 seconds.
-  command = FB::Gcode.new('G01 X01 Y01 Z01')
-  EventMachine::PeriodicTimer.new(1.5) { bot.commands.move_relative(command) }
+  EventMachine::PeriodicTimer.new(1.5) do
+    bot.commands.move_relative(x: 100, y: 50)
+  end
 
-  # Example 2: Writing raw strings to serial every 2.5
-  EventMachine::PeriodicTimer.new(2.5) { bot.write("F31 P8") }
+  # Example 2: Writing raw gcode object to serial every 2.5
+  EventMachine::PeriodicTimer.new(2.5) { bot.write FB::Gcode.new("F31 P8") }
 
   # This will execute after status has been updated / internal code.
-  bot.onmessage { |gcode| puts "SERIAL  IN: #{gcode.name}" }
+  bot.onmessage { |gcode| puts "Message just came in." }
 
   # Try pulling the USB cable out to test this one.
-  bot.onclose { EM.stop }
+  bot.onclose { puts "bye!"; EM.stop }
 end
+
 ```
+
+# Upgrading to Ruby 2.2
+
+This gem requires Ruby 2.2. As of this writing, a Pi is loaded with 1.9.3 by default.
+
+To upgrade your ruby version, try this:
+
+```
+ curl -L https://get.rvm.io | bash -s stable --ruby
+```
+
+This will take about 2 hours on a standard pi.

data/Rakefile

@@ -1,9 +1,9 @@
-require 'rake/testtask'
+# require 'rake/testtask'
 
-Rake::TestTask.new do |t|
-  t.libs << 'test'
-  t.test_files = Dir.glob('test/**/*_test.rb')
-end
+# Rake::TestTask.new do |t|
+#   t.libs << 'test'
+#   t.test_files = Dir.glob('test/**/*_test.rb')
+# end
 
-desc "Run tests"
-task :default => :test
+# desc "Run tests"
+# task :default => :test

data/example.rb

@@ -3,19 +3,47 @@ require 'pry'
 
 bot = FB::Arduino.new # Defaults to '/dev/ttyACM0', can be configured.
 
-EM.run do
-  FB::ArduinoEventMachine.connect(bot)
+puts """
+FARMBOT SERIAL SANDBOX. WELCOME!
+================================"""
+$commands = {
+  "q" => "bot.commands.emergency_stop",
+  "w" => "bot.commands.move_relative(x: 600)",
+  "s" => "bot.commands.move_relative(x: -600)",
+  "e" => "bot.commands.home_x",
+  "r" => "bot.commands.home_y",
+  "t" => "bot.commands.home_z",
+  "y" => "bot.commands.home_all",
+  "u" => "bot.commands.read_parameter(8)",
+  "i" => "bot.commands.write_parameter",
+  "p" => "bot.commands.read_status(8)",
+}
+
+$commands.each { |k, v| puts "#{k}: #{v}" }
 
-  # Example 1: Writing to the serial line the "correct way" every 1.5 seconds.
-  command = FB::Gcode.new('G01 X01 Y01 Z01')
-  EventMachine::PeriodicTimer.new(1.5) { bot.commands.move_relative(command) }
+class KeyboardHandler < EM::Connection
+  include EM::Protocols::LineText2
 
-  # Example 2: Writing raw strings to serial every 2.5
-  EventMachine::PeriodicTimer.new(2.5) { bot.write("F31 P8") }
+  attr_reader :bot
 
-  # This will execute after status has been updated / internal code.
-  bot.onmessage { |gcode| puts "SERIAL  IN: #{gcode.name}" }
+  def initialize(bot)
+    @bot = bot
+  end
 
-  # Try pulling the USB cable out to test this one.
-  bot.onclose { EM.stop }
+  def receive_line(data)
+    cmd = $commands[data] || ""
+    eval(cmd)
+  end
 end
+
+puts "Starting now."
+
+EM.run do
+  FB::ArduinoEventMachine.connect(bot)
+  bot.onmessage { |gcode| print "#{gcode.name}; " }
+  bot.onchange { |diff| print "#{diff}; " }
+  bot.onclose { puts "bye!"; EM.stop } # Unplug the bot and see
+  # EventMachine::PeriodicTimer.new(2) { bot.serial_port.puts "G82" }
+  EM.open_keyboard(KeyboardHandler, bot)
+end
+

data/lib/arduino.rb

@@ -1,6 +1,7 @@
 require 'serialport'
 require_relative 'default_serial_port'
-require_relative 'arduino/command_set'
+require_relative 'arduino/incoming_handler'
+require_relative 'arduino/outgoing_handler'
 require_relative 'arduino/event_machine'
 require_relative 'arduino/status'
 # Communicate with the arduino using a serial interface
@@ -8,14 +9,23 @@ module FB
   class Arduino
     class EmergencyStop < StandardError; end # Not yet used.
 
-    attr_reader :serial_port, :logger, :commands, :queue, :status
+    attr_reader :serial_port, :logger, :commands, :inbound_queue, :status,
+      :inputs, :outbound_queue
 
-    # Initial and provide a serial object, as well as an IO object to send
+    # Initialize and provide a serial object, as well as an IO object to send
     # log messages to. Default SerialPort is DefaultSerialPort. Default logger
     # is STDOUT
-    def initialize(serial_port = DefaultSerialPort.new, logger = STDOUT)
-      @serial_port, @logger, @queue = serial_port, logger, EM::Channel.new
-      @commands, @status = FB::ArduinoCommandSet.new(self), FB::Status.new(self)
+    def initialize(serial_port: DefaultSerialPort.new, logger: STDOUT)
+      @outbound_queue = [] # Pi -> Arduino Gcode
+      @inbound_queue  = EM::Channel.new # Pi <- Arduino
+
+      @serial_port = serial_port
+      @logger      = logger
+      @commands    = FB::OutgoingHandler.new(self)
+      @inputs      = FB::IncomingHandler.new(self)
+      @status      = FB::Status.new(self)
+
+      start_event_listeners
     end
 
     # Log to screen/file/IO stream
@@ -23,36 +33,62 @@ module FB
       logger.puts(message)
     end
 
-    # Highest priority message when processing incoming Gcode. Use for system
-    # level status changes.
-    def parse_incoming(gcode)
-      commands.execute(gcode)
+    # Send outgoing test to arduino from pi
+    def write(string)
+      @outbound_queue.unshift string
+      execute_command_next_tick
+    end
+
+    def onchange(&blk)
+      @onchange = blk
     end
 
     # Handle incoming text from arduino into pi
     def onmessage(&blk)
-      raise 'read() requires a block' unless block_given?
-      @queue.subscribe do |gcodes|
-        gcodes.each do |gcode|
-          parse_incoming(gcode)
-          blk.call(gcode)
-        end
-      end
+      @onmessage = blk
     end
 
     def onclose(&blk)
       @onclose = blk
     end
 
-    # Send outgoing test to arduino from pi
-    def write(string)
-      serial_port.puts string
-    end
-
     # Handle loss of serial connection
     def disconnect
       log "Connection to device lost"
       @onclose.call if @onclose
     end
+
+    private
+
+    # Highest priority message when processing incoming Gcode. Use for system
+    # level status changes.
+    def parse_incoming(gcode)
+      inputs.execute(gcode)
+    end
+
+    def execute_command_next_tick
+      EM.next_tick do
+        if status.ready?
+          diff = (Time.now - (@time || Time.now)).to_i
+          log "Sending queue after #{diff}s delay" if diff > 0
+          serial_port.puts @outbound_queue.pop
+          @time = nil
+        else
+          @time ||= Time.now
+          serial_port.puts "F31 P8"
+          execute_command_next_tick
+        end
+      end
+    end
+
+    def start_event_listeners
+      status.onchange { |diff| @onchange.call(diff) if @onchange }
+      inbound_queue.subscribe do |gcodes|
+        gcodes.each do |gcode|
+          parse_incoming(gcode)
+          @onmessage.call(gcode) if @onmessage
+        end
+      end
+    end
   end
 end

data/lib/arduino/event_machine.rb

@@ -7,12 +7,9 @@ module FB
       attr_accessor :arduino
     end
 
-    def self.poll(interval, &blk)
-      EventMachine::PeriodicTimer.new(interval.to_f, &blk)
-    end
-
     def initialize
-      @q, @buffer = self.class.arduino.queue, ''
+      @bot = self.class.arduino
+      @q, @buffer = @bot.inbound_queue, ''
     end
 
     # Gets called when data arrives.
@@ -23,7 +20,7 @@ module FB
           send_buffer
           clear_buffer
         else
-          add_to_buffer(chunk)
+          add_to_buffer(chunk) # Keep RXing the buffer until chunk completes.
         end
       end
     end
@@ -32,7 +29,7 @@ module FB
     # splits the data on \r\n. Unlike Ruby's split() method, this method will
     # preserve the \r\n.
     def split_into_chunks(data)
-      data.gsub("\r\n", '!@').split('@').map{ |d| d.gsub('!', "\r\n") }
+      data.gsub("\r\n", '\b\a').split('\a').map{ |d| d.gsub('\b', "\r\n") }
     end
 
     def clear_buffer

data/lib/arduino/incoming_handler.rb

@@ -0,0 +1,50 @@
+module FB
+  # Handles Gcode that moves from the Arduino to the Pi (Arduino -> Pi).
+  class IncomingHandler
+    attr_reader :bot
+
+    class UnhandledGcode < StandardError; end
+
+    def initialize(bot)
+      @bot = bot
+    end
+
+    def execute(gcode)
+      self.send(gcode.name, gcode)
+    rescue NoMethodError
+      bot.log "#{gcode.name} is a valid GCode, but no input handler method exists"
+    end
+
+    def unknown(gcode)
+      bot.log "Don't know how to parse incoming GCode: #{gcode}"
+    end
+
+    def received(gcode)
+      bot.status[:busy] = 1
+    end
+
+    def reporting_end_stops(gcode)
+      bot.status.gcode_update(gcode)
+    end
+
+    def report_current_position(gcode)
+      bot.status.gcode_update(gcode)
+    end
+
+    def done(gcode)
+      bot.status[:busy] = 0
+    end
+
+    def busy(gcode)
+      bot.status[:busy] = 1
+    end
+
+    def report_status_value(gcode)
+      bot.status.gcode_update(gcode)
+    end
+
+    def report_software_version(gcode)
+      nil # Don't need the info right now.
+    end
+  end
+end

data/lib/arduino/outgoing_handler.rb

@@ -0,0 +1,57 @@
+module FB
+  # Responsible for writing to the serial line. Sends Gcode from the pi to the
+  # arduino. (Pi -> Arduino)
+  class OutgoingHandler
+    attr_reader :bot
+
+    class UnhandledGcode < StandardError; end
+
+    def initialize(bot)
+      @bot = bot
+    end
+
+    def emergency_stop(*)
+      bot.outbound_queue = []  # Dump pending commands.
+      bot.serial_port.puts "E" # Don't queue this one- write to serial line.
+    end
+
+    def move_relative(x: 0, y: 0, z: 0, s: 100)
+      write "G00 X#{x} Y#{y} Z#{z}"
+    end
+
+    def home_x
+      write "F11"
+    end
+
+    def home_y
+      write "F12"
+    end
+
+    def home_z
+      write "F13"
+    end
+
+    def home_all
+      write "G28"
+    end
+
+    def read_parameter(num)
+      write "F21 P#{num}"
+    end
+
+    def write_parameter(num, val)
+      write "F22 P#{num} V#{val}"
+    end
+
+    def read_status(pin)
+      write "F31 P#{pin}"
+    end
+
+  private
+
+    def write(str)
+      bot.write(FB::Gcode.new(str))
+    end
+  end
+end
+

data/lib/arduino/status.rb

@@ -3,23 +3,48 @@ module FB
     # Map of informational status and default values for status within Arduino.
     DEFAULT_INFO = {X: 0, Y: 0, Z: 0, S: 10, Q: 0,  T: 0,  C: '', P: 0,  V: 0,
                     W: 0, L: 0, E: 0, M: 0, XA: 0, XB: 0, YA: 0, YB: 0, ZA: 0,
-                   ZB: 0, busy: 1}
-    # Put it into a struct.
+                   ZB: 0,YR: 0, R: 0, BUSY: 0}
     Info = Struct.new(*DEFAULT_INFO.keys)
 
     attr_reader :bot
 
     def initialize(bot)
+      @changes = EM::Channel.new
       @bot, @info = bot, Info.new(*DEFAULT_INFO.values)
     end
 
+    def transaction(&blk)
+      old = @info.to_h
+      yield
+      emit_updates(old)
+    end
+
     def []=(register, value)
-      # Add event broadcasts here!!!
-      @info[value.upcase.to_sym] = value
+      transaction { @info[register.upcase.to_sym] = value }
     end
 
     def [](value)
       @info[value.upcase.to_sym]
     end
+
+    def gcode_update(gcode)
+      transaction do
+        gcode.params.each { |p| @info.send("#{p.head}=", p.tail) }
+      end
+    end
+
+    def onchange
+      @changes.subscribe { |diff| yield(diff) }
+    end
+
+    def ready?
+      self[:BUSY] == 0
+    end
+
+    def emit_updates(old)
+      # calculate a diff between the old status and new status
+      diff = (@info.to_h.to_a - old.to_a).to_h
+      @changes << diff unless diff.empty?
+    end
   end
 end

data/lib/gcode.rb

@@ -8,7 +8,7 @@ module FB
     def initialize(str)
       @str = str
       @params = str.split(' ').map{|line| GcodeToken.new(line)}
-      @cmd = @params.shift
+      @cmd = @params.shift || 'NULL'
     end
 
     # Turns a string of many gcodes into an array of many gcodes. Used to parse
@@ -22,6 +22,10 @@ module FB
       GCODE_DICTIONARY[cmd.to_sym] || :unknown
     end
 
+    def to_s
+      [@cmd, *@params].map(&:to_s).join(" ")
+    end
+
     # A head/tail pair of a single node of GCode. Ex: R01 = [:R, '01']
     class GcodeToken
       attr_reader :head, :tail, :name
@@ -29,10 +33,16 @@ module FB
       def initialize(str)
         nodes = str.scan(/\d+|\D+/) # ["R", "01"]
         @head, @tail = nodes.shift.to_sym, nodes.join(" ")
+        # Coerce to ints if possible, since serial line is all string types.
+        @tail = @tail.to_i if @tail.match(/^\d+$/)
       end
 
       def to_sym
-        "#{head}#{tail}".to_sym
+        to_s.to_sym
+      end
+
+      def to_s
+        "#{head}#{tail}"
       end
     end
   end

data/lib/gcode.yml

@@ -26,10 +26,10 @@
 :F82: :report_current_position
 :F83: :report_software_version
 :E:   :emergency_stop
-:R01: :received
-:R02: :done
-:R03: :error
-:R04: :busy
+:R1: :received
+:R2: :done
+:R3: :error
+:R4: :busy
 :R21: :report_parameter_value
 :R31: :report_status_value
 :R41: :report_pin_value

data/spec/fixtures/stub_serial_port.rb

@@ -1,17 +1,6 @@
 ## SERIAL PORT SIMULATION
 ## **********************
-module FB
-  # Used for unit tests
-  class StubSerialPort # TODO: Inherit from StringIO?
-    def initialize(comm_port, parameters)
-    end
-
-    def write(text)
-      text
-    end
-
-    def read(characters)
-      characters
-    end
+class StubSerialPort < StringIO
+  def initialize(comm_port, parameters)
   end
 end

data/spec/lib/arduino_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe FB::Arduino do
+  let(:logger) { StringIO.new("") }
+  let(:bot) do
+    FB::Arduino.new(StubSerialPort.new(0, 0), logger)
+  end
+
+  it "initializes" do
+    expect(bot).to be_kind_of(FB::Arduino)
+    expect(bot.serial_port).to be_kind_of(StubSerialPort)
+    expect(bot.logger).to be_kind_of(StringIO)
+    expect(bot.commands).to be_kind_of(FB::OutgoingHandler)
+    expect(bot.queue).to be_kind_of(EM::Channel)
+    expect(bot.status).to be_kind_of(FB::Status)
+    expect(bot.inputs).to be_kind_of(FB::IncomingHandler)
+  end
+
+  it 'prints to the logger object' do
+    bot.log "Hello, World!"
+    bot.logger.rewind
+    expect(bot.logger.gets.chomp).to eq("Hello, World!")
+  end
+
+end
+

data/spec/lib/gcode_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+describe FB::Gcode do
+  let(:gcode) { FB::Gcode.new("F31 P8 ")}
+
+  it("initializes from string") { expect(gcode).to be_kind_of(FB::Gcode) }
+
+  it("infers Gcode name") { expect(gcode.name).to eq(:read_status) }
+
+  it "returns :unknown for bad Gcode tokens" do
+    unknown = FB::Gcode.new("QQQ31 F32 ").name
+    expect(unknown).to eq(:unknown)
+  end
+
+  it("sets the original input string") { expect(gcode.str).to eq("F31 P8 ") }
+
+  it("sets @cmd using the first Gcode node") do
+    expect(gcode.cmd).to be_kind_of(FB::Gcode::GcodeToken)
+    expect(gcode.cmd.head).to eq(:F)
+    expect(gcode.cmd.tail).to eq(31)
+  end
+
+  it("sets @params using the last Gcode node(s)") do
+    expect(gcode.params).to be_kind_of(Array)
+    expect(gcode.params[0]).to be_kind_of(FB::Gcode::GcodeToken)
+    expect(gcode.params[0].head).to eq(:P)
+    expect(gcode.params[0].tail).to eq(8)
+  end
+
+  it("serializes back to string via #to_s") do
+    expect(gcode.to_s).to eq("F31 P8")
+  end
+
+  it "parses multiple Gcodes in a single string via parse_lines" do
+    codes = FB::Gcode.parse_lines("A12 B34\nC56 D78\r\n")
+    expect(codes.count).to eq(2)
+    expect(codes.first).to be_kind_of(FB::Gcode)
+    expect(codes.last.cmd.head).to eq(:C)
+    expect(codes.first.params.first.tail).to eq(34)
+  end
+end
+

data/spec/spec_helper.rb

@@ -5,13 +5,6 @@ SimpleCov.start do
 end
 require 'pry'
 require 'farmbot-serial'
-
+require_relative 'fixtures/stub_serial_port'
 RSpec.configure do |config|
-  config.expect_with :rspec do |expectations|
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = true
-  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: farmbot-serial
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Tim Evers
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-27 00:00:00.000000000 Z
+date: 2015-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -122,18 +122,18 @@ files:
 - Rakefile
 - example.rb
 - lib/arduino.rb
-- lib/arduino/command_set.rb
 - lib/arduino/event_machine.rb
+- lib/arduino/incoming_handler.rb
+- lib/arduino/outgoing_handler.rb
 - lib/arduino/status.rb
 - lib/default_serial_port.rb
 - lib/farmbot-serial.rb
 - lib/gcode.rb
 - lib/gcode.yml
-- lib/param.yml
 - spec/fixtures/stub_serial_port.rb
-- spec/lib/ramps_arduino_values_received_spec.rb
+- spec/lib/arduino_spec.rb
+- spec/lib/gcode_spec.rb
 - spec/spec_helper.rb
-- testcommands.csv
 homepage: http://github.com/farmbot/farmbot-serial
 licenses:
 - MIT
@@ -146,7 +146,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -160,5 +160,6 @@ specification_version: 4
 summary: Serial library for Farmbot
 test_files:
 - spec/fixtures/stub_serial_port.rb
-- spec/lib/ramps_arduino_values_received_spec.rb
+- spec/lib/arduino_spec.rb
+- spec/lib/gcode_spec.rb
 - spec/spec_helper.rb

data/lib/arduino/command_set.rb

@@ -1,39 +0,0 @@
-module FB
-  # Composes all logic related to controlling a bot into a single object.
-  # Responsible for writing to the serial line.
-  class ArduinoCommandSet
-    attr_reader :bot
-
-    def initialize(bot)
-      @bot = bot
-    end
-
-    def execute(gcode)
-      puts "SERIAL OUT: #{gcode.name}"
-      self.send(gcode.name, gcode)
-    end
-
-    def emergency_stop(*)
-      bot.write("E")
-    end
-
-    def move_relative(gcode)
-    end
-
-    def received(gcode)
-    end
-
-    def reporting_end_stops(gcode)
-    end
-
-    def report_current_position(gcode)
-    end
-
-    def done(gcode)
-    end
-
-    def report_status_value(gcode)
-    end
-  end
-end
-

data/lib/param.yml

@@ -1,21 +0,0 @@
-# ---
-# X: :x_movement
-# Y: :y_movement
-# Z: :z_movement
-# S: :speed
-# Q: :quanity
-# T: :time
-# C: :comment
-# P: :parameter
-# V: :value_number
-# W: :secondary_value
-# L: :number
-# E: :element
-# M: :pin_mode
-# M: :read_write_mode
-# XA: :end_stop_1_x_axis
-# XB: :end_stop_2_x_axis
-# YA: :end_stop_1_y_axis
-# YB: :end_stop_2_y_axis
-# ZA: :end_stop_1_z_axis
-# ZB: :end_stop_2_z_axis

data/spec/lib/ramps_arduino_values_received_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-describe FB::HardwareInterfaceArduinoValuesReceived do
-
-  before do
-    @ramps = FB::HardwareInterfaceArduinoValuesReceived.new
-  end
-
-  it "load parameters" do
-
-    p  = rand(9999999).to_i
-    v  = rand(9999999).to_i
-
-    x  = rand(9999999).to_i
-    y  = rand(9999999).to_i
-    z  = rand(9999999).to_i
-
-    xa = rand(9999999).to_i
-    xb = rand(9999999).to_i
-    ya = rand(9999999).to_i
-    yb = rand(9999999).to_i
-    za = rand(9999999).to_i
-    zb = rand(9999999).to_i
-
-    @ramps.load_parameter("P", p)
-    @ramps.load_parameter("V", v)
-    @ramps.load_parameter("X", x)
-    @ramps.load_parameter("Y", y)
-    @ramps.load_parameter("Z", z)
-
-    @ramps.load_parameter("XA", xa)
-    @ramps.load_parameter("XB", xb)
-    @ramps.load_parameter("YA", ya)
-    @ramps.load_parameter("YB", yb)
-    @ramps.load_parameter("ZA", za)
-    @ramps.load_parameter("ZB", zb)
-
-    expect(@ramps.p).to eq(p)
-    expect(@ramps.v).to eq(v)
-
-    expect(@ramps.x).to eq(x)
-    expect(@ramps.y).to eq(y)
-    expect(@ramps.z).to eq(z)
-
-    expect(@ramps.xa).to eq(xa)
-    expect(@ramps.xb).to eq(xb)
-    expect(@ramps.ya).to eq(ya)
-    expect(@ramps.yb).to eq(yb)
-    expect(@ramps.za).to eq(za)
-    expect(@ramps.zb).to eq(zb)
-
-  end
-
-end
-

data/testcommands.csv

@@ -1,25 +0,0 @@
-HOME Y,0,0,0
-HOME X,0,0,0
-MOVE ABSOLUTE,  0, 30,  0,  0
-
-MOVE ABSOLUTE, 30, 30,  0,  0
-DOSE WATER,     0,  0,  0,  5
-MOVE ABSOLUTE, 60, 30,  0,  0
-DOSE WATER,     0,  0,  0,  5
-MOVE ABSOLUTE, 90, 30,  0,  0
-DOSE WATER,     0,  0,  0,  5
-MOVE ABSOLUTE,120, 30,  0,  0
-DOSE WATER,     0,  0,  0,  5
-
-MOVE ABSOLUTE,120, 60,  0,  0
-DOSE WATER,     0,  0,  0,  5
-MOVE ABSOLUTE, 90, 60,  0,  0
-DOSE WATER,     0,  0,  0,  5
-MOVE ABSOLUTE, 60, 60,  0,  0
-DOSE WATER,     0,  0,  0,  5
-MOVE ABSOLUTE, 30, 60,  0,  0
-DOSE WATER,     0,  0,  0,  5
-
-
-HOME Y,0,0,0
-HOME X,0,0,0