nxt 0.3.0 → 0.5.0

data/lib/nxt/connectors/input/touch.rb

@@ -1,11 +0,0 @@
-module NXT
-  module Connector
-    module Input
-      class Touch
-        def initialize(port)
-          @port = port
-        end
-      end
-    end
-  end
-end

data/lib/nxt/connectors/input/ultrasonic.rb

@@ -1,11 +0,0 @@
-module NXT
-  module Connector
-    module Input
-      class Ultrasonic
-        def initialize(port)
-          @port = port
-        end
-      end
-    end
-  end
-end

data/lib/nxt/connectors/output/motor.rb

@@ -1,114 +0,0 @@
-module NXT
-  module Connector
-    module Output
-      class Motor
-        include NXT::Command::Output
-        extend NXT::Utils::Accessors
-
-        DURATION_TYPE = [:seconds, :degrees, :rotations].freeze
-        DURATION_AFTER = [:coast, :brake].freeze
-        DIRECTION = [:forwards, :backwards].freeze
-
-        attr_accessor :port, :interface
-
-        attr_combined_accessor :duration, 0
-        attr_combined_accessor :duration_type, :seconds
-        attr_combined_accessor :duration_after, :brake
-        attr_combined_accessor :direction, :forwards
-
-        attr_setter :direction, is_in: DIRECTION
-        attr_setter :duration_after, is_in: DURATION_AFTER
-        attr_setter :duration_type, is_in: DURATION_TYPE
-
-        def initialize(port, interface)
-          @port = port
-          @interface = interface
-        end
-
-        def duration=(duration, options = {})
-          raise TypeError.new('Expected duration to be a number') unless duration.is_a?(Integer)
-          @duration = duration
-
-          self.duration_type = options[:type] if options.include?(:type)
-
-          if options.include?(:after)
-            raise TypeError.new('The after option is only available when the unit duration is in seconds.') if self.duration_type != :seconds
-            self.duration_after = options[:after]
-          end
-
-          self
-        end
-
-        def forwards
-          self.direction = :forwards
-          self
-        end
-
-        def backwards
-          self.direction = :backwards
-          self
-        end
-
-        def stop(type = :coast)
-          self.power = 0
-          self.mode = :coast
-
-          self.move
-        end
-
-        # takes block for response, or can return the response instead.
-        def move
-          response_required = (self.duration > 0 && self.duration_type != :seconds)
-
-          set_motor_output_state(response_required)
-
-          if self.duration > 0 && self.duration_type == :seconds
-            sleep(self.duration)
-            self.reset
-            self.stop(self.duration_after)
-          else
-            self.reset
-          end
-        end
-
-        def reset
-          self.duration = 0
-          self.direction = :forwards
-          self.power = 75
-          self.mode = :motor_on
-          self.regulation_mode = :idle
-          self.run_state = :running
-          self.tacho_limit = 0
-        end
-
-
-        private
-        def set_motor_output_state(response_required=true)
-          original_tacho_limit = self.tacho_limit
-          adjust_tacho_limit
-
-          original_power = self.power
-          adjust_power
-
-          set_output_state(response_required)
-
-          self.power = original_power
-          self.tacho_limit = original_tacho_limit
-        end
-
-        def adjust_tacho_limit
-          case self.duration_type
-          when :rotations
-            self.tacho_limit = self.duration * 360
-          when :degrees
-            self.tacho_limit = self.duration
-          end
-        end
-
-        def adjust_power
-          self.power *= -1 if self.direction == :backwards
-        end
-      end
-    end
-  end
-end

data/lib/nxt/errors.rb

