revpi/revpimodio2
1
0
Fork 0
mirror of https://github.com/naruxde/revpimodio2.git synced 2025-11-09 06:13:53 +01:00
Code Issues Packages Releases Wiki Activity

Fehlerabfang und Leistung in ProcimgWriter.run() verbessert

Browse Source
This commit is contained in:
Sven Sager
2017-11-15 11:32:56 +01:00
parent 01515e28c5
commit 8b0e465205
1 changed files with 49 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

108
revpimodio2/helper.py
View File

@@ -401,24 +401,10 @@ class ProcimgWriter(Thread):
"""Startet die automatische Prozessabbildsynchronisierung.""" """Startet die automatische Prozessabbildsynchronisierung."""
fh = self._modio._create_myfh() fh = self._modio._create_myfh()
self._adjwait = self._refresh self._adjwait = self._refresh
while not self._work.is_set(): while not self._work.is_set():
ot = default_timer() ot = default_timer()
# Verzögerte Events prüfen
# NOTE: Darf dies VOR der Aktualisierung der Daten gemacht werden?
if self.__eventwork:
for tup_fire in list(self.__dict_delay.keys()):
if tup_fire[0][4] \
and getattr(self._modio.io, tup_fire[1]).value != \
tup_fire[2]:
del self.__dict_delay[tup_fire]
else:
self.__dict_delay[tup_fire] -= 1
if self.__dict_delay[tup_fire] <= 1:
# Verzögertes Event übernehmen und löschen
self._eventq.put(tup_fire, False)
del self.__dict_delay[tup_fire]
# Lockobjekt holen und Fehler werfen, wenn nicht schnell genug # Lockobjekt holen und Fehler werfen, wenn nicht schnell genug
if not self.lck_refresh.acquire(timeout=self._adjwait): if not self.lck_refresh.acquire(timeout=self._adjwait):
warnings.warn( warnings.warn(
@@ -427,63 +413,67 @@ class ProcimgWriter(Thread):
), ),
RuntimeWarning RuntimeWarning
) )
# Verzögerte Events pausieren an dieser Stelle
continue continue
try: try:
fh.seek(0) fh.seek(0)
bytesbuff = bytearray(fh.read(self._modio._length)) bytesbuff = bytearray(fh.read(self._modio._length))
if self._modio._monitoring:
# Inputs und Outputs in Puffer
for dev in self._modio._lst_refresh:
dev._filelock.acquire()
dev._ba_devdata[:] = bytesbuff[dev._slc_devoff]
if self.__eventwork \
and len(dev._dict_events) > 0 \
and dev._ba_datacp != dev._ba_devdata:
self.__check_change(dev)
dev._filelock.release()
else:
# Inputs in Puffer, Outputs in Prozessabbild
for dev in self._modio._lst_refresh:
with dev._filelock:
dev._ba_devdata[dev._slc_inp] = \
bytesbuff[dev._slc_inpoff]
if self.__eventwork\
and len(dev._dict_events) > 0 \
and dev._ba_datacp != dev._ba_devdata:
self.__check_change(dev)
fh.seek(dev._slc_outoff.start)
fh.write(dev._ba_devdata[dev._slc_out])
if self._modio._buffedwrite:
fh.flush()
except IOError: except IOError:
self._gotioerror() self._gotioerror()
self.lck_refresh.release() self.lck_refresh.release()
self._work.wait(self._adjwait)
continue continue
if self._modio._monitoring:
# Inputs und Outputs in Puffer
for dev in self._modio._lst_refresh:
dev._filelock.acquire()
dev._ba_devdata[:] = bytesbuff[dev._slc_devoff]
if self.__eventwork \
and len(dev._dict_events) > 0 \
and dev._ba_datacp != dev._ba_devdata:
self.__check_change(dev)
dev._filelock.release()
else: else:
# Inputs in Puffer, Outputs in Prozessabbild # Alle aufwecken
ioerr = False self.lck_refresh.release()
for dev in self._modio._lst_refresh: self.newdata.set()
dev._filelock.acquire()
dev._ba_devdata[dev._slc_inp] = bytesbuff[dev._slc_inpoff]
if self.__eventwork\
and len(dev._dict_events) > 0 \
and dev._ba_datacp != dev._ba_devdata:
self.__check_change(dev)
try: finally:
fh.seek(dev._slc_outoff.start) # Verzögerte Events prüfen
fh.write(dev._ba_devdata[dev._slc_out]) if self.__eventwork:
except IOError: for tup_fire in list(self.__dict_delay.keys()):
ioerr = True if tup_fire[0][4] \
finally: and getattr(self._modio.io, tup_fire[1]).value != \
dev._filelock.release() tup_fire[2]:
del self.__dict_delay[tup_fire]
else:
self.__dict_delay[tup_fire] -= 1
if self.__dict_delay[tup_fire] <= 0:
# Verzögertes Event übernehmen und löschen
self._eventq.put(tup_fire, False)
del self.__dict_delay[tup_fire]
if self._modio._buffedwrite: # Refresh abwarten
try: self._work.wait(self._adjwait)
fh.flush()
except IOError:
ioerr = True
if ioerr:
self._gotioerror()
self.lck_refresh.release()
self._work.wait(self._adjwait)
continue
self.lck_refresh.release()
# Alle aufwecken
self.newdata.set()
self._work.wait(self._adjwait)
# Wartezeit anpassen um echte self._refresh zu erreichen # Wartezeit anpassen um echte self._refresh zu erreichen
if default_timer() - ot >= self._refresh: if default_timer() - ot >= self._refresh: