xbee 1.0.2

data/lib/xbee/frames/frame.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+require 'semantic_logger'
+
+require_relative '../address_16'
+require_relative '../address_64'
+require_relative '../exceptions/frame_format_error'
+require_relative '../exceptions/unknown_frame_type'
+
+module XBee
+	module Frames
+		class Frame
+			include SemanticLogger::Loggable
+
+			class << self
+				# [<Integer, Frame>] Map of frame type IDs to implementation classes
+				@@frame_types = {}
+
+				# Registers the frame type
+				def api_id(byte)
+					@@frame_types ||= {}
+					raise "Attempted to redefine API ID #{byte.inspect}" if @@frame_types.has_key? byte
+					@@frame_types[byte] = self
+
+					define_singleton_method(:frame_type) do
+						byte
+					end
+
+					define_method(:frame_type) do
+						byte
+					end
+				end
+
+
+				def from_packet(packet)
+					raise Exceptions::UnknownFrameType, packet unless @@frame_types.has_key? packet.data[0]
+					@@frame_types[packet.data[0]].new packet: packet
+				end
+			end
+
+
+			# [XBee::Packet] if this frame was received, it'll belong to a Packet. (Frames prepped for transmit have no Packet association.)
+			attr_reader :packet
+
+			# Subclasses should shift +@parse_bytes+ as necessary to get their data fields.
+			def initialize(packet: nil)
+				logger.trace 'Initializing...', packet: packet
+				@packet = packet
+				if packet
+					@parse_bytes = packet.data.dup
+					@frame_type = @parse_bytes.shift
+				end
+			end
+
+
+			def bytes
+				[frame_type]
+			end
+
+
+			def to_packet
+				@packet = Packet.new bytes
+			end
+		end
+	end
+end

data/lib/xbee/frames/identified_frame.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+require_relative 'frame'
+
+module XBee
+	module Frames
+		# The base class for frames that have an ID for tracking the radio's processing.
+		class IdentifiedFrame < Frame
+			attr_accessor :id
+
+			def initialize(packet: nil)
+				super
+
+				if @parse_bytes
+					@id = @parse_bytes.shift
+				end
+			end
+
+
+			def bytes
+				super + [(id || 0x00)]
+			end
+		end
+	end
+end

data/lib/xbee/frames/many_to_one_route_request_indicator.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+require_relative 'unidentified_addressed_frame'
+
+module XBee
+	module Frames
+		class ManyToOneRouteRequestIndicator < UnidentifiedAddressedFrame
+			api_id 0xA3
+
+		end
+	end
+end

data/lib/xbee/frames/modem_status.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+require_relative 'frame'
+
+module XBee
+	module Frames
+		class ModemStatus < Frame
+			api_id 0x8A
+
+
+			STATUSES = {
+				0x00 => 'Hardware reset',
+				0x01 => 'Watchdog timer reset',
+				0x02 => 'Joined network',
+				0x03 => 'Disassociated',
+				0x06 => 'Coordinator started',
+				0x07 => 'Network security key was updated',
+				0x0D => 'Voltage supply limit exceeded',
+				0x11 => 'Modem configuration changed while join in progress',
+			}
+
+			attr_accessor :status
+
+
+			def initialize(packet: nil)
+				super
+
+				if @parse_bytes
+					@status = @parse_bytes.shift
+				end
+			end
+
+
+			def status_string
+				if status < 0x80
+					STATUSES[status]
+				else
+					'Ember ZigBee stack error'
+				end
+			end
+
+
+			def bytes
+				super + [status || 0x00]
+			end
+		end
+	end
+end

data/lib/xbee/frames/node_identification_indicator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+require_relative 'unidentified_addressed_frame'
+require_relative '../bytes'
+
+module XBee
+	module Frames
+		class NodeIdentificationIndicator < UnidentifiedAddressedFrame
+			api_id 0x95
+
+			attr_accessor :options
+			attr_accessor :source_address16
+			attr_accessor :source_address64
+			attr_accessor :parent_address16
+			attr_accessor :identifier
+			attr_accessor :device_type
+			attr_accessor :source_event
+			attr_accessor :profile_id
+			attr_accessor :manufacturer_id
+
+
+			def initialize(packet: nil)
+				super
+
+				if @parse_bytes
+					@options = @parse_bytes.shift
+					@source_address16 = Address16.new *@parse_bytes.shift(2)
+					@source_address64 = Address64.new *@parse_bytes.shift(8)
+					@identifier = @parse_bytes.shift 2
+					@parent_address16 = Address16.new *@parse_bytes.shift(2)
+					@device_type = @parse_bytes.shift
+					@source_event = @parse_bytes.shift
+					@profile_id = Bytes.unsigned_int_from_array @parse_bytes.shift(2)
+					@manufacturer_id = Bytes.unsigned_int_from_array @parse_bytes.shift(2)
+				end
+			end
+		end
+	end
+end

data/lib/xbee/frames/over_the_air_firmware_update_status.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require_relative 'unidentified_addressed_frame'
+
+module XBee
+	module Frames
+		class OverTheAirFirmwareUpdateStatus < UnidentifiedAddressedFrame
+			api_id 0xA0
+
+			attr_accessor :options
+			attr_accessor :bootloader_message
+			attr_accessor :block_number
+
+			attr_accessor :target_address64
+
+
+			def initialize(packet: nil)
+				super
+
+				if @parse_bytes
+					@options = @parse_bytes.shift
+					@bootloader_message = @parse_bytes.shift
+					@block_number = @parse_bytes.shift
+					@target_address64 = Address64.new *@parse_bytes.shift(8)
+				end
+			end
+		end
+	end
+end

