nxt 0.3.0 → 0.5.0

data/lib/telegrams/commands/direct/replies/set_output_state_reply.rb

@@ -0,0 +1,11 @@
+require_relative '../../direct_command_reply'
+
+class SetOutputStateReply < DirectCommandReply
+	def initialize(bytes)
+		super(bytes)
+	end
+
+  def validate_bytes(bytes)
+    raise ArgumentError, "must be a reply for a SetOutputState command" unless bytes[1] == 0x04
+  end
+end

data/lib/telegrams/commands/direct/replies/start_program_reply.rb

@@ -0,0 +1,13 @@
+require_relative '../../direct_command_reply'
+
+class StartProgramReply < DirectCommandReply
+  def initialize(bytes)
+    super(bytes)
+  end
+
+  # override
+  def validate_bytes(bytes)
+    super(bytes)
+    raise ArgumentError, "must be a reply for a StartProgram command" unless bytes[1] == 0x00
+  end
+end

data/lib/telegrams/commands/direct/replies/stop_program_reply.rb

@@ -0,0 +1,13 @@
+require_relative '../../direct_command_reply'
+
+class StopProgramReply < DirectCommandReply
+  def initialize(bytes)
+    super(bytes)
+  end
+
+  # override
+  def validate_bytes(bytes)
+    super(bytes)
+    raise ArgumentError, "must be a reply for a StopProgram command" unless bytes[1] == 0x01
+  end
+end

data/lib/telegrams/commands/direct/replies/stop_sound_playback_reply.rb

@@ -0,0 +1,13 @@
+require_relative '../../direct_command_reply'
+
+class StopSoundPlaybackReply < DirectCommandReply
+  def initialize(bytes)
+    super(bytes)
+  end
+
+  # override
+  def validate_bytes(bytes)
+    super(bytes)
+    raise ArgumentError, "must be a reply for a StopSoundPlayback command" unless bytes[1] == 0x0C
+  end
+end

data/lib/telegrams/commands/direct/reset_motor_position.rb

@@ -0,0 +1,8 @@
+require_relative '../direct_command'
+
+class ResetMotorPosition < DirectCommand
+  def initialize(require_response=true)
+    super
+    @command = 0x0A
+  end
+end

data/lib/telegrams/commands/direct/set_input_mode.rb

@@ -0,0 +1,101 @@
+require_relative '../direct_command'
+
+class SetInputMode < DirectCommand
+
+  class << self
+    def input_ports; INPUT_PORTS.keys; end
+    def sensor_types; SENSOR_TYPES.keys; end
+    def sensor_modes; SENSOR_MODES.keys; end
+  end
+
+  attr_reader :input_port, :sensor_type, :sensor_mode
+
+	def initialize(input_port, sensor_type, sensor_mode, response_required=true)
+		super(response_required)
+		@command = 0x05
+
+    validate_arguments(input_port, sensor_type, sensor_mode)
+    @input_port = input_port
+    @sensor_type = sensor_type
+    @sensor_mode = sensor_mode
+	end
+
+  INPUT_PORTS = {
+    one: 0x00,
+    two: 0x01,
+    three: 0x02,
+    four: 0x03
+  }
+
+  SENSOR_TYPES = {}
+  [:no_sensor,
+   :switch,
+   :temperature,
+   :reflection,
+   :angle,
+   :light_active,
+   :light_inactive,
+   :sound_db,
+   :sound_dba,
+   :custom,
+   :lowspeed,
+   :lowspeed_9v,
+   :highspeed,
+   :colorfull,
+   :colorred,
+   :colorgreen,
+   :colorblue,
+   :colornone
+  ].each_with_index do |key, index|
+    SENSOR_TYPES[key] = index
+  end
+
+  SENSOR_MODES = {
+    :rawmode => 0x00,
+    :booleanmode => 0x20,
+    :transitioncntmode => 0x40,
+    :periodcountermode => 0x60,
+    :pctfullscalemode => 0x80,
+    :celsiusmode => 0xA0,
+    :fahrenheitmode => 0xC0,
+    :anglestepmode => 0xE0,
+    :slopemask => 0x1F,
+    :modemask => 0xE0
+  }
+
+  def sensor_types
+    self.class.sensor_types
+  end
+
+  def sensor_modes
+    self.class.sensor_modes
+  end
+
+  def input_ports
+    self.class.input_ports
+  end
+
+  def as_bytes
+    super << INPUT_PORTS[@input_port] << SENSOR_TYPES[@sensor_type] << SENSOR_MODES[@sensor_mode]
+  end
+
+  private
+  def validate_arguments(input_port, sensor_type, sensor_mode)
+    validate_input_port(input_port)
+    validate_sensor_type(sensor_type)
+    validate_sensor_mode(sensor_mode)
+  end
+
+  def validate_input_port(input_port)
+    raise ArgumentError, "Invalid input port" unless input_ports.include? input_port
+  end
+
+  def validate_sensor_type(sensor_type)
+    raise ArgumentError, "Invalid sensor type" unless sensor_types.include? sensor_type
+  end
+
+  def validate_sensor_mode(sensor_mode)
+    raise ArgumentError, "Invalid sensor mode" unless sensor_modes.include? sensor_mode
+  end
+
+end

