ant-wireless 0.1.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60dd8cb782d7e1f500a55f7cd80b77fb2fcd3d9a58388a5e2fdff25ee5c70e2c
-  data.tar.gz: e9c54e26b412c78b10d42a3d6df532b0e58ddab7775146602b38d52ae119e5aa
+  metadata.gz: 1cbf09bffd2b5ac2d18ea9fb271bb1e358707b45a49bd45651129d5030598e95
+  data.tar.gz: f2d892f9c17f352e81b1b6236ac567a62f24b61495860b0f071975bd80446ea8
 SHA512:
-  metadata.gz: 50f34e579557e981f7f63610dedc06959ab1109e30a65e2d34d2fd33cc29f00c5ac955785e47e7d2b7c912e13999aedeaa0c961a5505b560d0d7e7092f3eb4d0
-  data.tar.gz: 2a3892e482b4173861a1c61c3b194589e14baa6c9d440b02004d8e519c388a88bbc527d3192fe769a36d48dad3d54f4c9bb0f6fce08a9e9cb00876a9684fc0d2
+  metadata.gz: 8ecd19b9d5c711fe0e71be58e5fa3c1386fa340bc9cafa0279e08ba52b48ebe8f7169386faf93fe5b7a900a8ee70d84d049f31db3405dc2c7e957fa5126fce2c
+  data.tar.gz: 83aa2b97810514c2279182d1853efeed48087e270cb6db2533b151cae046370a6071c7fa2ed164cf6558c79b1f970a3d18526c2188ea281dc4493ec8313ebec5

data/History.md

@@ -1,6 +1,37 @@
 # Release History for ruby-ant
 
 ---
+## v0.4.0 [2021-11-05] Michael Granger <ged@FaerieMUD.org>
+
+Enhancements:
+
+- Add advanced burst support (with a customized ANT-SDK).
+
+
+## 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>
 

data/README.md

@@ -24,7 +24,10 @@ manner.
 * [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:
+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, and with implementations for advanced burst and checking
+initialization status. That is available under the same licensing terms at:
 
 https://github.com/RavnGroup/Garmin-ANT-SDK
 
@@ -57,6 +60,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 +91,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,26 @@ rant_s_init( int argc, VALUE *argv, VALUE _module )
 }
 
 
+/*
+ * call-seq:
+ *    Ant.initialized?   -> true or false
+ *
+ * Returns +true+ if the ANT library has been initialized.
+ *
+ * Note: this requires a modified version of the Garmin ANT-SDK.
+ *
+ */
+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 +311,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
@@ -381,6 +427,56 @@ rant_s_use_extended_messages_eq( VALUE _module, VALUE true_false )
 }
 
 
+/*
+ * call-seq:
+ *    Ant.configure_advanced_burst( enabled, max_packet_length, required_fields, optional_fields,
+ *        stall_count=3210, retry_count=4 )
+ *
+ * Enable/disable and configure advanced burst. This is the lower-level method; the
+ * higher-level methods are: #enable_advanced_burst and #disable_advanced_burst.
+ *
+ */
+static VALUE
+rant_s_configure_advanced_burst( int argc, VALUE *argv, VALUE _module )
+{
+	VALUE enabled,
+		max_packet_length,
+		required_fields,
+		optional_fields,
+		stall_count = Qnil,
+		retry_count = Qnil;
+	bool bEnable;
+	unsigned char ucMaxPacketLength,
+		ucRetryCount = 0;
+	unsigned long ulRequiredFields,
+		ulOptionalFields;
+	unsigned short usStallCount = 0;
+	bool rval;
+
+	rb_scan_args( argc, argv, "42", &enabled, &max_packet_length, &required_fields,
+		&optional_fields, &stall_count, &retry_count );
+
+	bEnable = RTEST( enabled );
+	ucMaxPacketLength = NUM2CHR( max_packet_length );
+	ulRequiredFields = NUM2ULONG( required_fields );
+	ulOptionalFields = NUM2ULONG( optional_fields );
+
+	if ( RTEST(stall_count) ) {
+		usStallCount = NUM2USHORT( stall_count );
+	}
+	if ( RTEST(retry_count) ) {
+		ucRetryCount = NUM2CHR( retry_count );
+	}
+
+	rant_log( "warn", "Configuring advanced burst: enable = %d, maxpacketlength = %d",
+		bEnable, ucMaxPacketLength );
+	rval = ANT_ConfigureAdvancedBurst_ext( bEnable, ucMaxPacketLength, ulRequiredFields,
+		ulOptionalFields, usStallCount, ucRetryCount );
+
+	return rval ? Qtrue : Qfalse;
+}
+
+
 // Buffer for response data.
 // static UCHAR pucResponseBuffer[ MESG_RESPONSE_EVENT_SIZE ];
 static UCHAR pucResponseBuffer[ MESG_MAX_SIZE_VALUE ];