data/lib/xbee/frames/receive_packet.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+require_relative 'frame'
+
+module XBee
+	module Frames
+		# When a device configured with a standard API Rx Indicator (AO = 0) receives an RF data packet, it
+		# sends it out the serial interface using this message type.
+		class ReceivePacket < Frame
+			api_id 0x90
+
+
+			OPTION_BITS = {
+				0x01 => 'Acknowledged',
+				0x02 => 'Broadcast packet',
+				0x20 => 'Encrypted with APS encryption',
+				0x40 => 'End device',
+			}.freeze
+
+
+			attr_accessor :address64
+			attr_accessor :address16
+			attr_accessor :options
+			attr_accessor :data
+
+
+			def initialize(packet: nil)
+				super
+
+				if @parse_bytes
+					@address64 = Address64.new *@parse_bytes.shift(8)
+					@address16 = Address16.new *@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 + [options || 0x00] + (data || [])
+			end
+		end
+	end
+end

data/lib/xbee/frames/remote_at_command_request.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+require_relative 'addressed_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 RemoteATCommandRequest < AddressedFrame
+			api_id 0x17
+
+			OPTIONS = {
+				0x01 => :disable_ack,
+				0x40 => :extended_transmission_timeout,
+			}.freeze
+
+			attr_accessor :at_command
+			attr_accessor :command_parameter
+			attr_accessor :remote_command_options
+
+
+			def initialize(packet: nil)
+				@address16 = Address16::BROADCAST
+
+				super
+
+				if @parse_bytes
+					@remote_command_options = @parse_bytes.shift
+					@at_command = @parse_bytes.shift 2
+					@command_parameter = @parse_bytes
+					@parse_bytes = []
+				end
+			end
+
+
+			# @param value [Array/String] The AT command. Must be two bytes, either an array or a string.
+			def at_command=(value)
+				raise ArgumentError, "AT command must be exactly two bytes (got #{value.inspect})" unless value.length == 2
+				if value.respond_to?(:force_encoding)
+					@at_command = value.dup.force_encoding('ASCII').unpack 'C*'
+				else
+					@at_command = value
+				end
+			end
+
+
+			def bytes
+				super + [remote_command_options || 0x00] + (at_command || [0] * 2) + (command_parameter || [])
+			end
+		end
+	end
+end

data/lib/xbee/frames/remote_at_command_response.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+require_relative 'addressed_frame'
+
+module XBee
+	module Frames
+		# If a device receives this frame in response to a Remote Command Request (0x17) frame, the device
+		# sends an AT Command Response (0x97) frame out the serial interface.
+		# Some commands, such as the ND command, may send back multiple frames.
+		class RemoteATCommandResponse < AddressedFrame
+			api_id 0x97
+
+			attr_accessor :at_command
+			attr_accessor :status
+			attr_accessor :data
+
+
+			# Possible values for +status+
+			STATUS = {
+				0 => :ok,
+				1 => :error,
+				2 => :invalid_command,
+				3 => :invalid_parameter,
+				4 => :transmission_failed,
+			}.freeze
+
+
+			def initialize(packet: nil)
+				super
+
+				if @parse_bytes
+					@at_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/route_record_indicator.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require_relative 'unidentified_addressed_frame'
+
+module XBee
+	module Frames
+		class RouteRecordIndicator <  UnidentifiedAddressedFrame
+			api_id 0xA1
+
+			attr_accessor :options
+			attr_accessor :addresses
+
+
+			def initialize(packet: nil)
+				@addresses = []
+
+				super
+
+				if @parse_bytes
+					@options = @parse_bytes.shift
+					number_of_addresses = @parse_bytes.shift
+					number_of_addresses.times do
+						@addresses.push Address16.new(*@parse_bytes.shift(2))
+					end
+				end
+			end
+		end
+	end
+end

data/lib/xbee/frames/transmit_request.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+require_relative 'addressed_frame'
+
+module XBee
+	module Frames
+		# This frame causes the device to send payload data as an RF packet to a specific destination.
+		# * 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. 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 TransmitRequest < AddressedFrame
+			api_id 0x10
+
+			attr_accessor :broadcast_radius
+			attr_accessor :options
+			attr_accessor :data
+
+
+			OPTIONS = {
+				0x01 => :disable_retries,
+				0x20 => :enable_aps_encryption,
+				0x40 => :extended_transmission_timeout,
+			}.freeze
+
+			class << self
+				# Allocates and returns an instance pre-addressed as a broadcast.
+				def broadcast
+					new.tap do |frame|
+						frame.address64 = Address64::BROADCAST
+					end
+				end
+
+
+				# Allocates and returns an instance pre-addressed for the coordinator node.
+				def coordinator
+					new.tap do |frame|
+						frame.address64 = Address64::COORDINATOR
+						frame.address16 = Address16::COORDINATOR
+					end
+				end
+			end
+
+
+			def initialize(packet: nil)
+				super
+
+				if @parse_bytes
+					@broadcast_radius = @parse_bytes.shift
+					@options = @parse_bytes.shift
+					@data = @parse_bytes
+					@parse_bytes = []
+				end
+			end
+
+
+			def bytes
+				super + [broadcast_radius || 0x00] + [options || 0x00] + (data || [])
+			end
+		end
+	end
+end