Python frame.APIFrame類代碼示例

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_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_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 _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 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 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.
        """

        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 test_escape_method(self):
     """
     APIFrame.escape() must work as expected
     """
     test_data = APIFrame.START_BYTE
     new_data = APIFrame.escape(test_data)
     self.assertEqual(new_data, APIFrame.ESCAPE_BYTE + b'\x5e')

 def test_single_byte(self):
     """
     read a frame containing a single byte
     """
     frame = '\x7E\x00\x01\x00\xFF'
     expected_data = '\x00'
     
     data = APIFrame.parse(frame).data
     self.assertEqual(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.
        """
        WAITING = 0
        PARSING = 1
        
        data = ''
        state = WAITING
        
        while True:
            if state == WAITING:
                if self._callback and not self._thread_continue:
                    raise ThreadQuitException

                if self.serial.inWaiting() == 0:
                    time.sleep(.01)
                    continue
                
                byte = self.serial.read()
                
                # If a start byte is found, swich states
                if byte == APIFrame.START_BYTE:
                    data += byte
                    state = PARSING
            else:
                # Save all following bytes
                data += self.serial.read()
                
                if len(data) == 3:
                    # We have the length bytes of the data
                    # Now, wait for the rest to appear
                    data_len = struct.unpack("> h", data[1:3])[0]
                    
                    # Wait for the expected number of bytes to appear
                    # Grab the checksum too
                    data += self.serial.read(data_len + 1)
                    
                    try:
                        # Try to parse and return result
                        return APIFrame.parse(data)
                    except ValueError:
                        # Bad frame, so restart
                        data = ''
                        state = WAITING

    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 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 _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)
        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)