data/lib/telegrams/commands/direct/set_output_state.rb

@@ -0,0 +1,29 @@
+require_relative '../direct_command'
+require_relative './output_state'
+require 'forwardable'
+
+class SetOutputState < DirectCommand
+  extend Forwardable
+
+  def initialize(output_state, wait_for_reply=true)
+    super(wait_for_reply)
+    @command = 0x04
+
+    raise ArgumentError, "output_state must be a valid OutputState object" if output_state.nil?
+    @output_state = output_state
+  end
+
+  def as_bytes
+    super.concat(@output_state.as_bytes)
+  end
+
+  # follow Law of Demeter and hide internal access to output_state
+  def_delegators :@output_state, :port, :power, :mode_flags, :regulation_mode,
+                                 :turn_ratio, :run_state, :tacho_limit
+
+  private
+  def output_state
+    @output_state
+  end
+end
+

data/lib/telegrams/commands/direct/start_program.rb

@@ -0,0 +1,30 @@
+require_relative '../direct_command'
+require_relative '../message_translator'
+
+class StartProgram < DirectCommand
+  include MessageTranslator
+
+  attr_reader :name
+
+  def initialize(program_name, require_response=true)
+    raise ArgumentError, "program_name is required" if program_name.nil?
+
+    super(require_response)
+    @command = 0x00  # startprogram
+    @name = adjust_program_name(program_name)
+  end
+
+  def as_bytes
+   bytes = super
+   bytes.concat program_name_as_bytes
+  end
+
+  private
+  def program_name_as_bytes
+    string_as_bytes(@name)
+  end
+
+  def adjust_program_name(name)
+    add_default_extension_if_missing(name, 'rxe')
+  end
+end

data/lib/telegrams/commands/direct/stop_program.rb

@@ -0,0 +1,9 @@
+require_relative '../direct_command'
+
+class StopProgram < DirectCommand
+  def initialize(require_response=true)
+    super
+    @command = 0x01
+  end
+
+end

data/lib/telegrams/commands/direct/stop_sound_playback.rb

@@ -0,0 +1,8 @@
+require_relative '../direct_command'
+
+class StopSoundPlayback < DirectCommand
+  def initialize(require_response=true)
+    super(require_response)
+    @command= 0x0C
+  end
+end

data/lib/telegrams/commands/direct_command.rb

@@ -0,0 +1,8 @@
+require_relative "../respondable_telegram"
+
+class DirectCommand < RespondableTelegram
+  def initialize(require_response=true)
+    super
+    @type = 0x00
+  end
+end

data/lib/telegrams/commands/direct_command_reply.rb

@@ -0,0 +1,10 @@
+require_relative '../reply'
+
+class DirectCommandReply < Reply
+
+  def initialize(bytes)
+    super
+  end
+
+end
+

data/lib/telegrams/commands/message_translator.rb

@@ -0,0 +1,46 @@
+module MessageTranslator
+  FILENAME_MAX_LENGTH = 20 # 15.3 + null terminator
+
+  def string_as_bytes(string, max_length=FILENAME_MAX_LENGTH)
+    # pad out to max length with null characters and then
+    # convert all to ASCIIZ (null-terminated ascii string)
+    string.ljust(max_length, "\0").unpack('C*')
+  end
+
+  def string_from_bytes(bytes)
+    # convert from ASCIIZ (null-terminated ascii), removing all the 
+    # trailing null characters
+    bytes.pack("C*").strip
+  end
+
+  def add_default_extension_if_missing(filename, default_extension)
+    /.+\.[A-Za-z0-9]{3}$/.match(filename).nil? ? "#{filename}.#{default_extension}" : filename
+  end
+
+  def boolean_as_bytes(boolean)
+    boolean ? [0xff] : [0x00]
+  end
+
+  def boolean_from_bytes(bytes)
+    bytes == [0x00] ? false : true
+  end
+
+  def integer_as_uword_bytes(integer)
+   integer_as_bytes(integer, 4) # make sure number is 4 bytes, or 2, 2 digit hex values
+  end
+
+  def integer_as_ulong_bytes(integer)
+   integer_as_bytes(integer, 8) # (4 bytes as 2 digit hex values each)
+  end
+
+  def integer_as_bytes(integer, bytes_length)
+   uword_byte_length = bytes_length
+   bytes_string = integer.to_s(16).rjust(uword_byte_length, "0")
+   [bytes_string].pack('H*').bytes.to_a.reverse # reverse because it's MSB
+  end
+
+  def integer_from_bytes(bytes)
+    bytes.reverse.pack('C*').unpack('H*')[0].hex
+  end
+
+end

