xbee 1.0.2

data/lib/xbee/address_64.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+require_relative 'address'
+
+module XBee
+	class Address64 < Address
+		def initialize(b1, b2, b3, b4, b5, b6, b7, b8)
+			@bytes = [b1, b2, b3, b4, b5, b6, b7, b8]
+		end
+
+
+		class << self
+			def from_string(string)
+				if (matcher = /^(\h\h)[^\h]*(\h\h)[^\h]*(\h\h)[^\h]*(\h\h)[^\h]*(\h\h)[^\h]*(\h\h)[^\h]*(\h\h)[^\h]*(\h\h)$/.match(string))
+					new *(matcher[1..8].map &:hex)
+				else
+					raise ArgumentError, "#{string.inspect} is not a valid 64-bit address string"
+				end
+			end
+
+
+			def from_array(array)
+				if array.length == 8 && array.all? { |x| (0..255).cover? x }
+					new *array
+				else
+					raise ArgumentError, "#{array.inspect} is not a valid 64-bit address array"
+				end
+			end
+		end
+
+
+
+		def to_s
+			('%02x' * 8) % @bytes
+		end
+
+
+		BROADCAST = new(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff).freeze
+		COORDINATOR = new(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00).freeze
+	end
+end

data/lib/xbee/bytes.rb

@@ -0,0 +1,21 @@
+module XBee
+	# Starting to accumulate code to manipulate arrays of bytes in one place. Maybe eventually this will be a subclass of Array or...?
+	class Bytes
+
+		class << self
+
+			def array_from_unsigned_int(int, _num_bytes = 2)
+				# TODO: Make this more generic than the 16-bit case
+				[(int >> 8) & 0xff, int & 0xff]
+			end
+
+
+			def unsigned_int_from_array(array)
+				index = -1
+				array.reverse.reduce(0) do |result, byte|
+					result + (byte << 8 * (index += 1))
+				end
+			end
+		end
+	end
+end

data/lib/xbee/exceptions/exception.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module XBee
+	module Exceptions
+		# Base class for all XBee exception types, for convenience when consumer code wants to rescue anything XBee raises.
+		class Exception < RuntimeError
+		end
+	end
+end

data/lib/xbee/exceptions/frame_format_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+require_relative 'exception'
+
+module XBee
+	module Exceptions
+		class FrameFormatError < XBee::Exceptions::Exception
+		end
+	end
+end

data/lib/xbee/exceptions/unknown_frame_type.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+require_relative 'exception'
+
+module XBee
+	module Exceptions
+		class UnknownFrameType < ::XBee::Exceptions::Exception
+		end
+	end
+end

data/lib/xbee/frames/addressed_frame.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+require_relative 'identified_frame'
+
+module XBee
+	module Frames
+		class AddressedFrame < IdentifiedFrame
+
+			attr_accessor :address16
+			attr_accessor :address64
+
+
+			def initialize(packet: nil)
+				super
+
+				if @parse_bytes
+					@address64 = Address64.new *@parse_bytes.shift(8)
+					@address16 = Address16.new *@parse_bytes.shift(2)
+				end
+			end
+
+
+			def bytes
+				super + (address64 || Address64.from_array([0] * 8)).to_a + (address16 || Address16.new(0, 0)).to_a
+			end
+		end
+	end
+end

data/lib/xbee/frames/at_command.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+require_relative 'identified_frame'
+
+module XBee
+	module Frames
+		# Use this frame to query or set device parameters on the local device. This API command applies
+		# changes after running the command. You can query parameter values by sending the 0x08 AT
+		# Command frame with no parameter value field (the two-byte AT command is immediately followed by
+		# the frame checksum).
+		class ATCommand < IdentifiedFrame
+			api_id 0x08
+
+			attr_accessor :command_bytes
+			# attr_accessor :command
+			attr_accessor :parameter_bytes
+			# attr_accessor :parameter
+
+
+			def initialize(packet: nil)
+				super
+
+				if @parse_bytes
+					@command_bytes = @parse_bytes.shift 2
+					@parameter_bytes = @parse_bytes
+					@parse_bytes = []
+				end
+			end
+
+
+			def bytes
+				super + command_bytes + (parameter_bytes || [])
+			end
+		end
+	end
+end

data/lib/xbee/frames/at_command_queue_parameter_value.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+require_relative 'at_command'
+
+module XBee
+	module Frames
+		# This frame allows you to query or set device parameters. In contrast to the AT Command (0x08)
+		# frame, this frame queues new parameter values and does not apply them until you issue either:
+		#  * The AT Command (0x08) frame (for API type)
+		#  * The AC command
+		#
+		# When querying parameter values, the 0x09 frame behaves identically to the 0x08 frame. The device
+		# returns register queries immediately and not does not queue them. The response for this command is
+		# also an AT Command Response frame (0x88).
+		#
+		# Send a command to change the baud rate (BD) to 115200 baud, but do not apply changes yet. The
+		# module continues to operate at the previous baud rate until you apply the changes.
+		class ATCommandQueueParameterValue < ATCommand
+			api_id 0x09
+		end
+	end
+end

