ant-wireless 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60dd8cb782d7e1f500a55f7cd80b77fb2fcd3d9a58388a5e2fdff25ee5c70e2c
-  data.tar.gz: e9c54e26b412c78b10d42a3d6df532b0e58ddab7775146602b38d52ae119e5aa
+  metadata.gz: 0440d58876178ab22b480c72d95830474b407f7b1b366e518a7733a02abdd857
+  data.tar.gz: 2e0eb9be083381e57df2b13843894c33f43a957bff10a30fd06654fee41a5085
 SHA512:
-  metadata.gz: 50f34e579557e981f7f63610dedc06959ab1109e30a65e2d34d2fd33cc29f00c5ac955785e47e7d2b7c912e13999aedeaa0c961a5505b560d0d7e7092f3eb4d0
-  data.tar.gz: 2a3892e482b4173861a1c61c3b194589e14baa6c9d440b02004d8e519c388a88bbc527d3192fe769a36d48dad3d54f4c9bb0f6fce08a9e9cb00876a9684fc0d2
+  metadata.gz: 8237b0332974c4bc1afc2697b4502bb0048dbc00e6caf3ca4f004bc71a0f854fa997b0239d961dd0a0681dbeb3d3bbc370407c4900812233c6ae0a00fef7dbb1
+  data.tar.gz: e2e8f4dff3fc5d60181bd1b7a9f8fa3b5e7683d0c56243ffa0c4645cccc2b1692f738e39fc7f09ea63affaa6d126e4e9a254efbcbb624df14f811a78ccf17e72

data/History.md

@@ -1,6 +1,14 @@
 # Release History for ruby-ant
 
 ---
+## v0.2.0 [2021-09-22] Michael Granger <ged@FaerieMUD.org>
+
+Enhancements:
+
+- Add channel period, search timeout, and introspection methods
+- Add Ant.initialized? predicate
+- Make the default response and event callback modules more useful.
+
 
 ## v0.1.0 [2021-08-26] Michael Granger <ged@FaerieMUD.org>
 

data/README.md

@@ -57,6 +57,12 @@ This task will install dependencies, and do any other necessary setup for develo
 
 ## License
 
+Portions of this code are from StaticCling, and are used under the
+terms of the 3-Clause BSD License. Specifics can be found in the
+appropriate files.
+
+This software is:
+
 Copyright (c) 2021, Ravn Group
 
 Permission is hereby granted, free of charge, to any person obtaining
@@ -82,3 +88,4 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 [ant]: https://www.thisisant.com/
 [antstick]: https://buy.garmin.com/en-US/US/p/10997/pn/010-01058-00
 [antsdk]: https://www.thisisant.com/developer/resources/downloads/#software_tab
+

data/ext/ant_ext/ant_ext.c

@@ -225,6 +225,17 @@ rant_s_init( int argc, VALUE *argv, VALUE _module )
 }
 
 
