internal void ConfigureANT()
{
Console.WriteLine("Resetting module 0 ...");
device0.ResetSystem();
System.Threading.Thread.Sleep(500);
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("Setting Channel ID...");
channel0.setChannelSearchTimeout((byte)100, 100);
if (channel0.setChannelID(0, false, 40, 0, 8192))
{
Console.WriteLine("Channel ID set");
}
else
{
Console.WriteLine("Error configuring Channel ID");
}
radarEquipmentDisplay = new BikeRadarDisplay(channel0, networkAntPlus);
radarEquipmentDisplay.DataPageReceived += radarEquipment_DataPageReceived;
radarEquipmentDisplay.RadarSensorFound += radarEquipment_Found;
radarEquipmentDisplay.RadarTargetsAPageReceived += radarEquipment_RadarTargetsAPageReceived;
radarEquipmentDisplay.RadarTargetsBPageReceived += radarEquipment_RadarTargetsBPageReceived;
radarEquipmentDisplay.TurnOn();
}
void findUsableAntDevice()
{
List <ANT_Device> unusableDevices = new List <ANT_Device>();
try
{
antStick = new ANT_Device();
//Get new devices until we
//lowpri and prox search is enough now to ensure we get a device that behave as we expected
while (antStick.getDeviceCapabilities().lowPrioritySearch == false || antStick.getDeviceCapabilities().ProximitySearch == false)
{
unusableDevices.Add(antStick); //keep the last device ref so we don't see it again
antStick = new ANT_Device(); //this will throw an exception when there are no devices left
}
if (!antStick.setNetworkKey(0, ANTPLUS_NETWORK_KEY, 500))
{
throw new ApplicationException("Failed to set network key");
}
}
catch (Exception ex)
{
ANT_Device.shutdownDeviceInstance(ref antStick); //Don't leave here with an invalid device ref
throw new Exception("Could not connect to valid USB2: " + ex.Message); //forward the exception
}
finally
{
//Release all the unusable devices
foreach (ANT_Device i in unusableDevices)
{
i.Dispose();
}
}
}
/// <summary>
/// Configure the host search parameters, and begin the search
/// </summary>
/// <param name="antDevice">ANT USB device</param>
public void ConfigureHost(ANT_Device antDevice)
{
// Configure ANT channel parameters
antfsHost.SetNetworkKey(Demo.NetworkNumber, Demo.NetworkKey);
antfsHost.SetChannelID(Demo.DeviceType, Demo.TransmissionType);
antfsHost.SetChannelPeriod(Demo.ChannelPeriod);
// Configure search parameters
if (antfsHost.AddSearchDevice(ClientDeviceID, Demo.ClientManufacturerID, Demo.ClientDeviceType) == 0)
{
throw new Exception("Error adding search device: ");
}
if (Demo.AntfsBroadcast)
{
// If we want to use ANT-FS broadcast mode, and start the channel in broadcast mode,
// setup callback to handle responses for channel 0 while in broadcast mode
channel0.channelResponse += new dChannelResponseHandler(HandleChannelResponses);
// Configure the channel as a slave, and look for messages from the master in the channel callback
// This demo will automatically switch to ANT-FS mode after a few seconds
if (!antDevice.setNetworkKey(Demo.NetworkNumber, Demo.NetworkKey, 500))
{
throw new Exception("Error configuring network key");
}
if (!channel0.assignChannel(ANT_ReferenceLibrary.ChannelType.BASE_Slave_Receive_0x00, Demo.NetworkNumber, 500))
{
throw new Exception("Error assigning channel");
}
if (!channel0.setChannelID(DeviceNumber, false, Demo.DeviceType, Demo.TransmissionType, 500))
{
throw new Exception("Error configuring Channel ID");
}
if (!channel0.setChannelFreq(Demo.SearchRF, 500))
{
throw new Exception("Error configuring radio frequency");
}
if (!channel0.setChannelPeriod(Demo.ChannelPeriod, 500))
{
throw new Exception("Error configuring channel period");
}
if (!channel0.openChannel(500))
{
throw new Exception("Error opening channel");
}
}
else
{
// Start searching directly for an ANT-FS client matching the search criteria
// NOTE: If not interested in the payload while in broadcast mode and intend to start a session right away,
// you can specify useRequestPage = true to search for broadcast devices, and automatically request them
// to switch to ANT-FS mode
antfsHost.SearchForDevice(Demo.SearchRF, ConnectRF, DeviceNumber);
}
Console.WriteLine("Searching for devices...");
// Setup a timer, so that we can cancel the search if no device is found
searchTimer = new Timer(SearchExpired, null, SearchTimeout * 1000, Timeout.Infinite); // convert time to milliseconds
}
public void Init()
{
usbDevice = new ANT_Device();
usbDevice.ResetSystem();
usbDevice.setNetworkKey(0, NETWORK_KEY);
network = new AntPlus.Types.Network(0, NETWORK_KEY, CHANNEL_FREQUENCY);
}
private static void ConfigureANT()
{
WriteLog("Configuring ANT communication...");
WriteLog("Resetting ANT USB Dongle...");
device0.ResetSystem(); // Soft reset
System.Threading.Thread.Sleep(500); // Delay 500ms after a reset
WriteLog("Setting ANT network key...");
if (device0.setNetworkKey(USER_NETWORK_NUM, USER_NETWORK_KEY, 500))
{
WriteLog("ANT network key setting successful");
}
else
{
throw new Exception("Error configuring network key");
}
WriteLog("Setting Channel ID...");
//channel0.setChannelTransmitPower(ANT_ReferenceLibrary.TransmitPower.RADIO_TX_POWER_0DB_0x03,500);
if (channel0.setChannelID(USER_DEVICENUM, USER_PAIRINGENABLED, USER_DEVICETYPE, USER_TRANSTYPE, USER_RESPONSEWAITTIME)) // Not using pairing bit
{
WriteLog("Channel ID: " + channel0.getChannelNum());
}
else
{
throw new Exception("Error configuring Channel ID");
}
genericControllableDevice = new GenericControllableDevice(channel0, networkAntPlus);
genericControllableDevice.DataPageReceived += GenericControllableDevice_DataPageReceived;
genericControllableDevice.TurnOn();
//CheckUsbDongle();
}
public void Reconnect(ANT_Device previousDevice)
{
device = previousDevice;
device.deviceResponse += new ANT_Device.dDeviceResponseHandler(DeviceResponse);
device.serialError += new ANT_Device.dSerialErrorHandler(SerialErrorHandler);
device.ResetSystem();
device.setNetworkKey(0, NETWORK_KEY, 500);
}
public void Reconnect(ANT_Device previousDevice)
{
int usbNum = previousDevice.getOpenedUSBDeviceNum();
devices[usbNum] = previousDevice;
previousDevice.deviceResponse += new ANT_Device.dDeviceResponseHandler(DeviceResponse);
previousDevice.serialError += new ANT_Device.dSerialErrorHandler(SerialErrorHandler);
previousDevice.ResetSystem();
previousDevice.setNetworkKey(0, NETWORK_KEY, 500);
}
// Use this for initialization
void Start()
{
current_speed = 0;
current_rpm = 0;
speedData = new ANTRawData[2];
rpmData = new ANTRawData[2];
if (bikeController == null)
{
bikeController = GameObject.FindWithTag("Player").GetComponent <BikeControl>();
}
try
{
dev0 = new ANT_Device();
dev0.deviceResponse += new ANT_Device.dDeviceResponseHandler(dev0_deviceResponse);
dev0.getChannel(0).channelResponse += new dChannelResponseHandler(speedSensorResponse);
dev0.getChannel(1).channelResponse += new dChannelResponseHandler(cadenceSensorResponse);
dev0.setNetworkKey(0, new byte[] { 0xB9, 0xA5, 0x21, 0xFB, 0xBD, 0x72, 0xC3, 0x45 });
channel_speed = dev0.getChannel(0);
channel_cadence = dev0.getChannel(1);
channel_speed.assignChannel(ANT_ReferenceLibrary.ChannelType.BASE_Slave_Receive_0x00, 0, timeout);
channel_speed.setChannelID(0, false, 123, 0, timeout);
channel_speed.setChannelPeriod(8118, timeout);
channel_speed.setChannelFreq(57, timeout);
channel_speed.openChannel(timeout);
channel_cadence.assignChannel(ANT_ReferenceLibrary.ChannelType.BASE_Slave_Receive_0x00, 0, timeout);
channel_cadence.setChannelID(0, false, 122, 0, timeout);
channel_cadence.setChannelPeriod(8102, timeout);
channel_cadence.setChannelFreq(57, timeout);
channel_cadence.openChannel(timeout);
StartCoroutine(UpdateCoroutine());
StartCoroutine(WaitForDecreaseSpeed());
StartCoroutine(DecreaseSpeed());
bikeController.is_ant_used = true;
}
catch (System.Exception)
{
bikeController.is_ant_used = false;
}
finally
{
}
Debug.Log("ANT Reset : " + bikeController.is_ant_used);
}
public void StartCommunication()
{
antDevice = new ANT_Device();
var networkKeyString = File.ReadAllLines("ant-network.key").FirstOrDefault(l => !l.StartsWith("#"))?.Trim();
antDevice.setNetworkKey(0, StringToByteArray(networkKeyString));
antDevice.deviceResponse += new ANT_Device.dDeviceResponseHandler(device0_deviceResponse);
antDevice.getChannel(0).channelResponse += new dChannelResponseHandler(d0channel0_channelResponse);
threadSafePrintLine("ANT+ USB Device Connected");
setupAndOpen(antDevice, ANT_ReferenceLibrary.ChannelType.BASE_Master_Transmit_0x10, 17, 0); // FE-C
setupAndOpen(antDevice, ANT_ReferenceLibrary.ChannelType.BASE_Master_Transmit_0x10, 11, 1); // Power
SetNextBroadcastMessage();
}
public void Init()
{
messageQueue = new Queue <ANT_Response>(16);
errorQueue = new Queue <SerialError>(16);
channelList = new List <AntChannel>();
//init the device
if (device == null)
{
device = new ANT_Device();
device.deviceResponse += new ANT_Device.dDeviceResponseHandler(DeviceResponse);
device.serialError += new ANT_Device.dSerialErrorHandler(SerialErrorHandler);
device.ResetSystem();
device.setNetworkKey(0, NETWORK_KEY, 500);
}
}
private static void ConfigureANT()
{
Console.WriteLine("Resetting module 0 ...");
device0.ResetSystem();
System.Threading.Thread.Sleep(500);
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("Setting Channel ID...");
if (channel0.setChannelID(1, false, 17, 0, 8192))
{
Console.WriteLine("Channel ID set");
}
else
{
throw new Exception("Error configuring Channel ID");
}
Console.WriteLine("Setting Channel ID...");
if (channel1.setChannelID(1, false, 11, 5, 8182))
{
Console.WriteLine("Channel ID set");
}
else
{
throw new Exception("Error configuring Channel ID");
}
fitnessEquipmentDisplay = new FitnessEquipmentDisplay(channel0, networkAntPlus);
fitnessEquipmentDisplay.SpecificTrainerPageReceived += FitnessEquipmentDisplay_SpecificTrainerPage;
fitnessEquipmentDisplay.TurnOn();
bikePowerOnlySensor = new BikePowerOnlySensor(channel1, networkAntPlus);
bikePowerOnlySensor.TurnOn();
}
public Network()
{
device = new ANT_Device(); // Create a device instance using the automatic constructor (automatic detection of USB device number and baud rate)
device.deviceResponse += new ANT_Device.dDeviceResponseHandler(DeviceResponse); // Add device response function to receive protocol event messages
device.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,
if (!device.setNetworkKey(USER_NETWORK_NUM, USER_NETWORK_KEY, 500))
{
throw new Exception("Error configuring network key");
}
device.enableRxExtendedMessages(true);
}
/* public static async void SendDeviceProperties()
* {
* try
* {
* Console.WriteLine("Sending device properties:");
* Random random = new Random();
* TwinCollection telemetryConfig = new TwinCollection();
* reportedProperties["DeviceProperty"] = random.Next(1, 6);
* Console.WriteLine(JsonConvert.SerializeObject(reportedProperties));
*
* await Client.UpdateReportedPropertiesAsync(reportedProperties);
* }
* catch (Exception ex)
* {
* Console.WriteLine();
* Console.WriteLine("Error in sample: {0}", ex.Message);
* }
* }
*/
private static async void SendTelemetryAsync(CancellationToken token)
{
try
{
//ANT Part
byte USER_RADIOFREQ = 57; // RF Frequency + 2400 MHz
//ANTPLUS KEY
byte[] USER_NETWORK_KEY = { 0xB9, 0xA5, 0x21, 0xFB, 0xBD, 0x72, 0xC3, 0x45 }; // key
byte USER_NETWORK_NUM = 0;
//Use USB dongle to connect ANT+ device
ANT_Device USB_Dongle;
USB_Dongle = new ANT_Device();
USB_Dongle.ResetSystem();
USB_Dongle.setNetworkKey(USER_NETWORK_NUM, USER_NETWORK_KEY);
ANT_Channel Channel0 = USB_Dongle.getChannel(0);
Network AntPlusNetwork = new Network(USER_NETWORK_NUM, USER_NETWORK_KEY, USER_RADIOFREQ);
HeartRateDisplay HR = new HeartRateDisplay(Channel0, AntPlusNetwork);
HR.TurnOn();
Console.WriteLine(">>ANT+ Tuen on...");
while (true)
{
byte currentHeartbeat = HR.HeartRate;
var telemetryDataPoint = new
{
heartbeat = currentHeartbeat,
};
var messageString = JsonConvert.SerializeObject(telemetryDataPoint);
var message = new Message(Encoding.ASCII.GetBytes(messageString));
token.ThrowIfCancellationRequested();
await Client.SendEventAsync(message);
Console.WriteLine("{0} > Sending heartbeat signal : {1}", DateTime.Now, messageString);
await Task.Delay(1000);
}
}
catch (Exception ex)
{
Console.WriteLine();
Console.WriteLine("Intentional shutdown: {0}", ex.Message);
}
}
public void Start()
{
try
{
usbDevice = new ANT_Device();
usbDevice.ResetSystem();
usbDevice.setNetworkKey(0, NETWORK_KEY);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.Read();
return;
}
network = new AntPlus.Types.Network(0, NETWORK_KEY, CHANNEL_FREQUENCY);
Console.WriteLine(ConfigurationManager.AppSettings["model"]);
if (ConfigurationManager.AppSettings["ridermodel"] == "fec")
{
Console.WriteLine("Using FEC for physical model.");
bikeModel = BikeModel.FEC;
}
else if (ConfigurationManager.AppSettings["ridermodel"] == "physics")
{
Console.WriteLine("Using integrated model for physical model.");
bikeModel = BikeModel.BikePhysics;
}
AntManagerState.Initialize(Single.Parse(ConfigurationManager.AppSettings["cp"]));
InitHRM(0);
InitCAD(1);
InitFEC(2);
InitBP(3);
InitSC(4);
InitAC();
InitFIT();
}
static void Main(string[] args)
{
byte USER_RADIOFREQ = 57; // RF Frequency + 2400 MHz
//Do not distrubute this key
byte[] USER_NETWORK_KEY = { 0xB9, 0xA5, 0x21, 0xFB, 0xBD, 0x72, 0xC3, 0x45 };
byte USER_NETWORK_NUM = 0;
ANT_Device USB_Dongle;
USB_Dongle = new ANT_Device();
USB_Dongle.ResetSystem();
USB_Dongle.setNetworkKey(USER_NETWORK_NUM, USER_NETWORK_KEY);
ANT_Channel Channel0 = USB_Dongle.getChannel(0);
Network AntPlusNetwork = new Network(USER_NETWORK_NUM, USER_NETWORK_KEY, USER_RADIOFREQ);
HeartRateDisplay HeartRate = new HeartRateDisplay(Channel0, AntPlusNetwork);
HeartRate.TurnOn();
while (Console.KeyAvailable == false)
{
Console.WriteLine("Heart Rate=" + HeartRate.HeartRate);
System.Threading.Thread.Sleep(500);
}
}
////////////////////////////////////////////////////////////////////////////////
// ConfigureANT
//
// Resets the system, configures the ANT channel and starts the demo
////////////////////////////////////////////////////////////////////////////////
private static void ConfigureANT()
{
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("Assigning channel...");
if (channel0.assignChannel(channelType, USER_NETWORK_NUM, 500))
{
Console.WriteLine("Channel assigned");
}
else
{
throw new Exception("Error assigning channel");
}
Console.WriteLine("Setting Channel ID...");
if (channel0.setChannelID(user_devicenum, false, user_devicetype, USER_TRANSTYPE, 500)) // Not using pairing bit
{
Console.WriteLine("Channel ID set");
}
else
{
throw new Exception("Error configuring Channel ID");
}
Console.WriteLine("Setting Radio Frequency...");
if (channel0.setChannelFreq(USER_RADIOFREQ, 500))
{
Console.WriteLine("Radio Frequency set");
}
else
{
throw new Exception("Error configuring Radio Frequency");
}
Console.WriteLine("Setting Channel Period...");
if (channel0.setChannelPeriod(user_channelperiod, 500))
{
Console.WriteLine("Channel Period set");
}
else
{
throw new Exception("Error configuring Channel Period");
}
Console.WriteLine("Opening channel...");
bBroadcasting = true;
if (channel0.openChannel(500))
{
Console.WriteLine("Channel opened");
}
else
{
bBroadcasting = false;
throw new Exception("Error opening channel");
}
#if (ENABLE_EXTENDED_MESSAGES)
// Extended messages are not supported in all ANT devices, so
// we will not wait for the response here, and instead will monitor
// the protocol events
Console.WriteLine("Enabling extended messages...");
device0.enableRxExtendedMessages(true);
#endif
}
private void InitAnt()
{
try
{
String path = Application.dataPath + "/Plugins";
ANT_Common.CustomDllSearchPath = Path.GetFullPath(path);
_device = new ANT_Device();
_device.deviceResponse += DeviceResponse;
_channel = _device.getChannel(userAntChannel);
_channel.channelResponse += ChannelResponse;
System.Threading.Thread.Sleep(500);
if (_device.setNetworkKey(USER_NETWORK_NUM, USER_NETWORK_KEY, 500))
{
Debug.Log("Network key set");
}
else
{
throw new Exception("Error configuring network key");
}
if (!_channel.assignChannel(ANT_ReferenceLibrary.ChannelType.BASE_Slave_Receive_0x00, USER_NETWORK_NUM,
500))
{
throw new Exception("Error assigning channel");
}
if (_channel.setChannelID(userDeviceNum, false, userDeviceType, userTransmissionType, 500)
) // Not using pairing bit
{
Debug.Log("Channel ID set");
}
else
{
throw new Exception("Error configuring Channel ID");
}
if (_channel.setChannelFreq(userUserRadioFreq, 500))
{
Debug.Log("Radio Frequency set");
}
else
{
throw new Exception("Error configuring Radio Frequency");
}
Debug.Log("Setting Channel Period...");
if (_channel.setChannelPeriod(userChannelPeriod, 500))
{
Debug.Log("Channel Period set");
}
else
{
throw new Exception("Error configuring Channel Period");
}
if (!_channel.openChannel(500))
{
throw new Exception("Error during opening channel");
}
_device.enableRxExtendedMessages(true);
}
catch (Exception e)
{
if (_device == null)
{
throw new Exception("Could not connect to any ANT device\nDetails:\n" + e);
}
throw new Exception("Error connecting to ANT: " + e.Message);
}
}
////////////////////////////////////////////////////////////////////////////////
// ConfigureANT
//
// Resets the system, configures the ANT channel and starts the demo
////////////////////////////////////////////////////////////////////////////////
private static void ConfigureANT()
{
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("Assigning channel...");
if (channel0.assignChannel(channelType, USER_NETWORK_NUM, 500))
{
Console.WriteLine("Channel assigned");
}
else
{
throw new Exception("Error assigning channel");
}
Console.WriteLine("Setting Channel ID...");
if (channel0.setChannelID(USER_DEVICENUM, false, USER_DEVICETYPE, USER_TRANSTYPE, 500)) // Not using pairing bit
{
Console.WriteLine("Channel ID set");
}
else
{
throw new Exception("Error configuring Channel ID");
}
Console.WriteLine("Setting Radio Frequency...");
if (channel0.setChannelFreq(USER_RADIOFREQ, 500))
{
Console.WriteLine("Radio Frequency set");
}
else
{
throw new Exception("Error configuring Radio Frequency");
}
Console.WriteLine("Setting Channel Period...");
if (channel0.setChannelPeriod(USER_CHANNELPERIOD, 500))
{
Console.WriteLine("Channel Period set");
}
else
{
throw new Exception("Error configuring Channel Period");
}
Console.WriteLine("Opening channel...");
bBroadcasting = true;
if (channel0.openChannel(500))
{
Console.WriteLine("Channel opened");
}
else
{
bBroadcasting = false;
throw new Exception("Error opening channel");
}
}
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();
}
private void setupAndOpenScan(ANT_Device deviceToSetup, ANT_ReferenceLibrary.ChannelType channelType)
{
//We try-catch and forward exceptions to the calling function to handle and pass the errors to the user
try
{
if (!deviceToSetup.setNetworkKey(0, USER_NETWORK_KEY, 500))
{
// threadSafePrintLine("Network Key set to ... well, you know, on net 0.", textBox_Display);
// else
throw new Exception("Channel assignment operation failed.");
}
//To access an ANTChannel on a paticular device we need to get the channel from the device
//Once again, this ensures you have a valid object associated with a real-world ANTChannel
//ie: You can only get channels that actually exist
ANT_Channel channel0 = deviceToSetup.getChannel(0);
//Almost all functions in the library have two overloads, one with a response wait time and one without
//If you give a wait time, you can check the return value for success or failure of the command, however
//the wait time version is blocking. 500ms is usually a safe value to ensure you wait long enough for any response.
//But with no wait time, the command is simply sent and you have to monitor the device response for success or failure.
//To setup channels for communication there are three mandatory operations assign, setID, and Open
//Various other settings such as message period and network key affect communication
//between two channels as well, see the documentation for further details on these functions.
//So, first we assign the channel, we have already been passed the channelType which is an enum that has various flags
//If we were doing something more advanced we could use a bitwise or ie:base|adv1|adv2 here too
//We also use net 0 which has the public network key by default
if (!channel0.assignChannel(channelType, 0, 500))
{
// threadSafePrintLine("Ch assigned to " + channelType + " on net 0.", textBox_Display);
// else
throw new Exception("Channel assignment operation failed.");
}
//Next we have to set the channel id. Slaves will only communicate with a master device that
//has the same id unless one or more of the id parameters are set to a wild card 0. If wild cards are included
//the slave will search until it finds a broadcast that matches all the non-wild card parameters in the id.
//For now we pick an arbitrary id so that we can ensure we match between the two devices.
//The pairing bit ensures on a search that you only pair with devices that also are requesting
//pairing, but we don't need it here so we set it to false
if (!channel0.setChannelID(USER_DEVICENUM, false, USER_DEVICETYPE, USER_TRANSTYPE, 500))
{
// threadSafePrintLine("Set channel ID to " + USER_DEVICENUM + " " + USER_DEVICETYPE + " " + USER_TRANSTYPE, textBox_Display);
// else
throw new Exception("Set Channel ID operation failed.");
}
//Setting the channel period isn't mandatory, but we set it slower than the default period so messages aren't coming so fast
//The period parameter is divided by 32768 to set the period of a message in seconds. So here, 16384/32768 = 1/2 sec/msg = 2Hz
if (!channel0.setChannelPeriod(USER_CHANNELPERIOD, 500))
{
// threadSafePrintLine("Message Period set to " + USER_CHANNELPERIOD + "/32768 seconds per message", textBox_Display);
// else
throw new Exception("Set Channel Period Op Faildd.");
}
if (!channel0.setChannelFreq(USER_RADIOFREQ, 500))
{
// threadSafePrintLine("Message Radio Freq set to +" + USER_RADIOFREQ, textBox_Display);
// else
throw new Exception("Set Radio Freq failed.");
}
if (!deviceToSetup.enableRxExtendedMessages(true, 500))
{
// threadSafePrintLine("Requesting Extended Messages", textBox_Display);
// else
throw new Exception("Extenned Message Request Failed.");
}
//Now we open the channel
if (!deviceToSetup.openRxScanMode(500))
{
// threadSafePrintLine("Opened Device in Scan mode" + Environment.NewLine, textBox_Display);
// else
throw new Exception("Channel Open operation failed.");
}
}
catch (Exception ex)
{
throw new Exception("Setup and Open Failed. " + ex.Message + Environment.NewLine);
}
}
/// <summary>
/// Configure the client beacon parameters, and start transmitting/beaconing
/// </summary>
/// <param name="antDevice">ANT USB device</param>
public void ConfigureClient(ANT_Device antDevice)
{
// Configure ANT Channel parameters
antfsClient.SetClientNetworkKey(0, Demo.NetworkKey);
antfsClient.SetChannelID(Demo.DeviceType, Demo.TransmissionType);
antfsClient.SetChannelPeriod(Demo.ChannelPeriod);
// Setup client configuration parameters.
// ANTFS_ClientParameters is a struct, so make sure to initialize ALL parameters
ANTFS_ClientParameters clientConfig = new ANTFS_ClientParameters();
clientConfig.BeaconDeviceType = Demo.ClientDeviceType;
clientConfig.BeaconManufacturerID = Demo.ClientManufacturerID;
clientConfig.BeaconRadioFrequency = Demo.SearchRF;
clientConfig.LinkPeriod = Demo.LinkPeriod;
clientConfig.AuthenticationType = ClientAuthenticationType;
clientConfig.IsDataAvailable = DataAvailable;
clientConfig.IsPairingEnabled = PairingEnabled;
clientConfig.IsUploadEnabled = UploadEnabled;
clientConfig.BeaconTimeout = BeaconTimeout;
clientConfig.PairingTimeout = PairingTimeout;
clientConfig.SerialNumber = antDevice.getSerialNumber(); // Use the serial number of the USB stick to identify the client
// Apply configuration
antfsClient.Configure(clientConfig);
// Configure friendly name and passkey (optional)
antfsClient.SetFriendlyName(ClientFriendlyName);
antfsClient.SetPassKey(PassKey);
// Create directory, an add a single entry, of the configured size
dirFS = new ANTFS_Directory();
ANTFS_Directory.Entry fileEntry;
fileEntry.FileIndex = 1;
fileEntry.FileSize = TestFileSize;
fileEntry.FileDataType = 1;
fileEntry.FileNumber = 1;
fileEntry.FileSubType = 0;
fileEntry.GeneralFlags = (byte)(ANTFS_Directory.GeneralFlags.Read | ANTFS_Directory.GeneralFlags.Write | ANTFS_Directory.GeneralFlags.Erase);
fileEntry.SpecificFlags = 0;
fileEntry.TimeStamp = 0; // TODO: Encode the timestamp properly
dirFS.AddEntry(fileEntry);
if (Demo.AntfsBroadcast)
{
// If we want to use ANT-FS broadcast mode, and start the channel in broadcast mode,
// setup callback to handle responses for channel 0 while in broadcast mode
channel0.channelResponse += new dChannelResponseHandler(HandleChannelResponses);
// Configure the channel as a master, and look for the request message in the channel callback
// to switch to ANT-FS mode
if (!antDevice.setNetworkKey(Demo.NetworkNumber, Demo.NetworkKey, 500))
{
throw new Exception("Error configuring network key");
}
if (!channel0.assignChannel(ANT_ReferenceLibrary.ChannelType.BASE_Master_Transmit_0x10, Demo.NetworkNumber, 500))
{
throw new Exception("Error assigning channel");
}
if (!channel0.setChannelID((ushort)clientConfig.SerialNumber, false, Demo.DeviceType, Demo.TransmissionType, 500))
{
throw new Exception("Error configuring Channel ID");
}
if (!channel0.setChannelFreq(Demo.SearchRF, 500))
{
throw new Exception("Error configuring radio frequency");
}
if (!channel0.setChannelPeriod(Demo.ChannelPeriod, 500))
{
throw new Exception("Error configuring channel period");
}
if (!channel0.openChannel(500))
{
throw new Exception("Error opening channel");
}
}
else
{
// If we want to start in ANT-FS mode, just open the beacon
antfsClient.OpenBeacon();
}
}