data/lib/telegrams/commands/system/get_device_info.rb

@@ -0,0 +1,8 @@
+require_relative '../system_command'
+
+class GetDeviceInfo < SystemCommand
+  def initialize
+    super
+    @command = 0x9B
+  end
+end

data/lib/telegrams/commands/system/replies/get_device_info_reply.rb

@@ -0,0 +1,41 @@
+require_relative '../../../reply'
+
+class GetDeviceInfoReply < Reply
+  attr_reader :nxt_brick_name, :bt_address, 
+              :signal_strength, :free_user_flash_memory_bytes
+
+  def initialize(bytes)
+    super
+    raise ArgumentError, "must be a GetDeviceInfoReply (0x9B)" unless bytes[1] == 0x9B
+
+    @nxt_brick_name = parse_brick_name(bytes)
+    @bt_address = parse_bt_address(bytes)
+    @signal_strength = parse_signal_strength(bytes)
+    @free_user_flash_memory_bytes = parse_free_user_flash_memory(bytes)
+  end
+
+  private
+  def parse_brick_name(bytes)
+    bytes[3..17].pack("C*").strip
+  end
+
+  def parse_bt_address(bytes)
+    # skip the null terminator, so 18-23 with 24 at null terminator
+    address = bytes[18..23].map { | byte | byte.to_s(8).rjust(2, "0") }
+    "btspp://#{address.join('')}"
+  end
+
+  def parse_signal_strength(bytes)
+    signal_strength_bytes = bytes[25..28]
+    convert_byte_array_of_little_endian_to_number(signal_strength_bytes)
+  end
+
+  def parse_free_user_flash_memory(bytes)
+    free_memory_bytes = bytes[29..32]
+    convert_byte_array_of_little_endian_to_number(free_memory_bytes)
+  end
+
+  def convert_byte_array_of_little_endian_to_number(byte_array)
+    byte_array.pack('C*').unpack('v*')[0]
+  end
+end

data/lib/telegrams/commands/system_command.rb

@@ -0,0 +1,8 @@
+require_relative '../respondable_telegram'
+
+class SystemCommand < RespondableTelegram
+  def initialize(response_required=true)
+    super
+    @type = 0x01
+  end
+end

data/lib/telegrams/no_message_reply.rb

@@ -0,0 +1,10 @@
+require_relative './reply'
+
+class NoMessageReply < Reply
+  # override to return empty string
+  def message
+    ''
+  end
+end
+
+

data/lib/telegrams/reply.rb

@@ -0,0 +1,82 @@
+require_relative './telegram'
+
+class Reply < Telegram
+  COMMAND_TYPE = 0x02
+  SUCCESS = 0x00
+  STATUS_MESSAGES = {
+    SUCCESS => 'Success',
+    # base error messages
+    0x81 => 'No more handles',
+    0x82 => 'No space',
+    0x83 => 'No more files',
+    0x84 => 'End of file expected',
+    0x85 => 'End of file',
+    0x86 => 'Not a linear file',
+    0x87 => 'File not found',
+    0x88 => 'Handle all ready closed',
+    0x89 => 'No linear space',
+    0x8A => 'Undefined error',
+    0x8B => 'File is busy',
+    0x8C => 'No write buffers',
+    0x8D => 'Append not possible',
+    0x8E => 'File is full',
+    0x8F => 'File exists',
+    0x90 => 'Module not found',
+    0x91 => 'Out of boundary',
+    0x92 => 'Illegal file name',
+    0x93 => 'Illegal handle',
+
+    # command replies
+    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'
+  }
+
+  attr_accessor :type, :command, :status, :message_bytes, :status_description
+
+  def initialize(bytes=nil)
+    validate_bytes(bytes)
+    @type = bytes[0]
+    @command = bytes[1]
+    @status = bytes[2]
+    @message_bytes = bytes[3..-1]
+    set_status_description
+  end
+
+
+  def success?
+    status == SUCCESS
+  end
+
+
+  def message
+    # override in subclasses to translate bytes to something meaningful
+    message_bytes
+  end
+
+
+  private
+  def validate_bytes(bytes)
+    raise ArgumentError, "must be non-nil" if bytes.nil?
+    raise ArgumentError, "must have a type, command, and status" unless bytes.size && bytes.size >= 3
+    raise ArgumentError, "must be a reply telegram" unless bytes[0] == COMMAND_TYPE
+  end
+
+  def set_status_description
+    @status_description = STATUS_MESSAGES.include?(status) ? STATUS_MESSAGES[status] : ''
+  end
+end