+static VALUE
+rant_s_initialized_p( VALUE _module )
+{
+#ifdef HAVE_ANT_ISINITIALIZED
+	const bool initialized = ANT_IsInitialized();
+	return initialized ? Qtrue : Qfalse;
+#else
+	rb_notimplement();
+#endif
+}
+
 
 /*
  * call-seq:
@@ -291,7 +302,7 @@ rant_s_set_network_key( VALUE _module, VALUE network_number, VALUE key )
 	}
 
 	if ( !ANT_SetNetworkKey(ucNetNumber, (unsigned char *)pucKey) ) {
-		rb_raise( rb_eRuntimeError, "could not set the network key." );
+		rant_log( "error", "could not set the network key." );
 	}
 
 	return Qtrue;
@@ -463,6 +474,56 @@ rant_s_on_response( int argc, VALUE *argv, VALUE module )
 }
 
 
+/*
+ * call-seq:
+ *    Ant.request_capabilities
+ *
+ * Request the current ANT device's capabilities. These will be delivered
+ * via a callback to the #on_capabilities response callback, which by default
+ * extracts them into a Hash which is stored at Ant.capabilities.
+ *
+ */
+static VALUE
+rant_s_request_capabilities( VALUE module )
+{
+	bool rval = ANT_RequestMessage( 0, MESG_CAPABILITIES_ID );
+	return rval ? Qtrue : Qfalse;
+}
+
+
+/*
+ * call-seq:
+ *    Ant.request_serial_num
+ *
+ * Request the current ANT device's serial number. The result will be delivered
+ * via a callback to the #on_get_serial_num response callback, which by default
+ * extracts it and stores it at Ant.serial_number.
+ *
+ */
+static VALUE
+rant_s_request_serial_num( VALUE module )
+{
+	bool rval = ANT_RequestMessage( 0, MESG_GET_SERIAL_NUM_ID );
+	return rval ? Qtrue : Qfalse;
+}
+
+
+/*
+ * call-seq:
+ *    Ant.request_version
+ *
+ * Request the current device's ANT version. The result will be delivered
+ * via a callback to the #on_version response callback, which by default
+ * extracts it and stores it at Ant.hardware_version.
+ *
+ */
+static VALUE
+rant_s_request_version( VALUE module )
+{
+	bool rval = ANT_RequestMessage( 0, MESG_VERSION_ID );
+	return rval ? Qtrue : Qfalse;
+}
+
 
 /*
  * call-seq:
@@ -508,6 +569,7 @@ Init_ant_ext()
 	rb_define_singleton_method( rant_mAnt, "device_serial_number", rant_s_device_serial_number, 0 );
 
 	rb_define_singleton_method( rant_mAnt, "init", rant_s_init, -1 );
+	rb_define_singleton_method( rant_mAnt, "initialized?", rant_s_initialized_p, 0 );
 	// rb_define_singleton_method( rant_mAnt, "init_ext", rant_s_init_ext, 4 );
 	rb_define_singleton_method( rant_mAnt, "close", rant_s_close, 0 );
 	rb_define_singleton_method( rant_mAnt, "reset", rant_s_reset, 0 );
@@ -521,6 +583,10 @@ Init_ant_ext()
 	rb_define_singleton_method( rant_mAnt, "on_response", rant_s_on_response, -1 );
 	// EXPORT void ANT_UnassignAllResponseFunctions(); //Unassigns all response functions
 
+	rb_define_singleton_method( rant_mAnt, "request_capabilities", rant_s_request_capabilities, 0 );
+	rb_define_singleton_method( rant_mAnt, "request_serial_num", rant_s_request_serial_num, 0 );
+	rb_define_singleton_method( rant_mAnt, "request_version", rant_s_request_version, 0 );
+
 	rb_define_singleton_method( rant_mAnt, "log_directory=", rant_s_log_directory_eq, 1 );
 
 
@@ -536,6 +602,7 @@ Init_ant_ext()
 	EXPOSE_CONST( ANT_EXT_STRING_SIZE );
 	EXPOSE_CONST( ANT_EXT_MESG_BITFIELD_DEVICE_ID );
 	EXPOSE_CONST( ANT_EXT_MESG_BIFIELD_EXTENSION );
+	rb_define_const( rant_mAnt, "ANT_EXT_MESG_BITFIELD_EXTENSION", INT2FIX(ANT_EXT_MESG_BIFIELD_EXTENSION) );
 	EXPOSE_CONST( ANT_EXT_MESG_BITFIELD_OVERWRITE_SHARED_ADR );
 	EXPOSE_CONST( ANT_EXT_MESG_BITFIELD_TRANSMISSION_TYPE );
 
@@ -617,6 +684,9 @@ Init_ant_ext()
 	EXPOSE_CONST( CAPABILITIES_SELECTIVE_DATA_UPDATE_ENABLED );
 	EXPOSE_CONST( CAPABILITIES_ENCRYPTED_CHANNEL_ENABLED );
 
+	// Not in the header; this is taken from 9.5.7.4, ANT Message Protocol and Usage v5.1
+	rb_define_const( rant_mAnt, "CAPABILITIES_RFACTIVE_NOTIFICATION_ENABLED", INT2FIX(0) );
+
 	EXPOSE_CONST( CHANNEL_NUMBER_MASK );
 	EXPOSE_CONST( SEQUENCE_NUMBER_MASK );
 	EXPOSE_CONST( SEQUENCE_NUMBER_ROLLOVER );

data/ext/ant_ext/channel.c

@@ -128,6 +128,11 @@ rant_channel_init( VALUE self, VALUE channel_number, VALUE channel_type, VALUE n
 	rb_iv_set( self, "@network_number", network_number );
 	rb_iv_set( self, "@extended_options", extended_options );
 
+	rb_iv_set( self, "@device_type", Qnil );
+	rb_iv_set( self, "@device_number", Qnil );
+	rb_iv_set( self, "@transmission_type", Qnil );
+	rb_iv_set( self, "@rf_frequency", Qnil );
+
 	rb_hash_aset( registry, channel_number, self );
 
 	return self;
@@ -173,8 +178,8 @@ rant_channel_set_channel_id( int argc, VALUE *argv, VALUE self )
 	rb_scan_args( argc, argv, "31", &device_number, &device_type, &transmission_type, &timeout );
 
 	usDeviceNumber = NUM2USHORT( device_number );
-	ucDeviceType = NUM2USHORT( device_type );
-	ucTransmissionType = NUM2USHORT( transmission_type );
+	ucDeviceType = NUM2CHR( device_type );
+	ucTransmissionType = NUM2CHR( transmission_type );
 
 	if ( RTEST(timeout) )
 		ulResponseTime = NUM2UINT( timeout );
@@ -186,13 +191,114 @@ rant_channel_set_channel_id( int argc, VALUE *argv, VALUE self )
 		rb_raise( rb_eRuntimeError, "Failed to set the channel id." );
 	}
 
+	rb_iv_set( self, "@device_type", device_type );
+	rb_iv_set( self, "@device_number", device_number );
+	rb_iv_set( self, "@transmission_type", transmission_type );
+
+	return Qtrue;
+}
+
+
+/*
+ * call-seq:
+ *    channel.set_channel_period( period, timeout=0 )
+ *
+ * This message configures the messaging +period+ of a specific channel where:
+ * Messaging period = channel period time +period+ * 32768.
+ *
+ * E.g.: To send or receive a message at 4Hz, set the channel period to 8192 (32768/4).
+ *
+ * Note: The minimum acceptable channel period is difficult to specify as it is
+ * system dependent and depends on the number of configured channels and their use.
+ * Caution should be used to appropriately test the system when high data rates are
+ * used, especially in combination with multiple channels.
+ *
+ */
+static VALUE
+rant_channel_set_channel_period( int argc, VALUE *argv, VALUE self )
+{
+	rant_channel_t *ptr = rant_get_channel( self );
+	VALUE period, timeout;
+	unsigned int ulResponseTime = 0;
+	unsigned short usMesgPeriod;
+	bool result;
+
+	rb_scan_args( argc, argv, "11", &period, &timeout );
+
+	usMesgPeriod = NUM2USHORT( period );
+	if ( RTEST(timeout) )
+		ulResponseTime = NUM2UINT( timeout );
+
+	result = ANT_SetChannelPeriod_RTO( ptr->channel_num, usMesgPeriod, ulResponseTime );
+
+	if ( !result )
+		rb_raise( rb_eRuntimeError, "Failed to set the channel period." );
+
+	return Qtrue;
+}
+
+
+/*
+ * call-seq:
+ *    channel.set_channel_search_timeout( search_timeout, timeout=0 )
+ *
+ * Configure the length of time that the receiver will search for a channel
+ * before timing out. Note that a value of zero will disable high priority
+ * search mode, and a value of 255 sets an infinite search time-out. The
+ * exception to this is the AP1 module, which has only a high priority search
+ * mode. For AP1 only, a value of 0 is an immediate search timeout, and a value
+ * of 255 corresponds to approximately 10.5 minutes.
+ *
+ */
+static VALUE
+rant_channel_set_channel_search_timeout( int argc, VALUE *argv, VALUE self )
+{
+	rant_channel_t *ptr = rant_get_channel( self );
+	VALUE search_timeout, timeout;
+	unsigned int ulResponseTime = 0;
+	unsigned char ucSearchTimeout;
+	bool result;
+
+	rb_scan_args( argc, argv, "11", &search_timeout, &timeout );
+
+	ucSearchTimeout = NUM2CHR( search_timeout );
+	if ( RTEST(timeout) )
+		ulResponseTime = NUM2UINT( timeout );
+
+	result = ANT_SetChannelSearchTimeout_RTO( ptr->channel_num, ucSearchTimeout, ulResponseTime );
+
+	if ( !result )
+		rb_raise( rb_eRuntimeError, "Failed to set the channel search timeout." );
+
+	return Qtrue;
+}
+
+
+/*
+ * call-seq:
+ *    channel.set_channel_rf_freq( frequency )
+ *
+ * Set the ANT RF +frequency+.
+ *
+ */
+static VALUE
+rant_channel_set_channel_rf_freq( VALUE self, VALUE frequency )
+{
+	rant_channel_t *ptr = rant_get_channel( self );
+	unsigned short ucRFFreq = NUM2USHORT( frequency );
+
+	if ( ucRFFreq > 124 ) {
+		rb_raise( rb_eArgError, "frequency must be between 0 and 124." );
+	}
+
+	ANT_SetChannelRFFreq( ptr->channel_num, ucRFFreq );
+
+	rb_iv_set( self, "@rf_frequency", frequency );
+
 	return Qtrue;
 }
 
 
