diff --git a/Makefile b/Makefile
index 554945691b459..d14c047a5b8a5 100644
--- a/Makefile
+++ b/Makefile
@@ -304,6 +304,9 @@ update-frozen-libraries:
 
 one-of-each: samd21 litex mimxrt10xx nordic stm
 
+analog:
+	$(MAKE) -C ports/analog/ BOARD=apard32690
+
 samd21:
 	$(MAKE) -C ports/atmel-samd BOARD=trinket_m0
 
diff --git a/locale/circuitpython.pot b/locale/circuitpython.pot
index c43e3a945f478..4c799f3b0e90f 100644
--- a/locale/circuitpython.pot
+++ b/locale/circuitpython.pot
@@ -28,6 +28,25 @@ msgid ""
 "Code stopped by auto-reload. Reloading soon.\n"
 msgstr ""
 
+#: ports/analog/common-hal/busio/UART.c
+#, c-format
+msgid ""
+"\n"
+"ERR: Error starting transaction: %d\n"
+msgstr ""
+
+#: ports/analog/common-hal/busio/UART.c
+msgid ""
+"\n"
+"ERR: Requested bus is busy\n"
+msgstr ""
+
+#: ports/analog/common-hal/busio/UART.c
+msgid ""
+"\n"
+"ERR: Uart transaction timed out.\n"
+msgstr ""
+
 #: supervisor/shared/safe_mode.c
 msgid ""
 "\n"
@@ -632,6 +651,10 @@ msgid ""
 "disable.\n"
 msgstr ""
 
+#: ports/analog/common-hal/busio/UART.c
+msgid "Baudrate invalid. Must be a standard UART baudrate.\n"
+msgstr ""
+
 #: ports/espressif/common-hal/canio/CAN.c
 msgid "Baudrate not supported by peripheral"
 msgstr ""
@@ -721,6 +744,10 @@ msgstr ""
 msgid "CIRCUITPY drive could not be found or created."
 msgstr ""
 
+#: ports/analog/common-hal/busio/SPI.c
+msgid "CPOL / CPHA must both be either 0 or 1\n"
+msgstr ""
+
 #: ports/espressif/common-hal/espidf/__init__.c
 msgid "CRC or checksum was invalid"
 msgstr ""
@@ -943,6 +970,38 @@ msgstr ""
 msgid "ECB only operates on 16 bytes at a time"
 msgstr ""
 
+#: ports/analog/common-hal/busio/UART.c
+msgid "ERR: Could not init ringbuffer\n"
+msgstr ""
+
+#: ports/analog/peripherals/max32690/max32_uart.c
+#, c-format
+msgid ""
+"ERR: Unable to find a uart matching pins...\n"
+"TX: port %d mask %d\n"
+"RX: port %d mask %d\n"
+msgstr ""
+
+#: ports/analog/peripherals/max32690/max32_i2c.c
+#, c-format
+msgid ""
+"ERR: Unable to find an I2C matching pins...\n"
+"SCL: port %d mask %d\n"
+"SDA: port %d mask %d\n"
+msgstr ""
+
+#: ports/analog/peripherals/max32690/max32_spi.c
+#, c-format
+msgid ""
+"ERR: Unable to find an SPI matching pins...         \n"
+"MOSI: port %d mask %d\n"
+"MISO: port %d mask %d\n"
+msgstr ""
+
+#: ports/analog/common-hal/busio/I2C.c
+msgid "ERROR during I2C Transaction\n"
+msgstr ""
+
 #: ports/espressif/common-hal/busio/SPI.c
 #: ports/espressif/common-hal/canio/CAN.c
 msgid "ESP-IDF memory allocation failed"
@@ -1036,6 +1095,19 @@ msgstr ""
 msgid "Failed to enable continuous"
 msgstr ""
 
+#: ports/analog/common-hal/busio/I2C.c
+#, c-format
+msgid "Failed to init I2C. ERR: %d\n"
+msgstr ""
+
+#: ports/analog/common-hal/busio/SPI.c
+msgid "Failed to init SPI.\n"
+msgstr ""
+
+#: ports/analog/common-hal/busio/UART.c
+msgid "Failed to initialize UART.\n"
+msgstr ""
+
 #: shared-module/audiomp3/MP3Decoder.c
 msgid "Failed to parse MP3 file"
 msgstr ""
@@ -1049,6 +1121,23 @@ msgstr ""
 msgid "Failed to release mutex, err 0x%04x"
 msgstr ""
 
+#: ports/analog/common-hal/busio/I2C.c
+#, c-format
+msgid "Failed to set I2C frequency. ERR: %d\n"
+msgstr ""
+
+#: ports/analog/common-hal/busio/SPI.c
+msgid "Failed to set SPI Clock Mode\n"
+msgstr ""
+
+#: ports/analog/common-hal/busio/SPI.c
+msgid "Failed to set SPI Frame Size\n"
+msgstr ""
+
+#: ports/analog/common-hal/busio/SPI.c
+msgid "Failed to set SPI Frequency\n"
+msgstr ""
+
 #: ports/zephyr-cp/common-hal/wifi/Radio.c
 msgid "Failed to set hostname"
 msgstr ""
@@ -1089,6 +1178,10 @@ msgstr ""
 msgid "Firmware is too big"
 msgstr ""
 
+#: ports/analog/common-hal/busio/UART.c
+msgid "Flow Ctrl needs both CTS & RTS"
+msgstr ""
+
 #: shared-bindings/bitmaptools/__init__.c
 msgid "For L8 colorspace, input bitmap must have 8 bits per pixel"
 msgstr ""
@@ -1148,6 +1241,10 @@ msgstr ""
 msgid "I2C init error"
 msgstr ""
 
+#: ports/analog/common-hal/busio/I2C.c
+msgid "I2C needs SDA & SCL"
+msgstr ""
+
 #: ports/raspberrypi/common-hal/busio/I2C.c
 #: ports/raspberrypi/common-hal/i2ctarget/I2CTarget.c
 msgid "I2C peripheral in use"
@@ -1761,6 +1858,10 @@ msgstr ""
 msgid "Parameter error"
 msgstr ""
 
+#: ports/analog/common-hal/busio/UART.c
+msgid "Parity must be ODD, EVEN, or NONE\n"
+msgstr ""
+
 #: ports/espressif/common-hal/audiobusio/__init__.c
 msgid "Peripheral in use"
 msgstr ""
@@ -1898,6 +1999,7 @@ msgstr ""
 msgid "ROS topic failed to initialize"
 msgstr ""
 
+#: ports/analog/common-hal/busio/UART.c
 #: ports/atmel-samd/common-hal/busio/UART.c ports/cxd56/common-hal/busio/UART.c
 #: ports/nordic/common-hal/busio/UART.c ports/stm/common-hal/busio/UART.c
 msgid "RS485"
@@ -1990,6 +2092,10 @@ msgstr ""
 msgid "SPI init error"
 msgstr ""
 
+#: ports/analog/common-hal/busio/SPI.c
+msgid "SPI needs MOSI, MISO, and SCK"
+msgstr ""
+
 #: ports/raspberrypi/common-hal/busio/SPI.c
 msgid "SPI peripheral in use"
 msgstr ""
@@ -2121,6 +2227,10 @@ msgstr ""
 msgid "Timeout is too long: Maximum timeout length is %d seconds"
 msgstr ""
 
+#: ports/analog/common-hal/busio/UART.c
+msgid "Timeout must be < 100 seconds"
+msgstr ""
+
 #: ports/atmel-samd/common-hal/audiobusio/I2SOut.c
 msgid "Too many channels in sample"
 msgstr ""
@@ -2164,6 +2274,10 @@ msgstr ""
 msgid "UART init"
 msgstr ""
 
+#: ports/analog/common-hal/busio/UART.c
+msgid "UART needs TX & RX"
+msgstr ""
+
 #: ports/raspberrypi/common-hal/busio/UART.c
 msgid "UART peripheral in use"
 msgstr ""
diff --git a/ports/analog/Makefile b/ports/analog/Makefile
index 08b245c5897e3..13bf189286786 100644
--- a/ports/analog/Makefile
+++ b/ports/analog/Makefile
@@ -5,12 +5,13 @@
 #
 # SPDX-License-Identifier: MIT
 
+BOARD ?= apard32690
+CROSS_COMPILE = arm-none-eabi-
+
 # Includes mpconfigboard.mk & mpconfigport.mk,
 # along with numerous other shared environment makefiles.
 include ../../py/circuitpy_mkenv.mk
 
-CROSS_COMPILE = arm-none-eabi-
-
 # MCU_SERIES e.g. 	"max32"
 # MCU_VARIANT e.g. 	"max32690"
 # defined in mpconfigboard.mk
@@ -19,6 +20,7 @@ MCU_SERIES_UPPER := $(shell echo $(MCU_SERIES) | tr '[:lower:]' '[:upper:]')
 MCU_VARIANT_LOWER := $(shell echo $(MCU_VARIANT) | tr '[:upper:]' '[:lower:]')
 MCU_VARIANT_UPPER := $(shell echo $(MCU_VARIANT) | tr '[:lower:]' '[:upper:]')
 
+
 # *******************************************************************************
 #### MSDK INCLUDES ####
 # Necessary for msdk makefiles
@@ -58,6 +60,7 @@ DIE_TYPE=me18
 endif
 
 PERIPH_SRC = $(ADI_PERIPH)/Source
+PERIPH_INC = $(ADI_PERIPH)/Include/$(MCU_VARIANT_UPPER)
 
 INC += -I.
 INC += -I../..
@@ -74,7 +77,7 @@ INC += \
 	-I$(TOP)/lib/cmsis/inc \
 	-I$(CMSIS_ROOT)/Include \
 	-I$(CMSIS_ROOT)/Device/Maxim/$(MCU_VARIANT_UPPER)/Include \
