def build_frame(packet_bytearray, operating_mode=OperatingMode.API_MODE):
"""
Creates a packet from raw data.
Args:
packet_bytearray (Bytearray): the raw data of the packet to build.
operating_mode (:class:`.OperatingMode`): the operating mode in which
the raw data has been captured.
.. seealso::
| :class:`.OperatingMode`
"""
if len(packet_bytearray) < 5:
raise InvalidPacketException(
message="Bytearray must have, at least, 5 bytes (header, length, "
"frameType, checksum)")
frame_type = ApiFrameType.get(packet_bytearray[3])
if frame_type == ApiFrameType.GENERIC:
return GenericXBeePacket.create_packet(packet_bytearray,
operating_mode=operating_mode)
if frame_type == ApiFrameType.AT_COMMAND:
return ATCommPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.AT_COMMAND_QUEUE:
return ATCommQueuePacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.AT_COMMAND_RESPONSE:
return ATCommResponsePacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.RECEIVE_PACKET:
return ReceivePacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.RX_64:
return RX64Packet.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.RX_16:
return RX16Packet.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.REMOTE_AT_COMMAND_REQUEST:
return RemoteATCommandPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.REMOTE_AT_COMMAND_RESPONSE:
return RemoteATCommandResponsePacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.TRANSMIT_REQUEST:
return TransmitPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.TRANSMIT_STATUS:
return TransmitStatusPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.MODEM_STATUS:
return ModemStatusPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.TX_STATUS:
return TXStatusPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.RX_IO_16:
return RX16IOPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.RX_IO_64:
return RX64IOPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.IO_DATA_SAMPLE_RX_INDICATOR:
return IODataSampleRxIndicatorPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.EXPLICIT_ADDRESSING:
return ExplicitAddressingPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.EXPLICIT_RX_INDICATOR:
return ExplicitRXIndicatorPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.TX_SMS:
return TXSMSPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.TX_IPV4:
return TXIPv4Packet.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.RX_SMS:
return RXSMSPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.USER_DATA_RELAY_OUTPUT:
return UserDataRelayOutputPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.RX_IPV4:
return RXIPv4Packet.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.REMOTE_AT_COMMAND_REQUEST_WIFI:
return RemoteATCommandWifiPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.SEND_DATA_REQUEST:
return SendDataRequestPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.DEVICE_RESPONSE:
return DeviceResponsePacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.USER_DATA_RELAY_REQUEST:
return UserDataRelayPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.REMOTE_AT_COMMAND_RESPONSE_WIFI:
return RemoteATCommandResponseWifiPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.IO_DATA_SAMPLE_RX_INDICATOR_WIFI:
return IODataSampleRxIndicatorWifiPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.SEND_DATA_RESPONSE:
return SendDataResponsePacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.DEVICE_REQUEST:
return DeviceRequestPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.DEVICE_RESPONSE_STATUS:
return DeviceResponseStatusPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.FRAME_ERROR:
return FrameErrorPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.REGISTER_JOINING_DEVICE:
return RegisterJoiningDevicePacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.REGISTER_JOINING_DEVICE_STATUS:
return RegisterDeviceStatusPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.ROUTE_RECORD_INDICATOR:
return RouteRecordIndicatorPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.SOCKET_CREATE:
return SocketCreatePacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.SOCKET_CREATE_RESPONSE:
return SocketCreateResponsePacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.SOCKET_OPTION_REQUEST:
return SocketOptionRequestPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.SOCKET_OPTION_RESPONSE:
return SocketOptionResponsePacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.SOCKET_CONNECT:
return SocketConnectPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.SOCKET_CONNECT_RESPONSE:
return SocketConnectResponsePacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.SOCKET_CLOSE:
return SocketClosePacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.SOCKET_CLOSE_RESPONSE:
return SocketCloseResponsePacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.SOCKET_SEND:
return SocketSendPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.SOCKET_SENDTO:
return SocketSendToPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.SOCKET_BIND:
return SocketBindListenPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.SOCKET_LISTEN_RESPONSE:
return SocketListenResponsePacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.SOCKET_NEW_IPV4_CLIENT:
return SocketNewIPv4ClientPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.SOCKET_RECEIVE:
return SocketReceivePacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.SOCKET_RECEIVE_FROM:
return SocketReceiveFromPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.SOCKET_STATE:
return SocketStatePacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.DIGIMESH_ROUTE_INFORMATION:
return RouteInformationPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.FILE_SYSTEM_REQUEST:
return FSRequestPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.FILE_SYSTEM_RESPONSE:
return FSResponsePacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.REMOTE_FILE_SYSTEM_REQUEST:
return RemoteFSRequestPacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.REMOTE_FILE_SYSTEM_RESPONSE:
return RemoteFSResponsePacket.create_packet(packet_bytearray, operating_mode)
if frame_type == ApiFrameType.OTA_FIRMWARE_UPDATE_STATUS:
return OTAFirmwareUpdateStatusPacket.create_packet(packet_bytearray, operating_mode)
return UnknownXBeePacket.create_packet(packet_bytearray, operating_mode=operating_mode)
def connect(self, address):
"""
Connects to a remote socket at the given address.
Args:
address (Tuple): A pair ``(host, port)`` where ``host`` is the domain name or string representation of an
IPv4 and ``port`` is the numeric port value.
Raises:
TimeoutException: if the connect response is not received in the configured timeout.
ValueError: if ``address`` is ``None`` or not a pair ``(host, port)``.
ValueError: if ``port`` is less than 1 or greater than 65535.
XBeeException: if the connection with the XBee device is not open.
XBeeSocketException: if the connect status is not ``SUCCESS``.
"""
# Check address and its contents.
if address is None or len(address) != 2:
raise ValueError(
"Invalid address, it must be a pair (host, port).")
host = address[0]
port = address[1]
if isinstance(host, IPv4Address):
host = str(host)
if port < 1 or port > 65535:
raise ValueError("Port number must be between 1 and 65535.")
# If the socket is not created, create it first.
if self.__socket_id is None:
self.__create_socket()
lock = threading.Condition()
received_state = list()
# Define the socket state received callback.
def socket_state_received_callback(socket_id, state):
# Check the socket ID.
if socket_id != self.__socket_id:
return
# Add the state to the list and notify the lock.
received_state.append(state)
lock.acquire()
lock.notify()
lock.release()
# Add the socket state received callback.
self.__xbee_device.add_socket_state_received_callback(
socket_state_received_callback)
try:
# Create, send and check the socket connect packet.
connect_packet = SocketConnectPacket(
self.__xbee_device.get_next_frame_id(), self.__socket_id, port,
SocketConnectPacket.DEST_ADDRESS_STRING, host)
response_packet = self.__xbee_device.send_packet_sync_and_get_response(
connect_packet, timeout=self.__get_timeout())
self.__check_response(response_packet)
# Wait until the socket state frame is received confirming the connection.
if not received_state:
lock.acquire()
lock.wait(self.__timeout)
lock.release()
# Check if the socket state has been received.
if not received_state:
raise TimeoutException(
"Timeout waiting for the socket connection")
# Check if the socket is connected successfully.
if received_state[0] != SocketState.CONNECTED:
raise XBeeSocketException(status=received_state[0])
self.__connected = True
# Register internal socket state and data reception callbacks.
self.__register_state_callback()
self.__register_data_received_callback()
finally:
# Always remove the socket state callback.
self.__xbee_device.del_socket_state_received_callback(
socket_state_received_callback)