-// ANT_SetChannelPeriod_RTO(UCHAR ucANTChannel_, USHORT usMesgPeriod_, ULONG ulResponseTime_);
-// ANT_SetChannelSearchTimeout_RTO(UCHAR ucANTChannel_, UCHAR ucSearchTimeout_, ULONG ulResponseTime_);
-// ANT_SetChannelRFFreq_RTO(UCHAR ucANTChannel_, UCHAR ucRFFreq_, ULONG ulResponseTime_);
 
 
 /*
@@ -450,29 +556,6 @@ rant_channel_send_broadcast_data( VALUE self, VALUE data )
 }
 
 
-/*
- * call-seq:
- *    channel.set_channel_rf_freq( frequency )
- *
- * Set the ANT RF +frequency+.
- *
- */
-static VALUE
-rant_channel_set_channel_rf_freq( VALUE self, VALUE frequency )
-{
-	rant_channel_t *ptr = rant_get_channel( self );
-	unsigned short ucRFFreq = NUM2USHORT( frequency );
-
-	if ( ucRFFreq > 124 ) {
-		rb_raise( rb_eArgError, "frequency must be between 0 and 124." );
-	}
-
-	ANT_SetChannelRFFreq( ptr->channel_num, ucRFFreq );
-
-	return Qtrue;
-}
-
-
 void
 init_ant_channel()
 {
@@ -501,11 +584,15 @@ init_ant_channel()
 	rb_attr( rant_cAntChannel, rb_intern("network_number"), 1, 0, 0 );
 	rb_attr( rant_cAntChannel, rb_intern("extended_options"), 1, 0, 0 );
 
+	rb_attr( rant_cAntChannel, rb_intern("device_number"), 1, 0, 0 );
+	rb_attr( rant_cAntChannel, rb_intern("device_type"), 1, 0, 0 );
+	rb_attr( rant_cAntChannel, rb_intern("transmission_type"), 1, 0, 0 );
+	rb_attr( rant_cAntChannel, rb_intern("rf_frequency"), 1, 0, 0 );
+
 	rb_define_method( rant_cAntChannel, "set_channel_id", rant_channel_set_channel_id, -1 );
-	// rb_define_method( rant_cAntChannel, "set_channel_period",
-	// rant_channel_set_channel_period, -1 );
-	// rb_define_method( rant_cAntChannel, "set_channel_search_timeout",
-	// rant_channel_set_channel_search_timeout, -1 );
+	rb_define_method( rant_cAntChannel, "set_channel_period", rant_channel_set_channel_period, -1 );
+	rb_define_method( rant_cAntChannel, "set_channel_search_timeout",
+		rant_channel_set_channel_search_timeout, -1 );
 	rb_define_method( rant_cAntChannel, "set_channel_rf_freq", rant_channel_set_channel_rf_freq, 1 );
 
 	rb_define_method( rant_cAntChannel, "open", rant_channel_open, -1 );

data/ext/ant_ext/extconf.rb

@@ -14,6 +14,7 @@ have_header( 'ruby/thread.h' ) or
 	abort "Your Ruby is too old!"
 
 have_func( 'ANT_Init', 'libant.h' )
+have_func( 'ANT_IsInitialized', 'libant.h' )
 have_func( 'ANT_LibVersion', 'libant.h' )
 have_func( 'ANT_GetDeviceSerialNumber', 'libant.h' )
 

data/lib/ant/channel/event_callbacks.rb

@@ -13,8 +13,8 @@ require 'ant/mixins'
 # Refs:
 # * 9.5.6.1 Channel Response / Event (0x40) [ANT Message Protocol and Usage, Rev 5.1]
 module Ant::Channel::EventCallbacks
-	extend Loggability
-	include Ant::DataUtilities
+	extend Loggability,
+		Ant::DataUtilities
 
 
 	# Mapping of response message IDs to handler methods
@@ -62,13 +62,9 @@ module Ant::Channel::EventCallbacks
 	end
 
 
-	###############
-	module_function
-	###############
-
 	### Default callback hook -- handles event callbacks.
 	def handle_event_callback( channel_num, event_id, data )
-		handler_method = HANDLER_METHODS[ event_id ] or
+		handler_method = Ant::Channel::EventCallbacks::HANDLER_METHODS[ event_id ] or
 			raise "Unhandled channel event %p" % [ event_id ]
 
 		if self.respond_to?( handler_method )
@@ -81,10 +77,10 @@ module Ant::Channel::EventCallbacks
 
 	### Handle an TX event.
 	def on_event_tx( channel_num, data )
-		# self.log.info "Broadcast message on channel %d was transmitted." % [ channel_num ]
-		data = SecureRandom.bytes( 8 )
-		self.log.info "Sending our own broadcast data: \n%s" % [ hexdump(data) ]
-		self.send_broadcast_data( data )
+		channel = Ant::Channel.registry[ channel_num ]
+		self.log.debug "%p ready for transmission." % [ channel ]
+		ident = [ 1, 33 ].pack( "CC" )
+		channel.send_broadcast_data( ident )
 	end
 
 
@@ -148,7 +144,7 @@ module Ant::Channel::EventCallbacks
 			usDeviceNumber     = data.bytes[10] | (data.bytes[11] << 8)
 			ucDeviceType       = data.bytes[12]
 			ucTransmissionType = data.bytes[13]
-			self.log.info "Got an acknowledge on Chan ID(%d/%d/%d)" %
+			self.log.debug "Got an acknowledge on Chan ID(%d/%d/%d)" %
 				[usDeviceNumber, ucDeviceType, ucTransmissionType]
 		end
 
@@ -162,7 +158,7 @@ module Ant::Channel::EventCallbacks
 			usDeviceNumber     = data.bytes[10] | (data.bytes[11] << 8)
 			ucDeviceType       = data.bytes[12]
 			ucTransmissionType = data.bytes[13]
-			self.log.info "Got a burst on Chan ID(%d/%d/%d)" %
+			self.log.debug "Got a burst on Chan ID(%d/%d/%d)" %
 				[usDeviceNumber, ucDeviceType, ucTransmissionType]
 		end
 
@@ -176,7 +172,7 @@ module Ant::Channel::EventCallbacks
 			usDeviceNumber     = data.bytes[10] | (data.bytes[11] << 8)
 			ucDeviceType       = data.bytes[12]
 			ucTransmissionType = data.bytes[13]
-			self.log.info "Got a broadcast on Chan ID(%d/%d/%d)" %
+			self.log.debug "Got a broadcast on Chan ID(%d/%d/%d)" %
 				[usDeviceNumber, ucDeviceType, ucTransmissionType]
 		end
 
@@ -185,7 +181,7 @@ module Ant::Channel::EventCallbacks
 
 
 	def on_event_rx_acknowledged( channel_num, data )
-		self.log.info "Acknowledged: Rx:\n%s" % [ hexdump(data[1..9]) ]
+		self.log.debug "Acknowledged: Rx [%d]:\n%s" % [ data.bytes[0], Ant::DataUtilities.hexdump(data[1..9]) ]
 	end
 
 
@@ -193,12 +189,12 @@ module Ant::Channel::EventCallbacks
 		channel = (data.bytes[0] & CHANNEL_NUMBER_MASK) >> 5
 		sequence_num = data.bytes[0] & SEQUENCE_NUMBER_MASK
 
-		self.log.info "Burst (0x%02x): Rx: %d:\n%s" % [ channel, sequence_num, hexdump(data[1..9]) ]
+		self.log.debug "Burst (0x%02x): Rx: %d:\n%s" % [ channel, sequence_num, Ant::DataUtilities.hexdump(data[1..9]) ]
 	end
 
 
 	def on_event_rx_broadcast( channel_num, data )
-		self.log.info "Broadcast: Rx:\n%s" % [ hexdump(data[1..9]) ]
+		self.log.debug "Broadcast: Rx [%d]:\n%s" % [ data.bytes[0], Ant::DataUtilities.hexdump(data[1..9]) ]
 	end
 
 

data/lib/ant/channel.rb

@@ -9,6 +9,7 @@ require 'ant' unless defined?( Ant )
 class Ant::Channel
 	extend Loggability
 
+
 	# The default network number
 	DEFAULT_NETWORK_NUMBER = 0
 
@@ -20,7 +21,8 @@ class Ant::Channel
 	# Autoloads
 	#
 
-	autoload :EventCallbacks, 'ant/channel/event_callbacks'
+	require 'ant/channel/event_callbacks'
+	include Ant::Channel::EventCallbacks
 
 
 	# Loggability API -- log to the Ant logger
@@ -44,23 +46,68 @@ class Ant::Channel
 
 
 	### Set up the given +mod+ as the handler module for channel events.
-	def set_event_handlers( object=Ant::Channel::EventCallbacks )
+	def set_event_handlers( object=self )
 		self.on_event( &object.method(:handle_event_callback) )
 	end
 
 
+	### Return the ANT channel ID if one has been assigned.
+	def channel_id
+		device_number     = self.device_number or return nil
+		device_type       = self.device_type & 0x7f
+		pairing_bit       = self.device_type & 0x80
+		transmission_type = self.transmission_type
+
+		return "%d/%d/%d%s" % [
+			device_number,
+			device_type,
+			transmission_type,
+			pairing_bit.nonzero? ? '+' : '',
+		]
+	end
+
+
+	### Return a human-readable description of the channel type.
+	def channel_type_description
+		case self.channel_type
+		when Ant::PARAMETER_RX_NOT_TX
+			return :slave
+		when Ant::PARAMETER_TX_NOT_RX
+			return :master
+		when Ant::PARAMETER_SHARED_CHANNEL
+			return :shared
+		when Ant::PARAMETER_NO_TX_GUARD_BAND
+			return :no_tx_guard_band
+		when Ant::PARAMETER_ALWAYS_RX_WILD_CARD_SEARCH_ID
+			return :always_rx_wild_card_search_id
+		when Ant::PARAMETER_RX_ONLY
+			return :rx_only
+		else
+			return nil
+		end
+	end
+
+
+	### Returns +true+ if the channel is not closed.
+	def open?
+		return !self.closed?
+	end
+
+
 	### Return a human-readable version of the object suitable for debugging.
 	def inspect
-		return "#<%p:%#x {%d} %#02x on network %d: %d%s>" % [
+		return "#<%p:%#x %s {%s} #%d @%dMHz on network %d%s>" % [
 			self.class,
 			self.object_id,
+			self.channel_type_description,
+			self.channel_id || '-',
 			self.channel_number,
-			self.channel_type,
+			self.rf_frequency + 2400,
 			self.network_number,
-			self.extended_options,
 			self.closed? ? " (closed)" : "",
 		]
 	end
 
 end # class Ant::Channel
 
+

data/lib/ant/response_callbacks.rb

@@ -4,6 +4,7 @@
 require 'loggability'
 
 require 'ant' unless defined?( Ant )
+require 'ant/bitvector'
 
 
 # A module that handles response callbacks by logging them.
@@ -16,91 +17,50 @@ module Ant::ResponseCallbacks
 
 	# Mapping of response message IDs to handler methods
 	HANDLER_METHODS = {
+		Ant::Message::MESG_STARTUP_MESG_ID              => :on_startup_mesg,
+
+		Ant::Message::MESG_CAPABILITIES_ID              => :on_capabilities,
+		Ant::Message::MESG_CHANNEL_STATUS_ID            => :on_channel_status,
 		Ant::Message::MESG_VERSION_ID                   => :on_version,
+		Ant::Message::MESG_CHANNEL_ID_ID                => :on_channel_id,
+		Ant::Message::MESG_EVENT_BUFFERING_CONFIG_ID    => :on_event_buffering_config,
+		Ant::Message::MESG_GET_SERIAL_NUM_ID            => :on_get_serial_num,
+
 		Ant::Message::MESG_RESPONSE_EVENT_ID            => :on_response_event,
 
-		Ant::Message::MESG_UNASSIGN_CHANNEL_ID          => :on_unassign_channel,
+		Ant::Message::MESG_NETWORK_KEY_ID               => :on_network_key,
 		Ant::Message::MESG_ASSIGN_CHANNEL_ID            => :on_assign_channel,
-		Ant::Message::MESG_CHANNEL_MESG_PERIOD_ID       => :on_channel_mesg_period,
-		Ant::Message::MESG_CHANNEL_SEARCH_TIMEOUT_ID    => :on_channel_search_timeout,
+		Ant::Message::MESG_UNASSIGN_CHANNEL_ID          => :on_unassign_channel,
 		Ant::Message::MESG_CHANNEL_RADIO_FREQ_ID        => :on_channel_radio_freq,
-		Ant::Message::MESG_NETWORK_KEY_ID               => :on_network_key,
-		Ant::Message::MESG_RADIO_TX_POWER_ID            => :on_radio_tx_power,
-		Ant::Message::MESG_RADIO_CW_MODE_ID             => :on_radio_cw_mode,
-		Ant::Message::MESG_SYSTEM_RESET_ID              => :on_system_reset,
 		Ant::Message::MESG_OPEN_CHANNEL_ID              => :on_open_channel,
+
+		Ant::Message::MESG_RX_EXT_MESGS_ENABLE_ID       => :on_rx_ext_mesgs_enable,
 		Ant::Message::MESG_CLOSE_CHANNEL_ID             => :on_close_channel,
 		Ant::Message::MESG_REQUEST_ID                   => :on_request,
 
 		Ant::Message::MESG_BROADCAST_DATA_ID            => :on_broadcast_data,
 		Ant::Message::MESG_ACKNOWLEDGED_DATA_ID         => :on_acknowledged_data,
 		Ant::Message::MESG_BURST_DATA_ID                => :on_burst_data,
+		Ant::Message::MESG_ADV_BURST_DATA_ID            => :on_adv_burst_data,
 
-		Ant::Message::MESG_CHANNEL_ID_ID                => :on_channel_id,
-		Ant::Message::MESG_CHANNEL_STATUS_ID            => :on_channel_status,
-		Ant::Message::MESG_RADIO_CW_INIT_ID             => :on_radio_cw_init,
-		Ant::Message::MESG_CAPABILITIES_ID              => :on_capabilities,
-
-		Ant::Message::MESG_STACKLIMIT_ID                => :on_stacklimit,
-
-		Ant::Message::MESG_SCRIPT_DATA_ID               => :on_script_data,
-		Ant::Message::MESG_SCRIPT_CMD_ID                => :on_script_cmd,
-
-		Ant::Message::MESG_ID_LIST_ADD_ID               => :on_id_list_add,
-		Ant::Message::MESG_CRYPTO_ID_LIST_ADD_ID        => :on_crypto_id_list_add,
-		Ant::Message::MESG_ID_LIST_CONFIG_ID            => :on_id_list_config,
-		Ant::Message::MESG_CRYPTO_ID_LIST_CONFIG_ID     => :on_crypto_id_list_config,
-		Ant::Message::MESG_OPEN_RX_SCAN_ID              => :on_open_rx_scan,
-
-		Ant::Message::MESG_EXT_CHANNEL_RADIO_FREQ_ID    => :on_ext_channel_radio_freq_id,
-		Ant::Message::MESG_EXT_BROADCAST_DATA_ID        => :on_ext_broadcast_data,
-		Ant::Message::MESG_EXT_ACKNOWLEDGED_DATA_ID     => :on_ext_acknowledged_data,
-		Ant::Message::MESG_EXT_BURST_DATA_ID            => :on_ext_burst_data,
-
-		Ant::Message::MESG_CHANNEL_RADIO_TX_POWER_ID    => :on_channel_radio_tx_power,
-		Ant::Message::MESG_GET_SERIAL_NUM_ID            => :on_get_serial_num,
-		Ant::Message::MESG_GET_TEMP_CAL_ID              => :on_get_temp_cal,
-		Ant::Message::MESG_SET_LP_SEARCH_TIMEOUT_ID     => :on_set_lp_search_timeout,
-		Ant::Message::MESG_SET_TX_SEARCH_ON_NEXT_ID     => :on_set_tx_search_on_next,
-		Ant::Message::MESG_SERIAL_NUM_SET_CHANNEL_ID_ID => :on_serial_num_set_channel_id,
-		Ant::Message::MESG_RX_EXT_MESGS_ENABLE_ID       => :on_rx_ext_mesgs_enable,
-		Ant::Message::MESG_RADIO_CONFIG_ALWAYS_ID       => :on_radio_config_always,
-		Ant::Message::MESG_ENABLE_LED_FLASH_ID          => :on_enable_led_flash,
-		Ant::Message::MESG_XTAL_ENABLE_ID               => :on_xtal_enable,
-		Ant::Message::MESG_ANTLIB_CONFIG_ID             => :on_antlib_config,
-		Ant::Message::MESG_STARTUP_MESG_ID              => :on_startup_mesg,
-		Ant::Message::MESG_AUTO_FREQ_CONFIG_ID          => :on_auto_freq_config,
-		Ant::Message::MESG_PROX_SEARCH_CONFIG_ID        => :on_prox_search_config,
+		Ant::Message::MESG_CHANNEL_MESG_PERIOD_ID       => :on_channel_mesg_period,
+		Ant::Message::MESG_CHANNEL_SEARCH_TIMEOUT_ID    => :on_channel_search_timeout,
 
-		Ant::Message::MESG_ADV_BURST_DATA_ID            => :on_adv_burst_data,
-		Ant::Message::MESG_EVENT_BUFFERING_CONFIG_ID    => :on_event_buffering_config,
+		Ant::Message::MESG_RADIO_TX_POWER_ID            => :on_radio_tx_power,
 
-		Ant::Message::MESG_SET_SEARCH_CH_PRIORITY_ID    => :on_set_search_ch_priority,
-
-		Ant::Message::MESG_HIGH_DUTY_SEARCH_MODE_ID     => :on_high_duty_search_mode,
-		Ant::Message::MESG_CONFIG_ADV_BURST_ID          => :on_config_adv_burst,
-		Ant::Message::MESG_EVENT_FILTER_CONFIG_ID       => :on_event_filter_config,
-		Ant::Message::MESG_SDU_CONFIG_ID                => :on_sdu_config,
-		Ant::Message::MESG_SDU_SET_MASK_ID              => :on_sdu_set_mask,
-		Ant::Message::MESG_USER_CONFIG_PAGE_ID          => :on_user_config_page,
-		Ant::Message::MESG_ENCRYPT_ENABLE_ID            => :on_encrypt_enable,
-		Ant::Message::MESG_SET_CRYPTO_KEY_ID            => :on_set_crypto_key,
-		Ant::Message::MESG_SET_CRYPTO_INFO_ID           => :on_set_crypto_info,
-		Ant::Message::MESG_CUBE_CMD_ID                  => :on_cube_cmd,
-
-		Ant::Message::MESG_ACTIVE_SEARCH_SHARING_ID     => :on_active_search_sharing,
-		Ant::Message::MESG_NVM_CRYPTO_KEY_OPS_ID        => :on_nvm_crypto_key_ops,
+		# :TODO: There are many other MESG_ constants, but I think most or all of
+		# them are for the serial protocol.
 	}
 
 
 
 	### Default callback hook -- handles response callbacks.
 	def self::handle_response_callback( channel_num, message_id, data )
-		handler_method = HANDLER_METHODS[ message_id ] or
+		handler_method = Ant::ResponseCallbacks::HANDLER_METHODS[ message_id ] or
 			raise "Unhandled response message ID %p" % [ message_id ]
 
-		if self.respond_to?( handler_method )
-			self.public_send( handler_method, channel_num, data )
+		if self.respond_to?( handler_method, true )
+			self.send( handler_method, channel_num, data )
 		else
 			Ant::ResponseCallbacks.log_response_callback( channel_num, handler_method, message_id, data )
 		end
@@ -124,7 +84,9 @@ module Ant::ResponseCallbacks
 
 	### Handle version number response messages.
 	def on_version( channel_num, data )
-		self.log.info "ANT Version %s" % [ data ]
+		version = data.strip
+		self.log.info "ANT Version %s" % [ version ]
+		Ant.instance_variable_set( :@hardware_version, version )
 	end
 
 
@@ -135,6 +97,19 @@ module Ant::ResponseCallbacks
 	end
 
 
+	### Log a success or an error message for a response event message.
+	def log_response_event( channel_num, data, err_desc, log_desc )
+		status = data.bytes[ 2 ]
+		channel = Ant::Channel.registry[ channel_num ]
+
+		if status.nonzero?
+			self.log.error "Error while %s on %p: %#02x" % [ err_desc, channel, status ]
+		else
+			self.log.info( log_desc )
+		end
+	end
+
+
 	### Handle startup response messages.
 	def on_startup_mesg( channel_num, data )
 		reason = case data.bytes[ 0 ]
@@ -166,13 +141,15 @@ module Ant::ResponseCallbacks
 
 	### Handle channel assignment event response messages.
 	def on_assign_channel( channel_num, data )
-		self.log_response_event( channel_num, data, "assigning channel", "Channel assigned." )
+		self.log_response_event( channel_num, data, "assigning channel",
+			"Channel %d assigned." % [channel_num] )
 	end
 
 
 	### Handle channel unassignment event response messages.
-	def on_unassign_channel
-		self.log_response_event( channel_num, data, "unassigning channel", "Channel unassigned." )
+	def on_unassign_channel( channel_num, data )
+		self.log_response_event( channel_num, data, "unassigning channel",
+			"Channel %d unassigned." % [channel_num] )
 	end
 
 
@@ -201,328 +178,125 @@ module Ant::ResponseCallbacks
 	end
 
 
-	### Log a success or an error message for a response event message.
-	def log_response_event( channel_num, data, err_desc, log_desc )
-		status = data.bytes[ 2 ]
-		if status.nonzero?
-			self.log.error "Error while %s: %#02x" % [ err_desc, status ]
-		else
-			self.log.info( log_desc )
-		end
-	end
-
-
 	### Handle channel_mesg_period response events.
 	def on_channel_mesg_period( channel_num, data )
-		self.log_response_event( channel_num, data, "channel_mesg_period", "Channel period assigned." )
+		self.log_response_event( channel_num, data, "setting channel period", "Channel period assigned." )
 	end
 
 
 	### Handle channel_search_timeout response event.
 	def on_channel_search_timeout( channel_num, data )
-		self.log_response_event( channel_num, data, "channel_search_timeout", "Channel assigned." )
+		self.log_response_event( channel_num, data, "setting search timeout", "Search timeout." )
 	end
 
 
 	### Handle radio_tx_power response event.
 	def on_radio_tx_power( channel_num, data )
-		self.log_response_event( channel_num, data, "radio_tx_power", "Channel assigned." )
-	end
-
-
-	### Handle radio_cw_mode response event.
-	def on_radio_cw_mode( channel_num, data )
-		self.log_response_event( channel_num, data, "radio_cw_mode", "Channel assigned." )
-	end
-
-
-	### Handle system_reset response event.
-	def on_system_reset( channel_num, data )
-		self.log_response_event( channel_num, data, "system_reset", "Channel assigned." )
-	end
-
-
-	### Handle request response event.
-	def on_request( channel_num, data )
-		self.log_response_event( channel_num, data, "request", "Channel assigned." )
+		self.log_response_event( channel_num, data, "setting transmit power", "Transmit power changed." )
 	end
 
 
 	### Handle broadcast_data response event.
 	def on_broadcast_data( channel_num, data )
-		self.log_response_event( channel_num, data, "broadcast_data", "Channel assigned." )
+		self.log_response_event( channel_num, data, "sending broadcast data", "Sent broadcast data." )
 	end
 
 
 	### Handle acknowledged_data response event.
 	def on_acknowledged_data( channel_num, data )
-		self.log_response_event( channel_num, data, "acknowledged_data", "Channel assigned." )
+		self.log_response_event( channel_num, data, "sending acked data", "Acked data sent." )
 	end
 
 
 	### Handle burst_data response event.
 	def on_burst_data( channel_num, data )
-		self.log_response_event( channel_num, data, "burst_data", "Channel assigned." )
+		self.log_response_event( channel_num, data, "sending burst data", "Burst data sent." )
 	end
 
 
 	### Handle channel_status response event.
 	def on_channel_status( channel_num, data )
-		self.log_response_event( channel_num, data, "channel_status", "Channel assigned." )
+		self.log_response_event( channel_num, data, "requesting channel status", "Got channel status." )
 	end
 
 
-	### Handle radio_cw_init response event.
-	def on_radio_cw_init( channel_num, data )
-		self.log_response_event( channel_num, data, "radio_cw_init", "Channel assigned." )
+	### Handle on_rx_ext_mesgs_enable response event.
+	def on_rx_ext_mesgs_enable( channel_num, data )
+		self.log_response_event( channel_num, data, "enabling extended message: not supported",
+			"Enabled extended messages." )
 	end
 
 
 	### Handle capabilities response event.
 	def on_capabilities( channel_num, data )
-		self.log_response_event( channel_num, data, "capabilities", "Channel assigned." )
-	end
-
-
-	### Handle stacklimit response event.
-	def on_stacklimit( channel_num, data )
-		self.log_response_event( channel_num, data, "stacklimit", "Channel assigned." )
-	end
-
-
-	### Handle script_data response event.
-	def on_script_data( channel_num, data )
-		self.log_response_event( channel_num, data, "script_data", "Channel assigned." )
-	end
-
-
-	### Handle script_cmd response event.
-	def on_script_cmd( channel_num, data )
-		self.log_response_event( channel_num, data, "script_cmd", "Channel assigned." )
-	end
-
-
-	### Handle id_list_add response event.
-	def on_id_list_add( channel_num, data )
-		self.log_response_event( channel_num, data, "id_list_add", "Channel assigned." )
-	end
-
-
-	### Handle crypto_id_list_add response event.
-	def on_crypto_id_list_add( channel_num, data )
-		self.log_response_event( channel_num, data, "crypto_id_list_add", "Channel assigned." )
-	end
-
-
-	### Handle id_list_config response event.
-	def on_id_list_config( channel_num, data )
-		self.log_response_event( channel_num, data, "id_list_config", "Channel assigned." )
-	end
-
-
-	### Handle crypto_id_list_config response event.
-	def on_crypto_id_list_config( channel_num, data )
-		self.log_response_event( channel_num, data, "crypto_id_list_config", "Channel assigned." )
-	end
-
-
-	### Handle open_rx_scan response event.
-	def on_open_rx_scan( channel_num, data )
-		self.log_response_event( channel_num, data, "open_rx_scan", "Channel assigned." )
-	end
-
-
-	### Handle ext_channel_radio_freq_id response event.
-	def on_ext_channel_radio_freq_id( channel_num, data )
-		self.log_response_event( channel_num, data, "ext_channel_radio_freq_id", "Channel assigned." )
-	end
-
-
-	### Handle ext_broadcast_data response event.
-	def on_ext_broadcast_data( channel_num, data )
-		self.log_response_event( channel_num, data, "ext_broadcast_data", "Channel assigned." )
-	end
-
-
-	### Handle ext_acknowledged_data response event.
-	def on_ext_acknowledged_data( channel_num, data )
-		self.log_response_event( channel_num, data, "ext_acknowledged_data", "Channel assigned." )
-	end
-
-
-	### Handle ext_burst_data response event.
-	def on_ext_burst_data( channel_num, data )
-		self.log_response_event( channel_num, data, "ext_burst_data", "Channel assigned." )
-	end
-
+		std_opts  = Ant::BitVector.new( data.bytes[2] )
+        adv_opts  = Ant::BitVector.new( data.bytes[3] )
+        adv_opts2 = Ant::BitVector.new( data.bytes[4] )
+        adv_opts3 = Ant::BitVector.new( data.bytes[6] )
+        adv_opts4 = Ant::BitVector.new( data.bytes[7] )
+
+		caps = {
+			max_channels: data.bytes[0],
+			max_networks: data.bytes[1],
+			max_sensrcore_channels: data.bytes[5],
+
+			rx_channels_enabled: std_opts.off?( Ant::CAPABILITIES_NO_RX_CHANNELS ),
+			tx_channels_enabled: std_opts.off?( Ant::CAPABILITIES_NO_TX_CHANNELS ),
+			rx_messages_enabled: std_opts.off?( Ant::CAPABILITIES_NO_RX_MESSAGES ),
+			tx_messages_enabled: std_opts.off?( Ant::CAPABILITIES_NO_TX_MESSAGES ),
+			ackd_messages_enabled: std_opts.off?( Ant::CAPABILITIES_NO_ACKD_MESSAGES ),
+			burst_transfer_enabled: std_opts.off?( Ant::CAPABILITIES_NO_BURST_TRANSFER ),
+
+			overun_underrun: adv_opts.on?( Ant::CAPABILITIES_OVERUN_UNDERRUN ),
+			network_enabled: adv_opts.on?( Ant::CAPABILITIES_NETWORK_ENABLED ),
+			api_version2: adv_opts.on?( Ant::CAPABILITIES_AP1_VERSION_2 ),
+			serial_number_enabled: adv_opts.on?( Ant::CAPABILITIES_SERIAL_NUMBER_ENABLED ),
+			per_channel_tx_power_enabled: adv_opts.on?( Ant::CAPABILITIES_PER_CHANNEL_TX_POWER_ENABLED ),
+			low_priority_search_enabled: adv_opts.on?( Ant::CAPABILITIES_LOW_PRIORITY_SEARCH_ENABLED ),
+			script_enabled: adv_opts.on?( Ant::CAPABILITIES_SCRIPT_ENABLED ),
+			search_list_enabled: adv_opts.on?( Ant::CAPABILITIES_SEARCH_LIST_ENABLED ),
+
+			led_enabled: adv_opts2.on?( Ant::CAPABILITIES_LED_ENABLED ),
+			ext_message_enabled: adv_opts2.on?( Ant::CAPABILITIES_EXT_MESSAGE_ENABLED ),
+			scan_mode_enabled: adv_opts2.on?( Ant::CAPABILITIES_SCAN_MODE_ENABLED ),
+			prox_search_enabled: adv_opts2.on?( Ant::CAPABILITIES_PROX_SEARCH_ENABLED ),
+			ext_assign_enabled: adv_opts2.on?( Ant::CAPABILITIES_EXT_ASSIGN_ENABLED ),
+			antfs_enabled: adv_opts2.on?( Ant::CAPABILITIES_FS_ANTFS_ENABLED ),
+			fit1_enabled: adv_opts2.on?( Ant::CAPABILITIES_FIT1_ENABLED ),
+
+			advanced_burst_enabled: adv_opts3.on?( Ant::CAPABILITIES_ADVANCED_BURST_ENABLED ),
+			event_buffering_enabled: adv_opts3.on?( Ant::CAPABILITIES_EVENT_BUFFERING_ENABLED ),
+			event_filtering_enabled: adv_opts3.on?( Ant::CAPABILITIES_EVENT_FILTERING_ENABLED ),
+			high_duty_search_mode_enabled: adv_opts3.on?( Ant::CAPABILITIES_HIGH_DUTY_SEARCH_MODE_ENABLED ),
+			active_search_sharing_mode_enabled: adv_opts3.on?( Ant::CAPABILITIES_ACTIVE_SEARCH_SHARING_MODE_ENABLED ),
+			selective_data_update_enabled: adv_opts3.on?( Ant::CAPABILITIES_SELECTIVE_DATA_UPDATE_ENABLED ),
+			encrypted_channel_enabled: adv_opts3.on?( Ant::CAPABILITIES_ENCRYPTED_CHANNEL_ENABLED ),
+
+			rfactive_notification_enabled: adv_opts4.on?( Ant::CAPABILITIES_RFACTIVE_NOTIFICATION_ENABLED ),
+		}.freeze
+
+		caplist = caps.keys.select do |cap|
+			caps[ cap ]
+		end
+		self.log.info "ANT Capabilities: %s" % [ caplist.sort.join(' ') ]
 
-	### Handle channel_radio_tx_power response event.
-	def on_channel_radio_tx_power( channel_num, data )
-		self.log_response_event( channel_num, data, "channel_radio_tx_power", "Channel assigned." )
+		Ant.instance_variable_set( :@capabilities, caps );
 	end
 
 
-	### Handle get_serial_num response event.
+	### Handle serial number response event.
 	def on_get_serial_num( channel_num, data )
-		self.log_response_event( channel_num, data, "get_serial_num", "Channel assigned." )
-	end
-
-
-	### Handle get_temp_cal response event.
-	def on_get_temp_cal( channel_num, data )
-		self.log_response_event( channel_num, data, "get_temp_cal", "Channel assigned." )
-	end
-
-
-	### Handle set_lp_search_timeout response event.
-	def on_set_lp_search_timeout( channel_num, data )
-		self.log_response_event( channel_num, data, "set_lp_search_timeout", "Channel assigned." )
-	end
-
-
-	### Handle set_tx_search_on_next response event.
-	def on_set_tx_search_on_next( channel_num, data )
-		self.log_response_event( channel_num, data, "set_tx_search_on_next", "Channel assigned." )
-	end
-
-
-	### Handle serial_num_set_channel_id response event.
-	def on_serial_num_set_channel_id( channel_num, data )
-		self.log_response_event( channel_num, data, "serial_num_set_channel_id", "Channel assigned." )
-	end
-
-
-	### Handle rx_ext_mesgs_enable response event.
-	def on_rx_ext_mesgs_enable( channel_num, data )
-		self.log_response_event( channel_num, data, "rx_ext_mesgs_enable", "Channel assigned." )
-	end
-
-
-	### Handle radio_config_always response event.
-	def on_radio_config_always( channel_num, data )
-		self.log_response_event( channel_num, data, "radio_config_always", "Channel assigned." )
-	end
-
-
-	### Handle enable_led_flash response event.
-	def on_enable_led_flash( channel_num, data )
-		self.log_response_event( channel_num, data, "enable_led_flash", "Channel assigned." )
-	end
-
-
-	### Handle xtal_enable response event.
-	def on_xtal_enable( channel_num, data )
-		self.log_response_event( channel_num, data, "xtal_enable", "Channel assigned." )
-	end
-
-
-	### Handle antlib_config response event.
-	def on_antlib_config( channel_num, data )
-		self.log_response_event( channel_num, data, "antlib_config", "Channel assigned." )
-	end
-
-
-	### Handle auto_freq_config response event.
-	def on_auto_freq_config( channel_num, data )
-		self.log_response_event( channel_num, data, "auto_freq_config", "Channel assigned." )
-	end
+		serial = data.unpack1( 'L<' )
 
-
-	### Handle prox_search_config response event.
-	def on_prox_search_config( channel_num, data )
-		self.log_response_event( channel_num, data, "prox_search_config", "Channel assigned." )
-	end
-
-
-	### Handle adv_burst_data response event.
-	def on_adv_burst_data( channel_num, data )
-		self.log_response_event( channel_num, data, "adv_burst_data", "Channel assigned." )
-	end
-
-
-	### Handle event_buffering_config response event.
-	def on_event_buffering_config( channel_num, data )
-		self.log_response_event( channel_num, data, "event_buffering_config", "Channel assigned." )
-	end
-
-
-	### Handle set_search_ch_priority response event.
-	def on_set_search_ch_priority( channel_num, data )
-		self.log_response_event( channel_num, data, "set_search_ch_priority", "Channel assigned." )
-	end
-
-
-	### Handle high_duty_search_mode response event.
-	def on_high_duty_search_mode( channel_num, data )
-		self.log_response_event( channel_num, data, "high_duty_search_mode", "Channel assigned." )
-	end
-
-
-	### Handle config_adv_burst response event.
-	def on_config_adv_burst( channel_num, data )
-		self.log_response_event( channel_num, data, "config_adv_burst", "Channel assigned." )
-	end
-
-
-	### Handle event_filter_config response event.
-	def on_event_filter_config( channel_num, data )
-		self.log_response_event( channel_num, data, "event_filter_config", "Channel assigned." )
-	end
-
-
-	### Handle sdu_config response event.
-	def on_sdu_config( channel_num, data )
-		self.log_response_event( channel_num, data, "sdu_config", "Channel assigned." )
-	end
-
-
-	### Handle sdu_set_mask response event.
-	def on_sdu_set_mask( channel_num, data )
-		self.log_response_event( channel_num, data, "sdu_set_mask", "Channel assigned." )
-	end
-
-
-	### Handle user_config_page response event.
-	def on_user_config_page( channel_num, data )
-		self.log_response_event( channel_num, data, "user_config_page", "Channel assigned." )
-	end
-
-
-	### Handle encrypt_enable response event.
-	def on_encrypt_enable( channel_num, data )
-		self.log_response_event( channel_num, data, "encrypt_enable", "Channel assigned." )
-	end
-
-
-	### Handle set_crypto_key response event.
-	def on_set_crypto_key( channel_num, data )
-		self.log_response_event( channel_num, data, "set_crypto_key", "Channel assigned." )
+		self.log.debug "ANT device serial number: %d." % [ serial ]
+		Ant.instance_variable_set( :@serial_num, serial )
 	end
 
 
-	### Handle set_crypto_info response event.
-	def on_set_crypto_info( channel_num, data )
-		self.log_response_event( channel_num, data, "set_crypto_info", "Channel assigned." )
-	end
-
-
-	### Handle cube_cmd response event.
-	def on_cube_cmd( channel_num, data )
-		self.log_response_event( channel_num, data, "cube_cmd", "Channel assigned." )
-	end
-
-
-	### Handle active_search_sharing response event.
-	def on_active_search_sharing( channel_num, data )
-		self.log_response_event( channel_num, data, "active_search_sharing", "Channel assigned." )
-	end
-
-
-	### Handle nvm_crypto_key_ops response event.
-	def on_nvm_crypto_key_ops( channel_num, data )
-		self.log_response_event( channel_num, data, "nvm_crypto_key_ops", "Channel assigned." )
+	### Handle request response event.
+	def on_request( channel_num, data )
+		self.log_response_event( channel_num, data, "requesting an unsupported message", "[n/a]" )
 	end
 
-
 end # module Ant::ResponseCallbacks
 

data/lib/ant.rb

@@ -12,7 +12,7 @@ module Ant
 	extend Loggability
 
 	# Package version
-	VERSION = '0.1.0'
+	VERSION = '0.2.0'
 
 	# A Range for matching valid ANT device numbers
 	VALID_DEVICE_NUMBERS = ( 0...65535 ).freeze
@@ -35,6 +35,23 @@ module Ant
 	autoload :DataUtilities, 'ant/mixins'
 
 
+	# Capabilities hash -- set asynchronously by calling Ant.request_capabilities
+	@capabilities = nil
+	singleton_class.attr_reader( :capabilities )
+
+	# Serial number -- set asynchronously by calling Ant.request_serial_num
+	@serial_num = nil
+	singleton_class.attr_reader( :serial_num )
+
+	# Version of ANT supported by the hardware -- set asynchronously by calling
+	# Ant.request_version
+	@hardware_version = nil
+	singleton_class.attr_reader( :hardware_version )
+
+	# Add some convenience aliases
+	singleton_class.alias_method( :is_initialized?, :initialized? )
+
+
 	### Set up the given +object+ as the handler for response callbacks. It must
 	### respond to :handle_response_callback.
 	def self::set_response_handler( object=Ant::ResponseCallbacks )

data/spec/ant_spec.rb

@@ -33,6 +33,15 @@ RSpec.describe( Ant ) do
 	end
 
 
+	it "knows if it's been initialized or not", :hardware do
+		expect( Ant ).to_not be_initialized
+		Ant.init
+		expect( Ant ).to be_initialized
+		Ant.close
+		expect( Ant ).to_not be_initialized
+	end
+
+
 	it "can validate a device number" do
 		expect( described_class.validate_device_number(111) ).to eq( 111 )
 		expect {

data/spec/spec_helper.rb

@@ -20,6 +20,8 @@ RSpec.configure do |config|
 		Ant.init
 		Ant.close
 	rescue => err
+		$stderr.puts "%p while initializing hardware: %s; disabling hardware specs" %
+			[ err.class, err.message ]
 		config.filter_run_excluding( :hardware )
 	end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ant-wireless
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Michael Granger
@@ -34,7 +34,7 @@ cert_chain:
   MCh97sQ/Z/MOusb5+QddBmB+k8EicXyGNl4b5L4XpL7fIQu+Y96TB3JEJlShxFD9
   k9FjI4d9EP54gS/4
   -----END CERTIFICATE-----
-date: 2021-08-26 00:00:00.000000000 Z
+date: 2021-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler