Refactoring of code.

Author: basilfx

README.md

@@ -2,7 +2,7 @@
 Frame-based streaming protocol for embedded applications.
 
 ## Introduction
-This is a Python module to provide a bi-directional frame-based streaming protocol for low-speed embedded applications, such as serial connected devices. It allowes the receiver to 'jump into' a stream of data frames. Every frame starts with a preamble, so the receiver can synchronize. Any mismatch in checksum will the receiver.
+This is a general purpose Python module to provide a bi-directional frame-based streaming protocol for low-speed embedded applications, such as serial connected devices. It allowes the receiver to 'jump into' a stream of data frames. Every frame starts with a preamble, so the receiver can synchronize. Any mismatch in checksum will the receiver.
 
 A payload is optional. The reserved `RESET` flag can be used to indicate that the link should reset, for instance when the receiver just started and the sender should restart.
 

tests/test_tinylink.py

@@ -12,15 +12,15 @@ def __init__(self):
         self.index = 0
         self.length = 0
 
-    def send(self, data):
+    def write(self, data):
         self.buffer.extend(data)
         self.length += len(data)
 
         # Return number of bytes written
         return len(data)
 
-    def recv(self, count):
-        data = self.buffer[self.index:min(self.length, self.index+count)]
+    def read(self, count):
+        data = str(self.buffer[self.index:min(self.length, self.index+count)])
         self.index += len(data)
 
         # Return data
@@ -33,7 +33,7 @@ class TinyLinkTest(unittest.TestCase):
 
     def test_basic(self):
         """
-        Test send/receive by using a dummy handle.
+        Test read/write by using a dummy handle.
         """
 
         handle = DummyHandle()
@@ -99,7 +99,7 @@ def test_sync(self):
         garbage = "Garbage here that doesn't synchronize."
         message = "Hi!"
 
-        size = handle.send(garbage) + link.write(message)
+        size = handle.write(garbage) + link.write(message)
         frames = link.read(size)
 
         self.assertEqual(len(frames), 1)
@@ -116,7 +116,7 @@ def test_sync_small(self):
         garbage = "Garbage here that doesn't synchronize."
         message = "Hi!"
 
-        size = handle.send(garbage) + link.write(message)
+        size = handle.write(garbage) + link.write(message)
         frames = link.read(size)
 
         self.assertEqual(len(frames), 1)

tinylink/__init__.py

@@ -2,12 +2,14 @@
 
 import struct
 
+__version__ = "1.1"
+
 # This can be anything, and is used to synchronize a frame
 PREAMBLE = 0xAA55AA55
 
 # Endianness
 LITTLE_ENDIAN = "<"
-BIG_ENDINAN = ">"
+BIG_ENDIAN = ">"
 
 # Protocol states
 WAITING_FOR_PREAMBLE = 1
@@ -37,7 +39,7 @@ def __init__(self, data=None, flags=FLAG_NONE):
         self.flags = flags
 
     def __repr__(self):
-        return "%s(%s, flags=0x%02x)" % (self.__class__.__name__,
+        return "%s(%s, flags=%d)" % (self.__class__.__name__,
             repr(self.data), self.flags)
 
 class Frame(BaseFrame):
@@ -77,10 +79,10 @@ class TinyLink(object):
     """
 
     def __init__(self, handle, endianness=LITTLE_ENDIAN,
-        max_length=2**(LEN_LENGTH * 8)):
+        max_length=2**(LEN_LENGTH * 8), ignore_damaged=False):
         """
         Construct a new TinyLink state machine. A state machine takes a handle,
-        which provides a `recv' and `send' method.
+        which provides a `read' and `write' method.
 
         The endianness is either LITTLE_ENDIAN or BIG_ENDIAN. While big endian
         is common for networking, little endian is directly compatible with ARM
@@ -90,6 +92,9 @@ def __init__(self, handle, endianness=LITTLE_ENDIAN,
         Both microcontroller and this instance should agree upon the value of
         `max_length'. In case a message is received that exceeds this value, it
         will be silently ignored.
+
+        By default, if a fully received frame is damaged, it will be returned
+        as a `DamagedFrame' instance, unless `ignored_damaged' is True.
         """
 
         self.handle = handle
@@ -105,9 +110,9 @@ def __init__(self, handle, endianness=LITTLE_ENDIAN,
         self.buffer = buffer(self.stream)
         self.index = 0
 
-    def send_frame(self, frame):
+    def write_frame(self, frame):
         """
-        Send a frame via the handle.
+        Write a frame via the handle.
         """
 
         result = bytearray()
@@ -130,38 +135,35 @@ def send_frame(self, frame):
                 frame.data, checksum_frame)
 
         # Write to file
-        return self.handle.send(result)
+        return self.handle.write(result)
 
     def reset(self):
         """
-        Shorthand for `send_data(ResetFrame())'.
+        Shorthand for `write_frame(ResetFrame())'.
         """
 
-        return self.send_frame(ResetFrame())
+        return self.write_frame(ResetFrame())
 
     def write(self, data, flags=FLAG_NONE):
         """
-        Shorthand for `send_data(Frame(data, flags=flags))'.
+        Shorthand for `write_frame(Frame(data, flags=flags))'.
         """
 
-        return self.send_frame(Frame(data, flags=flags))
+        return self.write_frame(Frame(data, flags=flags))
 
-    def read(self, limit=1, ignore_damaged=False):
+    def read(self, limit=1):
         """
         Read at `limit' bytes from the handle and process this byte. Returns a
         list of received frames, if any. A reset frame is indicated by a
         `ResetFrame' instance.
-
-        By default, if a fully received package is damaged, it will be returned
-        as a `DamagedFrame' instance, unless `ignored_damaged' is True.
         """
 
-        # Define list for all results
+        # List of frames received
         frames = []
 
         # Bytes are added one at a time
-        for byte in self.handle.recv(limit):
-            self.stream[self.index] = byte
+        while limit:
+            self.stream[self.index] = self.handle.read(1)
             self.index += 1
 
             # Decide what to do
@@ -217,12 +219,15 @@ def read(self, limit=1, ignore_damaged=False):
                     # Verify checksum
                     if checksum_b == utils.checksum_frame(result, checksum_a):
                         frames.append(Frame(result, flags=flags))
-                    elif not ignore_damaged:
+                    elif not self.ignore_damaged:
                         frames.append(DamagedFrame(result, flags=flags))
 
                     # Reset to start state
                     self.index = 0
                     self.state = WAITING_FOR_PREAMBLE
 
+            # Decrement number of bytes to read
+            limit -= 1
+
         # Done
         return frames