farmbot-serial 0.0.1

data/lib/hardware_interface_arduino.rb

@@ -0,0 +1,346 @@
+## HARDWARE INTERFACE
+## ******************
+
+# Communicate with the arduino using a serial interface
+# All information is exchanged using a variation of g-code
+# Parameters are stored in the database
+module Fb
+  class HardwareInterfaceArduino
+
+    attr_accessor :ramps_param, :ramps_main
+    #attr_accessor :test_serial_read, :test_serial_write
+    attr_accessor :serial_port
+    attr_accessor :external_info
+
+    # initialize the interface
+    #
+    def initialize(test_mode)
+      @status_debug_msg = $debug_msg
+
+      @test_mode         = test_mode
+
+      # connect to arduino
+      connect_board()
+
+      @external_info         = ""
+
+    end
+
+    ## ARDUINO HANLDING
+    ## ****************
+
+    # connect to the serial port and start communicating with the arduino/firmata protocol
+    #
+    def connect_board
+
+      parameters =
+      {
+        "baud"         => 115200,
+        "data_bits"    => 8,
+        "stop_bits"    => 1,
+        "parity"       => SerialPort::NONE,
+        "flow_control" => SerialPort::SOFT
+      }
+
+      comm_port = '/dev/ttyACM0'
+      @serial_port = SerialPort.new(comm_port, parameters) if @test_mode == false
+      @serial_port = SerialPortSim.new(comm_port, parameters) if @test_mode == true
+
+    end
+
+    # write a command to the robot
+    #
+    def execute_command(text, log, onscreen)
+      begin
+
+        write_status = create_write_status(text, log, onscreen)
+
+  #puts @serial_port.test_serial_read
+        prepare_serial_port(write_status)
+  #puts @serial_port.test_serial_read
+
+        # wait until the arduino responds
+        while(write_status.is_busy())
+
+          check_emergency_stop
+          process_feedback(write_status)
+
+        end
+
+        log_result_of_execution(write_status)
+
+      rescue => e
+  #puts 'exception received'
+  #puts e
+        handle_execution_exception(e)
+      end
+    end
+
+    def create_write_status(text, log, onscreen)
+      write_status = Fb::HardwareInterfaceArduinoWriteStatus.new
+      write_status.text     = text
+      write_status.log      = log
+
+      write_status.onscreen = onscreen
+      write_status
+    end
+
+    def handle_execution_exception(e)
+      puts("ST: serial error\n#{e.message}\n#{e.backtrace.inspect}")
+      @serial_port.rts = 1
+      connect_board
+      sleep 5 if @test_mode == false
+    end
+
+    def log_result_of_execution(write_status)
+
+      # log things if needed
+      if write_status.done == 1
+        puts 'ST: done' if write_status.onscreen
+      else
+        puts 'ST: timeout'
+        sleep 5 if @test_mode == false
+      end
+    end
+
+    # receive all characters coming from the serial port
+    #
+    def process_feedback(write_status)
+      i = @serial_port.read(1)
+
+  #print "-#{i}"
+  #print "#{i}"
+
+      if i != nil
+        i.each_char do |c|
+
+          add_and_process_characters(write_status, c)
+
+        end
+      else
+        sleep 0.001 if @test_mode == false
+        #write_status.done = 1 if @test_mode == true
+      end
+    end
+
+    # keep incoming characters in a buffer until it is a complete string
+    #
+    def add_and_process_characters(write_status, c)
+
+      if c == "\r" or c == "\n"
+        if write_status.received.length >= 3
+          log_incoming_text(write_status)
+          write_status.split_received
+          process_code_and_params(write_status)
+
+        end
+      else
+        write_status.received = write_status.received + c
+      end
+    end
+
+    # handle the incoming message depending on the first code number
+    #
+    def process_code_and_params(write_status)
+
+      # process the feedback
+      case write_status.code
+
+        # command received by arduino
+        when 'R01'
+          write_status.timeout = 90
+
+        # command is finished
+        when 'R02'
+          write_status.done = 1
+
+        # command is finished with errors
+        when 'R03'
+          write_status.done = 1
+
+        # command is still ongoing
+        when 'R04'
+          write_status.start = Time.now
+          write_status.timeout = 90
+
+        # specific feedback that is processes separately
+        else
+          process_value(write_status.code,write_status.params)
+      end
+
+      write_status.received = ''
+
+    end
+
+    # set the serial port ready to send
+    #
+    def prepare_serial_port(write_status)
+      puts "WR: #{write_status.text}" if write_status.onscreen
+      @serial_port.read_timeout = 2
+      clean_serial_buffer() if @test_mode == false
+      serial_port_write( "#{write_status.text}\n" )
+    end
+
+    # empty the input buffer so no old data is processed
+    #
+    def clean_serial_buffer
+      while (@serial_port.read(1) != nil)
+      end
+    end
+
+    # write something to the serial port
+    def serial_port_write(text)
+      @serial_port.write( text )
+    end
+
+    # if there is an emergency stop, immediately write it to the arduino
+    #
+    def check_emergency_stop
+      if (Fb::HardwareInterface.current.status.emergency_stop)
+       serial_port_write( "E\n" )
+      end
+    end
+
+    # write to log
+    #
+    def log_incoming_text(write_status)
+      puts "RD: #{write_status.received}" if write_status.onscreen
+    end
+
+    # process values received from arduino
+    #
+    def process_value(code,text)
+
+      params = Fb::HardwareInterfaceArduinoValuesReceived.new
+
+      process_value_split(code, params, text)
+
+      # depending on the report code, process the values
+      # this is done by reading parameter names and their values
+      # and respong on it as needed
+
+      process_value_process_param_list(params,code)
+      process_value_process_named_params(params,code)
+      process_value_process_text(code,text)
+
+    end
+
+    def process_value_split(code, params, text)
+
+      # get all separate parameters from the text
+      text.split(' ').each do |param|
+
+        if code == "R81"
+         # this is the only code that uses two letter parameters
+          par_code  = param[0..1].to_s
+          par_value = param[2..-1].to_i
+        else
+          par_code  = param[0..0].to_s
+          par_value = param[1..-1].to_i
+        end
+
+        params.load_parameter(par_code, par_value)
+
+      end
+
+    end
+
+    def process_value_process_param_list(params,code)
+      #if params.p != 0
+        process_value_R21(params,code)
+        process_value_R23(params,code)
+        process_value_R41(params,code)
+      #end
+    end
+
+
+    # Process report parameter value
+    #
+    def process_value_R21(params,code)
+      if code == 'R21'
+        param = @ramps_param.get_param_by_id(params.p)
+        if param != nil
+          param['value_ar'] = params.v
+        end
+      end
+    end
+
+    # Process report parameter value and save to database
+    #
+    def process_value_R23(params,code)
+      if code == 'R23'
+        param = @ramps_param.get_param_by_id(params.p)
+        if param != nil
+          @ramps_param.save_param_value(params.p, :by_id, :from_db, params.v)
+        end
+      end
+    end
+
+    # Process report pin values
+    #
+    def process_value_R41(params,code)
+      raise 'Not implemented.'
+    end
+
+    def process_value_process_named_params(params,code)
+      process_value_R81(params,code)
+      process_value_R82(params,code)
+    end
+
+    # Process report end stops
+    #
+    def process_value_R81(params,code)
+      if code == 'R81'
+        Fb::HardwareInterface.current.status.info_end_stop_x_a = (params.xa == 1)
+        Fb::HardwareInterface.current.status.info_end_stop_x_b = (params.xb == 1)
+        Fb::HardwareInterface.current.status.info_end_stop_y_a = (params.ya == 1)
+        Fb::HardwareInterface.current.status.info_end_stop_y_b = (params.yb == 1)
+        Fb::HardwareInterface.current.status.info_end_stop_z_a = (params.za == 1)
+        Fb::HardwareInterface.current.status.info_end_stop_z_b = (params.zb == 1)
+      end
+    end
+
+    # Process report position
+    def process_value_R82(params,code)
+      if code == 'R82'
+
+        Fb::HardwareInterface.current.status.info_current_x_steps = params.x
+        Fb::HardwareInterface.current.status.info_current_x       = params.x / @ramps_param.axis_x_steps_per_unit
+
+        Fb::HardwareInterface.current.status.info_current_y_steps = params.y
+        Fb::HardwareInterface.current.status.info_current_y       = params.y / @ramps_param.axis_y_steps_per_unit
+
+        Fb::HardwareInterface.current.status.info_current_z_steps = params.z
+        Fb::HardwareInterface.current.status.info_current_z       = params.z / @ramps_param.axis_z_steps_per_unit
+
+      end
+    end
+
+    def process_value_process_text(code,text)
+      process_value_process_R83(code,text)
+      process_value_process_R99(code,text)
+    end
+
+    # Process report software version
+    #
+    def process_value_process_R83(code,text)
+      if code == 'R83'
+          Fb::HardwareInterface.current.status.device_version = text
+      end
+    end
+
+    # Process report of a debug comment
+    #
+    def process_value_process_R99(code,text)
+      if code == 'R99'
+          puts ">#{text}<"
+      end
+    end
+
+    def puts(*)
+      # Too many messages in the test buffer right now. Will delete this later.
+      # just disabling it for now.
+      STDOUT.print('╳')
+    end
+  end
+end

