ant-wireless 0.1.0.pre.20210617213631

data/ext/ant_ext/version.h

@@ -0,0 +1,41 @@
+/*
+This software is subject to the license described in the License.txt file
+included with this software distribution. You may not use this file except
+in compliance with this license.
+
+Copyright (c) Dynastream Innovations Inc. 2016
+All rights reserved.
+*/
+#if !defined(__VERSION_H__)
+#define __VERSION_H__
+
+#include "build_version.h"
+
+#ifdef _UNICODE
+#define _T(x)      L ## x
+#else
+#define _T(x)      x
+#endif
+
+#define STRINGIZE2(s) _T(#s)
+#define STRINGIZE(s) STRINGIZE2(s)
+
+#define VER_FILE_DESCRIPTION_STR    _T(PRODUCT_STRING)
+#define VER_FILE_VERSION_STR        STRINGIZE(VERSION_MAJOR)            \
+                                    _T(".") STRINGIZE(VERSION_MINOR)
+
+// Version Information
+#define SW_VER_PPP                     "ALU"
+#define SW_VER_NUM                     VER_FILE_VERSION_STR
+#if !defined(EXT_FUNCTIONALITY)
+   #define SW_VER_DEV                     "00"
+   #define SW_VER_SUFFIX                  ""
+#else
+   #define SW_VER_DEV                     "0001"   //Add two digits which are the ext lib version of the corresponding non-extended version
+   #define SW_VER_SUFFIX                  "_BAXEXT"
+#endif
+
+#define SW_VER                         SW_VER_PPP SW_VER_NUM SW_VER_DEV SW_VER_SUFFIX
+#define SW_DESCR                       ""
+
+#endif // !defined(CONFIG_H)

data/lib/ant.rb

@@ -0,0 +1,138 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+require 'loggability'
+
+require_relative 'ant_ext'
+
+
+#--
+# See ext/ant_ext/ant_ext.c
+module Ant
+	extend Loggability
+
+	# Package version
+	VERSION = '0.0.1'
+
+	# Version control revision
+	REVISION = %q$Revision$
+
+
+	# A Range for matching valid ANT device numbers
+	VALID_DEVICE_NUMBERS = ( 0...65535 ).freeze
+
+	# A Range for matching valid ANT device types (6 least signficant bits)
+	VALID_DEVICE_TYPES = ( 0...127 ).freeze
+
+	# The default range of frequencies for the channel period
+	VALID_CHANNEL_PERIODS = ( 0...65535 ).freeze
+
+	# The valid offsets for the "RF Frequency" setting; this is an offset from 2400Hz.
+	VALID_RF_FREQUENCIES = ( 0...124 ).freeze
+
+
+	# Loggability API -- set up a logger for the library
+	log_as :ant
+
+
+	Loggability.level = :debug
+
+
+	autoload :ResponseCallbacks, 'ant/response_callbacks'
+	autoload :DataUtilities, 'ant/mixins'
+
+
+	### Set up the given +mod+ as the handler module for response callbacks. You can
+	### create your own handler module and extend with the default Ant::ResponseCallbacks.
+	def self::set_response_handlers( mod=Ant::ResponseCallbacks )
+		self.extend( mod )
+		self.on_response( &self.method(:handle_response_callback) )
+	end
+
+
+	### Check that specified +number+ is a valid device number and raise an
+	### appropriate exception if it isn't. Returns the number as an Integer if it is
+	### valid.
+	def self::validate_device_number( number )
+		number = Integer( number )
+		unless VALID_DEVICE_NUMBERS.include?( number )
+			raise RangeError, "invalid device number; expected a number between %d and %d, got %p" %
+				[ VALID_DEVICE_NUMBERS.begin, VALID_DEVICE_NUMBERS.end, number ]
+		end
+
+		return number
+	end
+
+
+	### Check that specified +number+ is a valid device type and raise an
+	### appropriate exception if it isn't. Returns the number as an Integer if it is
+	### valid.
+	def self::validate_device_type( number )
+		number = Integer( number )
+		unless VALID_DEVICE_TYPES.include?( number )
+			raise RangeError, "invalid device type; expected a number between %d and %d, got %p" %
+				[ VALID_DEVICE_TYPES.begin, VALID_DEVICE_TYPES.end, number ]
+		end
+
+		return number
+	end
+
+
+	### Check that specified +frequency+ is a valid channel period and raise an
+	### appropriate exception if it isn't. Returns the frequency as an Integer if it is
+	### valid.
+	def self::validate_channel_period( frequency )
+		frequency = Integer( frequency )
+		unless VALID_CHANNEL_PERIODS.include?( frequency )
+			raise RangeError, "invalid channel period; expected a frequency between %d and %d, got %p" %
+				[ VALID_CHANNEL_PERIODS.begin, VALID_CHANNEL_PERIODS.end, frequency ]
+		end
+
+		return frequency
+	end
+
+
+	### Check that specified +number+ is a valid ANT network number and raise an
+	### appropriate exception if it isn't. Note that this does not check
+	### the local device(s) to ensure they support the given network. Returns the key
+	### as an Integer if it is valid.
+	def self::validate_network_number( number )
+		number = Integer( number )
+		unless number >= 0 && number <= 255
+			raise RangeError, "invalid network number; expected an eight-bit number, got %p" %
+				[ number ]
+		end
+
+		return number
+	end
+
+
+	### Check that specified +data+ is a valid ANT network key and raise an
+	### appropriate exception if it isn't. Returns the key itself if it is valid.
+	def self::validate_network_key( data )
+		data = data.to_s
+		unless data.bytesize == 8
+			raise RangeError, "invalid network key; expected exactly eight bytes, got %d" %
+				[ data.bytesize ]
+		end
+
+		self.log.debug "Validated network key: %p" % [ data ]
+		return data
+	end
+
+
+	### Check that specified +offset+ is a valid "rf frequency" and raise an
+	### appropriate exception if it isn't. Returns the offset as an Integer if it is
+	### valid.
+	def self::validate_rf_frequency( offset )
+		offset = Integer( offset )
+		unless VALID_RF_FREQUENCIES.include?( offset )
+			raise RangeError, "invalid RF Frequency; expected a offset between %d and %d, got %p" %
+				[ VALID_RF_FREQUENCIES.begin, VALID_RF_FREQUENCIES.end, offset ]
+		end
+
+		return offset
+	end
+
+end # module Ant
+

