Prevent using same port multiple times (#121)

* Prevent using same port multiple times

* Use WeakMethod for callbacks, to avoid bumping up refcount of Device.  Also make sure we wait for callback loop to terminate to avoid _enter_buffered_busy error

Author: chrisruk

buildhat/color.py

@@ -143,27 +143,31 @@ def get_color_hsv(self):
         hue = int((math.degrees((math.atan2(s,c))) + 360) % 360)
         sat = int(sum([hsv[1] for hsv in readings]) / len(readings))
         val = int(sum([hsv[2] for hsv in readings]) / len(readings))
-        return (hue, sat, val)       
+        return (hue, sat, val)
+
+    def _cb_handle(self, lst):
+        self._data.append(lst[:4])
+        if len(self._data) == self.avg_reads:
+            r, g, b, _ = self._avgrgbi(self._data)
+            seg = self.segment_color(r, g, b)
+            if self._cmp(seg, self._color):
+                with self._cond:
+                    self._old_color = seg
+                    self._cond.notify()
 
     def wait_until_color(self, color):
         """Waits until specific color
 
         :param color: Color to look for 
         """
         self.mode(5)
-        cond = Condition()
-        data = deque(maxlen=self.avg_reads)
-        def cb(lst):
-            data.append(lst[:4])
-            if len(data) == self.avg_reads:
-                r, g, b, _ = self._avgrgbi(data)
-                seg = self.segment_color(r, g, b)
-                if seg == color:
-                    with cond:
-                        cond.notify()
-        self.callback(cb)
-        with cond:
-            cond.wait()
+        self._cond = Condition()
+        self._data = deque(maxlen=self.avg_reads)
+        self._color = color
+        self._cmp = lambda x, y: x == y
+        self.callback(self._cb_handle)
+        with self._cond:
+            self._cond.wait()
         self.callback(None)
 
     def wait_for_new_color(self):
@@ -173,20 +177,13 @@ def wait_for_new_color(self):
         if self._old_color is None:
             self._old_color = self.get_color()
             return self._old_color
-        cond = Condition()
-        data = deque(maxlen=self.avg_reads)
-        def cb(lst):
-            data.append(lst[:4])
-            if len(data) ==  self.avg_reads:
-                r, g, b, _ = self._avgrgbi(data)
-                seg = self.segment_color(r, g, b)
-                if seg != self._old_color:
-                    self._old_color = seg
-                    with cond:
-                        cond.notify()
-        self.callback(cb)
-        with cond:
-            cond.wait()
+        self._cond = Condition()
+        self._data = deque(maxlen=self.avg_reads)
+        self._color = self._old_color
+        self._cmp = lambda x, y: x != y
+        self.callback(self._cb_handle)
+        with self._cond:
+            self._cond.wait()
         self.callback(None)
         return self._old_color
 

buildhat/colordistance.py

@@ -127,25 +127,29 @@ def get_color_rgb(self):
             reads.append(self.get())
         return self._avgrgb(reads)
 
+    def _cb_handle(self, lst):
+        self._data.append(lst)
+        if len(self._data) == self.avg_reads:
+            r, g, b = self._avgrgb(self._data)
+            seg = self.segment_color(r, g, b)
+            if self._cmp(seg, self._color):
+                with self._cond:
+                    self._old_color = seg
+                    self._cond.notify()
+
     def wait_until_color(self, color):
         """Waits until specific color
 
         :param color: Color to look for 
         """
         self.mode(6)
-        cond = Condition()
-        data = deque(maxlen=self.avg_reads)
-        def cb(lst):
-            data.append(lst)
-            if len(data) == self.avg_reads:
-                r, g, b = self._avgrgb(data)
-                seg = self.segment_color(r, g, b)
-                if seg == color:
-                    with cond:
-                        cond.notify()
-        self.callback(cb)
-        with cond:
-            cond.wait()
+        self._cond = Condition()
+        self._data = deque(maxlen=self.avg_reads)
+        self._color = color
+        self._cmp = lambda x, y: x == y
+        self.callback(self._cb_handle)
+        with self._cond:
+            self._cond.wait()
         self.callback(None)
 
     def wait_for_new_color(self):
@@ -155,20 +159,13 @@ def wait_for_new_color(self):
         if self._old_color is None:
             self._old_color = self.get_color()
             return self._old_color
-        cond = Condition()
-        data = deque(maxlen=self.avg_reads)
-        def cb(lst):
-            data.append(lst)
-            if len(data) ==  self.avg_reads:
-                r, g, b = self._avgrgb(data)
-                seg = self.segment_color(r, g, b)
-                if seg != self._old_color:
-                    self._old_color = seg
-                    with cond:
-                        cond.notify()
-        self.callback(cb)
-        with cond:
-            cond.wait()
+        self._cond = Condition()
+        self._data = deque(maxlen=self.avg_reads)
+        self._color = self._old_color
+        self._cmp = lambda x, y: x != y
+        self.callback(self._cb_handle)
+        with self._cond:
+            self._cond.wait()
         self.callback(None)
         return self._old_color
 

buildhat/devices.py

@@ -1,5 +1,5 @@
 from .serinterface import BuildHAT
-from .exc import DeviceNotFound, DeviceChanged, DeviceInvalidMode, DeviceInvalid
+from .exc import DeviceNotFound, DeviceChanged, DeviceInvalidMode, DeviceInvalid, PortInUse
 import weakref
 import time
 import os
@@ -29,29 +29,48 @@ class Device:
                       75: "Motor",
                       76: "Motor"
                     }