@@ -1,25 +0,0 @@
-module NXT
-  module Errors
-    SUCCESS = 0x00
-    CODES = {
-      SUCCESS => 'Success',
-      0x20 => 'Pending communication transaction in progress',
-      0x40 => 'Specified mailbox queue is empty',
-      0xBD => 'Request failed (i.e., specified file not found)',
-      0xBE => 'Unknown command opcode',
-      0xBF => 'Insane packet',
-      0xC0 => 'Data contains out-of-range values',
-      0xDD => 'Communication bus error',
-      0xDE => 'No free memory in communication buffer',
-      0xDF => 'Specified channel/connection is not valid',
-      0xE0 => 'Specified channel/connection not configured or busy',
-      0xEC => 'No active program',
-      0xED => 'Illegal size specified',
-      0xEE => 'Illegal mailbox queue ID specified',
-      0xEF => 'Attempted to access invalid field of a structure',
-      0xF0 => 'Bad input or output specified',
-      0xFB => 'Insufficient memory available',
-      0xFF => 'Bad arguments'
-    }
-  end
-end

data/lib/nxt/exceptions.rb

@@ -1,26 +0,0 @@
-module NXT
-  module Exceptions
-    # Raised when a class has not implemented a method from the base class
-    # that is required to be overriden.
-    class InterfaceNotImplemented < NotImplementedError; end
-
-    # Raised when an invalid interface is attempted to be constructed.
-    class InvalidInterfaceError < TypeError; end
-
-    # Raised when a port is attempted to be named when it already has been.
-    class PortTakenError < TypeError; end
-
-    # Raised when an invalid name is attempted to be given to a port.
-    class InvalidIdentifierError < TypeError; end
-
-    # Raised when the device file attempted to be used for communication is
-    # for whatever reason does not exist or is not correct.
-    class InvalidDeviceError < TypeError; end
-
-    # Raised when communication with a Serial Port connection fails.
-    class SerialPortConnectionError < RuntimeError; end
-
-    # Raised when a command returns a reply message error
-    class CommandError < RuntimeError; end
-  end
-end

data/lib/nxt/interfaces/base.rb

@@ -1,36 +0,0 @@
-require_relative '../commands/base' #TODO: bad code smell here
-
-module NXT
-  module Interface
-    class Base
-      def send_and_receive(msg, response_required = true)
-        if response_required
-          msg[0] = msg[0] | (response_required ? 0x00 : 0x80)
-        end
-
-        self.send(msg)
-
-        if response_required
-          response = self.receive
-          response
-        end
-      end
-
-      def send
-        raise InterfaceNotImplemented.new('The #send method must be implemented.')
-      end
-
-      def receive
-        raise InterfaceNotImplemented.new('The #receive method must be implemented.')
-      end
-
-      def connect
-        raise InterfaceNotImplemented.new('The #connect method must be implemented')
-      end
-
-      def disconnect
-        raise InterfaceNotImplemented.new('The #disconnect method must be implemented')
-      end
-    end
-  end
-end

data/lib/nxt/interfaces/serial_port.rb

