add a root_group property to the display, reset the REPL position when display.show(None) is called.

Author: Kevin Matocha

shared-bindings/displayio/Display.c

@@ -444,6 +444,23 @@ const mp_obj_property_t displayio_display_bus_obj = {
               MP_ROM_NONE},
 };
 
+//|     root_group: _Group
+//|     """The root group on the display."""
+//|
+//|
+STATIC mp_obj_t displayio_display_obj_get_root_group(mp_obj_t self_in) {
+    displayio_display_obj_t *self = native_display(self_in);
+    return common_hal_displayio_display_get_root_group(self);
+}
+MP_DEFINE_CONST_FUN_OBJ_1(displayio_display_get_root_group_obj, displayio_display_obj_get_root_group);
+
+const mp_obj_property_t displayio_display_root_group_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&displayio_display_get_root_group_obj,
+              MP_ROM_NONE,
+              MP_ROM_NONE},
+};
+
 
 //|     def fill_row(self, y: int, buffer: WriteableBuffer) -> WriteableBuffer:
 //|         """Extract the pixels from a single row
@@ -517,6 +534,7 @@ STATIC const mp_rom_map_elem_t displayio_display_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_height), MP_ROM_PTR(&displayio_display_height_obj) },
     { MP_ROM_QSTR(MP_QSTR_rotation), MP_ROM_PTR(&displayio_display_rotation_obj) },
     { MP_ROM_QSTR(MP_QSTR_bus), MP_ROM_PTR(&displayio_display_bus_obj) },
+    { MP_ROM_QSTR(MP_QSTR_root_group), MP_ROM_PTR(&displayio_display_root_group_obj) },
 };
 STATIC MP_DEFINE_CONST_DICT(displayio_display_locals_dict, displayio_display_locals_dict_table);
 

shared-bindings/displayio/Display.h

@@ -69,6 +69,6 @@ mp_float_t common_hal_displayio_display_get_brightness(displayio_display_obj_t *
 bool common_hal_displayio_display_set_brightness(displayio_display_obj_t *self, mp_float_t brightness);
 
 mp_obj_t common_hal_displayio_display_get_bus(displayio_display_obj_t *self);
-
+mp_obj_t common_hal_displayio_display_get_root_group(displayio_display_obj_t *self);
 
 #endif // MICROPY_INCLUDED_SHARED_BINDINGS_DISPLAYIO_DISPLAY_H

shared-bindings/supervisor/__init__.c

@@ -324,7 +324,6 @@ STATIC const mp_rom_map_elem_t supervisor_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_ticks_ms),  MP_ROM_PTR(&supervisor_ticks_ms_obj) },
     { MP_ROM_QSTR(MP_QSTR_get_previous_traceback),  MP_ROM_PTR(&supervisor_get_previous_traceback_obj) },
     { MP_ROM_QSTR(MP_QSTR_disable_ble_workflow),  MP_ROM_PTR(&supervisor_disable_ble_workflow_obj) },
-    { MP_ROM_QSTR(MP_QSTR_splash),  MP_ROM_PTR(&circuitpython_splash) },
     { MP_ROM_QSTR(MP_QSTR_reset_terminal),  MP_ROM_PTR(&supervisor_reset_terminal_obj) },
 };
 

shared-module/board/__init__.c

