syscalls are objects now, make schedule public

src/apps/playground/__init__.py

@@ -141,9 +141,7 @@ class PinDialog():
     def wait_for_result(self):
         while True:
             self.render()
-            event, pos = yield loop.Wait([loop.TOUCH_START,
+            event, *pos = yield loop.Select(loop.TOUCH_START | loop.TOUCH_MOVE | loop.TOUCH_END)
-                                          loop.TOUCH_MOVE,
-                                          loop.TOUCH_END])
             result = self.send(event, pos)
             if result is not None:
                 return result
@@ -171,11 +169,13 @@ def layout_tap_to_confirm(address, amount, currency):
 
     # animation = ui.animate_pulse(func, ui.BLACK, ui.GREY, speed=200000)
 
-    pin = PinDialog()
+    pin_dialog = PinDialog()
+
+    pin_result = yield from pin_dialog.wait_for_result()
 
-    pin_result = yield from pin.wait_for_result()
     if pin_result is PIN_CONFIRMED:
-        print('PIN confirmed:', pin.pin)
+        print('PIN confirmed:', pin_dialog.pin)
+
     elif pin_result is PIN_CANCELLED:
         print('PIN CANCELLED, go home')
 

src/trezor/loop.py

@@ -5,20 +5,6 @@ from .utils import type_gen
 from . import msg
 from . import log
 
-TOUCH_START = const(-1)
-TOUCH_MOVE = const(-2)
-TOUCH_END = const(-3)
-MESSAGE = const(-4)
-
-event_handlers = {
-    TOUCH_START: None,
-    TOUCH_MOVE: None,
-    TOUCH_END: None,
-    MESSAGE: None,
-}
-time_queue = []
-schedule_ctr = 0
-
 if __debug__:
     # For performance stats
     import array
@@ -26,13 +12,35 @@ if __debug__:
     log_delay_rb_len = const(10)
     log_delay_rb = array.array('i', [0] * log_delay_rb_len)
 
+TOUCH_START = const(1)
+TOUCH_MOVE = const(2)
+TOUCH_END = const(4)
+HID_READ = const(8)
 
-def __schedule(gen, args=(), time=None):
+time_queue = []
-    global schedule_ctr
+time_queue_ctr = 0
+blocked_events = 0
+blocked_gen = None
+
+
+def schedule(gen, data=None, time=None):
+    global time_queue_ctr
     if not time:
         time = utime.ticks_us()
-    heappush(time_queue, (time, schedule_ctr, gen, args))
+    heappush(time_queue, (time, time_queue_ctr, gen, data))
-    schedule_ctr += 1
+    time_queue_ctr += 1
+
+
+class Sleep():
+
+    def __init__(self, us):
+        self.time = utime.ticks_us() + us
+
+
+class Select():
+
+    def __init__(self, events):
+        self.events = events
 
 
 class Wait():
@@ -45,7 +53,7 @@ class Wait():
         self.gens = gens
 
         for g in gens:
-            __schedule(self._wait(g))
+            schedule(self._wait(g))
 
     def _wait(self, gen):
         if isinstance(gen, type_gen):
@@ -59,7 +67,7 @@ class Wait():
         self.received += 1
 
         if self.received == self.wait_for:
-            __schedule(self.callback, (gen, result))
+            schedule(self.callback, (gen, result))
             self.callback = None
 
             if self.exit_others:
@@ -68,84 +76,73 @@ class Wait():
                         g.close()
 
 
-def sleep(us):
+def run_forever():
-    return utime.ticks_us() + us
-
-
-def run_forever(start_gens):
     if __debug__:
-        global log_delay_pos
+        global log_delay_pos, log_delay_rb, log_delay_rb_len
-        global log_delay_rb
+    global blocked_events, blocked_gen
-        global log_delay_rb_len
 
-    delay_max = const(1000000)
+    DELAY_MAX = const(1000000)
-
-    for gen in start_gens:
-        __schedule(gen)
 
     while True:
 