@@ -1,88 +0,0 @@
-require 'serialport'
-
-module NXT
-  module Interface
-    class SerialPort < Base
-      include NXT::Exceptions
-
-      attr_reader :dev
-
-      BAUD_RATE = 57600
-      DATA_BITS = 8
-      STOP_BITS = 1
-      PARITY = ::SerialPort::NONE
-      READ_TIMEOUT = 5000
-
-      def initialize(dev)
-        self.dev = (dev)
-      end
-
-      def dev=(dev)
-        raise InvalidDeviceError unless File.exists?(dev)
-        @dev = dev
-      end
-
-      def connect
-        @connection = ::SerialPort.new(@dev, BAUD_RATE, DATA_BITS, STOP_BITS, PARITY)
-
-        if !@connection.nil?
-          @connection.flow_control = ::SerialPort::HARD
-          @connection.read_timeout = READ_TIMEOUT
-        else
-          raise SerialPortConnectionError.new("Could not establish a SerialPort connection to #{dev}")
-        end
-
-        @connection
-      rescue ArgumentError
-        raise SerialPortConnectionError.new("The #{dev} device is not a valid SerialPort")
-      end
-
-      def disconnect
-        @connection.close if @connection && !@connection.closed?
-      end
-
-      def connected?
-        !@connection.closed?
-      end
-
-      def send(msg)
-        # The expected data package structure for NXT Bluetooth communication is:
-        #
-        #     [Length Byte 1, Length Byte 2, Command Type, Command, ...]
-        #
-        # So here we calculate the two leading length bytes, and rely on the
-        # passed in argument to give us the rest of the message to send.
-        #
-        # Note that the length is stored in Little Endian ie. LSB -> MSB
-        #
-        # Reference: Appendix 1, Page 22
-        msg = [(msg.length & 255), (msg.length >> 8)] + msg
-
-        msg.each do |b|
-          @connection.putc(b)
-        end
-      end
-
-      def receive
-        # This gets the length of the received data from the header that was sent
-        # to us. We unpack it, as it's stored as a 16-bit Little Endian number.
-        #
-        # Reference: Appendix 1, Page 22
-        length = @connection.sysread(2)
-        actual_length = length.unpack('v')[0]
-        response_bytes = @connection.sysread(actual_length)
-        response_array = response_bytes.unpack('C*')
-        response = {
-          :reply => response_array[0] == 0x02,
-          :for_command => response_array[1],
-          :status => response_array[2]
-        }
-        response[:message] = NXT::Errors::CODES[response[:status]]
-        response[:for_command_name] = NXT::Command::Base::COMMANDS[response[:for_command]]
-        response[:data] = response_array[3..-1] if response_array.size > 3
-
-        response
-      end
-    end
-  end
-end

data/lib/nxt/interfaces/usb.rb

@@ -1,8 +0,0 @@
-require 'usb'
-
-module NXT
-  module Interface
-    class USB < Base
-    end
-  end
-end

data/lib/nxt/nxt_brick.rb