data/lib/xbee/frames/at_command_response.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+require_relative 'identified_frame'
+
+module XBee
+	module Frames
+		class ATCommandResponse < IdentifiedFrame
+			api_id 0x88
+
+			attr_accessor :command
+			attr_accessor :status
+			attr_accessor :data
+
+
+			def initialize(packet: nil)
+				super
+
+				if @parse_bytes
+					@command = @parse_bytes.shift 2
+					@status = @parse_bytes.shift
+					@data = @parse_bytes
+					@parse_bytes = []
+				end
+			end
+
+
+			def bytes
+				super + (command || [0x00] * 2) + [status || 0x00] + (data || [])
+			end
+		end
+	end
+end

data/lib/xbee/frames/create_source_route.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+require_relative 'addressed_frame'
+
+module XBee
+	module Frames
+		class CreateSourceRoute < AddressedFrame
+			api_id 0x21
+
+			# TODO: Not implemented
+			def initialize(packet: nil)
+				raise 'Not implemented'
+			end
+		end
+	end
+end

data/lib/xbee/frames/data/sample.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module XBee
+	module Frames
+		module Data
+			class Sample
+				# Bit-mapping of digital channel names
+				DIGITAL_CHANNELS = [
+					:na,
+					:na,
+					:na,
+					:DIO12,
+					:DIO11,
+					:DIO10,
+					:na,
+					:na,
+					:DIO7,
+					:DIO6,
+					:DIO5,
+					:DIO4,
+					:DIO3,
+					:DIO2,
+					:DIO1,
+					:DIO0,
+				]
+
+				# Bit-mapping of analog channel names
+				ANALOG_CHANNELS = [
+					:supply_voltage,
+					:na,
+					:na,
+					:na,
+					:AD3,
+					:AD2,
+					:AD1,
+					:AD0,
+				]
+
+
+				attr_reader :digital_values
+				attr_reader :analog_values
+
+
+				# Parses the input bytes into @digital_values and @analog_values.
+				# Consumes the bytes read, so the next sample can be constructed.
+				# @param parse_bytes [Array<Integer>] Input data.
+				def initialize(parse_bytes:)
+					input = parse_bytes
+					@digital_channel_mask = (input.shift << 8) + input.shift
+					@analog_channel_mask = input.shift
+
+					@digital_values = {}
+					if @digital_channel_mask > 0
+						raw = (input.shift << 8) + input.shift
+						DIGITAL_CHANNELS.reverse.each_with_index do |channel, index|
+							if (@digital_channel_mask & (1 << index)) > 0
+								@digital_values[channel] = (raw & (1 << index)) > 0 ? 1 : 0
+							end
+						end
+					end
+
+					@analog_values = {}
+					ANALOG_CHANNELS.reverse.each_with_index do |channel, index|
+						if (@analog_channel_mask & (1 << index)) > 0
+							@analog_values[channel] = (input.shift << 8) + input.shift
+						end
+					end
+				end
+			end
+		end
+	end
+end

data/lib/xbee/frames/data_sample_rx_indicator.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+require_relative 'frame'
+require_relative 'data/sample'
+
+module XBee
+	module Frames
+		class DataSampleRXIndicator < Frame
+			api_id 0x92
+
+			attr_reader :address16
+			attr_reader :address64
+			attr_reader :options
+
+			# [Array<Data::DataSample>] Array of sample objects
+			attr_reader :samples
+
+
+			OPTION_BITS = {
+				0x01 => :acknowledged,
+				0x02 => :broadcast,
+			}.freeze
+
+
+			def initialize(packet: nil)
+				@samples = []
+
+				super
+
+				if @parse_bytes
+					@address64 = Address64.new *@parse_bytes.shift(8)
+					@address16 = Address16.new *@parse_bytes.shift(2)
+					@options = @parse_bytes.shift
+					@number_of_samples = @parse_bytes.shift
+					@number_of_samples.times do
+						@samples << Data::Sample.new(parse_bytes: @parse_bytes)
+					end
+				end
+			end
+
+
+			def bytes
+				super +
+					(address64 || Address64::COORDINATOR).to_a +
+					(address16 || Address16::COORDINATOR).to_a +
+					[options || 0x00] +
+					[(samples || []).length] +
+					samples.map(&:to_a).reduce(:+)
+			end
+		end
+	end
+end