data/lib/ant/channel.rb

@@ -0,0 +1,66 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+require 'loggability'
+
+require 'ant' unless defined?( Ant )
+
+
+class Ant::Channel
+	extend Loggability
+
+	# The default network number
+	DEFAULT_NETWORK_NUMBER = 0
+
+	# The default channel options
+	DEFAULT_EXTENDED_OPTIONS = 0x0
+
+
+	#
+	# Autoloads
+	#
+
+	autoload :EventCallbacks, 'ant/channel/event_callbacks'
+
+
+	# Loggability API -- log to the Ant logger
+	log_to :ant
+
+	# Disallow manual instantiation
+	private_class_method :new
+
+
+	##
+	# Channel registry, keyed by channel number.
+	singleton_class.attr_reader( :registry )
+
+
+	######
+	public
+	######
+
+	alias_method :set_channel_rf_frequency, :set_channel_rf_freq
+
+
+	### 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) )
+	end
+
+
+	### Return a human-readable version of the object suitable for debugging.
+	def inspect
+		return "#<%p:%#x {%d} %#02x on network %d: %d%s>" % [
+			self.class,
+			self.object_id,
+			self.channel_number,
+			self.channel_type,
+			self.network_number,
+			self.extended_options,
+			self.closed? ? " (closed)" : "",
+		]
+	end
+
+end # class Ant::Channel
+

data/lib/ant/channel/event_callbacks.rb

