/**
* Returns the first data packet from the queue waiting up to the
* specified timeout if necessary for an XBee data packet to become
* available. {@code null} if the queue is empty or there is not any data
* packet inside.
*
* @param timeout The time in milliseconds to wait for an XBee data packet
* to become available. 0 to return immediately.
*
* @return The first data packet from the queue, {@code null} if it is
* empty or no data packets are contained in the queue.
*
* @see com.digi.xbee.api.packet.XBeePacket
*/
public XBeePacket getFirstDataPacket(int timeout)
{
if (timeout > 0)
{
XBeePacket xbeePacket = getFirstDataPacket(0);
// Wait for a timeout or until a data XBee packet is read.
long deadLine = CurrentTimeMillis() + timeout;
while (xbeePacket == null && deadLine > CurrentTimeMillis())
{
Sleep(100);
xbeePacket = getFirstDataPacket(0);
}
return(xbeePacket);
}
else
{
for (int i = 0; i < packetsList.Count; i++)
{
XBeePacket xbeePacket = packetsList.ElementAt(i);
if (IsDataPacket(xbeePacket))
{
packetsList.Remove(xbeePacket);
return(xbeePacket);
}
}
}
return(null);
}
/**
* Returns the first data packet from the queue whose 64-bit source
* address matches the address of the provided remote XBee device.
*
* <p>The methods waits up to the specified timeout if necessary for an
* XBee data packet to become available. {@code null} if the queue is
* empty or there is not any XBee data packet sent by the provided remote
* XBee device.</p>
*
* @param remoteXBeeDevice The XBee device containing the 64-bit address
* to look for in the list of packets.
* @param timeout The time in milliseconds to wait for an XBee data packet
* from the specified remote XBee device to become
* available. 0 to return immediately.
*
* @return The first XBee data packet whose its 64-bit address matches the
* address of the provided remote XBee device. {@code null} if no
* data packets from the specified XBee device are found in the
* queue.
*
* @see com.digi.xbee.api.RemoteXBeeDevice
* @see com.digi.xbee.api.packet.XBeePacket
*/
public XBeePacket getFirstDataPacketFrom(RemoteXBeeDevice remoteXBeeDevice, int timeout)
{
if (timeout > 0)
{
XBeePacket xbeePacket = getFirstDataPacketFrom(remoteXBeeDevice, 0);
// Wait for a timeout or until an XBee packet from remoteXBeeDevice is read.
long deadLine = CurrentTimeMillis() + timeout;
while (xbeePacket == null && deadLine > CurrentTimeMillis())
{
Sleep(100);
xbeePacket = getFirstDataPacketFrom(remoteXBeeDevice, 0);
}
return(xbeePacket);
}
else
{
for (int i = 0; i < packetsList.Count; i++)
{
XBeePacket xbeePacket = packetsList.ElementAt(i);
if (IsDataPacket(xbeePacket) && AddressesMatch(xbeePacket, remoteXBeeDevice))
{
packetsList.Remove(xbeePacket);
return(xbeePacket);
}
}
}
return(null);
}
/// <summary>
/// Returns the first IP data packet from the queue whose IP address matches the provided address.
/// </summary>
/// <param name="ipAddress">The IP address to look for in the list of packets.</param>
/// <param name="timeout">The time in milliseconds to wait for an IP data packet to become
/// available. 0 to return immediately.</param>
/// <returns>The first IP packet whose IP address matches the provided IP address. <c>null</c> if
/// no IP data packets from the specified IP address are found in the queue.</returns>
/// <seealso cref="XBeePacket"/>
/// <seealso cref="IPAddress"/>
public XBeePacket GetFirstIPDataPacketFrom(IPAddress ipAddress, int timeout)
{
if (timeout > 0)
{
XBeePacket xbeePacket = GetFirstIPDataPacketFrom(ipAddress, 0);
// Wait for a timeout or until a IP data packet with the
// provided IP address is read.
long deadLine = CurrentTimeMillis() + timeout;
while (xbeePacket == null && deadLine > CurrentTimeMillis())
{
Sleep(100);
xbeePacket = GetFirstIPDataPacketFrom(ipAddress, 0);
}
return(xbeePacket);
}
else
{
for (int i = 0; i < packetsList.Count; i++)
{
XBeePacket xbeePacket = packetsList.ElementAt(i);
if (IsIPDataPacket(xbeePacket) && IPAddressesMatch(xbeePacket, ipAddress))
{
packetsList.Remove(xbeePacket);
return(xbeePacket);
}
}
}
return(null);
}
public async void PacketReceived(XBeePacket receivedPacket)
{
if (!_node.discovering)
{
return;
}
RemoteXBeeDevice rdevice = null;
byte[] commandValue = _node.GetRemoteDeviceData((XBeeAPIPacket)receivedPacket);
rdevice = await _node.ParseDiscoveryAPIData(commandValue, _node.xbeeDevice);
// If a device with a specific id is being search and it is
// already found, return it.
if (_id != null)
{
if (rdevice != null && _id.Equals(rdevice.NodeID))
{
lock (_node.deviceList)
{
_node.deviceList.Add(rdevice);
}
// If the local device is 802.15.4 wait until the 'end' command is received.
if (_node.xbeeDevice.XBeeProtocol != XBeeProtocol.RAW_802_15_4)
{
_node.discovering = false;
}
}
}
else if (rdevice != null)
{
_node.notifyDeviceDiscovered(_listeners, rdevice);
}
}
/// <summary>
/// Adds the provided packet to the list of packets. If the queue is full the first packet will be discarded to add the given one.
/// </summary>
/// <param name="xbeePacket">The XBee packet to be added to the list.</param>
/// <seealso cref="XBeePacket"/>
public void AddPacket(XBeePacket xbeePacket)
{
if (packetsList.Count == MaxSize)
{
packetsList.RemoveFirst();
}
packetsList.AddLast(xbeePacket);
}
/// <summary>
/// Returns whether or not the given XBee packet is an IP data packet.
/// </summary>
/// <param name="xbeePacket">The XBee packet to check if is an IP data packet.</param>
/// <returns><c>true</c> if the XBee packet is an IP data packet, <c>false</c>
/// otherwise.</returns>
private bool IsIPDataPacket(XBeePacket xbeePacket)
{
if (!(xbeePacket is XBeeAPIPacket))
{
return(false);
}
APIFrameType packetType = ((XBeeAPIPacket)xbeePacket).FrameType;
return(packetType == APIFrameType.RX_IPV4);
}
/// <summary>
/// Returns whether the given XBee packet is a User Data Relay packet or not.
/// </summary>
/// <param name="xbeePacket">The XBee packet to check if is a User Data Relay packet.</param>
/// <returns><c>true</c> if the XBee packet is an User Data Relay packet, <c>false</c>
/// otherwise.</returns>
/// <seealso cref="XBeePacket"/>
/// <seealso cref="UserDataRelayOutputPacket"/>
private bool IsUserDataRelayPacket(XBeePacket xbeePacket)
{
if (!(xbeePacket is XBeeAPIPacket))
{
return(false);
}
APIFrameType packetType = ((XBeeAPIPacket)xbeePacket).FrameType;
return(packetType == APIFrameType.USER_DATA_RELAY_OUTPUT);
}
/// <summary>
/// Returns whether or not the given XBee packet is an explicit data packet.
/// </summary>
/// <param name="xbeePacket">The XBee packet to check if is an explicit data packet.</param>
/// <returns><c>true</c> if the XBee packet is an explicit data packet, <c>false</c>
/// otherwise.</returns>
/// <seealso cref="XBeePacket"/>
/// <seealso cref="ExplicitRxIndicatorPacket"/>
private bool IsExplicitDataPacket(XBeePacket xbeePacket)
{
if (!(xbeePacket is XBeeAPIPacket))
{
return(false);
}
APIFrameType packetType = ((XBeeAPIPacket)xbeePacket).FrameType;
return(packetType == APIFrameType.EXPLICIT_RX_INDICATOR);
}
//public event EventHandler<PacketReceivedEventArgs> PacketReceived;
/**
* Notifies subscribed XBee packet listeners that a new XBee packet has
* been received.
*
* @param packet The received XBee packet.
*
* @see com.digi.xbee.api.packet.XBeeAPIPacket
* @see com.digi.xbee.api.packet.XBeePacket
*/
private void NotifyPacketReceived(XBeePacket packet)
{
logger.DebugFormat(connectionInterface.ToString() + "Packet received: \n{0}", packet.ToPrettyString());
try
{
lock (packetReceiveListeners)
{
var removeListeners = new List <IPacketReceiveListener>();
var tasks = new ConcurrentBag <Task>();
foreach (IPacketReceiveListener listener in packetReceiveListeners.Keys)
{
tasks.Add(Task.Factory.StartNew((state) =>
{
var listener0 = (IPacketReceiveListener)state;
lock (listener0)
{
if (packetReceiveListeners[listener0] == ALL_FRAME_IDS)
{
listener0.PacketReceived(packet);
}
else if (((XBeeAPIPacket)packet).NeedsAPIFrameID &&
((XBeeAPIPacket)packet).FrameID == packetReceiveListeners[listener0])
{
listener0.PacketReceived(packet);
removeListeners.Add(listener0);
}
}
}, listener));
}
Task.WaitAll(tasks.ToArray());
//executor.shutdown();
// Remove required listeners.
foreach (IPacketReceiveListener listener in removeListeners)
{
int value;
packetReceiveListeners.TryRemove(listener, out value);
}
}
}
catch (Exception e)
{
logger.Error(e.Message, e);
}
}
private bool SendPacket(XBeePacket packet)
{
byte[] bytes = packet.GetBytes();
try
{
_serialPort.Write(bytes, 0, bytes.Length);
}
catch (Exception ex)
{
//TODO: Tratar a Exceção
System.Windows.MessageBox.Show(ex.Message, "Erro no envio do comando");
return(false);
}
return(true);
}
/**
* Returns whether or not the given XBee packet is a data packet.
*
* @param xbeePacket The XBee packet to check if is data packet.
*
* @return {@code true} if the XBee packet is a data packet, {@code false}
* otherwise.
*
* @see com.digi.xbee.api.packet.XBeePacket
*/
private bool IsDataPacket(XBeePacket xbeePacket)
{
if (!(xbeePacket is XBeeAPIPacket))
{
return(false);
}
APIFrameType packetType = ((XBeeAPIPacket)xbeePacket).FrameType;
switch (packetType)
{
case APIFrameType.RECEIVE_PACKET:
case APIFrameType.RX_16:
case APIFrameType.RX_64:
return(true);
default:
return(false);
}
}
/// <summary>
/// Notifies subscribed XBee packet event handlers that a new XBee Packet has been received.
/// </summary>
/// <param name="packet">The received XBee packet.</param>
/// <seealso cref="XBeeAPIPacket"/>
/// <seealso cref="XBeePacket"/>
private void NotifyPacketReceived(XBeePacket packet)
{
logger.DebugFormat(connectionInterface.ToString() + "Packet received: \n{0}", packet.ToPrettyString());
try
{
lock (packetReceivedHandlers)
{
var args = new PacketReceivedEventArgs(packet);
XBeeAPIPacket apiPacket = (XBeeAPIPacket)packet;
List <CustomPacketReceivedEventHandler> handlersToRemove = new List <CustomPacketReceivedEventHandler>();
// Need to go over the list of Packet received handlers to
// verify which ones need to be notified of the received packet.
foreach (var packetHandler in packetReceivedHandlers)
{
if (packetHandler.Handler != null)
{
if (packetHandler.FrameId == ALL_FRAME_IDS)
{
packetHandler.Handler.DynamicInvoke(this, args);
}
else if (apiPacket.NeedsAPIFrameID &&
apiPacket.FrameID == packetHandler.FrameId)
{
packetHandler.Handler.DynamicInvoke(this, args);
handlersToRemove.Add(packetHandler);
}
}
}
foreach (CustomPacketReceivedEventHandler handlerToRemove in handlersToRemove)
{
RemovePacketReceivedHandler(handlerToRemove.Handler);
}
}
}
catch (Exception e)
{
logger.Error(e.Message, e);
}
}
/// <summary>
/// Returns whether or not the IP address of the XBee packet matches the provided one.
/// </summary>
/// <param name="xbeePacket">The XBee packet to compare its IP address with the provided
/// one.</param>
/// <param name="ipAddress">The IP address to be compared with the XBee packet's one.</param>
/// <returns><c>true</c> if the IP address of the XBee packet (if it has) matches the
/// provided one. <c>false</c> otherwise.</returns>
private bool IPAddressesMatch(XBeePacket xbeePacket, IPAddress ipAddress)
{
if (xbeePacket == null || ipAddress == null || !(xbeePacket is XBeeAPIPacket))
{
return(false);
}
APIFrameType packetType = (xbeePacket as XBeeAPIPacket).FrameType;
switch (packetType)
{
case APIFrameType.RX_IPV4:
if ((xbeePacket as RXIPv4Packet).SourceAddress.Equals(ipAddress))
{
return(true);
}
break;
default:
return(false);
}
return(false);
}
/**
* Returns the first packet from the queue waiting up to the specified
* timeout if necessary for an XBee packet to become available.
* {@code null }if the queue is empty.
*
* @param timeout The time in milliseconds to wait for an XBee packet to
* become available. 0 to return immediately.
* @return The first packet from the queue, {@code null} if it is empty.
*
* @see com.digi.xbee.api.packet.XBeePacket
*/
public XBeePacket GetFirstPacket(int timeout)
{
if (timeout > 0)
{
XBeePacket xbeePacket = GetFirstPacket(0);
// Wait for a timeout or until an XBee packet is read.
long deadLine = CurrentTimeMillis() + timeout;
while (xbeePacket == null && deadLine > CurrentTimeMillis())
{
Sleep(100);
xbeePacket = GetFirstPacket(0);
}
return(xbeePacket);
}
else if (packetsList.Count > 0)
{
var first = packetsList.First.Value;
packetsList.RemoveFirst();
return(first);
}
return(null);
}
protected void SendRequest(XBeeRequest request)
{
IsRequestSupported(request);
if (_addressLookupEnabled)
{
_currentRequest = request;
}
if (Logger.IsActive(LogLevel.Debug))
{
Logger.Debug("Sending " + request.GetType().Name + ": " + request);
}
var bytes = XBeePacket.GetBytes(request);
if (Logger.IsActive(LogLevel.LowDebug))
{
Logger.LowDebug("Sending " + ByteUtils.ToBase16(bytes));
}
_connection.Send(bytes);
}
/**
* Dispatches the received XBee packet to the corresponding listener(s).
*
* @param packet The received XBee packet to be dispatched to the
* corresponding listeners.
*
* @see com.digi.xbee.api.packet.XBeeAPIPacket
* @see com.digi.xbee.api.packet.XBeePacket
*/
private void PacketReceived(XBeePacket packet)
{
// Add the packet to the packets queue.
xbeePacketsQueue.AddPacket(packet);
// Notify that a packet has been received to the corresponding listeners.
NotifyPacketReceived(packet);
// Check if the packet is an API packet.
if (!(packet is XBeeAPIPacket))
{
return;
}
// Get the API packet type.
XBeeAPIPacket apiPacket = (XBeeAPIPacket)packet;
APIFrameType apiType = apiPacket.FrameType;
if (apiType == APIFrameType.UNKNOWN)
{
return;
}
try
{
// Obtain the remote device from the packet.
RemoteXBeeDevice remoteDevice = GetRemoteXBeeDeviceFromPacket(apiPacket);
byte[] data = null;
switch (apiType)
{
case APIFrameType.RECEIVE_PACKET:
ReceivePacket receivePacket = (ReceivePacket)apiPacket;
data = receivePacket.RFData;
notifyDataReceived(new XBeeMessage(remoteDevice, data, apiPacket.IsBroadcast));
break;
case APIFrameType.RX_64:
RX64Packet rx64Packet = (RX64Packet)apiPacket;
data = rx64Packet.RFData;
notifyDataReceived(new XBeeMessage(remoteDevice, data, apiPacket.IsBroadcast));
break;
case APIFrameType.RX_16:
RX16Packet rx16Packet = (RX16Packet)apiPacket;
data = rx16Packet.RFData;
notifyDataReceived(new XBeeMessage(remoteDevice, data, apiPacket.IsBroadcast));
break;
case APIFrameType.IO_DATA_SAMPLE_RX_INDICATOR:
IODataSampleRxIndicatorPacket ioSamplePacket = (IODataSampleRxIndicatorPacket)apiPacket;
NotifyIOSampleReceived(remoteDevice, ioSamplePacket.IOSample);
break;
case APIFrameType.RX_IO_64:
RX64IOPacket rx64IOPacket = (RX64IOPacket)apiPacket;
NotifyIOSampleReceived(remoteDevice, rx64IOPacket.getIOSample());
break;
case APIFrameType.RX_IO_16:
RX16IOPacket rx16IOPacket = (RX16IOPacket)apiPacket;
NotifyIOSampleReceived(remoteDevice, rx16IOPacket.IOSample);
break;
case APIFrameType.MODEM_STATUS:
ModemStatusPacket modemStatusPacket = (ModemStatusPacket)apiPacket;
NotifyModemStatusReceived(modemStatusPacket.Status);
break;
default:
break;
}
}
catch (XBeeException e)
{
logger.Error(e.Message, e);
}
}
/*
* (non-Javadoc)
* @see java.lang.Thread#run()
*/
//@Override
public void Run()
{
logger.Debug(connectionInterface.ToString() + "Data reader started.");
running = true;
// Clear the list of read packets.
xbeePacketsQueue.ClearQueue();
try
{
lock (connectionInterface)
{
Monitor.Wait(connectionInterface);
}
while (running)
{
if (!running)
{
break;
}
if (connectionInterface.SerialPort != null)
{
switch (mode)
{
case OperatingMode.AT:
break;
case OperatingMode.API:
case OperatingMode.API_ESCAPE:
int headerByte = connectionInterface.SerialPort.ReadByte();
// If it is packet header parse the packet, if not discard this byte and continue.
if (headerByte == SpecialByte.HEADER_BYTE.GetValue())
{
try
{
XBeePacket packet = parser.ParsePacket(connectionInterface.SerialPort, mode);
PacketReceived(packet);
}
catch (InvalidPacketException e)
{
logger.Error("Error parsing the API packet.", e);
}
}
break;
default:
break;
}
}
else if (connectionInterface.SerialPort == null)
{
break;
}
if (connectionInterface.SerialPort == null)
{
break;
}
else if (connectionInterface.SerialPort.BytesToRead > 0)
{
continue;
}
lock (connectionInterface)
{
Monitor.Wait(connectionInterface);
}
}
}
catch (IOException e)
{
logger.Error("Error reading from input stream.", e);
}
catch (ThreadInterruptedException e)
{
logger.Error(e.Message, e);
}
//catch (IllegalStateException e)
//{
// logger.Error(e.Message, e);
//}
finally
{
if (running)
{
running = false;
if (connectionInterface.SerialPort.IsOpen)
{
connectionInterface.SerialPort.Close();
}
}
}
}
/// <summary>
/// Instantiates a <see cref="PacketReceivedEventArgs"/> object with the provided parameters.
/// </summary>
/// <param name="packet">The received packet.</param>
public PacketReceivedEventArgs(XBeePacket packet)
{
ReceivedPacket = packet;
}
/// <summary>
/// Returns whether or not the source address of the provided XBee packet matches the address
/// of the given remote XBee device.
/// </summary>
/// <param name="xbeePacket">The XBee packet to compare its address with the remote XBee
/// device.</param>
/// <param name="remoteXBeeDevice">The remote XBee device to compare its address with the XBee
/// packet.</param>
/// <returns><c>true</c> if the source address of the provided packet (if it has) matches the
/// address of the remote XBee device.</returns>
/// <seealso cref="RemoteXBeeDevice"/>
/// <seealso cref="XBeePacket"/>
private bool AddressesMatch(XBeePacket xbeePacket, RemoteXBeeDevice remoteXBeeDevice)
{
if (!(xbeePacket is XBeeAPIPacket))
{
return(false);
}
APIFrameType packetType = ((XBeeAPIPacket)xbeePacket).FrameType;
switch (packetType)
{
case APIFrameType.RECEIVE_PACKET:
if (remoteXBeeDevice.XBee64BitAddr != null &&
((ReceivePacket)xbeePacket).SourceAddress64.Equals(remoteXBeeDevice.XBee64BitAddr))
{
return(true);
}
if (remoteXBeeDevice.XBee16BitAddr != null &&
!remoteXBeeDevice.XBee16BitAddr.Equals(XBee16BitAddress.UNKNOWN_ADDRESS) &&
((ReceivePacket)xbeePacket).SourceAddress16.Equals(remoteXBeeDevice.XBee16BitAddr))
{
return(true);
}
break;
case APIFrameType.REMOTE_AT_COMMAND_RESPONSE:
if (remoteXBeeDevice.XBee64BitAddr != null &&
((RemoteATCommandResponsePacket)xbeePacket).SourceAddress64.Equals(remoteXBeeDevice.XBee64BitAddr))
{
return(true);
}
if (remoteXBeeDevice.XBee16BitAddr != null &&
!remoteXBeeDevice.XBee16BitAddr.Equals(XBee16BitAddress.UNKNOWN_ADDRESS) &&
((RemoteATCommandResponsePacket)xbeePacket).SourceAddress16.Equals(remoteXBeeDevice.XBee16BitAddr))
{
return(true);
}
break;
case APIFrameType.RX_16:
if (((RX16Packet)xbeePacket).SourceAddress16.Equals(remoteXBeeDevice.XBee16BitAddr))
{
return(true);
}
break;
case APIFrameType.RX_64:
if (((RX64Packet)xbeePacket).SourceAddress64.Equals(remoteXBeeDevice.XBee64BitAddr))
{
return(true);
}
break;
case APIFrameType.RX_IO_16:
if (((RX16IOPacket)xbeePacket).SourceAddress16.Equals(remoteXBeeDevice.XBee16BitAddr))
{
return(true);
}
break;
case APIFrameType.RX_IO_64:
if (((RX64IOPacket)xbeePacket).SourceAddress64.Equals(remoteXBeeDevice.XBee64BitAddr))
{
return(true);
}
break;
case APIFrameType.EXPLICIT_RX_INDICATOR:
if (((ExplicitRxIndicatorPacket)xbeePacket).SourceAddress64.Equals(remoteXBeeDevice.XBee64BitAddr))
{
return(true);
}
break;
default:
return(false);
}
return(false);
}
/// <summary>
/// Sends the given XBee packet synchronously and blocks until the response is received or
/// the configured receive timeout expires.
/// </summary>
/// <remarks>The receive timeout is consulted/configured using the <see cref="ReceiveTimeout"/>property.
///
/// Use <see cref="SendPacketAsync(XBeePacket)"/> or
/// <see cref="SendPacket(XBeePacket, EventHandler{PacketReceivedEventArgs})"/> for non-blocking
/// operations.</remarks>
/// <param name="packet">The XBee packet to be sent.</param>
/// <returns>An <see cref="XBeePacket"/> object containing the response of the sent packet or
/// <c>null</c> if there is no response.</returns>
/// <exception cref="ArgumentNullException">If <c><paramref name="packet"/> == null</c>.</exception>
/// <exception cref="InterfaceNotOpenException">If this device connection is not open.</exception>
/// <exception cref="InvalidOperatingModeException">If the operating mode is different from
/// <see cref="OperatingMode.API"/> and <see cref="OperatingMode.API_ESCAPE"/>.</exception>
/// <exception cref="TimeoutException">If the configured time expires while waiting for the
/// packet reply.</exception>
/// <exception cref="XBeeException">If there is any other XBee related error.</exception>
/// <seealso cref="ReceiveTimeout"/>
/// <seealso cref="SendPacket(XBeePacket, EventHandler{PacketReceivedEventArgs})"/>
/// <seealso cref="SendPacketAsync(XBeePacket)"/>
/// <seealso cref="XBeePacket"/>
public new XBeePacket SendPacket(XBeePacket packet)
{
return(base.SendPacket(packet));
}
/// <summary>
/// Sends the given XBee packet asynchronously.
/// </summary>
/// <remarks>To be notified when the answer is received, use the <see cref="PacketReceived"/>
/// event handler.</remarks>
/// <param name="packet">The XBee packet to be sent asynchronously.</param>
/// <exception cref="ArgumentNullException">If <c><paramref name="packet"/> == null</c>.</exception>
/// <exception cref="InterfaceNotOpenException">If this device connection is not open.</exception>
/// <exception cref="InvalidOperatingModeException">If the operating mode is different from
/// <see cref="OperatingMode.API"/> and <see cref="OperatingMode.API_ESCAPE"/>.</exception>
/// <exception cref="XBeeException">If there is any other XBee related error.</exception>
/// <seealso cref="SendPacket(XBeePacket)"/>
/// <seealso cref="SendPacket(XBeePacket, EventHandler{PacketReceivedEventArgs})"/>
/// <seealso cref="XBeePacket"/>
public new void SendPacketAsync(XBeePacket packet)
{
base.SendPacketAsync(packet);
}
/// <summary>
/// Sends the given XBee packet and registers the given packet handler (if not <c>null</c>) to
/// manage what happens when the answers is received.
/// </summary>
/// <remarks>This is a non-blocking operation. To wait for the answer use
/// <see cref="SendPacket(XBeePacket)"/>.</remarks>
/// <param name="packet">XBee packet to be sent.</param>
/// <param name="handler">Event handler for the operation, <c>null</c> not to be notified when
/// the answer arrives.</param>
/// <exception cref="ArgumentNullException">If <c><paramref name="packet"/> == null</c>.</exception>
/// <exception cref="InterfaceNotOpenException">If this device connection is not open.</exception>
/// <exception cref="InvalidOperatingModeException">If the operating mode is different from
/// <see cref="OperatingMode.API"/> and <see cref="OperatingMode.API_ESCAPE"/>.</exception>
/// <exception cref="XBeeException">If there is any other XBee related error.</exception>
/// <seealso cref="SendPacket(XBeePacket)"/>
/// <seealso cref="SendPacketAsync(XBeePacket)"/>
/// <seealso cref="PacketReceivedEventArgs"/>
/// <seealso cref="XBeePacket"/>
public new void SendPacket(XBeePacket packet, EventHandler <PacketReceivedEventArgs> handler)
{
base.SendPacket(packet, handler);
}
/// <summary>
/// Dispatches the received XBee packet to the corresponding event handler(s).
/// </summary>
/// <param name="packet">The received XBee packet to be dispatched to the corresponding event
/// handlers.</param>
/// <seealso cref="XBeeAPIPacket"/>
/// <seealso cref="XBeePacket"/>
private void PacketReceived(XBeePacket packet)
{
// Add the packet to the packets queue.
XBeePacketsQueue.AddPacket(packet);
// Notify that a packet has been received to the corresponding event handlers.
NotifyPacketReceived(packet);
// Check if the packet is an API packet.
if (!(packet is XBeeAPIPacket))
{
return;
}
// Get the API packet type.
XBeeAPIPacket apiPacket = (XBeeAPIPacket)packet;
APIFrameType apiType = apiPacket.FrameType;
try
{
// Obtain the remote device from the packet.
RemoteXBeeDevice remoteDevice = GetRemoteXBeeDeviceFromPacket(apiPacket);
byte[] data = null;
switch (apiType)
{
case APIFrameType.RECEIVE_PACKET:
ReceivePacket receivePacket = (ReceivePacket)apiPacket;
data = receivePacket.RFData;
NotifyDataReceived(new XBeeMessage(remoteDevice, data, apiPacket.IsBroadcast));
break;
case APIFrameType.RX_64:
RX64Packet rx64Packet = (RX64Packet)apiPacket;
data = rx64Packet.RFData;
NotifyDataReceived(new XBeeMessage(remoteDevice, data, apiPacket.IsBroadcast));
break;
case APIFrameType.RX_16:
RX16Packet rx16Packet = (RX16Packet)apiPacket;
data = rx16Packet.RFData;
NotifyDataReceived(new XBeeMessage(remoteDevice, data, apiPacket.IsBroadcast));
break;
case APIFrameType.IO_DATA_SAMPLE_RX_INDICATOR:
IODataSampleRxIndicatorPacket ioSamplePacket = (IODataSampleRxIndicatorPacket)apiPacket;
NotifyIOSampleReceived(remoteDevice, ioSamplePacket.IOSample);
break;
case APIFrameType.RX_IO_64:
RX64IOPacket rx64IOPacket = (RX64IOPacket)apiPacket;
NotifyIOSampleReceived(remoteDevice, rx64IOPacket.IoSample);
break;
case APIFrameType.RX_IO_16:
RX16IOPacket rx16IOPacket = (RX16IOPacket)apiPacket;
NotifyIOSampleReceived(remoteDevice, rx16IOPacket.IoSample);
break;
case APIFrameType.MODEM_STATUS:
ModemStatusPacket modemStatusPacket = (ModemStatusPacket)apiPacket;
NotifyModemStatusReceived(modemStatusPacket.Status);
break;
case APIFrameType.EXPLICIT_RX_INDICATOR:
ExplicitRxIndicatorPacket explicitDataPacket = (ExplicitRxIndicatorPacket)apiPacket;
byte sourceEndpoint = explicitDataPacket.SourceEndpoint;
byte destEndpoint = explicitDataPacket.DestEndpoint;
byte[] clusterID = explicitDataPacket.ClusterID;
byte[] profileID = explicitDataPacket.ProfileID;
data = explicitDataPacket.RFData;
// If this is an explicit packet for data transmissions in the Digi profile,
// notify also the data event handler and add a Receive packet to the queue.
if (sourceEndpoint == ExplicitRxIndicatorPacket.DATA_ENDPOINT &&
destEndpoint == ExplicitRxIndicatorPacket.DATA_ENDPOINT &&
clusterID.SequenceEqual(ExplicitRxIndicatorPacket.DATA_CLUSTER) &&
profileID.SequenceEqual(ExplicitRxIndicatorPacket.DIGI_PROFILE))
{
NotifyDataReceived(new XBeeMessage(remoteDevice, data, apiPacket.IsBroadcast));
XBeePacketsQueue.AddPacket(new ReceivePacket(explicitDataPacket.SourceAddress64,
explicitDataPacket.SourceAddress16,
explicitDataPacket.ReceiveOptions,
explicitDataPacket.RFData));
}
NotifyExplicitDataReceived(new ExplicitXBeeMessage(remoteDevice, sourceEndpoint, destEndpoint, clusterID,
profileID, data, explicitDataPacket.IsBroadcast));
break;
case APIFrameType.USER_DATA_RELAY_OUTPUT:
UserDataRelayOutputPacket relayPacket = (UserDataRelayOutputPacket)apiPacket;
NotifyUserDataRelayReceived(new UserDataRelayMessage(relayPacket.SourceInterface, relayPacket.Data));
break;
case APIFrameType.RX_IPV4:
RXIPv4Packet rxIPv4Packet = (RXIPv4Packet)apiPacket;
NotifyIPDataReceived(new IPMessage(
rxIPv4Packet.SourceAddress,
rxIPv4Packet.SourcePort,
rxIPv4Packet.DestPort,
rxIPv4Packet.Protocol,
rxIPv4Packet.Data));
break;
case APIFrameType.RX_SMS:
RXSMSPacket rxSMSPacket = (RXSMSPacket)apiPacket;
NotifySMSReceived(new SMSMessage(rxSMSPacket.PhoneNumber, rxSMSPacket.Data));
break;
default:
break;
}
}
catch (XBeeException e)
{
logger.Error(e.Message, e);
}
}
private void Run()
{
logger.Debug(connectionInterface.ToString() + "Data reader started.");
IsRunning = true;
// Clear the list of read packets.
XBeePacketsQueue.ClearQueue();
try
{
lock (connectionInterface)
{
Monitor.Wait(connectionInterface);
}
while (IsRunning)
{
if (!IsRunning)
{
break;
}
if (connectionInterface.Stream != null)
{
switch (mode)
{
case OperatingMode.AT:
break;
case OperatingMode.API:
case OperatingMode.API_ESCAPE:
int headerByte = connectionInterface.Stream.ReadByte();
// If it is packet header parse the packet, if not discard this byte and continue.
if (headerByte == SpecialByte.HEADER_BYTE.GetValue())
{
try
{
XBeePacket packet = parser.ParsePacket(connectionInterface.Stream, mode);
PacketReceived(packet);
}
catch (InvalidPacketException e)
{
logger.Error("Error parsing the API packet.", e);
}
}
break;
default:
break;
}
}
else if (connectionInterface.Stream == null)
{
break;
}
if (connectionInterface.Stream == null)
{
break;
}
else if (connectionInterface.Stream.Available > 0)
{
continue;
}
lock (connectionInterface)
{
Monitor.Wait(connectionInterface);
}
}
}
catch (IOException e)
{
logger.Error("Error reading from input stream.", e);
}
finally
{
if (IsRunning)
{
IsRunning = false;
if (connectionInterface.IsOpen)
{
connectionInterface.Close();
}
}
}
}
/**
* Returns whether or not the source address of the provided XBee packet
* matches the address of the given remote XBee device.
*
* @param xbeePacket The XBee packet to compare its address with the
* remote XBee device.
* @param remoteXBeeDevice The remote XBee device to compare its address
* with the XBee packet.
*
* @return {@code true} if the source address of the provided packet (if
* it has) matches the address of the remote XBee device.
*
* @see com.digi.xbee.api.RemoteXBeeDevice
* @see com.digi.xbee.api.packet.XBeePacket
*/
private bool AddressesMatch(XBeePacket xbeePacket, RemoteXBeeDevice remoteXBeeDevice)
{
if (!(xbeePacket is XBeeAPIPacket))
{
return(false);
}
APIFrameType packetType = ((XBeeAPIPacket)xbeePacket).FrameType;
switch (packetType)
{
case APIFrameType.RECEIVE_PACKET:
if (remoteXBeeDevice.Get64BitAddress() != null && ((ReceivePacket)xbeePacket).get64bitSourceAddress().Equals(remoteXBeeDevice.Get64BitAddress()))
{
return(true);
}
if (remoteXBeeDevice.Get16BitAddress() != null && ((ReceivePacket)xbeePacket).get16bitSourceAddress().Equals(remoteXBeeDevice.Get16BitAddress()))
{
return(true);
}
break;
case APIFrameType.REMOTE_AT_COMMAND_RESPONSE:
if (remoteXBeeDevice.Get64BitAddress() != null && ((RemoteATCommandResponsePacket)xbeePacket).get64bitSourceAddress().Equals(remoteXBeeDevice.Get64BitAddress()))
{
return(true);
}
if (remoteXBeeDevice.Get16BitAddress() != null && ((RemoteATCommandResponsePacket)xbeePacket).get16bitSourceAddress().Equals(remoteXBeeDevice.Get16BitAddress()))
{
return(true);
}
break;
case APIFrameType.RX_16:
if (((RX16Packet)xbeePacket).Get16bitSourceAddress().Equals(remoteXBeeDevice.Get16BitAddress()))
{
return(true);
}
break;
case APIFrameType.RX_64:
if (((RX64Packet)xbeePacket).SourceAddress64.Equals(remoteXBeeDevice.Get64BitAddress()))
{
return(true);
}
break;
case APIFrameType.RX_IO_16:
if (((RX16IOPacket)xbeePacket).get16bitSourceAddress().Equals(remoteXBeeDevice.Get16BitAddress()))
{
return(true);
}
break;
case APIFrameType.RX_IO_64:
if (((RX64IOPacket)xbeePacket).SourceAddress64.Equals(remoteXBeeDevice.Get64BitAddress()))
{
return(true);
}
break;
default:
return(false);
}
return(false);
}