@@ -1,167 +0,0 @@
-# This class is the entry point for end-users creating their own list of
-# commands to execute remotely on a Lego NXT brick.
-#
-# An instance of this class provides all the endpoints necessary to:
-#
-# * educate the API on the connected input and output devices; and,
-# * access these input and output devices and run commands using them.
-#
-# @example Creating an instance using a block, with one motor output.
-#
-#   NXTBrick.new(interface) do |nxt|
-#     nxt.add_motor_output(:a, :front_left)
-#   end
-#
-# @example Creating an instance without a block, with one motor and one light sensor.
-#
-#   nxt = NXTBrick.new(interface)
-#   nxt.add_motor_output(:a, :front_left)
-#   # ...
-#   nxt.disconnect
-class NXTBrick
-  include NXT::Exceptions
-
-  # An enumeration of possible ports, both input and output, that the NXT brick
-  # can have connectors attached to.
-  PORTS = [:a, :b, :c, :one, :two, :three, :four]
-
-  # Get the instance of the interface that this runner class is using to connect
-  # to the NXT brick.
-  attr_accessor :interface
-
-  # Accessors for output ports on the NXT brick. These will be populated with
-  # the appropriate instances of their respective output connectors.
-  attr_reader :a, :b, :c
-
-  # Accessors for input ports on the NXT brick. These will be populated with the
-  # appropriate instances of their respective input connectors.
-  attr_reader :one, :two, :three, :four
-
-  # We mandate that all added port connections have an identifier associated
-  # with it. This is so that code is not fragile when port swapping needs to
-  # be done.
-  attr_reader :port_identifiers
-
-  def initialize(interface_type, *interface_args)
-    @port_identifiers = {}
-    interface_type = interface_type.to_s.classify
-
-    validate_interface(interface_type)
-    self.interface = NXT::Interface.const_get(interface_type).new(*interface_args)
-
-    if block_given?
-      begin
-        self.connect
-        yield(self)
-      ensure
-        self.disconnect
-      end
-    end
-  end
-
-  # Connect using the given interface to the NXT brick.
-  def connect
-    self.interface.connect
-  end
-
-  # Close the connection to the NXT brick, and dispose of any resources that
-  # this instance of NXTBrick is using. Any commands run against this runner
-  # after calling disconnect will fail.
-  def disconnect
-    self.interface.disconnect
-  end
-
-  # Add a new connector instance, binding a specific identifier to the given
-  # port.
-  #
-  # If the given port already is bound, an exception will be thrown. The
-  # instance given though can be of any class, presuming it talks the
-  # correct language.
-  #
-  # @param Symbol port The port to bind to.
-  # @param Symbol identifier The identifier to associate with this port.
-  # @param Class klass The Class to instantiate as the instance of this
-  #                    port. There is no limitation on what type this can
-  #                    be, though it must be able to hook in correctly
-  #                    with the NXT library.
-  def add(port, identifier, klass)
-    raise TypeError.new('Expected port to be a Symbol') unless port.is_a?(Symbol)
-    raise TypeError.new('Expected identifier to be a Symbol') unless identifier.is_a?(Symbol)
-    raise TypeError.new('Expected klass to be a Class') unless klass.is_a?(Class)
-
-    unless PORTS.include?(port)
-      raise TypeError.new("Expected port to be one of: :#{PORTS.join(', :')}")
-    end
-
-    port_variable = :"@#{port}"
-
-    if !self.respond_to?(identifier)
-      # Makes a new instance of the class and pushes it into our instance variable
-      # for the given port.
-      self.instance_variable_set(port_variable, klass.new(port, self.interface))
-
-      # Given that that succeeded, all that remains is to add the identifier
-      # to our lookup Hash. We'll use this Hash later on within method_missing.
-      @port_identifiers[identifier] = port
-
-      # Define a method on the eigenclass of this instance.
-      (class << self; self; end).send(:define_method, identifier) do
-        self.instance_variable_get(port_variable)
-      end
-    else
-      if !self.instance_variable_get(port_variable).nil?
-        raise PortTakenError.new("Port #{port} is already set, call remove first")
-      else
-        raise InvalidIdentifierError.new("Cannot use identifier #{identifier}, a method on #{self.class} is already using it.")
-      end
-    end
-  end
-
-  # Remove the assigned (if any) connector instance from the given
-  # identifier.
-  #
-  # @param Symbol identifier The identifier to search for and remove.
-  def remove(identifier)
-    raise TypeError.new('Expected identifier to be a Symbol') unless identifier.is_a?(Symbol)
-    !!@port_identifiers.delete(identifier)
-  end
-
-  # This will dynamically add methods like:
-  #
-  # * add_light_input
-  # * add_motor_output
-  # * add_ultrasonic_input
-  #
-  # This means they don't have to provide the class each and every time. For
-  # connectors they have added themselves, it's likely best to use the
-  # {#add} method.
-  NXT::Connector.constants.each do |type_const|
-    NXT::Connector.const_get(type_const).constants.each do |const|
-      # We don't use a splat here for the args, because that way when
-      # people don't pass in the correct number of params, it says helpfully
-      # '1 of 2' args passed (or something similar).
-      define_method("add_#{const.to_s.underscore}_#{type_const.to_s.underscore}") do |port, identifier|
-        self.add(port, identifier, NXT::Connector.const_get(type_const).const_get(const))
-      end
-    end
-  end
-
-  def start_program(name)
-    NXT::Command::Output::Program.start(self.interface, name)
-  end
-
-  def stop_program
-    NXT::Command::Output::Program.stop(self.interface)
-  end
-
-  def running_program_name
-    NXT::Command::Output::Program.get_running_name(self.interface)
-  end
-
-  private
-  def validate_interface(interface_type_name_string)
-    unless NXT::Interface.constants.include?(interface_type_name_string.to_sym)
-      raise InvalidInterfaceError.new("There is no interface of type #{interface_type_name_string}.")
-    end
-  end
-end