class ZigBeeProtocol(LineReceiver, ZigBee):
def __init__(self, escaped=True):
self._escaped = escaped
self.frame = APIFrame(escaped=self._escaped)
self.setRawMode()
def rawDataReceived(self, data):
print "received from ", self.transport.getPeer(), ": ", repr(data)
#data=data[1:]
if data[0] == APIFrame.START_BYTE:
self.frame = APIFrame(escaped=self._escaped)
for i in range(0, len(data)):
self.frame.fill(data[i])
if (not (self.frame.remaining_bytes() > 0)):
try:
# Try to parse and return result
self.frame.parse()
return getattr(self, "handle_packet", None)(self._split_response(self.frame.data))
except ValueError:
# Bad frame, so restart
self.frame = APIFrame(escaped=self._escaped)
def _write(self, data):
frame = APIFrame(data, self._escaped).output()
self.transport.write(frame)
class txXBee(protocol.Protocol, ZigBee):
def __init__(self, escaped=True):
self._escaped = escaped
self._frame = None
def dataReceived(self, data):
for c in data:
if self._frame:
self._frame.fill(c)
if self._frame.remaining_bytes() == 0:
try:
# Try to parse and return result
self._frame.parse()
self.handle_packet(self._split_response(self._frame.data))
except ValueError:
# Bad frame, so restart
self.handle_badframe(self._frame.raw_data)
self._frame = None
else:
if c == APIFrame.START_BYTE:
self._frame = APIFrame(escaped=self._escaped)
self._frame.fill(c)
def handle_packet(self, packet):
pass
def handle_badframe(self, packet):
pass
def _write(self, data):
frame = APIFrame(data, self._escaped).output()
self.transport.write(frame)
def _wait_for_frame(self, timeout=None):
"""
_wait_for_frame: None -> binary data
_wait_for_frame will read from the serial port until a valid
API frame arrives. It will then return the binary data
contained within the frame.
If this method is called as a separate thread
and self.thread_continue is set to False, the thread will
exit by raising a ThreadQuitException.
"""
frame = APIFrame(escaped=self._escaped)
deadline = 0
if timeout is not None and timeout > 0:
deadline = time.time() + timeout
while True:
if self._callback and not self._thread_continue:
raise ThreadQuitException
if self.serial.inWaiting() == 0:
if deadline and time.time() > deadline:
raise _TimeoutException
time.sleep(.01)
continue
byte = self.serial.read()
if byte != APIFrame.START_BYTE:
continue
# Save all following bytes, if they are not empty
if len(byte) == 1:
frame.fill(byte)
while(frame.remaining_bytes() > 0):
byte = self.serial.read()
if len(byte) == 1:
frame.fill(byte)
try:
# Try to parse and return result
frame.parse()
# Ignore empty frames
if len(frame.data) == 0:
frame = APIFrame()
continue
return frame
except ValueError:
# Bad frame, so restart
frame = APIFrame(escaped=self._escaped)
def test_unescape_input(self):
"""
APIFrame must properly unescape escaped input
"""
test_data = b'\x7D\x23'
expected_data = b'\x03'
frame = APIFrame(escaped=True)
for byte in [test_data[x:x+1] for x in range(0, len(test_data))]:
frame.fill(byte)
self.assertEqual(frame.raw_data, expected_data)
def test_unescape_input(self):
"""
APIFrame must properly unescape escaped input
"""
test_data = b'\x7D\x23'
expected_data = b'\x03'
frame = APIFrame(escaped=True)
for byte in [test_data[x:x + 1] for x in range(0, len(test_data))]:
frame.fill(byte)
self.assertEqual(frame.raw_data, expected_data)
def test_invalid_checksum(self):
"""
when an invalid frame is read, an exception must be raised
"""
api_frame = APIFrame()
frame = b'\x7E\x00\x01\x00\xF6'
for byte in frame:
api_frame.fill(intToByte(byteToInt(byte)))
self.assertRaises(ValueError, api_frame.parse)
def test_invalid_checksum(self):
"""
when an invalid frame is read, an exception must be raised
"""
api_frame = APIFrame()
frame = b'\x7E\x00\x01\x00\xF6'
for byte in frame:
api_frame.fill(intToByte(byteToInt(byte)))
self.assertRaises(ValueError, api_frame.parse)
def _wait_for_frame(self, timeout=None):
"""
_wait_for_frame: None -> binary data
_wait_for_frame will read from the serial port until a valid
API frame arrives. It will then return the binary data
contained within the frame.
If this method is called as a separate thread
and self.thread_continue is set to False, the thread will
exit by raising a ThreadQuitException.
"""
frame = APIFrame(escaped=self._escaped)
deadline = 0
if timeout is not None and timeout > 0:
deadline = time.time() + timeout
while True:
if self._exit.is_set():
raise ThreadQuitException
byte = self.serial.read()
if byte != APIFrame.START_BYTE:
if deadline and time.time() > deadline:
raise TimeoutException
continue
if timeout is not None and timeout > 0:
deadline = time.time() + timeout
frame.fill(byte) # Save all following bytes
while frame.remaining_bytes() > 0:
if self._exit.is_set():
raise ThreadQuitException
if self.serial.inWaiting() < 1 and deadline and time.time() > deadline:
raise TimeoutException, len(frame.data)
byte = self.serial.read(frame.remaining_bytes())
for b in byte:
frame.fill(b)
try:
# Try to parse and return result
frame.parse()
return frame
except ValueError:
# Bad frame, so restart
frame = APIFrame(escaped=self._escaped)
def _wait_for_frame(self, timeout=None):
"""
_wait_for_frame: None -> binary data
_wait_for_frame will read from the serial port until a valid
API frame arrives. It will then return the binary data
contained within the frame.
If this method is called as a separate thread
and self.thread_continue is set to False, the thread will
exit by raising a ThreadQuitException.
"""
frame = APIFrame(escaped=self._escaped)
deadline = 0
if timeout is not None and timeout > 0:
deadline = time.time() + timeout
while True:
if self._exit.is_set(): raise ThreadQuitException
byte = self.serial.read()
if byte != APIFrame.START_BYTE:
if deadline and time.time() > deadline:
raise TimeoutException
continue
if timeout is not None and timeout > 0:
deadline = time.time() + timeout
frame.fill(byte) # Save all following bytes
while (frame.remaining_bytes() > 0):
if self._exit.is_set(): raise ThreadQuitException
if self.serial.inWaiting() < 1 and \
deadline and time.time() > deadline:
raise TimeoutException, len(frame.data)
byte = self.serial.read(frame.remaining_bytes())
for b in byte:
frame.fill(b)
try:
# Try to parse and return result
frame.parse()
return frame
except ValueError:
# Bad frame, so restart
frame = APIFrame(escaped=self._escaped)
def test_single_byte(self):
"""
read a frame containing a single byte
"""
api_frame = APIFrame()
frame = b'\x7E\x00\x01\x00\xFF'
expected_data = b'\x00'
for byte in frame:
api_frame.fill(intToByte(byteToInt(byte)))
api_frame.parse()
self.assertEqual(api_frame.data, expected_data)
def test_single_byte(self):
"""
read a frame containing a single byte
"""
api_frame = APIFrame()
frame = b'\x7E\x00\x01\x00\xFF'
expected_data = b'\x00'
for byte in frame:
api_frame.fill(intToByte(byteToInt(byte)))
api_frame.parse()
self.assertEqual(api_frame.data, expected_data)
def _wait_for_frame(self):
"""
_wait_for_frame: None -> binary data
_wait_for_frame will read from the serial port until a valid
API frame arrives. It will then return the binary data
contained within the frame.
If this method is called as a separate thread
and self.thread_continue is set to False, the thread will
exit by raising a ThreadQuitException.
"""
global handler
frame = APIFrame(escaped=self._escaped)
mode = 0
try:
while True:
signal.alarm(10)
if self._callback and not self._thread_continue:
raise ThreadQuitException
while (self.serial.inWaiting() < 1):
time.sleep(0.01)
byte = self.serial.read()
signal.alarm(0)
if byte == '':
continue
if (mode == 0):
if byte == APIFrame.START_BYTE:
mode = 1
else:
continue
frame.fill(byte)
if ((mode == 1) and (frame.remaining_bytes() <= 0)):
try:
# Try to parse and return result
frame.parse()
mode = 0
return frame
except ValueError:
# Bad frame, so restart
mode = 0
frame = APIFrame(escaped=self._escaped)
except Exception, exc:
print exc
def _wait_for_frame(self):
"""
_wait_for_frame: None -> binary data
_wait_for_frame will read from the serial port until a valid
API frame arrives. It will then return the binary data
contained within the frame.
If this method is called as a separate thread
and self.thread_continue is set to False, the thread will
exit by raising a ThreadQuitException.
"""
frame = APIFrame(escaped=self._escaped)
while True:
if self._callback and not self._thread_continue:
raise ThreadQuitException
bytes = self.serial.read(1)
byte = bytes[0]
if byte != APIFrame.START_BYTE:
continue
frame.fill(byte)
while True:
remaining_bytes = frame.remaining_bytes()
if remaining_bytes < 1:
break
bytes = self.serial.read(remaining_bytes)
for byte in bytes:
frame.fill(byte)
try:
# Try to parse and return result
frame.parse()
# Ignore empty frames
if len(frame.data) == 0:
frame = APIFrame()
continue
return frame
except ValueError:
# Bad frame, so restart
frame = APIFrame(escaped=self._escaped)
def _wait_for_frame(self, msec):
"""
_wait_for_frame: None -> binary data
_wait_for_frame will read from the serial port until a valid
API frame arrives. It will then return the binary data
contained within the frame.
If this method is called as a separate thread
and self.thread_continue is set to False, the thread will
exit by raising a ThreadQuitException.
"""
frame = APIFrame(escaped=self._escaped)
timeoutflag = False if msec < 0 else True
limit = time.time() + msec / 1000.0
while True:
if timeoutflag and time.time() > limit:
return None
if self._callback and not self._thread_continue:
raise ThreadQuitException
if self.serial.inWaiting() == 0:
time.sleep(.01)
continue
byte = self.serial.read()
if byte != APIFrame.START_BYTE:
continue
# Save all following bytes
frame.fill(byte)
while(frame.remaining_bytes() > 0):
frame.fill(self.serial.read())
try:
# Try to parse and return result
frame.parse()
return frame
except ValueError:
# Bad frame, so restart
frame = APIFrame(escaped=self._escaped)
def _wait_for_frame(self):
"""
_wait_for_frame: None -> binary data
_wait_for_frame will read from the serial port until a valid
API frame arrives. It will then return the binary data
contained within the frame.
If this method is called as a separate thread
and self.thread_continue is set to False, the thread will
exit by raising a ThreadQuitException.
"""
frame = APIFrame(escaped=self._escaped)
mode = 0
while True:
if self._callback and not self._thread_continue:
raise ThreadQuitException
while ( self.serial.inWaiting() <1):
time.sleep(0.01)
byte = self.serial.read()
if byte =='':
continue
if (mode ==0):
if byte == APIFrame.START_BYTE:
mode=1
else:
continue
frame.fill(byte)
if ( (mode==1) and (frame.remaining_bytes() <=0) ) :
try:
# Try to parse and return result
frame.parse()
mode =0
return frame
except ValueError:
# Bad frame, so restart
mode=0
frame = APIFrame(escaped=self._escaped)
def _process_input(self, data, events):
"""
_process_input:
_process_input will be notified when there is data ready on the
serial connection to be read. It will read and process the data
into an API Frame and then either resolve a frame future, or push
the frame into the queue of frames needing to be processed
"""
frame = APIFrame(escaped=self._escaped)
byte = self.serial.read()
if byte != APIFrame.START_BYTE:
return
# Save all following bytes, if they are not empty
if len(byte) == 1:
frame.fill(byte)
while (frame.remaining_bytes() > 0):
byte = self.serial.read()
if len(byte) == 1:
frame.fill(byte)
try:
# Try to parse and return result
frame.parse()
# Ignore empty frames
if len(frame.data) == 0:
return
if self._frame_future is not None:
self._frame_future.set_result(frame)
self._frame_future = None
else:
self._frame_queue.append(frame)
except ValueError:
return
def _process_input(self, data, events):
"""
_process_input:
_process_input will be notified when there is data ready on the
serial connection to be read. It will read and process the data
into an API Frame and then either resolve a frame future, or push
the frame into the queue of frames needing to be processed
"""
frame = APIFrame(escaped=self._escaped)
byte = self.serial.read()
if byte != APIFrame.START_BYTE:
return
# Save all following bytes, if they are not empty
if len(byte) == 1:
frame.fill(byte)
while(frame.remaining_bytes() > 0):
byte = self.serial.read()
if len(byte) == 1:
frame.fill(byte)
try:
# Try to parse and return result
frame.parse()
# Ignore empty frames
if len(frame.data) == 0:
return
if self._frame_future is not None:
self._frame_future.set_result(frame)
self._frame_future = None
else:
self._frame_queue.append(frame)
except ValueError:
return
def _wait_for_frame(self):
"""
_wait_for_frame: None -> binary data
_wait_for_frame will read from the serial port until a valid
API frame arrives. It will then return the binary data
contained within the frame.
If this method is called as a separate thread
and self.thread_continue is set to False, the thread will
exit by raising a ThreadQuitException.
"""
frame = APIFrame(escaped=self._escaped)
while True:
if self._callback and not self._thread_continue:
raise ThreadQuitException
if self.serial.inWaiting() == 0:
time.sleep(.01)
continue
byte = self.serial.read()
if byte != APIFrame.START_BYTE:
continue
# Save all following bytes
frame.fill(byte)
while (frame.remaining_bytes() > 0):
frame.fill(self.serial.read())
try:
# Try to parse and return result
frame.parse()
return frame
except ValueError:
# Bad frame, so restart
frame = APIFrame(escaped=self._escaped)
class ZigBeeProtocol(LineReceiver, ZigBee): def __init__(self, escaped=True): self._escaped = escaped self.frame = APIFrame(escaped=self._escaped) self.setRawMode() def rawDataReceived(self, data): if data[0] == APIFrame.START_BYTE: self.frame = APIFrame(escaped=self._escaped) for i in range(0, len(data)): self.frame.fill(data[i]) if (not (self.frame.remaining_bytes() > 0)): try: # Try to parse and return result self.frame.parse() return getattr(self, "handle_packet", None)(self._split_response(self.frame.data)) except ValueError: # Bad frame, so restart self.frame = APIFrame(escaped=self._escaped) def _write(self, data): frame = APIFrame(data, self._escaped).output() self.transport.write(frame)
def test_remaining_bytes(self):
"""
remaining_bytes() should provide accurate indication
of remaining bytes required before parsing a packet
"""
api_frame = APIFrame()
frame = b'\x7E\x00\x04\x00\x00\x00\x00\xFF'
self.assertEqual(api_frame.remaining_bytes(), 3)
api_frame.fill(frame[0])
self.assertEqual(api_frame.remaining_bytes(), 2)
api_frame.fill(frame[1])
self.assertEqual(api_frame.remaining_bytes(), 1)
api_frame.fill(frame[2])
self.assertEqual(api_frame.remaining_bytes(), 5)
api_frame.fill(frame[3])
self.assertEqual(api_frame.remaining_bytes(), 4)
def test_remaining_bytes(self):
"""
remaining_bytes() should provide accurate indication
of remaining bytes required before parsing a packet
"""
api_frame = APIFrame()
frame = b'\x7E\x00\x04\x00\x00\x00\x00\xFF'
self.assertEqual(api_frame.remaining_bytes(), 3)
api_frame.fill(frame[0])
self.assertEqual(api_frame.remaining_bytes(), 2)
api_frame.fill(frame[1])
self.assertEqual(api_frame.remaining_bytes(), 1)
api_frame.fill(frame[2])
self.assertEqual(api_frame.remaining_bytes(), 5)
api_frame.fill(frame[3])
self.assertEqual(api_frame.remaining_bytes(), 4)