@@ -57,6 +57,7 @@ typedef struct {
 
 static const board_i2c_pin_t i2c_pin[CIRCUITPY_BOARD_I2C] = CIRCUITPY_BOARD_I2C_PIN;
 static busio_i2c_obj_t i2c_obj[CIRCUITPY_BOARD_I2C];
+static bool i2c_obj_created[CIRCUITPY_BOARD_I2C];
 
 bool common_hal_board_is_i2c(mp_obj_t obj) {
     for (uint8_t instance = 0; instance < CIRCUITPY_BOARD_I2C; instance++) {
@@ -68,7 +69,7 @@ bool common_hal_board_is_i2c(mp_obj_t obj) {
 }
 
 mp_obj_t common_hal_board_get_i2c(const mp_int_t instance) {
-    return &i2c_obj[instance];
+    return i2c_obj_created[instance] ? &i2c_obj[instance] : NULL;
 }
 
 mp_obj_t common_hal_board_create_i2c(const mp_int_t instance) {
@@ -85,6 +86,7 @@ mp_obj_t common_hal_board_create_i2c(const mp_int_t instance) {
 
     common_hal_busio_i2c_construct(self, i2c_pin[instance].scl, i2c_pin[instance].sda, 100000, 255);
 
+    i2c_obj_created[instance] = true;
     return &i2c_obj[instance];
 }
 #endif
@@ -101,6 +103,7 @@ typedef struct {
 
 static const board_spi_pin_t spi_pin[CIRCUITPY_BOARD_SPI] = CIRCUITPY_BOARD_SPI_PIN;
 static busio_spi_obj_t spi_obj[CIRCUITPY_BOARD_SPI];
+static bool spi_obj_created[CIRCUITPY_BOARD_SPI];
 
 bool common_hal_board_is_spi(mp_obj_t obj) {
     for (uint8_t instance = 0; instance < CIRCUITPY_BOARD_SPI; instance++) {
@@ -112,7 +115,7 @@ bool common_hal_board_is_spi(mp_obj_t obj) {
 }
 
 mp_obj_t common_hal_board_get_spi(const mp_int_t instance) {
-    return &spi_obj[instance];
+    return spi_obj_created[instance] ? &spi_obj[instance] : NULL;
 }
 
 mp_obj_t common_hal_board_create_spi(const mp_int_t instance) {
@@ -130,6 +133,7 @@ mp_obj_t common_hal_board_create_spi(const mp_int_t instance) {
 
     common_hal_busio_spi_construct(self, spi_pin[instance].clock, spi_pin[instance].mosi, spi_pin[instance].miso);
 
+    spi_obj_created[instance] = true;
     return &spi_obj[instance];
 }
 #endif
@@ -143,6 +147,7 @@ typedef struct {
 
 static const board_uart_pin_t uart_pin[CIRCUITPY_BOARD_UART] = CIRCUITPY_BOARD_UART_PIN;
 static busio_uart_obj_t uart_obj[CIRCUITPY_BOARD_UART];
+static bool uart_obj_created[CIRCUITPY_BOARD_UART];
 
 bool common_hal_board_is_uart(mp_obj_t obj) {
     for (uint8_t instance = 0; instance < CIRCUITPY_BOARD_UART; instance++) {
@@ -154,7 +159,7 @@ bool common_hal_board_is_uart(mp_obj_t obj) {
 }
 
 mp_obj_t common_hal_board_get_uart(const mp_int_t instance) {
-    return &uart_obj[instance];
+    return uart_obj_created[instance] ? &uart_obj[instance] : NULL;
 }
 
 mp_obj_t common_hal_board_create_uart(const mp_int_t instance) {
@@ -174,6 +179,7 @@ mp_obj_t common_hal_board_create_uart(const mp_int_t instance) {
     common_hal_busio_uart_construct(self, uart_pin[instance].tx, uart_pin[instance].rx,
         NULL, NULL, NULL, false, 9600, 8, BUSIO_UART_PARITY_NONE, 1, 1.0f, 64, NULL, false);
 
+    uart_obj_created[instance] = true;
     return &uart_obj[instance];
 }
 #endif
@@ -190,11 +196,12 @@ void reset_board_buses(void) {
             }
         }
         #endif
-        if (!common_hal_busio_i2c_deinited(&i2c_obj[instance])) {
+        if (i2c_obj_created[instance]) {
             // make sure I2C lock is not held over a soft reset
             common_hal_busio_i2c_unlock(&i2c_obj[instance]);
             if (!display_using_i2c) {
                 common_hal_busio_i2c_deinit(&i2c_obj[instance]);
+                i2c_obj_created[instance] = false;
             }
         }
     }
@@ -217,18 +224,22 @@ void reset_board_buses(void) {
             #endif
         }
         #endif
-        if (!common_hal_busio_spi_deinited(&spi_obj[instance])) {
+        if (spi_obj_created[instance]) {
             // make sure SPI lock is not held over a soft reset
             common_hal_busio_spi_unlock(&spi_obj[instance]);
             if (!display_using_spi) {
                 common_hal_busio_spi_deinit(&spi_obj[instance]);
+                spi_obj_created[instance] = false;
             }
         }
     }
     #endif
     #if CIRCUITPY_BOARD_UART
     for (uint8_t instance = 0; instance < CIRCUITPY_BOARD_UART; instance++) {
-        common_hal_busio_uart_deinit(&uart_obj[instance]);
+        if (uart_obj_created[instance]) {
+            common_hal_busio_uart_deinit(&uart_obj[instance]);
+            uart_obj_created[instance] = false;
+        }
     }
     #endif
 }

shared-module/displayio/Display.c

@@ -220,6 +220,10 @@ mp_obj_t common_hal_displayio_display_get_bus(displayio_display_obj_t *self) {
     return self->core.bus;
 }
 
+mp_obj_t common_hal_displayio_display_get_root_group(displayio_display_obj_t *self) {
+    return self->core.current_group;
+}
+
 STATIC const displayio_area_t *_get_refresh_areas(displayio_display_obj_t *self) {
     if (self->core.full_refresh) {
         self->core.area.next = NULL;

shared-module/displayio/display_core.c

@@ -163,12 +163,15 @@ void displayio_display_core_set_rotation(displayio_display_core_t *self,
 }
 
 bool displayio_display_core_show(displayio_display_core_t *self, displayio_group_t *root_group) {
-    if (root_group == NULL) {
-        if (!circuitpython_splash.in_group) {
-            root_group = &circuitpython_splash;
-        } else if (self->current_group == &circuitpython_splash) {
-            return true;
-        }
+
+    if (root_group == NULL) { // set the display to the REPL, reset REPL position and size
+        circuitpython_splash.in_group = false;
+        // force the circuit_python_splash out of any group (Note: could cause problems with the parent group)
+        circuitpython_splash.x = 0; // reset position in case someone moved it.
+        circuitpython_splash.y = 0;
+        supervisor_stop_terminal();
+        supervisor_start_terminal(self->width, self->height);
+        root_group = &circuitpython_splash;
     }
     if (root_group == self->current_group) {
         return true;

supervisor/shared/display.h

@@ -32,7 +32,6 @@
 #if CIRCUITPY_TERMINALIO
 
 #include "shared-bindings/displayio/Bitmap.h"
-#include "shared-bindings/displayio/Group.h"
 #include "shared-bindings/displayio/TileGrid.h"
 #include "shared-bindings/fontio/BuiltinFont.h"
 #include "shared-bindings/terminalio/Terminal.h"
@@ -46,7 +45,6 @@ extern const fontio_builtinfont_t supervisor_terminal_font;
 extern displayio_bitmap_t supervisor_terminal_font_bitmap;
 extern displayio_tilegrid_t supervisor_terminal_text_grid;
 extern terminalio_terminal_obj_t supervisor_terminal;
-extern displayio_group_t circuitpython_splash;
 
 #endif
 

tests/circuitpython-manual/audiobusio/i2s_sample_loop.py

@@ -19,7 +19,7 @@
 # signed 16 bit
 s16 = array.array("h", [0] * length)
 for i in range(length):
-    s16[i] = int(math.sin(math.pi * 2 * i / length) * (2**15))
+    s16[i] = int(math.sin(math.pi * 2 * i / length) * (2 ** 15))
     print(s16[i])
 
 sample = audiocore.RawSample(s16, sample_rate=8000)

tests/circuitpython-manual/audiopwmio/single_buffer_loop.py

@@ -19,29 +19,29 @@
 # unsigned 8 bit
 u8 = array.array("B", [0] * length)
 for i in range(length):
-    u8[i] = int(math.sin(math.pi * 2 * i / length) * (2**7) + 2**7)
+    u8[i] = int(math.sin(math.pi * 2 * i / length) * (2 ** 7) + 2 ** 7)
 
 samples.append(audiocore.RawSample(u8, sample_rate=4000))
 
 # signed 8 bit
 s8 = array.array("b", [0] * length)
 for i in range(length):
-    s8[i] = int(math.sin(math.pi * 2 * i / length) * (2**7))
+    s8[i] = int(math.sin(math.pi * 2 * i / length) * (2 ** 7))
 
 samples.append(audiocore.RawSample(s8, sample_rate=16000))
 
 # unsigned 16 bit
 u16 = array.array("H", [0] * length)
 for i in range(length):
-    u16[i] = int(math.sin(math.pi * 2 * i / length) * (2**15) + 2**15)
+    u16[i] = int(math.sin(math.pi * 2 * i / length) * (2 ** 15) + 2 ** 15)
 
 samples.append(audiocore.RawSample(u16, sample_rate=8000))
 
 
 # signed 16 bit
 s16 = array.array("h", [0] * length)
 for i in range(length):
-    s16[i] = int(math.sin(math.pi * 2 * i / length) * (2**15))
+    s16[i] = int(math.sin(math.pi * 2 * i / length) * (2 ** 15))
 
 samples.append(audiocore.RawSample(s16, sample_rate=8000))
 

tests/cpydiff/modules_random_randint.py

@@ -8,5 +8,5 @@
 import random
 
 
-x = random.randint(2**128 - 1, 2**128)
+x = random.randint(2 ** 128 - 1, 2 ** 128)
 print("x={}".format(x))

tests/float/complex1.py

@@ -27,15 +27,15 @@
 print(1j / 2)
 print((1j / 2j).real)
 print(1j / (1 + 2j))
-ans = 0j**0
+ans = 0j ** 0
 print("%.5g %.5g" % (ans.real, ans.imag))
-ans = 0j**1
+ans = 0j ** 1
 print("%.5g %.5g" % (ans.real, ans.imag))
-ans = 0j**0j
+ans = 0j ** 0j
 print("%.5g %.5g" % (ans.real, ans.imag))
-ans = 1j**2.5
+ans = 1j ** 2.5
 print("%.5g %.5g" % (ans.real, ans.imag))
-ans = 1j**2.5j
+ans = 1j ** 2.5j
 print("%.5g %.5g" % (ans.real, ans.imag))
 
 # comparison
@@ -116,10 +116,10 @@
 
 # zero division via power
 try:
-    0j**-1
+    0j ** -1
 except ZeroDivisionError:
     print("ZeroDivisionError")
 try:
-    0j**1j
+    0j ** 1j
 except ZeroDivisionError:
     print("ZeroDivisionError")

tests/float/float1.py

@@ -88,7 +88,7 @@
     print("ZeroDivisionError")
 
 try:
-    0.0**-1
+    0.0 ** -1
 except ZeroDivisionError:
     print("ZeroDivisionError")
 

tests/float/float2int_doubleprec_intbig.py

@@ -35,16 +35,16 @@
     print(int(1418774543.0))
     print("%d" % 1418774543.0)
     if ll_type == 3:
-        print(int(2.0**100))
-        print("%d" % 2.0**100)
+        print(int(2.0 ** 100))
+        print("%d" % 2.0 ** 100)
 else:
     print(int(1073741823.0))
     print("%d" % 1073741823.0)
 
 testpass = True
 p2_rng = ((30, 63, 1024), (62, 63, 1024))[is_64bit][ll_type]
 for i in range(0, p2_rng):
-    bitcnt = len(bin(int(2.0**i))) - 3
+    bitcnt = len(bin(int(2.0 ** i))) - 3
     if i != bitcnt:
         print("fail: 2**%u was %u bits long" % (i, bitcnt))
         testpass = False
@@ -53,7 +53,7 @@
 testpass = True
 p10_rng = ((9, 18, 23), (18, 18, 23))[is_64bit][ll_type]
 for i in range(0, p10_rng):
-    digcnt = len(str(int(10.0**i))) - 1
+    digcnt = len(str(int(10.0 ** i))) - 1
     if i != digcnt:
         print("fail: 10**%u was %u digits long" % (i, digcnt))
         testpass = False
@@ -72,28 +72,28 @@ def fp2int_test(num, name, should_fail):
 if ll_type != 2:
     if ll_type == 0:
         if is_64bit:
-            neg_bad_fp = -1.00000005 * 2.0**62.0
-            pos_bad_fp = 2.0**62.0
-            neg_good_fp = -(2.0**62.0)
-            pos_good_fp = 0.99999993 * 2.0**62.0
+            neg_bad_fp = -1.00000005 * 2.0 ** 62.0
+            pos_bad_fp = 2.0 ** 62.0
+            neg_good_fp = -(2.0 ** 62.0)
+            pos_good_fp = 0.99999993 * 2.0 ** 62.0
         else:
-            neg_bad_fp = -1.00000005 * 2.0**30.0
-            pos_bad_fp = 2.0**30.0
-            neg_good_fp = -(2.0**30.0)
-            pos_good_fp = 0.9999999499 * 2.0**30.0
+            neg_bad_fp = -1.00000005 * 2.0 ** 30.0
+            pos_bad_fp = 2.0 ** 30.0
+            neg_good_fp = -(2.0 ** 30.0)
+            pos_good_fp = 0.9999999499 * 2.0 ** 30.0
     else:
-        neg_bad_fp = -0.51 * 2.0**64.0
-        pos_bad_fp = 2.0**63.0
-        neg_good_fp = -(2.0**63.0)
-        pos_good_fp = 1.9999998 * 2.0**62.0
+        neg_bad_fp = -0.51 * 2.0 ** 64.0
+        pos_bad_fp = 2.0 ** 63.0
+        neg_good_fp = -(2.0 ** 63.0)
+        pos_good_fp = 1.9999998 * 2.0 ** 62.0
 
     fp2int_test(neg_bad_fp, "neg bad", True)
     fp2int_test(pos_bad_fp, "pos bad", True)
     fp2int_test(neg_good_fp, "neg good", False)
     fp2int_test(pos_good_fp, "pos good", False)
 else:
-    fp2int_test(-1.9999999999999981 * 2.0**1023.0, "large neg", False)
-    fp2int_test(1.9999999999999981 * 2.0**1023.0, "large pos", False)
+    fp2int_test(-1.9999999999999981 * 2.0 ** 1023.0, "large neg", False)
+    fp2int_test(1.9999999999999981 * 2.0 ** 1023.0, "large pos", False)
 
 fp2int_test(float("inf"), "inf test", True)
 fp2int_test(float("-inf"), "inf test", True)