data/lib/xbee/frames/explicit_addressing_command.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+require_relative 'addressed_frame'
+
+module XBee
+	module Frames
+		# This frame is similar to Transmit Request (0x10), but it also requires you to specify the application-
+		# layer addressing fields: endpoints, cluster ID, and profile ID.
+		#
+		# This frame causes the device to send payload data as an RF packet to a specific destination, using
+		# specific source and destination endpoints, cluster ID, and profile ID.
+		#
+		# * For broadcast transmissions, set the 64-bit destination address to 0x000000000000FFFF .
+		#   Address the coordinator by either setting the 64-bit address to all 0x00s and the 16-bit address
+		#   to 0xFFFE, or setting the 64-bit address to the coordinator's 64-bit address and the 16-bit
+		#   address to 0x0000.
+		#
+		# * For all other transmissions, setting the 16-bit address to the correct 16-bit address helps
+		#   improve performance when transmitting to multiple destinations. If you do not know a 16-bit
+		#   address, set this field to 0xFFFE (unknown). If successful, the Transmit Status frame (0x8B)
+		#   indicates the discovered 16-bit address.
+		#
+		# You can set the broadcast radius from 0 up to NH to 0xFF. If set to 0, the value of NH specifies the
+		# broadcast radius (recommended). This parameter is only used for broadcast transmissions.
+		#
+		# You can read the maximum number of payload bytes with the NP command.
+		class ExplicitAddressingCommand < AddressedFrame
+			api_id 0x11
+
+			attr_accessor :source_endpoint
+			attr_accessor :destination_endpoint
+			attr_accessor :cluster_id # 2 bytes
+			attr_accessor :profile_id # 2 bytes
+			attr_accessor :broadcast_radius
+			attr_accessor :transmission_options
+			attr_accessor :data
+
+
+			OPTIONS = {
+				0x01 => :disable_retries,
+				0x08 => :multicast_addressing,
+				0x20 => :enable_aps_encryption,
+				0x40 => :extended_transmission_timeout,
+			}.freeze
+
+
+
+			def initialize(packet: nil)
+				super
+
+				if @parse_bytes
+					@source_endpoint = @parse_bytes.shift
+					@destination_endpoint = @parse_bytes.shift
+					@cluster_id = @parse_bytes.shift 2
+					@profile_id = @parse_bytes.shift 2
+					@broadcast_radius = @parse_bytes.shift
+					@transmission_options = @parse_bytes.shift
+					@data = @parse_bytes
+					@parse_bytes = []
+				end
+			end
+
+
+			def bytes
+				super + [options || 0x00] + (data || [])
+			end
+		end
+	end
+end

data/lib/xbee/frames/explicit_rx_indicator.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require_relative 'frame'
+require_relative '../bytes'
+
+module XBee
+	module Frames
+		# When a device configured with explicit API Rx Indicator (AO = 1) receives an RF packet, it sends it out
+		# the serial interface using this message type.
+		class ExplicitRXIndicator < Frame
+			api_id 0x91
+
+
+			OPTION_BITS = {
+				0x01 => 'Acknowledged',
+				0x02 => 'Broadcast packet',
+				0x20 => 'Encrypted with APS encryption',
+			}.freeze
+
+
+			attr_accessor :address64
+			attr_accessor :address16
+			attr_accessor :source_endpoint # 8-bit scalar
+			attr_accessor :destination_endpoint # 8-bit scalar
+			attr_accessor :cluster_id # 16-bit scalar
+			attr_accessor :profile_id # 16-bit scalar
+			attr_accessor :options # 8-bit scalar
+			attr_accessor :data # 0-n bytes
+
+
+			def initialize(packet: nil)
+				super
+
+				if @parse_bytes
+					@address64 = Address64.new *@parse_bytes.shift(8)
+					@address16 = Address16.new *@parse_bytes.shift(2)
+					@source_endpoint = @parse_bytes.shift
+					@destination_endpoint = @parse_bytes.shift
+					@cluster_id = Bytes.unsigned_int_from_array @parse_bytes.shift(2)
+					@profile_id = Bytes.unsigned_int_from_array @parse_bytes.shift(2)
+					@options = @parse_bytes.shift
+					@data = @parse_bytes
+					@parse_bytes = []
+				end
+			end
+
+
+			def bytes
+				super +
+					(address64 || Address64.from_array([0] * 8)).to_a +
+					(address16 || Address16.new(0, 0)).to_a +
+					[source_endpoint || 0x00] +
+					[destination_endpoint || 0x00] +
+					Bytes.array_from_unsigned_int(cluster_id || 0) +
+					Bytes.array_from_unsigned_int(profile_id || 0) +
+					[options || 0x00] +
+					(data || [])
+			end
+		end
+	end
+end