@@ -0,0 +1,207 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'loggability'
+
+require 'ant/channel' unless defined?( Ant::Channel )
+require 'ant/mixins'
+
+
+# A module that contains logging event callbacks for an ANT::Channel.
+#
+# 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
+
+
+	# Mapping of response message IDs to handler methods
+	HANDLER_METHODS = {
+		Ant::EVENT_CHANNEL_CLOSED        => :on_event_channel_closed,
+		Ant::EVENT_CHANNEL_COLLISION     => :on_event_channel_collision,
+		Ant::EVENT_RX_ACKNOWLEDGED       => :on_event_rx_acknowledged,
+		Ant::EVENT_RX_BROADCAST          => :on_event_rx_broadcast,
+		Ant::EVENT_RX_BURST_PACKET       => :on_event_rx_burst_packet,
+		Ant::EVENT_RX_EXT_ACKNOWLEDGED   => :on_event_rx_ext_acknowledged,
+		Ant::EVENT_RX_EXT_BROADCAST      => :on_event_rx_ext_broadcast,
+		Ant::EVENT_RX_EXT_BURST_PACKET   => :on_event_rx_ext_burst_packet,
+		Ant::EVENT_RX_FAIL               => :on_event_rx_fail,
+		Ant::EVENT_RX_FAIL_GO_TO_SEARCH  => :on_event_rx_fail_go_to_search,
+		Ant::EVENT_RX_FLAG_ACKNOWLEDGED  => :on_event_rx_flag_acknowledged,
+		Ant::EVENT_RX_FLAG_BROADCAST     => :on_event_rx_flag_broadcast,
+		Ant::EVENT_RX_FLAG_BURST_PACKET  => :on_event_rx_flag_burst_packet,
+		Ant::EVENT_RX_SEARCH_TIMEOUT     => :on_event_rx_search_timeout,
+		Ant::EVENT_TRANSFER_RX_FAILED    => :on_event_transfer_rx_failed,
+		Ant::EVENT_TRANSFER_TX_COMPLETED => :on_event_transfer_tx_completed,
+		Ant::EVENT_TRANSFER_TX_FAILED    => :on_event_transfer_tx_failed,
+		Ant::EVENT_TRANSFER_TX_START     => :on_event_transfer_tx_start,
+		Ant::EVENT_TX                    => :on_event_tx,
+	}
+
+	# The mask of the channel number in buffer data
+	CHANNEL_NUMBER_MASK = 0x1F
+
+	# The mask of the sequence number in buffer data
+	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
+
+
+	### Log the channel event by default.
+	def self::log_event_callback( channel_num, handler_method, event_id, data )
+		self.log.debug "Event on channel %d: %#0x (%s): %s" % [
+			channel_num,
+			event_id,
+			handler_method,
+			Ant::DataUtilities.hexdump( data[ 0..3 ] )
+		]
+	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 )
+	end
+
+
+	### Handle a RX_SEARCH_TIMEOUT event.
+	def on_event_rx_search_timeout( channel_num, * )
+		self.log.warn "Search timeout on channel %d." % [ channel_num ]
+	end
+
+
+	### Handle a RX_FAIL event.
+	def on_event_rx_fail( channel_num, * )
+		self.log.warn "Receive failed on channel %d." % [ channel_num ]
+	end
+
+
+	### Handle a TRANSFER_RX_FAILED event.
+	def on_event_transfer_rx_failed( channel_num, * )
+		self.log.warn "Receive failed on channel %d." % [ channel_num ]
+	end
+
+
+	### Handle a TRANSFER_TX_COMPLETED event.
+	def on_event_transfer_tx_completed( channel_num, * )
+		self.log.warn "Transfer completed on channel %d." % [ channel_num ]
+	end
+
+
+	### Handle a TRANSFER_TX_FAILED event.
+	def on_event_transfer_tx_failed( channel_num, * )
+		self.log.warn "Transfer failed on channel %d." % [ channel_num ]
+	end
+
+
+	### Handle a CHANNEL_CLOSED event.
+	def on_event_channel_closed( channel_num, * )
+		self.log.warn "Channel %d was closed." % [ channel_num ]
+	end
+
+
+	### Handle a RX_FAIL_GO_TO_SEARCH event.
+	def on_event_rx_fail_go_to_search( channel_num, * )
+		self.log.warn "Channel %d dropped; resume search." % [ channel_num ]
+	end
+
+
+	### Handle a CHANNEL_COLLISION event.
+	def on_event_channel_collision( channel_num, * )
+		self.log.warn "Channel collision on channel %d." % [ channel_num ]
+	end
+
+
+	### Handle a TRANSFER_TX_START event.
+	def on_event_transfer_tx_start( channel_num, * )
+		self.log.warn "Burst transfer started on channel %d." % [ channel_num ]
+	end
+
+
+	# def on_event_rx_flag_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)" %
+				[usDeviceNumber, ucDeviceType, ucTransmissionType]
+		end
+
+		self.on_event_rx_burst_packet( channel_num, data )
+	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)" %
+				[usDeviceNumber, ucDeviceType, ucTransmissionType]
+		end
+
+		self.on_event_rx_broadcast( channel_num, data )
+	end
+
+
+	# def on_event_rx_acknowledged( channel_num, data )
+	#
+	# 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]) ]
+	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]) ]
+	end
+
+
+	# def on_event_rx_ext_acknowledged( channel_num, data )
+	#
+	# end
+	# def on_event_rx_ext_burst_packet( channel_num, data )
+	#
+	# end
+	# def on_event_rx_ext_broadcast( channel_num, data )
+	#
+	# end
+
+
+end # module Ant::Channel::EventCallbacks