+    _used = { 0: False,
+              1: False,
+              2: False,
+              3: False
+            }
 
     def __init__(self, port):
         if not isinstance(port, str) or len(port) != 1:
             raise DeviceNotFound("Invalid port")
         p = ord(port) - ord('A')
         if not (p >= 0 and p <= 3):
             raise DeviceNotFound("Invalid port")
+        if Device._used[p]:
+            raise PortInUse("Port already used")
         self.port = p
-        if not Device._instance:
-            data = os.path.join(os.path.dirname(sys.modules["buildhat"].__file__),"data/")
-            firm = os.path.join(data,"firmware.bin")
-            sig = os.path.join(data,"signature.bin")
-            ver = os.path.join(data,"version")
-            vfile = open(ver)
-            v = int(vfile.read())
-            vfile.close()
-            Device._instance = BuildHAT(firm, sig, v)
-            weakref.finalize(self, self._close)
+        Device._setup()
         self._simplemode = -1
         self._combimode = -1
         self._typeid = self._conn.typeid
         if (self._typeid in Device._device_names and Device._device_names[self._typeid] != type(self).__name__) or self._typeid == -1:
             raise DeviceInvalid('There is not a {} connected to port {} (Found {})'.format(type(self).__name__, port, self.name))
+        Device._used[p] = True
+
+    def _setup(device="/dev/serial0"):
+        if Device._instance:
+            return
+        data = os.path.join(os.path.dirname(sys.modules["buildhat"].__file__),"data/")
+        firm = os.path.join(data,"firmware.bin")
+        sig = os.path.join(data,"signature.bin")
+        ver = os.path.join(data,"version")
+        vfile = open(ver)
+        v = int(vfile.read())
+        vfile.close()
+        Device._instance = BuildHAT(firm, sig, v, device=device)
+        weakref.finalize(Device._instance, Device._instance.shutdown)
+
+    def __del__(self):
+        if hasattr(self, "port") and Device._used[self.port]:
+            Device._used[self.port] = False
+            self._conn.callit = None
+            self.deselect()
+            self.off()
 
     @property
     def _conn(self):
@@ -83,9 +102,6 @@ def name(self):
         else:
             return "Unknown"
 
-    def _close(self):
-        Device._instance.shutdown()
-
     def isconnected(self):
         if not self.connected:
             raise DeviceNotFound("No device found")
@@ -163,4 +179,7 @@ def callback(self, func):
             self.select()
         else:
             self.deselect()
-        self._conn.callit = func
+        if func is None:
+            self._conn.callit = None
+        else:
+            self._conn.callit = weakref.WeakMethod(func)

buildhat/exc.py

@@ -22,6 +22,9 @@ class DeviceNotFound(Exception):
 class DeviceChanged(Exception):
     pass
 
+class PortInUse(Exception):
+    pass
+
 class DistanceSensorException(Exception):
     pass
 

buildhat/hat.py

@@ -7,17 +7,8 @@
 class Hat:
     """Allows enumeration of devices which are connected to the hat
     """
