Fehlerverwaltung bei cycleloop und mainloop

Device.__contains__ Rückgabe bei ersetzen IOs nun False
RevPiModIO.__del__ löst klarere Fehler bei falscher Instantiierung aus

revpimodio2/__init__.py

@@ -24,7 +24,7 @@ __all__ = [
 __author__ = "Sven Sager <akira@revpimodio.org>"
 __name__ = "revpimodio2"
 __package__ = "revpimodio2"
-__version__ = "2.0.6"
+__version__ = "2.0.7"
 
 # Global package values
 OFF = 0

revpimodio2/device.py

@@ -171,18 +171,20 @@ class Device(object):
     def __contains__(self, key):
         """Prueft ob IO auf diesem Device liegt.
         @param key IO-Name <class 'str'> / IO-Bytenummer <class 'int'>
-        @return True, wenn device vorhanden"""
-        if type(key) == str:
-            return key in self._modio.io \
-                and getattr(self._modio.io, key)._parentdevice == self
-        elif type(key) == int:
+        @return True, wenn IO auf Device vorhanden"""
+        if issubclass(type(key), IOBase):
+            # Umwandlung für key
+            key = key._name
+
+        if type(key) == int:
             if key in self._modio.io:
                 for io in self._modio.io[key]:
                     if io is not None and io._parentdevice == self:
                         return True
             return False
         else:
-            return key._parentdevice == self
+            return key in self._modio.io \
+                and getattr(self._modio.io, key)._parentdevice == self
 
     def __int__(self):
         """Gibt die Positon im RevPi Bus zurueck.

revpimodio2/io.py

@@ -22,11 +22,10 @@ class IOList(object):
 
     def __contains__(self, key):
         """Prueft ob IO existiert.
-        @param key IO-Name <class 'str'> oder Byte <class 'int'>
+        @param key IO-Name <class 'str'> oder Bytenummer <class 'int'>
         @return True, wenn IO vorhanden / Byte belegt"""
         if type(key) == int:
-            return key in self.__dict_iobyte \
-                and len(self.__dict_iobyte[key]) > 0
+            return len(self.__dict_iobyte.get(key, [])) > 0
         else:
             return hasattr(self, key) and type(getattr(self, key)) != DeadIO
 

revpimodio2/modio.py

@@ -86,9 +86,10 @@ class RevPiModIO(object):
 
     def __del__(self):
         """Zerstoert alle Klassen um aufzuraeumen."""
-        self.exit(full=True)
-        if self._myfh is not None:
-            self._myfh.close()
+        if hasattr(self, "_exit"):
+            self.exit(full=True)
+            if self._myfh is not None:
+                self._myfh.close()
 
     def __evt_exit(self, signum, sigframe):
         """Eventhandler fuer Programmende.
@@ -368,23 +369,33 @@ class RevPiModIO(object):
         self._looprunning = True
         cycleinfo = helpermodule.Cycletools(self._imgwriter.refresh)
         ec = None
-        while ec is None and not self._exit.is_set():
-            # Auf neue Daten warten und nur ausführen wenn set()
-            if not self._imgwriter.newdata.wait(2.5):
-                if not self._exit.is_set() and not self._imgwriter.is_alive():
-                    raise RuntimeError("autorefresh thread not running")
-                continue
-            self._imgwriter.newdata.clear()
+        try:
+            while ec is None and not self._exit.is_set():
+                # Auf neue Daten warten und nur ausführen wenn set()
+                if not self._imgwriter.newdata.wait(2.5):
+                    if not self._exit.is_set() \
+                            and not self._imgwriter.is_alive():
+                        self.exit(full=False)
+                        self._looprunning = False
+                        raise RuntimeError("autorefresh thread not running")
+                    continue
+                self._imgwriter.newdata.clear()
 
-            # Vor Aufruf der Funktion autorefresh sperren
-            self._imgwriter.lck_refresh.acquire()
+                # Vor Aufruf der Funktion autorefresh sperren
+                self._imgwriter.lck_refresh.acquire()
 
-            # Funktion aufrufen und auswerten
-            ec = func(cycleinfo)
-            cycleinfo._docycle()
+                # Funktion aufrufen und auswerten
+                ec = func(cycleinfo)
+                cycleinfo._docycle()
 
-            # autorefresh freigeben
-            self._imgwriter.lck_refresh.release()
+                # autorefresh freigeben
+                self._imgwriter.lck_refresh.release()
+        except Exception as e:
+            if self._imgwriter.lck_refresh.locked():
+                self._imgwriter.lck_refresh.release()
+            self.exit(full=False)
+            self._looprunning = False
+            raise e
 
         # Cycleloop beenden
         self._looprunning = False
@@ -533,6 +544,8 @@ class RevPiModIO(object):
             # Auf neue Daten warten und nur ausführen wenn set()
             if not self._imgwriter.newdata.wait(2.5):
                 if not self._exit.is_set() and not self._imgwriter.is_alive():
+                    self.exit(full=False)
+                    self._looprunning = False
                     raise RuntimeError("autorefresh thread not running")
                 continue
 
@@ -624,16 +637,23 @@ class RevPiModIO(object):
                         del dict_delay[tup_fire]
 
             # Erst nach Datenübernahme alle Events feuern
-            while len(lst_fire) > 0:
-                tup_fire = lst_fire.pop()
-                if tup_fire[0][2]:
-                    th = helpermodule.EventCallback(
-                        tup_fire[0][0], tup_fire[1], tup_fire[2]
-                    )
-                    th.start()
-                else:
-                    # Direct callen da Prüfung in io.IOBase.reg_event ist
-                    tup_fire[0][0](tup_fire[1], tup_fire[2])
+            try:
+                while len(lst_fire) > 0:
+                    tup_fire = lst_fire.pop()
+                    if tup_fire[0][2]:
+                        th = helpermodule.EventCallback(
+                            tup_fire[0][0], tup_fire[1], tup_fire[2]
+                        )
+                        th.start()
+                    else:
+                        # Direct callen da Prüfung in io.IOBase.reg_event ist
+                        tup_fire[0][0](tup_fire[1], tup_fire[2])
+            except Exception as e:
+                if self._imgwriter.lck_refresh.locked():
+                    self._imgwriter.lck_refresh.release()
+                self.exit(full=False)
+                self._looprunning = False
+                raise e
 
             # Refreshsperre aufheben wenn freeze
             if freeze: