Prevent looping over sequences of images and strings from allocating memory in the display ticker.

Author: markshannon

inc/genhdr/qstrdefs.generated.h

@@ -468,6 +468,7 @@ QDEF(MP_QSTR_ScrollingString, (const byte*)"\xbd\x0f" "ScrollingString")
 QDEF(MP_QSTR_on, (const byte*)"\x64\x02" "on")
 QDEF(MP_QSTR_off, (const byte*)"\x8a\x03" "off")
 QDEF(MP_QSTR_is_on, (const byte*)"\x61\x05" "is_on")
+QDEF(MP_QSTR_Facade, (const byte*)"\xc1\x06" "Facade")
 QDEF(MP_QSTR_MicroBitButton, (const byte*)"\x16\x0e" "MicroBitButton")
 QDEF(MP_QSTR_button_a, (const byte*)"\xed\x08" "button_a")
 QDEF(MP_QSTR_button_b, (const byte*)"\xee\x08" "button_b")

inc/microbit/microbitimage.h

@@ -62,6 +62,10 @@ typedef union _microbit_image_obj_t {
 
 } microbit_image_obj_t;
 
+/** Return a facade object that presents the string as a sequence of images */
+mp_obj_t microbit_string_facade(mp_obj_t string);
+
+void microbit_image_set_from_char(greyscale_t *img, char c);
 microbit_image_obj_t *microbit_image_for_char(char c);
 mp_obj_t microbit_image_slice(microbit_image_obj_t *img, mp_int_t start, mp_int_t width, mp_int_t stride);
 /* ref exists so that we can pull a string out of an object and not have it GC'ed while oterating over it */
@@ -84,7 +88,6 @@ extern const monochrome_5by5_t microbit_const_image_heart_obj;
 #define BLANK_IMAGE (microbit_image_obj_t *)(&microbit_blank_image)
 #define HEART_IMAGE (microbit_image_obj_t *)(&microbit_const_image_heart_obj)
 
-microbit_image_obj_t *microbit_image_for_char(char c);
 microbit_image_obj_t *microbit_image_dim(microbit_image_obj_t *lhs, mp_float_t fval);
 microbit_image_obj_t *microbit_image_sum(microbit_image_obj_t *lhs, microbit_image_obj_t *rhs, bool add);
 

inc/microbit/qstrdefsport.h

@@ -152,6 +152,7 @@ Q(ScrollingString)
 Q(on)
 Q(off)
 Q(is_on)
+Q(Facade)
 
 Q(MicroBitButton)
 Q(button_a)

source/lib/iters.c

@@ -3,7 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2015 Mark Shannon
+ * Copyright (c) 2015/6 Mark Shannon
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -27,23 +27,20 @@
 #include "py/runtime.h"
 #include "lib/iters.h"
 
+
 typedef struct _repeat_iterator_t {
     mp_obj_base_t base;
     mp_obj_t iterable;
-    mp_obj_t iterator;
+    mp_int_t index;
 } repeat_iterator_t;
 
-STATIC mp_obj_t microbit_repeat_iter_next(mp_obj_t iter_in) {
+static mp_obj_t microbit_repeat_iter_next(mp_obj_t iter_in) {
     repeat_iterator_t *iter = (repeat_iterator_t *)iter_in;
-    mp_obj_t result = mp_iternext(iter->iterator);
-    if (result == MP_OBJ_STOP_ITERATION) {
-        iter->iterator = mp_getiter(iter->iterable);
-        result = mp_iternext(iter->iterator);
-        if (result == MP_OBJ_STOP_ITERATION) {
-            nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, "cannot repeat empty sequence"));
-        }
+    iter->index++;
+    if (iter->index >= mp_obj_get_int(mp_obj_len(iter->iterable))) {
+        iter->index = 0;
     }
-    return result;
+    return mp_obj_subscr(iter->iterable, MP_OBJ_NEW_SMALL_INT(iter->index), MP_OBJ_SENTINEL);
 }
 
 const mp_obj_type_t microbit_repeat_iterator_type = {
@@ -65,10 +62,9 @@ const mp_obj_type_t microbit_repeat_iterator_type = {
 };
 
 mp_obj_t microbit_repeat_iterator(mp_obj_t iterable) {
-    mp_obj_t iter = mp_getiter(iterable);
     repeat_iterator_t *result = m_new_obj(repeat_iterator_t);
     result->base.type = &microbit_repeat_iterator_type;
     result->iterable = iterable;
-    result->iterator = iter;
+    result->index = -1;
     return result;
 }

source/microbit/microbitdisplay.cpp

@@ -105,6 +105,7 @@ mp_obj_t microbit_display_show_func(mp_uint_t n_args, const mp_obj_t *pos_args,
                 goto single_image_immediate;
             }
         }
