void ChannelResponse(ANT_Response response)
{
if (response.getChannelEventCode() == ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_TX_FAILED_0x06)
{
deviceChannel.sendAcknowledgedData(pageToSend); //send the page again if the transfer failed
}
}
void DeviceEventResponse(ANT_Response response)
{
var ec = response.getChannelEventCode();
switch (response.getMessageID())
{
case ANTMessageID.CHANNEL_SEARCH_TIMEOUT_0x44:
Debug.WriteLine("DeviceEventResponse CHANNEL_SEARCH_TIMEOUT_0x44");
break;
case ANTMessageID.CLOSE_CHANNEL_0x4C:
if (ec == ANTEventID.CHANNEL_IN_WRONG_STATE_0x15)
{
Debug.WriteLine("CHANNEL_IN_WRONG_STATE_0x15: Channel is already closed");
}
break;
case ANTMessageID.NETWORK_KEY_0x46:
case ANTMessageID.ASSIGN_CHANNEL_0x42:
case ANTMessageID.CHANNEL_ID_0x51:
case ANTMessageID.CHANNEL_RADIO_FREQ_0x45:
case ANTMessageID.CHANNEL_MESG_PERIOD_0x43:
case ANTMessageID.OPEN_CHANNEL_0x4B:
case ANTMessageID.UNASSIGN_CHANNEL_0x41:
if (ec != ANTEventID.RESPONSE_NO_ERROR_0x00)
{
PrintErrorMessage(response, "UNASSIGN_CHANNEL_0x41 RESPONSE_NO_ERROR_0x00");
}
break;
case ANTMessageID.RX_EXT_MESGS_ENABLE_0x66:
if (ec == ANTEventID.INVALID_MESSAGE_0x28)
{
Debug.WriteLine("Extended messages not supported in this ANT product");
break;
}
else if (ec != ANTEventID.RESPONSE_NO_ERROR_0x00)
{
PrintErrorMessage(response, "RX_EXT_MESGS_ENABLE_0x66 RESPONSE_NO_ERROR_0x00");
break;
}
// Extended messages enabled
break;
case ANTMessageID.REQUEST_0x4D:
if (ec == ANTEventID.INVALID_MESSAGE_0x28)
{
Debug.WriteLine("Requested message not supported in this ANT product");
break;
}
break;
default:
PrintErrorMessage(response, "Unhandled response");
break;
}
}
/// <summary>
/// Handle channel responses, while in broadcast mode
/// </summary>
/// <param name="response">ANT channel events</param>
public void HandleChannelResponses(ANT_Response response)
{
// Make sure we are not processing responses if ANT-FS is active
if (antfsClient.GetStatus() != ANTFS_ClientChannel.State.Idle)
{
return;
}
if ((response.responseID == (byte)ANT_ReferenceLibrary.ANTMessageID.RESPONSE_EVENT_0x40))
{
if (response.getChannelEventCode() == ANT_ReferenceLibrary.ANTEventID.EVENT_TX_0x03)
{
channel0.sendBroadcastData(txBuffer);
txBuffer[7]++;
Console.Write("Tx: " + Demo.CursorStrings[cursorIndex++] + "\r");
cursorIndex &= 3;
}
else if (response.getChannelEventCode() == ANT_ReferenceLibrary.ANTEventID.EVENT_CHANNEL_CLOSED_0x07)
{
Console.WriteLine("Channel Closed");
Console.WriteLine("Unassigning Channel...");
if (channel0.unassignChannel(500))
{
Console.WriteLine("Unassigned Channel");
Console.WriteLine("Press enter to exit");
demoDone = true;
}
}
}
else if (response.responseID == (byte)ANT_ReferenceLibrary.ANTMessageID.ACKNOWLEDGED_DATA_0x4F)
{
// Look for request page
if (response.messageContents[1] == 0x46)
{
if (response.messageContents[6] == 0 &&
response.messageContents[7] == 0x43 &&
response.messageContents[8] == 0x02)
{
Console.WriteLine("Remote device requesting ANT-FS session");
}
antfsClient.OpenBeacon();
}
}
}
private void handleANTResponses(ANT_Response response)
{
if ((int)response.responseID == 64)
{
if (response.getChannelEventCode() == ANT_ReferenceLibrary.ANTEventID.RESPONSE_NO_ERROR_0x00)
{
Debug.LogError("SET " + ((object)response.getMessageID()).ToString() + "... OK");
}
else
{
Debug.LogError("Response: " + ((object)response.getChannelEventCode()).ToString()
+ " to " + ((object)response.getMessageID()).ToString());
}
}
else
{
Debug.LogError(((object)(ANT_ReferenceLibrary.ANTMessageID)response.responseID).ToString());
}
}
void OnChannelResponse(ANT_Response response)
{
if (response.getChannelEventCode() == ANT_ReferenceLibrary.ANTEventID.EVENT_RX_FAIL_0x02)
{
DisplayText("channel " + response.antChannel.ToString() + " " + "RX fail");
}
else if (response.getChannelEventCode() == ANT_ReferenceLibrary.ANTEventID.EVENT_RX_FAIL_GO_TO_SEARCH_0x08)
{
DisplayText("channel " + response.antChannel.ToString() + " " + "Go to search");
}
else if (response.getChannelEventCode() == ANT_ReferenceLibrary.ANTEventID.EVENT_TX_0x03)
{
DisplayText("channel " + response.antChannel.ToString() + " " + "Tx: (" + response.antChannel.ToString() + ")" + BitConverter.ToString(hrChannel.txBuffer));
}
else
{
DisplayText("channel " + response.antChannel.ToString() + " " + response.getChannelEventCode());
}
}
private static void Tramp_ChannelResponse(ANT_Response response)
{
try
{
ANT_ReferenceLibrary.ANTMessageID responseID = (ANT_ReferenceLibrary.ANTMessageID)response.responseID;
if (responseID != ANT_ReferenceLibrary.ANTMessageID.RESPONSE_EVENT_0x40)
{
switch (responseID)
{
case ANT_ReferenceLibrary.ANTMessageID.BROADCAST_DATA_0x4E:
case ANT_ReferenceLibrary.ANTMessageID.ACKNOWLEDGED_DATA_0x4F:
case ANT_ReferenceLibrary.ANTMessageID.BURST_DATA_0x50:
break;
default:
switch (responseID)
{
case ANT_ReferenceLibrary.ANTMessageID.EXT_BROADCAST_DATA_0x5D:
case ANT_ReferenceLibrary.ANTMessageID.EXT_ACKNOWLEDGED_DATA_0x5E:
case ANT_ReferenceLibrary.ANTMessageID.EXT_BURST_DATA_0x5F:
break;
default:
goto IL_226;
}
break;
}
bool flag = ANT.bDisplay;
if (flag)
{
bool flag2 = response.isExtended();
if (flag2)
{
ANT_ChannelID chID = response.getDeviceIDfromExt();
}
bool flag3 = response.responseID == 78 || response.responseID == 93;
if (!flag3)
{
bool flag4 = response.responseID == 79 || response.responseID == 94;
if (flag4)
{
}
}
}
else
{
string[] expr_1F2 = new string[]
{
"|",
"/",
"_",
"\\"
};
ANT.iIndex &= 3;
}
}
else
{
switch (response.getChannelEventCode())
{
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_SEARCH_TIMEOUT_0x01:
MessageBox.Show("Search Timeout");
break;
case ANT_ReferenceLibrary.ANTEventID.EVENT_TX_0x03:
{
byte[] expr_8A_cp_0 = ANT.txBuffer;
int expr_8A_cp_1 = 0;
expr_8A_cp_0[expr_8A_cp_1] += 1;
bool flag5 = ANT.bBroadcasting;
if (flag5)
{
ANT.channel1.sendBroadcastData(ANT.txBuffer);
bool flag6 = ANT.bDisplay;
if (flag6)
{
}
}
else
{
string[] ac = new string[]
{
"|",
"/",
"_",
"\\"
};
Console.Write("Tx: " + ac[ANT.iIndex++] + "\r");
ANT.iIndex &= 3;
}
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_RX_FAILED_0x04:
MessageBox.Show("Burst receive has failed");
break;
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_TX_COMPLETED_0x05:
MessageBox.Show("Transfer Completed");
break;
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_TX_FAILED_0x06:
MessageBox.Show("Transfer Failed");
break;
case ANT_ReferenceLibrary.ANTEventID.EVENT_CHANNEL_CLOSED_0x07:
{
bool flag7 = ANT.channel1.unassignChannel(500u);
if (flag7)
{
ANT.bDone = true;
}
break;
}
}
}
IL_226 :;
}
catch (Exception ex)
{
MessageBox.Show("Channel response processing failed with exception: " + ex.Message);
}
}
/*
* private ushort _movingAverage(ushort aSample)
* {
* for (int index = 0; index < this._gSampleHistory.Length - 1; ++index)
* this._gSampleHistory[index] = this._gSampleHistory[index + 1];
* this._gSampleHistory[this._gSampleHistory.Length - 1] = aSample;
* uint num1 = 0U;
* foreach (ushort num2 in this._gSampleHistory)
* num1 += (uint) num2;
* return (ushort) ((ulong) num1 / (ulong) this._gSampleHistory.Length);
* }
*
* private ushort _variance(ushort aMean, ushort aSample)
* {
* try {
* return Convert.ToUInt16(Math.Sqrt(Math.Pow((double) ((int) aSample - (int) aMean), 2.0)));
* }
* catch
* {
* return (ushort) 0;
* }
* }
*
*/
private void handleBroadcastChannelResponses(ANT_Response response)
{
switch ((ANT_ReferenceLibrary.ANTMessageID)response.responseID)
{
case ANT_ReferenceLibrary.ANTMessageID.RESPONSE_EVENT_0x40:
switch (response.getChannelEventCode())
{
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_SEARCH_TIMEOUT_0x01:
Debug.LogError("Search timed out");
return;
case ANT_ReferenceLibrary.ANTEventID.EVENT_TX_0x03:
this.antfsBroadcastChannel.sendBroadcastData(this.BroadcastBuffer);
this.BroadcastBuffer [7] = (byte)((uint)this.BroadcastBuffer [7] + 1U);
return;
case ANT_ReferenceLibrary.ANTEventID.EVENT_CHANNEL_CLOSED_0x07:
Debug.Log("Channel closed, trying again");
if (this.antfsBroadcastChannel.openChannel(this.deviceChannel))
{
return;
}
Debug.LogError("Failed to open the channel");
return;
case ANT_ReferenceLibrary.ANTEventID.EVENT_CHANNEL_ACTIVE_0x0F:
return;
default:
Debug.Log(string.Format("{0}", (object)(int)response.getChannelEventCode()));
return;
}
case ANT_ReferenceLibrary.ANTMessageID.BROADCAST_DATA_0x4E:
Debug.Log("Channel = " + (object)response.antChannel);
try {
//this.Invoke ((Delegate)this.aListBoxMessageDelegate, (object)response.antChannel,
// (object)response.getDataPayload ());
this.PublishReading(response);
break;
} catch (Exception ex) {
Debug.LogError(((object)ex.Message).ToString());
break;
}
case ANT_ReferenceLibrary.ANTMessageID.ACKNOWLEDGED_DATA_0x4F:
if ((int)response.getDataPayload() [0] != 70 || ((int)response.getDataPayload() [5] != 0 ||
(int)response.getDataPayload() [6] != 67 || (int)response.getDataPayload() [7] != 2))
{
break;
}
else
{
break;
}
case ANT_ReferenceLibrary.ANTMessageID.CHANNEL_ID_0x51:
break;
default:
Debug.LogError("HBCR:Unexpected message = " + (object)response.responseID);
break;
}
}
internal void ChannelResponse0(ANT_Response response)
{
Random rnd = new Random();
try
{
switch ((ANT_ReferenceLibrary.ANTMessageID)response.responseID)
{
case ANT_ReferenceLibrary.ANTMessageID.RESPONSE_EVENT_0x40:
{
switch (response.getChannelEventCode())
{
case ANT_ReferenceLibrary.ANTEventID.EVENT_TX_0x03:
{
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_SEARCH_TIMEOUT_0x01:
{
Console.WriteLine("Search Timeout");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_FAIL_0x02:
{
Console.WriteLine("Rx Fail");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_RX_FAILED_0x04:
{
Console.WriteLine("Burst receive has failed");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_TX_COMPLETED_0x05:
{
Console.WriteLine("Transfer Completed");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_TX_FAILED_0x06:
{
Console.WriteLine("Transfer Failed");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_CHANNEL_CLOSED_0x07:
{
Console.WriteLine("Channel Closed");
Console.WriteLine("Unassigning Channel...");
if (channel0.unassignChannel(500))
{
Console.WriteLine("Unassigned Channel");
Console.WriteLine("Press enter to exit");
}
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_FAIL_GO_TO_SEARCH_0x08:
{
Console.WriteLine("Go to Search");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_CHANNEL_COLLISION_0x09:
{
Console.WriteLine("Channel Collision");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_TX_START_0x0A:
{
Console.WriteLine("Burst Started");
break;
}
default:
{
Console.WriteLine("Unhandled Channel Event " + response.getChannelEventCode());
break;
}
}
break;
}
case ANT_ReferenceLibrary.ANTMessageID.BROADCAST_DATA_0x4E:
case ANT_ReferenceLibrary.ANTMessageID.ACKNOWLEDGED_DATA_0x4F:
case ANT_ReferenceLibrary.ANTMessageID.BURST_DATA_0x50:
case ANT_ReferenceLibrary.ANTMessageID.EXT_BROADCAST_DATA_0x5D:
case ANT_ReferenceLibrary.ANTMessageID.EXT_ACKNOWLEDGED_DATA_0x5E:
case ANT_ReferenceLibrary.ANTMessageID.EXT_BURST_DATA_0x5F:
{
// Process received messages here
}
break;
default:
{
Console.WriteLine("Unknown Message " + response.responseID);
break;
}
}
}
catch (Exception ex)
{
Console.WriteLine("Channel response processing failed with exception: " + ex.Message);
}
}
void ChannelEventResponse(ANT_Response response)
{
switch (response.getChannelEventCode())
{
// This event indicates that a message has just been
// sent over the air. We take advantage of this event to set
// up the data for the next message period.
case ANTEventID.EVENT_TX_0x03:
{
txBuffer[0]++; // Increment the first byte of the buffer
// Broadcast data will be sent over the air on
// the next message period
if (isBroadcasting)
{
channel.sendBroadcastData(txBuffer);
}
break;
}
case ANTEventID.EVENT_RX_SEARCH_TIMEOUT_0x01:
{
Debug.WriteLine("Search Timeout");
OnSearchEnded(this, false, 0);
Closed();
break;
}
case ANTEventID.EVENT_RX_FAIL_0x02:
{
// Rx Fail
break;
}
case ANTEventID.EVENT_TRANSFER_RX_FAILED_0x04:
{
// Burst receive has failed
break;
}
case ANTEventID.EVENT_TRANSFER_TX_COMPLETED_0x05:
{
// Transfer Completed
break;
}
case ANTEventID.EVENT_TRANSFER_TX_FAILED_0x06:
{
// Transfer Failed
break;
}
case ANTEventID.EVENT_CHANNEL_CLOSED_0x07:
{
Debug.WriteLine("Channel closed");
// This event should be used to determine that the channel is closed.
Closed();
break;
}
case ANTEventID.EVENT_RX_FAIL_GO_TO_SEARCH_0x08:
{
// Go to Search
break;
}
case ANTEventID.EVENT_CHANNEL_COLLISION_0x09:
{
Debug.WriteLine("Channel Collision");
break;
}
case ANTEventID.EVENT_TRANSFER_TX_START_0x0A:
{
// Burst Started
break;
}
default:
{
Debug.WriteLine("Unhandled Channel Event " + response.getChannelEventCode());
break;
}
}
}
////////////////////////////////////////////////////////////////////////////////
// DeviceResponse
//
// Called whenever a message is received from ANT unless that message is a
// channel event message.
//
// response: ANT message
////////////////////////////////////////////////////////////////////////////////
static void DeviceResponse(ANT_Response response)
{
switch ((ANT_ReferenceLibrary.ANTMessageID)response.responseID)
{
case ANT_ReferenceLibrary.ANTMessageID.STARTUP_MESG_0x6F:
{
Console.Write("RESET Complete, reason: ");
byte ucReason = response.messageContents[0];
if (ucReason == (byte)ANT_ReferenceLibrary.StartupMessage.RESET_POR_0x00)
{
Console.WriteLine("RESET_POR");
}
if (ucReason == (byte)ANT_ReferenceLibrary.StartupMessage.RESET_RST_0x01)
{
Console.WriteLine("RESET_RST");
}
if (ucReason == (byte)ANT_ReferenceLibrary.StartupMessage.RESET_WDT_0x02)
{
Console.WriteLine("RESET_WDT");
}
if (ucReason == (byte)ANT_ReferenceLibrary.StartupMessage.RESET_CMD_0x20)
{
Console.WriteLine("RESET_CMD");
}
if (ucReason == (byte)ANT_ReferenceLibrary.StartupMessage.RESET_SYNC_0x40)
{
Console.WriteLine("RESET_SYNC");
}
if (ucReason == (byte)ANT_ReferenceLibrary.StartupMessage.RESET_SUSPEND_0x80)
{
Console.WriteLine("RESET_SUSPEND");
}
break;
}
case ANT_ReferenceLibrary.ANTMessageID.VERSION_0x3E:
{
Console.WriteLine("VERSION: " + new ASCIIEncoding().GetString(response.messageContents));
break;
}
case ANT_ReferenceLibrary.ANTMessageID.RESPONSE_EVENT_0x40:
{
switch (response.getMessageID())
{
case ANT_ReferenceLibrary.ANTMessageID.CLOSE_CHANNEL_0x4C:
{
if (response.getChannelEventCode() == ANT_ReferenceLibrary.ANTEventID.CHANNEL_IN_WRONG_STATE_0x15)
{
Console.WriteLine("Channel is already closed");
Console.WriteLine("Unassigning Channel...");
if (channel0.unassignChannel(500))
{
Console.WriteLine("Unassigned Channel");
Console.WriteLine("Press enter to exit");
bDone = true;
}
}
break;
}
case ANT_ReferenceLibrary.ANTMessageID.NETWORK_KEY_0x46:
case ANT_ReferenceLibrary.ANTMessageID.ASSIGN_CHANNEL_0x42:
case ANT_ReferenceLibrary.ANTMessageID.CHANNEL_ID_0x51:
case ANT_ReferenceLibrary.ANTMessageID.CHANNEL_RADIO_FREQ_0x45:
case ANT_ReferenceLibrary.ANTMessageID.CHANNEL_MESG_PERIOD_0x43:
case ANT_ReferenceLibrary.ANTMessageID.OPEN_CHANNEL_0x4B:
case ANT_ReferenceLibrary.ANTMessageID.UNASSIGN_CHANNEL_0x41:
{
if (response.getChannelEventCode() != ANT_ReferenceLibrary.ANTEventID.RESPONSE_NO_ERROR_0x00)
{
Console.WriteLine(String.Format("Error {0} configuring {1}", response.getChannelEventCode(), response.getMessageID()));
}
break;
}
case ANT_ReferenceLibrary.ANTMessageID.RX_EXT_MESGS_ENABLE_0x66:
{
if (response.getChannelEventCode() == ANT_ReferenceLibrary.ANTEventID.INVALID_MESSAGE_0x28)
{
Console.WriteLine("Extended messages not supported in this ANT product");
break;
}
else if (response.getChannelEventCode() != ANT_ReferenceLibrary.ANTEventID.RESPONSE_NO_ERROR_0x00)
{
Console.WriteLine(String.Format("Error {0} configuring {1}", response.getChannelEventCode(), response.getMessageID()));
break;
}
Console.WriteLine("Extended messages enabled");
break;
}
case ANT_ReferenceLibrary.ANTMessageID.REQUEST_0x4D:
{
if (response.getChannelEventCode() == ANT_ReferenceLibrary.ANTEventID.INVALID_MESSAGE_0x28)
{
Console.WriteLine("Requested message not supported in this ANT product");
break;
}
break;
}
default:
{
Console.WriteLine("Unhandled response " + response.getChannelEventCode() + " to message " + response.getMessageID()); break;
}
}
break;
}
}
}
private static void ChannelResponse(ANT_Response response)
{
try
{
ANT_ReferenceLibrary.ANTMessageID responseID = (ANT_ReferenceLibrary.ANTMessageID)response.responseID;
if (responseID != ANT_ReferenceLibrary.ANTMessageID.RESPONSE_EVENT_0x40)
{
switch (responseID)
{
case ANT_ReferenceLibrary.ANTMessageID.BROADCAST_DATA_0x4E:
case ANT_ReferenceLibrary.ANTMessageID.ACKNOWLEDGED_DATA_0x4F:
case ANT_ReferenceLibrary.ANTMessageID.BURST_DATA_0x50:
break;
default:
switch (responseID)
{
case ANT_ReferenceLibrary.ANTMessageID.EXT_BROADCAST_DATA_0x5D:
case ANT_ReferenceLibrary.ANTMessageID.EXT_ACKNOWLEDGED_DATA_0x5E:
case ANT_ReferenceLibrary.ANTMessageID.EXT_BURST_DATA_0x5F:
break;
default:
goto IL_2C9;
}
break;
}
bool flag = ANT_TAPING.bDisplay;
if (flag)
{
bool flag2 = response.isExtended();
if (flag2)
{
ANT_ChannelID chID = response.getDeviceIDfromExt();
}
bool flag3 = response.responseID == 78 || response.responseID == 93;
if (!flag3)
{
bool flag4 = response.responseID == 79 || response.responseID == 94;
if (flag4)
{
}
}
byte time_MSB = response.messageContents[6];
byte time_LSB = response.messageContents[5];
int Time = ((int)time_MSB << 8) + (int)time_LSB;
byte count_MSB = response.messageContents[8];
byte count_LSB = response.messageContents[7];
int Count = ((int)count_MSB << 8) + (int)count_LSB;
bool flag5 = ANT_TAPING.time_Last == 0 || ANT_TAPING.time_Last == Time;
if (flag5)
{
ANT_TAPING.time_Last = Time;
ANT_TAPING.count_Last = Count;
}
else
{
int tramp = (Count - ANT_TAPING.count_Last) * 60 * 1024 / (Time - ANT_TAPING.time_Last);
ANT_TAPING.time_Last = Time;
ANT_TAPING.count_Last = Count;
}
ANT_TAPING.Tramp = ANT_TAPING.Tramp.ToString();
}
else
{
string[] expr_295 = new string[]
{
"|",
"/",
"_",
"\\"
};
ANT_TAPING.iIndex &= 3;
}
}
else
{
switch (response.getChannelEventCode())
{
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_SEARCH_TIMEOUT_0x01:
MessageBox.Show("Search Timeout");
break;
case ANT_ReferenceLibrary.ANTEventID.EVENT_TX_0x03:
{
byte[] expr_8A_cp_0 = ANT_TAPING.txBuffer;
int expr_8A_cp_1 = 0;
expr_8A_cp_0[expr_8A_cp_1] += 1;
bool flag6 = ANT_TAPING.bBroadcasting;
if (flag6)
{
ANT_TAPING.channel0.sendBroadcastData(ANT_TAPING.txBuffer);
bool flag7 = ANT_TAPING.bDisplay;
if (flag7)
{
}
}
else
{
string[] ac = new string[]
{
"|",
"/",
"_",
"\\"
};
Console.Write("Tx: " + ac[ANT_TAPING.iIndex++] + "\r");
ANT_TAPING.iIndex &= 3;
}
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_RX_FAILED_0x04:
MessageBox.Show("Burst receive has failed");
break;
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_TX_COMPLETED_0x05:
MessageBox.Show("Transfer Completed");
break;
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_TX_FAILED_0x06:
MessageBox.Show("Transfer Failed");
break;
case ANT_ReferenceLibrary.ANTEventID.EVENT_CHANNEL_CLOSED_0x07:
{
bool flag8 = ANT_TAPING.channel0.unassignChannel(500u);
if (flag8)
{
ANT_TAPING.bDone = true;
}
break;
}
}
}
IL_2C9 :;
}
catch (Exception ex)
{
MessageBox.Show("Channel response processing failed with exception: " + ex.Message);
}
}
/// <summary>
/// A new measurment has been recieved from the HRM.
/// </summary>
/// <param name="response">The response object recieved by the ANT+ driver. This contains the status of the HRM device and the value measured by the sensor.</param>
static void ChannelResponse(ANT_Response response)
{
try
{
switch ((ANT_ReferenceLibrary.ANTMessageID)response.responseID)
{
case ANT_ReferenceLibrary.ANTMessageID.RESPONSE_EVENT_0x40:
{
switch (response.getChannelEventCode())
{
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_SEARCH_TIMEOUT_0x01:
{
Console.WriteLine("Search Timeout");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_FAIL_0x02:
{
Console.WriteLine("Rx Fail");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_RX_FAILED_0x04:
{
Console.WriteLine("Burst receive has failed");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_CHANNEL_CLOSED_0x07:
{
// This event should be used to determine that the channel is closed.
Console.WriteLine("Channel Closed");
Console.WriteLine("Unassigning Channel...");
if (channel0.unassignChannel(500))
{
Console.WriteLine("Unassigned Channel");
Console.WriteLine("Press enter to exit");
}
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_FAIL_GO_TO_SEARCH_0x08:
{
Console.WriteLine("Go to Search");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_CHANNEL_COLLISION_0x09:
{
Console.WriteLine("Channel Collision");
break;
}
default:
{
Console.WriteLine("Unhandled Channel Event " + response.getChannelEventCode());
break;
}
}
break;
}
case ANT_ReferenceLibrary.ANTMessageID.BROADCAST_DATA_0x4E:
case ANT_ReferenceLibrary.ANTMessageID.ACKNOWLEDGED_DATA_0x4F:
case ANT_ReferenceLibrary.ANTMessageID.BURST_DATA_0x50:
case ANT_ReferenceLibrary.ANTMessageID.EXT_BROADCAST_DATA_0x5D:
case ANT_ReferenceLibrary.ANTMessageID.EXT_ACKNOWLEDGED_DATA_0x5E:
case ANT_ReferenceLibrary.ANTMessageID.EXT_BURST_DATA_0x5F:
{
// Send the recieved packet to Unity
AsynchronousSocketListener.Send(response.messageContents[8].ToString());
Console.WriteLine(response.messageContents[8]);
Console.Write(BitConverter.ToString(response.getDataPayload()) + Environment.NewLine); // Display data payload
break;
}
default:
{
Console.WriteLine("Unknown Message " + response.responseID);
break;
}
}
}
catch (Exception ex)
{
Console.WriteLine("Channel response processing failed with exception: " + ex.Message);
}
}
static void ChannelResponsePower(ANT_Response response)
{
try
{
switch ((ANT_ReferenceLibrary.ANTMessageID)response.responseID)
{
case ANT_ReferenceLibrary.ANTMessageID.RESPONSE_EVENT_0x40:
{
switch (response.getChannelEventCode())
{
// This event indicates that a message has just been
// sent over the air. We take advantage of this event to set
// up the data for the next message period.
case ANT_ReferenceLibrary.ANTEventID.EVENT_TX_0x03:
{
workerDebug.RunWorkerAsync(argument: new object[] { "pacchetto potenza inviato con successo", 2 });
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_SEARCH_TIMEOUT_0x01:
{
Console.WriteLine("Search Timeout");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_FAIL_0x02:
{
Console.WriteLine("Rx Fail");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_RX_FAILED_0x04:
{
Console.WriteLine("Burst receive has failed");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_TX_COMPLETED_0x05:
{
Console.WriteLine("Transfer Completed");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_TX_FAILED_0x06:
{
Console.WriteLine("Transfer Failed");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_CHANNEL_CLOSED_0x07:
{
// This event should be used to determine that the channel is closed.
Console.WriteLine("Channel Closed");
Console.WriteLine("Unassigning Channel...");
if (channel2.unassignChannel(500))
{
Console.WriteLine("Unassigned Channel");
Console.WriteLine("Press enter to exit");
}
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_FAIL_GO_TO_SEARCH_0x08:
{
Console.WriteLine("Go to Search");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_CHANNEL_COLLISION_0x09:
{
Console.WriteLine("Channel Collision banana");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_TX_START_0x0A:
{
Console.WriteLine("Burst Started");
break;
}
default:
{
Console.WriteLine("Unhandled Channel Event " + response.getChannelEventCode());
break;
}
}
break;
}
case ANT_ReferenceLibrary.ANTMessageID.BROADCAST_DATA_0x4E:
case ANT_ReferenceLibrary.ANTMessageID.ACKNOWLEDGED_DATA_0x4F:
case ANT_ReferenceLibrary.ANTMessageID.BURST_DATA_0x50:
case ANT_ReferenceLibrary.ANTMessageID.EXT_BROADCAST_DATA_0x5D:
case ANT_ReferenceLibrary.ANTMessageID.EXT_ACKNOWLEDGED_DATA_0x5E:
case ANT_ReferenceLibrary.ANTMessageID.EXT_BURST_DATA_0x5F:
{
}
break;
default:
{
Console.WriteLine("Unknown Message " + response.responseID);
break;
}
}
}
catch (Exception ex)
{
Console.WriteLine("Channel response processing failed with exception: " + ex.Message);
}
}
void ChannelResponseCadenza(ANT_Response response)
{
try
{
switch ((ANT_ReferenceLibrary.ANTMessageID)response.responseID)
{
case ANT_ReferenceLibrary.ANTMessageID.RESPONSE_EVENT_0x40:
{
switch (response.getChannelEventCode()) //identifica che tipo di messaggio è stato ricevuto
{
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_SEARCH_TIMEOUT_0x01:
{
workerDebug.RunWorkerAsync(argument: new object[] { "Cadence sensor timeout", 0 });
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_FAIL_0x02:
{
workerDebug.RunWorkerAsync(argument: new object[] { "RX Failed", 0 });
pagineCadenzaRicevute++;
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_CHANNEL_CLOSED_0x07:
{
channel0.unassignChannel(500);
workerDebug.RunWorkerAsync(argument: new object[] { "channel closed", 0 });
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_FAIL_GO_TO_SEARCH_0x08:
{
workerDebug.RunWorkerAsync(argument: new object[] { "Serching", 0 });
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_CHANNEL_COLLISION_0x09:
{
workerDebug.RunWorkerAsync(argument: new object[] { "Channel collision", 0 });
pagineCadenzaRicevute++;
break;
}
default:
{
// Console.WriteLine("Unhandled Channel Event " + response.getChannelEventCode());
workerDebug.RunWorkerAsync(argument: new object[] { "Unhandled Channel Event " + response.getChannelEventCode(), 0 });
break;
}
}
break;
}
case ANT_ReferenceLibrary.ANTMessageID.BROADCAST_DATA_0x4E:
{
//Console.Write(BitConverter.ToString(response.getDataPayload()) + " cadenza: " + cadenza + " inmovinento: " + inMovimentoCadenza + Environment.NewLine); // Display data payload
if (!worker.IsBusy)
{
worker.RunWorkerAsync(argument: new object[] { calcolaCadenza(response.getDataPayload()), 0 });
workerDebug.RunWorkerAsync(argument: new object[] { "RX Success", 0 }); //i made this to sent ant integer used to select the ui element to change without creating other backgrouworkers
//pattern {message,selector} (selecort: 0=cadence; 1=speed; 2=power; 3=hr);
Thread.Sleep(150);
}
break;
}
default:
{
textBoxLogCadence.Text = ("Unknown Message " + response.responseID);
break;
}
}
}
catch (Exception ex)
{
Console.WriteLine("Channel response processing failed with exception: " + ex.Message);
}
}
void ChannelResponseVelocita(ANT_Response response)
{
try
{
switch ((ANT_ReferenceLibrary.ANTMessageID)response.responseID)
{
case ANT_ReferenceLibrary.ANTMessageID.RESPONSE_EVENT_0x40:
{
switch (response.getChannelEventCode())
{
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_SEARCH_TIMEOUT_0x01:
{
Console.WriteLine("Search Timeout");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_FAIL_0x02:
{
workerDebug.RunWorkerAsync(argument: new object[] { "RX Failed", 1 });
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_CHANNEL_CLOSED_0x07:
{
// This event should be used to determine that the channel is closed.
Console.WriteLine("Channel Closed");
Console.WriteLine("Unassigning Channel...");
if (channel1.unassignChannel(500))
{
Console.WriteLine("Unassigned Channel");
Console.WriteLine("Press enter to exit");
}
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_FAIL_GO_TO_SEARCH_0x08:
{
Console.WriteLine("Go to Search");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_CHANNEL_COLLISION_0x09:
{
Console.WriteLine("Channel Collision");
break;
}
default:
{
Console.WriteLine("Unhandled Channel Event " + response.getChannelEventCode());
break;
}
}
break;
}
case ANT_ReferenceLibrary.ANTMessageID.BROADCAST_DATA_0x4E:
case ANT_ReferenceLibrary.ANTMessageID.ACKNOWLEDGED_DATA_0x4F:
case ANT_ReferenceLibrary.ANTMessageID.BURST_DATA_0x50:
case ANT_ReferenceLibrary.ANTMessageID.EXT_BROADCAST_DATA_0x5D:
case ANT_ReferenceLibrary.ANTMessageID.EXT_ACKNOWLEDGED_DATA_0x5E:
case ANT_ReferenceLibrary.ANTMessageID.EXT_BURST_DATA_0x5F:
{
if (true)
{
if (response.isExtended()) // Check if we are dealing with an extended message
{
ANT_ChannelID chID = response.getDeviceIDfromExt(); // Channel ID of the device we just received a message from
Console.Write("Chan ID(" + chID.deviceNumber.ToString() + "," + chID.deviceTypeID.ToString() + "," + chID.transmissionTypeID.ToString() + ") - ");
}
if (response.responseID == (byte)ANT_ReferenceLibrary.ANTMessageID.BROADCAST_DATA_0x4E ||
response.responseID == (byte)ANT_ReferenceLibrary.ANTMessageID.EXT_BROADCAST_DATA_0x5D)
{
Console.Write("Rx:(" + response.antChannel.ToString() + "): "); //questo è quello importante
}
else if (response.responseID == (byte)ANT_ReferenceLibrary.ANTMessageID.ACKNOWLEDGED_DATA_0x4F ||
response.responseID == (byte)ANT_ReferenceLibrary.ANTMessageID.EXT_ACKNOWLEDGED_DATA_0x5E)
{
Console.Write("Acked Rx:(" + response.antChannel.ToString() + "): ");
}
else
{
Console.Write("Burst(" + response.getBurstSequenceNumber().ToString("X2") + ") Rx:(" + response.antChannel.ToString() + "): ");
}
isMoving = checkMovement(response.getDataPayload());
velocita = calcolaVelocita(response.getDataPayload());
if (!worker.IsBusy)
{
worker.RunWorkerAsync(argument: new object[] { velocita, 1 });
Thread.Sleep(100); //added this to avoid calling the worker while its busy. yeah, i know, its not an elegant solution but this is what i can do at the moment :)
}
workerDebug.RunWorkerAsync(argument: new object[] { "RX Success", 1 });
setPower(calcolaVelocita(response.getDataPayload()));
}
break;
}
default:
{
Console.WriteLine("Unknown Message " + response.responseID);
break;
}
}
}
catch (Exception ex)
{
Console.WriteLine("Channel response processing failed with exception: " + ex.Message);
}
}
private static void Tramp_DeviceResponse(ANT_Response response)
{
ANT_ReferenceLibrary.ANTMessageID responseID = (ANT_ReferenceLibrary.ANTMessageID)response.responseID;
if (responseID == ANT_ReferenceLibrary.ANTMessageID.RESPONSE_EVENT_0x40)
{
ANT_ReferenceLibrary.ANTMessageID messageID = response.getMessageID();
switch (messageID)
{
case ANT_ReferenceLibrary.ANTMessageID.UNASSIGN_CHANNEL_0x41:
case ANT_ReferenceLibrary.ANTMessageID.ASSIGN_CHANNEL_0x42:
case ANT_ReferenceLibrary.ANTMessageID.CHANNEL_MESG_PERIOD_0x43:
case ANT_ReferenceLibrary.ANTMessageID.CHANNEL_RADIO_FREQ_0x45:
case ANT_ReferenceLibrary.ANTMessageID.NETWORK_KEY_0x46:
case ANT_ReferenceLibrary.ANTMessageID.OPEN_CHANNEL_0x4B:
case ANT_ReferenceLibrary.ANTMessageID.CHANNEL_ID_0x51:
{
bool flag = response.getChannelEventCode() > ANT_ReferenceLibrary.ANTEventID.RESPONSE_NO_ERROR_0x00;
if (flag)
{
}
break;
}
case ANT_ReferenceLibrary.ANTMessageID.CHANNEL_SEARCH_TIMEOUT_0x44:
case ANT_ReferenceLibrary.ANTMessageID.RADIO_TX_POWER_0x47:
case ANT_ReferenceLibrary.ANTMessageID.RADIO_CW_MODE_0x48:
case (ANT_ReferenceLibrary.ANTMessageID) 73:
case ANT_ReferenceLibrary.ANTMessageID.SYSTEM_RESET_0x4A:
case ANT_ReferenceLibrary.ANTMessageID.BROADCAST_DATA_0x4E:
case ANT_ReferenceLibrary.ANTMessageID.ACKNOWLEDGED_DATA_0x4F:
case ANT_ReferenceLibrary.ANTMessageID.BURST_DATA_0x50:
break;
case ANT_ReferenceLibrary.ANTMessageID.CLOSE_CHANNEL_0x4C:
{
bool flag2 = response.getChannelEventCode() == ANT_ReferenceLibrary.ANTEventID.CHANNEL_IN_WRONG_STATE_0x15;
if (flag2)
{
bool flag3 = ANT.channel1.unassignChannel(500u);
if (flag3)
{
ANT.bDone = true;
}
}
break;
}
case ANT_ReferenceLibrary.ANTMessageID.REQUEST_0x4D:
{
bool flag4 = response.getChannelEventCode() == ANT_ReferenceLibrary.ANTEventID.INVALID_MESSAGE_0x28;
if (flag4)
{
}
break;
}
default:
if (messageID == ANT_ReferenceLibrary.ANTMessageID.RX_EXT_MESGS_ENABLE_0x66)
{
bool flag5 = response.getChannelEventCode() == ANT_ReferenceLibrary.ANTEventID.INVALID_MESSAGE_0x28;
if (!flag5)
{
bool flag6 = response.getChannelEventCode() > ANT_ReferenceLibrary.ANTEventID.RESPONSE_NO_ERROR_0x00;
if (flag6)
{
}
}
}
break;
}
}
}
////////////////////////////////////////////////////////////////////////////////
// ChannelResponse
//
// Called whenever a channel event is recieved.
//
// response: ANT message
////////////////////////////////////////////////////////////////////////////////
public void ChannelResponse(ANT_Response response)
{
try
{
switch ((ANT_ReferenceLibrary.ANTMessageID)response.responseID)
{
case ANT_ReferenceLibrary.ANTMessageID.RESPONSE_EVENT_0x40:
{
switch (response.getChannelEventCode())
{
// This event indicates that a message has just been
// sent over the air. We take advantage of this event to set
// up the data for the next message period.
case ANT_ReferenceLibrary.ANTEventID.EVENT_TX_0x03:
{
txBuffer[0]++; // Increment the first byte of the buffer
// Broadcast data will be sent over the air on
// the next message period
if (bBroadcasting)
{
channel0.sendBroadcastData(txBuffer);
if (bDisplay)
{
// Echo what the data will be over the air on the next message period
Console.WriteLine("Tx: (" + response.antChannel.ToString() + ")" + BitConverter.ToString(txBuffer));
}
}
else
{
string[] ac = { "|", "/", "_", "\\" };
Console.Write("Tx: " + ac[iIndex++] + "\r");
iIndex &= 3;
}
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_SEARCH_TIMEOUT_0x01:
{
Console.WriteLine("Search Timeout");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_FAIL_0x02:
{
Console.WriteLine("Rx Fail");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_RX_FAILED_0x04:
{
Console.WriteLine("Burst receive has failed");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_TX_COMPLETED_0x05:
{
Console.WriteLine("Transfer Completed");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_TX_FAILED_0x06:
{
Console.WriteLine("Transfer Failed");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_CHANNEL_CLOSED_0x07:
{
// This event should be used to determine that the channel is closed.
Console.WriteLine("Channel Closed");
Console.WriteLine("Unassigning Channel...");
if (channel0.unassignChannel(500))
{
Console.WriteLine("Unassigned Channel");
Console.WriteLine("Press enter to exit");
bDone = true;
}
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_FAIL_GO_TO_SEARCH_0x08:
{
Console.WriteLine("Go to Search");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_CHANNEL_COLLISION_0x09:
{
Console.WriteLine("Channel Collision");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_TX_START_0x0A:
{
Console.WriteLine("Burst Started");
break;
}
default:
{
Console.WriteLine("Unhandled Channel Event " + response.getChannelEventCode());
break;
}
}
break;
}
case ANT_ReferenceLibrary.ANTMessageID.BROADCAST_DATA_0x4E:
case ANT_ReferenceLibrary.ANTMessageID.ACKNOWLEDGED_DATA_0x4F:
case ANT_ReferenceLibrary.ANTMessageID.BURST_DATA_0x50:
case ANT_ReferenceLibrary.ANTMessageID.EXT_BROADCAST_DATA_0x5D:
case ANT_ReferenceLibrary.ANTMessageID.EXT_ACKNOWLEDGED_DATA_0x5E:
case ANT_ReferenceLibrary.ANTMessageID.EXT_BURST_DATA_0x5F:
{
if (bDisplay)
{
if (response.isExtended()) // Check if we are dealing with an extended message
{
ANT_ChannelID chID = response.getDeviceIDfromExt(); // Channel ID of the device we just received a message from
if (chID.deviceTypeID == 120)
{
this.Heartrate = System.Convert.ToString(response.getDataPayload()[7]); // Device type for HR monitor is 120
}
else if (chID.deviceTypeID == 11)
{
if (response.getDataPayload()[0] == 10)
{
this.pwr = response.getDataPayload()[7];
this.cadence = response.getDataPayload()[4];
}
}
if (chID.deviceTypeID == 120)
{
this.Heartrate = System.Convert.ToString(response.getDataPayload()[7]);
}
Console.Write("Chan ID(" + chID.deviceNumber.ToString() + "," + chID.deviceTypeID.ToString() + "," + chID.transmissionTypeID.ToString() + ") - ");
}
if (response.responseID == (byte)ANT_ReferenceLibrary.ANTMessageID.BROADCAST_DATA_0x4E ||
response.responseID == (byte)ANT_ReferenceLibrary.ANTMessageID.EXT_BROADCAST_DATA_0x5D)
{
Console.Write("Rx:(" + response.antChannel.ToString() + "): ");
}
else if (response.responseID == (byte)ANT_ReferenceLibrary.ANTMessageID.ACKNOWLEDGED_DATA_0x4F ||
response.responseID == (byte)ANT_ReferenceLibrary.ANTMessageID.EXT_ACKNOWLEDGED_DATA_0x5E)
{
Console.Write("Acked Rx:(" + response.antChannel.ToString() + "): ");
}
else
{
Console.Write("Burst(" + response.getBurstSequenceNumber().ToString("X2") + ") Rx:(" + response.antChannel.ToString() + "): ");
}
//Console.Write(BitConverter.ToString(response.getDataPayload()) + Environment.NewLine); // Display data payload
Console.Write(" Heart Rate is: " + this.Heartrate + Environment.NewLine);
}
else
{
string[] ac = { "|", "/", "_", "\\" };
Console.Write("Rx: " + ac[iIndex++] + "\r");
iIndex &= 3;
}
break;
}
default:
{
Console.WriteLine("Unknown Message " + response.responseID);
break;
}
}
}
catch (Exception ex)
{
Console.WriteLine("Channel response processing failed with exception: " + ex.Message);
}
}
void PrintErrorMessage(ANT_Response response, string header)
{
Debug.WriteLine(String.Format(header + " {0} configuring {1}", response.getChannelEventCode(), response.getMessageID()));
}
////////////////////////////////////////////////////////////////////////////////
// ChannelResponse
//
// Called whenever a channel event is recieved.
//
// response: ANT message
////////////////////////////////////////////////////////////////////////////////
void ChannelResponse(ANT_Response response)
{
//With the messageQueue we can deal with ANT response in the Unity main thread
if (response.responseID == (byte)ANT_ReferenceLibrary.ANTMessageID.RESPONSE_EVENT_0x40)
{
messageQueue.Enqueue(response);
}
try
{
switch ((ANT_ReferenceLibrary.ANTMessageID)response.responseID)
{
case ANT_ReferenceLibrary.ANTMessageID.RESPONSE_EVENT_0x40:
{
switch (response.getChannelEventCode())
{
// This event indicates that a message has just been
// sent over the air. We take advantage of this event to set
// up the data for the next message period.
case ANT_ReferenceLibrary.ANTEventID.EVENT_TX_0x03:
{
// Broadcast data will be sent over the air on
// the next message period
if (broadcasting)
{
channel.sendBroadcastData(txBuffer);
}
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_SEARCH_TIMEOUT_0x01:
{
Debug.Log("Search Timeout");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_FAIL_0x02:
{
if (!hideRXFAIL)
{
Debug.Log("Rx Fail");
}
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_RX_FAILED_0x04:
{
Debug.Log("Burst receive has failed");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_TX_COMPLETED_0x05:
{
Debug.Log("Transfer Completed");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_TX_FAILED_0x06:
{
Debug.Log("Transfer Failed");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_CHANNEL_CLOSED_0x07:
{
channel.unassignChannel(500);
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_FAIL_GO_TO_SEARCH_0x08:
{
Debug.Log("Go to Search");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_CHANNEL_COLLISION_0x09:
{
Debug.Log("Channel Collision");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_TX_START_0x0A:
{
Debug.Log("Burst Started");
break;
}
default:
{
Debug.Log("Unhandled Channel Event " + response.getChannelEventCode());
break;
}
}
break;
}
case ANT_ReferenceLibrary.ANTMessageID.BROADCAST_DATA_0x4E:
case ANT_ReferenceLibrary.ANTMessageID.ACKNOWLEDGED_DATA_0x4F:
case ANT_ReferenceLibrary.ANTMessageID.BURST_DATA_0x50:
case ANT_ReferenceLibrary.ANTMessageID.EXT_BROADCAST_DATA_0x5D:
case ANT_ReferenceLibrary.ANTMessageID.EXT_ACKNOWLEDGED_DATA_0x5E:
case ANT_ReferenceLibrary.ANTMessageID.EXT_BURST_DATA_0x5F:
{
if (response.isExtended() && isBackgroundScan == true)
{
RXQueue.Enqueue(response.messageContents);
}
else
{
RXQueue.Enqueue(response.getDataPayload());
}
break;
}
default:
{
Debug.Log("Unknown Message " + response.responseID);
break;
}
}
}
catch (Exception ex)
{
Debug.Log("Channel response processing failed with exception: " + ex.Message);
}
}
////////////////////////////////////////////////////////////////////////////////
// ChannelResponse
//
// Called whenever a channel event is received.
//
// response: ANT message
////////////////////////////////////////////////////////////////////////////////
static void ChannelResponse(ANT_Response response)
{
//Console.WriteLine(DateTime.Now + " - Processing Channel Response: " + (ANT_ReferenceLibrary.ANTMessageID)response.responseID);
Random rnd = new Random();
try
{
switch ((ANT_ReferenceLibrary.ANTMessageID)response.responseID)
{
// 0x40 = Channel Message
case ANT_ReferenceLibrary.ANTMessageID.RESPONSE_EVENT_0x40:
{
switch (response.getChannelEventCode())
{
// This event indicates that a message has just been
// sent over the air. We take advantage of this event to set
// up the data for the next message period.
case ANT_ReferenceLibrary.ANTEventID.EVENT_TX_0x03:
{
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_SEARCH_TIMEOUT_0x01:
{
Console.WriteLine("Search Timeout");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_FAIL_0x02:
{
Console.WriteLine("Rx Fail");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_RX_FAILED_0x04:
{
Console.WriteLine("Burst receive has failed");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_TX_COMPLETED_0x05:
{
Console.WriteLine("Transfer Completed");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_TX_FAILED_0x06:
{
Console.WriteLine("Transfer Failed");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_CHANNEL_CLOSED_0x07:
{
// This event should be used to determine that the channel is closed.
Console.WriteLine(DateTime.Now + " - ANT Channel Closed");
Console.WriteLine("Unassigning Channel...");
if (channel0.unassignChannel(500))
{
Console.WriteLine("Unassigned Channel");
//Console.WriteLine("Press enter to exit");
//bDone = true;
}
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_RX_FAIL_GO_TO_SEARCH_0x08:
{
Console.WriteLine("Go to Search");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_CHANNEL_COLLISION_0x09:
{
Console.WriteLine("Channel Collision");
break;
}
case ANT_ReferenceLibrary.ANTEventID.EVENT_TRANSFER_TX_START_0x0A:
{
Console.WriteLine("Burst Started");
break;
}
case ANT_ReferenceLibrary.ANTEventID.NO_EVENT_0x00:
{
Console.WriteLine("No_Event_0x00 - " + response.getChannelEventCode());
break;
}
default:
{
Console.WriteLine("Unhandled Channel Event " + response.getChannelEventCode());
break;
}
}
break;
}
case ANT_ReferenceLibrary.ANTMessageID.BROADCAST_DATA_0x4E:
case ANT_ReferenceLibrary.ANTMessageID.ACKNOWLEDGED_DATA_0x4F:
case ANT_ReferenceLibrary.ANTMessageID.BURST_DATA_0x50:
case ANT_ReferenceLibrary.ANTMessageID.EXT_BROADCAST_DATA_0x5D:
case ANT_ReferenceLibrary.ANTMessageID.EXT_ACKNOWLEDGED_DATA_0x5E:
case ANT_ReferenceLibrary.ANTMessageID.EXT_BURST_DATA_0x5F:
{
// Process received messages here
//Console.WriteLine("Channel - ResponseID: " + response.responseID);
byte[] Payload = new byte[8];
Payload = response.getDataPayload();
//Console.WriteLine("Channel - Payload[6]: " + Payload[6]);
//Console.WriteLine("Channel - Payload[7]: " + Payload[7]);
// Command Number: 0-65535
int CommandNumber = 0;
CommandNumber = BitConverter.ToUInt16(Payload, 6);
WriteLog("Received CommandNumber: " + CommandNumber);
string processName = "ZwiftApp";
//string processName = "notepad";
Process[] targetProcess = Process.GetProcessesByName(processName);
if (targetProcess.Length > 0)
{
WriteLog(processName + " found");
Process p = targetProcess[0];
IntPtr h = p.MainWindowHandle;
SetForegroundWindow(h);
INPUT[] inputs = new INPUT[1];
KEYBDINPUT kb = new KEYBDINPUT();
uint result;
inputs[0].type = 1; //keyboard
// Prepare Keyboard Entry !
kb.time = 0;
kb.dwExtraInfo = IntPtr.Zero;
kb.wVk = (ushort)0x00;
//
// ANT command codes:
//
// 32768 - Down
// 32769 - Up
// 32770 - Right
// 32771 - Left
// 32772 - SpaceBar
// 32773 - Enter
// 32774 - G
// 32775 - ESC
// 32776 - Snapshot
// 32777 - SwitchView
// 32778 - ElbowFlick
// 32779 - ANT Devices Pairing
// 32780 - 0 = View 0
// 32781 - 1 = View 1
// 32784 - 4 = View 4
// 32785 - 5 = View 5
// 32786 - 6 = View 6
// 32787 - 7 = View 7
// 32788 - 8 = View 8
// 32789 - 9 = View 9
// 32790 - Pg Up = FTP Bias Up
// 32791 - Pg Down = FTP Bias Down
// 32792 - Tab
//
ushort key_wScan = 0x50;
uint key_dwFlags = (uint)(KeyEventF.KeyDown | KeyEventF.ScanCode);
switch (CommandNumber)
{
case 32768:
{
key_wScan = 0x50; // Down + Extended (E0)
key_dwFlags = (uint)(KeyEventF.KeyDown | KeyEventF.ScanCode | KeyEventF.ExtendedKey);
break;
}
case 32769:
{
key_wScan = 0x48; // Up + Extended (E0)
key_dwFlags = (uint)(KeyEventF.KeyDown | KeyEventF.ScanCode | KeyEventF.ExtendedKey);
break;
}
case 32770:
{
key_wScan = 0x4d; // Right + Extended (E0)
key_dwFlags = (uint)(KeyEventF.KeyDown | KeyEventF.ScanCode | KeyEventF.ExtendedKey);
break;
}
case 32771:
{
key_wScan = 0x4b; // Left + Extended (E0)
key_dwFlags = (uint)(KeyEventF.KeyDown | KeyEventF.ScanCode | KeyEventF.ExtendedKey);
break;
}
case 32772:
{
key_wScan = 0x39; // SpaceBar
key_dwFlags = (uint)(KeyEventF.KeyDown | KeyEventF.ScanCode);
break;
}
case 32773:
{
key_wScan = 0x1c; // Enter
key_dwFlags = (uint)(KeyEventF.KeyDown | KeyEventF.ScanCode);
break;
}
case 32774:
{
key_wScan = 0x22; // G = US-G = 0x22 - Azerty / Qwerty
key_dwFlags = (uint)(KeyEventF.KeyDown | KeyEventF.ScanCode);
break;
}
case 32775:
{
key_wScan = 0x01; // ESC
key_dwFlags = (uint)(KeyEventF.KeyDown | KeyEventF.ScanCode);
break;
}
case 32776:
{
key_wScan = 0x44; // F10 - Snapshot
key_dwFlags = (uint)(KeyEventF.KeyDown | KeyEventF.ScanCode);
break;
}
case 32778:
{
key_wScan = 0x3b; // F1 - ElbowFlick
key_dwFlags = (uint)(KeyEventF.KeyDown | KeyEventF.ScanCode);
break;
}
case 32779:
{
key_wScan = 0x10; // A = US-Q = 0x10 - Azerty / Qwerty
key_dwFlags = (uint)(KeyEventF.KeyDown | KeyEventF.ScanCode);
break;
}
case 32780:
{
key_wScan = 0x52; // Num 0 - View 0
key_dwFlags = (uint)(KeyEventF.KeyDown | KeyEventF.ScanCode);
break;
}
case 32781:
{
key_wScan = 0x4f; // Num 1 - View 1
key_dwFlags = (uint)(KeyEventF.KeyDown | KeyEventF.ScanCode);
break;
}
case 32782:
{
key_wScan = 0x50; // Num 2 - View 2
key_dwFlags = (uint)(KeyEventF.KeyDown | KeyEventF.ScanCode);
break;
}
case 32783:
{
key_wScan = 0x51; // Num 3 - View 3
key_dwFlags = (uint)(KeyEventF.KeyDown | KeyEventF.ScanCode);
break;
}
case 32784:
{
key_wScan = 0x4b; // Num 4 - View 4
key_dwFlags = (uint)(KeyEventF.KeyDown | KeyEventF.ScanCode);
break;
}
case 32785:
{
key_wScan = 0x4c; // Num 5 - View 5
key_dwFlags = (uint)(KeyEventF.KeyDown | KeyEventF.ScanCode);
break;
}
case 32786:
{
key_wScan = 0x4d; // Num 6 - View 6
key_dwFlags = (uint)(KeyEventF.KeyDown | KeyEventF.ScanCode);
break;
}
case 32787:
{
key_wScan = 0x47; // Num 7 - View 7
key_dwFlags = (uint)(KeyEventF.KeyDown | KeyEventF.ScanCode);
break;
}
case 32788:
{
key_wScan = 0x48; // Num 8 - View 8
key_dwFlags = (uint)(KeyEventF.KeyDown | KeyEventF.ScanCode);
break;
}
case 32789:
{
key_wScan = 0x49; // Num 9 - View 9
key_dwFlags = (uint)(KeyEventF.KeyDown | KeyEventF.ScanCode);
break;
}
case 32790:
{
key_wScan = 0x49; // PgUp + Extended (E0) - FTP Bias Up
key_dwFlags = (uint)(KeyEventF.KeyDown | KeyEventF.ScanCode | KeyEventF.ExtendedKey);
break;
}
case 32791:
{
key_wScan = 0x51; // PgDown + Extended (E0) - FTP Bias Down
key_dwFlags = (uint)(KeyEventF.KeyDown | KeyEventF.ScanCode | KeyEventF.ExtendedKey);
break;
}
case 32792:
{
key_wScan = 0x0f; // Tab - Skip Block
key_dwFlags = (uint)(KeyEventF.KeyDown | KeyEventF.ScanCode);
break;
}
default:
{
break;
}
}
//kb.wScan = 0x01; // Esc
//kb.wScan = 0x10; // A = Paired Device
//kb.wScan = 0x12; // E - Select your Workout
//kb.wScan = 0x14; // T = User Customisation
//kb.wScan = 0x22; // G - HR-Power Graph
//kb.wScan = 0x44; // F10 = Screenshot
kb.wScan = key_wScan;
kb.dwFlags = key_dwFlags;
//kb.wScan = 0x32; // M
//kb.dwFlags = (uint) (KeyEventF.KeyDown | KeyEventF.ScanCode);
//kb.dwFlags = (uint) (KeyEventF.KeyDown | KeyEventF.ScanCode | KeyEventF.ExtendedKey);
inputs[0].ki = kb;
result = SendInput(1, inputs, Marshal.SizeOf(inputs[0]));
}
else
{
WriteLog("Zwift Application not found");
}
}
break;
default:
{
Console.WriteLine("Unknown Message " + response.responseID);
break;
}
}
}
catch (Exception ex)
{
Console.WriteLine("Channel response processing failed with exception: " + ex.Message);
}
}
