ant-wireless 0.1.0.pre.20210810141303 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05bb146cd01ae909001401030d988ca1e14977d6159c5da9ee81736e66a17540
-  data.tar.gz: b9240f153be4b7ca510344f41c94d8ad7bbb8a6dd2f72e41242c18641d772db8
+  metadata.gz: b16333eed832c3068cd6e95d167bffe8132aaba7543ccabd773d809fac840199
+  data.tar.gz: 92d089d1bcf5121dd46477befeabc33e43abbac10de105d3d94d176b54c9af8a
 SHA512:
-  metadata.gz: 415ed825c123a9ca66debe50a52e406da5d83310127956fc8f4caba7b28eddfbb679528be081c5449267ae44a6dd9e820bbbf86ea48af8ba2ac66a2f77445bbf
-  data.tar.gz: 64c3ade415dc32510a003e7cc41d1a61e532113541fd9de22ab5c4d31d8dfa797e099ff5bc05127ddf256438a1bf35a8461c70ebaf44c738af7fb5735dca0450
+  metadata.gz: 51dbc06b6c199f16404fb0d79fd78e10cf53c4ca68e221462d225e1dff171a51f5f1807da2ebe2719e45109e981ece26781090ebd583d4c8c01d6e1539c5e43a
+  data.tar.gz: da1492d614d52e83402c85bbeed0d45d03f7f101bd6b5036ae9bc7a488dfbd5df41ee5aa2a0a3b0a7b4e7019c4d95bc55d0167a3a6e77c1825565ca299ba492e

data/History.md

@@ -1,5 +1,32 @@
 # Release History for ruby-ant
 
 ---
+## v0.3.0 [2021-10-11] Michael Granger <ged@FaerieMUD.org>
 
+Enhancements:
+
+- Add frequency agility config to Channel
+- Add tunable transmit power knob
+
+
+## v0.2.1 [2021-09-30] Michael Granger <ged@FaerieMUD.org>
+
+Bugfixes:
+
+- Add missing files to the manifest
+
+
+
+## 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,13 +302,39 @@ 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;
 }
 
 
+/*
+ * call-seq:
+ *    Ant.transmit_power = 4
+ *
+ * Set the transmit power level for all channels. Valid values are 0-4; default
+ * is 3 = 0dBm.
+ *
+ *    # Set transmit power to -5 dBm
+ *    Ant.transmit_power = 2
+ */
+static VALUE
+rant_s_transmit_power_eq( VALUE _module, VALUE power )
+{
+	const unsigned char ucTransmitPower = NUM2CHR( power );
+	BOOL rval;
+
+	if ( ucTransmitPower < 0 || ucTransmitPower > 4 ) {
+		rb_raise( rb_eArgError, "expected a value between 0 and 4, got %d", ucTransmitPower );
+	}
+
+	rval = ANT_SetTransmitPower( ucTransmitPower );
+
+	return rval ? Qtrue : Qfalse;
+}
+
+
 /*
  * call-seq:
  *    Ant.assign_channel( channel, channel_type, network_number=0, extended_options=0x0, timeout=0 )   -> channel
@@ -463,6 +500,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,11 +595,13 @@ 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 );
 
 	rb_define_singleton_method( rant_mAnt, "set_network_key", rant_s_set_network_key, 2 );
+	rb_define_singleton_method( rant_mAnt, "transmit_power=", rant_s_transmit_power_eq, 1 );
 	rb_define_singleton_method( rant_mAnt, "assign_channel", rant_s_assign_channel, -1 );
 
 	rb_define_singleton_method( rant_mAnt, "use_extended_messages=",
@@ -521,6 +610,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 +629,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 +711,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,12 @@ 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_iv_set( self, "@agility_frequencies", Qnil );
+
 	rb_hash_aset( registry, channel_number, self );
 
 	return self;
@@ -173,8 +179,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 +192,139 @@ 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;
+}
+
+
+static VALUE
+rant_channet_set_frequency_agility( VALUE self, VALUE freq1, VALUE freq2, VALUE freq3 )
+{
+	rant_channel_t *ptr = rant_get_channel( self );
+	unsigned char ucFreq1 = NUM2CHR( freq1 ),
+		ucFreq2 = NUM2CHR( freq2 ),
+		ucFreq3 = NUM2CHR( freq3 );
+	VALUE frequencies = rb_ary_new_from_args( 3, freq1, freq2, freq3 );
+
+	if ( ucFreq1 > 124 || ucFreq2 > 124 || ucFreq3 > 124 ) {
+		rb_raise( rb_eArgError, "frequencies must be between 0 and 124." );
+	}
+
+	rant_log_obj( self, "info",
+		"Configuring channel %d to use frequency agility on %d, %d, and %d MHz.",
+		ptr->channel_num, ucFreq1 + 2400, ucFreq2 + 2400, ucFreq3 + 2400 );
+	ANT_ConfigFrequencyAgility( ptr->channel_num, ucFreq1, ucFreq2, ucFreq3 );
+
+	rb_ary_freeze( frequencies );
+	rb_iv_set( self, "@agility_frequencies", frequencies );
+
 	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 +582,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,12 +610,18 @@ 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_attr( rant_cAntChannel, rb_intern("agility_frequencies"), 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, "set_frequency_agility", rant_channet_set_frequency_agility, 3 );
 
 	rb_define_method( rant_cAntChannel, "open", rant_channel_open, -1 );
 	rb_define_method( rant_cAntChannel, "close", rant_channel_close, -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/bitvector.rb

@@ -0,0 +1,197 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+# vim: set nosta noet ts=4 sw=4:
+
+require 'ant' unless defined?( Ant )
+
+# Ant::BitVector -- a convenience class for manipulating and
+# comparing bit vectors.
+#
+# This is a slightly-modified version of the same utility in StaticCling.
+#
+# == Synopsis
+#
+#   require 'ant/bitvector'
+#
+#   vector = Ant::BitVector.new
+#
+#   vector.on( 4 )     # => 16
+#   vector.on( 12 )    # => 4112
+#   vector.toggle( 4 ) # => 4096
+#   vector.on?( 4 )    # => false
+#   vector.size        # => 13
+#   vector.to_hex      # => 0x1000
+#
+#   vector2 = Ant::BitVector.new( 5 )
+#   vector > vector2   # => true
+#
+#   vector2.each_with_index do |bit, i|
+#		puts "Bit %d is %s" % [ i + 1, bit.zero? ? 'off' : 'on' ]
+#	end
+#
+#		Bit 1 is on
+#		Bit 2 is off
+#		Bit 3 is on
+#
+# == Version
+#
+#  $Id$
+#
+# == Author
+#
+# * Mahlon E. Smith <mahlon@martini.nu>
+#
+# == License
+#
+# Copyright (c) 2000-2013, Mahlon E. Smith <mahlon@martini.nu>
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright notice,
+#     this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+#     * Neither the name of the author, nor the names of contributors may be
+#     used to endorse or promote products derived from this software without
+#     specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+class Ant::BitVector
+	include Enumerable,
+		Comparable
+
+	### Create a new bit vector object, optionally from a pre-existing
+	### +init+ number (Any number that ruby supports natively should be
+	### fine -- 0b, 0x, or decimal.)
+	def initialize( init=0 )
+		unless init.respond_to?( :to_i )
+			raise ArgumentError, "I don't know what to do with a %s object." % [ init.class.name ]
+		end
+
+		@bv = init.to_i
+	end
+
+
+	######
+	public
+	######
+
+	# let any additional methods fall through to Fixnum/Bignum objs,
+	# and return new vector objects.  This allows for doing bitwise math
+	# or simple addition/subtraction on two BitVector objects.
+	%w{ % & * ** + - / << >> ^ | ~ }.each do |op|
+		define_method( op.to_sym ) do |arg|
+			res = @bv.send( op.to_sym, arg.bv )
+			return self.class.new( res )
+		end
+	end
+
+
+	##
+	# Allow external access to the underlying Fixnum/Bignum
+	attr_reader :bv
+
+
+	### Return the bit vector as a decimal.
+	def to_i
+		return @bv
+	end
+	alias_method :to_int, :to_i
+	alias_method :to_dec, :to_i
+
+
+	### Return the bit vector as a binary string.
+	def to_bin
+		return "0b%s" % @bv.to_s(2)
+	end
+
+
+	### Return the bit vector as a hexidecimal string.
+	def to_hex
+		return "0x%04x" % @bv
+	end
+
+
+	### Return the length of the vector in bytes.
+	def size
+		return @bv.to_s(2).length
+	end
+
+
+	### Switch a +bit+ on.
+	def on( bit )
+		@bv = @bv | ( 1 << bit )
+	end
+
+
+	### Return boolean true if given +bit+ is currently on.
+	def on?( bit )
+		return @bv[ bit ].zero? ? false : true
+	end
+	alias_method :[], :on?
+
+
+	### Switch a +bit+ off.
+	def off( bit )
+		@bv = @bv & ~( 1 << bit )
+	end
+
+
+	### Return boolean true if given +bit+ is currently +off+.
+	def off?( bit )
+		return ! self.on?( bit )
+	end
+
+
+	### Swap the current state of the given +bit+.
+	def toggle( bit )
+		@bv = @bv ^ ( 1 << bit )
+	end
+	alias_method :flip, :toggle
+
+
+	### Set a +bit+ to +bool+ -- either true (on) or false (off).
+	### Any value other than nil or false is treated as true.
+	### This form also accepts ranges of bits, a la: vector[ 1..4 ] = true
+	def []=( bit, bool )
+		if bit.respond_to?( :each )
+			bit.each { |b| bool ? self.on( b ) : self.off( b ) }
+		else
+			bool ? self.on( bit ) : self.off( bit )
+		end
+	end
+
+
+	### Yield each binary position, least significant +bit+ first.
+	def each
+		@bv.to_s(2).reverse.each_byte do |bit|
+			yield bit.chr.to_i
+		end
+	end
+
+
+	### Comparision operator for Comparable mixin, fallthrough to
+	### Fixnum/Bignum.  Compares current state against +cmp+.
+	def <=>( cmp )
+		@bv <=> cmp.bv
+	end
+
+end # class Ant::BitVector
+