diff --git a/doc/index-revpimodio2.html b/doc/index-revpimodio2.html
new file mode 100644
index 0000000..421e8fa
--- /dev/null
+++ b/doc/index-revpimodio2.html
@@ -0,0 +1,48 @@
+
+
+revpimodio2
+
+
+
+
+revpimodio2
+
+Stellt alle Klassen fuer den RevolutionPi zur Verfuegung.
+
+Stellt Klassen fuer die einfache Verwendung des Revolution Pis der
+Kunbus GmbH (https://revolution.kunbus.de/) zur Verfuegung. Alle I/Os werden
+aus der piCtory Konfiguration eingelesen und mit deren Namen direkt zugreifbar
+gemacht. Fuer Gateways sind eigene IOs ueber mehrere Bytes konfigurierbar
+Mit den definierten Namen greift man direkt auf die gewuenschten Daten zu.
+Auf alle IOs kann der Benutzer Funktionen als Events registrieren. Diese
+fuehrt das Modul bei Datenaenderung aus.
+
+
+
+
+Modules
+
+
+| revpimodio2 |
+Stellt alle Klassen fuer den RevolutionPi zur Verfuegung. |
+
+| app |
+Bildet die App Sektion von piCtory ab. |
+
+| device |
+Modul fuer die Verwaltung der Devices. |
+
+| helper |
+RevPiModIO Helperklassen und Tools. |
+
+| io |
+RevPiModIO Modul fuer die Verwaltung der IOs. |
+
+| modio |
+RevPiModIO Hauptklasse. |
+
+| summary |
+Bildet die Summary-Sektion von piCtory ab. |
+
+
+
\ No newline at end of file
diff --git a/doc/index.html b/doc/index.html
new file mode 100644
index 0000000..2e6711c
--- /dev/null
+++ b/doc/index.html
@@ -0,0 +1,20 @@
+
+
+Table of contents
+
+
+
+
+Table of contents
+
+
+
+Packages
+
+
+| revpimodio2 |
+Stellt alle Klassen fuer den RevolutionPi zur Verfuegung. |
+
+
+
+
\ No newline at end of file
diff --git a/doc/revpimodio2.__init__.html b/doc/revpimodio2.__init__.html
new file mode 100644
index 0000000..bbc660a
--- /dev/null
+++ b/doc/revpimodio2.__init__.html
@@ -0,0 +1,70 @@
+
+
+revpimodio2.__init__
+
+
+
+
+revpimodio2.__init__
+
+Stellt alle Klassen fuer den RevolutionPi zur Verfuegung.
+
+Stellt Klassen fuer die einfache Verwendung des Revolution Pis der
+Kunbus GmbH (https://revolution.kunbus.de/) zur Verfuegung. Alle I/Os werden
+aus der piCtory Konfiguration eingelesen und mit deren Namen direkt zugreifbar
+gemacht. Fuer Gateways sind eigene IOs ueber mehrere Bytes konfigurierbar
+Mit den definierten Namen greift man direkt auf die gewuenschten Daten zu.
+Auf alle IOs kann der Benutzer Funktionen als Events registrieren. Diese
+fuehrt das Modul bei Datenaenderung aus.
+
+
+Global Attributes
+
+| BOTH |
| FALLING |
| GREEN |
| OFF |
| RED |
| RISING |
| __all__ |
| __author__ |
| __name__ |
| __package__ |
| __version__ |
+
+
+Classes
+
+
+Functions
+
+
+
+IOType
+
+IO Typen.
+
+
+Derived from
+object
+
+Class Attributes
+
+
+Class Methods
+
+
+Methods
+
+
+Static Methods
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/revpimodio2.app.html b/doc/revpimodio2.app.html
new file mode 100644
index 0000000..c18e732
--- /dev/null
+++ b/doc/revpimodio2.app.html
@@ -0,0 +1,76 @@
+
+
+revpimodio2.app
+
+
+
+
+revpimodio2.app
+
+Bildet die App Sektion von piCtory ab.
+
+
+Global Attributes
+
+
+Classes
+
+
+| App |
+Bildet die App Sektion der config.rsc ab. |
+
+
+
+Functions
+
+
+
+App
+
+Bildet die App Sektion der config.rsc ab.
+
+
+Derived from
+object
+
+Class Attributes
+
+
+Class Methods
+
+
+Methods
+
+
+| App |
+Instantiiert die App-Klasse. |
+
+
+
+Static Methods
+
+
+
+App (Constructor)
+App(app)
+
+Instantiiert die App-Klasse.
+
+- app
+-
+piCtory Appinformationen
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/revpimodio2.device.html b/doc/revpimodio2.device.html
new file mode 100644
index 0000000..10d480c
--- /dev/null
+++ b/doc/revpimodio2.device.html
@@ -0,0 +1,822 @@
+
+
+revpimodio2.device
+
+
+
+
+revpimodio2.device
+
+Modul fuer die Verwaltung der Devices.
+
+
+Global Attributes
+
+
+Classes
+
+
+| Core |
+Klasse fuer den RevPi Core. |
+
+| Device |
+Basisklasse fuer alle Device-Objekte der RevPiDevicelist()-Klasse. |
+
+| DeviceList |
+Basisklasse fuer direkten Zugriff auf Device Objekte. |
+
+| Gateway |
+Klasse fuer die RevPi Gateway-Devices. |
+
+| Virtual |
+Klasse fuer die RevPi Virtual-Devices. |
+
+
+
+Functions
+
+
+
+Core
+
+Klasse fuer den RevPi Core.
+
+ Stellt Funktionen fuer die LEDs und den Status zur Verfuegung.
+
+
+
+
+Derived from
+Device
+
+Class Attributes
+
+
+Class Methods
+
+
+Methods
+
+
+| _devconfigure |
+Core-Klasse vorbereiten. |
+
+| _errorlimit |
+Verwaltet das Lesen und Schreiben der ErrorLimits. |
+
+| errorlimit1 |
+Setzt RS485 ErrorLimit1 auf neuen Wert. |
+
+| errorlimit2 |
+Setzt RS485 ErrorLimit2 auf neuen Wert. |
+
+| frequency |
+Gibt CPU Taktfrequenz zurueck. |
+
+| get_leda1 |
+Gibt den Zustand der LED A1 vom core zurueck. |
+
+| get_leda2 |
+Gibt den Zustand der LED A2 vom core zurueck. |
+
+| get_status |
+Gibt den RevPi Core Status zurueck. |
+
+| iocycle |
+Gibt Zykluszeit der Prozessabbildsynchronisierung zurueck. |
+
+| ioerrorcount |
+Gibt Fehleranzahl auf RS485 piBridge Bus zurueck. |
+
+| leftgate |
+Statusbit links vom RevPi ist ein piGate Modul angeschlossen. |
+
+| missingdeviceorgate |
+Statusbit fuer ein IO-Modul fehlt oder piGate konfiguriert. |
+
+| overunderflow |
+Statusbit Modul belegt mehr oder weniger Speicher als konfiguriert. |
+
+| picontrolrunning |
+Statusbit fuer piControl-Treiber laeuft. |
+
+| rightgate |
+Statusbit rechts vom RevPi ist ein piGate Modul angeschlossen. |
+
+| set_leda1 |
+Setzt den Zustand der LED A1 vom core. |
+
+| set_leda2 |
+Setzt den Zustand der LED A2 vom core. |
+
+| temperatur |
+Gibt CPU-Temperatur zurueck. |
+
+| unconfdevice |
+Statusbit fuer ein IO-Modul nicht mit PiCtory konfiguriert. |
+
+
+
+Static Methods
+
+
+
+Core._devconfigure
+_devconfigure()
+
+Core-Klasse vorbereiten.
+
+
+Core._errorlimit
+_errorlimit(io_id, errorlimit)
+
+Verwaltet das Lesen und Schreiben der ErrorLimits.
+
+- io_id
+-
+Index des IOs fuer ErrorLimit
+
+
+- Returns:
+-
+Aktuellen ErrorLimit oder None wenn nicht verfuegbar
+
+
+
+Core.errorlimit1
+errorlimit1(value)
+
+Setzt RS485 ErrorLimit1 auf neuen Wert.
+
+- value
+-
+Neuer ErrorLimit1 Wert
+
+
+
+Core.errorlimit2
+errorlimit2(value)
+
+Setzt RS485 ErrorLimit2 auf neuen Wert.
+
+- value
+-
+Neuer ErrorLimit2 Wert
+
+
+
+Core.frequency
+frequency()
+
+Gibt CPU Taktfrequenz zurueck.
+
+- Returns:
+-
+CPU Taktfrequenz in MHz
+
+
+
+Core.get_leda1
+get_leda1()
+
+Gibt den Zustand der LED A1 vom core zurueck.
+
+- Returns:
+-
+0=aus, 1=gruen, 2=rot
+
+
+
+Core.get_leda2
+get_leda2()
+
+Gibt den Zustand der LED A2 vom core zurueck.
+
+- Returns:
+-
+0=aus, 1=gruen, 2=rot
+
+
+
+Core.get_status
+get_status()
+
+Gibt den RevPi Core Status zurueck.
+
+- Returns:
+-
+Status als int()
+
+
+
+Core.iocycle
+iocycle()
+
+Gibt Zykluszeit der Prozessabbildsynchronisierung zurueck.
+
+- Returns:
+-
+Zykluszeit in ms
+
+
+
+Core.ioerrorcount
+ioerrorcount()
+
+Gibt Fehleranzahl auf RS485 piBridge Bus zurueck.
+
+- Returns:
+-
+Fehleranzahl der piBridge
+
+
+
+Core.leftgate
+leftgate()
+
+Statusbit links vom RevPi ist ein piGate Modul angeschlossen.
+
+- Returns:
+-
+True, wenn piGate links existiert
+
+
+
+Core.missingdeviceorgate
+missingdeviceorgate()
+
+Statusbit fuer ein IO-Modul fehlt oder piGate konfiguriert.
+
+- Returns:
+-
+True, wenn IO-Modul fehlt oder piGate konfiguriert
+
+
+
+Core.overunderflow
+overunderflow()
+
+Statusbit Modul belegt mehr oder weniger Speicher als konfiguriert.
+
+- Returns:
+-
+True, wenn falscher Speicher belegt ist
+
+
+
+Core.picontrolrunning
+picontrolrunning()
+
+Statusbit fuer piControl-Treiber laeuft.
+
+- Returns:
+-
+True, wenn Treiber laeuft
+
+
+
+Core.rightgate
+rightgate()
+
+Statusbit rechts vom RevPi ist ein piGate Modul angeschlossen.
+
+- Returns:
+-
+True, wenn piGate rechts existiert
+
+
+
+Core.set_leda1
+set_leda1(value)
+
+Setzt den Zustand der LED A1 vom core.
+
+- value
+-
+0=aus, 1=gruen, 2=rot
+
+
+
+Core.set_leda2
+set_leda2(value)
+
+Setzt den Zustand der LED A2 vom core.
+
+- value
+-
+0=aus, 1=gruen, 2=rot
+
+
+
+Core.temperatur
+temperatur()
+
+Gibt CPU-Temperatur zurueck.
+
+- Returns:
+-
+CPU-Temperatur in Celsius
+
+
+
+Core.unconfdevice
+unconfdevice()
+
+Statusbit fuer ein IO-Modul nicht mit PiCtory konfiguriert.
+
+- Returns:
+-
+True, wenn IO Modul nicht konfiguriert
+
+
+
+
+
+Device
+
+Basisklasse fuer alle Device-Objekte der RevPiDevicelist()-Klasse.
+
+ Die Basisfunktionalitaet generiert bei Instantiierung alle IOs und
+ erweitert den Prozessabbildpuffer um die benoetigten Bytes. Ueber diese
+ Klasse oder von dieser abgeleiteten Klassen, werden alle IOs angesprochen.
+ Sie verwaltet ihren Prozessabbildpuffer und sorgt fuer die Aktualisierung
+ der IO-Werte.
+
+
+
+
+Derived from
+object
+
+Class Attributes
+
+
+Class Methods
+
+
+Methods
+
+
+| Device |
+Instantiierung der Device()-Klasse. |
+
+| __bytes__ |
+Gibt alle Daten des Devices als bytes() zurueck. |
+
+| __contains__ |
+Prueft ob IO auf diesem Device liegt. |
+
+| __int__ |
+Gibt die Positon im RevPi Bus zurueck. |
+
+| __iter__ |
+Gibt Iterator aller IOs zurueck. |
+
+| __len__ |
+Gibt Anzahl der Bytes zurueck, die dieses Device belegt. |
+
+| __str__ |
+Gibt den Namen des Devices zurueck. |
+
+| _buildio |
+Erstellt aus der piCtory-Liste die IOs fuer dieses Device. |
+
+| _devconfigure |
+Funktion zum ueberschreiben von abgeleiteten Klassen. |
+
+| auto_refresh |
+Registriert ein Device fuer die automatische Synchronisierung. |
+
+| get_allios |
+Gibt eine Liste aller Inputs und Outputs zurueck. |
+
+| get_inps |
+Gibt eine Liste aller Inputs zurueck. |
+
+| get_mems |
+Gibt eine Liste aller mems zurueck. |
+
+| get_outs |
+Gibt eine Liste aller Outputs zurueck. |
+
+
+
+Static Methods
+
+
+
+Device (Constructor)
+Device(parentmodio, dict_device, **kwargs)
+
+Instantiierung der Device()-Klasse.
+
+- parent
+-
+RevpiModIO parent object
+
- dict_device
+-
+dict() fuer dieses Device aus piCotry Konfiguration
+
- kwargs
+-
+Weitere Parameter:
+ - autoupdate: Wenn True fuehrt dieses Device Arbeiten am
+ Prozessabbild bei Aufruf der RevPiDevicelist-Funktionen aus
+ - simulator: Laed das Modul als Simulator und vertauscht IOs
+
+
+
+Device.__bytes__
+__bytes__()
+
+Gibt alle Daten des Devices als bytes() zurueck.
+
+- Returns:
+-
+Devicedaten als bytes()
+
+
+
+Device.__contains__
+__contains__(key)
+
+Prueft ob IO auf diesem Device liegt.
+
+- key
+-
+IO-Name str() / IO-Bytenummer int()
+
+
+- Returns:
+-
+True, wenn device vorhanden
+
+
+
+Device.__int__
+__int__()
+
+Gibt die Positon im RevPi Bus zurueck.
+
+- Returns:
+-
+Positionsnummer
+
+
+
+Device.__iter__
+__iter__()
+
+Gibt Iterator aller IOs zurueck.
+
+- Returns:
+-
+iter() aller IOs
+
+
+
+Device.__len__
+__len__()
+
+Gibt Anzahl der Bytes zurueck, die dieses Device belegt.
+
+- Returns:
+-
+int()
+
+
+
+Device.__str__
+__str__()
+
+Gibt den Namen des Devices zurueck.
+
+- Returns:
+-
+Devicename
+
+
+
+Device._buildio
+_buildio(dict_io, iotype)
+
+Erstellt aus der piCtory-Liste die IOs fuer dieses Device.
+
+- dict_io
+-
+dict()-Objekt aus piCtory Konfiguration
+
- iotype
+-
+IOType() Wert
+
+
+- Returns:
+-
+slice()-Objekt mit Start und Stop Position dieser IOs
+
+
+
+Device._devconfigure
+_devconfigure()
+
+Funktion zum ueberschreiben von abgeleiteten Klassen.
+
+
+Device.auto_refresh
+auto_refresh(remove=False)
+
+Registriert ein Device fuer die automatische Synchronisierung.
+
+- remove
+-
+bool() True entfernt Device aus Synchronisierung
+
+
+
+Device.get_allios
+get_allios()
+
+Gibt eine Liste aller Inputs und Outputs zurueck.
+
+- Returns:
+-
+list() Input und Output, keine MEMs
+
+
+
+Device.get_inps
+get_inps()
+
+Gibt eine Liste aller Inputs zurueck.
+
+- Returns:
+-
+list() Inputs
+
+
+
+Device.get_mems
+get_mems()
+
+Gibt eine Liste aller mems zurueck.
+
+- Returns:
+-
+list() Mems
+
+
+
+Device.get_outs
+get_outs()
+
+Gibt eine Liste aller Outputs zurueck.
+
+- Returns:
+-
+list() Outputs
+
+
+
+
+
+DeviceList
+
+Basisklasse fuer direkten Zugriff auf Device Objekte.
+
+
+Derived from
+object
+
+Class Attributes
+
+
+Class Methods
+
+
+Methods
+
+
+Static Methods
+
+
+
+DeviceList (Constructor)
+DeviceList()
+
+Init DeviceList class.
+
+
+DeviceList.__contains__
+__contains__(key)
+
+Prueft ob Device existiert.
+
+- key
+-
+DeviceName str() / Positionsnummer int()
+
+
+- Returns:
+-
+True, wenn Device vorhanden
+
+
+
+DeviceList.__getitem__
+__getitem__(key)
+
+Gibt angegebenes Device zurueck.
+
+- key
+-
+DeviceName str() / Positionsnummer int()
+
+
+- Returns:
+-
+Gefundenes Device()-Objekt
+
+
+
+DeviceList.__iter__
+__iter__()
+
+Gibt Iterator aller Devices zurueck.
+
+- Returns:
+-
+iter() aller Devices
+
+
+
+DeviceList.__len__
+__len__()
+
+Gibt Anzahl der Devices zurueck.
+ return Anzahl der Devices
+
+
+DeviceList.__setattr__
+__setattr__(key, value)
+
+Setzt Attribute nur wenn Device.
+
+- key
+-
+Attributname
+
- value
+-
+Attributobjekt
+
+
+
+
+
+Gateway
+
+Klasse fuer die RevPi Gateway-Devices.
+
+ Stellt neben den Funktionen von RevPiDevice weitere Funktionen fuer die
+ Gateways bereit. Es koennen ueber die reg_*-Funktionen eigene IOs definiert
+ werden, die ein RevPiStructIO-Objekt abbilden.
+ Dieser IO-Typ kann Werte ueber mehrere Bytes verarbeiten und zurueckgeben.
+
+
+
+
+Derived from
+Device
+
+Class Attributes
+
+
+Class Methods
+
+
+Methods
+
+
+| Gateway |
+Erweitert RevPiDevice um reg_*-Funktionen. |
+
+| get_rawbytes |
+Gibt die Bytes aus, die dieses Device verwendet. |
+
+
+
+Static Methods
+
+
+
+Gateway (Constructor)
+Gateway(parent, dict_device, **kwargs)
+
+Erweitert RevPiDevice um reg_*-Funktionen.
+
+- See Also:
+-
+RevPiDevice.__init__(...)
+
+
+
+Gateway.get_rawbytes
+get_rawbytes()
+
+Gibt die Bytes aus, die dieses Device verwendet.
+
+- Returns:
+-
+bytes() des Devices
+
+
+
+
+
+Virtual
+
+Klasse fuer die RevPi Virtual-Devices.
+
+ Stellt die selben Funktionen wie RevPiGateway zur Verfuegung. Es koennen
+ ueber die reg_*-Funktionen eigene IOs definiert werden, die ein
+ RevPiStructIO-Objekt abbilden.
+ Dieser IO-Typ kann Werte ueber mehrere Bytes verarbeiten und zurueckgeben.
+
+- See Also:
+-
+RevPiGateway
+
+
+
+Derived from
+Gateway
+
+Class Attributes
+
+
+Class Methods
+
+
+Methods
+
+
+Static Methods
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/revpimodio2.helper.html b/doc/revpimodio2.helper.html
new file mode 100644
index 0000000..c74c985
--- /dev/null
+++ b/doc/revpimodio2.helper.html
@@ -0,0 +1,410 @@
+
+
+revpimodio2.helper
+
+
+
+
+revpimodio2.helper
+
+RevPiModIO Helperklassen und Tools.
+
+
+Global Attributes
+
+
+Classes
+
+
+| Cycletools |
+Werkzeugkasten fuer Cycleloop-Funktion. |
+
+| EventCallback |
+Thread fuer das interne Aufrufen von Event-Funktionen. |
+
+| ProcimgWriter |
+Klasse fuer Synchroniseriungs-Thread. |
+
+
+
+Functions
+
+
+
+Cycletools
+
+Werkzeugkasten fuer Cycleloop-Funktion.
+
+ Diese Klasse enthaelt Werkzeuge fuer Zyklusfunktionen, wie Taktmerker
+ und Flankenmerker.
+ Zu beachten ist, dass die Flankenmerker beim ersten Zyklus alle den Wert
+ True haben! Ueber den Merker Cycletools.first kann ermittelt werden,
+ ob es sich um den ersten Zyklus handelt.
+
+ Taktmerker flag1c, flag5c, flag10c, usw. haben den als Zahl angegebenen
+ Wert an Zyklen jeweils False und True.
+ Beispiel: flag5c hat 5 Zyklen den Wert False und in den naechsten 5 Zyklen
+ den Wert True.
+
+ Flankenmerker flank5c, flank10c, usw. haben immer im, als Zahl angebenen
+ Zyklus fuer einen Zyklusdurchlauf den Wert True, sonst False.
+ Beispiel: flank5c hat immer alle 5 Zyklen den Wert True.
+
+ Diese Merker koennen z.B. verwendet werden um, an Outputs angeschlossene,
+ Lampen synchron blinken zu lassen.
+
+
+
+
+Derived from
+None
+
+Class Attributes
+
+
+Class Methods
+
+
+Methods
+
+
+| Cycletools |
+Init Cycletools class. |
+
+| _docycle |
+Zyklusarbeiten. |
+
+| get_tofc |
+Wert der Ausschaltverzoegerung. |
+
+| get_tonc |
+Einschaltverzoegerung. |
+
+| get_tpc |
+Impulstimer. |
+
+| set_tofc |
+Startet bei Aufruf einen ausschaltverzoegerten Timer. |
+
+| set_tonc |
+Startet einen einschaltverzoegerten Timer. |
+
+| set_tpc |
+Startet einen Impuls Timer. |
+
+
+
+Static Methods
+
+
+
+Cycletools (Constructor)
+Cycletools()
+
+Init Cycletools class.
+
+
+Cycletools._docycle
+_docycle()
+
+Zyklusarbeiten.
+
+
+Cycletools.get_tofc
+get_tofc(name)
+
+Wert der Ausschaltverzoegerung.
+
+- name
+-
+Eindeutiger Name des Timers
+
+
+- Returns:
+-
+Wert der Ausschaltverzoegerung
+
+
+
+Cycletools.get_tonc
+get_tonc(name)
+
+Einschaltverzoegerung.
+
+- name
+-
+Eindeutiger Name des Timers
+
+
+- Returns:
+-
+Wert der Einschaltverzoegerung
+
+
+
+Cycletools.get_tpc
+get_tpc(name)
+
+Impulstimer.
+
+- name
+-
+Eindeutiger Name des Timers
+
+
+- Returns:
+-
+Wert der des Impulses
+
+
+
+Cycletools.set_tofc
+set_tofc(name, cycles)
+
+Startet bei Aufruf einen ausschaltverzoegerten Timer.
+
+- name
+-
+Eindeutiger Name fuer Zugriff auf Timer
+
- cycles
+-
+Zyklusanzahl, der Verzoegerung wenn nicht neu gestartet
+
+
+
+Cycletools.set_tonc
+set_tonc(name, cycles)
+
+Startet einen einschaltverzoegerten Timer.
+
+- name
+-
+Eindeutiger Name fuer Zugriff auf Timer
+
- cycles
+-
+Zyklusanzahl, der Verzoegerung wenn neu gestartet
+
+
+
+Cycletools.set_tpc
+set_tpc(name, cycles)
+
+Startet einen Impuls Timer.
+
+- name
+-
+Eindeutiger Name fuer Zugriff auf Timer
+
- cycles
+-
+Zyklusanzahl, die der Impuls anstehen soll
+
+
+
+
+
+EventCallback
+
+Thread fuer das interne Aufrufen von Event-Funktionen.
+
+ Der Eventfunktion, welche dieser Thread aufruft, wird der Thread selber
+ als Parameter uebergeben. Darauf muss bei der definition der Funktion
+ geachtet werden z.B. "def event(th):". Bei umfangreichen Funktionen kann
+ dieser ausgewertet werden um z.B. doppeltes Starten zu verhindern.
+ Ueber EventCallback.ioname kann der Name des IO-Objekts abgerufen werden,
+ welches das Event ausgeloest hast. EventCallback.iovalue gibt den Wert des
+ IO-Objekts zum Ausloesezeitpunkt zurueck.
+ Der Thread stellt das EventCallback.exit Event als Abbruchbedingung fuer
+ die aufgerufene Funktion zur Verfuegung.
+ Durch Aufruf der Funktion EventCallback.stop() wird das exit-Event gesetzt
+ und kann bei Schleifen zum Abbrechen verwendet werden.
+ Mit dem .exit() Event auch eine Wartefunktion realisiert
+ werden: "th.exit.wait(0.5)" - Wartet 500ms oder bricht sofort ab, wenn
+ fuer den Thread .stop() aufgerufen wird.
+
+ while not th.exit.is_set():
+ # IO-Arbeiten
+ th.exit.wait(0.5)
+
+
+
+
+Derived from
+Thread
+
+Class Attributes
+
+
+Class Methods
+
+
+Methods
+
+
+| EventCallback |
+Init EventCallback class. |
+
+| run |
+Ruft die registrierte Funktion auf. |
+
+| stop |
+Setzt das exit-Event mit dem die Funktion beendet werden kann. |
+
+
+
+Static Methods
+
+
+
+EventCallback (Constructor)
+EventCallback(func, name, value)
+
+Init EventCallback class.
+
+- func
+-
+Funktion die beim Start aufgerufen werden soll
+
- name
+-
+IO-Name
+
- value
+-
+IO-Value zum Zeitpunkt des Events
+
+
+
+EventCallback.run
+run()
+
+Ruft die registrierte Funktion auf.
+
+
+EventCallback.stop
+stop()
+
+Setzt das exit-Event mit dem die Funktion beendet werden kann.
+
+
+
+
+ProcimgWriter
+
+Klasse fuer Synchroniseriungs-Thread.
+
+ Diese Klasse wird als Thread gestartet, wenn das Prozessabbild zyklisch
+ synchronisiert werden soll. Diese Funktion wird hauptsaechlich fuer das
+ Event-Handling verwendet.
+
+
+
+
+Derived from
+Thread
+
+Class Attributes
+
+
+Class Methods
+
+
+Methods
+
+
+| ProcimgWriter |
+Init ProcimgWriter class. |
+
+| _gotioerror |
+IOError Verwaltung fuer auto_refresh. |
+
+| get_refresh |
+Gibt Zykluszeit zurueck. |
+
+| run |
+Startet die automatische Prozessabbildsynchronisierung. |
+
+| set_refresh |
+Setzt die Zykluszeit in Millisekunden. |
+
+| stop |
+Beendet die automatische Prozessabbildsynchronisierung. |
+
+
+
+Static Methods
+
+
+
+ProcimgWriter (Constructor)
+ProcimgWriter(parentmodio)
+
+Init ProcimgWriter class.
+
+- parentmodio
+-
+Parent Object
+
+
+
+ProcimgWriter._gotioerror
+_gotioerror()
+
+IOError Verwaltung fuer auto_refresh.
+
+
+ProcimgWriter.get_refresh
+get_refresh()
+
+Gibt Zykluszeit zurueck.
+
+- Returns:
+-
+int() Zykluszeit in Millisekunden
+
+
+
+ProcimgWriter.run
+run()
+
+Startet die automatische Prozessabbildsynchronisierung.
+
+
+ProcimgWriter.set_refresh
+set_refresh(value)
+
+Setzt die Zykluszeit in Millisekunden.
+
+- value
+-
+int() Millisekunden
+
+
+
+ProcimgWriter.stop
+stop()
+
+Beendet die automatische Prozessabbildsynchronisierung.
+
+
+
+
\ No newline at end of file
diff --git a/doc/revpimodio2.io.html b/doc/revpimodio2.io.html
new file mode 100644
index 0000000..dd1dad9
--- /dev/null
+++ b/doc/revpimodio2.io.html
@@ -0,0 +1,777 @@
+
+
+revpimodio2.io
+
+
+
+
+revpimodio2.io
+
+RevPiModIO Modul fuer die Verwaltung der IOs.
+
+
+Global Attributes
+
+
+Classes
+
+
+| IOBase |
+Basisklasse fuer alle IO-Objekte. |
+
+| IOList |
+Basisklasse fuer direkten Zugriff auf IO Objekte. |
+
+| IntIO |
+Klasse fuer den Zugriff auf die Daten mit Konvertierung in int(). |
+
+| StructIO |
+Klasse fuer den Zugriff auf Daten ueber ein definierten struct(). |
+
+
+
+Functions
+
+
+
+IOBase
+
+Basisklasse fuer alle IO-Objekte.
+
+ Die Basisfunktionalitaet ermoeglicht das Lesen und Schreiben der Werte
+ als bytes() oder bool(). Dies entscheidet sich bei der Instantiierung.
+ Wenn eine Bittadresse angegeben wird, werden bool()-Werte erwartet
+ und zurueckgegeben, ansonsten bytes().
+
+ Diese Klasse dient als Basis fuer andere IO-Klassen mit denen die Werte
+ auch als int() verwendet werden koennen.
+
+
+
+
+Derived from
+object
+
+Class Attributes
+
+| address |
| length |
| name |
| value |
+
+
+Class Methods
+
+
+Methods
+
+
+| IOBase |
+Instantiierung der IOBase()-Klasse. |
+
+| __bool__ |
+bool()-wert der Klasse. |
+
+| __bytes__ |
+bytes()-wert der Klasse. |
+
+| __str__ |
+str()-wert der Klasse. |
+
+| _get_byteorder |
+Gibt konfigurierte Byteorder zurueck. |
+
+| get_address |
+Gibt die absolute Byteadresse im Prozessabbild zurueck. |
+
+| get_length |
+Gibt die Bytelaenge des IO zurueck. |
+
+| get_name |
+Gibt den Namen des IOs zurueck. |
+
+| get_value |
+Gibt den Wert des IOs als bytes() oder bool() zurueck. |
+
+| reg_event |
+Registriert ein Event bei der Eventueberwachung. |
+
+| replace_io |
+Ersetzt bestehenden IO mit Neuem. |
+
+| set_value |
+Setzt den Wert des IOs mit bytes() oder bool(). |
+
+| unreg_event |
+Entfernt ein Event aus der Eventueberwachung. |
+
+| wait |
+Wartet auf Wertaenderung eines IOs. |
+
+
+
+Static Methods
+
+
+
+IOBase (Constructor)
+IOBase(parentdevice, valuelist, iotype, byteorder)
+
+Instantiierung der IOBase()-Klasse.
+
+- parentdevice
+-
+Parentdevice auf dem der IO liegt
+
- valuelist
+-
+Datenliste fuer Instantiierung
+
- iotype
+-
+IOType() Wert
+
- byteorder
+-
+Byteorder 'little' / 'big' fuer int() Berechnung
+
+
+
+IOBase.__bool__
+__bool__()
+
+bool()-wert der Klasse.
+
+- Returns:
+-
+IO-Wert als bool(). Nur False wenn False oder 0 sonst True
+
+
+
+IOBase.__bytes__
+__bytes__()
+
+bytes()-wert der Klasse.
+
+- Returns:
+-
+IO-Wert als bytes()
+
+
+
+IOBase.__str__
+__str__()
+
+str()-wert der Klasse.
+
+- Returns:
+-
+Namen des IOs
+
+
+
+IOBase._get_byteorder
+_get_byteorder()
+
+Gibt konfigurierte Byteorder zurueck.
+
+- Returns:
+-
+str() Byteorder
+
+
+
+IOBase.get_address
+get_address()
+
+Gibt die absolute Byteadresse im Prozessabbild zurueck.
+
+- Returns:
+-
+Absolute Byteadresse
+
+
+
+IOBase.get_length
+get_length()
+
+Gibt die Bytelaenge des IO zurueck.
+
+- Returns:
+-
+Bytelaenge des IO
+
+
+
+IOBase.get_name
+get_name()
+
+Gibt den Namen des IOs zurueck.
+
+- Returns:
+-
+IO Name
+
+
+
+IOBase.get_value
+get_value()
+
+Gibt den Wert des IOs als bytes() oder bool() zurueck.
+
+- Returns:
+-
+IO-Wert
+
+
+
+IOBase.reg_event
+reg_event(func, edge=BOTH, as_thread=False)
+
+Registriert ein Event bei der Eventueberwachung.
+
+- func
+-
+Funktion die bei Aenderung aufgerufen werden soll
+
- edge
+-
+Ausfuehren bei RISING, FALLING or BOTH Wertaenderung
+
- as_thread
+-
+Bei True, Funktion als EventCallback-Thread ausfuehren
+
+
+
+IOBase.replace_io
+replace_io(name, frm, **kwargs)
+
+Ersetzt bestehenden IO mit Neuem.
+
+- name
+-
+Name des neuen Inputs
+
- frm
+-
+struct() formatierung (1 Zeichen)
+
- kwargs
+-
+Weitere Parameter:
+ - bmk: Bezeichnung fuer Input
+ - bit: Registriert Input als bool() am angegebenen Bit im Byte
+ - byteorder: Byteorder fuer den Input, Standardwert=little
+ - defaultvalue: Standardwert fuer Input, Standard ist 0
+ - event: Funktion fuer Eventhandling registrieren
+ - as_thread: Fuehrt die event-Funktion als RevPiCallback-Thread aus
+ - edge: event-Ausfuehren bei RISING, FALLING or BOTH Wertaenderung
+
+
+- See Also:
+-
+Python3 struct()
+
+
+
+IOBase.set_value
+set_value(value)
+
+Setzt den Wert des IOs mit bytes() oder bool().
+
+- value
+-
+IO-Wert als bytes() oder bool()
+
+
+
+IOBase.unreg_event
+unreg_event(func=None, edge=None)
+
+Entfernt ein Event aus der Eventueberwachung.
+
+- func
+-
+Nur Events mit angegebener Funktion
+
- edge
+-
+Nur Events mit angegebener Funktion und angegebener Edge
+
+
+
+IOBase.wait
+wait(edge=BOTH, exitevent=None, okvalue=None, timeout=0)
+
+Wartet auf Wertaenderung eines IOs.
+
+ Die Wertaenderung wird immer uerberprueft, wenn fuer Devices
+ in Devicelist.auto_refresh() neue Daten gelesen wurden.
+
+ Bei Wertaenderung, wird das Warten mit 0 als Rueckgabewert beendet.
+
+ HINWEIS: Wenn ProcimgWriter() keine neuen Daten liefert, wird
+ bis in die Ewigkeit gewartet (nicht bei Angabe von "timeout").
+
+ Wenn edge mit RISING oder FALLING angegeben wird muss diese Flanke
+ ausgeloest werden. Sollte der Wert 1 sein beim Eintritt mit Flanke
+ RISING, wird das Warten erst bei Aenderung von 0 auf 1 beendet.
+
+ Als exitevent kann ein threading.Event()-Objekt uebergeben werden,
+ welches das Warten bei is_set() sofort mit 1 als Rueckgabewert
+ beendet.
+
+ Wenn der Wert okvalue an dem IO fuer das Warten anliegt, wird
+ das Warten sofort mit -1 als Rueckgabewert beendet.
+
+ Der Timeoutwert bricht beim Erreichen das Warten sofort mit
+ Wert 2 Rueckgabewert ab. (Das Timeout wird ueber die Zykluszeit
+ der auto_refresh Funktion berechnet, entspricht also nicht exact den
+ angegeben Millisekunden! Es wird immer nach oben gerundet!)
+
+- edge
+-
+Flanke RISING, FALLING, BOTH bei der mit True beendet wird
+
- exitevent
+-
+thrading.Event() fuer vorzeitiges Beenden mit False
+
- okvalue
+-
+IO-Wert, bei dem das Warten sofort mit True beendet wird
+
- timeout
+-
+Zeit in ms nach der mit False abgebrochen wird
+
+
+- Returns:
+-
+int() erfolgreich Werte <= 0
+ - Erfolgreich gewartet
+ Wert 0: IO hat den Wert gewechselt
+ Wert -1: okvalue stimmte mit IO ueberein
+ - Fehlerhaft gewartet
+ Wert 1: exitevent wurde gesetzt
+ Wert 2: timeout abgelaufen
+ Wert 100: Devicelist.exit() wurde aufgerufen
+
+
+
+
+
+IOList
+
+Basisklasse fuer direkten Zugriff auf IO Objekte.
+
+
+Derived from
+object
+
+Class Attributes
+
+
+Class Methods
+
+
+Methods
+
+
+Static Methods
+
+
+
+IOList (Constructor)
+IOList()
+
+Init IOList class.
+
+
+IOList.__contains__
+__contains__(key)
+
+Prueft ob IO existiert.
+
+- key
+-
+IO-Name str() oder Byte int()
+
+
+- Returns:
+-
+True, wenn IO vorhanden / Byte belegt
+
+
+
+IOList.__delattr__
+__delattr__(key)
+
+Entfernt angegebenen IO.
+
+- key
+-
+IO zum entfernen
+
+
+
+IOList.__getattr__
+__getattr__(key)
+
+Verwaltet geloeschte IOs.
+
+- key
+-
+Wert eines alten IOs
+
+
+- Returns:
+-
+Alten IO, wenn in Ref-Listen
+
+
+
+IOList.__getitem__
+__getitem__(key)
+
+Ruft angegebenen IO ab.
+
+- key
+-
+IO Name oder Byte
+
+
+- Returns:
+-
+IO Object
+
+
+
+IOList.__iter__
+__iter__()
+
+Gibt Iterator aller IOs zurueck.
+
+- Returns:
+-
+Iterator aller IOs
+
+
+
+IOList.__replace_oldio_with_newio
+__replace_oldio_with_newio(io)
+
+Ersetzt bestehende IOs durch den neu Registrierten.
+
+- io
+-
+Neuer IO der eingefuegt werden soll
+
+
+
+IOList.__setattr__
+__setattr__(key, value)
+
+Setzt IO Wert.
+
+- key
+-
+IO Name oder Byte
+
- value
+-
+Wert, auf den der IO gesetzt wird
+
+
+
+IOList.__setitem__
+__setitem__(key, value)
+
+Setzt IO Wert.
+
+- key
+-
+IO Name oder Byte
+
- value
+-
+Wert, auf den der IO gesetzt wird
+
+
+
+IOList._register_new_io_object
+_register_new_io_object(new_io)
+
+Registriert neues IO Objekt unabhaenging von __setattr__.
+
+- new_io
+-
+Neues IO Objekt
+
+
+
+IOList._testme
+_testme()
+
+
+
+
+IntIO
+
+Klasse fuer den Zugriff auf die Daten mit Konvertierung in int().
+
+ Diese Klasse erweitert die Funktion von IOBase() um Funktionen,
+ ueber die mit int() Werten gearbeitet werden kann. Fuer die Umwandlung
+ koennen 'Byteorder' (Default 'little') und 'signed' (Default False) als
+ Parameter gesetzt werden.
+
+- See Also:
+-
+IOBase
+
+
+
+Derived from
+IOBase
+
+Class Attributes
+
+
+Class Methods
+
+
+Methods
+
+
+| __int__ |
+Gibt IO als int() Wert zurueck mit Beachtung byteorder/signed. |
+
+| _get_signed |
+Ruft ab, ob der Wert Vorzeichenbehaftet behandelt werden soll. |
+
+| _set_byteorder |
+Setzt Byteorder fuer int() Umwandlung. |
+
+| _set_signed |
+Left fest, ob der Wert Vorzeichenbehaftet behandelt werden soll. |
+
+| get_int |
+Gibt IO als int() Wert zurueck mit Beachtung byteorder/signed. |
+
+| set_int |
+Setzt IO mit Beachtung byteorder/signed. |
+
+
+
+Static Methods
+
+
+
+IntIO.__int__
+__int__()
+
+Gibt IO als int() Wert zurueck mit Beachtung byteorder/signed.
+
+- Returns:
+-
+int() ohne Vorzeichen
+
+
+
+IntIO._get_signed
+_get_signed()
+
+Ruft ab, ob der Wert Vorzeichenbehaftet behandelt werden soll.
+
+- Returns:
+-
+True, wenn Vorzeichenbehaftet
+
+
+
+IntIO._set_byteorder
+_set_byteorder(value)
+
+Setzt Byteorder fuer int() Umwandlung.
+
+- value
+-
+str() 'little' or 'big'
+
+
+
+IntIO._set_signed
+_set_signed(value)
+
+Left fest, ob der Wert Vorzeichenbehaftet behandelt werden soll.
+
+- value
+-
+True, wenn mit Vorzeichen behandel
+
+
+
+IntIO.get_int
+get_int()
+
+Gibt IO als int() Wert zurueck mit Beachtung byteorder/signed.
+
+- Returns:
+-
+int() Wert
+
+
+
+IntIO.set_int
+set_int(value)
+
+Setzt IO mit Beachtung byteorder/signed.
+
+- value
+-
+int()
+
+
+
+
+
+StructIO
+
+Klasse fuer den Zugriff auf Daten ueber ein definierten struct().
+
+ Diese Klasse ueberschreibt get_value() und set_value() der IOBase()
+ Klasse. Sie stellt ueber struct die Werte in der gewuenschten Formatierung
+ bereit. Der struct-Formatwert wird bei der Instantiierung festgelegt.
+
+- See Also:
+-
+IOBase
+
+
+
+Derived from
+IOBase
+
+Class Attributes
+
+
+Class Methods
+
+
+Methods
+
+
+Static Methods
+
+
+
+StructIO (Constructor)
+StructIO(parentio, name, iotype, byteorder, frm, **kwargs)
+
+Erstellt einen IO mit struct-Formatierung.
+
+- parentio
+-
+ParentIO Objekt, welches ersetzt wird
+
- name
+-
+Name des neuen IO
+
- iotype
+-
+IOType() Wert
+
- byteorder
+-
+Byteorder 'little' / 'big' fuer int() Berechnung
+
- frm
+-
+struct() formatierung (1 Zeichen)
+
- kwargs
+-
+Weitere Parameter:
+ - bmk: Bezeichnung fuer Output
+ - bit: Registriert Outputs als bool() am angegebenen Bit im Byte
+ - defaultvalue: Standardwert fuer Output, Standard ist 0
+
+
+
+StructIO.get_structvalue
+get_structvalue()
+
+Gibt den Wert mit struct Formatierung zurueck.
+
+- Returns:
+-
+Wert vom Typ der struct-Formatierung
+
+
+
+StructIO.set_structvalue
+set_structvalue(value)
+
+Setzt den Wert mit struct Formatierung.
+
+- value
+-
+Wert vom Typ der struct-Formatierung
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/revpimodio2.modio.html b/doc/revpimodio2.modio.html
new file mode 100644
index 0000000..3edb328
--- /dev/null
+++ b/doc/revpimodio2.modio.html
@@ -0,0 +1,656 @@
+
+
+revpimodio2.modio
+
+
+
+
+revpimodio2.modio
+
+RevPiModIO Hauptklasse.
+
+
+Global Attributes
+
+
+Classes
+
+
+| RevPiModIO |
+Klasse fuer die Verwaltung aller piCtory Informationen. |
+
+| RevPiModIODriver |
+Klasse um eigene Treiber fuer die virtuellen Devices zu erstellen. |
+
+| RevPiModIOSelected |
+Klasse fuer die Verwaltung einzelner Devices aus piCtory. |
+
+
+
+Functions
+
+
+
+RevPiModIO
+
+Klasse fuer die Verwaltung aller piCtory Informationen.
+
+ Diese Klasse uebernimmt die gesamte Konfiguration aus piCtory und bilded
+ die Devices und IOs ab. Sie uebernimmt die exklusive Verwaltung des
+ Prozessabbilds und stellt sicher, dass die Daten synchron sind.
+ Sollten nur einzelne Devices gesteuert werden, verwendet man
+ RevPiModIOSelected() und uebergibt bei Instantiierung eine Liste mit
+ Device Positionen oder Device Namen.
+
+
+
+
+Derived from
+object
+
+Class Attributes
+
+| configrsc |
| cycletime |
| length |
| monitoring |
| procimg |
| simulator |
+
+
+Class Methods
+
+
+Methods
+
+
+Static Methods
+
+
+
+RevPiModIO (Constructor)
+RevPiModIO(**kwargs)
+
+Instantiiert die Grundfunktionen.
+
+- kwargs
+-
+Weitere Parameter:
+ - auto_refresh: Wenn True, alle Devices zu auto_refresh hinzufuegen
+ - configrsc: Pfad zur piCtory Konfigurationsdatei
+ - procimg: Pfad zum Prozessabbild
+ - monitoring: In- und Outputs werden gelesen, niemals geschrieben
+ - simulator: Laed das Modul als Simulator und vertauscht IOs
+ - syncoutputs: Aktuell gesetzte Outputs vom Prozessabbild einlesen
+
+
+
+RevPiModIO.__del__
+__del__()
+
+Zerstoert alle Klassen um aufzuraeumen.
+
+
+RevPiModIO.__evt_exit
+__evt_exit(signum, sigframe)
+
+Eventhandler fuer Programmende.
+
+- signum
+-
+Signalnummer
+
- sigframe
+-
+Signalframe
+
+
+
+RevPiModIO._configure
+_configure()
+
+Verarbeitet die piCtory Konfigurationsdatei.
+
+
+RevPiModIO._create_myfh
+_create_myfh()
+
+Erstellt FileObject mit Pfad zum procimg.
+ return FileObject
+
+
+RevPiModIO._get_configrsc
+_get_configrsc()
+
+Getter function.
+
+- Returns:
+-
+Pfad der verwendeten piCtory Konfiguration
+
+
+
+RevPiModIO._get_cycletime
+_get_cycletime()
+
+Gibt Aktualisierungsrate in ms der Prozessabbildsynchronisierung aus.
+
+- Returns:
+-
+Millisekunden
+
+
+
+RevPiModIO._get_length
+_get_length()
+
+Getter function.
+
+- Returns:
+-
+Laenge in Bytes der Devices
+
+
+
+RevPiModIO._get_monitoring
+_get_monitoring()
+
+Getter function.
+
+- Returns:
+-
+True, wenn als Monitoring gestartet
+
+
+
+RevPiModIO._get_procimg
+_get_procimg()
+
+Getter function.
+
+- Returns:
+-
+Pfad des verwendeten Prozessabbilds
+
+
+
+RevPiModIO._get_simulator
+_get_simulator()
+
+Getter function.
+
+- Returns:
+-
+True, wenn als Simulator gestartet
+
+
+
+RevPiModIO._set_cycletime
+_set_cycletime(milliseconds)
+
+Setzt Aktualisierungsrate der Prozessabbild-Synchronisierung.
+
+- milliseconds
+-
+int() in Millisekunden
+
+
+
+RevPiModIO.auto_refresh_maxioerrors
+auto_refresh_maxioerrors(value=None)
+
+Maximale IO Fehler fuer auto_refresh.
+
+- value
+-
+Setzt maximale Anzahl bis exception ausgeloest wird
+
+
+- Returns:
+-
+Maximale Anzahl bis exception ausgeloest wird
+
+
+
+RevPiModIO.auto_refresh_resetioerrors
+auto_refresh_resetioerrors()
+
+Setzt aktuellen IOError-Zaehler auf 0 zurueck.
+
+
+RevPiModIO.cleanup
+cleanup()
+
+Beendet auto_refresh und alle Threads.
+
+
+RevPiModIO.cycleloop
+cycleloop(func, cycletime=50)
+
+Startet den Cycleloop.
+
+ Der aktuelle Programmthread wird hier bis Aufruf von
+ RevPiDevicelist.exit() "gefangen". Er fuehrt nach jeder Aktualisierung
+ des Prozessabbilds die uebergebene Funktion "func" aus und arbeitet sie
+ ab. Waehrend der Ausfuehrung der Funktion wird das Prozessabbild nicht
+ weiter aktualisiert. Die Inputs behalten bis zum Ende den aktuellen
+ Wert. Gesetzte Outputs werden nach Ende des Funktionsdurchlaufs in das
+ Prozessabbild geschrieben.
+
+ Verlassen wird der Cycleloop, wenn die aufgerufene Funktion einen
+ Rueckgabewert nicht gleich None liefert, oder durch Aufruf von
+ revpimodio.exit().
+
+ HINWEIS: Die Aktualisierungszeit und die Laufzeit der Funktion duerfen
+ die eingestellte auto_refresh Zeit, bzw. uebergebene cycletime nicht
+ ueberschreiten!
+
+ Ueber den Parameter cycletime kann die Aktualisierungsrate fuer das
+ Prozessabbild gesetzt werden (selbe Funktion wie
+ set_refreshtime(milliseconds)).
+
+- func
+-
+Funktion, die ausgefuehrt werden soll
+
- cycletime
+-
+auto_refresh Wert in Millisekunden
+
+
+- Returns:
+-
+None
+
+
+
+RevPiModIO.exit
+exit(full=True)
+
+Beendet mainloop() und optional auto_refresh.
+
+ Wenn sich das Programm im mainloop() befindet, wird durch Aufruf
+ von exit() die Kontrolle wieder an das Hauptprogramm zurueckgegeben.
+
+ Der Parameter full ist mit True vorbelegt und entfernt alle Devices aus
+ dem auto_refresh. Der Thread fuer die Prozessabbildsynchronisierung
+ wird dann gestoppt und das Programm kann sauber beendet werden.
+
+- full
+-
+Entfernt auch alle Devices aus auto_refresh
+
+
+
+RevPiModIO.get_jconfigrsc
+get_jconfigrsc()
+
+Laed die piCotry Konfiguration und erstellt ein dict().
+
+- Returns:
+-
+dict() der piCtory Konfiguration
+
+
+
+RevPiModIO.handlesignalend
+handlesignalend(cleanupfunc=None)
+
+Signalhandler fuer Programmende verwalten.
+
+ Wird diese Funktion aufgerufen, uebernimmt RevPiModIO die SignalHandler
+ fuer SIGINT und SIGTERM. Diese werden Empfangen, wenn das
+ Betriebssystem oder der Benutzer das Steuerungsprogramm sauber beenden
+ will.
+
+ Die optionale Funktion "cleanupfunc" wird als letztes nach dem letzten
+ Einlesen der Inputs ausgefuehrt. Dort gesetzte Outputs werden nach
+ Ablauf der Funktion ein letztes Mal geschrieben.
+ Gedacht ist dies fuer Aufraeumarbeiten, wie z.B. das abschalten der
+ LEDs am RevPi-Core.
+
+ Nach einmaligem Empfangen eines der Signale und dem Beenden der
+ RevPiModIO Thrads / Funktionen werden die SignalHandler wieder
+ freigegeben.
+
+- cleanupfunc
+-
+Funktion wird nach dem letzten Lesen der Inputs
+ ausgefuehrt, gefolgt vom letzten Schreiben der Outputs
+
+
+
+RevPiModIO.mainloop
+mainloop(freeze=False, blocking=True)
+
+Startet den Mainloop mit Eventueberwachung.
+
+ Der aktuelle Programmthread wird hier bis Aufruf von
+ RevPiDevicelist.exit() "gefangen" (es sei denn blocking=False). Er
+ durchlaeuft die Eventueberwachung und prueft Aenderungen der, mit
+ einem Event registrierten, IOs. Wird eine Veraenderung erkannt,
+ fuert das Programm die dazugehoerigen Funktionen der Reihe nach aus.
+
+ Wenn der Parameter "freeze" mit True angegeben ist, wird die
+ Prozessabbildsynchronisierung angehalten bis alle Eventfunktionen
+ ausgefuehrt wurden. Inputs behalten fuer die gesamte Dauer ihren
+ aktuellen Wert und Outputs werden erst nach Durchlauf aller Funktionen
+ in das Prozessabbild geschrieben.
+
+ Wenn der Parameter "blocking" mit False angegeben wird, aktiviert
+ dies die Eventueberwachung und blockiert das Programm NICHT an der
+ Stelle des Aufrufs. Eignet sich gut fuer die GUI Programmierung, wenn
+ Events vom RevPi benoetigt werden, aber das Programm weiter ausgefuehrt
+ werden soll.
+
+- freeze
+-
+Wenn True, Prozessabbildsynchronisierung anhalten
+
- blocking
+-
+Wenn False, blockiert das Programm NICHT
+
+
+- Returns:
+-
+None
+
+
+
+RevPiModIO.readprocimg
+readprocimg(force=False, device=None)
+
+Einlesen aller Inputs aller/eines Devices vom Prozessabbild.
+
+- force
+-
+auch Devices mit autoupdate=False
+
- device
+-
+nur auf einzelnes Device anwenden
+
+
+- Returns:
+-
+True, wenn Arbeiten an allen Devices erfolgreich waren
+
+
+
+RevPiModIO.setdefaultvalues
+setdefaultvalues(force=False, device=None)
+
+Alle Outputbuffer werden auf die piCtory default Werte gesetzt.
+
+- force
+-
+auch Devices mit autoupdate=False
+
- device
+-
+nur auf einzelnes Device anwenden
+
+
+
+RevPiModIO.syncoutputs
+syncoutputs(force=False, device=None)
+
+Lesen aller aktuell gesetzten Outputs im Prozessabbild.
+
+- force
+-
+auch Devices mit autoupdate=False
+
- device
+-
+nur auf einzelnes Device anwenden
+
+
+- Returns:
+-
+True, wenn Arbeiten an allen Devices erfolgreich waren
+
+
+
+RevPiModIO.writedefaultinputs
+writedefaultinputs(virtual_device)
+
+Schreibt fuer ein virtuelles Device piCtory Defaultinputwerte.
+
+ Sollten in piCtory Defaultwerte fuer Inputs eines virtuellen Devices
+ angegeben sein, werden diese nur beim Systemstart oder einem piControl
+ Reset gesetzt. Sollte danach das Prozessabbild mit NULL ueberschrieben,
+ gehen diese Werte verloren.
+ Diese Funktion kann nur auf virtuelle Devices angewendet werden!
+
+- virtual_device
+-
+Virtuelles Device fuer Wiederherstellung
+
+
+- Returns:
+-
+True, wenn Arbeiten am virtuellen Device erfolgreich waren
+
+
+
+RevPiModIO.writeprocimg
+writeprocimg(force=False, device=None)
+
+Schreiben aller Outputs aller Devices ins Prozessabbild.
+
+- force
+-
+auch Devices mit autoupdate=False
+
- device
+-
+nur auf einzelnes Device anwenden
+
+
+- Returns:
+-
+True, wenn Arbeiten an allen Devices erfolgreich waren
+
+
+
+
+
+RevPiModIODriver
+
+Klasse um eigene Treiber fuer die virtuellen Devices zu erstellen.
+
+ Mit dieser Klasse werden nur angegebene Virtuelle Devices mit RevPiModIO
+ verwaltet. Bei Instantiierung werden automatisch die Inputs und Outputs
+ verdreht, um das Schreiben der Inputs zu ermoeglichen. Die Daten koennen
+ dann ueber logiCAD an den Devices abgerufen werden.
+
+
+
+
+Derived from
+RevPiModIOSelected
+
+Class Attributes
+
+
+Class Methods
+
+
+Methods
+
+
+Static Methods
+
+
+
+RevPiModIODriver (Constructor)
+RevPiModIODriver(vdev, **kwargs)
+
+Instantiiert die Grundfunktionen.
+
+- vdev
+-
+Virtuelles Device fuer die Verwendung / oder list()
+
- kwargs
+-
+Weitere Parameter (nicht monitoring und simulator)
+
+
+- See Also:
+-
+RevPiModIO.__init__(...)
+
+
+
+
+
+RevPiModIOSelected
+
+Klasse fuer die Verwaltung einzelner Devices aus piCtory.
+
+ Diese Klasse uebernimmt nur angegebene Devices der piCtory Konfiguration
+ und bilded sie inkl. IOs ab. Sie uebernimmt die exklusive Verwaltung des
+ Adressbereichs im Prozessabbild an dem sich die angegebenen Devices
+ befinden und stellt sicher, dass die Daten synchron sind.
+
+
+
+
+Derived from
+RevPiModIO
+
+Class Attributes
+
+
+Class Methods
+
+
+Methods
+
+
+Static Methods
+
+
+
+RevPiModIOSelected (Constructor)
+RevPiModIOSelected(deviceselection, **kwargs)
+
+Instantiiert nur fuer angegebene Devices die Grundfunktionen.
+
+ Der Parameter deviceselection kann eine einzelne
+ Device Position / einzelner Device Name sein oder eine Liste mit
+ mehreren Positionen / Namen
+
+- deviceselection
+-
+Positionsnummer oder Devicename
+
- kwargs
+-
+Weitere Parameter
+
+
+- See Also:
+-
+RevPiModIO.__init__(...)
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/revpimodio2.summary.html b/doc/revpimodio2.summary.html
new file mode 100644
index 0000000..2741c25
--- /dev/null
+++ b/doc/revpimodio2.summary.html
@@ -0,0 +1,76 @@
+
+
+revpimodio2.summary
+
+
+
+
+revpimodio2.summary
+
+Bildet die Summary-Sektion von piCtory ab.
+
+
+Global Attributes
+
+
+Classes
+
+
+| Summary |
+Bildet die Summary-Sektion der config.rsc ab. |
+
+
+
+Functions
+
+
+
+Summary
+
+Bildet die Summary-Sektion der config.rsc ab.
+
+
+Derived from
+object
+
+Class Attributes
+
+
+Class Methods
+
+
+Methods
+
+
+| Summary |
+Instantiiert die RevPiSummary-Klasse. |
+
+
+
+Static Methods
+
+
+
+Summary (Constructor)
+Summary(summary)
+
+Instantiiert die RevPiSummary-Klasse.
+
+- summary
+-
+piCtory Summaryinformationen
+
+
+
+
+
\ No newline at end of file
diff --git a/eric-revpimodio.api b/eric-revpimodio.api
new file mode 100644
index 0000000..c1c8100
--- /dev/null
+++ b/eric-revpimodio.api
@@ -0,0 +1,124 @@
+revpimodio2.BOTH?7
+revpimodio2.FALLING?7
+revpimodio2.GREEN?7
+revpimodio2.IOType.INP?7
+revpimodio2.IOType.MEM?7
+revpimodio2.IOType.OUT?7
+revpimodio2.OFF?7
+revpimodio2.RED?7
+revpimodio2.RISING?7
+revpimodio2.app.App?1(app)
+revpimodio2.device.Core.A1?7
+revpimodio2.device.Core.A2?7
+revpimodio2.device.Core._devconfigure?5()
+revpimodio2.device.Core._errorlimit?5(io_id, errorlimit)
+revpimodio2.device.Core.errorlimit1?4(value)
+revpimodio2.device.Core.errorlimit2?4(value)
+revpimodio2.device.Core.frequency?4()
+revpimodio2.device.Core.get_leda1?4()
+revpimodio2.device.Core.get_leda2?4()
+revpimodio2.device.Core.get_status?4()
+revpimodio2.device.Core.iocycle?4()
+revpimodio2.device.Core.ioerrorcount?4()
+revpimodio2.device.Core.leftgate?4()
+revpimodio2.device.Core.missingdeviceorgate?4()
+revpimodio2.device.Core.overunderflow?4()
+revpimodio2.device.Core.picontrolrunning?4()
+revpimodio2.device.Core.rightgate?4()
+revpimodio2.device.Core.set_leda1?4(value)
+revpimodio2.device.Core.set_leda2?4(value)
+revpimodio2.device.Core.status?7
+revpimodio2.device.Core.temperatur?4()
+revpimodio2.device.Core.unconfdevice?4()
+revpimodio2.device.Device._buildio?5(dict_io, iotype)
+revpimodio2.device.Device._devconfigure?5()
+revpimodio2.device.Device.auto_refresh?4(remove=False)
+revpimodio2.device.Device.get_allios?4()
+revpimodio2.device.Device.get_inps?4()
+revpimodio2.device.Device.get_mems?4()
+revpimodio2.device.Device.get_outs?4()
+revpimodio2.device.Device?1(parentmodio, dict_device, **kwargs)
+revpimodio2.device.DeviceList?1()
+revpimodio2.device.Gateway.get_rawbytes?4()
+revpimodio2.device.Gateway?1(parent, dict_device, **kwargs)
+revpimodio2.helper.Cycletools._docycle?5()
+revpimodio2.helper.Cycletools.get_tofc?4(name)
+revpimodio2.helper.Cycletools.get_tonc?4(name)
+revpimodio2.helper.Cycletools.get_tpc?4(name)
+revpimodio2.helper.Cycletools.set_tofc?4(name, cycles)
+revpimodio2.helper.Cycletools.set_tonc?4(name, cycles)
+revpimodio2.helper.Cycletools.set_tpc?4(name, cycles)
+revpimodio2.helper.Cycletools?1()
+revpimodio2.helper.EventCallback.run?4()
+revpimodio2.helper.EventCallback.stop?4()
+revpimodio2.helper.EventCallback?1(func, name, value)
+revpimodio2.helper.ProcimgWriter._gotioerror?5()
+revpimodio2.helper.ProcimgWriter.get_refresh?4()
+revpimodio2.helper.ProcimgWriter.refresh?7
+revpimodio2.helper.ProcimgWriter.run?4()
+revpimodio2.helper.ProcimgWriter.set_refresh?4(value)
+revpimodio2.helper.ProcimgWriter.stop?4()
+revpimodio2.helper.ProcimgWriter?1(parentmodio)
+revpimodio2.io.IOBase._get_byteorder?5()
+revpimodio2.io.IOBase.address?7
+revpimodio2.io.IOBase.get_address?4()
+revpimodio2.io.IOBase.get_length?4()
+revpimodio2.io.IOBase.get_name?4()
+revpimodio2.io.IOBase.get_value?4()
+revpimodio2.io.IOBase.length?7
+revpimodio2.io.IOBase.name?7
+revpimodio2.io.IOBase.reg_event?4(func, edge=BOTH, as_thread=False)
+revpimodio2.io.IOBase.replace_io?4(name, frm, **kwargs)
+revpimodio2.io.IOBase.set_value?4(value)
+revpimodio2.io.IOBase.unreg_event?4(func=None, edge=None)
+revpimodio2.io.IOBase.value?7
+revpimodio2.io.IOBase.wait?4(edge=BOTH, exitevent=None, okvalue=None, timeout=0)
+revpimodio2.io.IOBase?1(parentdevice, valuelist, iotype, byteorder)
+revpimodio2.io.IOList._register_new_io_object?5(new_io)
+revpimodio2.io.IOList._testme?5()
+revpimodio2.io.IOList?1()
+revpimodio2.io.IntIO._get_signed?5()
+revpimodio2.io.IntIO._set_byteorder?5(value)
+revpimodio2.io.IntIO._set_signed?5(value)
+revpimodio2.io.IntIO.byteorder?7
+revpimodio2.io.IntIO.get_int?4()
+revpimodio2.io.IntIO.set_int?4(value)
+revpimodio2.io.IntIO.signed?7
+revpimodio2.io.IntIO.value?7
+revpimodio2.io.StructIO.byteorder?7
+revpimodio2.io.StructIO.get_structvalue?4()
+revpimodio2.io.StructIO.set_structvalue?4(value)
+revpimodio2.io.StructIO.value?7
+revpimodio2.io.StructIO?1(parentio, name, iotype, byteorder, frm, **kwargs)
+revpimodio2.modio.RevPiModIO._configure?5()
+revpimodio2.modio.RevPiModIO._create_myfh?5()
+revpimodio2.modio.RevPiModIO._get_configrsc?5()
+revpimodio2.modio.RevPiModIO._get_cycletime?5()
+revpimodio2.modio.RevPiModIO._get_length?5()
+revpimodio2.modio.RevPiModIO._get_monitoring?5()
+revpimodio2.modio.RevPiModIO._get_procimg?5()
+revpimodio2.modio.RevPiModIO._get_simulator?5()
+revpimodio2.modio.RevPiModIO._set_cycletime?5(milliseconds)
+revpimodio2.modio.RevPiModIO.auto_refresh_maxioerrors?4(value=None)
+revpimodio2.modio.RevPiModIO.auto_refresh_resetioerrors?4()
+revpimodio2.modio.RevPiModIO.cleanup?4()
+revpimodio2.modio.RevPiModIO.configrsc?7
+revpimodio2.modio.RevPiModIO.cycleloop?4(func, cycletime=50)
+revpimodio2.modio.RevPiModIO.cycletime?7
+revpimodio2.modio.RevPiModIO.exit?4(full=True)
+revpimodio2.modio.RevPiModIO.get_jconfigrsc?4()
+revpimodio2.modio.RevPiModIO.handlesignalend?4(cleanupfunc=None)
+revpimodio2.modio.RevPiModIO.length?7
+revpimodio2.modio.RevPiModIO.mainloop?4(freeze=False, blocking=True)
+revpimodio2.modio.RevPiModIO.monitoring?7
+revpimodio2.modio.RevPiModIO.procimg?7
+revpimodio2.modio.RevPiModIO.readprocimg?4(force=False, device=None)
+revpimodio2.modio.RevPiModIO.setdefaultvalues?4(force=False, device=None)
+revpimodio2.modio.RevPiModIO.simulator?7
+revpimodio2.modio.RevPiModIO.syncoutputs?4(force=False, device=None)
+revpimodio2.modio.RevPiModIO.writedefaultinputs?4(virtual_device)
+revpimodio2.modio.RevPiModIO.writeprocimg?4(force=False, device=None)
+revpimodio2.modio.RevPiModIO?1(**kwargs)
+revpimodio2.modio.RevPiModIODriver?1(vdev, **kwargs)
+revpimodio2.modio.RevPiModIOSelected?1(deviceselection, **kwargs)
+revpimodio2.summary.Summary?1(summary)
diff --git a/eric-revpimodio.bas b/eric-revpimodio.bas
new file mode 100644
index 0000000..641f05f
--- /dev/null
+++ b/eric-revpimodio.bas
@@ -0,0 +1,9 @@
+Core Device
+EventCallback Thread
+Gateway Device
+IntIO IOBase
+ProcimgWriter Thread
+RevPiModIODriver RevPiModIOSelected
+RevPiModIOSelected RevPiModIO
+StructIO IOBase
+Virtual Gateway
diff --git a/revpimodio2.e4p b/revpimodio2.e4p
index a0b8b62..7e42f71 100644
--- a/revpimodio2.e4p
+++ b/revpimodio2.e4p
@@ -1,7 +1,7 @@
-
+
en_US
@@ -30,6 +30,7 @@
doc
.hgignore
+ eric-revpimodio.api
Mercurial
@@ -217,12 +218,6 @@
setup.py
-
- noindex
-
-
- True
-
outputDirectory
diff --git a/revpimodio2/__init__.py b/revpimodio2/__init__.py
index c925763..3c93f26 100644
--- a/revpimodio2/__init__.py
+++ b/revpimodio2/__init__.py
@@ -36,6 +36,7 @@ BOTH = 33
warnings.simplefilter(action="always")
+
class IOType(object):
"""IO Typen."""
diff --git a/revpimodio2/device.py b/revpimodio2/device.py
index 9971a8e..4a161d0 100644
--- a/revpimodio2/device.py
+++ b/revpimodio2/device.py
@@ -5,10 +5,8 @@
# (c) Sven Sager, License: LGPLv3
#
# -*- coding: utf-8 -*-
-import struct
+"""Modul fuer die Verwaltung der Devices."""
from threading import Lock
-
-from . import io as iomodule
from .__init__ import IOType
from .helper import ProcimgWriter
@@ -42,7 +40,13 @@ class DeviceList(object):
def __iter__(self):
"""Gibt Iterator aller Devices zurueck.
@return iter() aller Devices"""
- return iter(self.__dict_position.values())
+ for dev in sorted(self.__dict_position):
+ yield self.__dict_position[dev]
+
+ def __len__(self):
+ """Gibt Anzahl der Devices zurueck.
+ return Anzahl der Devices"""
+ return len(self.__dict_position)
def __setattr__(self, key, value):
"""Setzt Attribute nur wenn Device.
@@ -107,9 +111,6 @@ class Device(object):
self.slc_out = self._buildio(dict_device.pop("out"), IOType.OUT)
self.slc_mem = self._buildio(dict_device.pop("mem"), IOType.MEM)
- # Alle IOs nach Adresse sortieren
- self._lst_io.sort(key=lambda x: x.slc_address.start)
-
# SLCs mit offset berechnen
self.slc_devoff = slice(self.offset, self.offset + self._length)
self.slc_inpoff = slice(
@@ -138,29 +139,14 @@ class Device(object):
@param key IO-Name str() / IO-Bytenummer int()
@return True, wenn device vorhanden"""
if type(key) == str:
- return hasattr(self._modio.io, key)
- if type(key) == int:
- key += self.offset
+ return hasattr(self._modio.io, key) \
+ and getattr(self._modio.io, key)._parentdevice == self
+ elif type(key) == int:
return key in self._modio.io \
- and len(self._modio.io[key]) > 0
+ and len(self._modio.io[key]) > 0 \
+ and self._modio.io[key][0]._parentdevice == self
else:
- return key in self._lst_io
-
- def __getitem__(self, key):
- """Gibt angegebenes IO-Objekt zurueck.
- @param key Name order Byteadresse des IOs
- @return IO-Objekt wenn Name, sonst list() mit IO-Objekt"""
- if type(key) == int:
- key += self.offset
- if key in self._modio.io:
- return self._modio.io[key]
- else:
- raise KeyError("byte '{}' does not exist".format(key))
- else:
- if hasattr(self._modio.io, key):
- return getattr(self._modio.io, key)
- else:
- raise KeyError("'{}' does not exist".format(key))
+ return key._parentdevice == self
def __int__(self):
"""Gibt die Positon im RevPi Bus zurueck.
@@ -170,34 +156,20 @@ class Device(object):
def __iter__(self):
"""Gibt Iterator aller IOs zurueck.
@return iter() aller IOs"""
- return iter(self._lst_io)
+ for i_byte in range(self.slc_devoff.start, self.slc_devoff.stop):
+ for io in self._modio.io[i_byte]:
+ yield io
+
+ def __len__(self):
+ """Gibt Anzahl der Bytes zurueck, die dieses Device belegt.
+ @return int()"""
+ return self._length
def __str__(self):
"""Gibt den Namen des Devices zurueck.
@return Devicename"""
return self.name
- def __setitem__(self, key, value):
- """Setzt den Wert des angegebenen Inputs.
- @param key Name oder Byte des Inputs
- @param value Wert der gesetzt werden soll"""
- if type(key) == int:
- key += self.offset
- if key in self._modio.io:
- if len(self._modio.io[key]) == 1:
- self._modio.io[key][0].value = value
- elif len(self._modio.io[key]) == 0:
- raise KeyError("byte '{}' contains no input".format(key))
- else:
- raise KeyError(
- "byte '{}' contains more than one bit-input"
- "".format(key)
- )
- else:
- raise KeyError("byte '{}' does not exist".format(key))
- else:
- getattr(self._modio.io, key).value = value
-
def _buildio(self, dict_io, iotype):
"""Erstellt aus der piCtory-Liste die IOs fuer dieses Device.
@@ -228,22 +200,12 @@ class Device(object):
)
# IO registrieren
- if hasattr(self._modio.io, io_new.name):
- raise NameError(
- "name '{}' already exists on device '{}'".format(
- io_new._name, self.name
- )
- )
- else:
- # Namesregister aufbauen
- setattr(self._modio.io, io_new._name, io_new)
+ self._modio.io._register_new_io_object(io_new)
- # Speicherbereich zuweisen
- self._ba_devdata.extend(bytes(io_new._length))
+ # Speicherbereich zuweisen
+ self._ba_devdata.extend(bytes(io_new._length))
- # IO eintragen
- self._lst_io.append(io_new)
- self._length += io_new._length
+ self._length += io_new._length
# Kleinste und größte Speicheradresse ermitteln
if io_new.slc_address.start < int_min:
@@ -303,45 +265,38 @@ class Device(object):
if not self._modio._monitoring:
self._modio.writeprocimg(True, self)
+ def get_allios(self):
+ """Gibt eine Liste aller Inputs und Outputs zurueck.
+ @return list() Input und Output, keine MEMs"""
+ return [
+ io for io in self._modio.io
+ if io._parentdevice == self and io._iotype != IOType.MEM
+ ]
+
def get_inps(self):
"""Gibt eine Liste aller Inputs zurueck.
@return list() Inputs"""
return [
- io for io in self._lst_io if io._iotype == IOType.INP
+ io for io in self._modio.io
+ if io._parentdevice == self and io._iotype == IOType.INP
]
def get_outs(self):
"""Gibt eine Liste aller Outputs zurueck.
@return list() Outputs"""
return [
- io for io in self._lst_io if io._iotype == IOType.OUT
+ io for io in self._modio.io
+ if io._parentdevice == self and io._iotype == IOType.OUT
]
def get_mems(self):
"""Gibt eine Liste aller mems zurueck.
@return list() Mems"""
return [
- io for io in self._lst_io if io._iotype == IOType.MEM
+ io for io in self._modio.io
+ if io._parentdevice == self and io._iotype == IOType.MEM
]
- def get_iobyabsaddress(self, address):
- """Gibt das IO-Objekt an angegebenen Byte im Prozessabbild zurueck.
- @param address Byteadresse im Prozessabbild
- @return list() mit IO-Objekt/en"""
- return self[address - self.offset]
-
- def get_iobyaddress(self, address):
- """Gibt das IO-Objekt an angegebenen Byte des Devices zurueck.
- @param address Byteadresse im Deviceabbild
- @return list() mit IO-Objekt/en"""
- return self[address]
-
- def get_iobyname(self, name):
- """Gibt das IO-Objekt mit angegebenen Namen zurueck.
- @param name Name des IO-Objekts
- @return IO-Objekt"""
- return getattr(self._modio.io, name)
-
class Core(Device):
@@ -361,6 +316,9 @@ class Core(Device):
self._ioerrorlimit1 = None
self._ioerrorlimit2 = None
+ # Eigene IO-Liste aufbauen
+ self._lst_io = [x for x in self.__iter__()]
+
int_lenio = len(self._lst_io)
if int_lenio == 6:
# Core 1.1
@@ -584,38 +542,12 @@ class Gateway(Device):
@see #RevPiDevice.__init__ RevPiDevice.__init__(...)"""
super().__init__(parent, dict_device, **kwargs)
- # TODO: evtl. an modio.io anhängen
- self._dict_iorefbyte = {}
- self._dict_iorefname = {}
self._dict_slc = {
IOType.INP: self.slc_inp,
IOType.OUT: self.slc_out,
IOType.MEM: self.slc_mem
}
- def _getbytename(self, iobyte):
- """Ermittelt den Namen eines IOs auf der Byteadresse.
- @param iobyte Bytenummer
- @return IO-Namen"""
-
- # Wenn IO schon ausgetauscht wurde
- if iobyte in self._dict_iorefbyte:
- return self._dict_iorefbyte[iobyte]
-
- # Wenn IO jetzt ausgetauscht wird
- if iobyte in self._modio.io:
- intlen = len(self._modio.io[iobyte])
- if intlen == 1:
- return self._modio.io[iobyte][0].name
- elif len == 0:
- raise KeyError("byte '{}' contains no input".format(iobyte))
- else:
- raise KeyError(
- "byte '{}' contains more than one bit-input".format(iobyte)
- )
- else:
- raise KeyError("byte '{}' does not exist".format(iobyte))
-
def get_rawbytes(self):
"""Gibt die Bytes aus, die dieses Device verwendet.
@return bytes() des Devices"""
@@ -635,3 +567,7 @@ class Virtual(Gateway):
"""
pass
+
+
+# Nachträglicher Import
+from . import io as iomodule
diff --git a/revpimodio2/helper.py b/revpimodio2/helper.py
index 48f6617..638930b 100644
--- a/revpimodio2/helper.py
+++ b/revpimodio2/helper.py
@@ -5,6 +5,7 @@
# (c) Sven Sager, License: LGPLv3
#
# -*- coding: utf-8 -*-
+"""RevPiModIO Helperklassen und Tools."""
import warnings
from threading import Event, Lock, Thread
from timeit import default_timer
diff --git a/revpimodio2/io.py b/revpimodio2/io.py
index c95b245..6fd37c1 100644
--- a/revpimodio2/io.py
+++ b/revpimodio2/io.py
@@ -5,10 +5,9 @@
# (c) Sven Sager, License: LGPLv3
#
# -*- coding: utf-8 -*-
+"""RevPiModIO Modul fuer die Verwaltung der IOs."""
import struct
from threading import Event
-
-from . import device as devicemodule
from .__init__ import RISING, FALLING, BOTH, IOType
@@ -17,13 +16,15 @@ class IOList(object):
"""Basisklasse fuer direkten Zugriff auf IO Objekte."""
def __init__(self):
- """Init IOList clacc."""
+ """Init IOList class."""
self.__dict_iobyte = {k: [] for k in range(4096)}
+ self.__dict_iorefbyte = {}
+ self.__dict_iorefname = {}
def __contains__(self, key):
"""Prueft ob IO existiert.
- @param key IO-Name str()
- @return True, wenn IO vorhanden"""
+ @param key IO-Name str() oder Byte 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
@@ -34,12 +35,27 @@ class IOList(object):
"""Entfernt angegebenen IO.
@param key IO zum entfernen"""
# TODO: Prüfen ob auch Bit sein kann
- # FIXME: IO von DeviceIO Liste entfernen
- # FIXME: IO aus Eventhandling entfernen
- dev = getattr(self, key)
- self.__dict_iobyte[dev.address].remove(dev)
+
+ io_del = getattr(self, key)
+
+ # Alte Events vom Device löschen
+ io_del.unreg_event()
+
+ # IO aus Byteliste und Attributen entfernen
+ self.__dict_iobyte[io_del.address].remove(io_del)
object.__delattr__(self, key)
+ def __getattr__(self, key):
+ """Verwaltet geloeschte IOs.
+ @param key Wert eines alten IOs
+ @return Alten IO, wenn in Ref-Listen"""
+ if key in self.__dict_iorefname:
+ return self.__dict_iorefname[key]
+ elif key in self.__dict_iorefbyte:
+ return self.__dict_iorefbyte[key]
+ else:
+ raise AttributeError("can not find io '{}'".format(key))
+
def __getitem__(self, key):
"""Ruft angegebenen IO ab.
@param key IO Name oder Byte
@@ -83,42 +99,23 @@ class IOList(object):
"""Setzt IO Wert.
@param key IO Name oder Byte
@param value Wert, auf den der IO gesetzt wird"""
- if issubclass(type(value), IOBase):
- if hasattr(self, key):
- raise AttributeError(
- "attribute {} already exists - can not set io".format(key)
- )
- object.__setattr__(self, key, value)
-
- # Bytedict erstellen für Adresszugriff
- if value._bitaddress < 0:
- self.__dict_iobyte[value.address].append(value)
- else:
- if len(self.__dict_iobyte[value.address]) != 8:
- # "schnell" 8 Einträge erstellen da es BIT IOs sind
- self.__dict_iobyte[value.address] += [
- None, None, None, None, None, None, None, None
- ]
- self.__dict_iobyte[value.address][value._bitaddress] = value
-
- elif key == "_IOList__dict_iobyte":
+ if key in [
+ "_IOList__dict_iobyte",
+ "_IOList__dict_iorefname",
+ "_IOList__dict_iorefbyte"
+ ]:
object.__setattr__(self, key, value)
else:
+ # Setzt Wert bei Zuweisung
getattr(self, key).value = value
- def _replace_io(self, io):
+ def __replace_oldio_with_newio(self, io):
"""Ersetzt bestehende IOs durch den neu Registrierten.
@param io Neuer IO der eingefuegt werden soll"""
- dict_oldio = {}
- for oldio in self._lst_io:
- # Alle IOs Prüfen ob sie im neuen Speicherbereich sind
- errstart = oldio.slc_address.start >= io.slc_address.start \
- and oldio.slc_address.start < io.slc_address.stop
- errstop = oldio.slc_address.stop > io.slc_address.start \
- and oldio.slc_address.stop <= io.slc_address.stop
+ for i in range(io.slc_address.start, io.slc_address.stop):
+ for oldio in self.__dict_iobyte[i + io._parentdevice.offset]:
- if errstart or errstop:
if type(oldio) == StructIO:
# Hier gibt es schon einen neuen IO
if oldio._bitaddress >= 0:
@@ -137,39 +134,52 @@ class IOList(object):
)
)
- else:
+ elif oldio is not None:
# IOs im Speicherbereich des neuen IO merken
- dict_oldio[oldio.name] = oldio
-
- for oldio in dict_oldio.values():
- if io._bitaddress >= 0:
- # ios für ref bei bitaddress speichern
- self._dict_iorefbyte[oldio.slc_address.start] = oldio.name
- self._dict_iorefname[oldio.name] = oldio.slc_address.start
-
- # ios aus listen entfernen
- delattr(self._modio.io, oldio.name)
- self._lst_io.remove(oldio)
-
- # Namensregister erweitern
- setattr(self._modio.io, io.name, io)
-
- # io einfügen (auch wenn nicht richtige stelle wegen BitOffset)
- self._lst_io.insert(io.slc_address.start, io)
-
- # Liste neu sortieren
- self._lst_io.sort(key=lambda x: x.slc_address.start)
+ if io._bitaddress >= 0:
+ # ios für ref bei bitaddress speichern
+ self.__dict_iorefbyte[oldio.slc_address.start] = oldio
+ self.__dict_iorefname[oldio.name] = oldio
+ # ios aus listen entfernen
+ delattr(self, oldio.name)
+ def _register_new_io_object(self, new_io):
+ """Registriert neues IO Objekt unabhaenging von __setattr__.
+ @param new_io Neues IO Objekt"""
+ if issubclass(type(new_io), IOBase):
+ if hasattr(self, new_io.name):
+ raise AttributeError(
+ "attribute {} already exists - can not set io".format(
+ new_io.name
+ )
+ )
+ if type(new_io) is StructIO:
+ self.__replace_oldio_with_newio(new_io)
+ object.__setattr__(self, new_io.name, new_io)
+ # Bytedict erstellen für Adresszugriff
+ if new_io._bitaddress < 0:
+ self.__dict_iobyte[new_io.address].append(new_io)
+ else:
+ if len(self.__dict_iobyte[new_io.address]) != 8:
+ # "schnell" 8 Einträge erstellen da es BIT IOs sind
+ self.__dict_iobyte[new_io.address] += [
+ None, None, None, None, None, None, None, None
+ ]
+ self.__dict_iobyte[new_io.address][new_io._bitaddress] = new_io
+ else:
+ raise AttributeError("io must be IOBase or sub class")
def _testme(self):
# NOTE: Nur Debugging
for x in self.__dict_iobyte:
if len(self.__dict_iobyte[x]) > 0:
print(x, self.__dict_iobyte[x])
+ print(self.__dict_iorefname)
+ print(self.__dict_iorefbyte)
class IOBase(object):
@@ -346,8 +356,8 @@ class IOBase(object):
)
break
- def reg_inp(self, name, frm, **kwargs):
- """Registriert einen neuen Input an Adresse von Diesem.
+ def replace_io(self, name, frm, **kwargs):
+ """Ersetzt bestehenden IO mit Neuem.
@param name Name des neuen Inputs
@param frm struct() formatierung (1 Zeichen)
@@ -364,7 +374,7 @@ class IOBase(object):
>Python3 struct()
"""
- if not issubclass(self._parentdevice, devicemodule.Gateway):
+ if not issubclass(type(self._parentdevice), Gateway):
raise RuntimeError(
"this function can be used for ios on gatway or virtual "
"devices only"
@@ -372,14 +382,14 @@ class IOBase(object):
# StructIO erzeugen und in IO-Liste einfügen
io_new = StructIO(
- self._parentdevice,
+ self,
name,
- IOType.INP,
+ self._iotype,
kwargs.get("byteorder", "little"),
frm,
**kwargs
)
- setattr(self._parentdevice._modio.io, name, io_new)
+ self._parentdevice._modio.io._register_new_io_object(io_new)
# Optional Event eintragen
reg_event = kwargs.get("event", None)
@@ -388,48 +398,6 @@ class IOBase(object):
edge = kwargs.get("edge", None)
io_new.reg_event(reg_event, as_thread=as_thread, edge=edge)
- def reg_out(self, name, frm, **kwargs):
- """Registriert einen neuen Output.
-
- @param name Name des neuen Outputs
- @param startout Outputname ab dem eingefuegt wird
- @param frm struct() formatierung (1 Zeichen)
- @param kwargs Weitere Parameter:
- - bmk: Bezeichnung fuer Output
- - bit: Registriert Outputs als bool() am angegebenen Bit im Byte
- - byteorder: Byteorder fuer den Output, Standardwert=little
- - defaultvalue: Standardwert fuer Output, Standard ist 0
- - event: Funktion fuer Eventhandling registrieren
- - as_thread: Fuehrt die event-Funktion als RevPiCallback-Thread aus
- - edge: event-Ausfuehren bei RISING, FALLING or BOTH Wertaenderung
- @see Python3 struct()
-
- """
- if not issubclass(self._parentdevice, devicemodule.Gateway):
- raise RuntimeError(
- "this function can be used on gatway or virtual devices only"
- )
-
- # StructIO erzeugen und in IO-Liste einfügen
- io_new = StructIO(
- self._parentdevice,
- name,
- IOType.OUT,
- kwargs.get("byteorder", "little"),
- frm,
- **kwargs
- )
- setattr(self._parentdevice._modio.io, name, io_new)
-
- # Optional Event eintragen
- reg_event = kwargs.get("event", None)
- if reg_event is not None:
- as_thread = kwargs.get("as_thread", False)
- edge = kwargs.get("edge", None)
- io_new.reg_event(name, reg_event, as_thread=as_thread, edge=edge)
-
def set_value(self, value):
"""Setzt den Wert des IOs mit bytes() oder bool().
@param value IO-Wert als bytes() oder bool()"""
@@ -715,9 +683,9 @@ class StructIO(IOBase):
name,
kwargs.get("defaultvalue", 0),
bitlength,
- parentio.address,
+ parentio.slc_address.start,
False,
- str(parentio.address).rjust(4, "0"),
+ str(parentio.slc_address.start).rjust(4, "0"),
kwargs.get("bmk", ""),
bitaddress
]
@@ -761,3 +729,7 @@ class StructIO(IOBase):
byteorder = property(IOBase._get_byteorder)
value = property(get_structvalue, set_structvalue)
+
+
+# Nachträglicher Import
+from .device import Gateway
diff --git a/revpimodio2/modio.py b/revpimodio2/modio.py
index 56ffc28..2f38419 100644
--- a/revpimodio2/modio.py
+++ b/revpimodio2/modio.py
@@ -5,6 +5,7 @@
# (c) Sven Sager, License: LGPLv3
#
# -*- coding: utf-8 -*-
+"""RevPiModIO Hauptklasse."""
import warnings
from json import load as jload
from os import access, F_OK, R_OK
@@ -56,7 +57,6 @@ class RevPiModIO(object):
# Private Variablen
self.__cleanupfunc = None
self._buffedwrite = False
- self._device = []
self._exit = Event()
self._imgwriter = None
self._length = 0
@@ -73,7 +73,6 @@ class RevPiModIO(object):
# piCtory Klassen
self.app = None
self.device = None
- self.devices = None
self.io = None
self.summary = None
@@ -129,7 +128,6 @@ class RevPiModIO(object):
# Device und IO Klassen anlegen
self.device = devicemodule.DeviceList()
- #self.io = iomodule.IOList()
self.io = IOList()
# Devices initialisieren
@@ -181,8 +179,6 @@ class RevPiModIO(object):
dev_new = None
if dev_new is not None:
- self._device.append(dev_new)
-
# Offset prüfen, muss mit Länge übereinstimmen
if self._length < dev_new.offset:
self._length = dev_new.offset
@@ -196,13 +192,13 @@ class RevPiModIO(object):
# DeviceList für direkten Zugriff aufbauen
setattr(self.device, dev_new.name, dev_new)
- # dict_devname zerstören, wenn doppelte Namen vorhanden sind
+ # Namenszugriff zerstören, wenn doppelte Namen vorhanden sind
for errdev in err_names:
delattr(self.device, errdev)
warnings.warn(
"equal device name in pictory configuration. can not "
"build device to acces by name. you can access all devices "
- "by position number pos_XX only!",
+ "by position number .device[nn] only!",
Warning
)
@@ -215,7 +211,7 @@ class RevPiModIO(object):
# Optional ins auto_refresh aufnehmen
if self._auto_refresh:
- for dev in self._device:
+ for dev in self.device:
dev.auto_refresh()
# Summary Klasse instantiieren
@@ -277,12 +273,11 @@ class RevPiModIO(object):
def cleanup(self):
"""Beendet auto_refresh und alle Threads."""
- # TODO: wirklich alles löschen
self.exit(full=True)
self._myfh.close()
self.app = None
+ self.core = None
self.device = None
- self.devices = None
self.io = None
self.summary = None
@@ -589,9 +584,8 @@ class RevPiModIO(object):
"""
if device is None:
- mylist = self._device
+ mylist = self.device
else:
- # TODO: Devicesuchen ändern
dev = device if issubclass(type(device), devicemodule.Device) \
else self.device.__getitem__(device)
@@ -644,7 +638,7 @@ class RevPiModIO(object):
)
if device is None:
- mylist = self._device
+ mylist = self.device
else:
dev = device if issubclass(type(device), devicemodule.Device) \
else self.__getitem__(device)
@@ -664,7 +658,7 @@ class RevPiModIO(object):
"""
if device is None:
- mylist = self._device
+ mylist = self.device
else:
dev = device if issubclass(type(device), devicemodule.Device) \
else self.__getitem__(device)
@@ -761,7 +755,7 @@ class RevPiModIO(object):
)
if device is None:
- mylist = self._device
+ mylist = self.device
else:
dev = device if issubclass(type(device), devicemodule.Device) \
else self.__getitem__(device)
@@ -850,7 +844,7 @@ class RevPiModIOSelected(RevPiModIO):
self._configure()
- if len(self._device) == 0:
+ if len(self.device) == 0:
if type(self) == RevPiModIODriver:
raise RuntimeError(
"could not find any given VIRTUAL devices in config"
@@ -859,7 +853,7 @@ class RevPiModIOSelected(RevPiModIO):
raise RuntimeError(
"could not find any given devices in config"
)
- elif len(self._device) != len(self._lst_devselect):
+ elif len(self.device) != len(self._lst_devselect):
if type(self) == RevPiModIODriver:
raise RuntimeError(
"could not find all given VIRTUAL devices in config"