+        # Peek at how long we can sleep while waiting for an event
         if time_queue:
             t, _, _, _ = time_queue[0]
             delay = t - utime.ticks_us()
         else:
-            delay = delay_max
+            delay = DELAY_MAX
 
         if __debug__:
             # Adding current delay to ring buffer for performance stats
             log_delay_rb[log_delay_pos] = delay
             log_delay_pos = (log_delay_pos + 1) % log_delay_rb_len
 
-        event = msg.select(delay)
+        message = msg.select(delay)
-
+        if message:
-        if event:
+            # Run interrupt handler right away, they have priority
-            # Run interrupt handler
+            event = message[0]
-            event_id, *args = event
+            data = message
-            event_id = -event_id
+            if blocked_events & event:
-            gen = event_handlers.get(event_id, None)
+                gen = blocked_gen
-            event_handlers[event_id] = None
+                blocked_events = 0
-            if not gen:
+                blocked_gen = None
+            else:
                 log.info(__name__, 'No handler for event: %s', event)
                 continue
         else:
-            if time_queue:
             # Run something from the time queue
-                _, _, gen, args = heappop(time_queue)
+            if time_queue:
+                _, _, gen, data = heappop(time_queue)
             else:
-                # Sleep again
-                delay = delay_max
                 continue
 
-        if not args:
-            args = None
         try:
-            ret = gen.send(args)
+            result = gen.send(data)
-
         except StopIteration as e:
             log.debug(__name__, '%s finished', gen)
             continue
-
         except Exception as e:
             log.exception(__name__, e)
             continue
 
-        if isinstance(ret, int) and ret >= 0:
+        if isinstance(result, Sleep):
-            # Sleep until ret, call us later
+            # Sleep until result.time, call us later
-            __schedule(gen, (), ret)
+            schedule(gen, None, result.time)
 
-        elif isinstance(ret, int) and ret in event_handlers:
+        elif isinstance(result, Select):
-            # Wait for event
+            # Wait for one or more types of event
-            if event_handlers[ret]:
+            if blocked_gen:
-                event_handlers[ret].close()
+                blocked_gen.close()
-            event_handlers[ret] = gen
+            blocked_gen = gen
+            blocked_events = result.events
 
-        elif isinstance(ret, Wait):
+        elif isinstance(result, Wait):
             # Register the origin generator as a waiting callback
-            ret.callback = gen
+            result.callback = gen
 
-        elif ret is None:
+        elif result is None:
             # Just call us asap
-            __schedule(gen)
+            schedule(gen)
 
         else:
-            raise Exception('Unhandled result %s by %s' % (ret, gen))
+            raise Exception('Unhandled result %s by %s' % (result, gen))

src/trezor/main.py

@@ -12,7 +12,7 @@ log.level = log.INFO
 
 def perf_info_debug():
     while True:
-        queue = [str(x[1]).split("'")[1] for x in loop.time_queue]
+        queue = [str(x[2]).split("'")[1] for x in loop.time_queue]
 
         delay_avg = sum(loop.log_delay_rb) / loop.log_delay_rb_len
         delay_last = loop.log_delay_rb[loop.log_delay_pos]
@@ -22,7 +22,7 @@ def perf_info_debug():
         log.info(__name__, "mem_alloc: %s/%s, delay_avg: %d, delay_last: %d, queue: %s",
               mem_alloc, gc.mem_alloc(), delay_avg, delay_last, ', '.join(queue))
 
-        yield loop.sleep(1000000)
+        yield loop.Sleep(1000000)
 
 
 def perf_info():
@@ -34,11 +34,8 @@ def perf_info():
 
 def run(main_layout):
     if __debug__:
-        perf_info_gen = perf_info_debug()
+        loop.schedule(perf_info_debug())
     else:
-        perf_info_gen = perf_info()
+        loop.schedule(perf_info())
-
+    loop.schedule(layout.set_main(main_layout))
-    loop.run_forever([
+    loop.run_forever()
-        perf_info_gen,
-        layout.set_main(main_layout),
-    ])