-    def __init__(self, device="/dev/serial0"):
-        if not Device._instance:
-            data = os.path.join(os.path.dirname(sys.modules["buildhat"].__file__),"data/")
-            firm = os.path.join(data,"firmware.bin")
-            sig = os.path.join(data,"signature.bin")
-            ver = os.path.join(data,"version")
-            vfile = open(ver)
-            v = int(vfile.read())
-            vfile.close()
-            Device._instance = BuildHAT(firm, sig, v, device=device)
-            weakref.finalize(self, self._close)
+    def __init__(self):
+        Device._setup()
 
     def get(self):
         """Gets devices which are connected or disconnected 

buildhat/motors.py

@@ -85,9 +85,6 @@ def set_default_speed(self, default_speed):
             raise MotorException("Invalid Speed")
         self.default_speed = default_speed
 
-    def _isfinishedcb(self, speed, pos, apos):
-        self._bqueue.append(pos)
-
     def run_for_rotations(self, rotations, speed=None, blocking=True):
         """Runs motor for N rotations
 
@@ -266,22 +263,21 @@ def when_rotated(self):
         """
         return self._when_rotated
 
-    def _intermediate(self, value, speed, pos, apos):
+    def _intermediate(self, data):
+        speed, pos, apos = data
         if self._oldpos is None:
             self._oldpos = pos
             return
         if abs(pos - self._oldpos) >= 1:
-            value(speed, pos, apos)
+            if self._when_rotated is not None:
+                self._when_rotated(speed, pos, apos)
             self._oldpos = pos
 
     @when_rotated.setter
     def when_rotated(self, value):
         """Calls back, when motor has been rotated"""
-        if value is not None:
-            self._when_rotated = lambda lst: [self._intermediate(value, lst[0], lst[1], lst[2]),self._isfinishedcb(lst[0], lst[1], lst[2])]
-        else:
-            self._when_rotated = lambda lst: self._isfinishedcb(lst[0], lst[1], lst[2])
-        self.callback(self._when_rotated)
+        self._when_rotated = value
+        self.callback(self._intermediate)
 
     def plimit(self, plimit):
         if not (plimit >= 0 and plimit <= 1):

buildhat/serinterface.py

@@ -1,5 +1,4 @@
 from .exc import DeviceNotFound, DeviceChanged, DeviceInvalid, HatNotFound
-import importlib
 import threading
 import gpiozero
 import serial
@@ -186,6 +185,8 @@ def shutdown(self):
             self.fin = True
             self.running = False
             self.th.join()
+            self.cbqueue.put(())
+            self.cb.join()
             turnoff = ""
             for p in range(4):
                 conn = self.connections[p]
@@ -199,7 +200,13 @@ def shutdown(self):
     def callbackloop(self, q):
         while self.running:
             cb = q.get()
-            cb[0](cb[1])
+            # Test for empty tuple, which should only be passed when
+            # we're shutting down
+            if len(cb) == 0:
+                continue
+            if not cb[0]._alive:
+                continue
+            cb[0]()(cb[1])
             q.task_done()
 
     def loop(self, cond, uselist, q):

test/distance.py

@@ -0,0 +1,30 @@
+import unittest
+from buildhat import DistanceSensor
+from buildhat.exc import PortInUse
+
+class TestDistance(unittest.TestCase):
+
+    def test_properties(self):
+        d = DistanceSensor('A')
+        self.assertIsInstance(d.distance, int)
+        self.assertIsInstance(d.threshold_distance, int)
+
+    def test_distance(self):
+        d = DistanceSensor('A')
+        self.assertIsInstance(d.get_distance(), int)
+
+    def test_eyes(self):
+        d = DistanceSensor('A')
+        d.eyes(100, 100, 100, 100)
+
+    def test_duplicate_port(self):
+        d = DistanceSensor('A')
+        self.assertRaises(PortInUse, DistanceSensor, 'A')
+
+    def test_del(self):
+        d = DistanceSensor('A')
+        del d
+        d = DistanceSensor('A')
+
+if __name__ == '__main__':
+    unittest.main()

test/vin.py renamed to test/hat.py

@@ -2,14 +2,17 @@
 from buildhat import Hat
 
 
-class TestVin(unittest.TestCase):
+class TestHat(unittest.TestCase):
 
     def test_vin(self):
         h = Hat()
         vin = h.get_vin()
         self.assertGreaterEqual(vin, 7.2)
         self.assertLessEqual(vin, 8.5)
 
+    def test_get(self):
+        h = Hat()
+        self.assertIsInstance(h.get(), dict)
 
 if __name__ == '__main__':
     unittest.main()