change the way the waker works: let others register to be called by it

diff --git a/statemachine.py b/statemachine.py
index 0f325a80ea93a61bad5a4ebfb61bf4533e341c47..59951d446f98bfe7e06c4277689c7d8746895843 100644 (file)
--- a/statemachine.py
+++ b/statemachine.py
@@ -304,12 +304,13 @@ class StateMachine():
                                return StateMachine.StateAuf(self.state_machine)
                        return super().handle_pins_event()
        
-       def __init__(self, actor, fallback = False):
+       def __init__(self, actor, waker, fallback = False):
                self.actor = actor
                self.callback = ThreadFunction(self._callback, name="StateMachine")
                self.current_state = StateMachine.StateStart(self, fallback)
                self.pins = None
                self.old_pins = None
+               waker.register(lambda: self.callback(StateMachine.CMD_WAKEUP), 1.0) # wake up every second
        
        def stop (self):
                self.callback.stop()

diff --git a/tuerd b/tuerd
index 92c4122c2cf0678e8f0fc20f875a3bf6ae481e6b..e828ebb6d5ecc85725163e5bd626292bd6239cb4 100755 (executable)
--- a/tuerd
+++ b/tuerd
@@ -30,10 +30,10 @@ GPIO.setmode(GPIO.BOARD)
 
 # bring 'em all up
 the_actor = actor.Actor()
-the_machine = statemachine.StateMachine(the_actor, args.fallback)
+the_waker = waker.Waker(the_machine)
+the_machine = statemachine.StateMachine(the_actor, the_waker, args.fallback)
 the_socket = tysock.TySocket(the_machine)
 the_pins = pins.PinsWatcher(the_machine)
-the_waker = waker.Waker(the_machine)
 
 # we do the socket accept thing in the main thread
 try:
@@ -44,8 +44,8 @@ except KeyboardInterrupt:
        pass
 
 # bring 'em all down
-the_waker.stop()
-the_pins.stop()
+the_waker.stop() # this one first, it "randomly" calls other threads
+the_pins.stop() # as does this
 the_machine.stop()
 the_actor.stop()
 

diff --git a/waker.py b/waker.py
index 7b212a194f79bdc5398c47e52cf2c2dccf9aa4c0..1cf2884155eaa7f0d1f741d8619c4efcd438649f 100644 (file)
--- a/waker.py
+++ b/waker.py
@@ -1,13 +1,35 @@
 from libtuer import ThreadRepeater
-from statemachine import StateMachine
+from collections import namedtuple
+
+SLEEP_TIME = 0.5
+
+ToBeWoken = namedtuple('ToBeWoken','f period time_since_call one_shot')
 
 class Waker():
        def __init__(self, sm):
                self._sm = sm
-               self._t = ThreadRepeater(self._wake, 0.5, name="Waker")
+               self._t = ThreadRepeater(self._wake, SLEEP_TIME, name="Waker")
+               self._tobewokens = []
+       
+       def register(f, time, one_shot = False):
+               '''Register a function which is called approximately every <time> seconds (or just once, if one_shot is True). f should return quickly, or it will delay the waker!'''
+               time = max(time//SLEEP_TIME, 1)
+               self._tobewokens.append(ToBeWoken(f, time, 0, one_shot))
        
        def _wake(self):
-               self._sm.callback(StateMachine.CMD_WAKEUP)
+               delete = []
+               # run the functions we ought to run
+               for tobewoken, idx in zip(self._tobewokens, range(len(self._tobewokens))):
+                       tobewoken.time_since_call += 1
+                       if tobewoken.time_since_call >= tobewoken.period:
+                               tobewoken.f()
+                               tobewoken.time_since_call = 0
+                               if tobewoken.one_shot:
+                                       delete.append(idx)
+               # delete what we have to delete - in reverse order so the indices stay valid!
+               delete.reverse()
+               for idx in delete:
+                       del self._tobewokens[idx]
        
        def stop(self):
                self._t.stop()