Merge pull request adafruit#2055 from jepler/run-background-tasks

dhalbert · web-flow · commit 0ddfbb0c2043 · 2019-08-19T17:15:20.000-04:00
Implement and use RUN_BACKGROUND_TASKS in place of MICROPY_VM_HOOK_LOOP
diff --git a/ports/atmel-samd/common-hal/audiobusio/PDMIn.c b/ports/atmel-samd/common-hal/audiobusio/PDMIn.c
@@ -408,9 +408,7 @@ uint32_t common_hal_audiobusio_pdmin_record_to_buffer(audiobusio_pdmin_obj_t* se
         // If wait_counts exceeds the max count, buffer has probably stopped filling;
         // DMA may have missed an I2S trigger event.
         while (!event_interrupt_active(event_channel) && ++wait_counts < MAX_WAIT_COUNTS) {
-            #ifdef MICROPY_VM_HOOK_LOOP
-                MICROPY_VM_HOOK_LOOP
-            #endif
+            RUN_BACKGROUND_TASKS;
         }
 
         // The mic is running all the time, so we don't need to wait the usual 10msec or 100msec
diff --git a/ports/atmel-samd/common-hal/audioio/AudioOut.c b/ports/atmel-samd/common-hal/audioio/AudioOut.c
@@ -69,9 +69,7 @@ static void ramp_value(uint16_t start, uint16_t end) {
         DAC->DATA.reg = value;
         DAC->DATABUF.reg = value;
         common_hal_mcu_delay_us(50);
-        #ifdef MICROPY_VM_HOOK_LOOP
-            MICROPY_VM_HOOK_LOOP
-        #endif
+        RUN_BACKGROUND_TASKS;
     }
 }
 #endif
@@ -94,9 +92,7 @@ static void ramp_value(uint16_t start, uint16_t end) {
         DAC->DATABUF[1].reg = value;
 
         common_hal_mcu_delay_us(50);
-        #ifdef MICROPY_VM_HOOK_LOOP
-            MICROPY_VM_HOOK_LOOP
-        #endif
+        RUN_BACKGROUND_TASKS;
     }
 }
 #endif
diff --git a/ports/atmel-samd/common-hal/busio/UART.c b/ports/atmel-samd/common-hal/busio/UART.c
@@ -291,13 +291,11 @@ size_t common_hal_busio_uart_read(busio_uart_obj_t *self, uint8_t *data, size_t
             // Reset the timeout on every character read.
             start_ticks = ticks_ms;
         }
-#ifdef MICROPY_VM_HOOK_LOOP
-        MICROPY_VM_HOOK_LOOP ;
+        RUN_BACKGROUND_TASKS;
         // Allow user to break out of a timeout with a KeyboardInterrupt.
         if (mp_hal_is_interrupted()) {
             break;
         }
