#62: add force flush meta attribute for ev3dev object attributes

ev3/ev3dev.py

@@ -104,7 +104,7 @@ def __init__(self, **kwargs):
 
     def __call__(self, cls):
         for name, args in self.kwargs.items():
-            def ev3_property(name, read_only=False, write_only=False, property_type=Ev3StringType):
+            def ev3_property(name, read_only=False, write_only=False, flush_on_write=False, property_type=Ev3StringType):
                 def fget(self):
                     if not write_only:
                         return property_type.post_read(self.read_value(name))
@@ -113,7 +113,7 @@ def fget(self):
 
                 def fset(self, value):
                     self.write_value(
-                        name, property_type.pre_write(value))
+                        name, property_type.pre_write(value), flush_on_write)
                 return property(fget, None if read_only else fset)
 
             setattr(cls, name, ev3_property(name, **args))
@@ -193,11 +193,13 @@ def read_value(self, name):
         else:
             return None
 
-    def write_value(self, name, value):
+    def write_value(self, name, value, flush = False):
         attr_file = os.path.join(self.sys_path, name)
         if os.path.isfile(attr_file):
             with open(attr_file, 'w') as f:
                 f.write(str(value))
+                if flush:
+                    f.flush()
         else:
             return
 
@@ -460,7 +462,7 @@ def fset(self, value):
 @create_ev3_property(
     brightness={'read_only': False, 'property_type': Ev3IntType},
     max_brightness={'read_only': True, 'property_type': Ev3IntType},
-    trigger={'read_only': False},
+    trigger={'read_only': False, 'flush_on_write': True},
     delay_on={'read_only': False, 'property_type': Ev3IntType},
     delay_off={'read_only': False, 'property_type': Ev3IntType}
 )

ev3/event_loop.py

@@ -30,7 +30,7 @@ def register_condition(self, condition, target, repeat=False, count=-1):
         return len(self._events) - 1
 
     def register_value_change(self, getter, startvalue, target, count=-1):
-        """Register `target` to be called when evaliating ``getter()``
+        """Register `target` to be called when evaluating ``getter()``
         returns a new value. `startvalue` is the starting value to check
         against.
 
@@ -54,28 +54,37 @@ def register_timer(self, seconds, target, count=1):
         """
         target_time = time.time() + seconds
         condition = lambda: time.time() >= target_time
-        return self._add_condition(condition, target, False, count)
+        return self.register_condition(condition, target, False, count)
+
+    def register_poll(self, poller, callback):
+        """Register `callback` to be called on every ``poller()`` evaluation.
+
+        Returns an ID that can be used to unregister this poll event.
+        """
+        self._events.append(PollEvent(
+            poller, callback))
+        return len(self._events) - 1
 
     def unregister(self, id):
         """Ungegister condition with the given id."""
         del self._events[id]
 
-    def start(self):
+    def start(self, time_delta = 0.1):
         """Starts the event loop."""
-        self._loop()
+        self._loop(time_delta)
 
     def stop(self):
         """Stops event loop."""
         self._closed = True
 
-    def _loop(self):
+    def _loop(self, time_delta = 0.1):
         """The event loop."""
         while not self._closed:
             for i in range(len(self._events) - 1, -1, -1):
                 self._events[i].evaluate()
                 if self._events[i]._count == 0:
                     self.unregister(i)
-            time.sleep(0.1)
+            time.sleep(time_delta)
 
 
 class Event(object):
@@ -136,3 +145,12 @@ def __init__(self, getter, startvalue, target, count=-1):
 
     def poll(self):
         return self._evaluation != self._previous_evaluation
+
+
+class PollEvent(Event):
+
+    def __init__(self, poller, callback):
+        Event.__init__(self, poller, callback, count=-1)
+
+    def poll(self):
+        return True