data/lib/hardware_interface_arduino_values_received.rb

@@ -0,0 +1,56 @@
+module Fb
+  class HardwareInterfaceArduinoValuesReceived
+
+    attr_accessor :p , :v
+    attr_accessor :x , :y , :z
+    attr_accessor :xa, :xb
+    attr_accessor :ya, :yb
+    attr_accessor :za, :zb
+
+
+    def initialize
+
+      @p  = -1
+      @v  = 0
+      @x  = 0
+      @y  = 0
+      @z  = 0
+      @xa = 0
+      @xb = 0
+      @ya = 0
+      @yb = 0
+      @za = 0
+      @zb = 0
+
+    end
+
+    def load_parameter(name, value)
+
+      case name
+        when 'P'
+          @p  = value
+        when 'V'
+          @v  = value
+        when 'XA'
+          @xa = value
+        when 'XB'
+          @xb = value
+        when 'YA'
+          @ya = value
+        when 'YB'
+          @yb = value
+        when 'ZA'
+          @za = value
+        when 'ZB'
+          @zb = value
+        when 'X'
+          @x  = value
+        when 'Y'
+          @y  = value
+        when 'Z'
+          @z  = value
+      end
+    end
+
+  end
+end

data/lib/hardware_interface_arduino_write_status.rb

@@ -0,0 +1,30 @@
+module Fb
+  class HardwareInterfaceArduinoWriteStatus
+
+    attr_accessor :done, :code, :received, :start, :log, :onscreen, :text,
+      :params, :timeout
+
+    def initialize
+      @done     = 0
+      @code     = ''
+      @received = ''
+      @text     = ''
+      @params   = ''
+      @log      = false
+      @onscreen = false
+      @start    = Time.now
+      @timeout  = 5
+    end
+
+    def is_busy
+      Time.now - @start < @timeout and @done == 0
+    end
+
+    def split_received
+      # get the parameter and data part
+      @code   = received[0..2].upcase
+      @params = received[3..-1].to_s.upcase.strip
+    end
+
+  end
+end

data/lib/hardware_interface_param.rb

@@ -0,0 +1,218 @@
+## HARDWARE INTERFACE
+## ******************
+
+# Communicate with the arduino using a serial interface
+# All information is exchanged using a variation of g-code
+# Parameters are stored in the database
+module Fb
+  class HardwareInterfaceParam
+
+    attr_accessor :params, :param_version_db, :param_version_ar, :params_in_sync,
+      :axis_x_steps_per_unit, :axis_y_steps_per_unit, :axis_z_steps_per_unit,
+      :ramps_arduino, :ramps_main
+
+
+    # initialize the interface
+    #
+    def initialize
+      @params                = []
+      @external_info         = ""
+      @param_version_db      = 0
+      @param_version_ar      = 0
+      @params_in_sync        = false
+
+      @axis_x_steps_per_unit = 1
+      @axis_y_steps_per_unit = 1
+      @axis_z_steps_per_unit = 1
+
+      load_param_names()
+
+
+      load_param_values_non_arduino()
+
+    end
+
+    ## DATABASE AND SETTINGS HANDLING
+    ## ******************************
+
+    # load non-arduino parameters
+    #
+    def load_param_values_non_arduino
+
+      p = get_param_by_name('MOVEMENT_STEPS_PER_UNIT_X')
+      @axis_x_steps_per_unit = p['value_db']
+
+      p = get_param_by_name('MOVEMENT_STEPS_PER_UNIT_Y')
+      @axis_y_steps_per_unit = p['value_db']
+
+      p = get_param_by_name('MOVEMENT_STEPS_PER_UNIT_Z')
+      @axis_z_steps_per_unit = p['value_db']
+
+    end
+
+    # load the id's of the arduino parameters
+    #
+    def load_param_names
+      $arduino_default_params.each do |p|
+         param_name_add(p[:name], p[:id], p[:value])
+      end
+    end
+
+    # add a parameter to the param list
+    #
+    def param_name_add(name, id, default)
+      found = false
+      @params.each do |p|
+        if p['name'] == name
+          found = true
+        end
+      end
+
+      if found == false
+        param = Hash.new
+        param['name']     = name
+        param['id']       = id
+        param['value_db'] = 0
+        param['value_ar'] = 0
+        param['default']  = default
+        @params << param
+      end
+    end
+
+    # get the parameter object by name
+    #
+    def get_param_by_name(name)
+      param = nil
+      @params.each do |p|
+        if p['name'] == name
+          param = p
+        end
+      end
+      return param
+    end
+
+    # get the parameter object by id
+    #
+    def get_param_by_id(id)
+      param = nil
+      @params.each do |p|
+        if p['id'] == id
+          param = p
+        end
+      end
+      return param
+    end
+
+    # get parameter object by name or id
+    #
+    def get_param(name_or_id, by_name_or_id)
+      param = nil
+      @params.each do |p|
+        if (by_name_or_id == :by_id   and p['id']   == name_or_id)
+          param = p
+        end
+        if (by_name_or_id == :by_name and p['name'] == name_or_id)
+          param = p
+        end
+      end
+      return param
+    end
+
+    # save parameter value to the database
+    #
+    def save_param_value(name_or_id, by_name_or_id, from_device_or_db, value)
+
+      param = get_param(name_or_id, by_name_or_id)
+
+      if param != nil and from_device_or_db == :from_device
+        param['value_ar'] = value
+      end
+      if param != nil and from_device_or_db == :from_db
+        param['value_db'] = value
+      end
+    end
+
+    # check to see of parameters in arduino are up to date
+    #
+    def check_parameters
+      update_param_version_ar()
+      compare_and_write_parameters()
+    end
+
+    def update_param_version_ar
+      # read the parameter version in the database and in the device
+      read_parameter_from_device(0)
+
+      params.each do |p|
+        if p['id'] == 0
+          @param_version_ar = p['value_ar']
+        end
+      end
+    end
+
+    def compare_and_write_parameters
+      # if the parameters in the device is different from the database parameter version
+      # read and compare each parameter and write to device is different
+
+      if @param_version_db != @param_version_ar
+
+        load_param_values_non_arduino()
+
+        if !parameters_different()
+          @params_in_sync = true
+          write_parameter_to_device(0, @param_version_db)
+        else
+          @params_in_sync = false
+        end
+      else
+        @params_in_sync = true
+      end
+    end
+
+    def parameters_different
+      differences_found_total = false
+      params.each do |p|
+        if p['id'] != 0
+          difference = check_and_write_parameter(p)
+          if difference then
+            @params_in_sync = false
+            differences_found_total = true
+          end
+        end
+      end
+      differences_found_total
+    end
+
+    # synchronise a parameter value
+    #
+    def check_and_write_parameter(param)
+
+       # read value from device and database
+       read_parameter_from_device(param['id'])
+
+       differences_found = false
+
+       # if the parameter value between device and database is different, write value to device
+       if param['value_db'] != param ['value_ar']
+         differences_found = true
+         write_parameter_to_device(param['id'],param['value_db'])
+       end
+
+      return differences_found
+
+    end
+
+    # read a parameter from arduino
+    #
+    def read_parameter_from_device(id)
+      @ramps_arduino.execute_command("F21 P#{id}", false, false)
+    end
+
+    # write a parameter value to arduino
+    #
+    def write_parameter_to_device(id, value)
+      @ramps_arduino.execute_command("F22 P#{id} V#{value}", false, false)
+    end
+
+  end
+end