static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
ANT_Device usbAntDevice = new ANT_Device();
usbAntDevice.ResetSystem(); // Soft reset
System.Threading.Thread.Sleep(500); // Delay 500ms after a reset
usbAntDevice.setNetworkKey(0, AntDevice.AntNetworkKey, 500);
var receiver = new AntHRreceiver(usbAntDevice);
Application.Run(new HRreportForm(receiver));
}
public AntHRreceiver(ANT_Device device, AntChannels channel = AntChannels.Channel0, byte networkNum = 0)
: base(device, channel, networkNum)
{
//
ChannelType = ChannelType.BidirectionalSlaveChannel;
DeviceNumber = 0;// 35032;
DeviceType = 120;
TransmissionType = 1;
RFChannelNumber = 57;
MessagePeriod = 8070;
ChannelResponse = onChannelResponse;
Init();
}
////////////////////////////////////////////////////////////////////////////////
// Init
//
// Initialize demo parameters.
//
////////////////////////////////////////////////////////////////////////////////
public void Initialise()
{
try
{
Console.WriteLine("Attempting to connect to an ANT USB device...");
device0 = new ANT_Device(); // Create a device instance using the automatic constructor (automatic detection of USB device number and baud rate)
device0.deviceResponse += new ANT_Device.dDeviceResponseHandler(DeviceResponse); // Add device response function to receive protocol event messages
Console.WriteLine("Initialization was successful!");
}
catch (Exception ex)
{
if (device0 == null) // Unable to connect to ANT
{
throw new Exception("Could not connect to any device.\n" +
"Details: \n " + ex.Message);
}
else
{
throw new Exception("Error connecting to ANT: " + ex.Message);
}
}
}
////////////////////////////////////////////////////////////////////////////////
// Init
//
// Initialize demo parameters.
//
////////////////////////////////////////////////////////////////////////////////
public void Initialise()
{
try
{
Console.WriteLine("Attempting to connect to an ANT USB device...");
device0 = new ANT_Device(); // Create a device instance using the automatic constructor (automatic detection of USB device number and baud rate)
device0.deviceResponse += new ANT_Device.dDeviceResponseHandler(DeviceResponse); // Add device response function to receive protocol event messages
Console.WriteLine("Initialization was successful!");
}
catch (Exception ex)
{
if (device0 == null) // Unable to connect to ANT
{
throw new Exception("Could not connect to any device.\n" +
"Details: \n " + ex.Message);
}
else
{
throw new Exception("Error connecting to ANT: " + ex.Message);
}
}
Console.WriteLine("Resetting module...");
device0.ResetSystem(); // Soft reset
System.Threading.Thread.Sleep(500); // Delay 500ms after a reset
// If you call the setup functions specifying a wait time, you can check the return value for success or failure of the command
// This function is blocking - the thread will be blocked while waiting for a response.
// 500ms is usually a safe value to ensure you wait long enough for any response
// If you do not specify a wait time, the command is simply sent, and you have to monitor the protocol events for the response,
Console.WriteLine("Setting network key...");
if (device0.setNetworkKey(USER_NETWORK_NUM, USER_NETWORK_KEY, 500))
Console.WriteLine("Network key set");
else
throw new Exception("Error configuring network key");
Console.WriteLine(USER_NETWORK_KEY[0]);
}
/// <summary>
/// Initialize device using configured parameters.
/// </summary>
public void Init()
{
lock (locker)
{
CheckDisposed();
// alternative default: ANT_ReferenceLibrary.PortType.USB, 0, 57600, ANT_ReferenceLibrary.FramerType.basicANT
device = new ANT_Device();
Reset();
// todo scope: support more than one network at a time
device.setNetworkKey(0, NetworkKey);
channel = new AntChannel(device.getChannel(0));
}
}
public void Stop()
{
// Nothing to stop if not started or already finished.
if (state == AntState.NotStarted || state == AntState.Finished)
return;
//if (state == AntState.StartFail || state == AntState.ConnectFail)
// return;
if (this.channel != null)
try
{
ANT_Channel tempChannel = this.channel;
this.channel = null;
tempChannel.closeChannel(RESPONSE_WAIT_TIME);
tempChannel.Dispose();
}
catch { }
if (this.device != null)
try
{
ANT_Device tempDevice = this.device;
this.device = null;
// We use a temp var here because this Dispose method is a little strange...
tempDevice.Dispose();
}
catch { }
UpdateState(AntState.Finished);
}
internal void MessageReceived(ANT_Device.ANTMessage newMessage, ushort messageSize)
{
if (channelResponse != null)
channelResponse(new ANT_Response(this, channelNumber, DateTime.Now, newMessage.msgID, newMessage.ucharBuf.Take(messageSize).ToArray()));
if (rawChannelResponse != null)
rawChannelResponse(newMessage, messageSize);
}
/// <summary>
/// Shuts down all open resources, calls reset on the physical device, and nullifies the given ANTDevice and all its channels
/// </summary>
/// <param name="deviceToShutdown">ANTDevice to shutdown</param>
public static void shutdownDeviceInstance(ref ANT_Device deviceToShutdown)
{
if (deviceToShutdown != null)
{
deviceToShutdown.Dispose();
deviceToShutdown = null;
}
}
//Internal, because a channel can not be created without a device instance. Channels must be created by the device class which assigns the appropriate channel number
internal ANT_Channel(ANT_Device creatingDevice, byte ucChannelNumber)
{
this.creatingDevice = creatingDevice;
this.unmanagedANTFramerPointer = creatingDevice.getFramerPtr();
channelNumber = ucChannelNumber;
}
internal void NotifyDeviceEvent(ANT_Device.DeviceNotificationCode notification, object notificationInfo)
{
if (DeviceNotification != null)
DeviceNotification(notification, notificationInfo);
}
static void Init()
{
try
{
Console.WriteLine("Attempting to connect to an ANT USB device...");
device0 = new ANT_Device(); // Create a device instance using the automatic constructor (automatic detection of USB device number and baud rate)
device0.deviceResponse += new ANT_Device.dDeviceResponseHandler(DeviceResponse); // Add device response function to receive protocol event messages
channel0 = device0.getChannel(USER_ANT_CHANNEL); // Get channel from ANT device
channel0.channelResponse += new dChannelResponseHandler(ChannelResponse); // Add channel response function to receive channel event messages
Console.WriteLine("Initialization was successful!");
}
catch (Exception ex)
{
//This part is likely to crash, but we want to catch that somewhere else
//We keep the try catch anyway as a reminder.
throw ex;
}
}
private bool OpenGarmin2()
{
//Initialise the ANT library and connect to ANT module
if (device != null)
{
ANT_Device.shutdownDeviceInstance(ref device);
device = null;
}
device = new ANT_Device();
if (device == null)
{
MessageBox.Show("Error initialising ANT module. Ensure the Garmin ANT agent is not running.");
return false;
}
device.ResetSystem();
channel = device.getChannel(0);
//Reset wireless transceiver
device.ResetSystem();
Thread.Sleep(50);
//Pass the callback functions to the ANT_DLL library
device.deviceResponse += new ANT_Device.DeviceResponseHandler(DeviceResponse);
channel.channelResponse += new ANT_Channel.ChannelResponseHandler(ChannelResponse);
//Set network key for Garmin HRM
//The garmin HRM key is "B9A521FBBD72C345"
byte[] GarminKey = { 0xb9, 0xa5, 0x21, 0xfb, 0xbd, 0x72, 0xc3, 0x45 };
device.setNetworkKey(0, GarminKey);
Thread.Sleep(50);
//Assign the channel
//Receive on channel 0, network #0
channel.assignChannel(ANT_ReferenceLibrary.ChannelType.BASE_Slave_Receive_0x00, 0);
//Congifure Channel ID - set up which devices to transmit-receive data from
//Set to receive from any device it finds
ushort device_id = ushort.Parse(txtDeviceID.Text);
channel.setChannelID((ushort)device_id, false, 0, 0);
Thread.Sleep(50);
//Set the receiver search timeout limit
channel.setChannelSearchTimeout(0xff);
Thread.Sleep(50);
//Set the messaging period (corresponding to the max number of messages per second)
//Messaging period for Garmin HRM is 0x1f86
channel.setChannelPeriod(0x1f86);
Thread.Sleep(50);
//Set the radio frequency corresponding to the Garmin watch (frequency 0x39)
channel.setChannelFreq(0x39);
Thread.Sleep(50);
//Open the channel to receive data !
channel.openChannel();
return true;
}
public AntDevice(ANT_Device device, AntChannels channel = AntChannels.Channel0, byte networkNum = 0)
{
_antDevice = device;
_channel = _antDevice.getChannel((int)channel);
NetworkNumber = networkNum;
}
public void Start()
{
if (state != AntState.NotStarted)
{
Debug.LogWarningFormat("[AntStick] Start called a second time (ignored).");
return;
}
UpdateState(AntState.Starting);
ushort deviceId = DEVICE_ID;
try
{
string line = null;
StreamReader reader = new StreamReader(ANT_DEVICE_ID_FILE_PATH, Encoding.Default);
using (reader)
{
line = reader.ReadLine();
reader.Close();
}
if (line == null)
{
Debug.LogWarningFormat("[AntStick] Could not get Ant Device ID from {0}. File exists but is empty.", ANT_DEVICE_ID_FILE_PATH);
}
else
{
deviceId = UInt16.Parse(line);
}
}
catch (FileNotFoundException ex)
{
Debug.LogWarningFormat("[AntStick] Could not get Ant Device ID from {0}. File not found. {1}", ANT_DEVICE_ID_FILE_PATH, ex.Message);
}
catch(FormatException ex)
{
Debug.LogWarningFormat("[AntStick] Could not get Ant Device ID from {0}. Could not parse first line as ushort. {1}", ANT_DEVICE_ID_FILE_PATH, ex.Message);
}
catch (Exception ex)
{
Debug.LogWarningFormat("[AntStick] Could not get Ant Device ID from {0}. Exception occurred. {1}", ANT_DEVICE_ID_FILE_PATH, ex.Message);
}
Debug.LogFormat("[AntStick] Using Device ID {0}.", deviceId);
Stats = new AntStats();
try
{
device = new ANT_Device();
}
catch (ANT_Exception ex)
{
Debug.LogWarningFormat("[AntStick] Could not open device (perhaps something else is using it?).\n{0}", ex.Message);
UpdateState(AntState.StartFail);
Stop();
return;
}
try
{
channel = device.getChannel(CHANNEL);
}
catch (ANT_Exception ex)
{
Debug.LogWarningFormat("[AntStick] Could not get channel {0}.\n{1}", CHANNEL, ex.Message);
UpdateState(AntState.StartFail);
Stop();
return;
}
device.deviceResponse += new ANT_Device.dDeviceResponseHandler(DeviceResponse);
channel.channelResponse += new dChannelResponseHandler(ChannelResponse);
try
{
if (!device.setNetworkKey(NETWORK_NUMBER, NETWORK_KEY, RESPONSE_WAIT_TIME))
{
Debug.LogWarning("[AntStick] Failed to set network key.");
UpdateState(AntState.StartFail);
Stop();
return;
}
if (!channel.assignChannel(CHANNEL_TYPE, NETWORK_NUMBER, RESPONSE_WAIT_TIME))
{
Debug.LogWarning("[AntStick] Failed to assign channel.");
UpdateState(AntState.StartFail);
Stop();
return;
}
if (!channel.setChannelID(deviceId, PAIRING_ENABLED, DEVICE_TYPE, TRANSMISSION_TYPE, RESPONSE_WAIT_TIME))
{
Debug.LogWarning("[AntStick] Failed to set channel Id.");
UpdateState(AntState.StartFail);
Stop();
return;
}
if (!channel.setChannelPeriod(CHANNEL_PERIOD, RESPONSE_WAIT_TIME))
{
Debug.LogWarning("[AntStick] Failed to set channel period.");
UpdateState(AntState.StartFail);
Stop();
return;
}
if (!channel.setChannelFreq(CHANNEL_FREQUENCY, RESPONSE_WAIT_TIME))
{
Debug.LogWarning("[AntStick] Failed to set channel frequency.");
UpdateState(AntState.StartFail);
Stop();
return;
}
if (!channel.openChannel(RESPONSE_WAIT_TIME))
{
Debug.LogWarning("[AntStick] Failed to open the channel.");
UpdateState(AntState.StartFail);
Stop();
return;
}
}
catch (ANT_Exception ex)
{
Debug.LogWarningFormat("[AntStick] Could not configure channel.\n{0}", ex.Message);
UpdateState(AntState.StartFail);
Stop();
return;
}
StartConnectTimeout();
}
void channel_DeviceNotification(ANT_Device.DeviceNotificationCode notification, object notificationInfo)
{
ANTFSClient_ProcessDeviceNotification(unmanagedClientPtr, (byte)notification, IntPtr.Zero);
//TODO: Once an object is defined for specific notification types, need to marshal it - pin it and pass it...
}
void channel_DeviceNotification(ANT_Device.DeviceNotificationCode notification, object notificationInfo)
{
ANTFSHost_ProcessDeviceNotification(unmanagedHostPtr, (byte) notification, IntPtr.Zero);
//TODO Once we define an object for a notification type, marshal it - pin it, etc
}
private static extern int ANTFSHost_ProcessMessage(IntPtr ClientPtr, ref ANT_Device.ANTMessage pstANTMessage, ushort usMessageSize);