-	-I$(ADI_PERIPH)/Include/$(MCU_VARIANT_UPPER) \
+	-I$(PERIPH_INC) \
 	-I$(PERIPH_SRC)/SYS \
 	-I$(PERIPH_SRC)/CTB \
 	-I$(PERIPH_SRC)/DMA \
@@ -83,7 +86,9 @@ INC += \
 	-I$(PERIPH_SRC)/ICC \
 	-I$(PERIPH_SRC)/TMR \
 	-I$(PERIPH_SRC)/RTC \
-	-I$(PERIPH_SRC)/UART
+	-I$(PERIPH_SRC)/UART \
+	-I$(PERIPH_SRC)/I2C \
+	-I$(PERIPH_SRC)/SPI
 
 INC += -I$(CMSIS_ROOT)/Device/Maxim/$(MCU_VARIANT_UPPER)/Source/GCC
 
@@ -116,13 +121,20 @@ SRC_MAX32 += \
 	$(PERIPH_SRC)/TMR/tmr_$(DIE_TYPE).c \
 	$(PERIPH_SRC)/UART/uart_common.c \
 	$(PERIPH_SRC)/UART/uart_$(DIE_TYPE).c \
-	$(PERIPH_SRC)/UART/uart_revb.c
+	$(PERIPH_SRC)/UART/uart_revb.c \
+	$(PERIPH_SRC)/I2C/i2c_$(DIE_TYPE).c \
+	$(PERIPH_SRC)/I2C/i2c_reva.c \
+	$(PERIPH_SRC)/SPI/spi_$(DIE_TYPE).c \
+	$(PERIPH_SRC)/SPI/spi_reva1.c
 
 SRC_C += $(SRC_MAX32) \
 			boards/$(BOARD)/board.c \
 			boards/$(BOARD)/pins.c \
 			peripherals/$(MCU_VARIANT_LOWER)/pins.c \
-			peripherals/$(MCU_VARIANT_LOWER)/gpios.c
+			peripherals/$(MCU_VARIANT_LOWER)/gpios.c \
+			peripherals/$(MCU_VARIANT_LOWER)/max32_uart.c \
+			peripherals/$(MCU_VARIANT_LOWER)/max32_i2c.c \
+			peripherals/$(MCU_VARIANT_LOWER)/max32_spi.c
 
 # *******************************************************************************
 ### Compiler & Linker Flags ###
@@ -263,11 +275,16 @@ flash-msdk:
 		-f interface/cmsis-dap.cfg -f target/$(MCU_VARIANT_LOWER).cfg \
 		-c "program $(BUILD)/firmware.elf verify; init; reset; exit"
 
+flash-openocd-jlink:
+	$(OPENOCD) -s $(OPENOCD_SCRIPTS) \
+		-f interface/jlink.cfg -f target/$(MCU_VARIANT_LOWER).cfg \
+		-c "program $(BUILD)/firmware.elf verify; init; reset; exit"
+
 # flash target using JLink
 JLINK_DEVICE = $(MCU_VARIANT_LOWER)
 
 JLINKEXE 		?= JLink.exe
-JLINKEXE     	+= -if SWD -device ${JLINK_DEVICE} -speed 10000
+JLINKEXE     	+= -if SWD -device ${JLINK_DEVICE} -speed 4000
 COMMAND_FILE 	:= tools/flash_max32.jlink
 
 flash-jlink: $(BUILD)/firmware.bin
diff --git a/ports/analog/background.c b/ports/analog/background.c
index ffad007ffa51c..ad840c6dcdabc 100644
--- a/ports/analog/background.c
+++ b/ports/analog/background.c
@@ -19,19 +19,13 @@ extern const mxc_gpio_cfg_t led_pin[];
 extern const int num_leds;
 
 /** NOTE: ALL "ticks" refer to a 1/1024 s period */
-static int status_led_ticks = 0;
+static int status_ticks = 0;
 
 // This function is where port-specific background
 // tasks should be performed
 // Execute port specific actions during background tick. Only if ticks are enabled.
 void port_background_tick(void) {
-    status_led_ticks++;
-
-    // Set an LED approx. 1/s
-    if (status_led_ticks > 1024) {
-        MXC_GPIO_OutToggle(led_pin[2].port, led_pin[2].mask);
-        status_led_ticks = 0;
-    }
+    status_ticks++;
 }
 
 // Execute port specific actions during background tasks. This is before the