-#endif
         // If we are zero timeout, make sure we don't loop again (in the event
         // we read in under 1ms)
         if (self->timeout_ms == 0) {
@@ -339,9 +337,7 @@ size_t common_hal_busio_uart_write(busio_uart_obj_t *self, const uint8_t *data,
             done = true;
             break;
         }
-        #ifdef MICROPY_VM_HOOK_LOOP
-            MICROPY_VM_HOOK_LOOP
-        #endif
+        RUN_BACKGROUND_TASKS;
     }
 
     if (!done) {
diff --git a/ports/atmel-samd/common-hal/pulseio/PulseOut.c b/ports/atmel-samd/common-hal/pulseio/PulseOut.c
@@ -198,9 +198,7 @@ void common_hal_pulseio_pulseout_send(pulseio_pulseout_obj_t* self, uint16_t* pu
     while(pulse_index < length) {
         // Do other things while we wait. The interrupts will handle sending the
         // signal.
-        #ifdef MICROPY_VM_HOOK_LOOP
-            MICROPY_VM_HOOK_LOOP
-        #endif
+        RUN_BACKGROUND_TASKS;
     }
 
     tc->COUNT16.CTRLBSET.reg = TC_CTRLBSET_CMD_STOP;
diff --git a/ports/atmel-samd/common-hal/touchio/TouchIn.c b/ports/atmel-samd/common-hal/touchio/TouchIn.c
@@ -51,9 +51,7 @@ static uint16_t get_raw_reading(touchio_touchin_obj_t *self) {
 
     while (!adafruit_ptc_is_conversion_finished(PTC)) {
         // wait
-        #ifdef MICROPY_VM_HOOK_LOOP
-            MICROPY_VM_HOOK_LOOP
-        #endif
+        RUN_BACKGROUND_TASKS;
     }
 
     return adafruit_ptc_get_conversion_result(PTC);
diff --git a/ports/atmel-samd/mphalport.c b/ports/atmel-samd/mphalport.c
@@ -53,9 +53,7 @@ void mp_hal_delay_ms(mp_uint_t delay) {
     uint64_t start_tick = ticks_ms;
     uint64_t duration = 0;
     while (duration < delay) {
-        #ifdef MICROPY_VM_HOOK_LOOP
-            MICROPY_VM_HOOK_LOOP
-        #endif
+        RUN_BACKGROUND_TASKS;
         // Check to see if we've been CTRL-Ced by autoreload or the user.
         if(MP_STATE_VM(mp_pending_exception) == MP_OBJ_FROM_PTR(&MP_STATE_VM(mp_kbd_exception)) ||
            MP_STATE_VM(mp_pending_exception) == MP_OBJ_FROM_PTR(&MP_STATE_VM(mp_reload_exception))) {
diff --git a/ports/nrf/bluetooth/ble_uart.c b/ports/nrf/bluetooth/ble_uart.c
@@ -138,9 +138,7 @@ void ble_uart_init(void) {
     m_cccd_enabled = false;
 
     while (!m_cccd_enabled) {
-#ifdef MICROPY_VM_HOOK_LOOP
-    MICROPY_VM_HOOK_LOOP
-#endif
+        RUN_BACKGROUND_TASKS;
     }
 }
 
@@ -150,9 +148,7 @@ bool ble_uart_connected(void) {
 
 char ble_uart_rx_chr(void) {
     while (isBufferEmpty(&m_rx_ring_buffer)) {
-#ifdef MICROPY_VM_HOOK_LOOP
-    MICROPY_VM_HOOK_LOOP
-#endif
+        RUN_BACKGROUND_TASKS;
     }
 
     uint8_t byte;
diff --git a/ports/nrf/common-hal/bleio/Central.c b/ports/nrf/common-hal/bleio/Central.c
@@ -115,7 +115,7 @@ void common_hal_bleio_central_connect(bleio_central_obj_t *self, bleio_address_o
     }
 
     while (self->waiting_to_connect) {
-        MICROPY_VM_HOOK_LOOP;
+        RUN_BACKGROUND_TASKS;
     }
 
     if (self->conn_handle == BLE_CONN_HANDLE_INVALID) {
diff --git a/ports/nrf/common-hal/bleio/Characteristic.c b/ports/nrf/common-hal/bleio/Characteristic.c
@@ -94,7 +94,7 @@ STATIC void characteristic_gatts_notify_indicate(uint16_t handle, uint16_t conn_
         // TX buffer is full
         // We could wait for an event indicating the write is complete, but just retrying is easier.
         if (err_code == NRF_ERROR_RESOURCES) {
-            MICROPY_VM_HOOK_LOOP;
+            RUN_BACKGROUND_TASKS;
             continue;
         }
 
@@ -118,7 +118,7 @@ STATIC void characteristic_gattc_read(bleio_characteristic_obj_t *characteristic
     }
 
     while (m_read_characteristic != NULL) {
-        MICROPY_VM_HOOK_LOOP;
+        RUN_BACKGROUND_TASKS;
     }
 
     ble_drv_remove_event_handler(characteristic_on_gattc_read_rsp_evt, characteristic);
@@ -258,7 +258,7 @@ void common_hal_bleio_characteristic_set_cccd(bleio_characteristic_obj_t *self,
         // Write without reponse will return NRF_ERROR_RESOURCES if too many writes are pending.
         if (err_code == NRF_ERROR_BUSY || err_code == NRF_ERROR_RESOURCES) {
             // We could wait for an event indicating the write is complete, but just retrying is easier.
-            MICROPY_VM_HOOK_LOOP;
+            RUN_BACKGROUND_TASKS;
             continue;
         }
 
diff --git a/ports/nrf/common-hal/bleio/CharacteristicBuffer.c b/ports/nrf/common-hal/bleio/CharacteristicBuffer.c
@@ -99,7 +99,7 @@ int common_hal_bleio_characteristic_buffer_read(bleio_characteristic_buffer_obj_
 
     // Wait for all bytes received or timeout
     while ( (ringbuf_count(&self->ringbuf) < len) && (ticks_ms - start_ticks < self->timeout_ms) ) {
-        MICROPY_VM_HOOK_LOOP;
+        RUN_BACKGROUND_TASKS;
         // Allow user to break out of a timeout with a KeyboardInterrupt.
         if ( mp_hal_is_interrupted() ) {
             return 0;
diff --git a/ports/nrf/common-hal/busio/UART.c b/ports/nrf/common-hal/busio/UART.c
@@ -235,13 +235,11 @@ size_t common_hal_busio_uart_read(busio_uart_obj_t *self, uint8_t *data, size_t
 
     // Wait for all bytes received or timeout
     while ( (ringbuf_count(&self->rbuf) < len) && (ticks_ms - start_ticks < self->timeout_ms) ) {
-#ifdef MICROPY_VM_HOOK_LOOP
-        MICROPY_VM_HOOK_LOOP ;
+        RUN_BACKGROUND_TASKS;
         // Allow user to break out of a timeout with a KeyboardInterrupt.
         if ( mp_hal_is_interrupted() ) {
             return 0;
         }
-#endif
     }
 
     // prevent conflict with uart irq
@@ -271,9 +269,7 @@ size_t common_hal_busio_uart_write (busio_uart_obj_t *self, const uint8_t *data,
 
     // Wait for on-going transfer to complete
     while ( nrfx_uarte_tx_in_progress(self->uarte) && (ticks_ms - start_ticks < self->timeout_ms) ) {
-#ifdef MICROPY_VM_HOOK_LOOP
-        MICROPY_VM_HOOK_LOOP
-#endif
+        RUN_BACKGROUND_TASKS;
     }
 
     // Time up
@@ -295,9 +291,7 @@ size_t common_hal_busio_uart_write (busio_uart_obj_t *self, const uint8_t *data,
     (*errcode) = 0;
 
     while ( nrfx_uarte_tx_in_progress(self->uarte) && (ticks_ms - start_ticks < self->timeout_ms) ) {
-#ifdef MICROPY_VM_HOOK_LOOP
-        MICROPY_VM_HOOK_LOOP
-#endif
+        RUN_BACKGROUND_TASKS;
     }
 
     if ( !nrfx_is_in_ram(data) ) {
diff --git a/ports/nrf/common-hal/neopixel_write/__init__.c b/ports/nrf/common-hal/neopixel_write/__init__.c
@@ -200,9 +200,7 @@ void common_hal_neopixel_write (const digitalio_digitalinout_obj_t* digitalinout
 
         // But we have to wait for the flag to be set.
         while ( !nrf_pwm_event_check(pwm, NRF_PWM_EVENT_SEQEND0) ) {
-#ifdef MICROPY_VM_HOOK_LOOP
-            MICROPY_VM_HOOK_LOOP
-#endif
+            RUN_BACKGROUND_TASKS;
         }
 
         // Before leave we clear the flag for the event.
diff --git a/ports/nrf/common-hal/pulseio/PulseOut.c b/ports/nrf/common-hal/pulseio/PulseOut.c
@@ -155,9 +155,7 @@ void common_hal_pulseio_pulseout_send(pulseio_pulseout_obj_t* self, uint16_t* pu
     while(pulse_array_index < length) {
         // Do other things while we wait. The interrupts will handle sending the
         // signal.
-        #ifdef MICROPY_VM_HOOK_LOOP
-            MICROPY_VM_HOOK_LOOP
-        #endif
+        RUN_BACKGROUND_TASKS;
     }
 
     nrfx_timer_disable(timer);
diff --git a/ports/nrf/mphalport.c b/ports/nrf/mphalport.c
@@ -39,9 +39,7 @@ void mp_hal_delay_ms(mp_uint_t delay) {
     uint64_t start_tick = ticks_ms;
     uint64_t duration = 0;
     while (duration < delay) {
-        #ifdef MICROPY_VM_HOOK_LOOP
-            MICROPY_VM_HOOK_LOOP
-        #endif
+        RUN_BACKGROUND_TASKS;
         // Check to see if we've been CTRL-Ced by autoreload or the user.
         if(MP_STATE_VM(mp_pending_exception) == MP_OBJ_FROM_PTR(&MP_STATE_VM(mp_kbd_exception)) ||
            MP_STATE_VM(mp_pending_exception) == MP_OBJ_FROM_PTR(&MP_STATE_VM(mp_reload_exception))) {
diff --git a/ports/nrf/sd_mutex.c b/ports/nrf/sd_mutex.c
@@ -37,9 +37,7 @@ void sd_mutex_acquire_check(nrf_mutex_t* p_mutex) {
 
 void sd_mutex_acquire_wait(nrf_mutex_t* p_mutex) {
     while (sd_mutex_acquire(p_mutex) == NRF_ERROR_SOC_MUTEX_ALREADY_TAKEN) {
-#ifdef MICROPY_VM_HOOK_LOOP
-    MICROPY_VM_HOOK_LOOP
-#endif
+        RUN_BACKGROUND_TASKS;
     }
 }
 
diff --git a/py/circuitpy_mpconfig.h b/py/circuitpy_mpconfig.h
@@ -596,8 +596,8 @@ extern const struct _mp_obj_module_t ustack_module;
       WIZNET_MODULE \
     PEW_MODULE \
     PIXELBUF_MODULE \
-    PULSEIO_MODULE \
     PS2IO_MODULE \
+    PULSEIO_MODULE \
     RANDOM_MODULE \
     RE_MODULE \
     ROTARYIO_MODULE \
@@ -645,6 +645,7 @@ extern const struct _mp_obj_module_t ustack_module;
     NETWORK_ROOT_POINTERS \
 
 void run_background_tasks(void);
+#define RUN_BACKGROUND_TASKS (run_background_tasks())
 
 // TODO: Used in wiznet5k driver, but may not be needed in the long run.
 #define MICROPY_THREAD_YIELD()
diff --git a/shared-bindings/_stage/__init__.c b/shared-bindings/_stage/__init__.c
@@ -96,9 +96,7 @@ STATIC mp_obj_t stage_render(size_t n_args, const mp_obj_t *args) {
     }
 
     while (!displayio_display_begin_transaction(display)) {
-#ifdef MICROPY_VM_HOOK_LOOP
-        MICROPY_VM_HOOK_LOOP ;
-#endif
+        RUN_BACKGROUND_TASKS;
     }
     displayio_area_t area;
     area.x1 = x0;
diff --git a/shared-bindings/displayio/FourWire.c b/shared-bindings/displayio/FourWire.c
@@ -119,9 +119,7 @@ STATIC mp_obj_t displayio_fourwire_obj_send(mp_obj_t self, mp_obj_t command_obj,
 
     // Wait for display bus to be available.
     while (!common_hal_displayio_fourwire_begin_transaction(self)) {
-#ifdef MICROPY_VM_HOOK_LOOP
-        MICROPY_VM_HOOK_LOOP ;
-#endif
+        RUN_BACKGROUND_TASKS;
     }
     common_hal_displayio_fourwire_send(self, true, &command, 1);
     common_hal_displayio_fourwire_send(self, false, ((uint8_t*) bufinfo.buf), bufinfo.len);
diff --git a/shared-bindings/displayio/I2CDisplay.c b/shared-bindings/displayio/I2CDisplay.c
@@ -111,9 +111,7 @@ STATIC mp_obj_t displayio_i2cdisplay_obj_send(mp_obj_t self, mp_obj_t command_ob
 
     // Wait for display bus to be available.
     while (!common_hal_displayio_i2cdisplay_begin_transaction(self)) {
-#ifdef MICROPY_VM_HOOK_LOOP
-        MICROPY_VM_HOOK_LOOP ;
-#endif
+        RUN_BACKGROUND_TASKS;
     }
     uint8_t full_command[bufinfo.len + 1];
     full_command[0] = command;
diff --git a/shared-bindings/displayio/ParallelBus.c b/shared-bindings/displayio/ParallelBus.c
@@ -122,9 +122,7 @@ STATIC mp_obj_t displayio_parallelbus_obj_send(mp_obj_t self, mp_obj_t command_o
 
     // Wait for display bus to be available.
     while (!common_hal_displayio_parallelbus_begin_transaction(self)) {
-#ifdef MICROPY_VM_HOOK_LOOP
-        MICROPY_VM_HOOK_LOOP ;
-#endif
+        RUN_BACKGROUND_TASKS;
     }
     common_hal_displayio_parallelbus_send(self, true, &command, 1);
     common_hal_displayio_parallelbus_send(self, false, ((uint8_t*) bufinfo.buf), bufinfo.len);
diff --git a/shared-bindings/i2cslave/I2CSlave.c b/shared-bindings/i2cslave/I2CSlave.c
@@ -182,7 +182,7 @@ STATIC mp_obj_t i2cslave_i2c_slave_request(size_t n_args, const mp_obj_t *pos_ar
         bool is_read;
         bool is_restart;
 
-        MICROPY_VM_HOOK_LOOP
+        RUN_BACKGROUND_TASKS;
         if (mp_hal_is_interrupted()) {
             return mp_const_none;
         }
@@ -337,7 +337,7 @@ STATIC mp_obj_t i2cslave_i2c_slave_request_read(size_t n_args, const mp_obj_t *p
     uint8_t *buffer = NULL;
     uint64_t timeout_end = common_hal_time_monotonic() + 10 * 1000;
     while (common_hal_time_monotonic() < timeout_end) {
-        MICROPY_VM_HOOK_LOOP
+        RUN_BACKGROUND_TASKS;
         if (mp_hal_is_interrupted()) {
             break;
         }
@@ -382,7 +382,7 @@ STATIC mp_obj_t i2cslave_i2c_slave_request_write(mp_obj_t self_in, mp_obj_t buf_
     mp_get_buffer_raise(buf_in, &bufinfo, MP_BUFFER_READ);
 
     for (size_t i = 0; i < bufinfo.len; i++) {
-        MICROPY_VM_HOOK_LOOP
+        RUN_BACKGROUND_TASKS;
         if (mp_hal_is_interrupted()) {
             break;
         }
diff --git a/shared-module/displayio/Display.c b/shared-module/displayio/Display.c
@@ -85,9 +85,7 @@ void common_hal_displayio_display_construct(displayio_display_obj_t* self,
 
     uint32_t i = 0;
     while (!self->begin_transaction(self->bus)) {
-#ifdef MICROPY_VM_HOOK_LOOP
-        MICROPY_VM_HOOK_LOOP ;
-#endif
+        RUN_BACKGROUND_TASKS;
     }
     while (i < init_sequence_len) {
         uint8_t *cmd = init_sequence + i;
@@ -242,7 +240,7 @@ int32_t common_hal_displayio_display_wait_for_frame(displayio_display_obj_t* sel
     uint64_t last_refresh = self->last_refresh;
     // Don't try to refresh if we got an exception.
     while (last_refresh == self->last_refresh && MP_STATE_VM(mp_pending_exception) == NULL) {
-        MICROPY_VM_HOOK_LOOP
+        RUN_BACKGROUND_TASKS;
     }
     return 0;
 }

Original file line number	Diff line number	Diff line change
`@@ -69,9 +69,7 @@ static void ramp_value(uint16_t start, uint16_t end) {`
`69`	`69`	`DAC->DATA.reg = value;`
`70`	`70`	`DAC->DATABUF.reg = value;`
`71`	`71`	`common_hal_mcu_delay_us(50);`
`72`		`- #ifdef MICROPY_VM_HOOK_LOOP`
`73`		`- MICROPY_VM_HOOK_LOOP`
`74`		`- #endif`
	`72`	`+ RUN_BACKGROUND_TASKS;`
`75`	`73`	`}`
`76`	`74`	`}`
`77`	`75`	`#endif`
`@@ -94,9 +92,7 @@ static void ramp_value(uint16_t start, uint16_t end) {`
`94`	`92`	`DAC->DATABUF[1].reg = value;`
`95`	`93`
`96`	`94`	`common_hal_mcu_delay_us(50);`
`97`		`- #ifdef MICROPY_VM_HOOK_LOOP`
`98`		`- MICROPY_VM_HOOK_LOOP`
`99`		`- #endif`
	`95`	`+ RUN_BACKGROUND_TASKS;`
`100`	`96`	`}`
`101`	`97`	`}`
`102`	`98`	`#endif`
Original file line number	Diff line number	Diff line change
`@@ -291,13 +291,11 @@ size_t common_hal_busio_uart_read(busio_uart_obj_t self, uint8_t data, size_t`
`291`	`291`	`// Reset the timeout on every character read.`
`292`	`292`	`start_ticks = ticks_ms;`
`293`	`293`	`}`
`294`		`-#ifdef MICROPY_VM_HOOK_LOOP`
`295`		`- MICROPY_VM_HOOK_LOOP ;`
	`294`	`+ RUN_BACKGROUND_TASKS;`
`296`	`295`	`// Allow user to break out of a timeout with a KeyboardInterrupt.`
`297`	`296`	`if (mp_hal_is_interrupted()) {`
`298`	`297`	`break;`
`299`	`298`	`}`
`300`		`-#endif`
`301`	`299`	`// If we are zero timeout, make sure we don't loop again (in the event`
`302`	`300`	`// we read in under 1ms)`
`303`	`301`	`if (self->timeout_ms == 0) {`
`@@ -339,9 +337,7 @@ size_t common_hal_busio_uart_write(busio_uart_obj_t self, const uint8_t data,`
`339`	`337`	`done = true;`
`340`	`338`	`break;`
`341`	`339`	`}`
`342`		`- #ifdef MICROPY_VM_HOOK_LOOP`
`343`		`- MICROPY_VM_HOOK_LOOP`
`344`		`- #endif`
	`340`	`+ RUN_BACKGROUND_TASKS;`
`345`	`341`	`}`
`346`	`342`
`347`	`343`	`if (!done) {`
Original file line number	Diff line number	Diff line change
`@@ -51,9 +51,7 @@ static uint16_t get_raw_reading(touchio_touchin_obj_t *self) {`
`51`	`51`
`52`	`52`	`while (!adafruit_ptc_is_conversion_finished(PTC)) {`
`53`	`53`	`// wait`
`54`		`- #ifdef MICROPY_VM_HOOK_LOOP`
`55`		`- MICROPY_VM_HOOK_LOOP`
`56`		`- #endif`
	`54`	`+ RUN_BACKGROUND_TASKS;`
`57`	`55`	`}`
`58`	`56`
`59`	`57`	`return adafruit_ptc_get_conversion_result(PTC);`
Original file line number	Diff line number	Diff line change
`@@ -138,9 +138,7 @@ void ble_uart_init(void) {`
`138`	`138`	`m_cccd_enabled = false;`
`139`	`139`
`140`	`140`	`while (!m_cccd_enabled) {`
`141`		`-#ifdef MICROPY_VM_HOOK_LOOP`
`142`		`- MICROPY_VM_HOOK_LOOP`
`143`		`-#endif`
	`141`	`+ RUN_BACKGROUND_TASKS;`
`144`	`142`	`}`
`145`	`143`	`}`
`146`	`144`
`@@ -150,9 +148,7 @@ bool ble_uart_connected(void) {`
`150`	`148`
`151`	`149`	`char ble_uart_rx_chr(void) {`
`152`	`150`	`while (isBufferEmpty(&m_rx_ring_buffer)) {`
`153`		`-#ifdef MICROPY_VM_HOOK_LOOP`
`154`		`- MICROPY_VM_HOOK_LOOP`
`155`		`-#endif`
	`151`	`+ RUN_BACKGROUND_TASKS;`
`156`	`152`	`}`
`157`	`153`
`158`	`154`	`uint8_t byte;`
Original file line number	Diff line number	Diff line change
`@@ -115,7 +115,7 @@ void common_hal_bleio_central_connect(bleio_central_obj_t *self, bleio_address_o`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`while (self->waiting_to_connect) {`
`118`		`- MICROPY_VM_HOOK_LOOP;`
	`118`	`+ RUN_BACKGROUND_TASKS;`
`119`	`119`	`}`
`120`	`120`
`121`	`121`	`if (self->conn_handle == BLE_CONN_HANDLE_INVALID) {`
Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,7 @@ STATIC void characteristic_gatts_notify_indicate(uint16_t handle, uint16_t conn_`
`94`	`94`	`// TX buffer is full`
`95`	`95`	`// We could wait for an event indicating the write is complete, but just retrying is easier.`
`96`	`96`	`if (err_code == NRF_ERROR_RESOURCES) {`
`97`		`- MICROPY_VM_HOOK_LOOP;`
	`97`	`+ RUN_BACKGROUND_TASKS;`
`98`	`98`	`continue;`
`99`	`99`	`}`
`100`	`100`
`@@ -118,7 +118,7 @@ STATIC void characteristic_gattc_read(bleio_characteristic_obj_t *characteristic`
`118`	`118`	`}`
`119`	`119`
`120`	`120`	`while (m_read_characteristic != NULL) {`
`121`		`- MICROPY_VM_HOOK_LOOP;`
	`121`	`+ RUN_BACKGROUND_TASKS;`
`122`	`122`	`}`
`123`	`123`
`124`	`124`	`ble_drv_remove_event_handler(characteristic_on_gattc_read_rsp_evt, characteristic);`
`@@ -258,7 +258,7 @@ void common_hal_bleio_characteristic_set_cccd(bleio_characteristic_obj_t *self,`
`258`	`258`	`// Write without reponse will return NRF_ERROR_RESOURCES if too many writes are pending.`
`259`	`259`	`if (err_code == NRF_ERROR_BUSY \|\| err_code == NRF_ERROR_RESOURCES) {`
`260`	`260`	`// We could wait for an event indicating the write is complete, but just retrying is easier.`
`261`		`- MICROPY_VM_HOOK_LOOP;`
	`261`	`+ RUN_BACKGROUND_TASKS;`
`262`	`262`	`continue;`
`263`	`263`	`}`
`264`	`264`