ant-wireless 0.1.0.pre.20210617213631 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47f23b13571d44d37275d309e73bf1b3b1d3b4f7e3c952f95fdf5b73321412b1
-  data.tar.gz: 6bbccd101666ef42d12eab3d9b3d9e653634d97e19d9042f0c8282d74caf3fcb
+  metadata.gz: 0440d58876178ab22b480c72d95830474b407f7b1b366e518a7733a02abdd857
+  data.tar.gz: 2e0eb9be083381e57df2b13843894c33f43a957bff10a30fd06654fee41a5085
 SHA512:
-  metadata.gz: 3cfbf1870872f9747df428d3ac4be4dd71b857bf47beb763f3d30fa517134b5d509e895ed975307b26de7936cee40dfc83f7b938e11679e61bf9e002d058acfb
-  data.tar.gz: e7831b872fabbd850a946c88d053edc604aff86652e0efc6ffee9e593f92e5c52216a7382520765f2793a1e728b4457335ef3b9a999ec3d3eaa00699fdc89c2a
+  metadata.gz: 8237b0332974c4bc1afc2697b4502bb0048dbc00e6caf3ca4f004bc71a0f854fa997b0239d961dd0a0681dbeb3d3bbc370407c4900812233c6ae0a00fef7dbb1
+  data.tar.gz: e2e8f4dff3fc5d60181bd1b7a9f8fa3b5e7683d0c56243ffa0c4645cccc2b1692f738e39fc7f09ea63affaa6d126e4e9a254efbcbb624df14f811a78ccf17e72

data/History.md

@@ -1,5 +1,16 @@
 # 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>
+
+First release.
 

data/README.md

@@ -20,8 +20,13 @@ manner.
 
 ## Prerequisites
 
-* Ruby
-* Garmin USB ANT Stick (https://buy.garmin.com/en-US/US/p/10997/pn/010-01058-00)
+* Ruby 2.7.x or later
+* [Garmin USB ANT Stick][antstick]
+* [ANT SDK][antsdk]
+
+Note that we had trouble compiling the latest ANT SDK on some platforms, so we are currently using a modified version of it with a reworked build system for MacOS and FreeBSD. That is available under the same licensing terms at:
+
+https://github.com/RavnGroup/Garmin-ANT-SDK
 
 
 ## Installation
@@ -52,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
@@ -76,4 +87,5 @@ 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:
@@ -490,7 +551,7 @@ Init_ant_ext()
 	/*
 	 * Document-module: Ant
 	 *
-	 * This is an extension for using the ANT ultra-low power wireless protocol via 
+	 * This is an extension for using the ANT ultra-low power wireless protocol via
 	 * the Garmin USB ANT Stick. ANT can be used to send information
 	 * wirelessly from one device to another device, in a robust and flexible
 	 * manner.
@@ -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,9 @@ 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 );
 
@@ -537,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 );
 
@@ -618,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,12 +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
-
-
-	# Loggability API -- send logs to the Ant logger
-	log_to :ant
+	extend Loggability,
+		Ant::DataUtilities
 
 
 	# Mapping of response message IDs to handler methods
@@ -51,17 +47,8 @@ module Ant::Channel::EventCallbacks
 	SEQUENCE_NUMBER_MASK = 0xE0
 
 
-	### Default callback hook -- handles event callbacks.
-	def handle_event_callback( channel_num, event_id, data )
-		handler_method = HANDLER_METHODS[ event_id ] or
-			raise "Unhandled channel event %p" % [ event_id ]
-
-		if self.respond_to?( handler_method )
-			self.public_send( handler_method, channel_num, data )
-		else
-			Ant::Channel::EventCallbacks.log_event_callback( channel_num, handler_method, event_id, data )
-		end
-	end
+	# Loggability API -- send logs to the Ant logger
+	log_to :ant
 
 
 	### Log the channel event by default.
@@ -75,13 +62,25 @@ module Ant::Channel::EventCallbacks
 	end
 
 
+	### Default callback hook -- handles event callbacks.
+	def handle_event_callback( channel_num, event_id, data )
+		handler_method = Ant::Channel::EventCallbacks::HANDLER_METHODS[ event_id ] or
+			raise "Unhandled channel event %p" % [ event_id ]
+
+		if self.respond_to?( handler_method )
+			self.public_send( handler_method, channel_num, data )
+		else
+			Ant::Channel::EventCallbacks.log_event_callback( channel_num, handler_method, event_id, data )
+		end
+	end
+
+
 	### 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.debug "Sending our own broadcast data: %p." % [ 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
 
 
@@ -139,18 +138,27 @@ module Ant::Channel::EventCallbacks
 	end
 
 
-	# def on_event_rx_flag_acknowledged( channel_num, data )
-	#
-	# end
+	def on_event_rx_flag_acknowledged( channel_num, data )
+		flags = data.bytes[ 9 ]
+		if flags & Ant::ANT_EXT_MESG_BITFIELD_DEVICE_ID
+			usDeviceNumber     = data.bytes[10] | (data.bytes[11] << 8)
+			ucDeviceType       = data.bytes[12]
+			ucTransmissionType = data.bytes[13]
+			self.log.debug "Got an acknowledge on Chan ID(%d/%d/%d)" %
+				[usDeviceNumber, ucDeviceType, ucTransmissionType]
+		end
+
+		self.on_event_rx_acknowledged( channel_num, data )
+	end
+
 
-	### Handle an RX_FLAG_BURST_PACKET event.
 	def on_event_rx_flag_burst_packet( channel_num, data )
 		flags = data.bytes[ 9 ]
 		if flags & Ant::ANT_EXT_MESG_BITFIELD_DEVICE_ID
 			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
 
@@ -158,14 +166,13 @@ module Ant::Channel::EventCallbacks
 	end
 
 
-	### Handle an RX_FLAG_BROADCAST event.
 	def on_event_rx_flag_broadcast( channel_num, data )
 		flags = data.bytes[ 9 ]
 		if flags & Ant::ANT_EXT_MESG_BITFIELD_DEVICE_ID
 			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
 
@@ -173,23 +180,21 @@ module Ant::Channel::EventCallbacks
 	end
 
 
-	# def on_event_rx_acknowledged( channel_num, data )
-	#
-	# end
+	def on_event_rx_acknowledged( channel_num, data )
+		self.log.debug "Acknowledged: Rx [%d]:\n%s" % [ data.bytes[0], Ant::DataUtilities.hexdump(data[1..9]) ]
+	end
 
 
-	### Handle an RX_BURST_PACKET event.
 	def on_event_rx_burst_packet( channel_num, data )
 		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..8]) ]
+		self.log.debug "Burst (0x%02x): Rx: %d:\n%s" % [ channel, sequence_num, Ant::DataUtilities.hexdump(data[1..9]) ]
 	end
 
 
-	### Handle an RX_BROADCAST event.
 	def on_event_rx_broadcast( channel_num, data )
-		self.log.info "Broadcast: Rx:\n%s" % [ hexdump(data[1..8]) ]
+		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
@@ -31,6 +33,7 @@ class Ant::Channel
 
 
 	##
+	# :singleton-method: registry
 	# Channel registry, keyed by channel number.
 	singleton_class.attr_reader( :registry )
 
@@ -43,24 +46,68 @@ class Ant::Channel
 
 
 	### Set up the given +mod+ as the handler module for channel events.
-	def set_event_handlers( mod=Ant::Channel::EventCallbacks )
-		self.extend( mod )
-		self.on_event( &self.method(:handle_event_callback) )
+	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
 
+