@@ -463,6 +559,73 @@ 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:
+ *    Ant.request_advanced_burst_capabilities
+ *
+ * Request the current device's advanced burst capabilities. The result will
+ * be delivered via a callback to the #on_version response callback, which by
+ * default extracts it and stores it at Ant.advanced_burst_capabilities.
+ *
+ */
+static VALUE
+rant_s_request_advanced_burst_capabilities( VALUE _module )
+{
+	bool rval = ANT_RequestMessage( 0, MESG_CONFIG_ADV_BURST_ID );
+	return rval ? Qtrue : Qfalse;
+}
+
 
 /*
  * call-seq:
@@ -508,19 +671,29 @@ 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=",
 		rant_s_use_extended_messages_eq, 1 );
+	rb_define_singleton_method( rant_mAnt, "configure_advanced_burst",
+		rant_s_configure_advanced_burst, -1 );
 
 	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, "request_advanced_burst_capabilities",
+		rant_s_request_advanced_burst_capabilities, 0 );
+
 	rb_define_singleton_method( rant_mAnt, "log_directory=", rant_s_log_directory_eq, 1 );
 
 
@@ -536,6 +709,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 +791,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

@@ -9,6 +9,9 @@
 
 #include "ant_ext.h"
 
+#define DEFAULT_ADV_PACKETS 3
+#define ADVANCED_BURST_TIMEOUT 5
+
 VALUE rant_cAntChannel;
 
 VALUE rant_mAntDataUtilities;
@@ -128,6 +131,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 +182,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 +195,147 @@ 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;
+}
+
+
+/*
+ * call-seq:
+ *    channel.set_frequency_agility( freq1, freq2, freq3 )
+ *
+ * Set the frequencies to use in frequency agility (integers between 0 and 124). These values
+ * use the same convention as the +rf_frequency+ setting; i.e., they're offsets from 2400 MHz.
+ *
+ */
+static VALUE
+rant_channel_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_);
 
 
 /*
@@ -452,24 +595,56 @@ rant_channel_send_broadcast_data( VALUE self, VALUE data )
 
 /*
  * call-seq:
- *    channel.set_channel_rf_freq( frequency )
+ *    channel.send_advanced_transfer( data, packets_per_message=3 )
  *
- * Set the ANT RF +frequency+.
+ * Send the given +data+ as one or more advanced burst packets. The +packets_per_message+
+ * may be set to a value between 1 and 3 to control how many 8-byte packets are send with
+ * each message.
  *
  */
 static VALUE
-rant_channel_set_channel_rf_freq( VALUE self, VALUE frequency )
+rant_channel_send_advanced_transfer( int argc, VALUE *argv, VALUE self )
 {
+#ifdef HAVE_ANT_SENDADVANCEDBURST
 	rant_channel_t *ptr = rant_get_channel( self );
-	unsigned short ucRFFreq = NUM2USHORT( frequency );
+	VALUE data = Qnil, packets = Qnil;
+	unsigned char *data_s;
+	long data_len;
+	unsigned short usNumDataPackets, remainingBytes;
+	unsigned char ucStdPcktsPerSerialMsg = DEFAULT_ADV_PACKETS;
+
+	rb_scan_args( argc, argv, "11", &data, &packets );
+	data_len = RSTRING_LEN( data );
+	usNumDataPackets = data_len / 8;
+	remainingBytes = data_len % 8;
+	if ( RTEST(packets) ) {
+		ucStdPcktsPerSerialMsg = NUM2CHR(packets);
+	}
 
-	if ( ucRFFreq > 124 ) {
-		rb_raise( rb_eArgError, "frequency must be between 0 and 124." );
+	data_s = ALLOC_N( unsigned char, data_len );
+	strncpy( (char *)data_s, StringValuePtr(data), data_len );
+
+	// Pad it to 8-byte alignment
+	if ( remainingBytes ) {
+		int pad_bytes = (8 - remainingBytes);
+		REALLOC_N( data_s, unsigned char, data_len + pad_bytes );
+		memset( data_s + data_len, 0, pad_bytes );
+
+		usNumDataPackets += 1;
 	}
 
-	ANT_SetChannelRFFreq( ptr->channel_num, ucRFFreq );
+	rant_log_obj( self, "warn", "Sending advanced burst packets (%d-byte messages): %s",
+		ucStdPcktsPerSerialMsg * 8, data_s );
+	if ( !ANT_SendAdvancedBurst_RTO(ptr->channel_num, data_s, usNumDataPackets,
+		ucStdPcktsPerSerialMsg, ADVANCED_BURST_TIMEOUT) )
+	{
+		rant_log_obj( self, "error", "failed to send advanced burst transfer." );
+	}
 
 	return Qtrue;
+#else
+	rb_notimplement();
+#endif
 }
 
 
@@ -501,12 +676,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_channel_set_frequency_agility, 3 );
 
 	rb_define_method( rant_cAntChannel, "open", rant_channel_open, -1 );
 	rb_define_method( rant_cAntChannel, "close", rant_channel_close, -1 );
@@ -515,6 +696,7 @@ init_ant_channel()
 	rb_define_method( rant_cAntChannel, "send_burst_transfer", rant_channel_send_burst_transfer, 1 );
 	rb_define_method( rant_cAntChannel, "send_acknowledged_data", rant_channel_send_acknowledged_data, 1 );
 	rb_define_method( rant_cAntChannel, "send_broadcast_data", rant_channel_send_broadcast_data, 1 );
+	rb_define_method( rant_cAntChannel, "send_advanced_transfer", rant_channel_send_advanced_transfer, -1 );
 
 	rb_define_method( rant_cAntChannel, "on_event", rant_channel_on_event, -1 );
 

data/ext/ant_ext/extconf.rb

@@ -14,9 +14,19 @@ 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' )
 
+# Look for a custom advanced burst function, as the official SDK has it in the
+# header but doesn't actually implement it.
+have_func( 'ANT_SendAdvancedBurst', 'libant.h' )
+
+# Ref: https://bugs.ruby-lang.org/issues/17865
+$CPPFLAGS << " -Wno-compound-token-split-by-macro "
+
+$CFLAGS << " -g "
+
 create_header()
 create_makefile( 'ant_ext' )