Merge remote-tracking branch 'origin/main' into bitmap-read-2

48 files changed, 776 insertions, 719 deletions

diff --git a/ports/nrf/common-hal/_bleio/Adapter.c b/ports/nrf/common-hal/_bleio/Adapter.c
index 10794c16a..ca21222b5 100644
--- a/ports/nrf/common-hal/_bleio/Adapter.c
+++ b/ports/nrf/common-hal/_bleio/Adapter.c
@@ -80,7 +80,7 @@ const nvm_bytearray_obj_t common_hal_bleio_nvm_obj = {
     .base = {
         .type = &nvm_bytearray_type,
     },
-    .start_address = (uint8_t*) CIRCUITPY_BLE_CONFIG_START_ADDR,
+    .start_address = (uint8_t *)CIRCUITPY_BLE_CONFIG_START_ADDR,
     .len = CIRCUITPY_BLE_CONFIG_SIZE,
 };
 
@@ -94,17 +94,17 @@ bleio_connection_internal_t bleio_connections[BLEIO_TOTAL_CONNECTION_COUNT];
 extern uint32_t _ram_start;
 STATIC uint32_t ble_stack_enable(void) {
     nrf_clock_lf_cfg_t clock_config = {
-#if BOARD_HAS_32KHZ_XTAL
-        .source       = NRF_CLOCK_LF_SRC_XTAL,
-        .rc_ctiv      = 0,
+        #if BOARD_HAS_32KHZ_XTAL
+        .source = NRF_CLOCK_LF_SRC_XTAL,
+        .rc_ctiv = 0,
         .rc_temp_ctiv = 0,
-        .accuracy     = NRF_CLOCK_LF_ACCURACY_20_PPM,
-#else
-        .source       = NRF_CLOCK_LF_SRC_RC,
-        .rc_ctiv      = 16,
+        .accuracy = NRF_CLOCK_LF_ACCURACY_20_PPM,
+        #else
+        .source = NRF_CLOCK_LF_SRC_RC,
+        .rc_ctiv = 16,
         .rc_temp_ctiv = 2,
-        .accuracy     = NRF_CLOCK_LF_ACCURACY_250_PPM,
-#endif
+        .accuracy = NRF_CLOCK_LF_ACCURACY_250_PPM,
+        #endif
     };
 
     uint32_t err_code = sd_softdevice_enable(&clock_config, softdevice_assert_handler);
@@ -211,20 +211,20 @@ STATIC uint32_t ble_stack_enable(void) {
     ble_gap_conn_params_t gap_conn_params = {
         .min_conn_interval = BLE_MIN_CONN_INTERVAL,
         .max_conn_interval = BLE_MAX_CONN_INTERVAL,
-        .slave_latency     = BLE_SLAVE_LATENCY,
-        .conn_sup_timeout  = BLE_CONN_SUP_TIMEOUT,
+        .slave_latency = BLE_SLAVE_LATENCY,
+        .conn_sup_timeout = BLE_CONN_SUP_TIMEOUT,
     };
-   err_code = sd_ble_gap_ppcp_set(&gap_conn_params);
-   if (err_code != NRF_SUCCESS) {
-       return err_code;
-   }
+    err_code = sd_ble_gap_ppcp_set(&gap_conn_params);
+    if (err_code != NRF_SUCCESS) {
+        return err_code;
+    }
 
-   err_code = sd_ble_gap_appearance_set(BLE_APPEARANCE_UNKNOWN);
-   return err_code;
+    err_code = sd_ble_gap_appearance_set(BLE_APPEARANCE_UNKNOWN);
+    return err_code;
 }
 
 STATIC bool adapter_on_ble_evt(ble_evt_t *ble_evt, void *self_in) {
-    bleio_adapter_obj_t *self = (bleio_adapter_obj_t*)self_in;
+    bleio_adapter_obj_t *self = (bleio_adapter_obj_t *)self_in;
 
     // For debugging.
     // mp_printf(&mp_plat_print, "Adapter event: 0x%04x\n", ble_evt->header.evt_id);
@@ -242,7 +242,7 @@ STATIC bool adapter_on_ble_evt(ble_evt_t *ble_evt, void *self_in) {
             }
 
             // Central has connected.
-            ble_gap_evt_connected_t* connected = &ble_evt->evt.gap_evt.params.connected;
+            ble_gap_evt_connected_t *connected = &ble_evt->evt.gap_evt.params.connected;
 
             connection->conn_handle = ble_evt->evt.gap_evt.conn_handle;
             connection->connection_obj = mp_const_none;
@@ -284,7 +284,7 @@ STATIC bool adapter_on_ble_evt(ble_evt_t *ble_evt, void *self_in) {
             connection->conn_handle = BLE_CONN_HANDLE_INVALID;
             connection->pair_status = PAIR_NOT_PAIRED;
             if (connection->connection_obj != mp_const_none) {
-                bleio_connection_obj_t* obj = connection->connection_obj;
+                bleio_connection_obj_t *obj = connection->connection_obj;
                 obj->connection = NULL;
                 obj->disconnect_reason = ble_evt->evt.gap_evt.params.disconnected.reason;
             }
@@ -310,7 +310,7 @@ STATIC void get_address(bleio_adapter_obj_t *self, ble_gap_addr_t *address) {
     check_nrf_error(sd_ble_gap_addr_get(address));
 }
 
-char default_ble_name[] = { 'C', 'I', 'R', 'C', 'U', 'I', 'T', 'P', 'Y', 0, 0, 0, 0 , 0};
+char default_ble_name[] = { 'C', 'I', 'R', 'C', 'U', 'I', 'T', 'P', 'Y', 0, 0, 0, 0, 0};
 
 STATIC void bleio_adapter_reset_name(bleio_adapter_obj_t *self) {
     uint8_t len = sizeof(default_ble_name) - 1;
@@ -324,7 +324,7 @@ STATIC void bleio_adapter_reset_name(bleio_adapter_obj_t *self) {
     default_ble_name[len - 1] = nibble_to_hex_lower[local_address.addr[0] & 0xf];
     default_ble_name[len] = '\0'; // for now we add null for compatibility with C ASCIIZ strings
 
-    common_hal_bleio_adapter_set_name(self, (char*) default_ble_name);
+    common_hal_bleio_adapter_set_name(self, (char *)default_ble_name);
 }
 
 void common_hal_bleio_adapter_set_enabled(bleio_adapter_obj_t *self, bool enabled) {
@@ -401,7 +401,7 @@ bool common_hal_bleio_adapter_set_address(bleio_adapter_obj_t *self, bleio_addre
     return sd_ble_gap_addr_set(&local_address) == NRF_SUCCESS;
 }
 
-mp_obj_str_t* common_hal_bleio_adapter_get_name(bleio_adapter_obj_t *self) {
+mp_obj_str_t *common_hal_bleio_adapter_get_name(bleio_adapter_obj_t *self) {
     uint16_t len = 0;
     sd_ble_gap_device_name_get(NULL, &len);
     uint8_t buf[len];
@@ -409,18 +409,18 @@ mp_obj_str_t* common_hal_bleio_adapter_get_name(bleio_adapter_obj_t *self) {
     if (err_code != NRF_SUCCESS) {
         return NULL;
     }
-    return mp_obj_new_str((char*) buf, len);
+    return mp_obj_new_str((char *)buf, len);
 }
 
-void common_hal_bleio_adapter_set_name(bleio_adapter_obj_t *self, const char* name) {
+void common_hal_bleio_adapter_set_name(bleio_adapter_obj_t *self, const char *name) {
     ble_gap_conn_sec_mode_t sec;
     sec.lv = 0;
     sec.sm = 0;
-    sd_ble_gap_device_name_set(&sec, (const uint8_t*) name, strlen(name));
+    sd_ble_gap_device_name_set(&sec, (const uint8_t *)name, strlen(name));
 }
 
 STATIC bool scan_on_ble_evt(ble_evt_t *ble_evt, void *scan_results_in) {
-    bleio_scanresults_obj_t *scan_results = (bleio_scanresults_obj_t*)scan_results_in;
+    bleio_scanresults_obj_t *scan_results = (bleio_scanresults_obj_t *)scan_results_in;
 
     if (ble_evt->header.evt_id == BLE_GAP_EVT_TIMEOUT &&
         ble_evt->evt.gap_evt.params.timeout.src == BLE_GAP_TIMEOUT_SRC_SCAN) {
@@ -435,14 +435,14 @@ STATIC bool scan_on_ble_evt(ble_evt_t *ble_evt, void *scan_results_in) {
     ble_gap_evt_adv_report_t *report = &ble_evt->evt.gap_evt.params.adv_report;
 
     shared_module_bleio_scanresults_append(scan_results,
-                                           supervisor_ticks_ms64(),
-                                           report->type.connectable,
-                                           report->type.scan_response,
-                                           report->rssi,
-                                           report->peer_addr.addr,
-                                           report->peer_addr.addr_type,
-                                           report->data.p_data,
-                                           report->data.len);
+        supervisor_ticks_ms64(),
+        report->type.connectable,
+        report->type.scan_response,
+        report->rssi,
+        report->peer_addr.addr,
+        report->peer_addr.addr_type,
+        report->data.p_data,
+        report->data.len);
 
     const uint32_t err_code = sd_ble_gap_scan_start(NULL, scan_results->common_hal_data);
     if (err_code != NRF_SUCCESS) {
@@ -452,7 +452,7 @@ STATIC bool scan_on_ble_evt(ble_evt_t *ble_evt, void *scan_results_in) {
     return true;
 }
 
-mp_obj_t common_hal_bleio_adapter_start_scan(bleio_adapter_obj_t *self, uint8_t* prefixes, size_t prefix_length, bool extended, mp_int_t buffer_size, mp_float_t timeout, mp_float_t interval, mp_float_t window, mp_int_t minimum_rssi, bool active) {
+mp_obj_t common_hal_bleio_adapter_start_scan(bleio_adapter_obj_t *self, uint8_t *prefixes, size_t prefix_length, bool extended, mp_int_t buffer_size, mp_float_t timeout, mp_float_t interval, mp_float_t window, mp_int_t minimum_rssi, bool active) {
     if (self->scan_results != NULL) {
         if (!shared_module_bleio_scanresults_get_done(self->scan_results)) {
             mp_raise_bleio_BluetoothError(translate("Scan already in progess. Stop with stop_scan."));
@@ -462,7 +462,7 @@ mp_obj_t common_hal_bleio_adapter_start_scan(bleio_adapter_obj_t *self, uint8_t*
     self->scan_results = shared_module_bleio_new_scanresults(buffer_size, prefixes, prefix_length, minimum_rssi);
     size_t max_packet_size = extended ? BLE_GAP_SCAN_BUFFER_EXTENDED_MAX_SUPPORTED : BLE_GAP_SCAN_BUFFER_MAX;
     uint8_t *raw_data = m_malloc(sizeof(ble_data_t) + max_packet_size, false);
-    ble_data_t * sd_data = (ble_data_t *) raw_data;
+    ble_data_t *sd_data = (ble_data_t *)raw_data;
     self->scan_results->common_hal_data = sd_data;
     sd_data->len = max_packet_size;
     sd_data->p_data = raw_data + sizeof(ble_data_t);
@@ -517,7 +517,7 @@ typedef struct {
 } connect_info_t;
 
 STATIC bool connect_on_ble_evt(ble_evt_t *ble_evt, void *info_in) {
-    connect_info_t *info = (connect_info_t*)info_in;
+    connect_info_t *info = (connect_info_t *)info_in;
 
     switch (ble_evt->header.evt_id) {
         case BLE_GAP_EVT_CONNECTED:
@@ -546,7 +546,7 @@ mp_obj_t common_hal_bleio_adapter_connect(bleio_adapter_obj_t *self, bleio_addre
     addr.addr_type = address->type;
     mp_buffer_info_t address_buf_info;
     mp_get_buffer_raise(address->bytes, &address_buf_info, MP_BUFFER_READ);
-    memcpy(addr.addr, (uint8_t *) address_buf_info.buf, NUM_BLEIO_ADDRESS_BYTES);
+    memcpy(addr.addr, (uint8_t *)address_buf_info.buf, NUM_BLEIO_ADDRESS_BYTES);
 
     ble_gap_scan_params_t scan_params = {
         .interval = MSEC_TO_UNITS(100, UNIT_0_625_MS),
@@ -621,7 +621,7 @@ STATIC void check_data_fit(size_t data_len, bool connectable) {
 }
 
 STATIC bool advertising_on_ble_evt(ble_evt_t *ble_evt, void *self_in) {
-    bleio_adapter_obj_t *self = (bleio_adapter_obj_t*)self_in;
+    bleio_adapter_obj_t *self = (bleio_adapter_obj_t *)self_in;
 
     switch (ble_evt->header.evt_id) {
         case BLE_GAP_EVT_ADV_SET_TERMINATED:
@@ -651,7 +651,7 @@ uint32_t _common_hal_bleio_adapter_start_advertising(bleio_adapter_obj_t *self,
 
     uint32_t err_code;
     bool extended = advertising_data_len > BLE_GAP_ADV_SET_DATA_SIZE_MAX ||
-                    scan_response_data_len > BLE_GAP_ADV_SET_DATA_SIZE_MAX;
+        scan_response_data_len > BLE_GAP_ADV_SET_DATA_SIZE_MAX;
 
     uint8_t adv_type;
     if (extended) {
@@ -749,39 +749,39 @@ void common_hal_bleio_adapter_start_advertising(bleio_adapter_obj_t *self, bool
             uint32_t adv_timeout_max_secs = UNITS_TO_SEC(BLE_GAP_ADV_TIMEOUT_LIMITED_MAX, UNIT_10_MS);
             uint32_t rotate_timeout_max_secs = BLE_GAP_DEFAULT_PRIVATE_ADDR_CYCLE_INTERVAL_S;
             timeout = MIN(adv_timeout_max_secs, rotate_timeout_max_secs);
-        }
-        else {
+        } else {
             timeout = BLE_GAP_ADV_TIMEOUT_GENERAL_UNLIMITED;
         }
     } else {
         if (SEC_TO_UNITS(timeout, UNIT_10_MS) > BLE_GAP_ADV_TIMEOUT_LIMITED_MAX) {
             mp_raise_bleio_BluetoothError(translate("Timeout is too long: Maximum timeout length is %d seconds"),
-                                        UNITS_TO_SEC(BLE_GAP_ADV_TIMEOUT_LIMITED_MAX, UNIT_10_MS));
+                UNITS_TO_SEC(BLE_GAP_ADV_TIMEOUT_LIMITED_MAX, UNIT_10_MS));
         }
     }
 
     // The advertising data buffers must not move, because the SoftDevice depends on them.
     // So make them long-lived and reuse them onwards.
     if (self->advertising_data == NULL) {
-        self->advertising_data = (uint8_t *) gc_alloc(BLE_GAP_ADV_SET_DATA_SIZE_EXTENDED_MAX_SUPPORTED * sizeof(uint8_t), false, true);
+        self->advertising_data = (uint8_t *)gc_alloc(BLE_GAP_ADV_SET_DATA_SIZE_EXTENDED_MAX_SUPPORTED * sizeof(uint8_t), false, true);
     }
     if (self->scan_response_data == NULL) {
-        self->scan_response_data = (uint8_t *) gc_alloc(BLE_GAP_ADV_SET_DATA_SIZE_EXTENDED_MAX_SUPPORTED * sizeof(uint8_t), false, true);
+        self->scan_response_data = (uint8_t *)gc_alloc(BLE_GAP_ADV_SET_DATA_SIZE_EXTENDED_MAX_SUPPORTED * sizeof(uint8_t), false, true);
     }
 
     memcpy(self->advertising_data, advertising_data_bufinfo->buf, advertising_data_bufinfo->len);
     memcpy(self->scan_response_data, scan_response_data_bufinfo->buf, scan_response_data_bufinfo->len);
 
     check_nrf_error(_common_hal_bleio_adapter_start_advertising(self, connectable, anonymous, timeout, interval,
-                                                                self->advertising_data,
-                                                                advertising_data_bufinfo->len,
-                                                                self->scan_response_data,
-                                                                scan_response_data_bufinfo->len));
+        self->advertising_data,
+        advertising_data_bufinfo->len,
+        self->scan_response_data,
+        scan_response_data_bufinfo->len));
 }
 
 void common_hal_bleio_adapter_stop_advertising(bleio_adapter_obj_t *self) {
-    if (adv_handle == BLE_GAP_ADV_SET_HANDLE_NOT_SET)
+    if (adv_handle == BLE_GAP_ADV_SET_HANDLE_NOT_SET) {
         return;
+    }
 
     // TODO: Don't actually stop. Switch to advertising CircuitPython if we don't already have a connection.
     const uint32_t err_code = sd_ble_gap_adv_stop(adv_handle);
@@ -830,12 +830,12 @@ void common_hal_bleio_adapter_erase_bonding(bleio_adapter_obj_t *self) {
     bonding_erase_storage();
 }
 
-void bleio_adapter_gc_collect(bleio_adapter_obj_t* adapter) {
-    gc_collect_root((void**)adapter, sizeof(bleio_adapter_obj_t) / sizeof(size_t));
-    gc_collect_root((void**)bleio_connections, sizeof(bleio_connections) / sizeof(size_t));
+void bleio_adapter_gc_collect(bleio_adapter_obj_t *adapter) {
+    gc_collect_root((void **)adapter, sizeof(bleio_adapter_obj_t) / sizeof(size_t));
+    gc_collect_root((void **)bleio_connections, sizeof(bleio_connections) / sizeof(size_t));
 }
 
-void bleio_adapter_reset(bleio_adapter_obj_t* adapter) {
+void bleio_adapter_reset(bleio_adapter_obj_t *adapter) {
     common_hal_bleio_adapter_stop_scan(adapter);
     if (adapter->current_advertising_data != NULL) {
         common_hal_bleio_adapter_stop_advertising(adapter);
diff --git a/ports/nrf/common-hal/_bleio/Adapter.h b/ports/nrf/common-hal/_bleio/Adapter.h
index 837e5c111..68a8b4864 100644
--- a/ports/nrf/common-hal/_bleio/Adapter.h
+++ b/ports/nrf/common-hal/_bleio/Adapter.h
@@ -43,16 +43,16 @@ extern bleio_connection_internal_t bleio_connections[BLEIO_TOTAL_CONNECTION_COUN
 
 typedef struct {
     mp_obj_base_t base;
-    uint8_t* advertising_data;
-    uint8_t* scan_response_data;
-    uint8_t* current_advertising_data;
-    bleio_scanresults_obj_t* scan_results;
+    uint8_t *advertising_data;
+    uint8_t *scan_response_data;
+    uint8_t *current_advertising_data;
+    bleio_scanresults_obj_t *scan_results;
     mp_obj_t name;
     mp_obj_tuple_t *connection_objs;
     ble_drv_evt_handler_entry_t handler_entry;
 } bleio_adapter_obj_t;
 
-void bleio_adapter_gc_collect(bleio_adapter_obj_t* adapter);
-void bleio_adapter_reset(bleio_adapter_obj_t* adapter);
+void bleio_adapter_gc_collect(bleio_adapter_obj_t *adapter);
+void bleio_adapter_reset(bleio_adapter_obj_t *adapter);
 
 #endif // MICROPY_INCLUDED_NRF_COMMON_HAL_BLEIO_ADAPTER_H
diff --git a/ports/nrf/common-hal/_bleio/Characteristic.c b/ports/nrf/common-hal/_bleio/Characteristic.c
index c0f0372c3..4c5de3124 100644
--- a/ports/nrf/common-hal/_bleio/Characteristic.c
+++ b/ports/nrf/common-hal/_bleio/Characteristic.c
@@ -38,7 +38,7 @@
 STATIC uint16_t characteristic_get_cccd(uint16_t cccd_handle, uint16_t conn_handle) {
     uint16_t cccd;
     ble_gatts_value_t value = {
-        .p_value = (uint8_t*) &cccd,
+        .p_value = (uint8_t *)&cccd,
         .len = 2,
     };
 
@@ -96,7 +96,7 @@ void common_hal_bleio_characteristic_construct(bleio_characteristic_obj_t *self,
     const mp_int_t max_length_max = fixed_length ? BLE_GATTS_FIX_ATTR_LEN_MAX : BLE_GATTS_VAR_ATTR_LEN_MAX;
     if (max_length < 0 || max_length > max_length_max) {
         mp_raise_ValueError_varg(translate("max_length must be 0-%d when fixed_length is %s"),
-                                 max_length_max, fixed_length ? "True" : "False");
+            max_length_max, fixed_length ? "True" : "False");
     }
     self->max_length = max_length;
     self->fixed_length = fixed_length;
@@ -116,7 +116,7 @@ bleio_service_obj_t *common_hal_bleio_characteristic_get_service(bleio_character
     return self->service;
 }
 
-size_t common_hal_bleio_characteristic_get_value(bleio_characteristic_obj_t *self, uint8_t* buf, size_t len) {
+size_t common_hal_bleio_characteristic_get_value(bleio_characteristic_obj_t *self, uint8_t *buf, size_t len) {
     // Do GATT operations only if this characteristic has been added to a registered service.
     if (self->handle != BLE_GATT_HANDLE_INVALID) {
         uint16_t conn_handle = bleio_connection_get_conn_handle(self->service->connection);
@@ -139,7 +139,7 @@ void common_hal_bleio_characteristic_set_value(bleio_characteristic_obj_t *self,
             uint16_t conn_handle = bleio_connection_get_conn_handle(self->service->connection);
             // Last argument is true if write-no-reponse desired.
             common_hal_bleio_gattc_write(self->handle, conn_handle, bufinfo,
-                                         (self->props & CHAR_PROP_WRITE_NO_RESPONSE));
+                (self->props & CHAR_PROP_WRITE_NO_RESPONSE));
         } else {
             // Validate data length for local characteristics only.
             if (self->fixed_length && bufinfo->len != self->max_length) {
@@ -216,7 +216,7 @@ void common_hal_bleio_characteristic_add_descriptor(bleio_characteristic_obj_t *
     check_nrf_error(sd_ble_gatts_descriptor_add(self->handle, &desc_attr, &descriptor->handle));
 
     mp_obj_list_append(MP_OBJ_FROM_PTR(self->descriptor_list),
-                       MP_OBJ_FROM_PTR(descriptor));
+        MP_OBJ_FROM_PTR(descriptor));
 }
 
 void common_hal_bleio_characteristic_set_cccd(bleio_characteristic_obj_t *self, bool notify, bool indicate) {
@@ -238,7 +238,7 @@ void common_hal_bleio_characteristic_set_cccd(bleio_characteristic_obj_t *self,
     ble_gattc_write_params_t write_params = {
         .write_op = BLE_GATT_OP_WRITE_REQ,
         .handle = self->cccd_handle,
-        .p_value = (uint8_t *) &cccd_value,
+        .p_value = (uint8_t *)&cccd_value,
         .len = 2,
     };
 
diff --git a/ports/nrf/common-hal/_bleio/CharacteristicBuffer.c b/ports/nrf/common-hal/_bleio/CharacteristicBuffer.c
index 132e392dd..b17327da4 100644
--- a/ports/nrf/common-hal/_bleio/CharacteristicBuffer.c
+++ b/ports/nrf/common-hal/_bleio/CharacteristicBuffer.c
@@ -49,7 +49,7 @@ STATIC void write_to_ringbuf(bleio_characteristic_buffer_obj_t *self, uint8_t *d
 }
 
 STATIC bool characteristic_buffer_on_ble_evt(ble_evt_t *ble_evt, void *param) {
-    bleio_characteristic_buffer_obj_t *self = (bleio_characteristic_buffer_obj_t *) param;
+    bleio_characteristic_buffer_obj_t *self = (bleio_characteristic_buffer_obj_t *)param;
     switch (ble_evt->header.evt_id) {
         case BLE_GATTS_EVT_WRITE: {
             // A client wrote to this server characteristic.
@@ -65,7 +65,7 @@ STATIC bool characteristic_buffer_on_ble_evt(ble_evt_t *ble_evt, void *param) {
         case BLE_GATTC_EVT_HVX: {
             // A remote service wrote to this characteristic.
 
-            ble_gattc_evt_hvx_t* evt_hvx = &ble_evt->evt.gattc_evt.params.hvx;
+            ble_gattc_evt_hvx_t *evt_hvx = &ble_evt->evt.gattc_evt.params.hvx;
             // Must be a notification, and event handle must match the handle for my characteristic.
             if (evt_hvx->type == BLE_GATT_HVX_NOTIFICATION &&
                 evt_hvx->handle == self->characteristic->handle) {
@@ -82,9 +82,9 @@ STATIC bool characteristic_buffer_on_ble_evt(ble_evt_t *ble_evt, void *param) {
 
 // Assumes that timeout and buffer_size have been validated before call.
 void common_hal_bleio_characteristic_buffer_construct(bleio_characteristic_buffer_obj_t *self,
-                                                      bleio_characteristic_obj_t *characteristic,
-                                                      mp_float_t timeout,
-                                                      size_t buffer_size) {
+    bleio_characteristic_obj_t *characteristic,
+    mp_float_t timeout,
+    size_t buffer_size) {
 
     self->characteristic = characteristic;
     self->timeout_ms = timeout * 1000;
@@ -100,10 +100,10 @@ uint32_t common_hal_bleio_characteristic_buffer_read(bleio_characteristic_buffer
     uint64_t start_ticks = supervisor_ticks_ms64();
 
     // Wait for all bytes received or timeout
-    while ( (ringbuf_num_filled(&self->ringbuf) < len) && (supervisor_ticks_ms64() - start_ticks < self->timeout_ms) ) {
+    while ((ringbuf_num_filled(&self->ringbuf) < len) && (supervisor_ticks_ms64() - start_ticks < self->timeout_ms)) {
         RUN_BACKGROUND_TASKS;
         // Allow user to break out of a timeout with a KeyboardInterrupt.
-        if ( mp_hal_is_interrupted() ) {
+        if (mp_hal_is_interrupted()) {
             return 0;
         }
     }
@@ -148,8 +148,8 @@ void common_hal_bleio_characteristic_buffer_deinit(bleio_characteristic_buffer_o
 
 bool common_hal_bleio_characteristic_buffer_connected(bleio_characteristic_buffer_obj_t *self) {
     return self->characteristic != NULL &&
-        self->characteristic->service != NULL &&
-        (!self->characteristic->service->is_remote ||
-         (self->characteristic->service->connection != MP_OBJ_NULL &&
-          common_hal_bleio_connection_get_connected(self->characteristic->service->connection)));
+           self->characteristic->service != NULL &&
+           (!self->characteristic->service->is_remote ||
+               (self->characteristic->service->connection != MP_OBJ_NULL &&
+                   common_hal_bleio_connection_get_connected(self->characteristic->service->connection)));
 }
diff --git a/ports/nrf/common-hal/_bleio/Connection.c b/ports/nrf/common-hal/_bleio/Connection.c
index 36fda0bb3..f57ee639a 100644
--- a/ports/nrf/common-hal/_bleio/Connection.c
+++ b/ports/nrf/common-hal/_bleio/Connection.c
@@ -63,8 +63,8 @@ static const ble_gap_sec_params_t pairing_sec_params = {
     .io_caps = BLE_GAP_IO_CAPS_NONE,
     .min_key_size = 7,
     .max_key_size = 16,
-    .kdist_own    = { .enc = 1, .id = 1},
-    .kdist_peer   = { .enc = 1, .id = 1},
+    .kdist_own = { .enc = 1, .id = 1},
+    .kdist_peer = { .enc = 1, .id = 1},
 };
 
 #define CONNECTION_DEBUG (1)
@@ -81,7 +81,7 @@ static bleio_service_obj_t *m_char_discovery_service;
 static bleio_characteristic_obj_t *m_desc_discovery_characteristic;
 
 bool connection_on_ble_evt(ble_evt_t *ble_evt, void *self_in) {
-    bleio_connection_internal_t *self = (bleio_connection_internal_t*)self_in;
+    bleio_connection_internal_t *self = (bleio_connection_internal_t *)self_in;
 
     if (BLE_GAP_EVT_BASE <= ble_evt->header.evt_id && ble_evt->header.evt_id <= BLE_GAP_EVT_LAST &&
         ble_evt->evt.gap_evt.conn_handle != self->conn_handle) {
@@ -121,7 +121,7 @@ bool connection_on_ble_evt(ble_evt_t *ble_evt, void *self_in) {
 
         case BLE_GATTS_EVT_EXCHANGE_MTU_REQUEST: {
             ble_gatts_evt_exchange_mtu_request_t *request =
-                    &ble_evt->evt.gatts_evt.params.exchange_mtu_request;
+                &ble_evt->evt.gatts_evt.params.exchange_mtu_request;
 
             uint16_t new_mtu = BLE_GATTS_VAR_ATTR_LEN_MAX;
             if (request->client_rx_mtu < new_mtu) {
@@ -142,7 +142,7 @@ bool connection_on_ble_evt(ble_evt_t *ble_evt, void *self_in) {
 
         case BLE_GATTC_EVT_EXCHANGE_MTU_RSP: {
             ble_gattc_evt_exchange_mtu_rsp_t *response =
-                    &ble_evt->evt.gattc_evt.params.exchange_mtu_rsp;
+                &ble_evt->evt.gattc_evt.params.exchange_mtu_rsp;
 
             self->mtu = response->server_rx_mtu;
             break;
@@ -169,12 +169,12 @@ bool connection_on_ble_evt(ble_evt_t *ble_evt, void *self_in) {
             sd_ble_gatts_sys_attr_set(self->conn_handle, NULL, 0, 0);
             break;
 
-        #if CIRCUITPY_VERBOSE_BLE
+            #if CIRCUITPY_VERBOSE_BLE
         // Use read authorization to snoop on all reads when doing verbose debugging.
         case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST: {
 
             ble_gatts_evt_rw_authorize_request_t *request =
-                    &ble_evt->evt.gatts_evt.params.authorize_request;
+                &ble_evt->evt.gatts_evt.params.authorize_request;
 
             mp_printf(&mp_plat_print, "Read %x offset %d ", request->request.read.handle, request->request.read.offset);
             uint8_t value_bytes[22];
@@ -200,20 +200,20 @@ bool connection_on_ble_evt(ble_evt_t *ble_evt, void *self_in) {
             sd_ble_gatts_rw_authorize_reply(self->conn_handle, &reply);
             break;
         }
-        #endif
+            #endif
 
         case BLE_GATTS_EVT_HVN_TX_COMPLETE: // Capture this for now. 0x55
             break;
         case BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST: {
             self->conn_params_updating = true;
             ble_gap_evt_conn_param_update_request_t *request =
-                    &ble_evt->evt.gap_evt.params.conn_param_update_request;
+                &ble_evt->evt.gap_evt.params.conn_param_update_request;
             sd_ble_gap_conn_param_update(self->conn_handle, &request->conn_params);
             break;
         }
         case BLE_GAP_EVT_CONN_PARAM_UPDATE: { // 0x12
             ble_gap_evt_conn_param_update_t *result =
-                    &ble_evt->evt.gap_evt.params.conn_param_update;
+                &ble_evt->evt.gap_evt.params.conn_param_update;
 
             #if CIRCUITPY_VERBOSE_BLE
             ble_gap_conn_params_t *cp = &ble_evt->evt.gap_evt.params.conn_param_update.conn_params;
@@ -236,23 +236,23 @@ bool connection_on_ble_evt(ble_evt_t *ble_evt, void *self_in) {
             self->ediv = EDIV_INVALID;
             ble_gap_sec_keyset_t keyset = {
                 .keys_own = {
-                    .p_enc_key  = &self->bonding_keys.own_enc,
-                    .p_id_key   = NULL,
+                    .p_enc_key = &self->bonding_keys.own_enc,
+                    .p_id_key = NULL,
                     .p_sign_key = NULL,
-                    .p_pk       = NULL
+                    .p_pk = NULL
                 },
 
                 .keys_peer = {
-                    .p_enc_key  = &self->bonding_keys.peer_enc,
-                    .p_id_key   = &self->bonding_keys.peer_id,
+                    .p_enc_key = &self->bonding_keys.peer_enc,
+                    .p_id_key = &self->bonding_keys.peer_id,
                     .p_sign_key = NULL,
-                    .p_pk       = NULL
+                    .p_pk = NULL
                 }
             };
 
             sd_ble_gap_sec_params_reply(self->conn_handle, BLE_GAP_SEC_STATUS_SUCCESS,
-                                        self->is_central ? NULL : &pairing_sec_params,
-                                        &keyset);
+                self->is_central ? NULL : &pairing_sec_params,
+                &keyset);
             break;
         }
 
@@ -263,7 +263,7 @@ bool connection_on_ble_evt(ble_evt_t *ble_evt, void *self_in) {
 
         case BLE_GAP_EVT_AUTH_STATUS: { // 0x19
             // Key exchange completed.
-            ble_gap_evt_auth_status_t* status = &ble_evt->evt.gap_evt.params.auth_status;
+            ble_gap_evt_auth_status_t *status = &ble_evt->evt.gap_evt.params.auth_status;
             self->sec_status = status->auth_status;
             if (status->auth_status == BLE_GAP_SEC_STATUS_SUCCESS) {
                 self->ediv = self->bonding_keys.own_enc.master_id.ediv;
@@ -281,9 +281,9 @@ bool connection_on_ble_evt(ble_evt_t *ble_evt, void *self_in) {
             // Peer asks for the stored keys.
             // - load key and return if bonded previously.
             // - Else return NULL --> Initiate key exchange
-            ble_gap_evt_sec_info_request_t* sec_info_request = &ble_evt->evt.gap_evt.params.sec_info_request;
-            (void) sec_info_request;
-            if ( bonding_load_keys(self->is_central, sec_info_request->master_id.ediv, &self->bonding_keys) ) {
+            ble_gap_evt_sec_info_request_t *sec_info_request = &ble_evt->evt.gap_evt.params.sec_info_request;
+            (void)sec_info_request;
+            if (bonding_load_keys(self->is_central, sec_info_request->master_id.ediv, &self->bonding_keys)) {
                 sd_ble_gap_sec_info_reply(
                     self->conn_handle,
                     &self->bonding_keys.own_enc.enc_info,
@@ -299,7 +299,7 @@ bool connection_on_ble_evt(ble_evt_t *ble_evt, void *self_in) {
 
         case BLE_GAP_EVT_CONN_SEC_UPDATE: { // 0x1a
             // We get this both on first-time pairing and on subsequent pairings using stored keys.
-            ble_gap_conn_sec_t* conn_sec = &ble_evt->evt.gap_evt.params.conn_sec_update.conn_sec;
+            ble_gap_conn_sec_t *conn_sec = &ble_evt->evt.gap_evt.params.conn_sec_update.conn_sec;
             if (conn_sec->sec_mode.sm <= 1 && conn_sec->sec_mode.lv <= 1) {
                 // Security setup did not succeed:
                 // mode 0, level 0 means no access
@@ -391,7 +391,7 @@ void common_hal_bleio_connection_set_connection_interval(bleio_connection_intern
 }
 
 // service_uuid may be NULL, to discover all services.
-STATIC bool discover_next_services(bleio_connection_internal_t* connection, uint16_t start_handle, ble_uuid_t *service_uuid) {
+STATIC bool discover_next_services(bleio_connection_internal_t *connection, uint16_t start_handle, ble_uuid_t *service_uuid) {
     m_discovery_successful = false;
     m_discovery_in_process = true;
 
@@ -408,7 +408,7 @@ STATIC bool discover_next_services(bleio_connection_internal_t* connection, uint
     return m_discovery_successful;
 }
 
-STATIC bool discover_next_characteristics(bleio_connection_internal_t* connection, bleio_service_obj_t *service, uint16_t start_handle) {
+STATIC bool discover_next_characteristics(bleio_connection_internal_t *connection, bleio_service_obj_t *service, uint16_t start_handle) {
     m_char_discovery_service = service;
 
     ble_gattc_handle_range_t handle_range;
@@ -430,7 +430,7 @@ STATIC bool discover_next_characteristics(bleio_connection_internal_t* connectio
     return m_discovery_successful;
 }
 
-STATIC bool discover_next_descriptors(bleio_connection_internal_t* connection, bleio_characteristic_obj_t *characteristic, uint16_t start_handle, uint16_t end_handle) {
+STATIC bool discover_next_descriptors(bleio_connection_internal_t *connection, bleio_characteristic_obj_t *characteristic, uint16_t start_handle, uint16_t end_handle) {
     m_desc_discovery_characteristic = characteristic;
 
     ble_gattc_handle_range_t handle_range;
@@ -452,7 +452,7 @@ STATIC bool discover_next_descriptors(bleio_connection_internal_t* connection, b
     return m_discovery_successful;
 }
 
-STATIC void on_primary_srv_discovery_rsp(ble_gattc_evt_prim_srvc_disc_rsp_t *response, bleio_connection_internal_t* connection) {
+STATIC void on_primary_srv_discovery_rsp(ble_gattc_evt_prim_srvc_disc_rsp_t *response, bleio_connection_internal_t *connection) {
     for (size_t i = 0; i < response->count; ++i) {
         ble_gattc_service_t *gattc_service = &response->services[i];
 
@@ -481,7 +481,7 @@ STATIC void on_primary_srv_discovery_rsp(ble_gattc_evt_prim_srvc_disc_rsp_t *res
         }
 
         mp_obj_list_append(MP_OBJ_FROM_PTR(connection->remote_service_list),
-                           MP_OBJ_FROM_PTR(service));
+            MP_OBJ_FROM_PTR(service));
     }
 
     if (response->count > 0) {
@@ -490,7 +490,7 @@ STATIC void on_primary_srv_discovery_rsp(ble_gattc_evt_prim_srvc_disc_rsp_t *res
     m_discovery_in_process = false;
 }
 
-STATIC void on_char_discovery_rsp(ble_gattc_evt_char_disc_rsp_t *response, bleio_connection_internal_t* connection) {
+STATIC void on_char_discovery_rsp(ble_gattc_evt_char_disc_rsp_t *response, bleio_connection_internal_t *connection) {
     for (size_t i = 0; i < response->count; ++i) {
         ble_gattc_char_t *gattc_char = &response->chars[i];
 
@@ -526,7 +526,7 @@ STATIC void on_char_discovery_rsp(ble_gattc_evt_char_disc_rsp_t *response, bleio
             mp_const_empty_bytes);
 
         mp_obj_list_append(MP_OBJ_FROM_PTR(m_char_discovery_service->characteristic_list),
-                           MP_OBJ_FROM_PTR(characteristic));
+            MP_OBJ_FROM_PTR(characteristic));
     }
 
     if (response->count > 0) {
@@ -535,7 +535,7 @@ STATIC void on_char_discovery_rsp(ble_gattc_evt_char_disc_rsp_t *response, bleio
     m_discovery_in_process = false;
 }
 
-STATIC void on_desc_discovery_rsp(ble_gattc_evt_desc_disc_rsp_t *response, bleio_connection_internal_t* connection) {
+STATIC void on_desc_discovery_rsp(ble_gattc_evt_desc_disc_rsp_t *response, bleio_connection_internal_t *connection) {
     for (size_t i = 0; i < response->count; ++i) {
         ble_gattc_desc_t *gattc_desc = &response->descs[i];
 
@@ -583,7 +583,7 @@ STATIC void on_desc_discovery_rsp(ble_gattc_evt_desc_disc_rsp_t *response, bleio
         descriptor->handle = gattc_desc->handle;
 
         mp_obj_list_append(MP_OBJ_FROM_PTR(m_desc_discovery_characteristic->descriptor_list),
-                           MP_OBJ_FROM_PTR(descriptor));
+            MP_OBJ_FROM_PTR(descriptor));
     }
 
     if (response->count > 0) {
@@ -593,7 +593,7 @@ STATIC void on_desc_discovery_rsp(ble_gattc_evt_desc_disc_rsp_t *response, bleio
 }
 
 STATIC bool discovery_on_ble_evt(ble_evt_t *ble_evt, mp_obj_t payload) {
-    bleio_connection_internal_t* connection = MP_OBJ_TO_PTR(payload);
+    bleio_connection_internal_t *connection = MP_OBJ_TO_PTR(payload);
     switch (ble_evt->header.evt_id) {
         case BLE_GAP_EVT_DISCONNECTED:
             m_discovery_successful = false;
@@ -714,7 +714,7 @@ STATIC void discover_remote_services(bleio_connection_internal_t *self, mp_obj_t
             while (next_desc_start_handle <= service->end_handle &&
                    next_desc_start_handle <= next_desc_end_handle &&
                    discover_next_descriptors(self, characteristic,
-                                             next_desc_start_handle, next_desc_end_handle)) {
+                       next_desc_start_handle, next_desc_end_handle)) {
                 // Get the most recently discovered descriptor, and then ask for descriptors
                 // whose handles start after that descriptor's handle.
                 // There must be at least one if discover_next_descriptors() returned true.
@@ -735,7 +735,7 @@ mp_obj_tuple_t *common_hal_bleio_connection_discover_remote_services(bleio_conne
     // Convert to a tuple and then clear the list so the callee will take ownership.
     mp_obj_tuple_t *services_tuple =
         mp_obj_new_tuple(self->connection->remote_service_list->len,
-                         self->connection->remote_service_list->items);
+            self->connection->remote_service_list->items);
     mp_obj_list_clear(MP_OBJ_FROM_PTR(self->connection->remote_service_list));
 
     return services_tuple;
@@ -748,7 +748,7 @@ uint16_t bleio_connection_get_conn_handle(bleio_connection_obj_t *self) {
     return self->connection->conn_handle;
 }
 
-mp_obj_t bleio_connection_new_from_internal(bleio_connection_internal_t* internal) {
+mp_obj_t bleio_connection_new_from_internal(bleio_connection_internal_t *internal) {
     if (internal->connection_obj != mp_const_none) {
         return internal->connection_obj;
     }
diff --git a/ports/nrf/common-hal/_bleio/Connection.h b/ports/nrf/common-hal/_bleio/Connection.h
index 180b2727c..eb095c993 100644
--- a/ports/nrf/common-hal/_bleio/Connection.h
+++ b/ports/nrf/common-hal/_bleio/Connection.h
@@ -78,7 +78,7 @@ typedef struct {
 
 typedef struct {
     mp_obj_base_t base;
-    bleio_connection_internal_t* connection;
+    bleio_connection_internal_t *connection;
     // The HCI disconnect reason.
     uint8_t disconnect_reason;
 } bleio_connection_obj_t;
@@ -87,7 +87,7 @@ void bleio_connection_clear(bleio_connection_internal_t *self);
 bool connection_on_ble_evt(ble_evt_t *ble_evt, void *self_in);
 
 uint16_t bleio_connection_get_conn_handle(bleio_connection_obj_t *self);
-mp_obj_t bleio_connection_new_from_internal(bleio_connection_internal_t* connection);
+mp_obj_t bleio_connection_new_from_internal(bleio_connection_internal_t *connection);
 bleio_connection_internal_t *bleio_conn_handle_to_connection(uint16_t conn_handle);
 
 #endif // MICROPY_INCLUDED_NRF_COMMON_HAL_BLEIO_CONNECTION_H
diff --git a/ports/nrf/common-hal/_bleio/Descriptor.c b/ports/nrf/common-hal/_bleio/Descriptor.c
index d848659fc..7ec287260 100644
--- a/ports/nrf/common-hal/_bleio/Descriptor.c
+++ b/ports/nrf/common-hal/_bleio/Descriptor.c
@@ -44,7 +44,7 @@ void common_hal_bleio_descriptor_construct(bleio_descriptor_obj_t *self, bleio_c
     const mp_int_t max_length_max = fixed_length ? BLE_GATTS_FIX_ATTR_LEN_MAX : BLE_GATTS_VAR_ATTR_LEN_MAX;
     if (max_length < 0 || max_length > max_length_max) {
         mp_raise_ValueError_varg(translate("max_length must be 0-%d when fixed_length is %s"),
-                                 max_length_max, fixed_length ? "True" : "False");
+            max_length_max, fixed_length ? "True" : "False");
     }
     self->max_length = max_length;
     self->fixed_length = fixed_length;
@@ -58,7 +58,7 @@ bleio_characteristic_obj_t *common_hal_bleio_descriptor_get_characteristic(bleio
     return self->characteristic;
 }
 
-size_t common_hal_bleio_descriptor_get_value(bleio_descriptor_obj_t *self, uint8_t* buf, size_t len) {
+size_t common_hal_bleio_descriptor_get_value(bleio_descriptor_obj_t *self, uint8_t *buf, size_t len) {
     // Do GATT operations only if this descriptor has been registered
     if (self->handle != BLE_GATT_HANDLE_INVALID) {
         uint16_t conn_handle = bleio_connection_get_conn_handle(self->characteristic->service->connection);
diff --git a/ports/nrf/common-hal/_bleio/PacketBuffer.c b/ports/nrf/common-hal/_bleio/PacketBuffer.c
index 6d587984c..8f87b2497 100644
--- a/ports/nrf/common-hal/_bleio/PacketBuffer.c
+++ b/ports/nrf/common-hal/_bleio/PacketBuffer.c
@@ -51,13 +51,13 @@ STATIC void write_to_ringbuf(bleio_packet_buffer_obj_t *self, uint8_t *data, uin
     // Make room for the new value by dropping the oldest packets first.
     while (ringbuf_capacity(&self->ringbuf) - ringbuf_num_filled(&self->ringbuf) < len + sizeof(uint16_t)) {
         uint16_t packet_length;
-        ringbuf_get_n(&self->ringbuf, (uint8_t*) &packet_length, sizeof(uint16_t));
+        ringbuf_get_n(&self->ringbuf, (uint8_t *)&packet_length, sizeof(uint16_t));
         for (uint16_t i = 0; i < packet_length; i++) {
             ringbuf_get(&self->ringbuf);
         }
         // set an overflow flag?
     }
-    ringbuf_put_n(&self->ringbuf, (uint8_t*) &len, sizeof(uint16_t));
+    ringbuf_put_n(&self->ringbuf, (uint8_t *)&len, sizeof(uint16_t));
     ringbuf_put_n(&self->ringbuf, data, len);
     sd_nvic_critical_region_exit(is_nested_critical_region);
 }
@@ -112,14 +112,14 @@ STATIC bool packet_buffer_on_ble_client_evt(ble_evt_t *ble_evt, void *param) {
     }
 
     uint16_t conn_handle = ble_evt->evt.gattc_evt.conn_handle;
-    bleio_packet_buffer_obj_t *self = (bleio_packet_buffer_obj_t *) param;
+    bleio_packet_buffer_obj_t *self = (bleio_packet_buffer_obj_t *)param;
     if (conn_handle != self->conn_handle) {
         return false;
     }
     switch (evt_id) {
         case BLE_GATTC_EVT_HVX: {
             // A remote service wrote to this characteristic.
-            ble_gattc_evt_hvx_t* evt_hvx = &ble_evt->evt.gattc_evt.params.hvx;
+            ble_gattc_evt_hvx_t *evt_hvx = &ble_evt->evt.gattc_evt.params.hvx;
             // Must be a notification, and event handle must match the handle for my characteristic.
             if (evt_hvx->handle == self->characteristic->handle) {
                 write_to_ringbuf(self, evt_hvx->data, evt_hvx->len);
@@ -143,7 +143,7 @@ STATIC bool packet_buffer_on_ble_client_evt(ble_evt_t *ble_evt, void *param) {
 }
 
 STATIC bool packet_buffer_on_ble_server_evt(ble_evt_t *ble_evt, void *param) {
-    bleio_packet_buffer_obj_t *self = (bleio_packet_buffer_obj_t *) param;
+    bleio_packet_buffer_obj_t *self = (bleio_packet_buffer_obj_t *)param;
     switch (ble_evt->header.evt_id) {
         case BLE_GATTS_EVT_WRITE: {
             uint16_t conn_handle = ble_evt->evt.gatts_evt.conn_handle;
@@ -160,7 +160,7 @@ STATIC bool packet_buffer_on_ble_server_evt(ble_evt_t *ble_evt, void *param) {
                 }
                 write_to_ringbuf(self, evt_write->data, evt_write->len);
             } else if (evt_write->handle == self->characteristic->cccd_handle) {
-                uint16_t cccd = *((uint16_t*) evt_write->data);
+                uint16_t cccd = *((uint16_t *)evt_write->data);
                 if (cccd & BLE_GATT_HVX_NOTIFICATION) {
                     self->conn_handle = conn_handle;
                 } else {
@@ -185,8 +185,8 @@ STATIC bool packet_buffer_on_ble_server_evt(ble_evt_t *ble_evt, void *param) {
 }
 
 void common_hal_bleio_packet_buffer_construct(
-        bleio_packet_buffer_obj_t *self, bleio_characteristic_obj_t *characteristic,
-        size_t buffer_size) {
+    bleio_packet_buffer_obj_t *self, bleio_characteristic_obj_t *characteristic,
+    size_t buffer_size) {
 
     self->characteristic = characteristic;
     self->client = self->characteristic->service->is_remote;
@@ -259,7 +259,7 @@ mp_int_t common_hal_bleio_packet_buffer_readinto(bleio_packet_buffer_obj_t *self
 
     // Get packet length, which is in first two bytes of packet.
     uint16_t packet_length;
-    ringbuf_get_n(&self->ringbuf, (uint8_t*) &packet_length, sizeof(uint16_t));
+    ringbuf_get_n(&self->ringbuf, (uint8_t *)&packet_length, sizeof(uint16_t));
 
     mp_int_t ret;
     if (packet_length > len) {
@@ -267,7 +267,7 @@ mp_int_t common_hal_bleio_packet_buffer_readinto(bleio_packet_buffer_obj_t *self
         ret = len - packet_length;
         // Discard the packet if it's too large. Don't fill data.
         while (packet_length--) {
-            (void) ringbuf_get(&self->ringbuf);
+            (void)ringbuf_get(&self->ringbuf);
         }
     } else {
         // Read as much as possible, but might be shorter than len.
@@ -281,7 +281,7 @@ mp_int_t common_hal_bleio_packet_buffer_readinto(bleio_packet_buffer_obj_t *self
     return ret;
 }
 
-mp_int_t common_hal_bleio_packet_buffer_write(bleio_packet_buffer_obj_t *self, uint8_t *data, size_t len, uint8_t* header, size_t header_len) {
+mp_int_t common_hal_bleio_packet_buffer_write(bleio_packet_buffer_obj_t *self, uint8_t *data, size_t len, uint8_t *header, size_t header_len) {
     if (self->outgoing[0] == NULL) {
         mp_raise_bleio_BluetoothError(translate("Writes not supported on Characteristic"));
     }
@@ -311,7 +311,7 @@ mp_int_t common_hal_bleio_packet_buffer_write(bleio_packet_buffer_obj_t *self, u
     uint8_t is_nested_critical_region;
     sd_nvic_critical_region_enter(&is_nested_critical_region);
 
-    uint8_t* pending = self->outgoing[self->pending_index];
+    uint8_t *pending = self->outgoing[self->pending_index];
 
     if (self->pending_size == 0) {
         memcpy(pending, header, header_len);
@@ -352,7 +352,7 @@ mp_int_t common_hal_bleio_packet_buffer_get_incoming_packet_length(bleio_packet_
             bleio_connection_internal_t *connection = bleio_conn_handle_to_connection(self->conn_handle);
             if (connection) {
                 return MIN(common_hal_bleio_connection_get_max_packet_length(connection),
-                           self->characteristic->max_length);
+                    self->characteristic->max_length);
             }
         }
         // There's no current connection, so we don't know the MTU, and
@@ -383,7 +383,7 @@ mp_int_t common_hal_bleio_packet_buffer_get_outgoing_packet_length(bleio_packet_
             bleio_connection_internal_t *connection = bleio_conn_handle_to_connection(self->conn_handle);
             if (connection) {
                 return MIN(common_hal_bleio_connection_get_max_packet_length(connection),
-                           self->characteristic->max_length);
+                    self->characteristic->max_length);
             }
         }
         // There's no current connection, so we don't know the MTU, and
diff --git a/ports/nrf/common-hal/_bleio/PacketBuffer.h b/ports/nrf/common-hal/_bleio/PacketBuffer.h
index 699291749..94e0f11d8 100644
--- a/ports/nrf/common-hal/_bleio/PacketBuffer.h
+++ b/ports/nrf/common-hal/_bleio/PacketBuffer.h
@@ -39,7 +39,7 @@ typedef struct {
     ringbuf_t ringbuf;
     // Two outgoing buffers to alternate between. One will be queued for transmission by the SD and
     // the other is waiting to be queued and can be extended.
-    uint8_t* outgoing[2];
+    uint8_t *outgoing[2];
     volatile uint16_t pending_size;
     // We remember the conn_handle so we can do a NOTIFY/INDICATE to a client.
     // We can find out the conn_handle on a Characteristic write or a CCCD write (but not a read).
diff --git a/ports/nrf/common-hal/_bleio/Service.c b/ports/nrf/common-hal/_bleio/Service.c
index 3159d3392..74e74fac9 100644
--- a/ports/nrf/common-hal/_bleio/Service.c
+++ b/ports/nrf/common-hal/_bleio/Service.c
@@ -34,7 +34,7 @@
 #include "shared-bindings/_bleio/Service.h"
 #include "shared-bindings/_bleio/Adapter.h"
 
-uint32_t _common_hal_bleio_service_construct(bleio_service_obj_t *self, bleio_uuid_obj_t *uuid, bool is_secondary, mp_obj_list_t * characteristic_list) {
+uint32_t _common_hal_bleio_service_construct(bleio_service_obj_t *self, bleio_uuid_obj_t *uuid, bool is_secondary, mp_obj_list_t *characteristic_list) {
     self->handle = 0xFFFF;
     self->uuid = uuid;
     self->characteristic_list = characteristic_list;
@@ -57,7 +57,7 @@ uint32_t _common_hal_bleio_service_construct(bleio_service_obj_t *self, bleio_uu
 
 void common_hal_bleio_service_construct(bleio_service_obj_t *self, bleio_uuid_obj_t *uuid, bool is_secondary) {
     check_nrf_error(_common_hal_bleio_service_construct(self, uuid, is_secondary,
-                                                        mp_obj_new_list(0, NULL)));
+        mp_obj_new_list(0, NULL)));
 }
 
 void bleio_service_from_connection(bleio_service_obj_t *self, mp_obj_t connection) {
@@ -86,15 +86,15 @@ bool common_hal_bleio_service_get_is_secondary(bleio_service_obj_t *self) {
 }
 
 void common_hal_bleio_service_add_characteristic(bleio_service_obj_t *self,
-                                                 bleio_characteristic_obj_t *characteristic,
-                                                 mp_buffer_info_t *initial_value_bufinfo) {
+    bleio_characteristic_obj_t *characteristic,
+    mp_buffer_info_t *initial_value_bufinfo) {
     ble_gatts_char_md_t char_md = {
-        .char_props.broadcast      = (characteristic->props & CHAR_PROP_BROADCAST) ? 1 : 0,
-        .char_props.read           = (characteristic->props & CHAR_PROP_READ) ? 1 : 0,
-        .char_props.write_wo_resp  = (characteristic->props & CHAR_PROP_WRITE_NO_RESPONSE) ? 1 : 0,
-        .char_props.write          = (characteristic->props & CHAR_PROP_WRITE) ? 1 : 0,
-        .char_props.notify         = (characteristic->props & CHAR_PROP_NOTIFY) ? 1 : 0,
-        .char_props.indicate       = (characteristic->props & CHAR_PROP_INDICATE) ? 1 : 0,
+        .char_props.broadcast = (characteristic->props & CHAR_PROP_BROADCAST) ? 1 : 0,
+        .char_props.read = (characteristic->props & CHAR_PROP_READ) ? 1 : 0,
+        .char_props.write_wo_resp = (characteristic->props & CHAR_PROP_WRITE_NO_RESPONSE) ? 1 : 0,
+        .char_props.write = (characteristic->props & CHAR_PROP_WRITE) ? 1 : 0,
+        .char_props.notify = (characteristic->props & CHAR_PROP_NOTIFY) ? 1 : 0,
+        .char_props.indicate = (characteristic->props & CHAR_PROP_INDICATE) ? 1 : 0,
     };
 
     ble_gatts_attr_md_t cccd_md = {
diff --git a/ports/nrf/common-hal/_bleio/UUID.c b/ports/nrf/common-hal/_bleio/UUID.c
index 0c79e980e..399bf23ed 100644
--- a/ports/nrf/common-hal/_bleio/UUID.c
+++ b/ports/nrf/common-hal/_bleio/UUID.c
@@ -67,7 +67,7 @@ void common_hal_bleio_uuid_get_uuid128(bleio_uuid_obj_t *self, uint8_t uuid128[1
     check_nrf_error(sd_ble_uuid_encode(&self->nrf_ble_uuid, &length, uuid128));
 }
 
-void common_hal_bleio_uuid_pack_into(bleio_uuid_obj_t *self, uint8_t* buf) {
+void common_hal_bleio_uuid_pack_into(bleio_uuid_obj_t *self, uint8_t *buf) {
     if (self->nrf_ble_uuid.type == BLE_UUID_TYPE_BLE) {
         buf[0] = self->nrf_ble_uuid.uuid & 0xff;
         buf[1] = self->nrf_ble_uuid.uuid >> 8;
diff --git a/ports/nrf/common-hal/_bleio/__init__.c b/ports/nrf/common-hal/_bleio/__init__.c
index 5293f7ad1..7248f8315 100644
--- a/ports/nrf/common-hal/_bleio/__init__.c
+++ b/ports/nrf/common-hal/_bleio/__init__.c
@@ -120,7 +120,7 @@ void common_hal_bleio_check_connected(uint16_t conn_handle) {
 }
 
 // GATTS read of a Characteristic or Descriptor.
-size_t common_hal_bleio_gatts_read(uint16_t handle, uint16_t conn_handle, uint8_t* buf, size_t len) {
+size_t common_hal_bleio_gatts_read(uint16_t handle, uint16_t conn_handle, uint8_t *buf, size_t len) {
     // conn_handle is ignored unless this is a system attribute.
     // If we're not connected, that's OK, because we can still read and write the local value.
 
@@ -147,7 +147,7 @@ void common_hal_bleio_gatts_write(uint16_t handle, uint16_t conn_handle, mp_buff
 }
 
 typedef struct {
-    uint8_t* buf;
+    uint8_t *buf;
     size_t len;
     size_t final_len;
     uint16_t conn_handle;
@@ -156,13 +156,13 @@ typedef struct {
 } read_info_t;
 
 STATIC bool _on_gattc_read_rsp_evt(ble_evt_t *ble_evt, void *param) {
-    read_info_t* read = param;
+    read_info_t *read = param;
     switch (ble_evt->header.evt_id) {
 
         // More events may be handled later, so keep this as a switch.
 
         case BLE_GATTC_EVT_READ_RSP: {
-            ble_gattc_evt_t* evt = &ble_evt->evt.gattc_evt;
+            ble_gattc_evt_t *evt = &ble_evt->evt.gattc_evt;
             ble_gattc_evt_read_rsp_t *response = &evt->params.read_rsp;
             if (read && evt->conn_handle == read->conn_handle) {
                 read->status = evt->gatt_status;
@@ -184,7 +184,7 @@ STATIC bool _on_gattc_read_rsp_evt(ble_evt_t *ble_evt, void *param) {
     return true;
 }
 
-size_t common_hal_bleio_gattc_read(uint16_t handle, uint16_t conn_handle, uint8_t* buf, size_t len) {
+size_t common_hal_bleio_gattc_read(uint16_t handle, uint16_t conn_handle, uint8_t *buf, size_t len) {
     common_hal_bleio_check_connected(conn_handle);
 
     read_info_t read_info;
diff --git a/ports/nrf/common-hal/_bleio/bonding.c b/ports/nrf/common-hal/_bleio/bonding.c
index 081ba992f..0c39bfe42 100644
--- a/ports/nrf/common-hal/_bleio/bonding.c
+++ b/ports/nrf/common-hal/_bleio/bonding.c
@@ -59,12 +59,12 @@ const uint32_t BONDING_FLAG = ('1' | '0' << 8 | 'D' << 16 | 'B' << 24);
 #if BONDING_DEBUG
 void bonding_print_block(bonding_block_t *block) {
     printf("at 0x%08lx: is_central: %1d, type: 0x%x, ediv: 0x%04x, data_length: %d\n",
-               (uint32_t) block, block->is_central, block->type, block->ediv, block->data_length);
+        (uint32_t)block, block->is_central, block->type, block->ediv, block->data_length);
 }
 
 void bonding_print_keys(bonding_keys_t *keys) {
-    for (size_t i = 0; i < sizeof(bonding_keys_t); i ++) {
-        printf("%x", ((uint8_t*) keys)[i]);
+    for (size_t i = 0; i < sizeof(bonding_keys_t); i++) {
+        printf("%x", ((uint8_t *)keys)[i]);
     }
     printf("\n");
 }
@@ -77,16 +77,16 @@ STATIC size_t compute_block_size(uint16_t data_length) {
 
 void bonding_erase_storage(void) {
     // Erase all pages in the bonding area.
-    for(uint32_t page_address = BONDING_PAGES_START_ADDR;
-        page_address < BONDING_PAGES_END_ADDR;
-        page_address += FLASH_PAGE_SIZE) {
+    for (uint32_t page_address = BONDING_PAGES_START_ADDR;
+         page_address < BONDING_PAGES_END_ADDR;
+         page_address += FLASH_PAGE_SIZE) {
         // Argument is page number, not address.
         sd_flash_page_erase_sync(page_address / FLASH_PAGE_SIZE);
     }
     // Write marker words at the beginning and the end of the bonding area.
     uint32_t flag = BONDING_FLAG;
-    sd_flash_write_sync((uint32_t *) BONDING_START_FLAG_ADDR, &flag, 1);
-    sd_flash_write_sync((uint32_t *) BONDING_END_FLAG_ADDR, &flag, 1);
+    sd_flash_write_sync((uint32_t *)BONDING_START_FLAG_ADDR, &flag, 1);
+    sd_flash_write_sync((uint32_t *)BONDING_END_FLAG_ADDR, &flag, 1);
 }
 
 // Given NULL to start or block address, return the address of the next valid block.
@@ -97,16 +97,16 @@ STATIC bonding_block_t *next_block(bonding_block_t *block) {
     while (1) {
         // Advance to next block.
         if (block == NULL) {
-            return (bonding_block_t *) BONDING_DATA_START_ADDR;
+            return (bonding_block_t *)BONDING_DATA_START_ADDR;
         } else if (block->type == BLOCK_UNUSED) {
             // Already at last block (the unused block).
             return NULL;
         }
 
         // Advance to next block.
-        block = (bonding_block_t *) ((uint8_t *) block + compute_block_size(block->data_length));
+        block = (bonding_block_t *)((uint8_t *)block + compute_block_size(block->data_length));
 
-        if (block >= (bonding_block_t *) BONDING_DATA_END_ADDR) {
+        if (block >= (bonding_block_t *)BONDING_DATA_END_ADDR) {
             // Went past end of bonding space.
             return NULL;
         }
@@ -133,20 +133,20 @@ STATIC bonding_block_t *find_existing_block(bool is_central, bonding_block_type_
         if (type == block->type) {
             if (type == BLOCK_UNUSED ||
                 (is_central == block->is_central && ediv == block->ediv)) {
-            return block;
+                return block;
             }
         }
     }
 }
 
 // Get an empty block large enough to store data_length data.
-STATIC bonding_block_t* find_unused_block(uint16_t data_length) {
+STATIC bonding_block_t *find_unused_block(uint16_t data_length) {
     bonding_block_t *unused_block = find_existing_block(true, BLOCK_UNUSED, EDIV_INVALID);
     // If no more room, erase all existing blocks and start over.
     if (!unused_block ||
-        (uint8_t *) unused_block + compute_block_size(data_length) >= (uint8_t *) BONDING_DATA_END_ADDR) {
+        (uint8_t *)unused_block + compute_block_size(data_length) >= (uint8_t *)BONDING_DATA_END_ADDR) {
         bonding_erase_storage();
-        unused_block = (bonding_block_t *) BONDING_DATA_START_ADDR;
+        unused_block = (bonding_block_t *)BONDING_DATA_START_ADDR;
     }
     return unused_block;
 }
@@ -155,12 +155,12 @@ STATIC bonding_block_t* find_unused_block(uint16_t data_length) {
 // We don't change data_length, so we can still skip over this block.
 STATIC void invalidate_block(bonding_block_t *block) {
     uint32_t zero = 0;
-    sd_flash_write_sync((uint32_t *) block, &zero, 1);
+    sd_flash_write_sync((uint32_t *)block, &zero, 1);
 }
 
 // Write bonding block header.
 STATIC void write_block_header(bonding_block_t *dest_block, bonding_block_t *source_block_header) {
-    sd_flash_write_sync((uint32_t *) dest_block, (uint32_t *) source_block_header, sizeof(bonding_block_t) / 4);
+    sd_flash_write_sync((uint32_t *)dest_block, (uint32_t *)source_block_header, sizeof(bonding_block_t) / 4);
 }
 
 // Write variable-length data at end of bonding block.
@@ -168,7 +168,7 @@ STATIC void write_block_data(bonding_block_t *dest_block, uint8_t *data, uint16_
     // Minimize the number of writes. Datasheet says no more than two writes per word before erasing again.
 
     // Start writing after the current header.
-    uint32_t *flash_word_p = (uint32_t *) ((uint8_t *) dest_block + sizeof(bonding_block_t));
+    uint32_t *flash_word_p = (uint32_t *)((uint8_t *)dest_block + sizeof(bonding_block_t));
     while (1) {
         uint32_t word = 0xffffffff;
         memcpy(&word, data, data_length >= 4 ? 4 : data_length);
@@ -186,11 +186,11 @@ STATIC void write_block_data(bonding_block_t *dest_block, uint8_t *data, uint16_
 STATIC void write_sys_attr_block(bleio_connection_internal_t *connection) {
     uint16_t length = 0;
     // First find out how big a buffer we need, then fetch the data.
-    if(sd_ble_gatts_sys_attr_get(connection->conn_handle, NULL, &length, SYS_ATTR_FLAGS) != NRF_SUCCESS) {
+    if (sd_ble_gatts_sys_attr_get(connection->conn_handle, NULL, &length, SYS_ATTR_FLAGS) != NRF_SUCCESS) {
         return;
     }
     uint8_t sys_attr[length];
-    if(sd_ble_gatts_sys_attr_get(connection->conn_handle, sys_attr, &length, SYS_ATTR_FLAGS) != NRF_SUCCESS) {
+    if (sd_ble_gatts_sys_attr_get(connection->conn_handle, sys_attr, &length, SYS_ATTR_FLAGS) != NRF_SUCCESS) {
         return;
     }
 
@@ -246,16 +246,16 @@ STATIC void write_keys_block(bleio_connection_internal_t *connection) {
     };
     bonding_block_t *new_block = find_unused_block(sizeof(bonding_keys_t));
     write_block_header(new_block, &block_header);
-    write_block_data(new_block, (uint8_t *) &connection->bonding_keys, sizeof(bonding_keys_t));
+    write_block_data(new_block, (uint8_t *)&connection->bonding_keys, sizeof(bonding_keys_t));
 }
 
 void bonding_clear_keys(bonding_keys_t *bonding_keys) {
-    memset((uint8_t*) bonding_keys, 0, sizeof(bonding_keys_t));
+    memset((uint8_t *)bonding_keys, 0, sizeof(bonding_keys_t));
 }
 
 void bonding_reset(void) {
-    if (BONDING_FLAG != *((uint32_t *) BONDING_START_FLAG_ADDR) ||
-        BONDING_FLAG != *((uint32_t *) BONDING_END_FLAG_ADDR)) {
+    if (BONDING_FLAG != *((uint32_t *)BONDING_START_FLAG_ADDR) ||
+        BONDING_FLAG != *((uint32_t *)BONDING_END_FLAG_ADDR)) {
         bonding_erase_storage();
     }
 }
@@ -292,7 +292,7 @@ bool bonding_load_cccd_info(bool is_central, uint16_t conn_handle, uint16_t ediv
     }
 
     return NRF_SUCCESS ==
-        sd_ble_gatts_sys_attr_set(conn_handle, block->data, block->data_length, SYS_ATTR_FLAGS);
+           sd_ble_gatts_sys_attr_set(conn_handle, block->data, block->data_length, SYS_ATTR_FLAGS);
 }
 
 bool bonding_load_keys(bool is_central, uint16_t ediv, bonding_keys_t *bonding_keys) {
diff --git a/ports/nrf/common-hal/_bleio/bonding.h b/ports/nrf/common-hal/_bleio/bonding.h
index cb8e7c427..c0dbe2aec 100644
--- a/ports/nrf/common-hal/_bleio/bonding.h
+++ b/ports/nrf/common-hal/_bleio/bonding.h
@@ -63,9 +63,9 @@ typedef enum {
 } bonding_block_type_t;
 
 typedef struct {
-    bool is_central: 1;            // 1 if data is for a central role.
-    uint16_t reserved: 7;          // Not currently used
-    bonding_block_type_t type: 8;  // What kind of data is stored in.
+    bool is_central : 1;            // 1 if data is for a central role.
+    uint16_t reserved : 7;          // Not currently used
+    bonding_block_type_t type : 8;  // What kind of data is stored in.
     uint16_t ediv;                 // ediv value; used as a lookup key.
     uint16_t conn_handle;          // Connection handle: used when a BLOCK_SYS_ATTR is queued to write.
                                    // Not used as a key, etc.
diff --git a/ports/nrf/common-hal/analogio/AnalogIn.c b/ports/nrf/common-hal/analogio/AnalogIn.c
index dbcc5281c..2f7bede16 100644
--- a/ports/nrf/common-hal/analogio/AnalogIn.c
+++ b/ports/nrf/common-hal/analogio/AnalogIn.c
@@ -39,14 +39,16 @@ void analogin_init(void) {
     nrf_saadc_enable(NRF_SAADC);
     nrf_saadc_event_clear(NRF_SAADC, NRF_SAADC_EVENT_CALIBRATEDONE);
     nrf_saadc_task_trigger(NRF_SAADC, NRF_SAADC_TASK_CALIBRATEOFFSET);
-    while (nrf_saadc_event_check(NRF_SAADC, NRF_SAADC_EVENT_CALIBRATEDONE) == 0) { }
+    while (nrf_saadc_event_check(NRF_SAADC, NRF_SAADC_EVENT_CALIBRATEDONE) == 0) {
+    }
     nrf_saadc_event_clear(NRF_SAADC, NRF_SAADC_EVENT_CALIBRATEDONE);
     nrf_saadc_disable(NRF_SAADC);
 }
 
 void common_hal_analogio_analogin_construct(analogio_analogin_obj_t *self, const mcu_pin_obj_t *pin) {
-    if (pin->adc_channel == 0)
+    if (pin->adc_channel == 0) {
         mp_raise_ValueError(translate("Pin does not have ADC capabilities"));
+    }
 
     nrf_gpio_cfg_default(pin->number);
 
@@ -59,8 +61,9 @@ bool common_hal_analogio_analogin_deinited(analogio_analogin_obj_t *self) {
 }
 
 void common_hal_analogio_analogin_deinit(analogio_analogin_obj_t *self) {
-    if (common_hal_analogio_analogin_deinited(self))
+    if (common_hal_analogio_analogin_deinited(self)) {
         return;
+    }
 
     nrf_gpio_cfg_default(self->pin->number);
 
@@ -88,32 +91,40 @@ uint16_t common_hal_analogio_analogin_get_value(analogio_analogin_obj_t *self) {
     nrf_saadc_oversample_set(NRF_SAADC, NRF_SAADC_OVERSAMPLE_DISABLED);
     nrf_saadc_enable(NRF_SAADC);
 
-    for (uint32_t i = 0; i < SAADC_CH_NUM; i++)
+    for (uint32_t i = 0; i < SAADC_CH_NUM; i++) {
         nrf_saadc_channel_input_set(NRF_SAADC, i, NRF_SAADC_INPUT_DISABLED, NRF_SAADC_INPUT_DISABLED);
+    }
 
     nrf_saadc_channel_init(NRF_SAADC, CHANNEL_NO, &config);
     nrf_saadc_channel_input_set(NRF_SAADC, CHANNEL_NO, self->pin->adc_channel, self->pin->adc_channel);
     nrf_saadc_buffer_init(NRF_SAADC, &value, 1);
 
     nrf_saadc_task_trigger(NRF_SAADC, NRF_SAADC_TASK_START);
-    while (nrf_saadc_event_check(NRF_SAADC, NRF_SAADC_EVENT_STARTED) == 0);
+    while (nrf_saadc_event_check(NRF_SAADC, NRF_SAADC_EVENT_STARTED) == 0) {
+        ;
+    }
     nrf_saadc_event_clear(NRF_SAADC, NRF_SAADC_EVENT_STARTED);
 
     nrf_saadc_task_trigger(NRF_SAADC, NRF_SAADC_TASK_SAMPLE);
-    while (nrf_saadc_event_check(NRF_SAADC, NRF_SAADC_EVENT_END) == 0);
+    while (nrf_saadc_event_check(NRF_SAADC, NRF_SAADC_EVENT_END) == 0) {
+        ;
+    }
     nrf_saadc_event_clear(NRF_SAADC, NRF_SAADC_EVENT_END);
 
     nrf_saadc_task_trigger(NRF_SAADC, NRF_SAADC_TASK_STOP);
-    while (nrf_saadc_event_check(NRF_SAADC, NRF_SAADC_EVENT_STOPPED) == 0);
+    while (nrf_saadc_event_check(NRF_SAADC, NRF_SAADC_EVENT_STOPPED) == 0) {
+        ;
+    }
     nrf_saadc_event_clear(NRF_SAADC, NRF_SAADC_EVENT_STOPPED);
 
     nrf_saadc_disable(NRF_SAADC);
 
-    if (value < 0)
+    if (value < 0) {
         value = 0;
+    }
 
     // Map value to from 14 to 16 bits
-    return (value << 2);
+    return value << 2;
 }
 
 float common_hal_analogio_analogin_get_reference_voltage(analogio_analogin_obj_t *self) {
diff --git a/ports/nrf/common-hal/analogio/AnalogIn.h b/ports/nrf/common-hal/analogio/AnalogIn.h
index a268bb54e..0f5fe3208 100644
--- a/ports/nrf/common-hal/analogio/AnalogIn.h
+++ b/ports/nrf/common-hal/analogio/AnalogIn.h
@@ -33,7 +33,7 @@
 
 typedef struct {
     mp_obj_base_t base;
-    const mcu_pin_obj_t * pin;
+    const mcu_pin_obj_t *pin;
 } analogio_analogin_obj_t;
 
 void analogin_init(void);
diff --git a/ports/nrf/common-hal/analogio/AnalogOut.c b/ports/nrf/common-hal/analogio/AnalogOut.c
index adafa15d5..7afa773d3 100644
--- a/ports/nrf/common-hal/analogio/AnalogOut.c
+++ b/ports/nrf/common-hal/analogio/AnalogOut.c
@@ -33,7 +33,7 @@
 #include "py/runtime.h"
 #include "supervisor/shared/translate.h"
 
-void common_hal_analogio_analogout_construct(analogio_analogout_obj_t* self, const mcu_pin_obj_t *pin) {
+void common_hal_analogio_analogout_construct(analogio_analogout_obj_t *self, const mcu_pin_obj_t *pin) {
     mp_raise_RuntimeError(translate("AnalogOut functionality not supported"));
 }
 
diff --git a/ports/nrf/common-hal/audiobusio/I2SOut.c b/ports/nrf/common-hal/audiobusio/I2SOut.c
index 34eecf8d5..ded03c07c 100644
--- a/ports/nrf/common-hal/audiobusio/I2SOut.c
+++ b/ports/nrf/common-hal/audiobusio/I2SOut.c
@@ -38,11 +38,20 @@
 
 static audiobusio_i2sout_obj_t *instance;
 
-struct { int16_t l, r; } static_sample16 = {0x8000, 0x8000};
-struct { uint8_t l1, r1, l2, r2; } static_sample8 = {0x80, 0x80, 0x80, 0x80};
-
-struct frequency_info { uint32_t RATIO; uint32_t MCKFREQ; int sample_rate; float abserr; };
-struct ratio_info { uint32_t RATIO; int16_t divisor; bool can_16bit; };
+struct { int16_t l, r;
+} static_sample16 = {0x8000, 0x8000};
+struct { uint8_t l1, r1, l2, r2;
+} static_sample8 = {0x80, 0x80, 0x80, 0x80};
+
+struct frequency_info { uint32_t RATIO;
+                        uint32_t MCKFREQ;
+                        int sample_rate;
+                        float abserr;
+};
+struct ratio_info { uint32_t RATIO;
+                    int16_t divisor;
+                    bool can_16bit;
+};
 struct ratio_info ratios[] = {
     { I2S_CONFIG_RATIO_RATIO_32X,   32,  true },
     { I2S_CONFIG_RATIO_RATIO_48X,   48, false },
@@ -55,7 +64,9 @@ struct ratio_info ratios[] = {
     { I2S_CONFIG_RATIO_RATIO_512X, 512,  true },
 };
 
-struct mclk_info { uint32_t MCKFREQ; int divisor; };
+struct mclk_info { uint32_t MCKFREQ;
+                   int divisor;
+};
 struct mclk_info mclks[] = {
     { I2S_CONFIG_MCKFREQ_MCKFREQ_32MDIV8,     8 },
     { I2S_CONFIG_MCKFREQ_MCKFREQ_32MDIV10,   10 },
@@ -71,7 +82,7 @@ struct mclk_info mclks[] = {
 };
 
 static void calculate_ratio_info(uint32_t target_sample_rate, struct frequency_info *info,
-        int ratio_index, int mclk_index) {
+    int ratio_index, int mclk_index) {
     info->RATIO = ratios[ratio_index].RATIO;
     info->MCKFREQ = mclks[mclk_index].MCKFREQ;
     info->sample_rate = 32000000
@@ -82,24 +93,24 @@ static void calculate_ratio_info(uint32_t target_sample_rate, struct frequency_i
 
 void choose_i2s_clocking(audiobusio_i2sout_obj_t *self, uint32_t sample_rate) {
     struct frequency_info best = {0, 0, 0, 1.0};
-    for (size_t ri=0; ri<sizeof(ratios) / sizeof(ratios[0]); ri++) {
+    for (size_t ri = 0; ri < sizeof(ratios) / sizeof(ratios[0]); ri++) {
         if (NRF_I2S->CONFIG.SWIDTH == I2S_CONFIG_SWIDTH_SWIDTH_16Bit
-                && !ratios[ri].can_16bit) {
+            && !ratios[ri].can_16bit) {
             continue;
         }
 
-        for (size_t mi=0; mi<sizeof(mclks) / sizeof(mclks[0]); mi++) {
+        for (size_t mi = 0; mi < sizeof(mclks) / sizeof(mclks[0]); mi++) {
             struct frequency_info info = {0, 0, 1.0};
             calculate_ratio_info(sample_rate, &info, ri, mi);
             if (info.abserr < best.abserr) {
                 best = info;
             }
-#ifdef DEBUG_CLOCKING
+            #ifdef DEBUG_CLOCKING
             mp_printf(&mp_plat_print,
-                    "RATIO=%3d MCKFREQ=%08x rate=%d abserr=%.4f\n",
-                    info.RATIO, info.MCKFREQ, info.sample_rate,
-                    (double)info.abserr);
-#endif
+                "RATIO=%3d MCKFREQ=%08x rate=%d abserr=%.4f\n",
+                info.RATIO, info.MCKFREQ, info.sample_rate,
+                (double)info.abserr);
+            #endif
         }
     }
     NRF_I2S->CONFIG.RATIO = best.RATIO;
@@ -107,7 +118,7 @@ void choose_i2s_clocking(audiobusio_i2sout_obj_t *self, uint32_t sample_rate) {
     self->sample_rate = best.sample_rate;
 }
 
-static void i2s_buffer_fill(audiobusio_i2sout_obj_t* self) {
+static void i2s_buffer_fill(audiobusio_i2sout_obj_t *self) {
     void *buffer = self->buffers[self->next_buffer];
     void *buffer_start = buffer;
     NRF_I2S->TXD.PTR = (uintptr_t)buffer;
@@ -119,7 +130,7 @@ static void i2s_buffer_fill(audiobusio_i2sout_obj_t* self) {
             uint32_t sample_buffer_length;
             audioio_get_buffer_result_t get_buffer_result =
                 audiosample_get_buffer(self->sample, false, 0,
-                                       &self->sample_data, &sample_buffer_length);
+                    &self->sample_data, &sample_buffer_length);
             self->sample_end = self->sample_data + sample_buffer_length;
             if (get_buffer_result == GET_BUFFER_DONE) {
                 if (self->loop) {
@@ -138,16 +149,16 @@ static void i2s_buffer_fill(audiobusio_i2sout_obj_t* self) {
         if (self->samples_signed) {
             memcpy(buffer, self->sample_data, bytecount);
         } else if (self->bytes_per_sample == 2) {
-            uint16_t *bp = (uint16_t*)buffer;
-            uint16_t *be = (uint16_t*)(buffer + bytecount);
-            uint16_t *sp = (uint16_t*)self->sample_data;
+            uint16_t *bp = (uint16_t *)buffer;
+            uint16_t *be = (uint16_t *)(buffer + bytecount);
+            uint16_t *sp = (uint16_t *)self->sample_data;
             for (; bp < be;) {
                 *bp++ = *sp++ + 0x8000;
             }
         } else {
-            uint8_t *bp = (uint8_t*)buffer;
-            uint8_t *be = (uint8_t*)(buffer + bytecount);
-            uint8_t *sp = (uint8_t*)self->sample_data;
+            uint8_t *bp = (uint8_t *)buffer;
+            uint8_t *be = (uint8_t *)(buffer + bytecount);
+            uint8_t *sp = (uint8_t *)self->sample_data;
             for (; bp < be;) {
                 *bp++ = *sp++ + 0x80;
             }
@@ -162,13 +173,13 @@ static void i2s_buffer_fill(audiobusio_i2sout_obj_t* self) {
     if (buffer != buffer_start) {
         if (self->bytes_per_sample == 1 && self->channel_count == 1) {
             // For 8-bit mono, 4 copies of the final sample are required
-            self->hold_value = 0x01010101 * *(uint8_t*)(buffer-1);
+            self->hold_value = 0x01010101 * *(uint8_t *)(buffer - 1);
         } else if (self->bytes_per_sample == 2 && self->channel_count == 2) {
             // For 16-bit stereo, 1 copy of the final sample is required
-            self->hold_value = *(uint32_t*)(buffer-4);
+            self->hold_value = *(uint32_t *)(buffer - 4);
         } else {
             // For 8-bit stereo and 16-bit mono, 2 copies of the final sample are required
-            self->hold_value = 0x00010001 * *(uint16_t*)(buffer-2);
+            self->hold_value = 0x00010001 * *(uint16_t *)(buffer - 2);
         }
     }
 
@@ -180,19 +191,21 @@ static void i2s_buffer_fill(audiobusio_i2sout_obj_t* self) {
             NRF_I2S->TASKS_STOP = 1;
             self->playing = false;
         }
-        uint32_t *bp = (uint32_t*)buffer;
-        uint32_t *be = (uint32_t*)(buffer + bytesleft);
-        for (; bp != be; )
+        uint32_t *bp = (uint32_t *)buffer;
+        uint32_t *be = (uint32_t *)(buffer + bytesleft);
+        for (; bp != be;) {
             *bp++ = self->hold_value;
+        }
         return;
     }
 }
 
-void common_hal_audiobusio_i2sout_construct(audiobusio_i2sout_obj_t* self,
-        const mcu_pin_obj_t* bit_clock, const mcu_pin_obj_t* word_select,
-        const mcu_pin_obj_t* data, bool left_justified) {
-    if (instance)
+void common_hal_audiobusio_i2sout_construct(audiobusio_i2sout_obj_t *self,
+    const mcu_pin_obj_t *bit_clock, const mcu_pin_obj_t *word_select,
+    const mcu_pin_obj_t *data, bool left_justified) {
+    if (instance) {
         mp_raise_RuntimeError(translate("Device in use"));
+    }
     instance = self;
 
     claim_pin(bit_clock);
@@ -216,11 +229,11 @@ void common_hal_audiobusio_i2sout_construct(audiobusio_i2sout_obj_t* self,
     supervisor_enable_tick();
 }
 
-bool common_hal_audiobusio_i2sout_deinited(audiobusio_i2sout_obj_t* self) {
+bool common_hal_audiobusio_i2sout_deinited(audiobusio_i2sout_obj_t *self) {
     return self->data_pin_number == 0xff;
 }
 
-void common_hal_audiobusio_i2sout_deinit(audiobusio_i2sout_obj_t* self) {
+void common_hal_audiobusio_i2sout_deinit(audiobusio_i2sout_obj_t *self) {
     if (common_hal_audiobusio_i2sout_deinited(self)) {
         return;
     }
@@ -236,8 +249,8 @@ void common_hal_audiobusio_i2sout_deinit(audiobusio_i2sout_obj_t* self) {
     supervisor_disable_tick();
 }
 
-void common_hal_audiobusio_i2sout_play(audiobusio_i2sout_obj_t* self,
-                                       mp_obj_t sample, bool loop) {
+void common_hal_audiobusio_i2sout_play(audiobusio_i2sout_obj_t *self,
+    mp_obj_t sample, bool loop) {
     if (common_hal_audiobusio_i2sout_get_playing(self)) {
         common_hal_audiobusio_i2sout_stop(self);
     }
@@ -271,7 +284,7 @@ void common_hal_audiobusio_i2sout_play(audiobusio_i2sout_obj_t* self,
      */
     enum { buffer_length_ms = 16 };
     self->buffer_length = sample_rate * buffer_length_ms
-            * self->bytes_per_sample * self->channel_count / 1000;
+        * self->bytes_per_sample * self->channel_count / 1000;
     self->buffer_length = (self->buffer_length + 3) & ~3;
     self->buffers[0] = m_malloc(self->buffer_length, false);
     self->buffers[1] = m_malloc(self->buffer_length, false);
@@ -297,25 +310,25 @@ void common_hal_audiobusio_i2sout_play(audiobusio_i2sout_obj_t* self,
     i2s_background();
 }
 
-void common_hal_audiobusio_i2sout_pause(audiobusio_i2sout_obj_t* self) {
+void common_hal_audiobusio_i2sout_pause(audiobusio_i2sout_obj_t *self) {
     self->paused = true;
 }
 
-void common_hal_audiobusio_i2sout_resume(audiobusio_i2sout_obj_t* self) {
+void common_hal_audiobusio_i2sout_resume(audiobusio_i2sout_obj_t *self) {
     self->paused = false;
 }
 
-bool common_hal_audiobusio_i2sout_get_paused(audiobusio_i2sout_obj_t* self) {
+bool common_hal_audiobusio_i2sout_get_paused(audiobusio_i2sout_obj_t *self) {
     return self->paused;
 }
 
-void common_hal_audiobusio_i2sout_stop(audiobusio_i2sout_obj_t* self) {
+void common_hal_audiobusio_i2sout_stop(audiobusio_i2sout_obj_t *self) {
     NRF_I2S->TASKS_STOP = 1;
     self->stopping = true;
     NRF_I2S->INTENCLR = I2S_INTENSET_TXPTRUPD_Msk;
 }
 
-bool common_hal_audiobusio_i2sout_get_playing(audiobusio_i2sout_obj_t* self) {
+bool common_hal_audiobusio_i2sout_get_playing(audiobusio_i2sout_obj_t *self) {
     if (NRF_I2S->EVENTS_STOPPED) {
         self->playing = false;
         NRF_I2S->EVENTS_STOPPED = 0;
diff --git a/ports/nrf/common-hal/audiobusio/PDMIn.c b/ports/nrf/common-hal/audiobusio/PDMIn.c
index ddd34174b..47d736577 100644
--- a/ports/nrf/common-hal/audiobusio/PDMIn.c
+++ b/ports/nrf/common-hal/audiobusio/PDMIn.c
@@ -35,13 +35,13 @@ NRF_PDM_Type *nrf_pdm = NRF_PDM;
 static uint32_t dummy_buffer[4];
 
 // Caller validates that pins are free.
-void common_hal_audiobusio_pdmin_construct(audiobusio_pdmin_obj_t* self,
-                                           const mcu_pin_obj_t* clock_pin,
-                                           const mcu_pin_obj_t* data_pin,
-                                           uint32_t sample_rate,
-                                           uint8_t bit_depth,
-                                           bool mono,
-                                           uint8_t oversample) {
+void common_hal_audiobusio_pdmin_construct(audiobusio_pdmin_obj_t *self,
+    const mcu_pin_obj_t *clock_pin,
+    const mcu_pin_obj_t *data_pin,
+    uint32_t sample_rate,
+    uint8_t bit_depth,
+    bool mono,
+    uint8_t oversample) {
     claim_pin(clock_pin);
     claim_pin(data_pin);
 
@@ -68,11 +68,11 @@ void common_hal_audiobusio_pdmin_construct(audiobusio_pdmin_obj_t* self,
     nrf_pdm->TASKS_START = 1;
 }
 
-bool common_hal_audiobusio_pdmin_deinited(audiobusio_pdmin_obj_t* self) {
+bool common_hal_audiobusio_pdmin_deinited(audiobusio_pdmin_obj_t *self) {
     return !self->clock_pin_number;
 }
 
-void common_hal_audiobusio_pdmin_deinit(audiobusio_pdmin_obj_t* self) {
+void common_hal_audiobusio_pdmin_deinit(audiobusio_pdmin_obj_t *self) {
     nrf_pdm->ENABLE = 0;
 
     reset_pin_number(self->clock_pin_number);
@@ -81,16 +81,16 @@ void common_hal_audiobusio_pdmin_deinit(audiobusio_pdmin_obj_t* self) {
     self->data_pin_number = 0;
 }
 
-uint8_t common_hal_audiobusio_pdmin_get_bit_depth(audiobusio_pdmin_obj_t* self) {
+uint8_t common_hal_audiobusio_pdmin_get_bit_depth(audiobusio_pdmin_obj_t *self) {
     return 16;
 }
 
-uint32_t common_hal_audiobusio_pdmin_get_sample_rate(audiobusio_pdmin_obj_t* self) {
+uint32_t common_hal_audiobusio_pdmin_get_sample_rate(audiobusio_pdmin_obj_t *self) {
     return 16000;
 }
 
-uint32_t common_hal_audiobusio_pdmin_record_to_buffer(audiobusio_pdmin_obj_t* self,
-        uint16_t* output_buffer, uint32_t output_buffer_length) {
+uint32_t common_hal_audiobusio_pdmin_record_to_buffer(audiobusio_pdmin_obj_t *self,
+    uint16_t *output_buffer, uint32_t output_buffer_length) {
     // Note: Adafruit's module has SELECT pulled to GND, which makes the DATA
     // valid when the CLK is low, therefore it must be sampled on the rising edge.
     if (self->mono) {
@@ -113,11 +113,11 @@ uint32_t common_hal_audiobusio_pdmin_record_to_buffer(audiobusio_pdmin_obj_t* se
 
     // Step 3. wait for PDM to end
     while (!nrf_pdm->EVENTS_END) {
-       MICROPY_VM_HOOK_LOOP;
+        MICROPY_VM_HOOK_LOOP;
     }
 
     // Step 4. They want unsigned
-    for (uint32_t i=0; i<output_buffer_length; i++) {
+    for (uint32_t i = 0; i < output_buffer_length; i++) {
         output_buffer[i] += 32768;
     }
 
diff --git a/ports/nrf/common-hal/audiopwmio/PWMAudioOut.c b/ports/nrf/common-hal/audiopwmio/PWMAudioOut.c
index 802f2bdc2..c3da51945 100644
--- a/ports/nrf/common-hal/audiopwmio/PWMAudioOut.c
+++ b/ports/nrf/common-hal/audiopwmio/PWMAudioOut.c
@@ -40,7 +40,7 @@
 #include "supervisor/shared/translate.h"
 
 // TODO: This should be the same size as PWMOut.c:pwms[], but there's no trivial way to accomplish that
-STATIC audiopwmio_pwmaudioout_obj_t* active_audio[4];
+STATIC audiopwmio_pwmaudioout_obj_t *active_audio[4];
 
 #define F_TARGET (62500)
 #define F_PWM (16000000)
@@ -55,17 +55,17 @@ STATIC uint32_t calculate_pwm_parameters(uint32_t sample_rate, uint32_t *top_out
     // the desired frequency is the closest integer multiple of sample_rate not less than F_TARGET
     uint32_t desired_frequency = (F_TARGET + sample_rate - 1) / sample_rate * sample_rate;
     // The top value is the PWM frequency divided by the desired frequency (round to nearest)
-    uint32_t top = (F_PWM + desired_frequency/2) / desired_frequency;
+    uint32_t top = (F_PWM + desired_frequency / 2) / desired_frequency;
     // The actual frequency is the PWM frequency divided by the top value (round to nearest)
-    uint32_t actual_frequency = (F_PWM + top/2) / top;
+    uint32_t actual_frequency = (F_PWM + top / 2) / top;
     // The multiplier is the actual frequency divided by the sample rate (round to nearest)
-    uint32_t multiplier = (actual_frequency + sample_rate/2) / sample_rate;
+    uint32_t multiplier = (actual_frequency + sample_rate / 2) / sample_rate;
     *top_out = top;
     return multiplier - 1;
 }
 
 STATIC void activate_audiopwmout_obj(audiopwmio_pwmaudioout_obj_t *self) {
-    for (size_t i=0; i < MP_ARRAY_SIZE(active_audio); i++) {
+    for (size_t i = 0; i < MP_ARRAY_SIZE(active_audio); i++) {
         if (!active_audio[i]) {
             active_audio[i] = self;
             supervisor_enable_tick();
@@ -76,7 +76,7 @@ STATIC void activate_audiopwmout_obj(audiopwmio_pwmaudioout_obj_t *self) {
 STATIC void deactivate_audiopwmout_obj(audiopwmio_pwmaudioout_obj_t *self) {
     // Turn off the interrupts to the CPU.
     self->pwm->INTENCLR = PWM_INTENSET_SEQSTARTED0_Msk | PWM_INTENSET_SEQSTARTED1_Msk;
-    for (size_t i=0; i < MP_ARRAY_SIZE(active_audio); i++) {
+    for (size_t i = 0; i < MP_ARRAY_SIZE(active_audio); i++) {
         if (active_audio[i] == self) {
             active_audio[i] = NULL;
             supervisor_disable_tick();
@@ -85,7 +85,7 @@ STATIC void deactivate_audiopwmout_obj(audiopwmio_pwmaudioout_obj_t *self) {
 }
 
 void audiopwmout_reset() {
-    for (size_t i=0; i < MP_ARRAY_SIZE(active_audio); i++) {
+    for (size_t i = 0; i < MP_ARRAY_SIZE(active_audio); i++) {
         if (active_audio[i]) {
             supervisor_disable_tick();
         }
@@ -99,7 +99,7 @@ STATIC void fill_buffers(audiopwmio_pwmaudioout_obj_t *self, int buf) {
     uint32_t buffer_length;
     audioio_get_buffer_result_t get_buffer_result =
         audiosample_get_buffer(self->sample, false, 0,
-                               &buffer, &buffer_length);
+            &buffer, &buffer_length);
     if (get_buffer_result == GET_BUFFER_ERROR) {
         common_hal_audiopwmio_pwmaudioout_stop(self);
         return;
@@ -114,23 +114,25 @@ STATIC void fill_buffers(audiopwmio_pwmaudioout_obj_t *self, int buf) {
             uint8_t rawval = (*buffer++ + offset);
             uint16_t val = (uint16_t)(((uint32_t)rawval * (uint32_t)scale) >> 8);
             *dev_buffer++ = val;
-            if (self->sample_channel_count == 1)
+            if (self->sample_channel_count == 1) {
                 *dev_buffer++ = val;
+            }
         }
     } else {
         uint16_t offset = self->signed_to_unsigned ? 0x8000 : 0;
         uint16_t scale = self->scale;
-        uint16_t *buffer16 = (uint16_t*)buffer;
+        uint16_t *buffer16 = (uint16_t *)buffer;
         while (dev_buffer < end_dev_buffer) {
             uint16_t rawval = (*buffer16++ + offset);
             uint16_t val = (uint16_t)((rawval * (uint32_t)scale) >> 16);
             *dev_buffer++ = val;
-            if (self->sample_channel_count == 1)
+            if (self->sample_channel_count == 1) {
                 *dev_buffer++ = val;
+            }
         }
     }
     self->pwm->SEQ[buf].PTR = (intptr_t)self->buffers[buf];
-    self->pwm->SEQ[buf].CNT = num_samples*2;
+    self->pwm->SEQ[buf].CNT = num_samples * 2;
 
     if (self->loop && get_buffer_result == GET_BUFFER_DONE) {
         audiosample_reset_buffer(self->sample, false, 0);
@@ -141,14 +143,16 @@ STATIC void fill_buffers(audiopwmio_pwmaudioout_obj_t *self, int buf) {
 }
 
 STATIC void audiopwmout_background_obj(audiopwmio_pwmaudioout_obj_t *self) {
-    if (!common_hal_audiopwmio_pwmaudioout_get_playing(self))
+    if (!common_hal_audiopwmio_pwmaudioout_get_playing(self)) {
         return;
+    }
     if (self->stopping) {
         bool stopped =
             (self->pwm->EVENTS_SEQEND[0] || !self->pwm->EVENTS_SEQSTARTED[0]) &&
             (self->pwm->EVENTS_SEQEND[1] || !self->pwm->EVENTS_SEQSTARTED[1]);
-        if (stopped)
+        if (stopped) {
             self->pwm->TASKS_STOP = 1;
+        }
     } else if (!self->paused && !self->single_buffer) {
         if (self->pwm->EVENTS_SEQSTARTED[0]) {
             fill_buffers(self, 1);
@@ -171,17 +175,19 @@ void audiopwmout_background() {
         return;
     }
     // Check our objects because the PWM could be active for some other reason.
-    for (size_t i=0; i < MP_ARRAY_SIZE(active_audio); i++) {
-        if (!active_audio[i]) continue;
+    for (size_t i = 0; i < MP_ARRAY_SIZE(active_audio); i++) {
+        if (!active_audio[i]) {
+            continue;
+        }
         audiopwmout_background_obj(active_audio[i]);
     }
 }
 
 // Caller validates that pins are free.
-void common_hal_audiopwmio_pwmaudioout_construct(audiopwmio_pwmaudioout_obj_t* self,
-        const mcu_pin_obj_t* left_channel, const mcu_pin_obj_t* right_channel, uint16_t quiescent_value) {
+void common_hal_audiopwmio_pwmaudioout_construct(audiopwmio_pwmaudioout_obj_t *self,
+    const mcu_pin_obj_t *left_channel, const mcu_pin_obj_t *right_channel, uint16_t quiescent_value) {
     self->pwm = pwmout_allocate(256, PWM_PRESCALER_PRESCALER_DIV_1, true, NULL, NULL,
-                                &self->pwm_irq);
+        &self->pwm_irq);
     if (!self->pwm) {
         mp_raise_RuntimeError(translate("All timers in use"));
     }
@@ -197,8 +203,7 @@ void common_hal_audiopwmio_pwmaudioout_construct(audiopwmio_pwmaudioout_obj_t* s
     self->pwm->PSEL.OUT[0] = self->left_channel_number = left_channel->number;
     claim_pin(left_channel);
 
-    if (right_channel)
-    {
+    if (right_channel) {
         self->pwm->PSEL.OUT[2] = self->right_channel_number = right_channel->number;
         claim_pin(right_channel);
     }
@@ -209,11 +214,11 @@ void common_hal_audiopwmio_pwmaudioout_construct(audiopwmio_pwmaudioout_obj_t* s
     // TODO: Ramp from 0 to quiescent value
 }
 
-bool common_hal_audiopwmio_pwmaudioout_deinited(audiopwmio_pwmaudioout_obj_t* self) {
+bool common_hal_audiopwmio_pwmaudioout_deinited(audiopwmio_pwmaudioout_obj_t *self) {
     return !self->pwm;
 }
 
-void common_hal_audiopwmio_pwmaudioout_deinit(audiopwmio_pwmaudioout_obj_t* self) {
+void common_hal_audiopwmio_pwmaudioout_deinit(audiopwmio_pwmaudioout_obj_t *self) {
     if (common_hal_audiopwmio_pwmaudioout_deinited(self)) {
         return;
     }
@@ -222,10 +227,12 @@ void common_hal_audiopwmio_pwmaudioout_deinit(audiopwmio_pwmaudioout_obj_t* self
     // TODO: ramp the pwm down from quiescent value to 0
     self->pwm->ENABLE = 0;
 
-    if (self->left_channel_number)
+    if (self->left_channel_number) {
         reset_pin_number(self->left_channel_number);
-    if (self->right_channel_number)
+    }
+    if (self->right_channel_number) {
         reset_pin_number(self->right_channel_number);
+    }
 
     pwmout_free_channel(self->pwm, 0);
     pwmout_free_channel(self->pwm, 2);
@@ -239,7 +246,7 @@ void common_hal_audiopwmio_pwmaudioout_deinit(audiopwmio_pwmaudioout_obj_t* self
     self->buffers[1] = NULL;
 }
 
-void common_hal_audiopwmio_pwmaudioout_play(audiopwmio_pwmaudioout_obj_t* self, mp_obj_t sample, bool loop) {
+void common_hal_audiopwmio_pwmaudioout_play(audiopwmio_pwmaudioout_obj_t *self, mp_obj_t sample, bool loop) {
     if (common_hal_audiopwmio_pwmaudioout_get_playing(self)) {
         common_hal_audiopwmio_pwmaudioout_stop(self);
     }
@@ -261,13 +268,14 @@ void common_hal_audiopwmio_pwmaudioout_play(audiopwmio_pwmaudioout_obj_t* self,
     }
     uint16_t buffer_length = (uint16_t)max_buffer_length;
     self->buffers[0] = m_malloc(buffer_length * 2 * sizeof(uint16_t), false);
-    if (!self->single_buffer)
+    if (!self->single_buffer) {
         self->buffers[1] = m_malloc(buffer_length * 2 * sizeof(uint16_t), false);
+    }
 
 
     uint32_t top;
     self->pwm->SEQ[0].REFRESH = self->pwm->SEQ[1].REFRESH = calculate_pwm_parameters(sample_rate, &top);
-    self->scale = top-1;
+    self->scale = top - 1;
     self->pwm->COUNTERTOP = top;
 
     self->pwm->LOOP = 1;
@@ -291,7 +299,7 @@ void common_hal_audiopwmio_pwmaudioout_play(audiopwmio_pwmaudioout_obj_t* self,
     self->paused = false;
 }
 
-void common_hal_audiopwmio_pwmaudioout_stop(audiopwmio_pwmaudioout_obj_t* self) {
+void common_hal_audiopwmio_pwmaudioout_stop(audiopwmio_pwmaudioout_obj_t *self) {
     deactivate_audiopwmout_obj(self);
     self->pwm->TASKS_STOP = 1;
     self->stopping = false;
@@ -304,7 +312,7 @@ void common_hal_audiopwmio_pwmaudioout_stop(audiopwmio_pwmaudioout_obj_t* self)
     self->buffers[1] = NULL;
 }
 
-bool common_hal_audiopwmio_pwmaudioout_get_playing(audiopwmio_pwmaudioout_obj_t* self) {
+bool common_hal_audiopwmio_pwmaudioout_get_playing(audiopwmio_pwmaudioout_obj_t *self) {
     if (!self->paused && self->pwm->EVENTS_STOPPED) {
         self->playing = false;
         self->pwm->EVENTS_STOPPED = 0;
@@ -328,12 +336,12 @@ bool common_hal_audiopwmio_pwmaudioout_get_playing(audiopwmio_pwmaudioout_obj_t*
  * feels instant. (This also saves on memory, for long in-memory "single buffer"
  * samples, since we have to locally take a resampled copy!)
  */
-void common_hal_audiopwmio_pwmaudioout_pause(audiopwmio_pwmaudioout_obj_t* self) {
+void common_hal_audiopwmio_pwmaudioout_pause(audiopwmio_pwmaudioout_obj_t *self) {
     self->paused = true;
     self->pwm->SHORTS = NRF_PWM_SHORT_SEQEND1_STOP_MASK;
 }
 
-void common_hal_audiopwmio_pwmaudioout_resume(audiopwmio_pwmaudioout_obj_t* self) {
+void common_hal_audiopwmio_pwmaudioout_resume(audiopwmio_pwmaudioout_obj_t *self) {
     self->paused = false;
     self->pwm->SHORTS = NRF_PWM_SHORT_LOOPSDONE_SEQSTART0_MASK;
     if (self->pwm->EVENTS_STOPPED) {
@@ -342,6 +350,6 @@ void common_hal_audiopwmio_pwmaudioout_resume(audiopwmio_pwmaudioout_obj_t* self
     }
 }
 
-bool common_hal_audiopwmio_pwmaudioout_get_paused(audiopwmio_pwmaudioout_obj_t* self) {
+bool common_hal_audiopwmio_pwmaudioout_get_paused(audiopwmio_pwmaudioout_obj_t *self) {
     return self->paused;
 }
diff --git a/ports/nrf/common-hal/busio/I2C.c b/ports/nrf/common-hal/busio/I2C.c
index 654fa857f..de9417a6c 100644
--- a/ports/nrf/common-hal/busio/I2C.c
+++ b/ports/nrf/common-hal/busio/I2C.c
@@ -42,24 +42,22 @@
 #define I2C_MAX_XFER_LEN         ((1UL << TWIM0_EASYDMA_MAXCNT_SIZE) - 1)
 
 STATIC twim_peripheral_t twim_peripherals[] = {
-#if NRFX_CHECK(NRFX_TWIM0_ENABLED)
+    #if NRFX_CHECK(NRFX_TWIM0_ENABLED)
     // SPIM0 and TWIM0 share an address.
     { .twim = NRFX_TWIM_INSTANCE(0),
-      .in_use = false
-    },
-#endif
-#if NRFX_CHECK(NRFX_TWIM1_ENABLED)
+      .in_use = false},
+    #endif
+    #if NRFX_CHECK(NRFX_TWIM1_ENABLED)
     // SPIM1 and TWIM1 share an address.
     { .twim = NRFX_TWIM_INSTANCE(1),
-      .in_use = false
-    },
-#endif
+      .in_use = false},
+    #endif
 };
 
 STATIC bool never_reset[MP_ARRAY_SIZE(twim_peripherals)];
 
 void i2c_reset(void) {
-    for (size_t i = 0 ; i < MP_ARRAY_SIZE(twim_peripherals); i++) {
+    for (size_t i = 0; i < MP_ARRAY_SIZE(twim_peripherals); i++) {
         if (never_reset[i]) {
             continue;
         }
@@ -69,7 +67,7 @@ void i2c_reset(void) {
 }
 
 void common_hal_busio_i2c_never_reset(busio_i2c_obj_t *self) {
-    for (size_t i = 0 ; i < MP_ARRAY_SIZE(twim_peripherals); i++) {
+    for (size_t i = 0; i < MP_ARRAY_SIZE(twim_peripherals); i++) {
         if (self->twim_peripheral == &twim_peripherals[i]) {
             never_reset[i] = true;
 
@@ -82,15 +80,15 @@ void common_hal_busio_i2c_never_reset(busio_i2c_obj_t *self) {
 
 static uint8_t twi_error_to_mp(const nrfx_err_t err) {
     switch (err) {
-    case NRFX_ERROR_DRV_TWI_ERR_ANACK:
-        return MP_ENODEV;
-    case NRFX_ERROR_BUSY:
-        return MP_EBUSY;
-    case NRFX_ERROR_DRV_TWI_ERR_DNACK:
-    case NRFX_ERROR_INVALID_ADDR:
-        return MP_EIO;
-    default:
-        break;
+        case NRFX_ERROR_DRV_TWI_ERR_ANACK:
+            return MP_ENODEV;
+        case NRFX_ERROR_BUSY:
+            return MP_EBUSY;
+        case NRFX_ERROR_DRV_TWI_ERR_DNACK:
+        case NRFX_ERROR_INVALID_ADDR:
+            return MP_EIO;
+        default:
+            break;
     }
 
     return 0;
@@ -103,7 +101,7 @@ void common_hal_busio_i2c_construct(busio_i2c_obj_t *self, const mcu_pin_obj_t *
 
     // Find a free instance.
     self->twim_peripheral = NULL;
-    for (size_t i = 0 ; i < MP_ARRAY_SIZE(twim_peripherals); i++) {
+    for (size_t i = 0; i < MP_ARRAY_SIZE(twim_peripherals); i++) {
         if (!twim_peripherals[i].in_use) {
             self->twim_peripheral = &twim_peripherals[i];
             // Mark it as in_use later after other validation is finished.
@@ -115,7 +113,7 @@ void common_hal_busio_i2c_construct(busio_i2c_obj_t *self, const mcu_pin_obj_t *
         mp_raise_ValueError(translate("All I2C peripherals are in use"));
     }
 
-#if CIRCUITPY_REQUIRE_I2C_PULLUPS
+    #if CIRCUITPY_REQUIRE_I2C_PULLUPS
     // Test that the pins are in a high state. (Hopefully indicating they are pulled up.)
     nrf_gpio_cfg_input(scl->number, NRF_GPIO_PIN_PULLDOWN);
     nrf_gpio_cfg_input(sda->number, NRF_GPIO_PIN_PULLDOWN);
@@ -133,19 +131,19 @@ void common_hal_busio_i2c_construct(busio_i2c_obj_t *self, const mcu_pin_obj_t *
         reset_pin_number(scl->number);
         mp_raise_RuntimeError(translate("No pull up found on SDA or SCL; check your wiring"));
     }
-#endif
+    #endif
 
     nrfx_twim_config_t config = NRFX_TWIM_DEFAULT_CONFIG(scl->number, sda->number);
 
-#if defined(TWIM_FREQUENCY_FREQUENCY_K1000)
+    #if defined(TWIM_FREQUENCY_FREQUENCY_K1000)
     if (frequency >= 1000000) {
         config.frequency = NRF_TWIM_FREQ_1000K;
     } else
-#endif
+    #endif
     if (frequency >= 400000) {
-      config.frequency = NRF_TWIM_FREQ_400K;
+        config.frequency = NRF_TWIM_FREQ_400K;
     } else if (frequency >= 250000) {
-      config.frequency = NRF_TWIM_FREQ_250K;
+        config.frequency = NRF_TWIM_FREQ_250K;
     } else {
         config.frequency = NRF_TWIM_FREQ_100K;
     }
@@ -198,11 +196,15 @@ bool common_hal_busio_i2c_probe(busio_i2c_obj_t *self, uint8_t addr) {
 
     nrf_twim_task_trigger(reg, NRF_TWIM_TASK_STARTTX);
     while (nrf_twim_event_check(reg, NRF_TWIM_EVENT_TXSTARTED) == 0 &&
-        nrf_twim_event_check(reg, NRF_TWIM_EVENT_ERROR) == 0);
+           nrf_twim_event_check(reg, NRF_TWIM_EVENT_ERROR) == 0) {
+        ;
+    }
     nrf_twim_event_clear(reg, NRF_TWIM_EVENT_TXSTARTED);
 
     nrf_twim_task_trigger(reg, NRF_TWIM_TASK_STOP);
-    while (nrf_twim_event_check(reg, NRF_TWIM_EVENT_STOPPED) == 0);
+    while (nrf_twim_event_check(reg, NRF_TWIM_EVENT_STOPPED) == 0) {
+        ;
+    }
     nrf_twim_event_clear(reg, NRF_TWIM_EVENT_STOPPED);
 
     if (nrf_twim_event_check(reg, NRF_TWIM_EVENT_ERROR)) {
@@ -237,7 +239,7 @@ void common_hal_busio_i2c_unlock(busio_i2c_obj_t *self) {
 }
 
 uint8_t common_hal_busio_i2c_write(busio_i2c_obj_t *self, uint16_t addr, const uint8_t *data, size_t len, bool stopBit) {
-    if(len == 0) {
+    if (len == 0) {
         return common_hal_busio_i2c_probe(self, addr) ? 0 : MP_ENODEV;
     }
 
@@ -246,12 +248,12 @@ uint8_t common_hal_busio_i2c_write(busio_i2c_obj_t *self, uint16_t addr, const u
     nrfx_twim_enable(&self->twim_peripheral->twim);
 
     // break into MAX_XFER_LEN transaction
-    while ( len ) {
+    while (len) {
         const size_t xact_len = MIN(len, I2C_MAX_XFER_LEN);
-        nrfx_twim_xfer_desc_t xfer_desc = NRFX_TWIM_XFER_DESC_TX(addr, (uint8_t*) data, xact_len);
+        nrfx_twim_xfer_desc_t xfer_desc = NRFX_TWIM_XFER_DESC_TX(addr, (uint8_t *)data, xact_len);
         uint32_t const flags = (stopBit ? 0 : NRFX_TWIM_FLAG_TX_NO_STOP);
 
-        if ( NRFX_SUCCESS != (err = nrfx_twim_xfer(&self->twim_peripheral->twim, &xfer_desc, flags)) ) {
+        if (NRFX_SUCCESS != (err = nrfx_twim_xfer(&self->twim_peripheral->twim, &xfer_desc, flags))) {
             break;
         }
 
@@ -265,7 +267,7 @@ uint8_t common_hal_busio_i2c_write(busio_i2c_obj_t *self, uint16_t addr, const u
 }
 
 uint8_t common_hal_busio_i2c_read(busio_i2c_obj_t *self, uint16_t addr, uint8_t *data, size_t len) {
-    if(len == 0) {
+    if (len == 0) {
         return 0;
     }
 
@@ -274,11 +276,11 @@ uint8_t common_hal_busio_i2c_read(busio_i2c_obj_t *self, uint16_t addr, uint8_t
     nrfx_twim_enable(&self->twim_peripheral->twim);
 
     // break into MAX_XFER_LEN transaction
-    while ( len ) {
+    while (len) {
         const size_t xact_len = MIN(len, I2C_MAX_XFER_LEN);
         nrfx_twim_xfer_desc_t xfer_desc = NRFX_TWIM_XFER_DESC_RX(addr, data, xact_len);
 
-        if ( NRFX_SUCCESS != (err = nrfx_twim_xfer(&self->twim_peripheral->twim, &xfer_desc, 0)) ) {
+        if (NRFX_SUCCESS != (err = nrfx_twim_xfer(&self->twim_peripheral->twim, &xfer_desc, 0))) {
             break;
         }
 
diff --git a/ports/nrf/common-hal/busio/I2C.h b/ports/nrf/common-hal/busio/I2C.h
index b75d15f00..04bc57868 100644
--- a/ports/nrf/common-hal/busio/I2C.h
+++ b/ports/nrf/common-hal/busio/I2C.h
@@ -38,7 +38,7 @@ typedef struct {
 
 typedef struct {
     mp_obj_base_t base;
-    twim_peripheral_t* twim_peripheral;
+    twim_peripheral_t *twim_peripheral;
     bool has_lock;
     uint8_t scl_pin_number;
     uint8_t sda_pin_number;
diff --git a/ports/nrf/common-hal/busio/SPI.c b/ports/nrf/common-hal/busio/SPI.c
index 1cf074955..309e1bce1 100644
--- a/ports/nrf/common-hal/busio/SPI.c
+++ b/ports/nrf/common-hal/busio/SPI.c
@@ -52,45 +52,41 @@
 
 // These are in order from highest available frequency to lowest (32MHz first, then 8MHz).
 STATIC spim_peripheral_t spim_peripherals[] = {
-#if NRFX_CHECK(NRFX_SPIM3_ENABLED)
+    #if NRFX_CHECK(NRFX_SPIM3_ENABLED)
     // SPIM3 exists only on nRF52840 and supports 32MHz max. All other SPIM's are only 8MHz max.
     // Allocate SPIM3 first.
     { .spim = NRFX_SPIM_INSTANCE(3),
       .max_frequency = 32000000,
-      .max_xfer_size = MIN(SPIM3_BUFFER_RAM_SIZE, (1UL << SPIM3_EASYDMA_MAXCNT_SIZE) - 1)
-    },
-#endif
-#if NRFX_CHECK(NRFX_SPIM2_ENABLED)
+      .max_xfer_size = MIN(SPIM3_BUFFER_RAM_SIZE, (1UL << SPIM3_EASYDMA_MAXCNT_SIZE) - 1)},
+    #endif
+    #if NRFX_CHECK(NRFX_SPIM2_ENABLED)
     // SPIM2 is not shared with a TWIM, so allocate before the shared ones.
     { .spim = NRFX_SPIM_INSTANCE(2),
       .max_frequency = 8000000,
-      .max_xfer_size = (1UL << SPIM2_EASYDMA_MAXCNT_SIZE) - 1
-    },
-#endif
-#if NRFX_CHECK(NRFX_SPIM1_ENABLED)
+      .max_xfer_size = (1UL << SPIM2_EASYDMA_MAXCNT_SIZE) - 1},
+    #endif
+    #if NRFX_CHECK(NRFX_SPIM1_ENABLED)
     // SPIM1 and TWIM1 share an address.
     { .spim = NRFX_SPIM_INSTANCE(1),
       .max_frequency = 8000000,
-      .max_xfer_size = (1UL << SPIM1_EASYDMA_MAXCNT_SIZE) - 1
-    },
-#endif
-#if NRFX_CHECK(NRFX_SPIM0_ENABLED)
+      .max_xfer_size = (1UL << SPIM1_EASYDMA_MAXCNT_SIZE) - 1},
+    #endif
+    #if NRFX_CHECK(NRFX_SPIM0_ENABLED)
     // SPIM0 and TWIM0 share an address.
     { .spim = NRFX_SPIM_INSTANCE(0),
       .max_frequency = 8000000,
-      .max_xfer_size = (1UL << SPIM0_EASYDMA_MAXCNT_SIZE) - 1
-    },
-#endif
+      .max_xfer_size = (1UL << SPIM0_EASYDMA_MAXCNT_SIZE) - 1},
+    #endif
 };
 
 STATIC bool never_reset[MP_ARRAY_SIZE(spim_peripherals)];
 
 // Separate RAM area for SPIM3 transmit buffer to avoid SPIM3 hardware errata.
 // https://infocenter.nordicsemi.com/index.jsp?topic=%2Ferrata_nRF52840_Rev2%2FERR%2FnRF52840%2FRev2%2Flatest%2Fanomaly_840_198.html
-STATIC uint8_t *spim3_transmit_buffer = (uint8_t *) SPIM3_BUFFER_RAM_START_ADDR;
+STATIC uint8_t *spim3_transmit_buffer = (uint8_t *)SPIM3_BUFFER_RAM_START_ADDR;
 
 void spi_reset(void) {
-    for (size_t i = 0 ; i < MP_ARRAY_SIZE(spim_peripherals); i++) {
+    for (size_t i = 0; i < MP_ARRAY_SIZE(spim_peripherals); i++) {
         if (never_reset[i]) {
             continue;
         }
@@ -99,7 +95,7 @@ void spi_reset(void) {
 }
 
 void common_hal_busio_spi_never_reset(busio_spi_obj_t *self) {
-    for (size_t i = 0 ; i < MP_ARRAY_SIZE(spim_peripherals); i++) {
+    for (size_t i = 0; i < MP_ARRAY_SIZE(spim_peripherals); i++) {
         if (self->spim_peripheral == &spim_peripherals[i]) {
             never_reset[i] = true;
 
@@ -119,12 +115,12 @@ static nrf_spim_frequency_t baudrate_to_spim_frequency(const uint32_t baudrate)
         const uint32_t boundary;
         nrf_spim_frequency_t spim_frequency;
     } baudrate_map[] = {
-#ifdef SPIM_FREQUENCY_FREQUENCY_M32
+        #ifdef SPIM_FREQUENCY_FREQUENCY_M32
         { 32000000, NRF_SPIM_FREQ_32M },
-#endif
-#ifdef SPIM_FREQUENCY_FREQUENCY_M16
+        #endif
+        #ifdef SPIM_FREQUENCY_FREQUENCY_M16
         { 16000000, NRF_SPIM_FREQ_16M },
-#endif
+        #endif
         {  8000000, NRF_SPIM_FREQ_8M },
         {  4000000, NRF_SPIM_FREQ_4M },
         {  2000000, NRF_SPIM_FREQ_2M },
@@ -147,10 +143,10 @@ static nrf_spim_frequency_t baudrate_to_spim_frequency(const uint32_t baudrate)
     return 0;
 }
 
-void common_hal_busio_spi_construct(busio_spi_obj_t *self, const mcu_pin_obj_t * clock, const mcu_pin_obj_t * mosi, const mcu_pin_obj_t * miso) {
+void common_hal_busio_spi_construct(busio_spi_obj_t *self, const mcu_pin_obj_t *clock, const mcu_pin_obj_t *mosi, const mcu_pin_obj_t *miso) {
     // Find a free instance, with most desirable (highest freq and not shared) allocated first.
     self->spim_peripheral = NULL;
-    for (size_t i = 0 ; i < MP_ARRAY_SIZE(spim_peripherals); i++) {
+    for (size_t i = 0; i < MP_ARRAY_SIZE(spim_peripherals); i++) {
         if ((spim_peripherals[i].spim.p_reg->ENABLE & SPIM_ENABLE_ENABLE_Msk) == 0) {
             self->spim_peripheral = &spim_peripherals[i];
             break;
@@ -162,7 +158,7 @@ void common_hal_busio_spi_construct(busio_spi_obj_t *self, const mcu_pin_obj_t *
     }
 
     nrfx_spim_config_t config = NRFX_SPIM_DEFAULT_CONFIG(NRFX_SPIM_PIN_NOT_USED, NRFX_SPIM_PIN_NOT_USED,
-                                                         NRFX_SPIM_PIN_NOT_USED, NRFX_SPIM_PIN_NOT_USED);
+        NRFX_SPIM_PIN_NOT_USED, NRFX_SPIM_PIN_NOT_USED);
 
     config.frequency = baudrate_to_spim_frequency(self->spim_peripheral->max_frequency);
 
@@ -198,8 +194,9 @@ bool common_hal_busio_spi_deinited(busio_spi_obj_t *self) {
 }
 
 void common_hal_busio_spi_deinit(busio_spi_obj_t *self) {
-    if (common_hal_busio_spi_deinited(self))
+    if (common_hal_busio_spi_deinited(self)) {
         return;
+    }
 
     nrfx_spim_uninit(&self->spim_peripheral->spim);
 
@@ -211,12 +208,12 @@ void common_hal_busio_spi_deinit(busio_spi_obj_t *self) {
 bool common_hal_busio_spi_configure(busio_spi_obj_t *self, uint32_t baudrate, uint8_t polarity, uint8_t phase, uint8_t bits) {
     // nrf52 does not support 16 bit
     if (bits != 8) {
-      return false;
+        return false;
     }
 
     // Set desired frequency, rounding down, and don't go above available frequency for this SPIM.
     nrf_spim_frequency_set(self->spim_peripheral->spim.p_reg,
-                           baudrate_to_spim_frequency(MIN(baudrate, self->spim_peripheral->max_frequency)));
+        baudrate_to_spim_frequency(MIN(baudrate, self->spim_peripheral->max_frequency)));
 
     nrf_spim_mode_t mode = NRF_SPIM_MODE_0;
     if (polarity) {
@@ -251,7 +248,7 @@ void common_hal_busio_spi_unlock(busio_spi_obj_t *self) {
 
 bool common_hal_busio_spi_write(busio_spi_obj_t *self, const uint8_t *data, size_t len) {
     const bool is_spim3 = self->spim_peripheral->spim.p_reg == NRF_SPIM3;
-    uint8_t *next_chunk = (uint8_t *) data;
+    uint8_t *next_chunk = (uint8_t *)data;
 
     while (len > 0) {
         size_t chunk_size = MIN(len, self->spim_peripheral->max_xfer_size);
@@ -301,7 +298,7 @@ bool common_hal_busio_spi_transfer(busio_spi_obj_t *self, const uint8_t *data_ou
         }
         const nrfx_spim_xfer_desc_t xfer =
             NRFX_SPIM_SINGLE_XFER(next_chunk_out, chunk_size,
-                                  next_chunk_in, chunk_size);
+                next_chunk_in, chunk_size);
         if (nrfx_spim_xfer(&self->spim_peripheral->spim, &xfer, 0) != NRFX_SUCCESS) {
             return false;
         }
@@ -313,39 +310,39 @@ bool common_hal_busio_spi_transfer(busio_spi_obj_t *self, const uint8_t *data_ou
     return true;
 }
 
-uint32_t common_hal_busio_spi_get_frequency(busio_spi_obj_t* self) {
+uint32_t common_hal_busio_spi_get_frequency(busio_spi_obj_t *self) {
     switch (self->spim_peripheral->spim.p_reg->FREQUENCY) {
-    case NRF_SPIM_FREQ_125K:
-        return 125000;
-    case NRF_SPIM_FREQ_250K:
-        return 250000;
-    case NRF_SPIM_FREQ_500K:
-        return 500000;
-    case NRF_SPIM_FREQ_1M:
-        return 1000000;
-    case NRF_SPIM_FREQ_2M:
-        return 2000000;
-    case NRF_SPIM_FREQ_4M:
-        return 4000000;
-    case NRF_SPIM_FREQ_8M:
-        return 8000000;
-#ifdef SPIM_FREQUENCY_FREQUENCY_M16
-    case NRF_SPIM_FREQ_16M:
-        return 16000000;
-#endif
-#ifdef SPIM_FREQUENCY_FREQUENCY_M32
-    case NRF_SPIM_FREQ_32M:
-        return 32000000;
-#endif
-    default:
-        return 0;
+        case NRF_SPIM_FREQ_125K:
+            return 125000;
+        case NRF_SPIM_FREQ_250K:
+            return 250000;
+        case NRF_SPIM_FREQ_500K:
+            return 500000;
+        case NRF_SPIM_FREQ_1M:
+            return 1000000;
+        case NRF_SPIM_FREQ_2M:
+            return 2000000;
+        case NRF_SPIM_FREQ_4M:
+            return 4000000;
+        case NRF_SPIM_FREQ_8M:
+            return 8000000;
+        #ifdef SPIM_FREQUENCY_FREQUENCY_M16
+        case NRF_SPIM_FREQ_16M:
+            return 16000000;
+        #endif
+        #ifdef SPIM_FREQUENCY_FREQUENCY_M32
+        case NRF_SPIM_FREQ_32M:
+            return 32000000;
+        #endif
+        default:
+            return 0;
     }
 }
 
-uint8_t common_hal_busio_spi_get_phase(busio_spi_obj_t* self) {
+uint8_t common_hal_busio_spi_get_phase(busio_spi_obj_t *self) {
     return (self->spim_peripheral->spim.p_reg->CONFIG & SPIM_CONFIG_CPHA_Msk) >> SPIM_CONFIG_CPHA_Pos;
 }
 
-uint8_t common_hal_busio_spi_get_polarity(busio_spi_obj_t* self) {
+uint8_t common_hal_busio_spi_get_polarity(busio_spi_obj_t *self) {
     return (self->spim_peripheral->spim.p_reg->CONFIG & SPIM_CONFIG_CPOL_Msk) >> SPIM_CONFIG_CPOL_Pos;
 }
diff --git a/ports/nrf/common-hal/busio/SPI.h b/ports/nrf/common-hal/busio/SPI.h
index ef3ac9531..796ff59f9 100644
--- a/ports/nrf/common-hal/busio/SPI.h
+++ b/ports/nrf/common-hal/busio/SPI.h
@@ -38,7 +38,7 @@ typedef struct {
 
 typedef struct {
     mp_obj_base_t base;
-    spim_peripheral_t* spim_peripheral;
+    spim_peripheral_t *spim_peripheral;
     bool has_lock;
     uint8_t clock_pin_number;
     uint8_t MOSI_pin_number;
diff --git a/ports/nrf/common-hal/busio/UART.c b/ports/nrf/common-hal/busio/UART.c
index 491e360e4..6436cb4e7 100644
--- a/ports/nrf/common-hal/busio/UART.c
+++ b/ports/nrf/common-hal/busio/UART.c
@@ -41,23 +41,23 @@
 
 // expression to examine, and return value in case of failing
 #define _VERIFY_ERR(_exp) \
-    do {\
-      uint32_t _err = (_exp);\
-      if (NRFX_SUCCESS != _err ) {\
-        mp_raise_msg_varg(&mp_type_RuntimeError, translate("error = 0x%08lX"), _err);\
-      }\
-    }while(0)
+    do { \
+        uint32_t _err = (_exp); \
+        if (NRFX_SUCCESS != _err) { \
+            mp_raise_msg_varg(&mp_type_RuntimeError, translate("error = 0x%08lX"), _err); \
+        } \
+    } while (0)
 
 static nrfx_uarte_t nrfx_uartes[] = {
-#if NRFX_CHECK(NRFX_UARTE0_ENABLED)
+    #if NRFX_CHECK(NRFX_UARTE0_ENABLED)
     NRFX_UARTE_INSTANCE(0),
-#endif
-#if NRFX_CHECK(NRFX_UARTE1_ENABLED)
+    #endif
+    #if NRFX_CHECK(NRFX_UARTE1_ENABLED)
     NRFX_UARTE_INSTANCE(1),
-#endif
+    #endif
 };
 
-static uint32_t get_nrf_baud (uint32_t baudrate) {
+static uint32_t get_nrf_baud(uint32_t baudrate) {
 
     static const struct {
         const uint32_t boundary;
@@ -70,9 +70,9 @@ static uint32_t get_nrf_baud (uint32_t baudrate) {
         { 14400, NRF_UARTE_BAUDRATE_14400 },
         { 19200, NRF_UARTE_BAUDRATE_19200 },
         { 28800, NRF_UARTE_BAUDRATE_28800 },
-	    { 31250, NRF_UARTE_BAUDRATE_31250 },
+        { 31250, NRF_UARTE_BAUDRATE_31250 },
         { 38400, NRF_UARTE_BAUDRATE_38400 },
-	    { 56000, NRF_UARTE_BAUDRATE_56000 },
+        { 56000, NRF_UARTE_BAUDRATE_56000 },
         { 57600, NRF_UARTE_BAUDRATE_57600 },
         { 76800, NRF_UARTE_BAUDRATE_76800 },
         { 115200, NRF_UARTE_BAUDRATE_115200 },
@@ -94,26 +94,26 @@ static uint32_t get_nrf_baud (uint32_t baudrate) {
     } while (true);
 }
 
-static void uart_callback_irq (const nrfx_uarte_event_t * event, void * context) {
-    busio_uart_obj_t* self = (busio_uart_obj_t*) context;
+static void uart_callback_irq(const nrfx_uarte_event_t *event, void *context) {
+    busio_uart_obj_t *self = (busio_uart_obj_t *)context;
 
-    switch ( event->type ) {
+    switch (event->type) {
         case NRFX_UARTE_EVT_RX_DONE:
             if (ringbuf_num_empty(&self->ringbuf) >= event->data.rxtx.bytes) {
                 ringbuf_put_n(&self->ringbuf, event->data.rxtx.p_data, event->data.rxtx.bytes);
                 // keep receiving
-                (void) nrfx_uarte_rx(self->uarte, &self->rx_char, 1);
+                (void)nrfx_uarte_rx(self->uarte, &self->rx_char, 1);
             } else {
                 // receive buffer full, suspend
                 self->rx_paused = true;
                 nrf_gpio_pin_write(self->rts_pin_number, true);
             }
 
-        break;
+            break;
 
         case NRFX_UARTE_EVT_TX_DONE:
             // nothing to do
-        break;
+            break;
 
         case NRFX_UARTE_EVT_ERROR:
             // Possible Error source is Overrun, Parity, Framing, Break
@@ -122,26 +122,26 @@ static void uart_callback_irq (const nrfx_uarte_event_t * event, void * context)
             ringbuf_put_n(&self->ringbuf, event->data.error.rxtx.p_data, event->data.error.rxtx.bytes);
 
             // Keep receiving
-            (void) nrfx_uarte_rx(self->uarte, &self->rx_char, 1);
-        break;
+            (void)nrfx_uarte_rx(self->uarte, &self->rx_char, 1);
+            break;
 
         default:
-        break;
+            break;
     }
 }
 
 void uart_reset(void) {
-    for (size_t i = 0 ; i < MP_ARRAY_SIZE(nrfx_uartes); i++) {
+    for (size_t i = 0; i < MP_ARRAY_SIZE(nrfx_uartes); i++) {
         nrfx_uarte_uninit(&nrfx_uartes[i]);
     }
 }
 
 void common_hal_busio_uart_construct(busio_uart_obj_t *self,
-    const mcu_pin_obj_t * tx, const mcu_pin_obj_t * rx,
-    const mcu_pin_obj_t * rts, const mcu_pin_obj_t * cts,
-    const mcu_pin_obj_t * rs485_dir, bool rs485_invert,
+    const mcu_pin_obj_t *tx, const mcu_pin_obj_t *rx,
+    const mcu_pin_obj_t *rts, const mcu_pin_obj_t *cts,
+    const mcu_pin_obj_t *rs485_dir, bool rs485_invert,
     uint32_t baudrate, uint8_t bits, busio_uart_parity_t parity, uint8_t stop,
-    mp_float_t timeout, uint16_t receiver_buffer_size, byte* receiver_buffer,
+    mp_float_t timeout, uint16_t receiver_buffer_size, byte *receiver_buffer,
     bool sigint_enabled) {
 
     if (bits != 8) {
@@ -154,7 +154,7 @@ void common_hal_busio_uart_construct(busio_uart_obj_t *self,
 
     // Find a free UART peripheral.
     self->uarte = NULL;
-    for (size_t i = 0 ; i < MP_ARRAY_SIZE(nrfx_uartes); i++) {
+    for (size_t i = 0; i < MP_ARRAY_SIZE(nrfx_uartes); i++) {
         if ((nrfx_uartes[i].p_reg->ENABLE & UARTE_ENABLE_ENABLE_Msk) == 0) {
             self->uarte = &nrfx_uartes[i];
             break;
@@ -165,15 +165,15 @@ void common_hal_busio_uart_construct(busio_uart_obj_t *self,
         mp_raise_ValueError(translate("All UART peripherals are in use"));
     }
 
-    if ( (tx == NULL) && (rx == NULL) ) {
+    if ((tx == NULL) && (rx == NULL)) {
         mp_raise_ValueError(translate("tx and rx cannot both be None"));
     }
 
-    if ( receiver_buffer_size == 0 ) {
+    if (receiver_buffer_size == 0) {
         mp_raise_ValueError(translate("Invalid buffer size"));
     }
 
-    if ( parity == BUSIO_UART_PARITY_ODD ) {
+    if (parity == BUSIO_UART_PARITY_ODD) {
         mp_raise_ValueError(translate("Odd parity is not supported"));
     }
 
@@ -196,7 +196,7 @@ void common_hal_busio_uart_construct(busio_uart_obj_t *self,
     _VERIFY_ERR(nrfx_uarte_init(self->uarte, &config, uart_callback_irq));
 
     // Init buffer for rx
-    if ( rx != NULL ) {
+    if (rx != NULL) {
         // Initially allocate the UART's buffer in the long-lived part of the
         // heap.  UARTs are generally long-lived objects, but the "make long-
         // lived" machinery is incapable of moving internal pointers like
@@ -213,21 +213,21 @@ void common_hal_busio_uart_construct(busio_uart_obj_t *self,
         claim_pin(rx);
     }
 
-    if ( tx != NULL ) {
+    if (tx != NULL) {
         self->tx_pin_number = tx->number;
         claim_pin(tx);
     } else {
         self->tx_pin_number = NO_PIN;
     }
 
-    if ( rts != NULL ) {
+    if (rts != NULL) {
         self->rts_pin_number = rts->number;
         claim_pin(rts);
     } else {
         self->rts_pin_number = NO_PIN;
     }
 
-    if ( cts != NULL ) {
+    if (cts != NULL) {
         self->cts_pin_number = cts->number;
         claim_pin(cts);
     } else {
@@ -248,7 +248,7 @@ bool common_hal_busio_uart_deinited(busio_uart_obj_t *self) {
 }
 
 void common_hal_busio_uart_deinit(busio_uart_obj_t *self) {
-    if ( !common_hal_busio_uart_deinited(self) ) {
+    if (!common_hal_busio_uart_deinited(self)) {
         nrfx_uarte_uninit(self->uarte);
         reset_pin_number(self->tx_pin_number);
         reset_pin_number(self->rx_pin_number);
@@ -264,7 +264,7 @@ void common_hal_busio_uart_deinit(busio_uart_obj_t *self) {
 
 // Read characters.
 size_t common_hal_busio_uart_read(busio_uart_obj_t *self, uint8_t *data, size_t len, int *errcode) {
-    if ( nrf_uarte_rx_pin_get(self->uarte->p_reg) == NRF_UARTE_PSEL_DISCONNECTED ) {
+    if (nrf_uarte_rx_pin_get(self->uarte->p_reg) == NRF_UARTE_PSEL_DISCONNECTED) {
         mp_raise_ValueError(translate("No RX pin"));
     }
 
@@ -278,10 +278,10 @@ 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_num_filled(&self->ringbuf) < len) && (supervisor_ticks_ms64() - start_ticks < self->timeout_ms) ) {
+    while ((ringbuf_num_filled(&self->ringbuf) < len) && (supervisor_ticks_ms64() - start_ticks < self->timeout_ms)) {
         RUN_BACKGROUND_TASKS;
         // Allow user to break out of a timeout with a KeyboardInterrupt.
-        if ( mp_hal_is_interrupted() ) {
+        if (mp_hal_is_interrupted()) {
             return 0;
         }
     }
@@ -297,7 +297,7 @@ size_t common_hal_busio_uart_read(busio_uart_obj_t *self, uint8_t *data, size_t
         // the character that did not fit in ringbuf is in rx_char
         ringbuf_put_n(&self->ringbuf, &self->rx_char, 1);
         // keep receiving
-        (void) nrfx_uarte_rx(self->uarte, &self->rx_char, 1);
+        (void)nrfx_uarte_rx(self->uarte, &self->rx_char, 1);
         nrf_gpio_pin_write(self->rts_pin_number, false);
         self->rx_paused = false;
     }
@@ -308,18 +308,20 @@ size_t common_hal_busio_uart_read(busio_uart_obj_t *self, uint8_t *data, size_t
 }
 
 // Write characters.
-size_t common_hal_busio_uart_write (busio_uart_obj_t *self, const uint8_t *data, size_t len, int *errcode) {
-    if ( nrf_uarte_tx_pin_get(self->uarte->p_reg) == NRF_UARTE_PSEL_DISCONNECTED ) {
+size_t common_hal_busio_uart_write(busio_uart_obj_t *self, const uint8_t *data, size_t len, int *errcode) {
+    if (nrf_uarte_tx_pin_get(self->uarte->p_reg) == NRF_UARTE_PSEL_DISCONNECTED) {
         mp_raise_ValueError(translate("No TX pin"));
     }
 
-    if ( len == 0 ) return 0;
+    if (len == 0) {
+        return 0;
+    }
 
     // EasyDMA can only access SRAM
-    uint8_t * tx_buf = (uint8_t*) data;
-    if ( !nrfx_is_in_ram(data) ) {
+    uint8_t *tx_buf = (uint8_t *)data;
+    if (!nrfx_is_in_ram(data)) {
         // TODO: If this is not too big, we could allocate it on the stack.
-        tx_buf = (uint8_t *) gc_alloc(len, false, false);
+        tx_buf = (uint8_t *)gc_alloc(len, false, false);
         memcpy(tx_buf, data, len);
     }
 
@@ -328,11 +330,11 @@ size_t common_hal_busio_uart_write (busio_uart_obj_t *self, const uint8_t *data,
     (*errcode) = 0;
 
     // Wait for write to complete.
-    while ( nrfx_uarte_tx_in_progress(self->uarte) ) {
+    while (nrfx_uarte_tx_in_progress(self->uarte)) {
         RUN_BACKGROUND_TASKS;
     }
 
-    if ( !nrfx_is_in_ram(data) ) {
+    if (!nrfx_is_in_ram(data)) {
         gc_free(tx_buf);
     }
 
@@ -349,7 +351,7 @@ void common_hal_busio_uart_set_baudrate(busio_uart_obj_t *self, uint32_t baudrat
 }
 
 mp_float_t common_hal_busio_uart_get_timeout(busio_uart_obj_t *self) {
-    return (mp_float_t) (self->timeout_ms / 1000.0f);
+    return (mp_float_t)(self->timeout_ms / 1000.0f);
 }
 
 void common_hal_busio_uart_set_timeout(busio_uart_obj_t *self, mp_float_t timeout) {
diff --git a/ports/nrf/common-hal/digitalio/DigitalInOut.c b/ports/nrf/common-hal/digitalio/DigitalInOut.c
index 2a72151b7..b42d7dc70 100644
--- a/ports/nrf/common-hal/digitalio/DigitalInOut.c
+++ b/ports/nrf/common-hal/digitalio/DigitalInOut.c
@@ -31,12 +31,12 @@
 #include "nrf_gpio.h"
 
 void common_hal_digitalio_digitalinout_never_reset(
-        digitalio_digitalinout_obj_t *self) {
+    digitalio_digitalinout_obj_t *self) {
     never_reset_pin_number(self->pin->number);
 }
 
 digitalinout_result_t common_hal_digitalio_digitalinout_construct(
-        digitalio_digitalinout_obj_t *self, const mcu_pin_obj_t *pin) {
+    digitalio_digitalinout_obj_t *self, const mcu_pin_obj_t *pin) {
     claim_pin(pin);
     self->pin = pin;
 
@@ -60,14 +60,14 @@ void common_hal_digitalio_digitalinout_deinit(digitalio_digitalinout_obj_t *self
 }
 
 void common_hal_digitalio_digitalinout_switch_to_input(
-        digitalio_digitalinout_obj_t *self, digitalio_pull_t pull) {
+    digitalio_digitalinout_obj_t *self, digitalio_pull_t pull) {
     nrf_gpio_cfg_input(self->pin->number, NRF_GPIO_PIN_NOPULL);
     common_hal_digitalio_digitalinout_set_pull(self, pull);
 }
 
 digitalinout_result_t common_hal_digitalio_digitalinout_switch_to_output(
-        digitalio_digitalinout_obj_t *self, bool value,
-        digitalio_drive_mode_t drive_mode) {
+    digitalio_digitalinout_obj_t *self, bool value,
+    digitalio_drive_mode_t drive_mode) {
 
     common_hal_digitalio_digitalinout_set_drive_mode(self, drive_mode);
     common_hal_digitalio_digitalinout_set_value(self, value);
@@ -75,53 +75,53 @@ digitalinout_result_t common_hal_digitalio_digitalinout_switch_to_output(
 }
 
 digitalio_direction_t common_hal_digitalio_digitalinout_get_direction(
-        digitalio_digitalinout_obj_t *self) {
+    digitalio_digitalinout_obj_t *self) {
 
     return (nrf_gpio_pin_dir_get(self->pin->number) == NRF_GPIO_PIN_DIR_INPUT)
         ? DIRECTION_INPUT : DIRECTION_OUTPUT;
 }
 
 void common_hal_digitalio_digitalinout_set_value(
-        digitalio_digitalinout_obj_t *self, bool value) {
+    digitalio_digitalinout_obj_t *self, bool value) {
     nrf_gpio_pin_write(self->pin->number, value);
 }
 
 bool common_hal_digitalio_digitalinout_get_value(
-        digitalio_digitalinout_obj_t *self) {
+    digitalio_digitalinout_obj_t *self) {
     return (nrf_gpio_pin_dir_get(self->pin->number) == NRF_GPIO_PIN_DIR_INPUT)
         ? nrf_gpio_pin_read(self->pin->number)
         : nrf_gpio_pin_out_read(self->pin->number);
 }
 
 digitalinout_result_t common_hal_digitalio_digitalinout_set_drive_mode(
-        digitalio_digitalinout_obj_t *self,
-        digitalio_drive_mode_t drive_mode) {
+    digitalio_digitalinout_obj_t *self,
+    digitalio_drive_mode_t drive_mode) {
     nrf_gpio_cfg(self->pin->number,
-                 NRF_GPIO_PIN_DIR_OUTPUT,
-                 NRF_GPIO_PIN_INPUT_DISCONNECT,
-                 NRF_GPIO_PIN_NOPULL,
-                 drive_mode == DRIVE_MODE_OPEN_DRAIN ? NRF_GPIO_PIN_H0D1 : NRF_GPIO_PIN_H0H1,
-                 NRF_GPIO_PIN_NOSENSE);
+        NRF_GPIO_PIN_DIR_OUTPUT,
+        NRF_GPIO_PIN_INPUT_DISCONNECT,
+        NRF_GPIO_PIN_NOPULL,
+        drive_mode == DRIVE_MODE_OPEN_DRAIN ? NRF_GPIO_PIN_H0D1 : NRF_GPIO_PIN_H0H1,
+        NRF_GPIO_PIN_NOSENSE);
     return DIGITALINOUT_OK;
 }
 
 digitalio_drive_mode_t common_hal_digitalio_digitalinout_get_drive_mode(
-        digitalio_digitalinout_obj_t *self) {
+    digitalio_digitalinout_obj_t *self) {
     uint32_t pin = self->pin->number;
     // Changes pin to be a relative pin number in port.
     NRF_GPIO_Type *reg = nrf_gpio_pin_port_decode(&pin);
 
     switch ((reg->PIN_CNF[pin] & GPIO_PIN_CNF_DRIVE_Msk) >> GPIO_PIN_CNF_DRIVE_Pos) {
-    case NRF_GPIO_PIN_S0D1:
-    case NRF_GPIO_PIN_H0D1:
-        return DRIVE_MODE_OPEN_DRAIN;
-    default:
-        return DRIVE_MODE_PUSH_PULL;
+        case NRF_GPIO_PIN_S0D1:
+        case NRF_GPIO_PIN_H0D1:
+            return DRIVE_MODE_OPEN_DRAIN;
+        default:
+            return DRIVE_MODE_PUSH_PULL;
     }
 }
 
 void common_hal_digitalio_digitalinout_set_pull(
-        digitalio_digitalinout_obj_t *self, digitalio_pull_t pull) {
+    digitalio_digitalinout_obj_t *self, digitalio_pull_t pull) {
     nrf_gpio_pin_pull_t hal_pull = NRF_GPIO_PIN_NOPULL;
 
     switch (pull) {
@@ -140,7 +140,7 @@ void common_hal_digitalio_digitalinout_set_pull(
 }
 
 digitalio_pull_t common_hal_digitalio_digitalinout_get_pull(
-        digitalio_digitalinout_obj_t *self) {
+    digitalio_digitalinout_obj_t *self) {
     uint32_t pin = self->pin->number;
     // Changes pin to be a relative pin number in port.
     NRF_GPIO_Type *reg = nrf_gpio_pin_port_decode(&pin);
diff --git a/ports/nrf/common-hal/displayio/ParallelBus.c b/ports/nrf/common-hal/displayio/ParallelBus.c
index 31ee1f48e..1afa6c4d6 100644
--- a/ports/nrf/common-hal/displayio/ParallelBus.c
+++ b/ports/nrf/common-hal/displayio/ParallelBus.c
@@ -33,9 +33,9 @@
 #include "shared-bindings/digitalio/DigitalInOut.h"
 #include "shared-bindings/microcontroller/__init__.h"
 
-void common_hal_displayio_parallelbus_construct(displayio_parallelbus_obj_t* self,
-    const mcu_pin_obj_t* data0, const mcu_pin_obj_t* command, const mcu_pin_obj_t* chip_select,
-    const mcu_pin_obj_t* write, const mcu_pin_obj_t* read, const mcu_pin_obj_t* reset) {
+void common_hal_displayio_parallelbus_construct(displayio_parallelbus_obj_t *self,
+    const mcu_pin_obj_t *data0, const mcu_pin_obj_t *command, const mcu_pin_obj_t *chip_select,
+    const mcu_pin_obj_t *write, const mcu_pin_obj_t *read, const mcu_pin_obj_t *reset) {
 
     uint8_t data_pin = data0->number;
     if (data_pin % 8 != 0) {
@@ -59,7 +59,7 @@ void common_hal_displayio_parallelbus_construct(displayio_parallelbus_obj_t* sel
     for (uint8_t i = 0; i < 8; i++) {
         g->PIN_CNF[data_pin + i] |= NRF_GPIO_PIN_S0S1 << GPIO_PIN_CNF_DRIVE_Pos;
     }
-    self->bus = ((uint8_t*) &g->OUT) + (data0->number % num_pins_in_port / 8);
+    self->bus = ((uint8_t *)&g->OUT) + (data0->number % num_pins_in_port / 8);
 
     self->command.base.type = &digitalio_digitalinout_type;
     common_hal_digitalio_digitalinout_construct(&self->command, command);
@@ -106,7 +106,7 @@ void common_hal_displayio_parallelbus_construct(displayio_parallelbus_obj_t* sel
     }
 }
 
-void common_hal_displayio_parallelbus_deinit(displayio_parallelbus_obj_t* self) {
+void common_hal_displayio_parallelbus_deinit(displayio_parallelbus_obj_t *self) {
     for (uint8_t i = 0; i < 8; i++) {
         reset_pin_number(self->data0_pin + i);
     }
@@ -119,7 +119,7 @@ void common_hal_displayio_parallelbus_deinit(displayio_parallelbus_obj_t* self)
 }
 
 bool common_hal_displayio_parallelbus_reset(mp_obj_t obj) {
-    displayio_parallelbus_obj_t* self = MP_OBJ_TO_PTR(obj);
+    displayio_parallelbus_obj_t *self = MP_OBJ_TO_PTR(obj);
     if (self->reset.base.type == &mp_type_NoneType) {
         return false;
     }
@@ -135,7 +135,7 @@ bool common_hal_displayio_parallelbus_bus_free(mp_obj_t obj) {
 }
 
 bool common_hal_displayio_parallelbus_begin_transaction(mp_obj_t obj) {
-    displayio_parallelbus_obj_t* self = MP_OBJ_TO_PTR(obj);
+    displayio_parallelbus_obj_t *self = MP_OBJ_TO_PTR(obj);
     common_hal_digitalio_digitalinout_set_value(&self->chip_select, false);
     return true;
 }
@@ -143,10 +143,10 @@ bool common_hal_displayio_parallelbus_begin_transaction(mp_obj_t obj) {
 // This ignores chip_select behaviour because data is clocked in by the write line toggling.
 void common_hal_displayio_parallelbus_send(mp_obj_t obj, display_byte_type_t byte_type,
     display_chip_select_behavior_t chip_select, const uint8_t *data, uint32_t data_length) {
-    displayio_parallelbus_obj_t* self = MP_OBJ_TO_PTR(obj);
+    displayio_parallelbus_obj_t *self = MP_OBJ_TO_PTR(obj);
     common_hal_digitalio_digitalinout_set_value(&self->command, byte_type == DISPLAY_DATA);
-    uint32_t* clear_write = (uint32_t*) &self->write_group->OUTCLR;
-    uint32_t* set_write = (uint32_t*) &self->write_group->OUTSET;
+    uint32_t *clear_write = (uint32_t *)&self->write_group->OUTCLR;
+    uint32_t *set_write = (uint32_t *)&self->write_group->OUTSET;
     uint32_t mask = self->write_mask;
     for (uint32_t i = 0; i < data_length; i++) {
         *clear_write = mask;
@@ -156,6 +156,6 @@ void common_hal_displayio_parallelbus_send(mp_obj_t obj, display_byte_type_t byt
 }
 
 void common_hal_displayio_parallelbus_end_transaction(mp_obj_t obj) {
-    displayio_parallelbus_obj_t* self = MP_OBJ_TO_PTR(obj);
+    displayio_parallelbus_obj_t *self = MP_OBJ_TO_PTR(obj);
     common_hal_digitalio_digitalinout_set_value(&self->chip_select, true);
 }
diff --git a/ports/nrf/common-hal/displayio/ParallelBus.h b/ports/nrf/common-hal/displayio/ParallelBus.h
index 5c10d3d42..30a0c7e61 100644
--- a/ports/nrf/common-hal/displayio/ParallelBus.h
+++ b/ports/nrf/common-hal/displayio/ParallelBus.h
@@ -31,14 +31,14 @@
 
 typedef struct {
     mp_obj_base_t base;
-    uint8_t* bus;
+    uint8_t *bus;
     digitalio_digitalinout_obj_t command;
     digitalio_digitalinout_obj_t chip_select;
     digitalio_digitalinout_obj_t reset;
     digitalio_digitalinout_obj_t write;
     digitalio_digitalinout_obj_t read;
     uint8_t data0_pin;
-    NRF_GPIO_Type* write_group;
+    NRF_GPIO_Type *write_group;
     uint32_t write_mask;
 } displayio_parallelbus_obj_t;
 
diff --git a/ports/nrf/common-hal/microcontroller/Pin.c b/ports/nrf/common-hal/microcontroller/Pin.c
index 23d6e23bf..aea4f63ea 100644
--- a/ports/nrf/common-hal/microcontroller/Pin.c
+++ b/ports/nrf/common-hal/microcontroller/Pin.c
@@ -49,16 +49,16 @@ STATIC uint32_t claimed_pins[GPIO_COUNT];
 STATIC uint32_t never_reset_pins[GPIO_COUNT];
 
 STATIC void reset_speaker_enable_pin(void) {
-#ifdef SPEAKER_ENABLE_PIN
+    #ifdef SPEAKER_ENABLE_PIN
     speaker_enable_in_use = false;
     nrf_gpio_cfg(SPEAKER_ENABLE_PIN->number,
-                 NRF_GPIO_PIN_DIR_OUTPUT,
-                 NRF_GPIO_PIN_INPUT_DISCONNECT,
-                 NRF_GPIO_PIN_NOPULL,
-                 NRF_GPIO_PIN_H0H1,
-                 NRF_GPIO_PIN_NOSENSE);
+        NRF_GPIO_PIN_DIR_OUTPUT,
+        NRF_GPIO_PIN_INPUT_DISCONNECT,
+        NRF_GPIO_PIN_NOPULL,
+        NRF_GPIO_PIN_H0H1,
+        NRF_GPIO_PIN_NOSENSE);
     nrf_gpio_pin_write(SPEAKER_ENABLE_PIN->number, false);
-#endif
+    #endif
 }
 
 void reset_all_pins(void) {
@@ -129,18 +129,18 @@ void never_reset_pin_number(uint8_t pin_number) {
     never_reset_pins[nrf_pin_port(pin_number)] |= 1 << nrf_relative_pin_number(pin_number);
 }
 
-void common_hal_never_reset_pin(const mcu_pin_obj_t* pin) {
+void common_hal_never_reset_pin(const mcu_pin_obj_t *pin) {
     never_reset_pin_number(pin->number);
 }
 
-void common_hal_reset_pin(const mcu_pin_obj_t* pin) {
+void common_hal_reset_pin(const mcu_pin_obj_t *pin) {
     if (pin == NULL) {
         return;
     }
     reset_pin_number(pin->number);
 }
 
-void claim_pin(const mcu_pin_obj_t* pin) {
+void claim_pin(const mcu_pin_obj_t *pin) {
     // Set bit in claimed_pins bitmask.
     claimed_pins[nrf_pin_port(pin->number)] |= 1 << nrf_relative_pin_number(pin->number);
 
@@ -204,11 +204,11 @@ bool common_hal_mcu_pin_is_free(const mcu_pin_obj_t *pin) {
 
 }
 
-uint8_t common_hal_mcu_pin_number(const mcu_pin_obj_t* pin) {
+uint8_t common_hal_mcu_pin_number(const mcu_pin_obj_t *pin) {
     return pin->number;
 }
 
-void common_hal_mcu_pin_claim(const mcu_pin_obj_t* pin) {
+void common_hal_mcu_pin_claim(const mcu_pin_obj_t *pin) {
     claim_pin(pin);
 }
 
diff --git a/ports/nrf/common-hal/microcontroller/Pin.h b/ports/nrf/common-hal/microcontroller/Pin.h
index 735ed90cc..888ab6a8c 100644
--- a/ports/nrf/common-hal/microcontroller/Pin.h
+++ b/ports/nrf/common-hal/microcontroller/Pin.h
@@ -43,7 +43,7 @@ void reset_all_pins(void);
 // reset_pin_number takes the pin number instead of the pointer so that objects don't
 // need to store a full pointer.
 void reset_pin_number(uint8_t pin);
-void claim_pin(const mcu_pin_obj_t* pin);
+void claim_pin(const mcu_pin_obj_t *pin);
 bool pin_number_is_free(uint8_t pin_number);
 void never_reset_pin_number(uint8_t pin_number);
 
diff --git a/ports/nrf/common-hal/microcontroller/Processor.c b/ports/nrf/common-hal/microcontroller/Processor.c
index ab5f29b5d..b31c4c12d 100644
--- a/ports/nrf/common-hal/microcontroller/Processor.c
+++ b/ports/nrf/common-hal/microcontroller/Processor.c
@@ -40,10 +40,10 @@
 float common_hal_mcu_processor_get_temperature(void) {
     int32_t temp = 0;
 
-#ifdef BLUETOOTH_SD
+    #ifdef BLUETOOTH_SD
     uint8_t sd_en = 0;
 
-    (void) sd_softdevice_is_enabled(&sd_en);
+    (void)sd_softdevice_is_enabled(&sd_en);
 
     if (sd_en) {
         uint32_t err_code = sd_temp_get(&temp);
@@ -52,9 +52,10 @@ float common_hal_mcu_processor_get_temperature(void) {
         }
         return temp / 4.0f;
     } // Fall through if SD not enabled.
-#endif
+    #endif
     NRF_TEMP->TASKS_START = 1;
-    while (NRF_TEMP->EVENTS_DATARDY == 0) { }
+    while (NRF_TEMP->EVENTS_DATARDY == 0) {
+    }
     NRF_TEMP->EVENTS_DATARDY = 0;
     temp = NRF_TEMP->TEMP;
     NRF_TEMP->TASKS_STOP = 1;
@@ -93,15 +94,18 @@ float common_hal_mcu_processor_get_voltage(void) {
     nrf_saadc_buffer_init(NRF_SAADC, &value, 1);
 
     nrf_saadc_task_trigger(NRF_SAADC, NRF_SAADC_TASK_START);
-    while (nrf_saadc_event_check(NRF_SAADC, NRF_SAADC_EVENT_STARTED) == 0) { }
+    while (nrf_saadc_event_check(NRF_SAADC, NRF_SAADC_EVENT_STARTED) == 0) {
+    }
     nrf_saadc_event_clear(NRF_SAADC, NRF_SAADC_EVENT_STARTED);
 
     nrf_saadc_task_trigger(NRF_SAADC, NRF_SAADC_TASK_SAMPLE);
-    while (nrf_saadc_event_check(NRF_SAADC, NRF_SAADC_EVENT_END) == 0) { }
+    while (nrf_saadc_event_check(NRF_SAADC, NRF_SAADC_EVENT_END) == 0) {
+    }
     nrf_saadc_event_clear(NRF_SAADC, NRF_SAADC_EVENT_END);
 
     nrf_saadc_task_trigger(NRF_SAADC, NRF_SAADC_TASK_STOP);
-    while (nrf_saadc_event_check(NRF_SAADC, NRF_SAADC_EVENT_STOPPED) == 0) { }
+    while (nrf_saadc_event_check(NRF_SAADC, NRF_SAADC_EVENT_STOPPED) == 0) {
+    }
     nrf_saadc_event_clear(NRF_SAADC, NRF_SAADC_EVENT_STOPPED);
 
     nrf_saadc_disable(NRF_SAADC);
@@ -111,14 +115,14 @@ float common_hal_mcu_processor_get_voltage(void) {
     }
 
 // The ADC reading we expect if VDD is 3.3V.
-#define NOMINAL_VALUE_3_3 (((3.3f/6)/0.6f)*16383)
-    return (value/NOMINAL_VALUE_3_3) * 3.3f;
+#define NOMINAL_VALUE_3_3 (((3.3f / 6) / 0.6f) * 16383)
+    return (value / NOMINAL_VALUE_3_3) * 3.3f;
 }
 
 
 void common_hal_mcu_processor_get_uid(uint8_t raw_id[]) {
-    for (int i=0; i<2; i++) {
-        ((uint32_t*) raw_id)[i] = NRF_FICR->DEVICEID[i];
+    for (int i = 0; i < 2; i++) {
+        ((uint32_t *)raw_id)[i] = NRF_FICR->DEVICEID[i];
     }
 }
 
diff --git a/ports/nrf/common-hal/microcontroller/__init__.c b/ports/nrf/common-hal/microcontroller/__init__.c
index 06aac9409..d84cc5845 100644
--- a/ports/nrf/common-hal/microcontroller/__init__.c
+++ b/ports/nrf/common-hal/microcontroller/__init__.c
@@ -82,12 +82,14 @@ void common_hal_mcu_enable_interrupts() {
 
 void common_hal_mcu_on_next_reset(mcu_runmode_t runmode) {
     enum { DFU_MAGIC_UF2_RESET = 0x57 };
-    if(runmode == RUNMODE_BOOTLOADER)
+    if (runmode == RUNMODE_BOOTLOADER) {
         NRF_POWER->GPREGRET = DFU_MAGIC_UF2_RESET;
-    else
+    } else {
         NRF_POWER->GPREGRET = 0;
-    if(runmode == RUNMODE_SAFE_MODE)
+    }
+    if (runmode == RUNMODE_SAFE_MODE) {
         safe_mode_on_next_reset(PROGRAMMATIC_SAFE_MODE);
+    }
 }
 
 void common_hal_mcu_reset(void) {
@@ -109,7 +111,7 @@ const nvm_bytearray_obj_t common_hal_mcu_nvm_obj = {
     .base = {
         .type = &nvm_bytearray_type,
     },
-    .start_address = (uint8_t*) CIRCUITPY_INTERNAL_NVM_START_ADDR,
+    .start_address = (uint8_t *)CIRCUITPY_INTERNAL_NVM_START_ADDR,
     .len = CIRCUITPY_INTERNAL_NVM_SIZE,
 };
 #endif
@@ -126,67 +128,67 @@ watchdog_watchdogtimer_obj_t common_hal_mcu_watchdogtimer_obj = {
 #endif
 
 STATIC const mp_rom_map_elem_t mcu_pin_globals_table[] = {
-  { MP_ROM_QSTR(MP_QSTR_P0_00), MP_ROM_PTR(&pin_P0_00) },
-  { MP_ROM_QSTR(MP_QSTR_P0_01), MP_ROM_PTR(&pin_P0_01) },
-  { MP_ROM_QSTR(MP_QSTR_P0_02), MP_ROM_PTR(&pin_P0_02) },
-  { MP_ROM_QSTR(MP_QSTR_P0_03), MP_ROM_PTR(&pin_P0_03) },
-  { MP_ROM_QSTR(MP_QSTR_P0_04), MP_ROM_PTR(&pin_P0_04) },
-  { MP_ROM_QSTR(MP_QSTR_P0_05), MP_ROM_PTR(&pin_P0_05) },
-  { MP_ROM_QSTR(MP_QSTR_P0_06), MP_ROM_PTR(&pin_P0_06) },
-  { MP_ROM_QSTR(MP_QSTR_P0_07), MP_ROM_PTR(&pin_P0_07) },
-  { MP_ROM_QSTR(MP_QSTR_P0_08), MP_ROM_PTR(&pin_P0_08) },
-  { MP_ROM_QSTR(MP_QSTR_P0_09), MP_ROM_PTR(&pin_P0_09) },
-  { MP_ROM_QSTR(MP_QSTR_P0_10), MP_ROM_PTR(&pin_P0_10) },
-  { MP_ROM_QSTR(MP_QSTR_P0_11), MP_ROM_PTR(&pin_P0_11) },
-  { MP_ROM_QSTR(MP_QSTR_P0_12), MP_ROM_PTR(&pin_P0_12) },
-  { MP_ROM_QSTR(MP_QSTR_P0_13), MP_ROM_PTR(&pin_P0_13) },
-  { MP_ROM_QSTR(MP_QSTR_P0_14), MP_ROM_PTR(&pin_P0_14) },
-  { MP_ROM_QSTR(MP_QSTR_P0_15), MP_ROM_PTR(&pin_P0_15) },
-  { MP_ROM_QSTR(MP_QSTR_P0_16), MP_ROM_PTR(&pin_P0_16) },
-  { MP_ROM_QSTR(MP_QSTR_P0_17), MP_ROM_PTR(&pin_P0_17) },
-  { MP_ROM_QSTR(MP_QSTR_P0_18), MP_ROM_PTR(&pin_P0_18) },
-  { MP_ROM_QSTR(MP_QSTR_P0_19), MP_ROM_PTR(&pin_P0_19) },
-  { MP_ROM_QSTR(MP_QSTR_P0_20), MP_ROM_PTR(&pin_P0_20) },
-  { MP_ROM_QSTR(MP_QSTR_P0_21), MP_ROM_PTR(&pin_P0_21) },
-  { MP_ROM_QSTR(MP_QSTR_P0_22), MP_ROM_PTR(&pin_P0_22) },
-  { MP_ROM_QSTR(MP_QSTR_P0_23), MP_ROM_PTR(&pin_P0_23) },
-  { MP_ROM_QSTR(MP_QSTR_P0_24), MP_ROM_PTR(&pin_P0_24) },
-  { MP_ROM_QSTR(MP_QSTR_P0_25), MP_ROM_PTR(&pin_P0_25) },
-  { MP_ROM_QSTR(MP_QSTR_P0_26), MP_ROM_PTR(&pin_P0_26) },
-  { MP_ROM_QSTR(MP_QSTR_P0_27), MP_ROM_PTR(&pin_P0_27) },
-  { MP_ROM_QSTR(MP_QSTR_P0_28), MP_ROM_PTR(&pin_P0_28) },
-  { MP_ROM_QSTR(MP_QSTR_P0_29), MP_ROM_PTR(&pin_P0_29) },
-  { MP_ROM_QSTR(MP_QSTR_P0_30), MP_ROM_PTR(&pin_P0_30) },
-  { MP_ROM_QSTR(MP_QSTR_P0_31), MP_ROM_PTR(&pin_P0_31) },
-#ifdef NRF52840
-  { MP_ROM_QSTR(MP_QSTR_P1_00), MP_ROM_PTR(&pin_P1_00) },
-  { MP_ROM_QSTR(MP_QSTR_P1_01), MP_ROM_PTR(&pin_P1_01) },
-  { MP_ROM_QSTR(MP_QSTR_P1_02), MP_ROM_PTR(&pin_P1_02) },
-  { MP_ROM_QSTR(MP_QSTR_P1_03), MP_ROM_PTR(&pin_P1_03) },
-  { MP_ROM_QSTR(MP_QSTR_P1_04), MP_ROM_PTR(&pin_P1_04) },
-  { MP_ROM_QSTR(MP_QSTR_P1_05), MP_ROM_PTR(&pin_P1_05) },
-  { MP_ROM_QSTR(MP_QSTR_P1_06), MP_ROM_PTR(&pin_P1_06) },
-  { MP_ROM_QSTR(MP_QSTR_P1_07), MP_ROM_PTR(&pin_P1_07) },
-  { MP_ROM_QSTR(MP_QSTR_P1_08), MP_ROM_PTR(&pin_P1_08) },
-  { MP_ROM_QSTR(MP_QSTR_P1_09), MP_ROM_PTR(&pin_P1_09) },
-  { MP_ROM_QSTR(MP_QSTR_P1_10), MP_ROM_PTR(&pin_P1_10) },
-  { MP_ROM_QSTR(MP_QSTR_P1_11), MP_ROM_PTR(&pin_P1_11) },
-  { MP_ROM_QSTR(MP_QSTR_P1_12), MP_ROM_PTR(&pin_P1_12) },
-  { MP_ROM_QSTR(MP_QSTR_P1_13), MP_ROM_PTR(&pin_P1_13) },
-  { MP_ROM_QSTR(MP_QSTR_P1_14), MP_ROM_PTR(&pin_P1_14) },
-  { MP_ROM_QSTR(MP_QSTR_P1_15), MP_ROM_PTR(&pin_P1_15) },
-#endif
-#ifdef NRF52833
-  { MP_ROM_QSTR(MP_QSTR_P1_00), MP_ROM_PTR(&pin_P1_00) },
-  { MP_ROM_QSTR(MP_QSTR_P1_01), MP_ROM_PTR(&pin_P1_01) },
-  { MP_ROM_QSTR(MP_QSTR_P1_02), MP_ROM_PTR(&pin_P1_02) },
-  { MP_ROM_QSTR(MP_QSTR_P1_03), MP_ROM_PTR(&pin_P1_03) },
-  { MP_ROM_QSTR(MP_QSTR_P1_04), MP_ROM_PTR(&pin_P1_04) },
-  { MP_ROM_QSTR(MP_QSTR_P1_05), MP_ROM_PTR(&pin_P1_05) },
-  { MP_ROM_QSTR(MP_QSTR_P1_06), MP_ROM_PTR(&pin_P1_06) },
-  { MP_ROM_QSTR(MP_QSTR_P1_07), MP_ROM_PTR(&pin_P1_07) },
-  { MP_ROM_QSTR(MP_QSTR_P1_08), MP_ROM_PTR(&pin_P1_08) },
-  { MP_ROM_QSTR(MP_QSTR_P1_09), MP_ROM_PTR(&pin_P1_09) },
-#endif
+    { MP_ROM_QSTR(MP_QSTR_P0_00), MP_ROM_PTR(&pin_P0_00) },
+    { MP_ROM_QSTR(MP_QSTR_P0_01), MP_ROM_PTR(&pin_P0_01) },
+    { MP_ROM_QSTR(MP_QSTR_P0_02), MP_ROM_PTR(&pin_P0_02) },
+    { MP_ROM_QSTR(MP_QSTR_P0_03), MP_ROM_PTR(&pin_P0_03) },
+    { MP_ROM_QSTR(MP_QSTR_P0_04), MP_ROM_PTR(&pin_P0_04) },
+    { MP_ROM_QSTR(MP_QSTR_P0_05), MP_ROM_PTR(&pin_P0_05) },
+    { MP_ROM_QSTR(MP_QSTR_P0_06), MP_ROM_PTR(&pin_P0_06) },
+    { MP_ROM_QSTR(MP_QSTR_P0_07), MP_ROM_PTR(&pin_P0_07) },
+    { MP_ROM_QSTR(MP_QSTR_P0_08), MP_ROM_PTR(&pin_P0_08) },
+    { MP_ROM_QSTR(MP_QSTR_P0_09), MP_ROM_PTR(&pin_P0_09) },
+    { MP_ROM_QSTR(MP_QSTR_P0_10), MP_ROM_PTR(&pin_P0_10) },
+    { MP_ROM_QSTR(MP_QSTR_P0_11), MP_ROM_PTR(&pin_P0_11) },
+    { MP_ROM_QSTR(MP_QSTR_P0_12), MP_ROM_PTR(&pin_P0_12) },
+    { MP_ROM_QSTR(MP_QSTR_P0_13), MP_ROM_PTR(&pin_P0_13) },
+    { MP_ROM_QSTR(MP_QSTR_P0_14), MP_ROM_PTR(&pin_P0_14) },
+    { MP_ROM_QSTR(MP_QSTR_P0_15), MP_ROM_PTR(&pin_P0_15) },
+    { MP_ROM_QSTR(MP_QSTR_P0_16), MP_ROM_PTR(&pin_P0_16) },
+    { MP_ROM_QSTR(MP_QSTR_P0_17), MP_ROM_PTR(&pin_P0_17) },
+    { MP_ROM_QSTR(MP_QSTR_P0_18), MP_ROM_PTR(&pin_P0_18) },
+    { MP_ROM_QSTR(MP_QSTR_P0_19), MP_ROM_PTR(&pin_P0_19) },
+    { MP_ROM_QSTR(MP_QSTR_P0_20), MP_ROM_PTR(&pin_P0_20) },
+    { MP_ROM_QSTR(MP_QSTR_P0_21), MP_ROM_PTR(&pin_P0_21) },
+    { MP_ROM_QSTR(MP_QSTR_P0_22), MP_ROM_PTR(&pin_P0_22) },
+    { MP_ROM_QSTR(MP_QSTR_P0_23), MP_ROM_PTR(&pin_P0_23) },
+    { MP_ROM_QSTR(MP_QSTR_P0_24), MP_ROM_PTR(&pin_P0_24) },
+    { MP_ROM_QSTR(MP_QSTR_P0_25), MP_ROM_PTR(&pin_P0_25) },
+    { MP_ROM_QSTR(MP_QSTR_P0_26), MP_ROM_PTR(&pin_P0_26) },
+    { MP_ROM_QSTR(MP_QSTR_P0_27), MP_ROM_PTR(&pin_P0_27) },
+    { MP_ROM_QSTR(MP_QSTR_P0_28), MP_ROM_PTR(&pin_P0_28) },
+    { MP_ROM_QSTR(MP_QSTR_P0_29), MP_ROM_PTR(&pin_P0_29) },
+    { MP_ROM_QSTR(MP_QSTR_P0_30), MP_ROM_PTR(&pin_P0_30) },
+    { MP_ROM_QSTR(MP_QSTR_P0_31), MP_ROM_PTR(&pin_P0_31) },
+    #ifdef NRF52840
+    { MP_ROM_QSTR(MP_QSTR_P1_00), MP_ROM_PTR(&pin_P1_00) },
+    { MP_ROM_QSTR(MP_QSTR_P1_01), MP_ROM_PTR(&pin_P1_01) },
+    { MP_ROM_QSTR(MP_QSTR_P1_02), MP_ROM_PTR(&pin_P1_02) },
+    { MP_ROM_QSTR(MP_QSTR_P1_03), MP_ROM_PTR(&pin_P1_03) },
+    { MP_ROM_QSTR(MP_QSTR_P1_04), MP_ROM_PTR(&pin_P1_04) },
+    { MP_ROM_QSTR(MP_QSTR_P1_05), MP_ROM_PTR(&pin_P1_05) },
+    { MP_ROM_QSTR(MP_QSTR_P1_06), MP_ROM_PTR(&pin_P1_06) },
+    { MP_ROM_QSTR(MP_QSTR_P1_07), MP_ROM_PTR(&pin_P1_07) },
+    { MP_ROM_QSTR(MP_QSTR_P1_08), MP_ROM_PTR(&pin_P1_08) },
+    { MP_ROM_QSTR(MP_QSTR_P1_09), MP_ROM_PTR(&pin_P1_09) },
+    { MP_ROM_QSTR(MP_QSTR_P1_10), MP_ROM_PTR(&pin_P1_10) },
+    { MP_ROM_QSTR(MP_QSTR_P1_11), MP_ROM_PTR(&pin_P1_11) },
+    { MP_ROM_QSTR(MP_QSTR_P1_12), MP_ROM_PTR(&pin_P1_12) },
+    { MP_ROM_QSTR(MP_QSTR_P1_13), MP_ROM_PTR(&pin_P1_13) },
+    { MP_ROM_QSTR(MP_QSTR_P1_14), MP_ROM_PTR(&pin_P1_14) },
+    { MP_ROM_QSTR(MP_QSTR_P1_15), MP_ROM_PTR(&pin_P1_15) },
+    #endif
+    #ifdef NRF52833
+    { MP_ROM_QSTR(MP_QSTR_P1_00), MP_ROM_PTR(&pin_P1_00) },
+    { MP_ROM_QSTR(MP_QSTR_P1_01), MP_ROM_PTR(&pin_P1_01) },
+    { MP_ROM_QSTR(MP_QSTR_P1_02), MP_ROM_PTR(&pin_P1_02) },
+    { MP_ROM_QSTR(MP_QSTR_P1_03), MP_ROM_PTR(&pin_P1_03) },
+    { MP_ROM_QSTR(MP_QSTR_P1_04), MP_ROM_PTR(&pin_P1_04) },
+    { MP_ROM_QSTR(MP_QSTR_P1_05), MP_ROM_PTR(&pin_P1_05) },
+    { MP_ROM_QSTR(MP_QSTR_P1_06), MP_ROM_PTR(&pin_P1_06) },
+    { MP_ROM_QSTR(MP_QSTR_P1_07), MP_ROM_PTR(&pin_P1_07) },
+    { MP_ROM_QSTR(MP_QSTR_P1_08), MP_ROM_PTR(&pin_P1_08) },
+    { MP_ROM_QSTR(MP_QSTR_P1_09), MP_ROM_PTR(&pin_P1_09) },
+    #endif
 };
 MP_DEFINE_CONST_DICT(mcu_pin_globals, mcu_pin_globals_table);
diff --git a/ports/nrf/common-hal/neopixel_write/__init__.c b/ports/nrf/common-hal/neopixel_write/__init__.c
index 8062937f4..c8aa44cd1 100644
--- a/ports/nrf/common-hal/neopixel_write/__init__.c
+++ b/ports/nrf/common-hal/neopixel_write/__init__.c
@@ -53,8 +53,8 @@
 // need to set the 15th bit on each register.
 
 // WS2812 (rev A) timing is 0.35 and 0.7us
-//#define MAGIC_T0H               5UL | (0x8000) // 0.3125us
-//#define MAGIC_T1H              12UL | (0x8000) // 0.75us
+// #define MAGIC_T0H               5UL | (0x8000) // 0.3125us
+// #define MAGIC_T1H              12UL | (0x8000) // 0.75us
 
 // WS2812B (rev B) timing is 0.4 and 0.8 us
 #define MAGIC_T0H               6UL | (0x8000) // 0.375us
@@ -78,18 +78,18 @@
 // ---------- END of Constants for cycle counter implementation --------
 
 // find a free PWM device, which is not enabled and has no connected pins
-static NRF_PWM_Type* find_free_pwm (void) {
-    NRF_PWM_Type* PWM[] = {
-            NRF_PWM0, NRF_PWM1, NRF_PWM2
-#ifdef NRF_PWM3
-            , NRF_PWM3
-#endif
+static NRF_PWM_Type *find_free_pwm(void) {
+    NRF_PWM_Type *PWM[] = {
+        NRF_PWM0, NRF_PWM1, NRF_PWM2
+        #ifdef NRF_PWM3
+        , NRF_PWM3
+        #endif
     };
 
-    for ( size_t device = 0; device < ARRAY_SIZE(PWM); device++ ) {
-        if ( (PWM[device]->ENABLE == 0) &&
-             (PWM[device]->PSEL.OUT[0] & PWM_PSEL_OUT_CONNECT_Msk) && (PWM[device]->PSEL.OUT[1] & PWM_PSEL_OUT_CONNECT_Msk) &&
-             (PWM[device]->PSEL.OUT[2] & PWM_PSEL_OUT_CONNECT_Msk) && (PWM[device]->PSEL.OUT[3] & PWM_PSEL_OUT_CONNECT_Msk) ) {
+    for (size_t device = 0; device < ARRAY_SIZE(PWM); device++) {
+        if ((PWM[device]->ENABLE == 0) &&
+            (PWM[device]->PSEL.OUT[0] & PWM_PSEL_OUT_CONNECT_Msk) && (PWM[device]->PSEL.OUT[1] & PWM_PSEL_OUT_CONNECT_Msk) &&
+            (PWM[device]->PSEL.OUT[2] & PWM_PSEL_OUT_CONNECT_Msk) && (PWM[device]->PSEL.OUT[3] & PWM_PSEL_OUT_CONNECT_Msk)) {
             return PWM[device];
         }
     }
@@ -106,7 +106,7 @@ void neopixel_write_reset(void) {
 
 uint64_t next_start_raw_ticks = 0;
 
-void common_hal_neopixel_write (const digitalio_digitalinout_obj_t* digitalinout, uint8_t *pixels, uint32_t numBytes) {
+void common_hal_neopixel_write(const digitalio_digitalinout_obj_t *digitalinout, uint8_t *pixels, uint32_t numBytes) {
     // To support both the SoftDevice + Neopixels we use the EasyDMA
     // feature from the NRF52. However this technique implies to
     // generate a pattern and store it on the memory. The actual
@@ -126,22 +126,22 @@ void common_hal_neopixel_write (const digitalio_digitalinout_obj_t* digitalinout
 // to handle larger NeoPixel rings without malloc'ing.
 #define STACK_PIXELS 24
     uint32_t pattern_size = PATTERN_SIZE(numBytes);
-    uint16_t* pixels_pattern = NULL;
+    uint16_t *pixels_pattern = NULL;
 
     // Use the stack to store STACK_PIXEL's worth of PWM data. uint32_t to ensure alignment.
     // It is 3*STACK_PIXELS to handle RGB.
     // PATTERN_SIZE is a multiple of 4, so we don't need round up to make sure one_pixel is large enough.
     uint32_t stack_pixels[PATTERN_SIZE(3 * STACK_PIXELS) / sizeof(uint32_t)];
 
-    NRF_PWM_Type* pwm = find_free_pwm();
+    NRF_PWM_Type *pwm = find_free_pwm();
 
     // only malloc if there is PWM device available
-    if ( pwm != NULL ) {
+    if (pwm != NULL) {
         if (pattern_size <= sizeof(stack_pixels)) {
-            pixels_pattern = (uint16_t *) stack_pixels;
+            pixels_pattern = (uint16_t *)stack_pixels;
         } else {
             uint8_t sd_en = 0;
-            (void) sd_softdevice_is_enabled(&sd_en);
+            (void)sd_softdevice_is_enabled(&sd_en);
 
             if (pixels_pattern_heap_size < pattern_size) {
                 // Current heap buffer is too small.
@@ -157,12 +157,12 @@ void common_hal_neopixel_write (const digitalio_digitalinout_obj_t* digitalinout
                     // transmit. This takes a bunch of memory to do so raise an
                     // exception if we can't.
                     MP_STATE_VM(pixels_pattern_heap) =
-                        (uint16_t *) m_realloc(MP_STATE_VM(pixels_pattern_heap), pattern_size);
+                        (uint16_t *)m_realloc(MP_STATE_VM(pixels_pattern_heap), pattern_size);
                 } else {
                     // Might return NULL.
                     MP_STATE_VM(pixels_pattern_heap) =
                         // true means move if necessary.
-                        (uint16_t *) m_realloc_maybe(MP_STATE_VM(pixels_pattern_heap), pattern_size, true);
+                        (uint16_t *)m_realloc_maybe(MP_STATE_VM(pixels_pattern_heap), pattern_size, true);
                 }
                 if (MP_STATE_VM(pixels_pattern_heap)) {
                     pixels_pattern_heap_size = pattern_size;
@@ -175,17 +175,18 @@ void common_hal_neopixel_write (const digitalio_digitalinout_obj_t* digitalinout
 
     // Wait to make sure we don't append onto the last transmission. This should only be a tick or
     // two.
-    while (port_get_raw_ticks(NULL) < next_start_raw_ticks) {}
+    while (port_get_raw_ticks(NULL) < next_start_raw_ticks) {
+    }
 
     // Use the identified device to choose the implementation
     // If a PWM device is available and we have a buffer, use DMA.
-    if ( (pixels_pattern != NULL) && (pwm != NULL) ) {
+    if ((pixels_pattern != NULL) && (pwm != NULL)) {
         uint16_t pos = 0;  // bit position
 
-        for ( uint16_t n = 0; n < numBytes; n++ ) {
+        for (uint16_t n = 0; n < numBytes; n++) {
             uint8_t pix = pixels[n];
 
-            for ( uint8_t mask = 0x80; mask > 0; mask >>= 1 ) {
+            for (uint8_t mask = 0x80; mask > 0; mask >>= 1) {
                 pixels_pattern[pos] = (pix & mask) ? MAGIC_T1H : MAGIC_T0H;
                 pos++;
             }
@@ -227,7 +228,7 @@ void common_hal_neopixel_write (const digitalio_digitalinout_obj_t* digitalinout
         //    pwm->INTEN |= (PWM_INTEN_SEQEND0_Enabled<<PWM_INTEN_SEQEND0_Pos);
 
         // PSEL must be configured before enabling PWM
-        nrf_pwm_pins_set(pwm, (uint32_t[]) {digitalinout->pin->number, 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL} );
+        nrf_pwm_pins_set(pwm, (uint32_t[]) {digitalinout->pin->number, 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL});
 
         // Enable the PWM
         nrf_pwm_enable(pwm);
@@ -238,7 +239,7 @@ void common_hal_neopixel_write (const digitalio_digitalinout_obj_t* digitalinout
         nrf_pwm_task_trigger(pwm, NRF_PWM_TASK_SEQSTART0);
 
         // But we have to wait for the flag to be set.
-        while ( !nrf_pwm_event_check(pwm, NRF_PWM_EVENT_SEQEND0) ) {
+        while (!nrf_pwm_event_check(pwm, NRF_PWM_EVENT_SEQEND0)) {
             RUN_BACKGROUND_TASKS;
         }
 
@@ -250,7 +251,7 @@ void common_hal_neopixel_write (const digitalio_digitalinout_obj_t* digitalinout
         // be selected on the next call.
         // TODO: Check if disabling the device causes performance issues.
         nrf_pwm_disable(pwm);
-        nrf_pwm_pins_set(pwm, (uint32_t[]) {0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL} );
+        nrf_pwm_pins_set(pwm, (uint32_t[]) {0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL});
 
     } // End of DMA implementation
     // ---------------------------------------------------------------------
@@ -264,9 +265,9 @@ void common_hal_neopixel_write (const digitalio_digitalinout_obj_t* digitalinout
         __disable_irq();
 
         uint32_t decoded_pin = digitalinout->pin->number;
-        NRF_GPIO_Type* port = nrf_gpio_pin_port_decode(&decoded_pin);
+        NRF_GPIO_Type *port = nrf_gpio_pin_port_decode(&decoded_pin);
 
-        uint32_t pinMask = ( 1UL << decoded_pin );
+        uint32_t pinMask = (1UL << decoded_pin);
 
         uint32_t CYCLES_X00 = CYCLES_800;
         uint32_t CYCLES_X00_T1H = CYCLES_800_T1H;
@@ -277,39 +278,43 @@ void common_hal_neopixel_write (const digitalio_digitalinout_obj_t* digitalinout
         DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;
 
         // Tries to re-send the frame if is interrupted by the SoftDevice.
-        while ( 1 ) {
+        while (1) {
             uint8_t *p = pixels;
 
             uint32_t cycStart = DWT->CYCCNT;
             uint32_t cyc = 0;
 
-            for ( uint16_t n = 0; n < numBytes; n++ ) {
+            for (uint16_t n = 0; n < numBytes; n++) {
                 uint8_t pix = *p++;
 
-                for ( uint8_t mask = 0x80; mask; mask >>= 1 ) {
-                    while ( DWT->CYCCNT - cyc < CYCLES_X00 )
+                for (uint8_t mask = 0x80; mask; mask >>= 1) {
+                    while (DWT->CYCCNT - cyc < CYCLES_X00) {
                         ;
+                    }
                     cyc = DWT->CYCCNT;
 
                     port->OUTSET |= pinMask;
 
-                    if ( pix & mask ) {
-                        while ( DWT->CYCCNT - cyc < CYCLES_X00_T1H )
+                    if (pix & mask) {
+                        while (DWT->CYCCNT - cyc < CYCLES_X00_T1H) {
                             ;
+                        }
                     } else {
-                        while ( DWT->CYCCNT - cyc < CYCLES_X00_T0H )
+                        while (DWT->CYCCNT - cyc < CYCLES_X00_T0H) {
                             ;
+                        }
                     }
 
                     port->OUTCLR |= pinMask;
                 }
             }
-            while ( DWT->CYCCNT - cyc < CYCLES_X00 )
+            while (DWT->CYCCNT - cyc < CYCLES_X00) {
                 ;
+            }
 
             // If total time longer than 25%, resend the whole data.
             // Since we are likely to be interrupted by SoftDevice
-            if ( (DWT->CYCCNT - cycStart) < (8 * numBytes * ((CYCLES_X00 * 5) / 4)) ) {
+            if ((DWT->CYCCNT - cycStart) < (8 * numBytes * ((CYCLES_X00 * 5) / 4))) {
                 break;
             }
 
diff --git a/ports/nrf/common-hal/nvm/ByteArray.c b/ports/nrf/common-hal/nvm/ByteArray.c
index 6b2f04a61..5af2cc563 100644
--- a/ports/nrf/common-hal/nvm/ByteArray.c
+++ b/ports/nrf/common-hal/nvm/ByteArray.c
@@ -51,9 +51,9 @@ static bool write_page(uint32_t page_addr, uint32_t offset, uint32_t len, uint8_
 }
 
 bool common_hal_nvm_bytearray_set_bytes(nvm_bytearray_obj_t *self,
-        uint32_t start_index, uint8_t* values, uint32_t len) {
+    uint32_t start_index, uint8_t *values, uint32_t len) {
 
-    uint32_t address = (uint32_t) self->start_address + start_index;
+    uint32_t address = (uint32_t)self->start_address + start_index;
     uint32_t offset = address % FLASH_PAGE_SIZE;
     uint32_t page_addr = address - offset;
 
@@ -71,6 +71,6 @@ bool common_hal_nvm_bytearray_set_bytes(nvm_bytearray_obj_t *self,
 }
 
 void common_hal_nvm_bytearray_get_bytes(nvm_bytearray_obj_t *self,
-    uint32_t start_index, uint32_t len, uint8_t* values) {
+    uint32_t start_index, uint32_t len, uint8_t *values) {
     memcpy(values, self->start_address + start_index, len);
 }
diff --git a/ports/nrf/common-hal/nvm/ByteArray.h b/ports/nrf/common-hal/nvm/ByteArray.h
index c048d5577..b3609a592 100644
--- a/ports/nrf/common-hal/nvm/ByteArray.h
+++ b/ports/nrf/common-hal/nvm/ByteArray.h
@@ -31,7 +31,7 @@
 
 typedef struct {
     mp_obj_base_t base;
-    uint8_t* start_address;
+    uint8_t *start_address;
     uint32_t len;
 } nvm_bytearray_obj_t;
 
diff --git a/ports/nrf/common-hal/os/__init__.c b/ports/nrf/common-hal/os/__init__.c
index b2ad00a5c..5a0f10596 100644
--- a/ports/nrf/common-hal/os/__init__.c
+++ b/ports/nrf/common-hal/os/__init__.c
@@ -55,16 +55,16 @@ STATIC MP_DEFINE_ATTRTUPLE(
     (mp_obj_t)&os_uname_info_release_obj,
     (mp_obj_t)&os_uname_info_version_obj,
     (mp_obj_t)&os_uname_info_machine_obj
-);
+    );
 
 mp_obj_t common_hal_os_uname(void) {
     return (mp_obj_t)&os_uname_info_obj;
 }
 
 bool common_hal_os_urandom(uint8_t *buffer, uint32_t length) {
-#ifdef BLUETOOTH_SD
+    #ifdef BLUETOOTH_SD
     uint8_t sd_en = 0;
-    (void) sd_softdevice_is_enabled(&sd_en);
+    (void)sd_softdevice_is_enabled(&sd_en);
 
     if (sd_en) {
         while (length != 0) {
@@ -84,13 +84,15 @@ bool common_hal_os_urandom(uint8_t *buffer, uint32_t length) {
         }
         return true;
     }
-#endif
+    #endif
 
     nrf_rng_event_clear(NRF_RNG, NRF_RNG_EVENT_VALRDY);
     nrf_rng_task_trigger(NRF_RNG, NRF_RNG_TASK_START);
 
     for (uint32_t i = 0; i < length; i++) {
-        while (nrf_rng_event_check(NRF_RNG, NRF_RNG_EVENT_VALRDY) == 0);
+        while (nrf_rng_event_check(NRF_RNG, NRF_RNG_EVENT_VALRDY) == 0) {
+            ;
+        }
         nrf_rng_event_clear(NRF_RNG, NRF_RNG_EVENT_VALRDY);
 
         buffer[i] = nrf_rng_random_value_get(NRF_RNG);
diff --git a/ports/nrf/common-hal/pulseio/PulseIn.c b/ports/nrf/common-hal/pulseio/PulseIn.c
index ca44a20b4..f8f877d96 100644
--- a/ports/nrf/common-hal/pulseio/PulseIn.c
+++ b/ports/nrf/common-hal/pulseio/PulseIn.c
@@ -40,7 +40,7 @@
 #include "nrfx_gpiote.h"
 
 // obj array to map pin -> self since nrfx hide the mapping
-static pulseio_pulsein_obj_t* _objs[GPIOTE_CH_NUM];
+static pulseio_pulsein_obj_t *_objs[GPIOTE_CH_NUM];
 
 // A single timer is shared amongst all PulseIn objects as a common high speed clock reference.
 static uint8_t refcount = 0;
@@ -57,9 +57,9 @@ static void timer_overflow_event_handler(nrf_timer_event_t event_type, void *p_c
 }
 
 // return index of the object in array
-static int _find_pulsein_obj(pulseio_pulsein_obj_t* obj) {
-    for(size_t i = 0; i < NRFX_ARRAY_SIZE(_objs); i++ ) {
-        if ( _objs[i] == obj) {
+static int _find_pulsein_obj(pulseio_pulsein_obj_t *obj) {
+    for (size_t i = 0; i < NRFX_ARRAY_SIZE(_objs); i++) {
+        if (_objs[i] == obj) {
             return i;
         }
     }
@@ -72,22 +72,24 @@ static void _pulsein_handler(nrfx_gpiote_pin_t pin, nrf_gpiote_polarity_t action
     uint32_t current_overflow = overflow_count;
     uint32_t current_count = nrfx_timer_capture(timer, 1);
 
-    pulseio_pulsein_obj_t* self = NULL;
-    for(size_t i = 0; i < NRFX_ARRAY_SIZE(_objs); i++ ) {
-        if ( _objs[i] && _objs[i]->pin == pin ) {
+    pulseio_pulsein_obj_t *self = NULL;
+    for (size_t i = 0; i < NRFX_ARRAY_SIZE(_objs); i++) {
+        if (_objs[i] && _objs[i]->pin == pin) {
             self = _objs[i];
             break;
         }
     }
-    if ( !self ) return;
+    if (!self) {
+        return;
+    }
 
     if (self->first_edge) {
         // first pulse is opposite state from idle
         bool state = nrf_gpio_pin_read(self->pin);
-        if ( self->idle_state != state ) {
+        if (self->idle_state != state) {
             self->first_edge = false;
         }
-    }else {
+    } else {
         uint32_t total_diff = current_count + 0xffff * (current_overflow - self->last_overflow) - self->last_count;
 
         // Cap duration at 16 bits.
@@ -110,7 +112,7 @@ static void _pulsein_handler(nrfx_gpiote_pin_t pin, nrf_gpiote_polarity_t action
 }
 
 void pulsein_reset(void) {
-    if ( nrfx_gpiote_is_init() ) {
+    if (nrfx_gpiote_is_init()) {
         nrfx_gpiote_uninit();
     }
     nrfx_gpiote_init(NRFX_GPIOTE_CONFIG_IRQ_PRIORITY);
@@ -123,14 +125,14 @@ void pulsein_reset(void) {
     memset(_objs, 0, sizeof(_objs));
 }
 
-void common_hal_pulseio_pulsein_construct(pulseio_pulsein_obj_t* self, const mcu_pin_obj_t* pin, uint16_t maxlen, bool idle_state) {
+void common_hal_pulseio_pulsein_construct(pulseio_pulsein_obj_t *self, const mcu_pin_obj_t *pin, uint16_t maxlen, bool idle_state) {
     int idx = _find_pulsein_obj(NULL);
-    if ( idx < 0 ) {
+    if (idx < 0) {
         mp_raise_NotImplementedError(NULL);
     }
     _objs[idx] = self;
 
-    self->buffer = (uint16_t *) m_malloc(maxlen * sizeof(uint16_t), false);
+    self->buffer = (uint16_t *)m_malloc(maxlen * sizeof(uint16_t), false);
     if (self->buffer == NULL) {
         mp_raise_msg_varg(&mp_type_MemoryError, translate("Failed to allocate RX buffer of %d bytes"), maxlen * sizeof(uint16_t));
     }
@@ -180,11 +182,11 @@ void common_hal_pulseio_pulsein_construct(pulseio_pulsein_obj_t* self, const mcu
     nrfx_gpiote_in_event_enable(self->pin, true);
 }
 
-bool common_hal_pulseio_pulsein_deinited(pulseio_pulsein_obj_t* self) {
-  return self->pin == NO_PIN;
+bool common_hal_pulseio_pulsein_deinited(pulseio_pulsein_obj_t *self) {
+    return self->pin == NO_PIN;
 }
 
-void common_hal_pulseio_pulsein_deinit(pulseio_pulsein_obj_t* self) {
+void common_hal_pulseio_pulsein_deinit(pulseio_pulsein_obj_t *self) {
     if (common_hal_pulseio_pulsein_deinited(self)) {
         return;
     }
@@ -194,7 +196,7 @@ void common_hal_pulseio_pulsein_deinit(pulseio_pulsein_obj_t* self) {
 
     // mark local array as invalid
     int idx = _find_pulsein_obj(self);
-    if ( idx < 0 ) {
+    if (idx < 0) {
         mp_raise_NotImplementedError(NULL);
     }
     _objs[idx] = NULL;
@@ -208,14 +210,14 @@ void common_hal_pulseio_pulsein_deinit(pulseio_pulsein_obj_t* self) {
     }
 }
 
-void common_hal_pulseio_pulsein_pause(pulseio_pulsein_obj_t* self) {
+void common_hal_pulseio_pulsein_pause(pulseio_pulsein_obj_t *self) {
     nrfx_gpiote_in_event_disable(self->pin);
     self->paused = true;
 }
 
-void common_hal_pulseio_pulsein_resume(pulseio_pulsein_obj_t* self, uint16_t trigger_duration) {
+void common_hal_pulseio_pulsein_resume(pulseio_pulsein_obj_t *self, uint16_t trigger_duration) {
     // Make sure we're paused.
-    if ( !self->paused ) {
+    if (!self->paused) {
         common_hal_pulseio_pulsein_pause(self);
     }
 
@@ -246,21 +248,21 @@ void common_hal_pulseio_pulsein_resume(pulseio_pulsein_obj_t* self, uint16_t tri
     nrfx_gpiote_in_event_enable(self->pin, true);
 }
 
-void common_hal_pulseio_pulsein_clear(pulseio_pulsein_obj_t* self) {
-    if ( !self->paused ) {
+void common_hal_pulseio_pulsein_clear(pulseio_pulsein_obj_t *self) {
+    if (!self->paused) {
         nrfx_gpiote_in_event_disable(self->pin);
     }
 
     self->start = 0;
     self->len = 0;
 
-    if ( !self->paused ) {
+    if (!self->paused) {
         nrfx_gpiote_in_event_enable(self->pin, true);
     }
 }
 
-uint16_t common_hal_pulseio_pulsein_get_item(pulseio_pulsein_obj_t* self, int16_t index) {
-    if ( !self->paused ) {
+uint16_t common_hal_pulseio_pulsein_get_item(pulseio_pulsein_obj_t *self, int16_t index) {
+    if (!self->paused) {
         nrfx_gpiote_in_event_disable(self->pin);
     }
 
@@ -268,26 +270,26 @@ uint16_t common_hal_pulseio_pulsein_get_item(pulseio_pulsein_obj_t* self, int16_
         index += self->len;
     }
     if (index < 0 || index >= self->len) {
-        if ( !self->paused ) {
+        if (!self->paused) {
             nrfx_gpiote_in_event_enable(self->pin, true);
         }
         mp_raise_IndexError_varg(translate("%q index out of range"), MP_QSTR_PulseIn);
     }
     uint16_t value = self->buffer[(self->start + index) % self->maxlen];
 
-    if ( !self->paused ) {
+    if (!self->paused) {
         nrfx_gpiote_in_event_enable(self->pin, true);
     }
 
     return value;
 }
 
-uint16_t common_hal_pulseio_pulsein_popleft(pulseio_pulsein_obj_t* self) {
+uint16_t common_hal_pulseio_pulsein_popleft(pulseio_pulsein_obj_t *self) {
     if (self->len == 0) {
         mp_raise_IndexError_varg(translate("pop from empty %q"), MP_QSTR_PulseIn);
     }
 
-    if ( !self->paused ) {
+    if (!self->paused) {
         nrfx_gpiote_in_event_disable(self->pin);
     }
 
@@ -295,21 +297,21 @@ uint16_t common_hal_pulseio_pulsein_popleft(pulseio_pulsein_obj_t* self) {
     self->start = (self->start + 1) % self->maxlen;
     self->len--;
 
-    if ( !self->paused ) {
+    if (!self->paused) {
         nrfx_gpiote_in_event_enable(self->pin, true);
     }
 
     return value;
 }
 
-uint16_t common_hal_pulseio_pulsein_get_maxlen(pulseio_pulsein_obj_t* self) {
+uint16_t common_hal_pulseio_pulsein_get_maxlen(pulseio_pulsein_obj_t *self) {
     return self->maxlen;
 }
 
-bool common_hal_pulseio_pulsein_get_paused(pulseio_pulsein_obj_t* self) {
+bool common_hal_pulseio_pulsein_get_paused(pulseio_pulsein_obj_t *self) {
     return self->paused;
 }
 
-uint16_t common_hal_pulseio_pulsein_get_len(pulseio_pulsein_obj_t* self) {
+uint16_t common_hal_pulseio_pulsein_get_len(pulseio_pulsein_obj_t *self) {
     return self->len;
 }
diff --git a/ports/nrf/common-hal/pulseio/PulseIn.h b/ports/nrf/common-hal/pulseio/PulseIn.h
index da5263ac9..cdd0e6690 100644
--- a/ports/nrf/common-hal/pulseio/PulseIn.h
+++ b/ports/nrf/common-hal/pulseio/PulseIn.h
@@ -39,7 +39,7 @@ typedef struct {
     bool paused;
     volatile bool first_edge;
 
-    uint16_t* buffer;
+    uint16_t *buffer;
     uint16_t maxlen;
 
     volatile uint16_t start;
diff --git a/ports/nrf/common-hal/pulseio/PulseOut.c b/ports/nrf/common-hal/pulseio/PulseOut.c
index f40dbea5c..17f498ba8 100644
--- a/ports/nrf/common-hal/pulseio/PulseOut.c
+++ b/ports/nrf/common-hal/pulseio/PulseOut.c
@@ -66,7 +66,7 @@ static void start_timer(void) {
 }
 
 static void pulseout_event_handler(nrf_timer_event_t event_type, void *p_context) {
-    pulseio_pulseout_obj_t *pulseout = (pulseio_pulseout_obj_t*) p_context;
+    pulseio_pulseout_obj_t *pulseout = (pulseio_pulseout_obj_t *)p_context;
     if (event_type != NRF_TIMER_EVENT_COMPARE0) {
         // Spurious event.
         return;
@@ -99,11 +99,11 @@ void pulseout_reset() {
     refcount = 0;
 }
 
-void common_hal_pulseio_pulseout_construct(pulseio_pulseout_obj_t* self,
-                                            const pwmio_pwmout_obj_t* carrier,
-                                            const mcu_pin_obj_t* pin,
-                                            uint32_t frequency,
-                                            uint16_t duty_cycle) {
+void common_hal_pulseio_pulseout_construct(pulseio_pulseout_obj_t *self,
+    const pwmio_pwmout_obj_t *carrier,
+    const mcu_pin_obj_t *pin,
+    uint32_t frequency,
+    uint16_t duty_cycle) {
     if (!carrier || pin || frequency) {
         mp_raise_NotImplementedError(translate("Port does not accept pins or frequency. Construct and pass a PWMOut Carrier instead"));
     }
@@ -128,11 +128,11 @@ void common_hal_pulseio_pulseout_construct(pulseio_pulseout_obj_t* self,
     turn_off(self);
 }
 
-bool common_hal_pulseio_pulseout_deinited(pulseio_pulseout_obj_t* self) {
+bool common_hal_pulseio_pulseout_deinited(pulseio_pulseout_obj_t *self) {
     return self->pwmout == NULL;
 }
 
-void common_hal_pulseio_pulseout_deinit(pulseio_pulseout_obj_t* self) {
+void common_hal_pulseio_pulseout_deinit(pulseio_pulseout_obj_t *self) {
     if (common_hal_pulseio_pulseout_deinited(self)) {
         return;
     }
@@ -145,7 +145,7 @@ void common_hal_pulseio_pulseout_deinit(pulseio_pulseout_obj_t* self) {
     }
 }
 
-void common_hal_pulseio_pulseout_send(pulseio_pulseout_obj_t* self, uint16_t* pulses, uint16_t length) {
+void common_hal_pulseio_pulseout_send(pulseio_pulseout_obj_t *self, uint16_t *pulses, uint16_t length) {
     pulse_array = pulses;
     pulse_array_index = 0;
     pulse_array_length = length;
@@ -156,7 +156,7 @@ void common_hal_pulseio_pulseout_send(pulseio_pulseout_obj_t* self, uint16_t* pu
     // Count up to the next given value.
     start_timer();
 
-    while(pulse_array_index < length) {
+    while (pulse_array_index < length) {
         // Do other things while we wait. The interrupts will handle sending the
         // signal.
         RUN_BACKGROUND_TASKS;
diff --git a/ports/nrf/common-hal/pwmio/PWMOut.c b/ports/nrf/common-hal/pwmio/PWMOut.c
index a9d896488..e49214631 100644
--- a/ports/nrf/common-hal/pwmio/PWMOut.c
+++ b/ports/nrf/common-hal/pwmio/PWMOut.c
@@ -36,19 +36,19 @@
 
 #define PWM_MAX_FREQ      (16000000)
 
-STATIC NRF_PWM_Type* pwms[] = {
-#if NRFX_CHECK(NRFX_PWM0_ENABLED)
+STATIC NRF_PWM_Type *pwms[] = {
+    #if NRFX_CHECK(NRFX_PWM0_ENABLED)
     NRF_PWM0,
-#endif
-#if NRFX_CHECK(NRFX_PWM1_ENABLED)
+    #endif
+    #if NRFX_CHECK(NRFX_PWM1_ENABLED)
     NRF_PWM1,
-#endif
-#if NRFX_CHECK(NRFX_PWM2_ENABLED)
+    #endif
+    #if NRFX_CHECK(NRFX_PWM2_ENABLED)
     NRF_PWM2,
-#endif
-#if NRFX_CHECK(NRFX_PWM3_ENABLED)
+    #endif
+    #if NRFX_CHECK(NRFX_PWM3_ENABLED)
     NRF_PWM3,
-#endif
+    #endif
 };
 
 #define CHANNELS_PER_PWM 4
@@ -58,14 +58,17 @@ STATIC uint16_t pwm_seq[MP_ARRAY_SIZE(pwms)][CHANNELS_PER_PWM];
 static uint8_t never_reset_pwm[MP_ARRAY_SIZE(pwms)];
 
 STATIC int pwm_idx(NRF_PWM_Type *pwm) {
-    for(size_t i=0; i < MP_ARRAY_SIZE(pwms); i++)
-        if(pwms[i] == pwm) return i;
+    for (size_t i = 0; i < MP_ARRAY_SIZE(pwms); i++) {
+        if (pwms[i] == pwm) {
+            return i;
+        }
+    }
     return -1;
 }
 
 void common_hal_pwmio_pwmout_never_reset(pwmio_pwmout_obj_t *self) {
-    for(size_t i=0; i < MP_ARRAY_SIZE(pwms); i++) {
-        NRF_PWM_Type* pwm = pwms[i];
+    for (size_t i = 0; i < MP_ARRAY_SIZE(pwms); i++) {
+        NRF_PWM_Type *pwm = pwms[i];
         if (pwm == self->pwm) {
             never_reset_pwm[i] += 1;
         }
@@ -75,8 +78,8 @@ void common_hal_pwmio_pwmout_never_reset(pwmio_pwmout_obj_t *self) {
 }
 
 void common_hal_pwmio_pwmout_reset_ok(pwmio_pwmout_obj_t *self) {
-    for(size_t i=0; i < MP_ARRAY_SIZE(pwms); i++) {
-        NRF_PWM_Type* pwm = pwms[i];
+    for (size_t i = 0; i < MP_ARRAY_SIZE(pwms); i++) {
+        NRF_PWM_Type *pwm = pwms[i];
         if (pwm == self->pwm) {
             never_reset_pwm[i] -= 1;
         }
@@ -84,32 +87,32 @@ void common_hal_pwmio_pwmout_reset_ok(pwmio_pwmout_obj_t *self) {
 }
 
 void reset_single_pwmout(uint8_t i) {
-    NRF_PWM_Type* pwm = pwms[i];
-
-    pwm->ENABLE          = 0;
-    pwm->MODE            = PWM_MODE_UPDOWN_Up;
-    pwm->DECODER         = PWM_DECODER_LOAD_Individual;
-    pwm->LOOP            = 0;
-    pwm->PRESCALER       = PWM_PRESCALER_PRESCALER_DIV_1; // default is 500 hz
-    pwm->COUNTERTOP      = (PWM_MAX_FREQ/500);                // default is 500 hz
-
-    pwm->SEQ[0].PTR      = (uint32_t) pwm_seq[i];
-    pwm->SEQ[0].CNT      = CHANNELS_PER_PWM; // default mode is Individual --> count must be 4
-    pwm->SEQ[0].REFRESH  = 0;
+    NRF_PWM_Type *pwm = pwms[i];
+
+    pwm->ENABLE = 0;
+    pwm->MODE = PWM_MODE_UPDOWN_Up;
+    pwm->DECODER = PWM_DECODER_LOAD_Individual;
+    pwm->LOOP = 0;
+    pwm->PRESCALER = PWM_PRESCALER_PRESCALER_DIV_1;       // default is 500 hz
+    pwm->COUNTERTOP = (PWM_MAX_FREQ / 500);                   // default is 500 hz
+
+    pwm->SEQ[0].PTR = (uint32_t)pwm_seq[i];
+    pwm->SEQ[0].CNT = CHANNELS_PER_PWM;      // default mode is Individual --> count must be 4
+    pwm->SEQ[0].REFRESH = 0;
     pwm->SEQ[0].ENDDELAY = 0;
 
-    pwm->SEQ[1].PTR      = 0;
-    pwm->SEQ[1].CNT      = 0;
-    pwm->SEQ[1].REFRESH  = 0;
+    pwm->SEQ[1].PTR = 0;
+    pwm->SEQ[1].CNT = 0;
+    pwm->SEQ[1].REFRESH = 0;
     pwm->SEQ[1].ENDDELAY = 0;
 
-    for(int ch =0; ch < CHANNELS_PER_PWM; ch++) {
+    for (int ch = 0; ch < CHANNELS_PER_PWM; ch++) {
         pwm_seq[i][ch] = (1 << 15); // polarity = 0
     }
 }
 
 void pwmout_reset(void) {
-    for(size_t i=0; i < MP_ARRAY_SIZE(pwms); i++) {
+    for (size_t i = 0; i < MP_ARRAY_SIZE(pwms); i++) {
         if (never_reset_pwm[i] > 0) {
             continue;
         }
@@ -143,8 +146,8 @@ bool convert_frequency(uint32_t frequency, uint16_t *countertop, nrf_pwm_clk_t *
 static IRQn_Type pwm_irqs[4] = {PWM0_IRQn, PWM1_IRQn, PWM2_IRQn, PWM3_IRQn};
 
 NRF_PWM_Type *pwmout_allocate(uint16_t countertop, nrf_pwm_clk_t base_clock,
-        bool variable_frequency, int8_t *channel_out, bool *pwm_already_in_use_out,
-        IRQn_Type* irq) {
+    bool variable_frequency, int8_t *channel_out, bool *pwm_already_in_use_out,
+    IRQn_Type *irq) {
     for (size_t pwm_index = 0; pwm_index < MP_ARRAY_SIZE(pwms); pwm_index++) {
         NRF_PWM_Type *pwm = pwms[pwm_index];
         bool pwm_already_in_use = pwm->ENABLE & PWM_ENABLE_ENABLE_Msk;
@@ -194,7 +197,7 @@ void pwmout_free_channel(NRF_PWM_Type *pwm, int8_t channel) {
     // Disconnect pin from channel.
     pwm->PSEL.OUT[channel] = 0xFFFFFFFF;
 
-    for(int i=0; i < CHANNELS_PER_PWM; i++) {
+    for (int i = 0; i < CHANNELS_PER_PWM; i++) {
         if (pwm->PSEL.OUT[i] != 0xFFFFFFFF) {
             // Some channel is still being used, so don't disable.
             return;
@@ -204,11 +207,11 @@ void pwmout_free_channel(NRF_PWM_Type *pwm, int8_t channel) {
     nrf_pwm_disable(pwm);
 }
 
-pwmout_result_t common_hal_pwmio_pwmout_construct(pwmio_pwmout_obj_t* self,
-                                                    const mcu_pin_obj_t* pin,
-                                                    uint16_t duty,
-                                                    uint32_t frequency,
-                                                    bool variable_frequency) {
+pwmout_result_t common_hal_pwmio_pwmout_construct(pwmio_pwmout_obj_t *self,
+    const mcu_pin_obj_t *pin,
+    uint16_t duty,
+    uint32_t frequency,
+    bool variable_frequency) {
 
     // We don't use the nrfx driver here because we want to dynamically allocate channels
     // as needed in an already-enabled PWM.
@@ -255,18 +258,18 @@ pwmout_result_t common_hal_pwmio_pwmout_construct(pwmio_pwmout_obj_t* self,
     return PWMOUT_OK;
 }
 
-bool common_hal_pwmio_pwmout_deinited(pwmio_pwmout_obj_t* self) {
+bool common_hal_pwmio_pwmout_deinited(pwmio_pwmout_obj_t *self) {
     return self->pwm == NULL;
 }
 
-void common_hal_pwmio_pwmout_deinit(pwmio_pwmout_obj_t* self) {
+void common_hal_pwmio_pwmout_deinit(pwmio_pwmout_obj_t *self) {
     if (common_hal_pwmio_pwmout_deinited(self)) {
         return;
     }
 
     nrf_gpio_cfg_default(self->pin_number);
 
-    NRF_PWM_Type* pwm = self->pwm;
+    NRF_PWM_Type *pwm = self->pwm;
     self->pwm = NULL;
 
     pwmout_free_channel(pwm, self->channel);
@@ -275,20 +278,20 @@ void common_hal_pwmio_pwmout_deinit(pwmio_pwmout_obj_t* self) {
     self->pin_number = NO_PIN;
 }
 
-void common_hal_pwmio_pwmout_set_duty_cycle(pwmio_pwmout_obj_t* self, uint16_t duty_cycle) {
+void common_hal_pwmio_pwmout_set_duty_cycle(pwmio_pwmout_obj_t *self, uint16_t duty_cycle) {
     self->duty_cycle = duty_cycle;
 
-    uint16_t* p_value = ((uint16_t*)self->pwm->SEQ[0].PTR) + self->channel;
+    uint16_t *p_value = ((uint16_t *)self->pwm->SEQ[0].PTR) + self->channel;
     *p_value = ((duty_cycle * self->pwm->COUNTERTOP) / 0xFFFF) | (1 << 15);
 
     self->pwm->TASKS_SEQSTART[0] = 1;
 }
 
-uint16_t common_hal_pwmio_pwmout_get_duty_cycle(pwmio_pwmout_obj_t* self) {
+uint16_t common_hal_pwmio_pwmout_get_duty_cycle(pwmio_pwmout_obj_t *self) {
     return self->duty_cycle;
 }
 
-void common_hal_pwmio_pwmout_set_frequency(pwmio_pwmout_obj_t* self, uint32_t frequency) {
+void common_hal_pwmio_pwmout_set_frequency(pwmio_pwmout_obj_t *self, uint32_t frequency) {
     // COUNTERTOP is 3..32767, so highest available frequency is PWM_MAX_FREQ / 3.
     uint16_t countertop;
     nrf_pwm_clk_t base_clock;
@@ -303,10 +306,10 @@ void common_hal_pwmio_pwmout_set_frequency(pwmio_pwmout_obj_t* self, uint32_t fr
     common_hal_pwmio_pwmout_set_duty_cycle(self, self->duty_cycle);
 }
 
-uint32_t common_hal_pwmio_pwmout_get_frequency(pwmio_pwmout_obj_t* self) {
+uint32_t common_hal_pwmio_pwmout_get_frequency(pwmio_pwmout_obj_t *self) {
     return self->frequency;
 }
 
-bool common_hal_pwmio_pwmout_get_variable_frequency(pwmio_pwmout_obj_t* self) {
+bool common_hal_pwmio_pwmout_get_variable_frequency(pwmio_pwmout_obj_t *self) {
     return self->variable_frequency;
 }
diff --git a/ports/nrf/common-hal/pwmio/PWMOut.h b/ports/nrf/common-hal/pwmio/PWMOut.h
index e910baa76..f96c5e4f8 100644
--- a/ports/nrf/common-hal/pwmio/PWMOut.h
+++ b/ports/nrf/common-hal/pwmio/PWMOut.h
@@ -32,10 +32,10 @@
 
 typedef struct {
     mp_obj_base_t base;
-    NRF_PWM_Type* pwm;
+    NRF_PWM_Type *pwm;
     uint8_t pin_number;
-    uint8_t channel: 7;
-    bool variable_frequency: 1;
+    uint8_t channel : 7;
+    bool variable_frequency : 1;
     uint16_t duty_cycle;
     uint32_t frequency;
 } pwmio_pwmout_obj_t;
diff --git a/ports/nrf/common-hal/rgbmatrix/RGBMatrix.c b/ports/nrf/common-hal/rgbmatrix/RGBMatrix.c
index d8289f56f..238fee976 100644
--- a/ports/nrf/common-hal/rgbmatrix/RGBMatrix.c
+++ b/ports/nrf/common-hal/rgbmatrix/RGBMatrix.c
@@ -43,7 +43,7 @@ static void rgbmatrix_event_handler(nrf_timer_event_t event_type, void *p_contex
     _PM_IRQ_HANDLER();
 }
 
-void common_hal_rgbmatrix_timer_enable(void* ptr) {
+void common_hal_rgbmatrix_timer_enable(void *ptr) {
     nrfx_timer_t *timer = nrf_peripherals_timer_from_reg(ptr);
     static const nrfx_timer_config_t timer_config = {
         .frequency = NRF_TIMER_FREQ_16MHz,
@@ -55,12 +55,12 @@ void common_hal_rgbmatrix_timer_enable(void* ptr) {
     nrfx_timer_init(timer, &timer_config, &rgbmatrix_event_handler);
 }
 
-void common_hal_rgbmatrix_timer_disable(void* ptr) {
+void common_hal_rgbmatrix_timer_disable(void *ptr) {
     nrfx_timer_t *timer = nrf_peripherals_timer_from_reg(ptr);
     nrfx_timer_uninit(timer);
 }
 
-void common_hal_rgbmatrix_timer_free(void* ptr) {
+void common_hal_rgbmatrix_timer_free(void *ptr) {
     nrfx_timer_t *timer = nrf_peripherals_timer_from_reg(ptr);
     nrf_peripherals_free_timer(timer);
 }
diff --git a/ports/nrf/common-hal/rgbmatrix/RGBMatrix.h b/ports/nrf/common-hal/rgbmatrix/RGBMatrix.h
index 6cf7354fc..8101b9c6b 100644
--- a/ports/nrf/common-hal/rgbmatrix/RGBMatrix.h
+++ b/ports/nrf/common-hal/rgbmatrix/RGBMatrix.h
@@ -30,8 +30,8 @@
 #include "shared-module/rgbmatrix/RGBMatrix.h"
 
 void *common_hal_rgbmatrix_timer_allocate(rgbmatrix_rgbmatrix_obj_t *self);
-void common_hal_rgbmatrix_timer_enable(void*);
-void common_hal_rgbmatrix_timer_disable(void*);
-void common_hal_rgbmatrix_timer_free(void*);
+void common_hal_rgbmatrix_timer_enable(void *);
+void common_hal_rgbmatrix_timer_disable(void *);
+void common_hal_rgbmatrix_timer_free(void *);
 
 #endif
diff --git a/ports/nrf/common-hal/rotaryio/IncrementalEncoder.c b/ports/nrf/common-hal/rotaryio/IncrementalEncoder.c
index 28f563da6..ef5e9ee5a 100644
--- a/ports/nrf/common-hal/rotaryio/IncrementalEncoder.c
+++ b/ports/nrf/common-hal/rotaryio/IncrementalEncoder.c
@@ -36,15 +36,20 @@ static rotaryio_incrementalencoder_obj_t *_objs[NUMBER_OF_PINS];
 
 static void _intr_handler(nrfx_gpiote_pin_t pin, nrf_gpiote_polarity_t action) {
     rotaryio_incrementalencoder_obj_t *self = _objs[pin];
-    if (!self) return;
+    if (!self) {
+        return;
+    }
 
     // reads a state 0 .. 3 *in order*.
     uint8_t new_state = nrf_gpio_pin_read(self->pin_a);
     new_state = (new_state << 1) + (new_state ^ nrf_gpio_pin_read(self->pin_b));
 
     uint8_t change = (new_state - self->state) & 0x03;
-    if (change == 1) self->quarter++;
-    else if (change == 3) self->quarter--;
+    if (change == 1) {
+        self->quarter++;
+    } else if (change == 3) {
+        self->quarter--;
+    }
     // ignore other state transitions
 
     self->state = new_state;
@@ -60,8 +65,8 @@ static void _intr_handler(nrfx_gpiote_pin_t pin, nrf_gpiote_polarity_t action) {
     }
 }
 
-void common_hal_rotaryio_incrementalencoder_construct(rotaryio_incrementalencoder_obj_t* self,
-    const mcu_pin_obj_t* pin_a, const mcu_pin_obj_t* pin_b) {
+void common_hal_rotaryio_incrementalencoder_construct(rotaryio_incrementalencoder_obj_t *self,
+    const mcu_pin_obj_t *pin_a, const mcu_pin_obj_t *pin_b) {
 
     self->pin_a = pin_a->number;
     self->pin_b = pin_b->number;
@@ -85,11 +90,11 @@ void common_hal_rotaryio_incrementalencoder_construct(rotaryio_incrementalencode
     claim_pin(pin_b);
 }
 
-bool common_hal_rotaryio_incrementalencoder_deinited(rotaryio_incrementalencoder_obj_t* self) {
+bool common_hal_rotaryio_incrementalencoder_deinited(rotaryio_incrementalencoder_obj_t *self) {
     return self->pin_a == NO_PIN;
 }
 
-void common_hal_rotaryio_incrementalencoder_deinit(rotaryio_incrementalencoder_obj_t* self) {
+void common_hal_rotaryio_incrementalencoder_deinit(rotaryio_incrementalencoder_obj_t *self) {
     if (common_hal_rotaryio_incrementalencoder_deinited(self)) {
         return;
     }
@@ -106,11 +111,11 @@ void common_hal_rotaryio_incrementalencoder_deinit(rotaryio_incrementalencoder_o
     self->pin_b = NO_PIN;
 }
 
-mp_int_t common_hal_rotaryio_incrementalencoder_get_position(rotaryio_incrementalencoder_obj_t* self) {
+mp_int_t common_hal_rotaryio_incrementalencoder_get_position(rotaryio_incrementalencoder_obj_t *self) {
     return self->position;
 }
 
-void common_hal_rotaryio_incrementalencoder_set_position(rotaryio_incrementalencoder_obj_t* self,
-        mp_int_t new_position) {
+void common_hal_rotaryio_incrementalencoder_set_position(rotaryio_incrementalencoder_obj_t *self,
+    mp_int_t new_position) {
     self->position = new_position;
 }
diff --git a/ports/nrf/common-hal/rtc/RTC.c b/ports/nrf/common-hal/rtc/RTC.c
index 93ba007c8..cdffe094a 100644
--- a/ports/nrf/common-hal/rtc/RTC.c
+++ b/ports/nrf/common-hal/rtc/RTC.c
@@ -49,8 +49,9 @@ __attribute__((section(".uninitialized"))) static uint32_t rtc_offset[3];
 
 void common_hal_rtc_init(void) {
     // If the prefix and suffix are not valid, zero-initialize the RTC offset.
-    if ((rtc_offset[0] != RTC_OFFSET_CHECK_PREFIX) || (rtc_offset[2] != RTC_OFFSET_CHECK_SUFFIX))
+    if ((rtc_offset[0] != RTC_OFFSET_CHECK_PREFIX) || (rtc_offset[2] != RTC_OFFSET_CHECK_SUFFIX)) {
         rtc_offset[1] = 0;
+    }
 }
 
 void common_hal_rtc_get_time(timeutils_struct_time_t *tm) {
@@ -62,7 +63,7 @@ void common_hal_rtc_set_time(timeutils_struct_time_t *tm) {
     uint64_t ticks_s = port_get_raw_ticks(NULL) / 1024;
     uint32_t epoch_s = timeutils_seconds_since_2000(
         tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec
-    );
+        );
     rtc_offset[1] = epoch_s - ticks_s;
 
     // Set the prefix and suffix in order to indicate the time is valid.  This
diff --git a/ports/nrf/common-hal/supervisor/Runtime.c b/ports/nrf/common-hal/supervisor/Runtime.c
index a24e86cdf..f82765178 100755..100644
--- a/ports/nrf/common-hal/supervisor/Runtime.c
+++ b/ports/nrf/common-hal/supervisor/Runtime.c
@@ -29,9 +29,9 @@
 #include "supervisor/serial.h"
 
 bool common_hal_supervisor_runtime_get_serial_connected(void) {
-    return (bool) serial_connected();
+    return (bool)serial_connected();
 }
 
 bool common_hal_supervisor_runtime_get_serial_bytes_available(void) {
-  return (bool) serial_bytes_available();
+    return (bool)serial_bytes_available();
 }
diff --git a/ports/nrf/common-hal/watchdog/WatchDogTimer.c b/ports/nrf/common-hal/watchdog/WatchDogTimer.c
index 539b43e76..3423d3466 100644
--- a/ports/nrf/common-hal/watchdog/WatchDogTimer.c
+++ b/ports/nrf/common-hal/watchdog/WatchDogTimer.c
@@ -62,11 +62,11 @@ STATIC void watchdogtimer_timer_event_handler(nrf_timer_event_t event_type, void
     self->mode = WATCHDOGMODE_NONE;
     mp_obj_exception_clear_traceback(MP_OBJ_FROM_PTR(&mp_watchdog_timeout_exception));
     MP_STATE_VM(mp_pending_exception) = &mp_watchdog_timeout_exception;
-#if MICROPY_ENABLE_SCHEDULER
+    #if MICROPY_ENABLE_SCHEDULER
     if (MP_STATE_VM(sched_state) == MP_SCHED_IDLE) {
         MP_STATE_VM(sched_state) = MP_SCHED_PENDING;
     }
-#endif
+    #endif
 }
 
 static void timer_free(void) {
diff --git a/ports/nrf/common-hal/watchdog/WatchDogTimer.h b/ports/nrf/common-hal/watchdog/WatchDogTimer.h
index 8d6df934e..1ff654c32 100644
--- a/ports/nrf/common-hal/watchdog/WatchDogTimer.h
+++ b/ports/nrf/common-hal/watchdog/WatchDogTimer.h
@@ -32,9 +32,9 @@
 #include "shared-bindings/watchdog/WatchDogTimer.h"
 
 struct _watchdog_watchdogtimer_obj_t {
-  mp_obj_base_t base;
-  mp_float_t timeout;
-  watchdog_watchdogmode_t mode;
+    mp_obj_base_t base;
+    mp_float_t timeout;
+    watchdog_watchdogmode_t mode;
 };
 
 // This needs to be called in order to disable the watchdog if it's set to