diff --git a/ports/analog/common-hal/busio/I2C.c b/ports/analog/common-hal/busio/I2C.c
new file mode 100644
index 0000000000000..c1b1d9efe1b17
--- /dev/null
+++ b/ports/analog/common-hal/busio/I2C.c
@@ -0,0 +1,260 @@
+/*
+ * This file is part of Adafruit for EFR32 project
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright 2023 Silicon Laboratories Inc. www.silabs.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "shared-bindings/busio/I2C.h"
+#include "py/mperrno.h"
+#include "py/runtime.h"
+#include "shared-bindings/microcontroller/__init__.h"
+#include "shared-bindings/microcontroller/Pin.h"
+
+#include "max32_port.h"
+
+#define I2C_PRIORITY 1
+
+// Set each bit to indicate an active I2c
+static uint8_t i2c_active = 0;
+static volatile int i2c_err;
+
+// I2C struct for configuring GPIO pins
+extern const mxc_gpio_cfg_t i2c_maps[NUM_I2C];
+
+// Construct I2C protocol, this function init i2c peripheral
+void common_hal_busio_i2c_construct(busio_i2c_obj_t *self,
+    const mcu_pin_obj_t *scl,
+    const mcu_pin_obj_t *sda,
+    uint32_t frequency, uint32_t timeout) {
+
+    int temp, err = 0;
+
+    // Check for NULL Pointers && valid I2C settings
+    assert(self);
+
+    // Assign I2C ID based on pins
+    temp = pinsToI2c(sda, scl);
+    if (temp == -1) {
+        return;
+    } else {
+        self->i2c_id = temp;
+        self->i2c_regs = MXC_I2C_GET_I2C(temp);
+    }
+
+    // Check for valid I2C controller
+    assert((self->i2c_id >= 0) && (self->i2c_id < NUM_I2C));
+    assert(!(i2c_active & (1 << self->i2c_id)));
+
+    // Init I2C as main / controller node (0x00 is ignored)
+    if ((scl != NULL) && (sda != NULL)) {
+        MXC_GPIO_Config(&i2c_maps[self->i2c_id]);
+        err = MXC_I2C_Init(self->i2c_regs, 1, 0x00);
+        if (err) {
+            mp_raise_RuntimeError_varg(MP_ERROR_TEXT("Failed to init I2C. ERR: %d\n"), err);
+        }
+        err = MXC_I2C_SetFrequency(self->i2c_regs, frequency);
+        if (err < 0) {
+            mp_raise_RuntimeError_varg(MP_ERROR_TEXT("Failed to set I2C frequency. ERR: %d\n"), err);
+        }
+    } else if (scl != NULL) {
+        mp_raise_NotImplementedError(MP_ERROR_TEXT("I2C needs SDA & SCL"));
+    } else if (sda != NULL) {
+        mp_raise_NotImplementedError(MP_ERROR_TEXT("I2C needs SDA & SCL"));
+    } else {
+        // Should not get here, as shared-bindings API should not call this way
+    }
+
+    // Attach I2C pins
+    self->sda = sda;
+    self->scl = scl;
+    common_hal_mcu_pin_claim(self->sda);
+    common_hal_mcu_pin_claim(self->scl);
+
+    // Indicate to this module that the I2C is active
+    i2c_active |= (1 << self->i2c_id);
+
+    // Set the timeout to a default value
+    if (((timeout < 0.0) || (timeout > 100.0))) {
+        self->timeout = 1.0;
+    } else {
+        self->timeout = timeout;
+    }
+
+    return;
+}
+
+// Never reset I2C obj when reload
+void common_hal_busio_i2c_never_reset(busio_i2c_obj_t *self) {
+    common_hal_never_reset_pin(self->sda);
+    common_hal_never_reset_pin(self->scl);
+}
+
+// Check I2C status, deinited or not
+bool common_hal_busio_i2c_deinited(busio_i2c_obj_t *self) {
+    return self->sda == NULL;
+}
+
+// Deinit i2c obj, reset I2C pin
+void common_hal_busio_i2c_deinit(busio_i2c_obj_t *self) {
+    MXC_I2C_Shutdown(self->i2c_regs);
+
+    common_hal_reset_pin(self->sda);
+    common_hal_reset_pin(self->scl);
+
+    self->sda = NULL;
+    self->scl = NULL;
+}
+
+// Probe device in I2C bus
+bool common_hal_busio_i2c_probe(busio_i2c_obj_t *self, uint8_t addr) {
+    uint32_t int_fl0, int_fl1;
+    bool ret = 0;
+
+    // Clear FIFOs & all interrupt flags
+    MXC_I2C_ClearRXFIFO(self->i2c_regs);
+    MXC_I2C_ClearTXFIFO(self->i2c_regs);
+    MXC_I2C_ClearFlags(self->i2c_regs, 0xFFFFFF, 0xFFFFFF);
+
+    // Pre-load target address into transmit FIFO
+    addr = (addr << 1);
+    self->i2c_regs->fifo = addr;
+
+    // Set start bit & wait for it to clear
+    MXC_I2C_Start(self->i2c_regs);
+
+    // wait for ACK/NACK
+    while (!(self->i2c_regs->intfl0 & MXC_F_I2C_INTFL0_ADDR_ACK) &&
+           !(self->i2c_regs->intfl0 & MXC_F_I2C_INTFL0_ADDR_NACK_ERR)) {
+    }
+
+    // Save interrupt flags for ACK/NACK checking
+    int_fl0 = self->i2c_regs->intfl0;
+
+    // Set / Wait for stop
+    MXC_I2C_Stop(self->i2c_regs);
+
+    // Wait for controller not busy, then clear flags
+    while (self->i2c_regs->status & MXC_F_I2C_STATUS_BUSY) {
+        ;
+    }
+    MXC_I2C_ClearFlags(self->i2c_regs, 0xFFFFFF, 0xFFFFFF);
+
+    if (int_fl0 & MXC_F_I2C_INTFL0_ADDR_ACK) {
+        ret = true;
+    } else {
+        ret = false;
+    }
+    return ret;
+}
+
+// Lock I2C bus
+bool common_hal_busio_i2c_try_lock(busio_i2c_obj_t *self) {
+
+    if (self->i2c_regs->status & MXC_F_I2C_STATUS_BUSY) {
+        return false;
+    } else {
+        self->has_lock = true;
+        return true;
+    }
+}
+
+// Check I2C lock status
+bool common_hal_busio_i2c_has_lock(busio_i2c_obj_t *self) {
+    return self->has_lock;
+}
+
+// Unlock I2C bus
+void common_hal_busio_i2c_unlock(busio_i2c_obj_t *self) {
+    self->has_lock = false;
+}
+
+// Write data to the device selected by address
+// todo test
+uint8_t common_hal_busio_i2c_write(busio_i2c_obj_t *self, uint16_t addr,
+    const uint8_t *data, size_t len) {
+
+    int ret;
+    mxc_i2c_req_t wr_req = {
+        .addr = addr,
+        .i2c = self->i2c_regs,
+        .tx_buf = (uint8_t *)data,
+        .tx_len = len,
+        .rx_buf = NULL,
+        .rx_len = 0,
+        .callback = NULL
+    };
+    ret = MXC_I2C_MasterTransaction(&wr_req);
+    if (ret) {
+        mp_raise_RuntimeError(MP_ERROR_TEXT("ERROR during I2C Transaction\n"));
+    }
+
+    return 0;
+}
+
+// Read into buffer from the device selected by address
+// todo test
+uint8_t common_hal_busio_i2c_read(busio_i2c_obj_t *self,
+    uint16_t addr,
+    uint8_t *data, size_t len) {
+
+    int ret;
+    mxc_i2c_req_t rd_req = {
+        .addr = addr,
+        .i2c = self->i2c_regs,
+        .tx_buf = NULL,
+        .tx_len = 0,
+        .rx_buf = data,
+        .rx_len = len,
+        .callback = NULL
+    };
+    ret = MXC_I2C_MasterTransaction(&rd_req);
+    if (ret) {
+        mp_raise_RuntimeError(MP_ERROR_TEXT("ERROR during I2C Transaction\n"));
+    }
+
+    return 0;
+}
+
+// Write the bytes from out_data to the device selected by address,
+// todo test
+uint8_t common_hal_busio_i2c_write_read(busio_i2c_obj_t *self, uint16_t addr,
+    uint8_t *out_data, size_t out_len,
+    uint8_t *in_data, size_t in_len) {
+
+    int ret;
+    mxc_i2c_req_t wr_rd_req = {
+        .addr = addr,
+        .i2c = self->i2c_regs,
+        .tx_buf = out_data,
+        .tx_len = out_len,
+        .rx_buf = in_data,
+        .rx_len = in_len,
+        .callback = NULL
+    };
+    ret = MXC_I2C_MasterTransaction(&wr_rd_req);
+    if (ret) {
+        mp_raise_RuntimeError(MP_ERROR_TEXT("ERROR during I2C Transaction\n"));
+    }
+
+    return 0;
+}
diff --git a/ports/analog/common-hal/busio/I2C.h b/ports/analog/common-hal/busio/I2C.h
new file mode 100644
index 0000000000000..55c230ee2f97f
--- /dev/null
+++ b/ports/analog/common-hal/busio/I2C.h
@@ -0,0 +1,28 @@
+// This file is part of the CircuitPython project: https://circuitpython.org
+//
+// SPDX-FileCopyrightText: Copyright (c) 2024 Brandon Hurst, Analog Devices, Inc.
+//
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include "common-hal/microcontroller/Pin.h"
+#include "py/obj.h"
+
+// HAL-specific
+#include "i2c.h"
+#include "gpio.h"
+
+// Define a struct for what BUSIO.I2C should carry
+typedef struct {
+    mp_obj_base_t base;
+
+    int i2c_id;
+    mxc_i2c_regs_t *i2c_regs;
+    const mcu_pin_obj_t *scl;
+    const mcu_pin_obj_t *sda;
+    const int frequency;
+
+    uint32_t timeout;
+    bool has_lock;
+} busio_i2c_obj_t;
diff --git a/ports/analog/common-hal/busio/SPI.c b/ports/analog/common-hal/busio/SPI.c
new file mode 100644
index 0000000000000..999eb8490b0eb
--- /dev/null
+++ b/ports/analog/common-hal/busio/SPI.c
@@ -0,0 +1,318 @@
+/*
+ * This file is part of Adafruit for EFR32 project
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright 2023 Silicon Laboratories Inc. www.silabs.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "shared-bindings/busio/SPI.h"
+#include "py/mperrno.h"
+#include "py/runtime.h"
+#include "shared-bindings/microcontroller/__init__.h"
+#include "supervisor/board.h"
+#include "shared-bindings/microcontroller/Pin.h"
+
+#include "max32_port.h"
+#include "spi_reva1.h"
+
+// Note that any bugs introduced in this file can cause crashes
+// at startupfor chips using external SPI flash.
+
+#define SPI_PRIORITY 1
+
+typedef enum {
+    SPI_FREE = 0,
+    SPI_BUSY,
+    SPI_NEVER_RESET,
+} spi_status_t;
+
+// Set each bit to indicate an active SPI
+static uint8_t spi_active = 0;
+static spi_status_t spi_status[NUM_SPI];
+static volatile int spi_err;
+
+// Construct SPI protocol, this function init SPI peripheral
+void common_hal_busio_spi_construct(busio_spi_obj_t *self,
+    const mcu_pin_obj_t *sck,
+    const mcu_pin_obj_t *mosi,
+    const mcu_pin_obj_t *miso,
+    bool half_duplex) {
+    int temp, err = 0;
+
+    // Check for NULL Pointer
+    assert(self);
+
+    // Assign SPI ID based on pins
+    temp = pinsToSpi(mosi, miso, sck);
+    if (temp == -1) {
+        return;
+    } else {
+        self->spi_id = temp;
+        self->spi_regs = MXC_SPI_GET_SPI(temp);
+    }
+
+    // Other pins default to true
+    mxc_spi_pins_t spi_pins = {
+        .clock = TRUE,
+        .mosi = TRUE,
+        .miso = TRUE,
+        .ss0 = FALSE,
+        .ss1 = FALSE,
+        .ss2 = FALSE,
+        .vddioh = true,
+        .drvstr = MXC_GPIO_DRVSTR_0
+    };
+
+    assert((self->spi_id >= 0) && (self->spi_id < NUM_SPI));
+
+    // Init SPI controller
+    if ((mosi != NULL) && (miso != NULL) && (sck != NULL)) {
+        // spi, mastermode, quadModeUsed, numSubs, ssPolarity, frequency
+        err = MXC_SPI_Init(self->spi_regs, MXC_SPI_TYPE_CONTROLLER, MXC_SPI_INTERFACE_STANDARD,
+            1, 0x01, 1000000, spi_pins);
+        MXC_GPIO_SetVSSEL(MXC_GPIO_GET_GPIO(sck->port), MXC_GPIO_VSSEL_VDDIOH, (sck->mask | miso->mask | mosi->mask | MXC_GPIO_PIN_0));
+        if (err) {
+            mp_raise_RuntimeError(MP_ERROR_TEXT("Failed to init SPI.\n"));
+        }
+    } else {
+        mp_raise_NotImplementedError(MP_ERROR_TEXT("SPI needs MOSI, MISO, and SCK"));
+    }
+
+    // Attach SPI pins
+    self->mosi = mosi;
+    self->miso = miso;
+    self->sck = sck;
+    common_hal_mcu_pin_claim(self->mosi);
+    common_hal_mcu_pin_claim(self->miso);
+    common_hal_mcu_pin_claim(self->sck);
+
+    // Indicate to this module that the SPI is active
+    spi_active |= (1 << self->spi_id);
+
+    return;
+}
+
+// Never reset SPI when reload
+void common_hal_busio_spi_never_reset(busio_spi_obj_t *self) {
+    common_hal_never_reset_pin(self->mosi);
+    common_hal_never_reset_pin(self->miso);
+    common_hal_never_reset_pin(self->sck);
+    common_hal_never_reset_pin(self->nss);
+
+    spi_status[self->spi_id] = SPI_NEVER_RESET;
+}
+
+// Check SPI status, deinited or not
+bool common_hal_busio_spi_deinited(busio_spi_obj_t *self) {
+    return self->sck == NULL;
+}
+
+// Deinit SPI obj
+void common_hal_busio_spi_deinit(busio_spi_obj_t *self) {
+
+    MXC_SPI_Shutdown(self->spi_regs);
+    common_hal_reset_pin(self->mosi);
+    common_hal_reset_pin(self->miso);
+    common_hal_reset_pin(self->sck);
+    common_hal_reset_pin(self->nss);
+
+    self->mosi = NULL;
+    self->miso = NULL;
+    self->sck = NULL;
+    self->nss = NULL;
+}
+
+// Configures the SPI bus. The SPI object must be locked.
+bool common_hal_busio_spi_configure(busio_spi_obj_t *self,
+    uint32_t baudrate,
+    uint8_t polarity,
+    uint8_t phase,
+    uint8_t bits) {
+
+    mxc_spi_clkmode_t clk_mode;
+    int ret;
+
+    self->baudrate = baudrate;
+    self->polarity = polarity;
+    self->phase = phase;
+    self->bits = bits;
+
+    switch ((polarity << 1) | (phase)) {
+        case 0b00:
+            clk_mode = MXC_SPI_CLKMODE_0;
+            break;
+        case 0b01:
+            clk_mode = MXC_SPI_CLKMODE_1;
+            break;
+        case 0b10:
+            clk_mode = MXC_SPI_CLKMODE_2;
+            break;
+        case 0b11:
+            clk_mode = MXC_SPI_CLKMODE_3;
+            break;
+        default:
+            mp_raise_ValueError(MP_ERROR_TEXT("CPOL / CPHA must both be either 0 or 1\n"));
+            return false;
+    }
+
+    ret = MXC_SPI_SetFrequency(self->spi_regs, baudrate);
+    if (ret) {
+        mp_raise_ValueError(MP_ERROR_TEXT("Failed to set SPI Frequency\n"));
+        return false;
+    }
+    ret = MXC_SPI_SetDataSize(self->spi_regs, bits);
+    if (ret) {
+        mp_raise_ValueError(MP_ERROR_TEXT("Failed to set SPI Frame Size\n"));
+        return false;
+    }
+    ret = MXC_SPI_SetMode(self->spi_regs, clk_mode);
+    if (ret) {
+        mp_raise_ValueError(MP_ERROR_TEXT("Failed to set SPI Clock Mode\n"));
+        return false;
+    }
+    return true;
+}
+
+// Lock SPI bus
+bool common_hal_busio_spi_try_lock(busio_spi_obj_t *self) {
+    if (spi_status[self->spi_id] != SPI_BUSY) {
+        self->has_lock = true;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+// Check SPI lock status
+bool common_hal_busio_spi_has_lock(busio_spi_obj_t *self) {
+    return self->has_lock;
+}
+
+// Unlock SPI bus
+void common_hal_busio_spi_unlock(busio_spi_obj_t *self) {
+    self->has_lock = false;
+}
+
+// Write the data contained in buffer
+bool common_hal_busio_spi_write(busio_spi_obj_t *self,
+    const uint8_t *data,
+    size_t len) {
+    int ret = 0;
+
+    mxc_spi_req_t wr_req = {
+        .spi = self->spi_regs,
+        .ssIdx = 0,
+        .txCnt = 0,
+        .rxCnt = 0,
+        .txData = (uint8_t *)data,
+        .txLen = len,
+        .rxData = NULL,
+        .rxLen = 0,
+        .ssDeassert = 1,
+        .completeCB = NULL,
+        .txDummyValue = 0xFF,
+    };
+    ret = MXC_SPI_MasterTransaction(&wr_req);
+    if (ret) {
+        return false;
+    } else {
+        return true;
+    }
+}
+
+// Read data into buffer
+bool common_hal_busio_spi_read(busio_spi_obj_t *self,
+    uint8_t *data, size_t len,
+    uint8_t write_value) {
+
+    int ret = 0;
+    // uint8_t tx_buffer[len] = {0x0};
+
+    // for (int i = 0; i < len; i++) {
+    //     tx_buffer[i] = write_value;
+    // }
+
+    mxc_spi_req_t rd_req = {
+        .spi = self->spi_regs,
+        .ssIdx = 0,
+        .txCnt = 0,
+        .rxCnt = 0,
+        .txData = NULL,
+        .txLen = len,
+        .rxData = data,
+        .rxLen = len,
+        .ssDeassert = 1,
+        .completeCB = NULL,
+        .txDummyValue = write_value,
+    };
+    ret = MXC_SPI_MasterTransaction(&rd_req);
+    if (ret) {
+        return false;
+    } else {
+        return true;
+    }
+}
+
+// Write out the data in data_out
+// while simultaneously reading data into data_in
+bool common_hal_busio_spi_transfer(busio_spi_obj_t *self,
+    const uint8_t *data_out,
+    uint8_t *data_in,
+    size_t len) {
+
+    int ret = 0;
+
+    mxc_spi_req_t rd_req = {
+        .spi = self->spi_regs,
+        .ssIdx = 0,
+        .txCnt = 0,
+        .rxCnt = 0,
+        .txData = (uint8_t *)data_out,
+        .txLen = len,
+        .rxData = data_in,
+        .rxLen = len,
+        .ssDeassert = 1,
+        .completeCB = NULL,
+        .txDummyValue = 0xFF,
+    };
+    ret = MXC_SPI_MasterTransaction(&rd_req);
+    if (ret) {
+        return false;
+    } else {
+        return true;
+    }
+}
+
+// Get SPI baudrate
+uint32_t common_hal_busio_spi_get_frequency(busio_spi_obj_t *self) {
+    return self->baudrate;
+}
+
+// Get SPI phase
+uint8_t common_hal_busio_spi_get_phase(busio_spi_obj_t *self) {
+    return self->phase;
+}
+
+// Get SPI polarity
+uint8_t common_hal_busio_spi_get_polarity(busio_spi_obj_t *self) {
+    return self->polarity;
+}
diff --git a/ports/analog/common-hal/busio/SPI.h b/ports/analog/common-hal/busio/SPI.h
new file mode 100644
index 0000000000000..d10601876fb5e
--- /dev/null
+++ b/ports/analog/common-hal/busio/SPI.h
@@ -0,0 +1,41 @@
+// This file is part of the CircuitPython project: https://circuitpython.org
+//
+// SPDX-FileCopyrightText: Copyright (c) 2024 Brandon Hurst, Analog Devices, Inc.
+//
+// SPDX-License-Identifier: MIT
+
+#ifndef MICROPY_INCLUDED_MAX32_COMMON_HAL_BUSIO_SPI_H
+#define MICROPY_INCLUDED_MAX32_COMMON_HAL_BUSIO_SPI_H
+
+#include "common-hal/microcontroller/Pin.h"
+#include "py/obj.h"
+
+// HAL-specific
+#include "spi.h"
+
+// Define a struct for what BUSIO.SPI should carry
+typedef struct {
+    mp_obj_base_t base;
+
+    // Spi regs & pins
+    int spi_id;
+    mxc_spi_regs_t *spi_regs;
+    const mcu_pin_obj_t *sck;
+    const mcu_pin_obj_t *mosi;
+    const mcu_pin_obj_t *miso;
+    const mcu_pin_obj_t *nss;
+
+    // Configuration
+    uint32_t baudrate;
+    uint16_t prescaler;
+    uint8_t polarity;
+    uint8_t phase;
+    uint8_t bits;
+
+    // Synch data
+    bool has_lock;
+} busio_spi_obj_t;
+
+void spi_reset(void);
+
+#endif  // MICROPY_INCLUDED_MAX32_COMMON_HAL_BUSIO_SPI_H
diff --git a/ports/analog/common-hal/busio/UART.c b/ports/analog/common-hal/busio/UART.c
new file mode 100644
index 0000000000000..f781da8705545
--- /dev/null
+++ b/ports/analog/common-hal/busio/UART.c
@@ -0,0 +1,481 @@
+/*
+ * This file is part of Adafruit for EFR32 project
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright 2023 Silicon Laboratories Inc. www.silabs.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+/** TODO:
+ * - Fix readline issue
+ *
+*/
+
+#if CIRCUITPY_BUSIO_UART
+
+#include "mpconfigport.h"
+#include "supervisor/shared/tick.h"
+
+#include "shared-bindings/microcontroller/__init__.h"
+#include "shared-bindings/microcontroller/Pin.h"
+#include "shared-bindings/busio/UART.h"
+#include "shared-bindings/microcontroller/Pin.h"
+#include "shared/readline/readline.h"
+#include "shared/runtime/interrupt_char.h"
+
+#include "py/gc.h"
+#include "py/ringbuf.h"
+#include "py/mperrno.h"
+#include "py/mpprint.h"
+#include "py/runtime.h"
+
+#include "max32_port.h"
+#include "UART.h"
+#include "nvic_table.h"
+
+// UART IRQ Priority
+#define UART_PRIORITY 1
+
+typedef enum {
+    UART_9600 = 9600,
+    UART_14400 = 14400,
+    UART_19200 = 19200,
+    UART_38400 = 38400,
+    UART_57600 = 57600,
+    UART_115200 = 115200,
+    UART_230400 = 230400,
+    UART_460800 = 460800,
+    UART_921600 = 921600,
+} uart_valid_baudrates;
+
+typedef enum {
+    UART_FREE = 0,
+    UART_BUSY,
+    UART_NEVER_RESET,
+} uart_status_t;
+
+static uint32_t timeout_ms = 0;
+
+// Set each bit to indicate an active UART
+// will be checked by ISR Handler for which ones to call
+static uint8_t uarts_active = 0;
+static uart_status_t uart_status[NUM_UARTS];
+static volatile int uart_err;
+static uint8_t uart_never_reset_mask = 0;
+static busio_uart_obj_t *context;
+
+static int isValidBaudrate(uint32_t baudrate) {
+    switch (baudrate) {
+        case UART_9600:
+            return 1;
+            break;
+        case UART_14400:
+            return 1;
+            break;
+        case UART_19200:
+            return 1;
+            break;
+        case UART_38400:
+            return 1;
+            break;
+        case UART_57600:
+            return 1;
+            break;
+        case UART_115200:
+            return 1;
+            break;
+        case UART_230400:
+            return 1;
+            break;
+        case UART_460800:
+            return 1;
+            break;
+        case UART_921600:
+            return 1;
+            break;
+        default:
+            return 0;
+            break;
+    }
+}
+
+static mxc_uart_parity_t convertParity(busio_uart_parity_t busio_parity) {
+    switch (busio_parity) {
+        case BUSIO_UART_PARITY_NONE:
+            return MXC_UART_PARITY_DISABLE;
+        case BUSIO_UART_PARITY_EVEN:
+            return MXC_UART_PARITY_EVEN_0;
+        case BUSIO_UART_PARITY_ODD:
+            return MXC_UART_PARITY_ODD_0;
+        default:
+            mp_raise_ValueError(MP_ERROR_TEXT("Parity must be ODD, EVEN, or NONE\n"));
+    }
+}
+
+void uart_isr(void) {
+    for (int i = 0; i < NUM_UARTS; i++) {
+        if (uarts_active & (1 << i)) {
+            MXC_UART_AsyncHandler(MXC_UART_GET_UART(i));
+        }
+    }
+}
+
+// Callback gets called when AsyncRequest is COMPLETE
+// (e.g. txLen == txCnt)
+static volatile void uartCallback(mxc_uart_req_t *req, int error) {
+    uart_status[MXC_UART_GET_IDX(req->uart)] = UART_FREE;
+    uart_err = error;
+
+    MXC_SYS_Crit_Enter();
+    ringbuf_put_n(context->ringbuf, req->rxData, req->rxLen);
+    MXC_SYS_Crit_Exit();
+}
+
+// Construct an underlying UART object.
+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,
+    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,
+    bool sigint_enabled) {
+    int err, temp;
+
+    // Check for NULL Pointers && valid UART settings
+    assert(self);
+
+    // Assign UART ID based on pins
+    temp = pinsToUart(tx, rx);
+    if (temp == -1) {
+        // Error will be indicated by pinsToUart(tx, rx) function
+        return;
+    } else {
+        self->uart_id = temp;
+        self->uart_regs = MXC_UART_GET_UART(temp);
+    }
+    assert((self->uart_id >= 0) && (self->uart_id < NUM_UARTS));
+
+    // Check for size of ringbuffer, desire powers of 2
+    // At least use 1 byte if no size is given
+    assert((receiver_buffer_size & (receiver_buffer_size - 1)) == 0);
+    if (receiver_buffer_size == 0) {
+        receiver_buffer_size += 1;
+    }
+
+    // Indicate RS485 not implemented
+    if ((rs485_dir != NULL) || (rs485_invert)) {
+        mp_raise_NotImplementedError(MP_ERROR_TEXT("RS485"));
+    }
+
+    if ((rx != NULL) && (tx != NULL)) {
+        err = MXC_UART_Init(self->uart_regs, baudrate, MXC_UART_IBRO_CLK);
+        if (err != E_NO_ERROR) {
+            mp_raise_RuntimeError(MP_ERROR_TEXT("Failed to initialize UART.\n"));
+        }
+
+        // attach & configure pins
+        self->tx_pin = tx;
+        self->rx_pin = rx;
+        common_hal_mcu_pin_claim(self->tx_pin);
+        common_hal_mcu_pin_claim(self->rx_pin);
+    } else if (tx != NULL) {
+        mp_raise_NotImplementedError(MP_ERROR_TEXT("UART needs TX & RX"));
+    } else if (rx != NULL) {
+        mp_raise_NotImplementedError(MP_ERROR_TEXT("UART needs TX & RX"));
+    } else {
+        // Should not get here, as shared-bindings API should not call this way
+    }
+
+    if ((cts) && (rts)) {
+        MXC_UART_SetFlowCtrl(self->uart_regs, MXC_UART_FLOW_EN, 8);
+        self->cts_pin = cts;
+        self->rts_pin = rts;
+        common_hal_mcu_pin_claim(self->cts_pin);
+        common_hal_mcu_pin_claim(self->rts_pin);
+    } else if (cts || rts) {
+        mp_raise_ValueError(MP_ERROR_TEXT("Flow Ctrl needs both CTS & RTS"));
+    }
+
+    // Set stop bits & data size
+    assert((stop == 1) || (stop == 2));
+    mp_arg_validate_int(bits, 8, MP_QSTR_bits);
+    MXC_UART_SetDataSize(self->uart_regs, bits);
+    MXC_UART_SetStopBits(self->uart_regs, stop);
+
+    // Set parity
+    MXC_UART_SetParity(self->uart_regs, convertParity(parity));
+
+    // attach UART parameters
+    self->stop_bits = stop; // must be 1 or 2
+    self->bits = bits;
+    self->parity = parity;
+    self->baudrate = baudrate;
+    self->error = E_NO_ERROR;
+
+    // Indicate to this module that the UART is active
+    uarts_active |= (1 << self->uart_id);
+
+    // Set the timeout to a default value
+    if (((timeout < 0.0) || (timeout > 100.0))) {
+        self->timeout = 1.0;
+    } else {
+        self->timeout = timeout;
+    }
+
+    // Initialize ringbuffer
+    if (receiver_buffer == NULL) {
+        self->ringbuf = gc_alloc(receiver_buffer_size, false);
+        if (!ringbuf_alloc(self->ringbuf, receiver_buffer_size)) {
+            m_malloc_fail(receiver_buffer_size);
+            mp_raise_RuntimeError(MP_ERROR_TEXT("ERR: Could not init ringbuffer\n"));
+        }
+    } else {
+        if (!(ringbuf_init(self->ringbuf, receiver_buffer, receiver_buffer_size))) {
+            mp_raise_RuntimeError(MP_ERROR_TEXT("ERR: Could not init ringbuffer\n"));
+        }
+        ;
+    }
+
+    context = self;
+
+    // Setup UART interrupt
+
+    NVIC_ClearPendingIRQ(MXC_UART_GET_IRQ(self->uart_id));
+    NVIC_DisableIRQ(MXC_UART_GET_IRQ(self->uart_id));
+    NVIC_SetPriority(MXC_UART_GET_IRQ(self->uart_id), UART_PRIORITY);
+    NVIC_SetVector(MXC_UART_GET_IRQ(self->uart_id), (uint32_t)uart_isr);
+
+    NVIC_EnableIRQ(MXC_UART_GET_IRQ(self->uart_id));
+
+    return;
+}
+
+void common_hal_busio_uart_deinit(busio_uart_obj_t *self) {
+    assert(self);
+
+    if (!common_hal_busio_uart_deinited(self)) {
+        // First disable the ISR to avoid pre-emption
+        NVIC_DisableIRQ(MXC_UART_GET_IRQ(self->uart_id));
+
+        // Shutdown the UART Controller
+        MXC_UART_Shutdown(self->uart_regs);
+        self->error = E_UNINITIALIZED;
+
+        assert(self->rx_pin && self->tx_pin);
+        reset_pin_number(self->rx_pin->port, self->rx_pin->mask);
+        reset_pin_number(self->tx_pin->port, self->tx_pin->mask);
+
+        if (self->cts_pin && self->rts_pin) {
+            reset_pin_number(self->cts_pin->port, self->cts_pin->mask);
+            reset_pin_number(self->rts_pin->port, self->rts_pin->mask);
+        }
+
+        self->tx_pin = NULL;
+        self->rx_pin = NULL;
+        self->cts_pin = NULL;
+        self->rts_pin = NULL;
+
+        ringbuf_deinit(self->ringbuf);
+
+        // Indicate to this module that the UART is not active
+        uarts_active &= ~(1 << self->uart_id);
+    }
+}
+
+bool common_hal_busio_uart_deinited(busio_uart_obj_t *self) {
+    if (uarts_active & (1 << self->uart_id)) {
+        return false;
+    } else {
+        return true;
+    };
+}
+
+// Read characters. len is in characters.
+size_t common_hal_busio_uart_read(busio_uart_obj_t *self,
+    uint8_t *data, size_t len, int *errcode) {
+    int err;
+    uint32_t start_time = 0;
+    static size_t bytes_remaining;
+
+    // Setup globals & status tracking
+    uart_err = E_NO_ERROR;
+    uarts_active |= (1 << self->uart_id);
+    uart_status[self->uart_id] = UART_BUSY;
+    bytes_remaining = len;
+
+    mxc_uart_req_t uart_rd_req;
+    uart_rd_req.rxCnt = 0;
+    uart_rd_req.txCnt = 0;
+    uart_rd_req.rxData = data;
+    uart_rd_req.txData = NULL;
+    uart_rd_req.rxLen = bytes_remaining;
+    uart_rd_req.txLen = 0;
+    uart_rd_req.uart = self->uart_regs;
+    uart_rd_req.callback = (void *)uartCallback;
+
+    // Initiate the read transaction
+    start_time = supervisor_ticks_ms64();
+    err = MXC_UART_TransactionAsync(&uart_rd_req);
+    if (err != E_NO_ERROR) {
+        *errcode = err;
+        MXC_UART_AbortAsync(self->uart_regs);
+        NVIC_DisableIRQ(MXC_UART_GET_IRQ(self->uart_id));
+        mp_raise_RuntimeError_varg(MP_ERROR_TEXT("\nERR: Error starting transaction: %d\n"), err);
+    }
+
+    // Wait for transaction completion or timeout
+    while ((uart_status[self->uart_id] != UART_FREE) &&
+           (supervisor_ticks_ms64() - start_time < (self->timeout * 1000))) {
+    }
+
+    // If the timeout gets hit, abort and error out
+    if (uart_status[self->uart_id] != UART_FREE) {
+        MXC_UART_AbortAsync(self->uart_regs);
+        NVIC_DisableIRQ(MXC_UART_GET_IRQ(self->uart_id));
+        mp_raise_RuntimeError(MP_ERROR_TEXT("\nERR: Uart transaction timed out.\n"));
+    }
+    // Check for errors from the callback
+    else if (uart_err != E_NO_ERROR) {
+        mp_printf(&mp_sys_stdout_print, "MAX32 ERR: %d\n", uart_err);
+        MXC_UART_AbortAsync(self->uart_regs);
+    }
+
+    // Copy the data from the ringbuf (or return error)
+    MXC_SYS_Crit_Enter();
+    err = ringbuf_get_n(context->ringbuf, data, len);
+    MXC_SYS_Crit_Exit();
+
+    return err;
+}
+
+// Write characters. len is in characters NOT bytes!
+// This function blocks until the timeout finishes
+size_t common_hal_busio_uart_write(busio_uart_obj_t *self,
+    const uint8_t *data, size_t len, int *errcode) {
+    int err;
+    uint32_t start_time = 0;
+    static size_t bytes_remaining;
+
+    // Setup globals & status tracking
+    uart_err = E_NO_ERROR;
+    uarts_active |= (1 << self->uart_id);
+    uart_status[self->uart_id] = UART_BUSY;
+    bytes_remaining = len;
+
+    mxc_uart_req_t uart_wr_req = {};
+
+    // Setup transaction
+    uart_wr_req.rxCnt = 0;
+    uart_wr_req.txCnt = 0;
+    uart_wr_req.rxData = NULL;
+    uart_wr_req.txData = data;
+    uart_wr_req.txLen = bytes_remaining;
+    uart_wr_req.rxLen = 0;
+    uart_wr_req.uart = self->uart_regs;
+    uart_wr_req.callback = (void *)uartCallback;
+
+    // Start the transaction
+    start_time = supervisor_ticks_ms64();
+    err = MXC_UART_TransactionAsync(&uart_wr_req);
+    if (err != E_NO_ERROR) {
+        *errcode = err;
+        MXC_UART_AbortAsync(self->uart_regs);
+        NVIC_DisableIRQ(MXC_UART_GET_IRQ(self->uart_id));
+        mp_raise_ConnectionError(MP_ERROR_TEXT("\nERR: Requested bus is busy\n"));
+    }
+
+    // Wait for transaction completion or timeout
+    while ((uart_status[self->uart_id] != UART_FREE) &&
+           (supervisor_ticks_ms64() - start_time < (self->timeout * 1000))) {
+
+        // Call the handler and abort if errors
+        uart_err = MXC_UART_AsyncHandler(self->uart_regs);
+        if (uart_err != E_NO_ERROR) {
+            mp_printf(&mp_sys_stdout_print, "MAX32 ERR: %d\n", uart_err);
+            MXC_UART_AbortAsync(self->uart_regs);
+        }
+    }
+
+    // If the timeout gets hit, abort and error out
+    if (uart_status[self->uart_id] != UART_FREE) {
+        MXC_UART_AbortAsync(self->uart_regs);
+        NVIC_DisableIRQ(MXC_UART_GET_IRQ(self->uart_id));
+        mp_raise_ConnectionError(MP_ERROR_TEXT("\nERR: Uart transaction timed out.\n"));
+    }
+    // Check for errors from the callback
+    else if (uart_err != E_NO_ERROR) {
+        mp_printf(&mp_sys_stdout_print, "MAX32 ERR: %d\n", uart_err);
+        MXC_UART_AbortAsync(self->uart_regs);
+    }
+
+    return len;
+}
+
+uint32_t common_hal_busio_uart_get_baudrate(busio_uart_obj_t *self) {
+    return self->baudrate;
+}
+
+// Validate baudrate
+void common_hal_busio_uart_set_baudrate(busio_uart_obj_t *self, uint32_t baudrate) {
+    if (isValidBaudrate(baudrate)) {
+        self->baudrate = baudrate;
+    } else {
+        mp_raise_ValueError(MP_ERROR_TEXT("Baudrate invalid. Must be a standard UART baudrate.\n"));
+    }
+}
+
+mp_float_t common_hal_busio_uart_get_timeout(busio_uart_obj_t *self) {
+    return self->timeout;
+}
+
+void common_hal_busio_uart_set_timeout(busio_uart_obj_t *self, mp_float_t timeout) {
+    if (timeout > 100.0) {
+        mp_raise_ValueError(MP_ERROR_TEXT("Timeout must be < 100 seconds"));
+    }
+
+    timeout_ms = 1000 * (uint32_t)timeout;
+    self->timeout = (uint32_t)timeout;
+
+    return;
+}
+
+uint32_t common_hal_busio_uart_rx_characters_available(busio_uart_obj_t *self) {
+    return ringbuf_num_filled(self->ringbuf);
+}
+
+void common_hal_busio_uart_clear_rx_buffer(busio_uart_obj_t *self) {
+    MXC_UART_ClearRXFIFO(self->uart_regs);
+    ringbuf_clear(self->ringbuf);
+}
+
+bool common_hal_busio_uart_ready_to_tx(busio_uart_obj_t *self) {
+    return !(MXC_UART_GetStatus(self->uart_regs) & (MXC_F_UART_STATUS_TX_BUSY));
+}
+
+void common_hal_busio_uart_never_reset(busio_uart_obj_t *self) {
+    common_hal_never_reset_pin(self->tx_pin);
+    common_hal_never_reset_pin(self->rx_pin);
+    common_hal_never_reset_pin(self->cts_pin);
+    common_hal_never_reset_pin(self->rts_pin);
+    uart_never_reset_mask |= (1 << (self->uart_id));
+}
+
+#endif // CIRCUITPY_BUSIO_UART
diff --git a/ports/analog/common-hal/busio/UART.h b/ports/analog/common-hal/busio/UART.h
new file mode 100644
index 0000000000000..296c738772e68
--- /dev/null
+++ b/ports/analog/common-hal/busio/UART.h
@@ -0,0 +1,39 @@
+// This file is part of the CircuitPython project: https://circuitpython.org
+//
+// SPDX-FileCopyrightText: Copyright (c) 2024 Brandon Hurst, Analog Devices, Inc.
+//
+// SPDX-License-Identifier: MIT
+
+#ifndef MICROPY_INCLUDED_MAX32_COMMON_HAL_BUSIO_UART_H
+#define MICROPY_INCLUDED_MAX32_COMMON_HAL_BUSIO_UART_H
+
+#include "common-hal/microcontroller/Pin.h"
+#include "py/obj.h"
+#include "py/ringbuf.h"
+
+#include "max32_port.h"
+
+// Define a struct for what BUSIO.UART should contain
+typedef struct {
+    mp_obj_base_t base;
+    int error;
+    float timeout;
+
+    int uart_id;
+    int uart_map;
+    mxc_uart_regs_t *uart_regs;
+    ringbuf_t *ringbuf;
+    bool parity;
+    uint8_t bits;
+    uint8_t stop_bits;
+    uint32_t baudrate;
+
+    const mcu_pin_obj_t *rx_pin;
+    const mcu_pin_obj_t *tx_pin;
+    const mcu_pin_obj_t *rts_pin;
+    const mcu_pin_obj_t *cts_pin;
+} busio_uart_obj_t;
+
+void uart_reset(void);
+
+#endif  // MICROPY_INCLUDED_MAX32_COMMON_HAL_BUSIO_UART_H
diff --git a/ports/analog/common-hal/busio/__init__.c b/ports/analog/common-hal/busio/__init__.c
new file mode 100644
index 0000000000000..ff05be051bb25
--- /dev/null
+++ b/ports/analog/common-hal/busio/__init__.c
@@ -0,0 +1,5 @@
+// This file is part of the CircuitPython project: https://circuitpython.org
+//
+// SPDX-FileCopyrightText: Copyright (c) 2024 Brandon Hurst, Analog Devices, Inc.
+//
+// SPDX-License-Identifier: MIT
diff --git a/ports/analog/common-hal/microcontroller/Pin.c b/ports/analog/common-hal/microcontroller/Pin.c
index 4545aa039c2fa..83e2f3b9c3a76 100644
--- a/ports/analog/common-hal/microcontroller/Pin.c
+++ b/ports/analog/common-hal/microcontroller/Pin.c
@@ -37,7 +37,7 @@ void reset_all_pins(void) {
 }
 
 void reset_pin_number(uint8_t pin_port, uint8_t pin_pad) {
-    if (pin_port == INVALID_PIN || pin_port > NUM_GPIO_PORTS) {
+    if ((pin_port == INVALID_PIN) || (pin_port > NUM_GPIO_PORTS)) {
         return;
     }
 
diff --git a/ports/analog/max32_port.h b/ports/analog/max32_port.h
index 5d92fcfe6d3ee..89830e96b0a49 100644
--- a/ports/analog/max32_port.h
+++ b/ports/analog/max32_port.h
@@ -22,29 +22,34 @@
 #include "system_max32690.h"
 #include "max32690.h"
 
+// UART Ports & pins
+#include "peripherals/max32690/max32_uart.h"
+#include "peripherals/max32690/max32_i2c.h"
+#include "peripherals/max32690/max32_spi.h"
+
 /** START: GPIO4 Handling specific to MAX32690 */
-#define GPIO4_PIN_MASK 0x00000003
-#define GPIO4_RESET_MASK 0xFFFFFF77
-#define GPIO4_OUTEN_MASK(mask)                                \
+    #define GPIO4_PIN_MASK 0x00000003
+    #define GPIO4_RESET_MASK 0xFFFFFF77
+    #define GPIO4_OUTEN_MASK(mask)                                \
     (((mask & (1 << 0)) << MXC_F_MCR_GPIO4_CTRL_P40_OE_POS) | \
     ((mask & (1 << 1)) << (MXC_F_MCR_GPIO4_CTRL_P41_OE_POS - 1)))
-#define GPIO4_PULLDIS_MASK(mask)                              \
+    #define GPIO4_PULLDIS_MASK(mask)                              \
     (((mask & (1 << 0)) << MXC_F_MCR_GPIO4_CTRL_P40_PE_POS) | \
     ((mask & (1 << 1)) << (MXC_F_MCR_GPIO4_CTRL_P41_PE_POS - 1)))
-#define GPIO4_DATAOUT_MASK(mask)                              \
+    #define GPIO4_DATAOUT_MASK(mask)                              \
     (((mask & (1 << 0)) << MXC_F_MCR_GPIO4_CTRL_P40_DO_POS) | \
     ((mask & (1 << 1)) << (MXC_F_MCR_GPIO4_CTRL_P41_DO_POS - 1)))
-#define GPIO4_DATAOUT_GET_MASK(mask)                                                             \
+    #define GPIO4_DATAOUT_GET_MASK(mask)                                                             \
     ((((MXC_MCR->gpio4_ctrl & MXC_F_MCR_GPIO4_CTRL_P40_DO) >> MXC_F_MCR_GPIO4_CTRL_P40_DO_POS) | \
     ((MXC_MCR->gpio4_ctrl & MXC_F_MCR_GPIO4_CTRL_P41_DO) >>                                    \
     (MXC_F_MCR_GPIO4_CTRL_P41_DO_POS - 1))) &                                                 \
     mask)
-#define GPIO4_DATAIN_MASK(mask)                                                                  \
+    #define GPIO4_DATAIN_MASK(mask)                                                                  \
     ((((MXC_MCR->gpio4_ctrl & MXC_F_MCR_GPIO4_CTRL_P40_IN) >> MXC_F_MCR_GPIO4_CTRL_P40_IN_POS) | \
     ((MXC_MCR->gpio4_ctrl & MXC_F_MCR_GPIO4_CTRL_P41_IN) >>                                    \
     (MXC_F_MCR_GPIO4_CTRL_P41_IN_POS - 1))) &                                                 \
     mask)
-#define GPIO4_AFEN_MASK(mask)                                  \
+    #define GPIO4_AFEN_MASK(mask)                                  \
     (((mask & (1 << 0)) << MXC_F_MCR_OUTEN_PDOWN_OUT_EN_POS) | \
     ((mask & (1 << 1)) >> (MXC_F_MCR_OUTEN_SQWOUT_EN_POS + 1)))
 /** END: GPIO4 Handling specific to MAX32690 */
diff --git a/ports/analog/mpconfigport.mk b/ports/analog/mpconfigport.mk
index 1729a284a3f47..c9b392e58062e 100644
--- a/ports/analog/mpconfigport.mk
+++ b/ports/analog/mpconfigport.mk
@@ -21,8 +21,10 @@ INTERNAL_FLASH_FILESYSTEM = 1
 ####################################################################################
 # These modules are implemented in ports/<port>/common-hal:
 
+# Actively implementing (some functions may be stubbed out)
+CIRCUITPY_BUSIO ?= 1
+
 # Plan to implement
-CIRCUITPY_BUSIO ?= 0
 CIRCUITPY_RTC ?= 0
 
 # Other modules (may or may not implement):
diff --git a/ports/analog/peripherals/max32690/gpios.h b/ports/analog/peripherals/max32690/gpios.h
index 4677bf8f33dbe..fe91227728291 100644
--- a/ports/analog/peripherals/max32690/gpios.h
+++ b/ports/analog/peripherals/max32690/gpios.h
@@ -4,6 +4,8 @@
 //
 // SPDX-License-Identifier: MIT
 
+#pragma once
+
 #include "py/obj.h"
 #include "py/mphal.h"
 
diff --git a/ports/analog/peripherals/max32690/max32_i2c.c b/ports/analog/peripherals/max32690/max32_i2c.c
new file mode 100644
index 0000000000000..daf665bbee741
--- /dev/null
+++ b/ports/analog/peripherals/max32690/max32_i2c.c
@@ -0,0 +1,76 @@
+// This file is part of the CircuitPython project: https://circuitpython.org
+//
+// SPDX-FileCopyrightText: Copyright (c) 2024 Brandon Hurst, Analog Devices, Inc.
+//
+// SPDX-License-Identifier: MIT
+
+#include "peripherals/pins.h"
+
+#include "common-hal/busio/I2C.h"
+#include "max32_i2c.h"
+#include "max32690.h"
+
+#include "py/runtime.h"
+#include "py/mperrno.h"
+
+
+/* Note: The MAX32690 assigns the same alternate function to multiple sets
+     * of pins.  The drivers will enable both sets so that either can be used.
+     * Users should ensure the unused set is left unconnected.
+     *
+     * See MAX32690 Rev A2 Errata #16:
+     * https://www.analog.com/media/en/technical-documentation/data-sheets/max32690_a2_errata_rev2.pdf
+     *
+     * Additionally, note that the TQFN package does not expose some of the duplicate pins.  For this package,
+     * enabling the un-routed GPIOs has been shown to cause initialization issues with the I2C block.
+     * To work around this, "MAX32690GTK_PACKAGE_TQFN" can be defined by the build system.  The recommend place
+     * to do it is in the "board.mk" file of the BSP.  This will prevent the inaccessible pins from being configured.
+     */
+
+const mxc_gpio_cfg_t i2c_maps[NUM_I2C] = {
+    // I2C0
+    { MXC_GPIO2, (MXC_GPIO_PIN_7 | MXC_GPIO_PIN_8), MXC_GPIO_FUNC_ALT1,
+      MXC_GPIO_PAD_NONE, MXC_GPIO_VSSEL_VDDIO, MXC_GPIO_DRVSTR_0 },
+    // I2C1
+    { MXC_GPIO0, (MXC_GPIO_PIN_11 | MXC_GPIO_PIN_12), MXC_GPIO_FUNC_ALT1,
+      MXC_GPIO_PAD_NONE, MXC_GPIO_VSSEL_VDDIO, MXC_GPIO_DRVSTR_0 },
+    // I2C2
+    { MXC_GPIO1, (MXC_GPIO_PIN_7 | MXC_GPIO_PIN_8), MXC_GPIO_FUNC_ALT3,
+      MXC_GPIO_PAD_NONE, MXC_GPIO_VSSEL_VDDIOH, MXC_GPIO_DRVSTR_0 },
+};
+#ifndef MAX32690GTK_PACKAGE_TQFN
+const mxc_gpio_cfg_t i2c_maps_extra[NUM_I2C] = {
+    // I2C0A
+    { MXC_GPIO0, (MXC_GPIO_PIN_30 | MXC_GPIO_PIN_31), MXC_GPIO_FUNC_ALT1,
+      MXC_GPIO_PAD_PULL_UP, MXC_GPIO_VSSEL_VDDIOH, MXC_GPIO_DRVSTR_0 },
+    // I2C1A
+    { MXC_GPIO2, (MXC_GPIO_PIN_17 | MXC_GPIO_PIN_18), MXC_GPIO_FUNC_ALT1,
+      MXC_GPIO_PAD_PULL_UP, MXC_GPIO_VSSEL_VDDIOH, MXC_GPIO_DRVSTR_0 },
+    // I2C2C
+    { MXC_GPIO0, (MXC_GPIO_PIN_13 | MXC_GPIO_PIN_14), MXC_GPIO_FUNC_ALT3,
+      MXC_GPIO_PAD_NONE, MXC_GPIO_VSSEL_VDDIO, MXC_GPIO_DRVSTR_0 },
+};
+#endif
+
+int pinsToI2c(const mcu_pin_obj_t *sda, const mcu_pin_obj_t *scl) {
+    for (int i = 0; i < NUM_I2C; i++) {
+        if ((i2c_maps[i].port == (MXC_GPIO_GET_GPIO(sda->port)))
+            && (i2c_maps[i].mask == ((sda->mask) | (scl->mask)))) {
+            return i;
+        }
+    }
+
+    // Additional for loop to cover alternate potential I2C maps
+    #ifndef MAX32690GTK_PACKAGE_TQFN
+    for (int i = 0; i < NUM_I2C; i++) {
+        if ((i2c_maps_extra[i].port == (MXC_GPIO_GET_GPIO(sda->port)))
+            && (i2c_maps_extra[i].mask == ((sda->mask) | (scl->mask)))) {
+            return i;
+        }
+    }
+    #endif
+
+    mp_raise_RuntimeError_varg(MP_ERROR_TEXT("ERR: Unable to find an I2C matching pins...\nSCL: port %d mask %d\nSDA: port %d mask %d\n"),
+        sda->port, sda->mask, scl->port, scl->mask);
+    return -1;
+}
diff --git a/ports/analog/peripherals/max32690/max32_i2c.h b/ports/analog/peripherals/max32690/max32_i2c.h
new file mode 100644
index 0000000000000..b64cfd308dcf5
--- /dev/null
+++ b/ports/analog/peripherals/max32690/max32_i2c.h
@@ -0,0 +1,16 @@
+// This file is part of the CircuitPython project: https://circuitpython.org
+//
+// SPDX-FileCopyrightText: Copyright (c) 2024 Brandon Hurst, Analog Devices, Inc.
+//
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include "i2c_regs.h"
+#include "mxc_sys.h"
+#include "i2c.h"
+#include "peripherals/pins.h"
+
+#define NUM_I2C 3
+
+int pinsToI2c(const mcu_pin_obj_t *sda, const mcu_pin_obj_t *scl);
diff --git a/ports/analog/peripherals/max32690/max32_spi.c b/ports/analog/peripherals/max32690/max32_spi.c
new file mode 100644
index 0000000000000..f2594787598b2
--- /dev/null
+++ b/ports/analog/peripherals/max32690/max32_spi.c
@@ -0,0 +1,47 @@
+// This file is part of the CircuitPython project: https://circuitpython.org
+//
+// SPDX-FileCopyrightText: Copyright (c) 2024 Brandon Hurst, Analog Devices, Inc.
+//
+// SPDX-License-Identifier: MIT
+
+#include "peripherals/pins.h"
+
+#include "common-hal/busio/SPI.h"
+#include "max32_spi.h"
+#include "max32690.h"
+
+#include "py/runtime.h"
+#include "py/mperrno.h"
+
+const mxc_gpio_cfg_t spi_maps[NUM_SPI] = {
+    // SPI0
+    { MXC_GPIO2, (MXC_GPIO_PIN_27 | MXC_GPIO_PIN_28 | MXC_GPIO_PIN_29),
+      MXC_GPIO_FUNC_ALT2, MXC_GPIO_PAD_NONE, MXC_GPIO_VSSEL_VDDIO, MXC_GPIO_DRVSTR_0 },
+    // SPI1
+    { MXC_GPIO1, (MXC_GPIO_PIN_26 | MXC_GPIO_PIN_28 | MXC_GPIO_PIN_29),
+      MXC_GPIO_FUNC_ALT1, MXC_GPIO_PAD_NONE, MXC_GPIO_VSSEL_VDDIO, MXC_GPIO_DRVSTR_0 },
+    // SPI2
+    { MXC_GPIO2, (MXC_GPIO_PIN_2 | MXC_GPIO_PIN_3 | MXC_GPIO_PIN_4),
+      MXC_GPIO_FUNC_ALT1, MXC_GPIO_PAD_NONE, MXC_GPIO_VSSEL_VDDIO, MXC_GPIO_DRVSTR_0 },
+    // SPI3
+    { MXC_GPIO0, (MXC_GPIO_PIN_16 | MXC_GPIO_PIN_20 | MXC_GPIO_PIN_21),
+      MXC_GPIO_FUNC_ALT1, MXC_GPIO_PAD_NONE, MXC_GPIO_VSSEL_VDDIO, MXC_GPIO_DRVSTR_0 },
+    // SPI4
+    { MXC_GPIO1, (MXC_GPIO_PIN_1 | MXC_GPIO_PIN_2 | MXC_GPIO_PIN_3),
+      MXC_GPIO_FUNC_ALT1, MXC_GPIO_PAD_NONE, MXC_GPIO_VSSEL_VDDIO, MXC_GPIO_DRVSTR_0 },
+};
+
+int pinsToSpi(const mcu_pin_obj_t *mosi, const mcu_pin_obj_t *miso,
+    const mcu_pin_obj_t *sck) {
+    for (int i = 0; i < NUM_SPI; i++) {
+        if ((spi_maps[i].port == (MXC_GPIO_GET_GPIO(mosi->port)))
+            && (spi_maps[i].mask == ((mosi->mask) | (miso->mask) | (sck->mask)))) {
+            return i;
+        }
+    }
+    mp_raise_RuntimeError_varg(MP_ERROR_TEXT("ERR: Unable to find an SPI matching pins... \
+        \nMOSI: port %d mask %d\nMISO: port %d mask %d\n"),
+        mosi->port, mosi->mask, miso->port, miso->mask,
+        sck->port, sck->mask);
+    return -1;
+}
diff --git a/ports/analog/peripherals/max32690/max32_spi.h b/ports/analog/peripherals/max32690/max32_spi.h
new file mode 100644
index 0000000000000..76bb48a59a7e5
--- /dev/null
+++ b/ports/analog/peripherals/max32690/max32_spi.h
@@ -0,0 +1,17 @@
+// This file is part of the CircuitPython project: https://circuitpython.org
+//
+// SPDX-FileCopyrightText: Copyright (c) 2024 Brandon Hurst, Analog Devices, Inc.
+//
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include "spi_regs.h"
+#include "mxc_sys.h"
+#include "spi.h"
+#include "peripherals/pins.h"
+
+#define NUM_SPI 5
+
+int pinsToSpi(const mcu_pin_obj_t *mosi, const mcu_pin_obj_t *miso,
+    const mcu_pin_obj_t *sck);
diff --git a/ports/analog/peripherals/max32690/max32_uart.c b/ports/analog/peripherals/max32690/max32_uart.c
new file mode 100644
index 0000000000000..5f7a8568fb426
--- /dev/null
+++ b/ports/analog/peripherals/max32690/max32_uart.c
@@ -0,0 +1,37 @@
+// This file is part of the CircuitPython project: https://circuitpython.org
+//
+// SPDX-FileCopyrightText: Copyright (c) 2024 Brandon Hurst, Analog Devices, Inc.
+//
+// SPDX-License-Identifier: MIT
+
+#include "peripherals/pins.h"
+
+#include "common-hal/busio/UART.h"
+#include "max32_uart.h"
+#include "max32690.h"
+
+#include "py/runtime.h"
+#include "py/mperrno.h"
+
+const mxc_gpio_cfg_t uart_maps[NUM_UARTS] = {
+    { MXC_GPIO2, (MXC_GPIO_PIN_11 | MXC_GPIO_PIN_12), MXC_GPIO_FUNC_ALT1,
+      MXC_GPIO_PAD_WEAK_PULL_UP, MXC_GPIO_VSSEL_VDDIO, MXC_GPIO_DRVSTR_0 },
+    { MXC_GPIO2, (MXC_GPIO_PIN_14 | MXC_GPIO_PIN_16), MXC_GPIO_FUNC_ALT1,
+      MXC_GPIO_PAD_WEAK_PULL_UP, MXC_GPIO_VSSEL_VDDIO, MXC_GPIO_DRVSTR_0 },
+    { MXC_GPIO1, (MXC_GPIO_PIN_9 | MXC_GPIO_PIN_10), MXC_GPIO_FUNC_ALT1,
+      MXC_GPIO_PAD_WEAK_PULL_UP, MXC_GPIO_VSSEL_VDDIO, MXC_GPIO_DRVSTR_0 },
+    { MXC_GPIO3, (MXC_GPIO_PIN_0 | MXC_GPIO_PIN_1), MXC_GPIO_FUNC_ALT2,
+      MXC_GPIO_PAD_WEAK_PULL_UP, MXC_GPIO_VSSEL_VDDIO, MXC_GPIO_DRVSTR_0 }
+};
+
+int pinsToUart(const mcu_pin_obj_t *rx, const mcu_pin_obj_t *tx) {
+    for (int i = 0; i < NUM_UARTS; i++) {
+        if ((uart_maps[i].port == (MXC_GPIO_GET_GPIO(tx->port)))
+            && (uart_maps[i].mask == ((tx->mask) | (rx->mask)))) {
+            return i;
+        }
+    }
+    mp_raise_RuntimeError_varg(MP_ERROR_TEXT("ERR: Unable to find a uart matching pins...\nTX: port %d mask %d\nRX: port %d mask %d\n"),
+        tx->port, tx->mask, rx->port, rx->mask);
+    return -1;
+}
diff --git a/ports/analog/peripherals/max32690/max32_uart.h b/ports/analog/peripherals/max32690/max32_uart.h
new file mode 100644
index 0000000000000..f03b500a3c507
--- /dev/null
+++ b/ports/analog/peripherals/max32690/max32_uart.h
@@ -0,0 +1,16 @@
+// This file is part of the CircuitPython project: https://circuitpython.org
+//
+// SPDX-FileCopyrightText: Copyright (c) 2024 Brandon Hurst, Analog Devices, Inc.
+//
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include "uart_regs.h"
+#include "mxc_sys.h"
+#include "uart.h"
+#include "peripherals/pins.h"
+
+#define NUM_UARTS 4
+
+int pinsToUart(const mcu_pin_obj_t *rx, const mcu_pin_obj_t *tx);
diff --git a/ports/analog/supervisor/port.c b/ports/analog/supervisor/port.c
index ad003c12ed9e0..8f14c8d90d626 100644
--- a/ports/analog/supervisor/port.c
+++ b/ports/analog/supervisor/port.c
@@ -39,6 +39,7 @@
 
 // Sys includes
 #include "max32_port.h"
+#include "nvic_table.h"
 
 // Timers
 #include "mxc_delay.h"
@@ -69,12 +70,21 @@ volatile uint32_t system_ticks = 0;
 
 void SysTick_Handler(void) {
     system_ticks++;
+
+    MXC_DelayHandler();
 }
 
 
 safe_mode_t port_init(void) {
     int err = E_NO_ERROR;
 
+    // Set Vector Table to RAM & configure ARM core to use RAM-based ISRs
+    // This allows definition of ISRs with custom names
+    //
+    // Useful for mapping ISRs with names not related to a specific IRQn.
+    // Source: https://arm-software.github.io/CMSIS_5/Core/html/using_VTOR_pg.html
+    NVIC_SetRAM();
+
     // 1ms tick timer
     SysTick_Config(SystemCoreClock / 1000);
     NVIC_EnableIRQ(SysTick_IRQn);
diff --git a/ports/analog/tools/debug-dap.gdb b/ports/analog/tools/debug-dap.gdb
new file mode 100644
index 0000000000000..d0aa7e2b13fa0
--- /dev/null
+++ b/ports/analog/tools/debug-dap.gdb
@@ -0,0 +1,3 @@
+target remote :3333
+break main
+continue
diff --git a/ports/analog/tools/debug-dap.sh b/ports/analog/tools/debug-dap.sh
new file mode 100644
index 0000000000000..df2964fcb122a
--- /dev/null
+++ b/ports/analog/tools/debug-dap.sh
@@ -0,0 +1,23 @@
+#!/bin/bash
+
+# Primer on taking cmd line args in Linux shell scripts
+# $0 is the script itself
+# $1 $2 $3 are arg1, arg2, arg3, etc
+
+# Export OCD Path
+### USER ACTION: Replace with your path to OpenOCD ###
+OCD_PATH="~/MaximSDK/Tools/OpenOCD"
+
+# Call openocd to setup the debug server, storing the PID for OpenOCD
+sh -c "openocd -s $OCD_PATH/scripts -f interface/cmsis-dap.cfg -f target/$1.cfg -c \"init; reset halt\" " &
+
+# Allow enough time for OCD server to set up
+# + wait for the sleep to finish
+sleep 3 &
+wait $!
+
+# spawn the gdb process and store the gdb_pid
+gdb-multiarch build-apard32690/firmware.elf -x "tools/debug-dap.gdb"
+
+# when gdb exits, kill all openocd processes
+killall openocd
diff --git a/ports/analog/tools/flash_max32.jlink b/ports/analog/tools/flash_max32.jlink
index 4c9cbacb96fee..0453f4cb077fd 100644
--- a/ports/analog/tools/flash_max32.jlink
+++ b/ports/analog/tools/flash_max32.jlink
@@ -1,6 +1,7 @@
-si 1
+selectinterface swd
 erase
-loadbin build-APARD/firmware.bin 0x10000000
-r
-g
+loadbin build-apard32690/firmware.bin 0x10000000
+reset
+halt
+go
 exit