Track creation of board.I2C(), etc.

dhalbert · dhalbert · commit 25707d311a51 · 2022-01-30T23:20:51.000-05:00
diff --git a/shared-module/board/__init__.c b/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
 }

Original file line number	Diff line number	Diff line change
`@@ -57,6 +57,7 @@ typedef struct {`
`57`	`57`
`58`	`58`	`static const board_i2c_pin_t i2c_pin[CIRCUITPY_BOARD_I2C] = CIRCUITPY_BOARD_I2C_PIN;`
`59`	`59`	`static busio_i2c_obj_t i2c_obj[CIRCUITPY_BOARD_I2C];`
	`60`	`+static bool i2c_obj_created[CIRCUITPY_BOARD_I2C];`
`60`	`61`
`61`	`62`	`bool common_hal_board_is_i2c(mp_obj_t obj) {`
`62`	`63`	`for (uint8_t instance = 0; instance < CIRCUITPY_BOARD_I2C; instance++) {`
`@@ -68,7 +69,7 @@ bool common_hal_board_is_i2c(mp_obj_t obj) {`
`68`	`69`	`}`
`69`	`70`
`70`	`71`	`mp_obj_t common_hal_board_get_i2c(const mp_int_t instance) {`
`71`		`- return &i2c_obj[instance];`
	`72`	`+ return i2c_obj_created[instance] ? &i2c_obj[instance] : NULL;`
`72`	`73`	`}`
`73`	`74`
`74`	`75`	`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) {`
`85`	`86`
`86`	`87`	`common_hal_busio_i2c_construct(self, i2c_pin[instance].scl, i2c_pin[instance].sda, 100000, 255);`
`87`	`88`
	`89`	`+ i2c_obj_created[instance] = true;`
`88`	`90`	`return &i2c_obj[instance];`
`89`	`91`	`}`
`90`	`92`	`#endif`
`@@ -101,6 +103,7 @@ typedef struct {`
`101`	`103`
`102`	`104`	`static const board_spi_pin_t spi_pin[CIRCUITPY_BOARD_SPI] = CIRCUITPY_BOARD_SPI_PIN;`
`103`	`105`	`static busio_spi_obj_t spi_obj[CIRCUITPY_BOARD_SPI];`
	`106`	`+static bool spi_obj_created[CIRCUITPY_BOARD_SPI];`
`104`	`107`
`105`	`108`	`bool common_hal_board_is_spi(mp_obj_t obj) {`
`106`	`109`	`for (uint8_t instance = 0; instance < CIRCUITPY_BOARD_SPI; instance++) {`
`@@ -112,7 +115,7 @@ bool common_hal_board_is_spi(mp_obj_t obj) {`
`112`	`115`	`}`
`113`	`116`
`114`	`117`	`mp_obj_t common_hal_board_get_spi(const mp_int_t instance) {`
`115`		`- return &spi_obj[instance];`
	`118`	`+ return spi_obj_created[instance] ? &spi_obj[instance] : NULL;`
`116`	`119`	`}`
`117`	`120`
`118`	`121`	`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) {`
`130`	`133`
`131`	`134`	`common_hal_busio_spi_construct(self, spi_pin[instance].clock, spi_pin[instance].mosi, spi_pin[instance].miso);`
`132`	`135`
	`136`	`+ spi_obj_created[instance] = true;`
`133`	`137`	`return &spi_obj[instance];`
`134`	`138`	`}`
`135`	`139`	`#endif`
`@@ -143,6 +147,7 @@ typedef struct {`
`143`	`147`
`144`	`148`	`static const board_uart_pin_t uart_pin[CIRCUITPY_BOARD_UART] = CIRCUITPY_BOARD_UART_PIN;`
`145`	`149`	`static busio_uart_obj_t uart_obj[CIRCUITPY_BOARD_UART];`
	`150`	`+static bool uart_obj_created[CIRCUITPY_BOARD_UART];`
`146`	`151`
`147`	`152`	`bool common_hal_board_is_uart(mp_obj_t obj) {`
`148`	`153`	`for (uint8_t instance = 0; instance < CIRCUITPY_BOARD_UART; instance++) {`
`@@ -154,7 +159,7 @@ bool common_hal_board_is_uart(mp_obj_t obj) {`
`154`	`159`	`}`
`155`	`160`
`156`	`161`	`mp_obj_t common_hal_board_get_uart(const mp_int_t instance) {`
`157`		`- return &uart_obj[instance];`
	`162`	`+ return uart_obj_created[instance] ? &uart_obj[instance] : NULL;`
`158`	`163`	`}`
`159`	`164`
`160`	`165`	`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) {`
`174`	`179`	`common_hal_busio_uart_construct(self, uart_pin[instance].tx, uart_pin[instance].rx,`
`175`	`180`	`NULL, NULL, NULL, false, 9600, 8, BUSIO_UART_PARITY_NONE, 1, 1.0f, 64, NULL, false);`
`176`	`181`
	`182`	`+ uart_obj_created[instance] = true;`
`177`	`183`	`return &uart_obj[instance];`
`178`	`184`	`}`
`179`	`185`	`#endif`
`@@ -190,11 +196,12 @@ void reset_board_buses(void) {`
`190`	`196`	`}`
`191`	`197`	`}`
`192`	`198`	`#endif`
`193`		`- if (!common_hal_busio_i2c_deinited(&i2c_obj[instance])) {`
	`199`	`+ if (i2c_obj_created[instance]) {`
`194`	`200`	`// make sure I2C lock is not held over a soft reset`
`195`	`201`	`common_hal_busio_i2c_unlock(&i2c_obj[instance]);`
`196`	`202`	`if (!display_using_i2c) {`
`197`	`203`	`common_hal_busio_i2c_deinit(&i2c_obj[instance]);`
	`204`	`+ i2c_obj_created[instance] = false;`
`198`	`205`	`}`
`199`	`206`	`}`
`200`	`207`	`}`
`@@ -217,18 +224,22 @@ void reset_board_buses(void) {`
`217`	`224`	`#endif`
`218`	`225`	`}`
`219`	`226`	`#endif`
`220`		`- if (!common_hal_busio_spi_deinited(&spi_obj[instance])) {`
	`227`	`+ if (spi_obj_created[instance]) {`
`221`	`228`	`// make sure SPI lock is not held over a soft reset`
`222`	`229`	`common_hal_busio_spi_unlock(&spi_obj[instance]);`
`223`	`230`	`if (!display_using_spi) {`
`224`	`231`	`common_hal_busio_spi_deinit(&spi_obj[instance]);`
	`232`	`+ spi_obj_created[instance] = false;`
`225`	`233`	`}`
`226`	`234`	`}`
`227`	`235`	`}`
`228`	`236`	`#endif`
`229`	`237`	`#if CIRCUITPY_BOARD_UART`
`230`	`238`	`for (uint8_t instance = 0; instance < CIRCUITPY_BOARD_UART; instance++) {`
`231`		`- common_hal_busio_uart_deinit(&uart_obj[instance]);`
	`239`	`+ if (uart_obj_created[instance]) {`
	`240`	`+ common_hal_busio_uart_deinit(&uart_obj[instance]);`
	`241`	`+ uart_obj_created[instance] = false;`
	`242`	`+ }`
`232`	`243`	`}`
`233`	`244`	`#endif`
`234`	`245`	`}`