/** * 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); }