+        image = microbit_string_facade(image);
     } else if (mp_obj_get_type(image) == &microbit_image_type) {
         if (!clear && !loop) {
             goto single_image_immediate;
@@ -381,9 +382,10 @@ void microbit_display_animate(microbit_display_obj_t *self, mp_obj_t iterable, m
     MP_STATE_PORT(async_data)[0] = self; // so it doesn't get GC'd
     MP_STATE_PORT(async_data)[1] = async_iterator;
     wakeup_event = false;
-    async_mode = ASYNC_MODE_ANIMATION;
     mp_obj_t obj = mp_iternext_allow_raise(async_iterator);
     draw_object(obj);
+    async_tick = 0;
+    async_mode = ASYNC_MODE_ANIMATION;
     if (wait) {
         wait_for_event();
     }

source/microbit/microbitimage.cpp

@@ -564,14 +564,19 @@ STATIC mp_int_t get_pixel_from_font_data(const unsigned char *data, int x, int y
     return ((data[y]>>(4-x))&1);
 }
 
-microbit_image_obj_t *microbit_image_for_char(char c) {
+void microbit_image_set_from_char(greyscale_t *img, char c) {
     const unsigned char *data = get_font_data_from_char(c);
-    greyscale_t *result = greyscale_new(5,5);
     for (int x = 0; x < 5; ++x) {
         for (int y = 0; y < 5; ++y) {
-            result->setPixelValue(x, y, get_pixel_from_font_data(data, x, y)*MAX_BRIGHTNESS);
+            img->setPixelValue(x, y, get_pixel_from_font_data(data, x, y)*MAX_BRIGHTNESS);
         }
     }
+}
+
+
+microbit_image_obj_t *microbit_image_for_char(char c) {
+    greyscale_t *result = greyscale_new(5,5);
+    microbit_image_set_from_char(result, c);
     return (microbit_image_obj_t *)result;
 }
 
@@ -799,4 +804,114 @@ const mp_obj_type_t microbit_scrolling_string_iterator_type = {
     .locals_dict = NULL,
 };
 
+/** Facade types to present a string as a sequence of images.
+ * These are necessary to avoid allocation during iteration,
+ * which may happen in interrupt handlers.
+ */
+
+typedef struct _string_image_facade_t {
+    mp_obj_base_t base;
+    mp_obj_t string;
+    greyscale_t *image;
+} string_image_facade_t;
+
+static mp_obj_t string_image_facade_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t value) {
+    if (value == MP_OBJ_SENTINEL) {
+        // Fill in image
+        string_image_facade_t *self = (string_image_facade_t *)self_in;
+        mp_uint_t len;
+        const char *text = mp_obj_str_get_data(self->string, &len);
+        mp_uint_t index = mp_get_index(self->base.type, len, index_in, false);
+        microbit_image_set_from_char(self->image, text[index]);
+        return self->image;
+    } else {
+        return MP_OBJ_NULL; // op not supported
+    }
+}
+
+static mp_obj_t facade_unary_op(mp_uint_t op, mp_obj_t self_in) {
+    string_image_facade_t *self = (string_image_facade_t *)self_in;
+    switch (op) {
+        case MP_UNARY_OP_LEN:
+            return mp_obj_len(self->string);
+        default: return MP_OBJ_NULL; // op not supported
+    }
+}
+
+static mp_obj_t microbit_facade_iterator(mp_obj_t iterable);
+
+const mp_obj_type_t string_image_facade_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_Facade,
+    .print = NULL,
+    .make_new = NULL,
+    .call = NULL,
+    .unary_op = facade_unary_op,
+    .binary_op = NULL,
+    .attr = NULL,
+    .subscr = string_image_facade_subscr,
+    .getiter = microbit_facade_iterator,
+    .iternext = NULL,
+    .buffer_p = {NULL},
+    .stream_p = NULL,
+    .bases_tuple = NULL,
+    NULL
+};
+
+
+typedef struct _facade_iterator_t {
+    mp_obj_base_t base;
+    mp_obj_t string;
+    mp_uint_t index;
+    greyscale_t *image;
+} facade_iterator_t;
+
+mp_obj_t microbit_string_facade(mp_obj_t string) {
+    string_image_facade_t *result = m_new_obj(string_image_facade_t);
+    result->base.type = &string_image_facade_type;
+    result->string = string;
+    result->image = greyscale_new(5,5);
+    return result;
+}
+
+static mp_obj_t microbit_facade_iter_next(mp_obj_t iter_in) {
+    facade_iterator_t *iter = (facade_iterator_t *)iter_in;
+    mp_uint_t len;
+    const char *text = mp_obj_str_get_data(iter->string, &len);
+    if (iter->index >= len) {
+        return MP_OBJ_STOP_ITERATION;
+    }
+    microbit_image_set_from_char(iter->image, text[iter->index]);
+    iter->index++;
+    return iter->image;
+}
+
+const mp_obj_type_t microbit_facade_iterator_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_iterator,
+    .print = NULL,
+    .make_new = NULL,
+    .call = NULL,
+    .unary_op = NULL,
+    .binary_op = NULL,
+    .attr = NULL,
+    .subscr = NULL,
+    .getiter = mp_identity,
+    .iternext = microbit_facade_iter_next,
+    .buffer_p = {NULL},
+    .stream_p = NULL,
+    .bases_tuple = NULL,
+    NULL
+};
+
+mp_obj_t microbit_facade_iterator(mp_obj_t iterable_in) {
+    facade_iterator_t *result = m_new_obj(facade_iterator_t);
+    string_image_facade_t *iterable = (string_image_facade_t *)iterable_in;
+    result->base.type = &microbit_facade_iterator_type;
+    result->string = iterable->string;
+    result->image = iterable->image;
+    result->index = 0;
+    return result;
+}
+
 }