Merge pull request #3326 from tannewt/native_wifi

Add native wifi API with ESP32S2 support

69 files changed, 3926 insertions, 59 deletions

diff --git a/conf.py b/conf.py
index 256ca922c..1d4c42048 100644
--- a/conf.py
+++ b/conf.py
@@ -146,6 +146,7 @@ version = release = final_version
 # directories to ignore when looking for source files.
 exclude_patterns = ["**/build*",
                     ".git",
+                    ".env",
                     ".venv",
                     ".direnv",
                     "docs/autoapi",
diff --git a/lib/tinyusb b/lib/tinyusb
-Subproject 22100b252fc2eb8f51ed407949645653c4880fd
+Subproject e90cf7a676eddcbd9c35d2d99a0a9cd14686e2c
diff --git a/locale/circuitpython.pot b/locale/circuitpython.pot
index aeea5f5e9..af9491c04 100644
--- a/locale/circuitpython.pot
+++ b/locale/circuitpython.pot
@@ -8,7 +8,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2020-08-30 14:38-0400\n"
+"POT-Creation-Date: 2020-09-09 14:33-0700\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"
@@ -273,7 +273,7 @@ msgstr ""
 msgid "A hardware interrupt channel is already in use"
 msgstr ""
 
-#: shared-bindings/_bleio/Address.c
+#: shared-bindings/_bleio/Address.c shared-bindings/ipaddress/IPv4Address.c
 #, c-format
 msgid "Address must be %d bytes long"
 msgstr ""
@@ -371,6 +371,10 @@ msgstr ""
 msgid "Attempted heap allocation when MicroPython VM not running."
 msgstr ""
 
+#: shared-bindings/wifi/Radio.c
+msgid "Authentication failure"
+msgstr ""
+
 #: main.c
 msgid "Auto-reload is off.\n"
 msgstr ""
@@ -578,6 +582,10 @@ msgid ""
 "boot. Press again to exit safe mode.\n"
 msgstr ""
 
+#: supervisor/shared/safe_mode.c
+msgid "CircuitPython was unable to allocate the heap.\n"
+msgstr ""
+
 #: shared-module/bitbangio/SPI.c
 msgid "Clock pin init failed."
 msgstr ""
@@ -1221,6 +1229,10 @@ msgstr ""
 msgid "No more timers available on this pin."
 msgstr ""
 
+#: shared-bindings/wifi/Radio.c
+msgid "No network with that ssid"
+msgstr ""
+
 #: shared-module/touchio/TouchIn.c
 msgid "No pulldown on pin; 1Mohm recommended"
 msgstr ""
@@ -1241,6 +1253,10 @@ msgstr ""
 msgid "Nordic Soft Device failure assertion."
 msgstr ""
 
+#: shared-bindings/ipaddress/IPv4Address.c shared-bindings/ipaddress/__init__.c
+msgid "Not a valid IP string"
+msgstr ""
+
 #: ports/nrf/common-hal/_bleio/__init__.c
 #: shared-bindings/_bleio/CharacteristicBuffer.c
 msgid "Not connected"
@@ -1285,6 +1301,10 @@ msgid ""
 "%d bpp given"
 msgstr ""
 
+#: shared-bindings/ipaddress/__init__.c
+msgid "Only raw int supported for ip"
+msgstr ""
+
 #: shared-bindings/audiobusio/PDMIn.c
 msgid "Oversample must be multiple of 8."
 msgstr ""
@@ -1481,6 +1501,10 @@ msgstr ""
 msgid "Serializer in use"
 msgstr ""
 
+#: shared-bindings/ssl/SSLContext.c
+msgid "Server side context cannot have hostname"
+msgstr ""
+
 #: shared-bindings/nvm/ByteArray.c
 msgid "Slice and value different lengths."
 msgstr ""
@@ -1676,6 +1700,10 @@ msgstr ""
 msgid "Unexpected nrfx uuid type"
 msgstr ""
 
+#: shared-bindings/wifi/Radio.c
+msgid "Unknown failure"
+msgstr ""
+
 #: ports/nrf/common-hal/_bleio/__init__.c
 #, c-format
 msgid "Unknown gatt error: 0x%04x"
@@ -1779,6 +1807,10 @@ msgid ""
 "To list built-in modules please do `help(\"modules\")`.\n"
 msgstr ""
 
+#: shared-bindings/wifi/Radio.c
+msgid "WiFi password must be between 8 and 63 characters"
+msgstr ""
+
 #: ports/nrf/common-hal/_bleio/PacketBuffer.c
 msgid "Writes not supported on Characteristic"
 msgstr ""
diff --git a/ports/esp32s2/CMakeLists.txt b/ports/esp32s2/CMakeLists.txt
index 716588cf2..0d7f48995 100644
--- a/ports/esp32s2/CMakeLists.txt
+++ b/ports/esp32s2/CMakeLists.txt
@@ -3,7 +3,10 @@
 cmake_minimum_required(VERSION 3.13)
 
 set(ENV{IDF_PATH} ${CMAKE_SOURCE_DIR}/esp-idf)
-set(COMPONENTS esptool_py soc driver log main)
+
+# The component list here determines what options we get in menuconfig and what the ninja file
+# can build.
+set(COMPONENTS esptool_py soc driver log main esp-tls mbedtls esp_event esp_netif esp_wifi lwip wpa_supplicant freertos)
 
 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
 project(circuitpython)
diff --git a/ports/esp32s2/Makefile b/ports/esp32s2/Makefile
index 19b89a13a..ea9c68592 100644
--- a/ports/esp32s2/Makefile
+++ b/ports/esp32s2/Makefile
@@ -78,10 +78,19 @@ INC += -Iesp-idf/components/freertos/xtensa/include
 INC += -Iesp-idf/components/esp32s2/include
 INC += -Iesp-idf/components/xtensa/esp32s2/include
 INC += -Iesp-idf/components/esp_common/include
+INC += -Iesp-idf/components/esp_event/include
+INC += -Iesp-idf/components/esp_netif/include
 INC += -Iesp-idf/components/esp_ringbuf/include
 INC += -Iesp-idf/components/esp_rom/include
+INC += -Iesp-idf/components/esp_wifi/include
 INC += -Iesp-idf/components/xtensa/include
 INC += -Iesp-idf/components/esp_timer/include
+INC += -Iesp-idf/components/mbedtls/mbedtls/include
+INC += -Iesp-idf/components/mbedtls/port/include/
+INC += -Iesp-idf/components/newlib/platform_include
+INC += -Iesp-idf/components/lwip/lwip/src/include
+INC += -Iesp-idf/components/lwip/port/esp32/include
+INC += -Iesp-idf/components/lwip/include/apps/sntp
 INC += -Iesp-idf/components/soc/include
 INC += -Iesp-idf/components/soc/src/esp32s2/include
 INC += -Iesp-idf/components/soc/soc/include
@@ -125,11 +134,12 @@ LDFLAGS += -L$(BUILD)/esp-idf/esp-idf/esp32s2 \
            -Tesp32s2.peripherals.ld \
            -Lesp-idf/components/esp_rom/esp32s2/ld \
            -Tesp32s2.rom.ld \
+           -Tesp32s2.rom.api.ld \
            -Tesp32s2.rom.libgcc.ld \
            -Tesp32s2.rom.newlib-data.ld \
            -Tesp32s2.rom.newlib-funcs.ld \
            -Tesp32s2.rom.spiflash.ld
-LIBS := -lgcc -lc
+LIBS := -lgcc -lc -lstdc++
 
 #
 
@@ -156,6 +166,7 @@ SRC_C += \
 	background.c \
 	fatfs_port.c \
 	mphalport.c \
+	bindings/espidf/__init__.c \
 	boards/$(BOARD)/board.c \
 	boards/$(BOARD)/pins.c \
 	modules/$(CIRCUITPY_MODULE).c \
@@ -238,20 +249,25 @@ $(BUILD)/esp-idf/partition_table/partition-table.bin: $(BUILD)/esp-idf/config/sd
 
 # run menuconfig
 menuconfig: $(BUILD)/esp-idf/config
-	ninja -C $(BUILD)/esp-idf menuconfig
-	diff --old-line-format= --unchanged-line-format= sdkconfig.defaults $(BUILD)/esp-idf/sdkconfig > boards/$(BOARD)/sdkconfig || true
+	$(Q)ninja -C $(BUILD)/esp-idf menuconfig
+	$(Q)diff --old-line-format= --unchanged-line-format= sdkconfig.defaults $(BUILD)/esp-idf/sdkconfig > boards/$(BOARD)/sdkconfig || true
 
 # qstr builds include headers so we need to make sure they are up to date
 $(HEADER_BUILD)/qstr.i.last: | $(BUILD)/esp-idf/config/sdkconfig.h
 
 # Order here matters
-ESP_IDF_COMPONENTS_LINK = freertos log esp_system esp32s2 bootloader_support pthread esp_timer vfs spi_flash app_update esp_common esp32s2 heap newlib driver xtensa soc esp_ringbuf #
+ESP_IDF_COMPONENTS_LINK = freertos log esp_system esp32s2 bootloader_support pthread esp_timer vfs spi_flash app_update esp_common esp32s2 heap newlib driver xtensa soc esp_ringbuf esp_wifi esp_event wpa_supplicant mbedtls efuse nvs_flash esp_netif lwip esp_rom esp-tls
 
 ESP_IDF_COMPONENTS_INCLUDE = driver freertos log soc
 
 INC += $(foreach component, $(ESP_IDF_COMPONENTS_INCLUDE), -Iesp-idf/components/$(component)/include)
 
 ESP_IDF_COMPONENTS_EXPANDED = $(foreach component, $(ESP_IDF_COMPONENTS_LINK), $(BUILD)/esp-idf/esp-idf/$(component)/lib$(component).a)
+ESP_IDF_WIFI_COMPONENTS_EXPANDED = $(foreach component, $(ESP_IDF_WIFI_COMPONENTS_LINK), $(BUILD)/esp-idf/esp-idf/$(component)/lib$(component).a)
+
+MBEDTLS_COMPONENTS_LINK = crypto tls x509
+MBEDTLS_COMPONENTS_LINK_EXPANDED = $(foreach component, $(MBEDTLS_COMPONENTS_LINK), $(BUILD)/esp-idf/esp-idf/mbedtls/mbedtls/library/libmbed$(component).a)
+
 BINARY_BLOBS = esp-idf/components/xtensa/esp32s2/libhal.a
 BINARY_WIFI_BLOBS = libcoexist.a libcore.a libespnow.a libmesh.a libnet80211.a libpp.a librtc.a libsmartconfig.a libphy.a
 BINARY_BLOBS += $(addprefix esp-idf/components/esp_wifi/lib/esp32s2/, $(BINARY_WIFI_BLOBS))
@@ -265,18 +281,27 @@ all: $(BUILD)/firmware.bin $(BUILD)/firmware.uf2
 
 .PHONY: esp-idf-stamp
 esp-idf-stamp: $(BUILD)/esp-idf/config/sdkconfig.h
-	ninja -C $(BUILD)/esp-idf \
+	$(Q)ninja -C $(BUILD)/esp-idf \
 		bootloader/bootloader.bin \
 		esp-idf/bootloader_support/libbootloader_support.a \
+		esp-idf/esp-tls/libesp-tls.a \
 		esp-idf/esp32s2/ld/esp32s2.project.ld \
+		esp-idf/esp_event/libesp_event.a \
+		esp-idf/esp_netif/libesp_netif.a \
+		esp-idf/esp_rom/libesp_rom.a \
 		esp-idf/esp_system/libesp_system.a \
+		esp-idf/esp_wifi/libesp_wifi.a \
+		esp-idf/lwip/liblwip.a \
+		esp-idf/nvs_flash/libnvs_flash.a \
+		esp-idf/wpa_supplicant/libwpa_supplicant.a \
+		esp-idf/mbedtls/libmbedtls.a \
 		esp-idf/freertos/libfreertos.a \
 		esp-idf/log/liblog.a \
 		esp-idf/xtensa/libxtensa.a
 
 $(BUILD)/firmware.elf: $(OBJ) | esp-idf-stamp
 	$(STEPECHO) "LINK $@"
-	$(Q)$(CC) -o $@ $(LDFLAGS) $^ $(ESP_IDF_COMPONENTS_EXPANDED) $(BINARY_BLOBS) build-$(BOARD)/esp-idf/esp-idf/newlib/libnewlib.a -u newlib_include_pthread_impl -Wl,--start-group $(LIBS) -Wl,--end-group
+	$(Q)$(CC) -o $@ $(LDFLAGS) $^ -Wl,--start-group $(ESP_IDF_COMPONENTS_EXPANDED) $(BINARY_BLOBS) $(MBEDTLS_COMPONENTS_LINK_EXPANDED) build-$(BOARD)/esp-idf/esp-idf/newlib/libnewlib.a  -Wl,--end-group -u newlib_include_pthread_impl -Wl,--start-group $(LIBS) -Wl,--end-group build-$(BOARD)/esp-idf/esp-idf/pthread/libpthread.a  -u __cxx_fatal_exception
 	# $(Q)$(SIZE) $@ | $(PYTHON3) $(TOP)/tools/build_memory_info.py $(BUILD)/esp-idf/esp-idf/esp32s2/esp32s2_out.ld
 
 $(BUILD)/circuitpython-firmware.bin: $(BUILD)/firmware.elf
diff --git a/ports/esp32s2/bindings/espidf/__init__.c b/ports/esp32s2/bindings/espidf/__init__.c
new file mode 100644
index 000000000..3b910cfe6
--- /dev/null
+++ b/ports/esp32s2/bindings/espidf/__init__.c
@@ -0,0 +1,110 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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 "py/obj.h"
+#include "py/runtime.h"
+
+#include "bindings/espidf/__init__.h"
+
+#include "esp-idf/components/heap/include/esp_heap_caps.h"
+
+//| """Direct access to a few ESP-IDF details. This module *should not* include any functionality
+//|    that could be implemented by other frameworks. It should only include ESP-IDF specific
+//|    things."""
+
+//| def heap_caps_get_total_size() -> int:
+//|     """Return the total size of the ESP-IDF, which includes the CircuitPython heap."""
+//|     ...
+//|
+
+STATIC mp_obj_t espidf_heap_caps_get_total_size(void) {
+    return MP_OBJ_NEW_SMALL_INT(heap_caps_get_total_size(MALLOC_CAP_8BIT));
+}
+MP_DEFINE_CONST_FUN_OBJ_0(espidf_heap_caps_get_total_size_obj, espidf_heap_caps_get_total_size);
+
+//| def heap_caps_get_free_size() -> int:
+//|     """Return total free memory in the ESP-IDF heap."""
+//|     ...
+//|
+
+STATIC mp_obj_t espidf_heap_caps_get_free_size(void) {
+    return MP_OBJ_NEW_SMALL_INT(heap_caps_get_free_size(MALLOC_CAP_8BIT));
+}
+MP_DEFINE_CONST_FUN_OBJ_0(espidf_heap_caps_get_free_size_obj, espidf_heap_caps_get_free_size);
+
+//| def heap_caps_get_largest_free_block() -> int:
+//|     """Return the size of largest free memory block in the ESP-IDF heap."""
+//|     ...
+//|
+
+STATIC mp_obj_t espidf_heap_caps_get_largest_free_block(void) {
+    return MP_OBJ_NEW_SMALL_INT(heap_caps_get_largest_free_block(MALLOC_CAP_8BIT));
+}
+MP_DEFINE_CONST_FUN_OBJ_0(espidf_heap_caps_get_largest_free_block_obj, espidf_heap_caps_get_largest_free_block);
+
+//| class MemoryError(MemoryError):
+//|     """Raised when an ESP IDF memory allocation fails."""
+//|     ...
+//|
+NORETURN void mp_raise_espidf_MemoryError(void) {
+    nlr_raise(mp_obj_new_exception(&mp_type_espidf_MemoryError));
+}
+
+void espidf_exception_print(const mp_print_t *print, mp_obj_t o_in, mp_print_kind_t kind) {
+    mp_print_kind_t k = kind & ~PRINT_EXC_SUBCLASS;
+    bool is_subclass = kind & PRINT_EXC_SUBCLASS;
+    if (!is_subclass && (k == PRINT_EXC)) {
+        mp_print_str(print, qstr_str(MP_OBJ_QSTR_VALUE(MP_ROM_QSTR(MP_QSTR_espidf))));
+        mp_print_str(print, ".");
+    }
+    mp_obj_exception_print(print, o_in, kind);
+}
+
+const mp_obj_type_t mp_type_espidf_MemoryError = {
+    { &mp_type_type },
+    .name = MP_QSTR_MemoryError,
+    .print = espidf_exception_print,
+    .make_new = mp_obj_exception_make_new,
+    .attr = mp_obj_exception_attr,
+    .parent = &mp_type_MemoryError,
+};
+
+STATIC const mp_rom_map_elem_t espidf_module_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_espidf) },
+
+    { MP_ROM_QSTR(MP_QSTR_heap_caps_get_total_size), MP_ROM_PTR(&espidf_heap_caps_get_total_size_obj)},
+    { MP_ROM_QSTR(MP_QSTR_heap_caps_get_free_size), MP_ROM_PTR(&espidf_heap_caps_get_free_size_obj)},
+    { MP_ROM_QSTR(MP_QSTR_heap_caps_get_largest_free_block), MP_ROM_PTR(&espidf_heap_caps_get_largest_free_block_obj)},
+
+    { MP_ROM_QSTR(MP_QSTR_MemoryError),      MP_ROM_PTR(&mp_type_espidf_MemoryError) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(espidf_module_globals, espidf_module_globals_table);
+
+const mp_obj_module_t espidf_module = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t*)&espidf_module_globals,
+};
diff --git a/ports/esp32s2/bindings/espidf/__init__.h b/ports/esp32s2/bindings/espidf/__init__.h
new file mode 100644
index 000000000..356c1c814
--- /dev/null
+++ b/ports/esp32s2/bindings/espidf/__init__.h
@@ -0,0 +1,34 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_ESP32S2_BINDINGS_ESPIDF___INIT___H
+#define MICROPY_INCLUDED_ESP32S2_BINDINGS_ESPIDF___INIT___H
+
+extern const mp_obj_type_t mp_type_espidf_MemoryError;
+
+NORETURN void mp_raise_espidf_MemoryError(void);
+
+#endif  // MICROPY_INCLUDED_ESP32S2_BINDINGS_ESPIDF___INIT___H
diff --git a/ports/esp32s2/common-hal/socketpool/Socket.c b/ports/esp32s2/common-hal/socketpool/Socket.c
new file mode 100644
index 000000000..0a994c604
--- /dev/null
+++ b/ports/esp32s2/common-hal/socketpool/Socket.c
@@ -0,0 +1,139 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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/socketpool/Socket.h"
+
+#include "bindings/espidf/__init__.h"
+#include "lib/utils/interrupt_char.h"
+#include "py/mperrno.h"
+#include "py/runtime.h"
+#include "supervisor/shared/tick.h"
+
+void common_hal_socketpool_socket_settimeout(socketpool_socket_obj_t* self, mp_uint_t timeout_ms) {
+    self->timeout_ms = timeout_ms;
+}
+
+bool common_hal_socketpool_socket_connect(socketpool_socket_obj_t* self, const char* host, mp_uint_t hostlen, mp_int_t port) {
+    // For simplicity we use esp_tls for all TCP connections. If it's not SSL, ssl_context will be
+    // NULL and should still work. This makes regular TCP connections more memory expensive but TLS
+    // should become more and more common. Therefore, we optimize for the TLS case.
+
+    esp_tls_cfg_t* tls_config = NULL;
+    if (self->ssl_context != NULL) {
+        tls_config = &self->ssl_context->ssl_config;
+    }
+    int result = esp_tls_conn_new_sync(host, hostlen, port, tls_config, self->tcp);
+    self->connected = result >= 0;
+    if (result < 0) {
+        int esp_tls_code;
+        int flags;
+        esp_err_t err = esp_tls_get_and_clear_last_error(self->tcp->error_handle, &esp_tls_code, &flags);
+
+        if (err == ESP_ERR_MBEDTLS_SSL_SETUP_FAILED) {
+            mp_raise_espidf_MemoryError();
+        } else if (ESP_ERR_MBEDTLS_SSL_HANDSHAKE_FAILED) {
+            mp_raise_OSError_msg_varg(translate("Failed SSL handshake"));
+        } else {
+            mp_raise_OSError_msg_varg(translate("Unhandled ESP TLS error %d %d %x %d"), esp_tls_code, flags, err, result);
+        }
+    }
+
+    return self->connected;
+}
+
+bool common_hal_socketpool_socket_get_connected(socketpool_socket_obj_t* self) {
+    return self->connected;
+}
+
+mp_uint_t common_hal_socketpool_socket_send(socketpool_socket_obj_t* self, const uint8_t* buf, mp_uint_t len) {
+    size_t sent = esp_tls_conn_write(self->tcp, buf, len);
+
+    if (sent < 0) {
+        mp_raise_OSError(MP_ENOTCONN);
+    }
+    return sent;
+}
+
+mp_uint_t common_hal_socketpool_socket_recv_into(socketpool_socket_obj_t* self, const uint8_t* buf, mp_uint_t len) {
+    size_t received = 0;
+    ssize_t last_read = 1;
+    uint64_t start_ticks = supervisor_ticks_ms64();
+    int sockfd;
+    esp_err_t err = esp_tls_get_conn_sockfd(self->tcp, &sockfd);
+    if (err != ESP_OK) {
+        mp_raise_OSError(MP_EBADF);
+    }
+    while (received < len &&
+           last_read > 0 &&
+           (self->timeout_ms == 0 || supervisor_ticks_ms64() - start_ticks <= self->timeout_ms) &&
+           !mp_hal_is_interrupted()) {
+        RUN_BACKGROUND_TASKS;
+        size_t available = esp_tls_get_bytes_avail(self->tcp);
+        if (available == 0) {
+            // This reads the raw socket buffer and is used for non-TLS connections
+            // and between encrypted TLS blocks.
+            int status = lwip_ioctl(sockfd, FIONREAD, &available);
+            if (status < 0) {
+                last_read = status;
+                break;
+            }
+        }
+        size_t remaining = len - received;
+        if (available > remaining) {
+            available = remaining;
+        }
+        if (available > 0) {
+            last_read = esp_tls_conn_read(self->tcp, (void*) buf + received, available);
+            received += last_read;
+        }
+    }
+
+    if (last_read == 0) {
+        // socket closed
+        common_hal_socketpool_socket_close(self);
+    }
+    if (last_read < 0) {
+        mp_raise_BrokenPipeError();
+    }
+    return received;
+}
+
+void common_hal_socketpool_socket_close(socketpool_socket_obj_t* self) {
+    self->connected = false;
+    if (self->tcp != NULL) {
+        esp_tls_conn_destroy(self->tcp);
+        self->tcp = NULL;
+    }
+}
+
+bool common_hal_socketpool_socket_get_closed(socketpool_socket_obj_t* self) {
+    return self->tcp == NULL;
+}
+
+
+mp_uint_t common_hal_socketpool_socket_get_hash(socketpool_socket_obj_t* self) {
+    return self->num;
+}
diff --git a/ports/esp32s2/common-hal/socketpool/Socket.h b/ports/esp32s2/common-hal/socketpool/Socket.h
new file mode 100644
index 000000000..c23dd171c
--- /dev/null
+++ b/ports/esp32s2/common-hal/socketpool/Socket.h
@@ -0,0 +1,47 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_ESP32S2_COMMON_HAL_SOCKETPOOL_SOCKET_H
+#define MICROPY_INCLUDED_ESP32S2_COMMON_HAL_SOCKETPOOL_SOCKET_H
+
+#include "py/obj.h"
+
+#include "common-hal/socketpool/SocketPool.h"
+#include "common-hal/ssl/SSLContext.h"
+
+#include "esp-idf/components/esp-tls/esp_tls.h"
+
+typedef struct {
+    mp_obj_base_t base;
+    int num;
+    bool connected;
+    esp_tls_t* tcp;
+    ssl_sslcontext_obj_t* ssl_context;
+    socketpool_socketpool_obj_t* pool;
+    mp_uint_t timeout_ms;
+} socketpool_socket_obj_t;
+
+#endif // MICROPY_INCLUDED_ESP32S2_COMMON_HAL_SOCKETPOOL_SOCKET_H
diff --git a/ports/esp32s2/common-hal/socketpool/SocketPool.c b/ports/esp32s2/common-hal/socketpool/SocketPool.c
new file mode 100644
index 000000000..4a07f21c4
--- /dev/null
+++ b/ports/esp32s2/common-hal/socketpool/SocketPool.c
@@ -0,0 +1,117 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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/socketpool/SocketPool.h"
+
+#include "py/runtime.h"
+#include "shared-bindings/wifi/__init__.h"
+
+#include "esp-idf/components/lwip/lwip/src/include/lwip/netdb.h"
+
+#include "bindings/espidf/__init__.h"
+
+void common_hal_socketpool_socketpool_construct(socketpool_socketpool_obj_t* self, mp_obj_t radio) {
+    if (radio != MP_OBJ_FROM_PTR(&common_hal_wifi_radio_obj)) {
+        mp_raise_ValueError(translate("SocketPool can only be used with wifi.radio"));
+    }
+}
+
+socketpool_socket_obj_t* common_hal_socketpool_socket(socketpool_socketpool_obj_t* self,
+    socketpool_socketpool_addressfamily_t family, socketpool_socketpool_sock_t type) {
+
+    int addr_family;
+    int ipproto;
+    if (family == SOCKETPOOL_AF_INET) {
+        addr_family = AF_INET;
+        ipproto = IPPROTO_IP;
+    } else { // INET6
+        addr_family = AF_INET6;
+        ipproto = IPPROTO_IPV6;
+    }
+
+    int socket_type;
+    if (type == SOCKETPOOL_SOCK_STREAM) {
+        socket_type = SOCK_STREAM;
+    } else if (type == SOCKETPOOL_SOCK_DGRAM) {
+        socket_type = SOCK_DGRAM;
+    } else { // SOCKETPOOL_SOCK_RAW
+        socket_type = SOCK_RAW;
+    }
+
+    if (socket_type == SOCK_DGRAM || socket_type == SOCK_RAW ||
+            addr_family == AF_INET6 || ipproto == IPPROTO_IPV6) {
+        mp_raise_NotImplementedError(translate("Only IPv4 SOCK_STREAM sockets supported"));
+    }
+
+    int socknum = -1;
+    esp_tls_t* tcp_handle = NULL;
+    if (socket_type == SOCK_DGRAM || socket_type == SOCK_RAW) {
+        // socknum = lwip_socket(addr_family, socket_type, ipproto);
+    } else {
+        tcp_handle = esp_tls_init();
+
+        if (tcp_handle == NULL) {
+            mp_raise_espidf_MemoryError();
+        }
+    }
+    if (socknum < 0 && tcp_handle == NULL) {
+        mp_raise_RuntimeError(translate("Out of sockets"));
+    }
+
+    socketpool_socket_obj_t *sock = m_new_obj_with_finaliser(socketpool_socket_obj_t);
+    sock->base.type = &socketpool_socket_type;
+    sock->num = socknum;
+    sock->tcp = tcp_handle;
+    sock->ssl_context = NULL;
+    sock->pool = self;
+    return sock;
+}
+
+
+mp_obj_t common_hal_socketpool_socketpool_gethostbyname(socketpool_socketpool_obj_t* self,
+    const char* host) {
+
+    const struct addrinfo hints = {
+        .ai_family = AF_INET,
+        .ai_socktype = SOCK_STREAM,
+    };
+    struct addrinfo *res;
+    int err = getaddrinfo(host, NULL, &hints, &res);
+    if (err != 0 || res == NULL) {
+        return mp_const_none;
+    }
+
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wcast-align"
+    struct in_addr *addr = &((struct sockaddr_in *)res->ai_addr)->sin_addr;
+    #pragma GCC diagnostic pop
+    char ip_str[IP4ADDR_STRLEN_MAX];
+    inet_ntoa_r(*addr, ip_str, IP4ADDR_STRLEN_MAX);
+    mp_obj_t ip_obj = mp_obj_new_str(ip_str, strlen(ip_str));
+    freeaddrinfo(res);
+
+    return ip_obj;
+}
diff --git a/ports/esp32s2/common-hal/socketpool/SocketPool.h b/ports/esp32s2/common-hal/socketpool/SocketPool.h
new file mode 100644
index 000000000..ae9988d59
--- /dev/null
+++ b/ports/esp32s2/common-hal/socketpool/SocketPool.h
@@ -0,0 +1,36 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_ESP32S2_COMMON_HAL_SOCKETPOOL_SOCKETPOOL_H
+#define MICROPY_INCLUDED_ESP32S2_COMMON_HAL_SOCKETPOOL_SOCKETPOOL_H
+
+#include "py/obj.h"
+
+typedef struct {
+    mp_obj_base_t base;
+} socketpool_socketpool_obj_t;
+
+#endif // MICROPY_INCLUDED_ESP32S2_COMMON_HAL_SOCKETPOOL_SOCKETPOOL_H
diff --git a/ports/esp32s2/common-hal/socketpool/__init__.c b/ports/esp32s2/common-hal/socketpool/__init__.c
new file mode 100644
index 000000000..fa0e7d5f3
--- /dev/null
+++ b/ports/esp32s2/common-hal/socketpool/__init__.c
@@ -0,0 +1,25 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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.
+ */
diff --git a/ports/esp32s2/common-hal/socketpool/__init__.h b/ports/esp32s2/common-hal/socketpool/__init__.h
new file mode 100644
index 000000000..8f9565b46
--- /dev/null
+++ b/ports/esp32s2/common-hal/socketpool/__init__.h
@@ -0,0 +1,31 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_ESP32S2_COMMON_HAL_SOCKETPOOL___INIT___H
+#define MICROPY_INCLUDED_ESP32S2_COMMON_HAL_SOCKETPOOL___INIT___H
+
+
+#endif // MICROPY_INCLUDED_ESP32S2_COMMON_HAL_SOCKETPOOL___INIT___H
diff --git a/ports/esp32s2/common-hal/ssl/SSLContext.c b/ports/esp32s2/common-hal/ssl/SSLContext.c
new file mode 100644
index 000000000..e24fd338b
--- /dev/null
+++ b/ports/esp32s2/common-hal/ssl/SSLContext.c
@@ -0,0 +1,41 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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/ssl/SSLContext.h"
+
+#include "py/runtime.h"
+
+void common_hal_ssl_sslcontext_construct(ssl_sslcontext_obj_t* self) {
+
+}
+
+socketpool_socket_obj_t* common_hal_ssl_sslcontext_wrap_socket(ssl_sslcontext_obj_t* self,
+    socketpool_socket_obj_t* socket, bool server_side, const char* server_hostname) {
+
+    socket->ssl_context = self;
+    // Should we store server hostname on the socket in case connect is called with an ip?
+    return socket;
+}
diff --git a/ports/esp32s2/common-hal/ssl/SSLContext.h b/ports/esp32s2/common-hal/ssl/SSLContext.h
new file mode 100644
index 000000000..41d199f08
--- /dev/null
+++ b/ports/esp32s2/common-hal/ssl/SSLContext.h
@@ -0,0 +1,39 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_ESP32S2_COMMON_HAL_SSL_SSLCONTEXT_H
+#define MICROPY_INCLUDED_ESP32S2_COMMON_HAL_SSL_SSLCONTEXT_H
+
+#include "py/obj.h"
+
+#include "esp-idf/components/esp-tls/esp_tls.h"
+
+typedef struct {
+    mp_obj_base_t base;
+    esp_tls_cfg_t ssl_config;
+} ssl_sslcontext_obj_t;
+
+#endif // MICROPY_INCLUDED_ESP32S2_COMMON_HAL_SSL_SSL_CONTEXT_H
diff --git a/ports/esp32s2/common-hal/ssl/__init__.c b/ports/esp32s2/common-hal/ssl/__init__.c
new file mode 100644
index 000000000..a105e5362
--- /dev/null
+++ b/ports/esp32s2/common-hal/ssl/__init__.c
@@ -0,0 +1,34 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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/ssl/SSLContext.h"
+
+#include "esp-idf/components/mbedtls/esp_crt_bundle/include/esp_crt_bundle.h"
+
+void common_hal_ssl_create_default_context(ssl_sslcontext_obj_t* self) {
+    memset(&self->ssl_config, 0, sizeof(esp_tls_cfg_t));
+    self->ssl_config.crt_bundle_attach = esp_crt_bundle_attach;
+}
diff --git a/ports/esp32s2/common-hal/ssl/__init__.h b/ports/esp32s2/common-hal/ssl/__init__.h
new file mode 100644
index 000000000..fe83a7919
--- /dev/null
+++ b/ports/esp32s2/common-hal/ssl/__init__.h
@@ -0,0 +1,31 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_ESP32S2_COMMON_HAL_SSL___INIT___H
+#define MICROPY_INCLUDED_ESP32S2_COMMON_HAL_SSL___INIT___H
+
+
+#endif // MICROPY_INCLUDED_ESP32S2_COMMON_HAL_SSL___INIT___H
diff --git a/ports/esp32s2/common-hal/wifi/Network.c b/ports/esp32s2/common-hal/wifi/Network.c
new file mode 100644
index 000000000..0320e8f92
--- /dev/null
+++ b/ports/esp32s2/common-hal/wifi/Network.c
@@ -0,0 +1,44 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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/wifi/Network.h"
+
+#include <string.h>
+
+#include "py/obj.h"
+
+mp_obj_t common_hal_wifi_network_get_ssid(wifi_network_obj_t *self) {
+    const char* cstr = (const char*) self->record.ssid;
+	return mp_obj_new_str(cstr, strlen(cstr));
+}
+
+mp_obj_t common_hal_wifi_network_get_rssi(wifi_network_obj_t *self) {
+    return mp_obj_new_int(self->record.rssi);
+}
+
+mp_obj_t common_hal_wifi_network_get_channel(wifi_network_obj_t *self) {
+    return mp_obj_new_int(self->record.primary);
+}
diff --git a/ports/esp32s2/common-hal/wifi/Network.h b/ports/esp32s2/common-hal/wifi/Network.h
new file mode 100644
index 000000000..ab75fcafe
--- /dev/null
+++ b/ports/esp32s2/common-hal/wifi/Network.h
@@ -0,0 +1,39 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_ESP32S2_COMMON_HAL_WIFI_NETWORK_H
+#define MICROPY_INCLUDED_ESP32S2_COMMON_HAL_WIFI_NETWORK_H
+
+#include "py/obj.h"
+
+#include "esp-idf/components/esp_wifi/include/esp_wifi_types.h"
+
+typedef struct {
+    mp_obj_base_t base;
+    wifi_ap_record_t record;
+} wifi_network_obj_t;
+
+#endif // MICROPY_INCLUDED_ESP32S2_COMMON_HAL_WIFI_NETWORK_H
diff --git a/ports/esp32s2/common-hal/wifi/Radio.c b/ports/esp32s2/common-hal/wifi/Radio.c
new file mode 100644
index 000000000..3c6ab5757
--- /dev/null
+++ b/ports/esp32s2/common-hal/wifi/Radio.c
@@ -0,0 +1,174 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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/wifi/Radio.h"
+
+#include <string.h>
+
+#include "common-hal/wifi/__init__.h"
+#include "lib/utils/interrupt_char.h"
+#include "py/runtime.h"
+#include "shared-bindings/ipaddress/IPv4Address.h"
+#include "shared-bindings/wifi/ScannedNetworks.h"
+#include "shared-module/ipaddress/__init__.h"
+
+#include "esp-idf/components/esp_wifi/include/esp_wifi.h"
+#include "esp-idf/components/lwip/include/apps/ping/ping_sock.h"
+
+static void start_station(wifi_radio_obj_t *self) {
+    if (self->sta_mode) {
+        return;
+    }
+    wifi_mode_t next_mode;
+    if (self->ap_mode) {
+        next_mode = WIFI_MODE_APSTA;
+    } else {
+        next_mode = WIFI_MODE_STA;
+    }
+    esp_wifi_set_mode(next_mode);
+
+    esp_wifi_set_config(WIFI_MODE_STA, &self->sta_config);
+}
+
+bool common_hal_wifi_radio_get_enabled(wifi_radio_obj_t *self) {
+    return self->started;
+}
+
+void common_hal_wifi_radio_set_enabled(wifi_radio_obj_t *self, bool enabled) {
+    if (self->started && !enabled) {
+        if (self->current_scan != NULL) {
+            common_hal_wifi_radio_stop_scanning_networks(self);
+        }
+        ESP_ERROR_CHECK(esp_wifi_stop());
+        self->started = false;
+        return;
+    }
+    if (!self->started && enabled) {
+        ESP_ERROR_CHECK(esp_wifi_start());
+        self->started = true;
+        return;
+    }
+}
+
+#define MAC_ADDRESS_LENGTH 6
+
+mp_obj_t common_hal_wifi_radio_get_mac_address(wifi_radio_obj_t *self) {
+    uint8_t mac[MAC_ADDRESS_LENGTH];
+    esp_wifi_get_mac(ESP_IF_WIFI_STA, mac);
+    return mp_obj_new_bytes(mac, MAC_ADDRESS_LENGTH);
+}
+
+mp_obj_t common_hal_wifi_radio_start_scanning_networks(wifi_radio_obj_t *self) {
+    if (self->current_scan != NULL) {
+        mp_raise_RuntimeError(translate("Already scanning for wifi networks"));
+    }
+    // check enabled
+    start_station(self);
+
+    wifi_scannednetworks_obj_t *scan = m_new_obj(wifi_scannednetworks_obj_t);
+    scan->base.type = &wifi_scannednetworks_type;
+    self->current_scan = scan;
+    scan->start_channel = 1;
+    scan->end_channel = 11;
+    scan->radio_event_group = self->event_group_handle;
+    wifi_scannednetworks_scan_next_channel(scan);
+    return scan;
+}
+
+void common_hal_wifi_radio_stop_scanning_networks(wifi_radio_obj_t *self) {
+    // Free the memory used to store the found aps.
+    wifi_scannednetworks_deinit(self->current_scan);
+    self->current_scan = NULL;
+}
+
+wifi_radio_error_t common_hal_wifi_radio_connect(wifi_radio_obj_t *self, uint8_t* ssid, size_t ssid_len, uint8_t* password, size_t password_len, uint8_t channel, mp_float_t timeout) {
+    // check enabled
+    wifi_config_t* config = &self->sta_config;
+    memcpy(&config->sta.ssid, ssid, ssid_len);
+    config->sta.ssid[ssid_len] = 0;
+    memcpy(&config->sta.password, password, password_len);
+    config->sta.password[password_len] = 0;
+    config->sta.channel = channel;
+    esp_wifi_set_config(ESP_IF_WIFI_STA, config);
+    self->starting_retries = 5;
+    self->retries_left = 5;
+    esp_wifi_connect();
+
+    EventBits_t bits;
+    do {
+        RUN_BACKGROUND_TASKS;
+        bits = xEventGroupWaitBits(self->event_group_handle,
+            WIFI_CONNECTED_BIT | WIFI_DISCONNECTED_BIT,
+            pdTRUE,
+            pdTRUE,
+            0);
+    } while ((bits & (WIFI_CONNECTED_BIT | WIFI_DISCONNECTED_BIT)) == 0 && !mp_hal_is_interrupted());
+    if ((bits & WIFI_DISCONNECTED_BIT) != 0) {
+        if (self->last_disconnect_reason == WIFI_REASON_AUTH_FAIL) {
+            return WIFI_RADIO_ERROR_AUTH;
+        } else if (self->last_disconnect_reason == WIFI_REASON_NO_AP_FOUND) {
+            return WIFI_RADIO_ERROR_NO_AP_FOUND;
+        }
+        return WIFI_RADIO_ERROR_UNKNOWN;
+    }
+    return WIFI_RADIO_ERROR_NONE;
+}
+
+mp_obj_t common_hal_wifi_radio_get_ipv4_address(wifi_radio_obj_t *self) {
+    if (!esp_netif_is_netif_up(self->netif)) {
+        return mp_const_none;
+    }
+    esp_netif_ip_info_t ip_info;
+    esp_netif_get_ip_info(self->netif, &ip_info);
+    return common_hal_ipaddress_new_ipv4address(ip_info.ip.addr);
+}
+
+mp_int_t common_hal_wifi_radio_ping(wifi_radio_obj_t *self, mp_obj_t ip_address, mp_float_t timeout) {
+    esp_ping_config_t ping_config = ESP_PING_DEFAULT_CONFIG();
+    ipaddress_ipaddress_to_esp_idf(ip_address, &ping_config.target_addr);
+    ping_config.count = 1;
+
+    size_t timeout_ms = timeout * 1000;
+
+    esp_ping_handle_t ping;
+    esp_ping_new_session(&ping_config, NULL, &ping);
+    esp_ping_start(ping);
+
+    uint32_t received = 0;
+    uint32_t total_time_ms = 0;
+    while (received == 0 && total_time_ms < timeout_ms && !mp_hal_is_interrupted()) {
+        RUN_BACKGROUND_TASKS;
+        esp_ping_get_profile(ping, ESP_PING_PROF_DURATION, &total_time_ms, sizeof(total_time_ms));
+        esp_ping_get_profile(ping, ESP_PING_PROF_REPLY, &received, sizeof(received));
+    }
+    uint32_t elapsed_time = 0xffffffff;
+    if (received > 0) {
+        esp_ping_get_profile(ping, ESP_PING_PROF_TIMEGAP, &elapsed_time, sizeof(elapsed_time));
+    }
+    esp_ping_delete_session(ping);
+
+    return elapsed_time;
+}
diff --git a/ports/esp32s2/common-hal/wifi/Radio.h b/ports/esp32s2/common-hal/wifi/Radio.h
new file mode 100644
index 000000000..205aef176
--- /dev/null
+++ b/ports/esp32s2/common-hal/wifi/Radio.h
@@ -0,0 +1,58 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_ESP32S2_COMMON_HAL_WIFI_RADIO_H
+#define MICROPY_INCLUDED_ESP32S2_COMMON_HAL_WIFI_RADIO_H
+
+#include "py/obj.h"
+
+#include "esp-idf/components/esp_event/include/esp_event.h"
+
+#include "shared-bindings/wifi/ScannedNetworks.h"
+
+// Event bits for the Radio event group.
+#define WIFI_SCAN_DONE_BIT BIT0
+#define WIFI_CONNECTED_BIT BIT1
+#define WIFI_DISCONNECTED_BIT BIT2
+
+typedef struct {
+    mp_obj_base_t base;
+    esp_event_handler_instance_t handler_instance_all_wifi;
+    esp_event_handler_instance_t handler_instance_got_ip;
+    wifi_scannednetworks_obj_t *current_scan;
+    StaticEventGroup_t event_group;
+    EventGroupHandle_t event_group_handle;
+    wifi_config_t sta_config;
+    esp_netif_t *netif;
+    bool started;
+    bool ap_mode;
+    bool sta_mode;
+    uint8_t retries_left;
+    uint8_t starting_retries;
+    uint8_t last_disconnect_reason;
+} wifi_radio_obj_t;
+
+#endif // MICROPY_INCLUDED_ESP32S2_COMMON_HAL_WIFI_RADIO_H
diff --git a/ports/esp32s2/common-hal/wifi/ScannedNetworks.c b/ports/esp32s2/common-hal/wifi/ScannedNetworks.c
new file mode 100644
index 000000000..507c6d186
--- /dev/null
+++ b/ports/esp32s2/common-hal/wifi/ScannedNetworks.c
@@ -0,0 +1,172 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Dan Halbert for Adafruit Industries
+ * Copyright (c) 2018 Artur Pacholec
+ * Copyright (c) 2017 Glenn Ruben Bakke
+ *
+ * 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 <string.h>
+
+#include "lib/utils/interrupt_char.h"
+#include "py/gc.h"
+#include "py/objstr.h"
+#include "py/runtime.h"
+#include "shared-bindings/wifi/__init__.h"
+#include "shared-bindings/wifi/Network.h"
+#include "shared-bindings/wifi/Radio.h"
+#include "shared-bindings/wifi/ScannedNetworks.h"
+
+#include "esp-idf/components/esp_wifi/include/esp_wifi.h"
+
+static void wifi_scannednetworks_done(wifi_scannednetworks_obj_t *self) {
+    self->done = true;
+    if (self->results != NULL) {
+        // Check to see if the heap is still active. If not, it'll be freed automatically.
+        if (gc_alloc_possible()) {
+            m_free(self->results);
+        }
+        self->results = NULL;
+    }
+}
+
+static bool wifi_scannednetworks_wait_for_scan(wifi_scannednetworks_obj_t *self) {
+    EventBits_t bits = xEventGroupWaitBits(self->radio_event_group,
+            WIFI_SCAN_DONE_BIT,
+            pdTRUE,
+            pdTRUE,
+            0);
+    while ((bits & WIFI_SCAN_DONE_BIT) == 0 && !mp_hal_is_interrupted()) {
+        RUN_BACKGROUND_TASKS;
+        bits = xEventGroupWaitBits(self->radio_event_group,
+            WIFI_SCAN_DONE_BIT,
+            pdTRUE,
+            pdTRUE,
+            0);
+    }
+    return !mp_hal_is_interrupted();
+}
+
+mp_obj_t common_hal_wifi_scannednetworks_next(wifi_scannednetworks_obj_t *self) {
+    if (self->done) {
+        return mp_const_none;
+    }
+    // If we are scanning, wait and then load them.
+    if (self->scanning) {
+        // We may have to scan more than one channel to get a result.
+        while (!self->done) {
+            if (!wifi_scannednetworks_wait_for_scan(self)) {
+                wifi_scannednetworks_done(self);
+                return mp_const_none;
+            }
+
+            esp_wifi_scan_get_ap_num(&self->total_results);
+            self->scanning = false;
+            if (self->total_results > 0) {
+                break;
+            }
+            // If total_results is zero then we need to start a scan and wait again.
+            wifi_scannednetworks_scan_next_channel(self);
+        }
+        // We not have found any more results so we're done.
+        if (self->done) {
+            return mp_const_none;
+        }
+        // If we need more space than we have, realloc.
+        if (self->total_results > self->max_results) {
+            wifi_ap_record_t* results = m_renew_maybe(wifi_ap_record_t,
+                                                      self->results,
+                                                      self->max_results,
+                                                      self->total_results,
+                                                      true /* allow move */);
+            if (results != NULL) {
+                self->results = results;
+                self->max_results = self->total_results;
+            } else {
+                if (self->max_results == 0) {
+                    // No room for any results should error.
+                    mp_raise_msg(&mp_type_MemoryError, translate("Failed to allocate wifi scan memory"));
+                }
+                // Unable to allocate more results, so load what we can.
+                self->total_results = self->max_results;
+            }
+        }
+        esp_wifi_scan_get_ap_records(&self->total_results, self->results);
+        self->scanning = false;
+    }
+
+    wifi_network_obj_t *entry = m_new_obj(wifi_network_obj_t);
+    entry->base.type = &wifi_network_type;
+    memcpy(&entry->record, &self->results[self->current_result], sizeof(wifi_ap_record_t));
+    self->current_result++;
+
+    // If we're returning our last network then start the next channel scan or
+    // be done.
+    if (self->current_result >= self->total_results) {
+        wifi_scannednetworks_scan_next_channel(self);
+        self->total_results = 0;
+        self->current_result = 0;
+    }
+
+    return MP_OBJ_FROM_PTR(entry);
+}
+
+// We don't do a linear scan so that we look at a variety of spectrum up front.
+static uint8_t scan_pattern[] = {6, 1, 11, 3, 9, 13, 2, 4, 8, 12, 5, 7, 10, 14};
+
+void wifi_scannednetworks_scan_next_channel(wifi_scannednetworks_obj_t *self) {
+    uint8_t next_channel = sizeof(scan_pattern);
+    while (self->current_channel_index < sizeof(scan_pattern)) {
+        next_channel = scan_pattern[self->current_channel_index];
+        self->current_channel_index++;
+        if (self->start_channel <= next_channel && next_channel <= self->end_channel) {
+            break;
+        }
+    }
+    wifi_scan_config_t config = { 0 };
+    config.channel = next_channel;
+    if (next_channel == sizeof(scan_pattern)) {
+        wifi_scannednetworks_done(self);
+    } else {
+        esp_err_t result = esp_wifi_scan_start(&config, false);
+        if (result != ESP_OK) {
+            wifi_scannednetworks_done(self);
+        } else {
+            self->scanning = true;
+        }
+    }
+}
+
+void wifi_scannednetworks_deinit(wifi_scannednetworks_obj_t* self) {
+    // if a scan is active, make sure and clean up the idf's buffer of results.
+    if (self->scanning) {
+        esp_wifi_scan_stop();
+        if (wifi_scannednetworks_wait_for_scan(self)) {
+            // Ignore the number of records since we're throwing them away.
+            uint16_t number = 0;
+            esp_wifi_scan_get_ap_records(&number, NULL);
+            self->scanning = false;
+        }
+    }
+    wifi_scannednetworks_done(self);
+}
diff --git a/ports/esp32s2/common-hal/wifi/ScannedNetworks.h b/ports/esp32s2/common-hal/wifi/ScannedNetworks.h
new file mode 100644
index 000000000..cd57e95f2
--- /dev/null
+++ b/ports/esp32s2/common-hal/wifi/ScannedNetworks.h
@@ -0,0 +1,62 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Dan Halbert for Adafruit Industries
+ * Copyright (c) 2018 Artur Pacholec
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_ESP32S2_COMMON_HAL_WIFI_SCANNEDNETWORKS_H
+#define MICROPY_INCLUDED_ESP32S2_COMMON_HAL_WIFI_SCANNEDNETWORKS_H
+
+#include <stdint.h>
+
+#include "py/obj.h"
+
+#include "FreeRTOS.h"
+#include "freertos/event_groups.h"
+
+#include "esp-idf/components/esp_wifi/include/esp_wifi_types.h"
+
+typedef struct {
+    mp_obj_base_t base;
+    uint8_t current_channel_index;
+    EventGroupHandle_t radio_event_group;
+
+    // Results from the last channel scan
+    wifi_ap_record_t* results;
+    uint16_t current_result;
+    uint16_t total_results;
+    uint16_t max_results;
+
+    // Limits on what channels to scan.
+    uint8_t start_channel;
+    uint8_t end_channel; // Inclusive
+
+    bool done;
+    bool scanning;
+} wifi_scannednetworks_obj_t;
+
+void wifi_scannednetworks_scan_next_channel(wifi_scannednetworks_obj_t *self);
+void wifi_scannednetworks_deinit(wifi_scannednetworks_obj_t *self);
+
+#endif // MICROPY_INCLUDED_ESP32S2_COMMON_HAL_WIFI_SCANNEDNETWORKS_H
diff --git a/ports/esp32s2/common-hal/wifi/__init__.c b/ports/esp32s2/common-hal/wifi/__init__.c
new file mode 100644
index 000000000..b9ea9da06
--- /dev/null
+++ b/ports/esp32s2/common-hal/wifi/__init__.c
@@ -0,0 +1,151 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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 "common-hal/wifi/__init__.h"
+
+#include "shared-bindings/ipaddress/IPv4Address.h"
+#include "shared-bindings/wifi/Radio.h"
+
+#include "py/runtime.h"
+
+#include "esp-idf/components/esp_wifi/include/esp_wifi.h"
+
+#include "esp-idf/components/heap/include/esp_heap_caps.h"
+
+wifi_radio_obj_t common_hal_wifi_radio_obj;
+
+#include "esp_log.h"
+static const char* TAG = "wifi";
+
+static void event_handler(void* arg, esp_event_base_t event_base,
+                          int32_t event_id, void* event_data) {
+    wifi_radio_obj_t* radio = arg;
+    if (event_base == WIFI_EVENT) {
+        switch (event_id) {
+            case WIFI_EVENT_SCAN_DONE:
+                xEventGroupSetBits(radio->event_group_handle, WIFI_SCAN_DONE_BIT);
+                break;
+            case WIFI_EVENT_STA_CONNECTED:
+                ESP_EARLY_LOGW(TAG, "connected");
+                break;
+            case WIFI_EVENT_STA_DISCONNECTED: {
+                ESP_EARLY_LOGW(TAG, "disconnected");
+                wifi_event_sta_disconnected_t* d = (wifi_event_sta_disconnected_t*) event_data;
+                uint8_t reason = d->reason;
+                ESP_EARLY_LOGW(TAG, "reason %d 0x%02x", reason, reason);
+                if (radio->retries_left > 0 &&
+                        (reason == WIFI_REASON_AUTH_EXPIRE ||
+                         reason == WIFI_REASON_ASSOC_EXPIRE ||
+                         reason == WIFI_REASON_CONNECTION_FAIL ||
+                         reason == WIFI_REASON_4WAY_HANDSHAKE_TIMEOUT)) {
+                    radio->retries_left--;
+                    ESP_EARLY_LOGI(TAG, "Retrying connect. %d retries remaining", radio->retries_left);
+                    esp_wifi_connect();
+                    return;
+                }
+
+                radio->last_disconnect_reason = reason;
+                xEventGroupSetBits(radio->event_group_handle, WIFI_DISCONNECTED_BIT);
+            }
+
+            // Cases to handle later.
+            // case WIFI_EVENT_STA_START:
+            // case WIFI_EVENT_STA_STOP:
+            // case WIFI_EVENT_STA_AUTHMODE_CHANGE:
+            default:
+                break;
+        }
+    }
+
+    if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
+        ESP_EARLY_LOGW(TAG, "got ip");
+        radio->retries_left = radio->starting_retries;
+        xEventGroupSetBits(radio->event_group_handle, WIFI_CONNECTED_BIT);
+    }
+}
+
+static bool wifi_inited;
+
+void common_hal_wifi_init(void) {
+    wifi_inited = true;
+    common_hal_wifi_radio_obj.base.type = &wifi_radio_type;
+
+    ESP_ERROR_CHECK(esp_netif_init());
+    ESP_ERROR_CHECK(esp_event_loop_create_default());
+
+    wifi_radio_obj_t* self = &common_hal_wifi_radio_obj;
+    self->netif = esp_netif_create_default_wifi_sta();
+
+    self->event_group_handle = xEventGroupCreateStatic(&self->event_group);
+    ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT,
+                                                        ESP_EVENT_ANY_ID,
+                                                        &event_handler,
+                                                        self,
+                                                        &self->handler_instance_all_wifi));
+    ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT,
+                                                        IP_EVENT_STA_GOT_IP,
+                                                        &event_handler,
+                                                        self,
+                                                        &self->handler_instance_got_ip));
+
+    wifi_init_config_t config = WIFI_INIT_CONFIG_DEFAULT();
+    esp_err_t result = esp_wifi_init(&config);
+    if (result == ESP_ERR_NO_MEM) {
+        mp_raise_msg(&mp_type_MemoryError, translate("Failed to allocate Wifi memory"));
+    } else if (result != ESP_OK) {
+        mp_raise_RuntimeError(translate("Failed to init wifi"));
+    }
+    common_hal_wifi_radio_set_enabled(self, true);
+}
+
+void wifi_reset(void) {
+    if (!wifi_inited) {
+        return;
+    }
+    wifi_radio_obj_t* radio = &common_hal_wifi_radio_obj;
+    common_hal_wifi_radio_set_enabled(radio, false);
+    ESP_ERROR_CHECK(esp_event_handler_instance_unregister(WIFI_EVENT,
+                                                          ESP_EVENT_ANY_ID,
+                                                          radio->handler_instance_all_wifi));
+    ESP_ERROR_CHECK(esp_event_handler_instance_unregister(IP_EVENT,
+                                                          IP_EVENT_STA_GOT_IP,
+                                                          radio->handler_instance_got_ip));
+    ESP_ERROR_CHECK(esp_wifi_deinit());
+    esp_netif_destroy(radio->netif);
+    radio->netif = NULL;
+    ESP_ERROR_CHECK(esp_netif_deinit());
+}
+
+void ipaddress_ipaddress_to_esp_idf(mp_obj_t ip_address, ip_addr_t* esp_ip_address) {
+    if (!MP_OBJ_IS_TYPE(ip_address, &ipaddress_ipv4address_type)) {
+        mp_raise_ValueError(translate("Only IPv4 addresses supported"));
+    }
+    mp_obj_t packed = common_hal_ipaddress_ipv4address_get_packed(ip_address);
+    size_t len;
+    const char* bytes = mp_obj_str_get_data(packed, &len);
+
+    IP_ADDR4(esp_ip_address, bytes[0], bytes[1], bytes[2], bytes[3]);
+}
diff --git a/ports/esp32s2/common-hal/wifi/__init__.h b/ports/esp32s2/common-hal/wifi/__init__.h
new file mode 100644
index 000000000..d2bd06c57
--- /dev/null
+++ b/ports/esp32s2/common-hal/wifi/__init__.h
@@ -0,0 +1,38 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_ESP32S2_COMMON_HAL_WIFI___INIT___H
+#define MICROPY_INCLUDED_ESP32S2_COMMON_HAL_WIFI___INIT___H
+
+#include "py/obj.h"
+
+#include "lwip/api.h"
+
+void wifi_reset(void);
+
+void ipaddress_ipaddress_to_esp_idf(mp_obj_t ip_address, ip_addr_t* esp_ip_address);
+
+#endif // MICROPY_INCLUDED_ESP32S2_COMMON_HAL_WIFI___INIT___H
diff --git a/ports/esp32s2/esp-idf b/ports/esp32s2/esp-idf
-Subproject 160ba4924d8b588e718f76e3a0d0e92c11052fa
+Subproject de733cdab556c5713c94ba95078f4024dd56fd8
diff --git a/ports/esp32s2/mpconfigport.h b/ports/esp32s2/mpconfigport.h
index 07f83434a..c06e63439 100644
--- a/ports/esp32s2/mpconfigport.h
+++ b/ports/esp32s2/mpconfigport.h
@@ -28,18 +28,19 @@
 #ifndef ESP32S2_MPCONFIGPORT_H__
 #define ESP32S2_MPCONFIGPORT_H__
 
-#define CIRCUITPY_INTERNAL_NVM_SIZE     (0)
-#define MICROPY_NLR_THUMB               (0)
+#define CIRCUITPY_INTERNAL_NVM_SIZE         (0)
+#define MICROPY_NLR_THUMB                   (0)
 
-#define MICROPY_PY_UJSON                (0)
-#define MICROPY_USE_INTERNAL_PRINTF     (0)
+#define MICROPY_PY_UJSON                 (1)
+#define MICROPY_USE_INTERNAL_PRINTF      (0)
 
 #include "py/circuitpy_mpconfig.h"
 
+
 #define MICROPY_PORT_ROOT_POINTERS \
 	CIRCUITPY_COMMON_ROOT_POINTERS
-#define MICROPY_NLR_SETJMP              (1)
-#define CIRCUITPY_DEFAULT_STACK_SIZE    (0x6000)
+#define MICROPY_NLR_SETJMP                  (1)
+#define CIRCUITPY_DEFAULT_STACK_SIZE        0x6000
 
 
 #endif  // __INCLUDED_ESP32S2_MPCONFIGPORT_H
diff --git a/ports/esp32s2/mpconfigport.mk b/ports/esp32s2/mpconfigport.mk
index d13eb17f7..ee98ce1f4 100644
--- a/ports/esp32s2/mpconfigport.mk
+++ b/ports/esp32s2/mpconfigport.mk
@@ -13,21 +13,19 @@ USB_SERIAL_NUMBER_LENGTH = 12
 LONGINT_IMPL = MPZ
 
 # These modules are implemented in ports/<port>/common-hal:
+CIRCUITPY_FULL_BUILD = 1
 CIRCUITPY_ANALOGIO = 0
-CIRCUITPY_NVM = 0
 CIRCUITPY_AUDIOBUSIO = 0
 CIRCUITPY_AUDIOIO = 0
-CIRCUITPY_ROTARYIO = 0
-CIRCUITPY_RTC = 0
+CIRCUITPY_COUNTIO = 0
 CIRCUITPY_FREQUENCYIO = 0
 CIRCUITPY_I2CPERIPHERAL = 0
-CIRCUITPY_COUNTIO = 0
-
-# These modules are implemented in shared-module/ - they can be included in
-# any port once their prerequisites in common-hal are complete.
-# Requires USB
+CIRCUITPY_ROTARYIO = 0
+CIRCUITPY_RTC = 0
+CIRCUITPY_NVM = 0
+# We don't have enough endpoints to include MIDI.
 CIRCUITPY_USB_MIDI = 0
-# Too large for the partition table!
-CIRCUITPY_ULAB = 0
+CIRCUITPY_WIFI = 1
+CIRCUITPY_ESPIDF = 1
 
 CIRCUITPY_MODULE ?= none
diff --git a/ports/esp32s2/partitions.csv b/ports/esp32s2/partitions.csv
index 47fb295e5..cf9b3cca8 100644
--- a/ports/esp32s2/partitions.csv
+++ b/ports/esp32s2/partitions.csv
@@ -1,10 +1,10 @@
 # ESP-IDF Partition Table
 # Name,   Type, SubType, Offset,  Size, Flags
-# bootloader.bin         0x1000
-# partition table        0x8000, 0xC00
-otadata,  data, ota,     0xd000,  0x2000,
-ota_0,    0,    ota_0,  0x10000, 512K,
-ota_1,    0,    ota_1,  0x90000, 512K,
-phy_init, data, phy,   0x110000,  0x1000,
-nvs,      data, nvs,   0x111000,  0x6000,
-user_fs,  data, fat,   0x200000,  2M,
+# bootloader.bin,,          0x1000, 32K
+# partition table,,         0x8000, 4K
+nvs,      data, nvs,      0x9000,  20K,
+otadata,  data, ota,      0xe000,  8K,
+ota_0,    0,    ota_0,   0x10000,  1408K,
+ota_1,    0,    ota_1,  0x170000,  1408K,
+uf2,      app,  factory,0x2d0000,  256K,
+user_fs,  data, fat,    0x310000,  960K,
diff --git a/ports/esp32s2/sdkconfig.defaults b/ports/esp32s2/sdkconfig.defaults
index 729ebac88..c0a56c143 100644
--- a/ports/esp32s2/sdkconfig.defaults
+++ b/ports/esp32s2/sdkconfig.defaults
@@ -37,6 +37,7 @@ CONFIG_APP_RETRIEVE_LEN_ELF_SHA=16
 #
 # Bootloader config
 #
+CONFIG_BOOTLOADER_OFFSET_IN_FLASH=0x1000
 CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_SIZE=y
 # CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_DEBUG is not set
 # CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_PERF is not set
@@ -64,15 +65,19 @@ CONFIG_BOOTLOADER_RESERVE_RTC_SIZE=0
 #
 # Security features
 #
+CONFIG_SECURE_TARGET_HAS_SECURE_ROM_DL_MODE=y
 # CONFIG_SECURE_SIGNED_APPS_NO_SECURE_BOOT is not set
 # CONFIG_SECURE_BOOT is not set
 # CONFIG_SECURE_FLASH_ENC_ENABLED is not set
+# CONFIG_SECURE_DISABLE_ROM_DL_MODE is not set
+# CONFIG_SECURE_ENABLE_SECURE_ROM_DL_MODE is not set
 # end of Security features
 
 #
 # Serial flasher config
 #
 CONFIG_ESPTOOLPY_BAUD_OTHER_VAL=115200
+CONFIG_ESPTOOLPY_WITH_STUB=y
 # CONFIG_ESPTOOLPY_FLASHMODE_QIO is not set
 # CONFIG_ESPTOOLPY_FLASHMODE_QOUT is not set
 CONFIG_ESPTOOLPY_FLASHMODE_DIO=y
@@ -96,6 +101,7 @@ CONFIG_ESPTOOLPY_BEFORE="default_reset"
 CONFIG_ESPTOOLPY_AFTER_RESET=y
 # CONFIG_ESPTOOLPY_AFTER_NORESET is not set
 CONFIG_ESPTOOLPY_AFTER="hard_reset"
+# CONFIG_ESPTOOLPY_MONITOR_BAUD_CONSOLE is not set
 # CONFIG_ESPTOOLPY_MONITOR_BAUD_9600B is not set
 # CONFIG_ESPTOOLPY_MONITOR_BAUD_57600B is not set
 CONFIG_ESPTOOLPY_MONITOR_BAUD_115200B=y
@@ -122,8 +128,8 @@ CONFIG_PARTITION_TABLE_MD5=y
 #
 # Compiler options
 #
-CONFIG_COMPILER_OPTIMIZATION_DEFAULT=y
-# CONFIG_COMPILER_OPTIMIZATION_SIZE is not set
+# CONFIG_COMPILER_OPTIMIZATION_DEFAULT is not set
+CONFIG_COMPILER_OPTIMIZATION_SIZE=y
 # CONFIG_COMPILER_OPTIMIZATION_PERF is not set
 # CONFIG_COMPILER_OPTIMIZATION_NONE is not set
 # CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_ENABLE is not set
@@ -187,6 +193,14 @@ CONFIG_EFUSE_MAX_BLK_LEN=256
 # end of eFuse Bit Manager
 
 #
+# ESP-TLS
+#
+CONFIG_ESP_TLS_USING_MBEDTLS=y
+CONFIG_ESP_TLS_SERVER=y
+# CONFIG_ESP_TLS_PSK_VERIFICATION is not set
+# end of ESP-TLS
+
+#
 # ESP32S2-specific
 #
 # CONFIG_ESP32S2_DEFAULT_CPU_FREQ_80 is not set
@@ -245,6 +259,10 @@ CONFIG_ESP32S2_RTC_CLK_SRC_INT_RC=y
 # CONFIG_ESP32S2_RTC_CLK_SRC_INT_8MD256 is not set
 CONFIG_ESP32S2_RTC_CLK_CAL_CYCLES=576
 # CONFIG_ESP32S2_NO_BLOBS is not set
+# CONFIG_ESP32S2_KEEP_USB_ALIVE is not set
+# CONFIG_ESP32S2_RTCDATA_IN_FAST_MEM is not set
+# CONFIG_ESP32S2_USE_FIXED_STATIC_RAM_SIZE is not set
+CONFIG_ESP32S2_ALLOW_RTC_FAST_MEM_AS_HEAP=y
 # end of ESP32S2-specific
 
 #
@@ -263,15 +281,16 @@ CONFIG_ESP_MAIN_TASK_STACK_SIZE=8192
 CONFIG_ESP_IPC_TASK_STACK_SIZE=1024
 CONFIG_ESP_MINIMAL_SHARED_STACK_SIZE=2048
 CONFIG_ESP_CONSOLE_UART_DEFAULT=y
+# CONFIG_ESP_CONSOLE_USB_CDC is not set
 # CONFIG_ESP_CONSOLE_UART_CUSTOM is not set
-# CONFIG_ESP_CONSOLE_UART_NONE is not set
+# CONFIG_ESP_CONSOLE_NONE is not set
+CONFIG_ESP_CONSOLE_UART=y
 CONFIG_ESP_CONSOLE_UART_NUM=0
-CONFIG_ESP_CONSOLE_UART_TX_GPIO=1
-CONFIG_ESP_CONSOLE_UART_RX_GPIO=3
 CONFIG_ESP_CONSOLE_UART_BAUDRATE=115200
 CONFIG_ESP_INT_WDT=y
 CONFIG_ESP_INT_WDT_TIMEOUT_MS=300
 # CONFIG_ESP_TASK_WDT is not set
+# CONFIG_ESP_PANIC_HANDLER_IRAM is not set
 CONFIG_ESP_MAC_ADDR_UNIVERSE_WIFI_STA=y
 CONFIG_ESP_MAC_ADDR_UNIVERSE_WIFI_AP=y
 # end of Common ESP-related
@@ -279,9 +298,7 @@ CONFIG_ESP_MAC_ADDR_UNIVERSE_WIFI_AP=y
 #
 # Ethernet
 #
-CONFIG_ETH_ENABLED=y
-CONFIG_ETH_USE_SPI_ETHERNET=y
-# CONFIG_ETH_SPI_ETHERNET_DM9051 is not set
+# CONFIG_ETH_USE_SPI_ETHERNET is not set
 # CONFIG_ETH_USE_OPENETH is not set
 # end of Ethernet
 
@@ -299,7 +316,7 @@ CONFIG_ESP_EVENT_POST_FROM_IRAM_ISR=y
 CONFIG_ESP_NETIF_IP_LOST_TIMER_INTERVAL=120
 CONFIG_ESP_NETIF_TCPIP_LWIP=y
 # CONFIG_ESP_NETIF_LOOPBACK is not set
-CONFIG_ESP_NETIF_TCPIP_ADAPTER_COMPATIBLE_LAYER=y
+# CONFIG_ESP_NETIF_TCPIP_ADAPTER_COMPATIBLE_LAYER is not set
 # end of ESP NETIF Adapter
 
 #
@@ -309,6 +326,7 @@ CONFIG_ESP_SYSTEM_PANIC_PRINT_HALT=y
 # CONFIG_ESP_SYSTEM_PANIC_PRINT_REBOOT is not set
 # CONFIG_ESP_SYSTEM_PANIC_SILENT_REBOOT is not set
 # CONFIG_ESP_SYSTEM_PANIC_GDBSTUB is not set
+CONFIG_ESP_SYSTEM_SINGLE_CORE_MODE=y
 # end of ESP System Settings
 
 #
@@ -333,7 +351,7 @@ CONFIG_ESP32_WIFI_AMPDU_TX_ENABLED=y
 CONFIG_ESP32_WIFI_TX_BA_WIN=6
 CONFIG_ESP32_WIFI_AMPDU_RX_ENABLED=y
 CONFIG_ESP32_WIFI_RX_BA_WIN=6
-CONFIG_ESP32_WIFI_NVS_ENABLED=y
+# CONFIG_ESP32_WIFI_NVS_ENABLED is not set
 CONFIG_ESP32_WIFI_SOFTAP_BEACON_MAX_LEN=752
 CONFIG_ESP32_WIFI_MGMT_SBUF_NUM=32
 # CONFIG_ESP32_WIFI_DEBUG_LOG_ENABLE is not set
@@ -389,7 +407,6 @@ CONFIG_FREERTOS_TIMER_QUEUE_LENGTH=10
 CONFIG_FREERTOS_QUEUE_REGISTRY_SIZE=0
 # CONFIG_FREERTOS_USE_TRACE_FACILITY is not set
 # CONFIG_FREERTOS_GENERATE_RUN_TIME_STATS is not set
-CONFIG_FREERTOS_TASK_FUNCTION_WRAPPER=y
 CONFIG_FREERTOS_CHECK_MUTEX_GIVEN_BY_OWNER=y
 # CONFIG_FREERTOS_CHECK_PORT_CRITICAL_COMPLIANCE is not set
 CONFIG_FREERTOS_DEBUG_OCDAWARE=y
@@ -432,12 +449,15 @@ CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES=y
 CONFIG_LWIP_TIMERS_ONDEMAND=y
 CONFIG_LWIP_MAX_SOCKETS=10
 # CONFIG_LWIP_USE_ONLY_LWIP_SELECT is not set
+# CONFIG_LWIP_SO_LINGER is not set
 CONFIG_LWIP_SO_REUSE=y
 CONFIG_LWIP_SO_REUSE_RXTOALL=y
-# CONFIG_LWIP_SO_RCVBUF is not set
+CONFIG_LWIP_SO_RCVBUF=y
 # CONFIG_LWIP_NETBUF_RECVINFO is not set
-CONFIG_LWIP_IP_FRAG=y
-# CONFIG_LWIP_IP_REASSEMBLY is not set
+CONFIG_LWIP_IP4_FRAG=y
+CONFIG_LWIP_IP6_FRAG=y
+# CONFIG_LWIP_IP4_REASSEMBLY is not set
+# CONFIG_LWIP_IP6_REASSEMBLY is not set
 # CONFIG_LWIP_IP_FORWARD is not set
 # CONFIG_LWIP_STATS is not set
 # CONFIG_LWIP_ETHARP_TRUST_IP_MAC is not set
@@ -478,6 +498,7 @@ CONFIG_LWIP_TCP_QUEUE_OOSEQ=y
 CONFIG_LWIP_TCP_OVERSIZE_MSS=y
 # CONFIG_LWIP_TCP_OVERSIZE_QUARTER_MSS is not set
 # CONFIG_LWIP_TCP_OVERSIZE_DISABLE is not set
+CONFIG_LWIP_TCP_RTO_TIME=3000
 # end of TCP
 
 #
@@ -492,6 +513,7 @@ CONFIG_LWIP_TCPIP_TASK_AFFINITY_NO_AFFINITY=y
 # CONFIG_LWIP_TCPIP_TASK_AFFINITY_CPU0 is not set
 CONFIG_LWIP_TCPIP_TASK_AFFINITY=0x7FFFFFFF
 # CONFIG_LWIP_PPP_SUPPORT is not set
+# CONFIG_LWIP_SLIP_SUPPORT is not set
 
 #
 # ICMP
@@ -514,6 +536,20 @@ CONFIG_LWIP_SNTP_UPDATE_DELAY=3600000
 # end of SNTP
 
 CONFIG_LWIP_ESP_LWIP_ASSERT=y
+
+#
+# Debug
+#
+# CONFIG_LWIP_NETIF_DEBUG is not set
+# CONFIG_LWIP_PBUF_DEBUG is not set
+# CONFIG_LWIP_ETHARP_DEBUG is not set
+# CONFIG_LWIP_API_LIB_DEBUG is not set
+# CONFIG_LWIP_SOCKETS_DEBUG is not set
+# CONFIG_LWIP_IP_DEBUG is not set
+# CONFIG_LWIP_ICMP_DEBUG is not set
+# CONFIG_LWIP_IP6_DEBUG is not set
+# CONFIG_LWIP_ICMP6_DEBUG is not set
+# end of Debug
 # end of LWIP
 
 #
@@ -578,8 +614,8 @@ CONFIG_MBEDTLS_KEY_EXCHANGE_ECDH_RSA=y
 
 CONFIG_MBEDTLS_SSL_RENEGOTIATION=y
 # CONFIG_MBEDTLS_SSL_PROTO_SSL3 is not set
-CONFIG_MBEDTLS_SSL_PROTO_TLS1=y
-CONFIG_MBEDTLS_SSL_PROTO_TLS1_1=y
+# CONFIG_MBEDTLS_SSL_PROTO_TLS1 is not set
+# CONFIG_MBEDTLS_SSL_PROTO_TLS1_1 is not set
 CONFIG_MBEDTLS_SSL_PROTO_TLS1_2=y
 CONFIG_MBEDTLS_SSL_PROTO_DTLS=y
 CONFIG_MBEDTLS_SSL_ALPN=y
@@ -677,6 +713,7 @@ CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y
 CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y
 CONFIG_SPI_FLASH_ERASE_YIELD_DURATION_MS=20
 CONFIG_SPI_FLASH_ERASE_YIELD_TICKS=1
+CONFIG_SPI_FLASH_WRITE_CHUNK_SIZE=8192
 
 #
 # Auto-detect flash chips
@@ -710,7 +747,6 @@ CONFIG_VFS_SEMIHOSTFS_HOST_PATH_MAX_LEN=128
 CONFIG_WPA_MBEDTLS_CRYPTO=y
 # CONFIG_WPA_DEBUG_PRINT is not set
 # CONFIG_WPA_TESTING_OPTIONS is not set
-# CONFIG_WPA_TLS_V12 is not set
 # CONFIG_WPA_WPS_WARS is not set
 # end of Supplicant
 # end of Component config
@@ -745,8 +781,8 @@ CONFIG_MONITOR_BAUD_115200B=y
 # CONFIG_MONITOR_BAUD_OTHER is not set
 CONFIG_MONITOR_BAUD_OTHER_VAL=115200
 CONFIG_MONITOR_BAUD=115200
-CONFIG_COMPILER_OPTIMIZATION_LEVEL_DEBUG=y
-# CONFIG_COMPILER_OPTIMIZATION_LEVEL_RELEASE is not set
+# CONFIG_COMPILER_OPTIMIZATION_LEVEL_DEBUG is not set
+CONFIG_COMPILER_OPTIMIZATION_LEVEL_RELEASE=y
 # CONFIG_OPTIMIZATION_ASSERTIONS_ENABLED is not set
 CONFIG_OPTIMIZATION_ASSERTIONS_SILENT=y
 # CONFIG_OPTIMIZATION_ASSERTIONS_DISABLED is not set
@@ -767,10 +803,9 @@ CONFIG_MAIN_TASK_STACK_SIZE=8192
 CONFIG_IPC_TASK_STACK_SIZE=1024
 CONFIG_CONSOLE_UART_DEFAULT=y
 # CONFIG_CONSOLE_UART_CUSTOM is not set
-# CONFIG_CONSOLE_UART_NONE is not set
+# CONFIG_ESP_CONSOLE_UART_NONE is not set
+CONFIG_CONSOLE_UART=y
 CONFIG_CONSOLE_UART_NUM=0
-CONFIG_CONSOLE_UART_TX_GPIO=1
-CONFIG_CONSOLE_UART_RX_GPIO=3
 CONFIG_CONSOLE_UART_BAUDRATE=115200
 CONFIG_INT_WDT=y
 CONFIG_INT_WDT_TIMEOUT_MS=300
diff --git a/ports/esp32s2/supervisor/port.c b/ports/esp32s2/supervisor/port.c
index 1300c2b71..e52b7f376 100644
--- a/ports/esp32s2/supervisor/port.c
+++ b/ports/esp32s2/supervisor/port.c
@@ -40,6 +40,7 @@
 #include "common-hal/busio/UART.h"
 #include "common-hal/pulseio/PulseIn.h"
 #include "common-hal/pwmio/PWMOut.h"
+#include "common-hal/wifi/__init__.h"
 #include "supervisor/memory.h"
 #include "supervisor/shared/tick.h"
 
@@ -65,6 +66,8 @@ safe_mode_t port_init(void) {
     args.dispatch_method = ESP_TIMER_TASK;
     args.name = "CircuitPython Tick";
     esp_timer_create(&args, &_tick_timer);
+
+    heap = NULL;
     never_reset_module_internal_pins();
 
     #ifdef CONFIG_SPIRAM
@@ -76,6 +79,10 @@ safe_mode_t port_init(void) {
         heap = malloc(HEAP_SIZE);
         heap_size = HEAP_SIZE / sizeof(uint32_t);
     }
+    if (heap == NULL) {
+        return NO_HEAP;
+    }
+
     return NO_SAFE_MODE;
 }
 
@@ -99,6 +106,9 @@ void reset_port(void) {
     spi_reset();
     uart_reset();
 #endif
+#if CIRCUITPY_WIFI
+    wifi_reset();
+#endif
 }
 
 void reset_to_bootloader(void) {
diff --git a/ports/stm/boards/espruino_pico/mpconfigboard.mk b/ports/stm/boards/espruino_pico/mpconfigboard.mk
index b1b023dd5..556ff35c4 100644
--- a/ports/stm/boards/espruino_pico/mpconfigboard.mk
+++ b/ports/stm/boards/espruino_pico/mpconfigboard.mk
@@ -9,6 +9,8 @@ MCU_SERIES = F4
 MCU_VARIANT = STM32F401xE
 MCU_PACKAGE = UFQFPN48
 
+OPTIMIZATION_FLAGS = -Os
+
 LD_COMMON = boards/common_default.ld
 # use for internal flash
 LD_FILE = boards/STM32F401xd_fs.ld
diff --git a/py/circuitpy_defns.mk b/py/circuitpy_defns.mk
index 36524b2fb..04e38d81e 100644
--- a/py/circuitpy_defns.mk
+++ b/py/circuitpy_defns.mk
@@ -168,6 +168,9 @@ endif
 ifeq ($(CIRCUITPY_I2CPERIPHERAL),1)
 SRC_PATTERNS += i2cperipheral/%
 endif
+ifeq ($(CIRCUITPY_IPADDRESS),1)
+SRC_PATTERNS += ipaddress/%
+endif
 ifeq ($(CIRCUITPY_MATH),1)
 SRC_PATTERNS += math/%
 endif
@@ -228,6 +231,12 @@ endif
 ifeq ($(CIRCUITPY_SHARPDISPLAY),1)
 SRC_PATTERNS += sharpdisplay/%
 endif
+ifeq ($(CIRCUITPY_SOCKETPOOL),1)
+SRC_PATTERNS += socketpool/%
+endif
+ifeq ($(CIRCUITPY_SSL),1)
+SRC_PATTERNS += ssl/%
+endif
 ifeq ($(CIRCUITPY_STAGE),1)
 SRC_PATTERNS += _stage/%
 endif
@@ -264,6 +273,9 @@ endif
 ifeq ($(CIRCUITPY_WATCHDOG),1)
 SRC_PATTERNS += watchdog/%
 endif
+ifeq ($(CIRCUITPY_WIFI),1)
+SRC_PATTERNS += wifi/%
+endif
 ifeq ($(CIRCUITPY_PEW),1)
 SRC_PATTERNS += _pew/%
 endif
@@ -332,11 +344,20 @@ SRC_COMMON_HAL_ALL = \
 	rtc/__init__.c \
 	sdioio/SDCard.c \
 	sdioio/__init__.c \
+	socketpool/__init__.c \
+	socketpool/SocketPool.c \
+	socketpool/Socket.c \
+	ssl/__init__.c \
+	ssl/SSLContext.c \
 	supervisor/Runtime.c \
 	supervisor/__init__.c \
 	watchdog/WatchDogMode.c \
 	watchdog/WatchDogTimer.c \
 	watchdog/__init__.c \
+	wifi/Network.c \
+	wifi/Radio.c \
+	wifi/ScannedNetworks.c \
+	wifi/__init__.c \
 
 ifeq ($(CIRCUITPY_BLEIO_HCI),1)
 # Helper code for _bleio HCI.
@@ -414,6 +435,8 @@ SRC_SHARED_MODULE_ALL = \
 	fontio/__init__.c \
 	framebufferio/FramebufferDisplay.c \
 	framebufferio/__init__.c \
+	ipaddress/IPv4Address.c \
+	ipaddress/__init__.c \
 	sdcardio/SDCard.c \
 	sdcardio/__init__.c \
 	gamepad/GamePad.c \
diff --git a/py/circuitpy_mpconfig.h b/py/circuitpy_mpconfig.h
index d144f0ba8..0fafbe876 100644
--- a/py/circuitpy_mpconfig.h
+++ b/py/circuitpy_mpconfig.h
@@ -364,6 +364,13 @@ extern const struct _mp_obj_module_t terminalio_module;
 #define TERMINALIO_MODULE
 #endif
 
+#if CIRCUITPY_ESPIDF
+extern const struct _mp_obj_module_t espidf_module;
+#define ESPIDF_MODULE            { MP_OBJ_NEW_QSTR(MP_QSTR_espidf),(mp_obj_t)&espidf_module },
+#else
+#define ESPIDF_MODULE
+#endif
+
 #if CIRCUITPY_FRAMEBUFFERIO
 extern const struct _mp_obj_module_t framebufferio_module;
 #define FRAMEBUFFERIO_MODULE       { MP_OBJ_NEW_QSTR(MP_QSTR_framebufferio), (mp_obj_t)&framebufferio_module },
@@ -421,6 +428,13 @@ extern const struct _mp_obj_module_t i2cperipheral_module;
 #define I2CPERIPHERAL_MODULE
 #endif
 
+#if CIRCUITPY_IPADDRESS
+extern const struct _mp_obj_module_t ipaddress_module;
+#define IPADDRESS_MODULE        { MP_OBJ_NEW_QSTR(MP_QSTR_ipaddress), (mp_obj_t)&ipaddress_module },
+#else
+#define IPADDRESS_MODULE
+#endif
+
 #if CIRCUITPY_MATH
 extern const struct _mp_obj_module_t math_module;
 #define MATH_MODULE            { MP_OBJ_NEW_QSTR(MP_QSTR_math), (mp_obj_t)&math_module },
@@ -574,6 +588,7 @@ extern const struct _mp_obj_module_t sdioio_module;
 #define SDIOIO_MODULE
 #endif
 
+
 #if CIRCUITPY_SHARPDISPLAY
 extern const struct _mp_obj_module_t sharpdisplay_module;
 #define SHARPDISPLAY_MODULE        { MP_OBJ_NEW_QSTR(MP_QSTR_sharpdisplay),(mp_obj_t)&sharpdisplay_module },
@@ -581,6 +596,20 @@ extern const struct _mp_obj_module_t sharpdisplay_module;
 #define SHARPDISPLAY_MODULE
 #endif
 
+#if CIRCUITPY_SOCKETPOOL
+extern const struct _mp_obj_module_t socketpool_module;
+#define SOCKETPOOL_MODULE           { MP_OBJ_NEW_QSTR(MP_QSTR_socketpool), (mp_obj_t)&socketpool_module },
+#else
+#define SOCKETPOOL_MODULE
+#endif
+
+#if CIRCUITPY_SSL
+extern const struct _mp_obj_module_t ssl_module;
+#define SSL_MODULE           { MP_OBJ_NEW_QSTR(MP_QSTR_ssl), (mp_obj_t)&ssl_module },
+#else
+#define SSL_MODULE
+#endif
+
 #if CIRCUITPY_STAGE
 extern const struct _mp_obj_module_t stage_module;
 #define STAGE_MODULE           { MP_OBJ_NEW_QSTR(MP_QSTR__stage), (mp_obj_t)&stage_module },
@@ -691,6 +720,13 @@ extern const struct _mp_obj_module_t watchdog_module;
 #define WATCHDOG_MODULE
 #endif
 
+#if CIRCUITPY_WIFI
+extern const struct _mp_obj_module_t wifi_module;
+#define WIFI_MODULE { MP_ROM_QSTR(MP_QSTR_wifi), MP_ROM_PTR(&wifi_module) },
+#else
+#define WIFI_MODULE
+#endif
+
 // Define certain native modules with weak links so they can be replaced with Python
 // implementations. This list may grow over time.
 #define MICROPY_PORT_BUILTIN_MODULE_WEAK_LINKS \
@@ -729,12 +765,14 @@ extern const struct _mp_obj_module_t watchdog_module;
       TERMINALIO_MODULE \
       VECTORIO_MODULE \
     ERRNO_MODULE \
+    ESPIDF_MODULE \
     FRAMEBUFFERIO_MODULE \
     FREQUENCYIO_MODULE \
     GAMEPAD_MODULE \
     GAMEPADSHIFT_MODULE \
     GNSS_MODULE \
     I2CPERIPHERAL_MODULE \
+    IPADDRESS_MODULE \
     JSON_MODULE \
     MATH_MODULE \
     _EVE_MODULE \
@@ -758,6 +796,8 @@ extern const struct _mp_obj_module_t watchdog_module;
     SDCARDIO_MODULE \
     SDIOIO_MODULE \
     SHARPDISPLAY_MODULE \
+    SOCKETPOOL_MODULE \
+    SSL_MODULE \
     STAGE_MODULE \
     STORAGE_MODULE \
     STRUCT_MODULE \
@@ -768,6 +808,7 @@ extern const struct _mp_obj_module_t watchdog_module;
     USB_MIDI_MODULE \
     USTACK_MODULE \
     WATCHDOG_MODULE \
+    WIFI_MODULE \
 
 // If weak links are enabled, just include strong links in the main list of modules,
 // and also include the underscore alternate names.
diff --git a/py/circuitpy_mpconfig.mk b/py/circuitpy_mpconfig.mk
index 90e8b5fde..a2da9c42f 100644
--- a/py/circuitpy_mpconfig.mk
+++ b/py/circuitpy_mpconfig.mk
@@ -99,6 +99,12 @@ CFLAGS += -DCIRCUITPY_COUNTIO=$(CIRCUITPY_COUNTIO)
 CIRCUITPY_DISPLAYIO ?= $(CIRCUITPY_FULL_BUILD)
 CFLAGS += -DCIRCUITPY_DISPLAYIO=$(CIRCUITPY_DISPLAYIO)
 
+# CIRCUITPY_ESPIDF is handled in the esp32s2 tree.
+# Only for ESP32S chips.
+# Assume not a ESP build.
+CIRCUITPY_ESPIDF ?= 0
+CFLAGS += -DCIRCUITPY_ESPIDF=$(CIRCUITPY_ESPIDF)
+
 ifeq ($(CIRCUITPY_DISPLAYIO),1)
 CIRCUITPY_FRAMEBUFFERIO ?= $(CIRCUITPY_FULL_BUILD)
 else
@@ -124,6 +130,9 @@ CFLAGS += -DCIRCUITPY_GNSS=$(CIRCUITPY_GNSS)
 CIRCUITPY_I2CPERIPHERAL ?= $(CIRCUITPY_FULL_BUILD)
 CFLAGS += -DCIRCUITPY_I2CPERIPHERAL=$(CIRCUITPY_I2CPERIPHERAL)
 
+CIRCUITPY_IPADDRESS ?= $(CIRCUITPY_WIFI)
+CFLAGS += -DCIRCUITPY_IPADDRESS=$(CIRCUITPY_IPADDRESS)
+
 CIRCUITPY_MATH ?= 1
 CFLAGS += -DCIRCUITPY_MATH=$(CIRCUITPY_MATH)
 
@@ -191,6 +200,12 @@ CFLAGS += -DCIRCUITPY_SDIOIO=$(CIRCUITPY_SDIOIO)
 CIRCUITPY_SHARPDISPLAY ?= $(CIRCUITPY_FRAMEBUFFERIO)
 CFLAGS += -DCIRCUITPY_SHARPDISPLAY=$(CIRCUITPY_SHARPDISPLAY)
 
+CIRCUITPY_SOCKETPOOL ?= $(CIRCUITPY_WIFI)
+CFLAGS += -DCIRCUITPY_SOCKETPOOL=$(CIRCUITPY_SOCKETPOOL)
+
+CIRCUITPY_SSL ?= $(CIRCUITPY_WIFI)
+CFLAGS += -DCIRCUITPY_SSL=$(CIRCUITPY_SSL)
+
 # Currently always off.
 CIRCUITPY_STAGE ?= 0
 CFLAGS += -DCIRCUITPY_STAGE=$(CIRCUITPY_STAGE)
@@ -263,6 +278,9 @@ CFLAGS += -DCIRCUITPY_ULAB=$(CIRCUITPY_ULAB)
 CIRCUITPY_WATCHDOG ?= 0
 CFLAGS += -DCIRCUITPY_WATCHDOG=$(CIRCUITPY_WATCHDOG)
 
+CIRCUITPY_WIFI ?= 0
+CFLAGS += -DCIRCUITPY_WIFI=$(CIRCUITPY_WIFI)
+
 # Enabled micropython.native decorator (experimental)
 CIRCUITPY_ENABLE_MPY_NATIVE ?= 0
 CFLAGS += -DCIRCUITPY_ENABLE_MPY_NATIVE=$(CIRCUITPY_ENABLE_MPY_NATIVE)
diff --git a/py/modbuiltins.c b/py/modbuiltins.c
index 905c3471f..41e1d4e48 100644
--- a/py/modbuiltins.c
+++ b/py/modbuiltins.c
@@ -726,6 +726,9 @@ STATIC const mp_rom_map_elem_t mp_module_builtins_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_NameError), MP_ROM_PTR(&mp_type_NameError) },
     { MP_ROM_QSTR(MP_QSTR_NotImplementedError), MP_ROM_PTR(&mp_type_NotImplementedError) },
     { MP_ROM_QSTR(MP_QSTR_OSError), MP_ROM_PTR(&mp_type_OSError) },
+        { MP_ROM_QSTR(MP_QSTR_TimeoutError), MP_ROM_PTR(&mp_type_TimeoutError) },
+        { MP_ROM_QSTR(MP_QSTR_ConnectionError), MP_ROM_PTR(&mp_type_ConnectionError) },
+            { MP_ROM_QSTR(MP_QSTR_BrokenPipeError), MP_ROM_PTR(&mp_type_BrokenPipeError) },
     { MP_ROM_QSTR(MP_QSTR_OverflowError), MP_ROM_PTR(&mp_type_OverflowError) },
     { MP_ROM_QSTR(MP_QSTR_RuntimeError), MP_ROM_PTR(&mp_type_RuntimeError) },
     #if MICROPY_PY_ASYNC_AWAIT
diff --git a/py/obj.h b/py/obj.h
index 943e1a389..805b26e48 100644
--- a/py/obj.h
+++ b/py/obj.h
@@ -627,6 +627,8 @@ extern const mp_obj_type_t mp_type_NameError;
 extern const mp_obj_type_t mp_type_NotImplementedError;
 extern const mp_obj_type_t mp_type_OSError;
 extern const mp_obj_type_t mp_type_TimeoutError;
+extern const mp_obj_type_t mp_type_ConnectionError;
+extern const mp_obj_type_t mp_type_BrokenPipeError;
 extern const mp_obj_type_t mp_type_OverflowError;
 extern const mp_obj_type_t mp_type_RuntimeError;
 extern const mp_obj_type_t mp_type_StopAsyncIteration;
diff --git a/py/objexcept.c b/py/objexcept.c
index e3b953543..01ba6da9c 100644
--- a/py/objexcept.c
+++ b/py/objexcept.c
@@ -282,15 +282,17 @@ MP_DEFINE_EXCEPTION(Exception, BaseException)
     MP_DEFINE_EXCEPTION(UnboundLocalError, NameError)
     */
   MP_DEFINE_EXCEPTION(OSError, Exception)
-  MP_DEFINE_EXCEPTION(TimeoutError, OSError)
-    /*
-    MP_DEFINE_EXCEPTION(BlockingIOError, OSError)
-    MP_DEFINE_EXCEPTION(ChildProcessError, OSError)
+    MP_DEFINE_EXCEPTION(TimeoutError, OSError)
     MP_DEFINE_EXCEPTION(ConnectionError, OSError)
       MP_DEFINE_EXCEPTION(BrokenPipeError, ConnectionError)
+      /*
       MP_DEFINE_EXCEPTION(ConnectionAbortedError, ConnectionError)
       MP_DEFINE_EXCEPTION(ConnectionRefusedError, ConnectionError)
       MP_DEFINE_EXCEPTION(ConnectionResetError, ConnectionError)
+      */
+    /*
+    MP_DEFINE_EXCEPTION(BlockingIOError, OSError)
+    MP_DEFINE_EXCEPTION(ChildProcessError, OSError)
     MP_DEFINE_EXCEPTION(InterruptedError, OSError)
     MP_DEFINE_EXCEPTION(IsADirectoryError, OSError)
     MP_DEFINE_EXCEPTION(NotADirectoryError, OSError)
diff --git a/py/runtime.c b/py/runtime.c
index f9ef7819d..e63e2337d 100644
--- a/py/runtime.c
+++ b/py/runtime.c
@@ -1602,6 +1602,14 @@ NORETURN void mp_raise_OSError_msg_varg(const compressed_string_t *fmt, ...) {
     va_end(argptr);
 }
 
+NORETURN void mp_raise_ConnectionError(const compressed_string_t *msg) {
+    mp_raise_msg(&mp_type_ConnectionError, msg);
+}
+
+NORETURN void mp_raise_BrokenPipeError(void) {
+    nlr_raise(mp_obj_new_exception_arg1(&mp_type_BrokenPipeError, MP_OBJ_NEW_SMALL_INT(MP_EPIPE)));
+}
+
 NORETURN void mp_raise_NotImplementedError(const compressed_string_t *msg) {
     mp_raise_msg(&mp_type_NotImplementedError, msg);
 }
diff --git a/py/runtime.h b/py/runtime.h
index dbc04b94e..ad7d0feab 100644
--- a/py/runtime.h
+++ b/py/runtime.h
@@ -166,6 +166,8 @@ NORETURN void mp_raise_OSError(int errno_);
 NORETURN void mp_raise_OSError_errno_str(int errno_, mp_obj_t str);
 NORETURN void mp_raise_OSError_msg(const compressed_string_t *msg);
 NORETURN void mp_raise_OSError_msg_varg(const compressed_string_t *fmt, ...);
+NORETURN void mp_raise_ConnectionError(const compressed_string_t *msg);
+NORETURN void mp_raise_BrokenPipeError(void);
 NORETURN void mp_raise_NotImplementedError(const compressed_string_t *msg);
 NORETURN void mp_raise_NotImplementedError_varg(const compressed_string_t *fmt, ...);
 NORETURN void mp_raise_OverflowError_varg(const compressed_string_t *fmt, ...);
diff --git a/shared-bindings/ipaddress/IPv4Address.c b/shared-bindings/ipaddress/IPv4Address.c
new file mode 100644
index 000000000..b2a10158a
--- /dev/null
+++ b/shared-bindings/ipaddress/IPv4Address.c
@@ -0,0 +1,198 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Dan Halbert for Adafruit Industries
+ * Copyright (c) 2018 Artur Pacholec
+ *
+ * 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/ipaddress/IPv4Address.h"
+
+#include <string.h>
+#include <stdio.h>
+
+#include "py/objproperty.h"
+#include "py/objstr.h"
+#include "py/runtime.h"
+#include "shared-bindings/ipaddress/__init__.h"
+
+//| class IPv4Address:
+//|     """Encapsulates an IPv4 address."""
+//|
+
+//|     def __init__(self, address: Union[int, str, bytes]) -> None:
+//|         """Create a new IPv4Address object encapsulating the address value.
+//|
+//|            The value itself can either be bytes or a string formatted address."""
+//|         ...
+//|
+STATIC mp_obj_t ipaddress_ipv4address_make_new(const mp_obj_type_t *type, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_address };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_address, MP_ARG_OBJ | MP_ARG_REQUIRED },
+    };
+
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    const mp_obj_t address = args[ARG_address].u_obj;
+
+    uint32_t value;
+    uint8_t* buf = NULL;
+    if (mp_obj_get_int_maybe(address, (mp_int_t*) &value)) {
+        // We're done.
+        buf = (uint8_t*) value;
+    } else if (MP_OBJ_IS_STR(address)) {
+        GET_STR_DATA_LEN(address, str_data, str_len);
+        if (!ipaddress_parse_ipv4address((const char*) str_data, str_len, &value)) {
+            mp_raise_ValueError(translate("Not a valid IP string"));
+        }
+    } else {
+        mp_buffer_info_t buf_info;
+        if (mp_get_buffer(address, &buf_info, MP_BUFFER_READ)) {
+            if (buf_info.len != 4) {
+                mp_raise_ValueError_varg(translate("Address must be %d bytes long"), 4);
+            }
+            buf = buf_info.buf;
+        }
+    }
+
+
+    ipaddress_ipv4address_obj_t *self = m_new_obj(ipaddress_ipv4address_obj_t);
+    self->base.type = &ipaddress_ipv4address_type;
+
+    common_hal_ipaddress_ipv4address_construct(self, buf, 4);
+
+    return MP_OBJ_FROM_PTR(self);
+}
+
+//|     packed: bytes
+//|     """The bytes that make up the address (read-only)."""
+//|
+STATIC mp_obj_t ipaddress_ipv4address_get_packed(mp_obj_t self_in) {
+    ipaddress_ipv4address_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+    return common_hal_ipaddress_ipv4address_get_packed(self);
+}
+MP_DEFINE_CONST_FUN_OBJ_1(ipaddress_ipv4address_get_packed_obj, ipaddress_ipv4address_get_packed);
+
+const mp_obj_property_t ipaddress_ipv4address_packed_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&ipaddress_ipv4address_get_packed_obj,
+              (mp_obj_t)&mp_const_none_obj,
+              (mp_obj_t)&mp_const_none_obj},
+};
+
+//|     version: int
+//|     """4 for IPv4, 6 for IPv6"""
+//|
+STATIC mp_obj_t ipaddress_ipv4address_get_version(mp_obj_t self_in) {
+    ipaddress_ipv4address_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_buffer_info_t buf_info;
+    mp_obj_t address_bytes = common_hal_ipaddress_ipv4address_get_packed(self);
+    mp_get_buffer_raise(address_bytes, &buf_info, MP_BUFFER_READ);
+    mp_int_t version = 6;
+    if (buf_info.len == 4) {
+        version = 4;
+    }
+
+    return MP_OBJ_NEW_SMALL_INT(version);
+}
+MP_DEFINE_CONST_FUN_OBJ_1(ipaddress_ipv4address_get_version_obj, ipaddress_ipv4address_get_version);
+
+const mp_obj_property_t ipaddress_ipv4address_version_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&ipaddress_ipv4address_get_version_obj,
+              (mp_obj_t)&mp_const_none_obj,
+              (mp_obj_t)&mp_const_none_obj},
+};
+
+//|     def __eq__(self, other: IPv4Address) -> bool:
+//|         """Two Address objects are equal if their addresses and address types are equal."""
+//|         ...
+//|
+STATIC mp_obj_t ipaddress_ipv4address_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
+    switch (op) {
+        // Two Addresses are equal if their address bytes and address_type are equal
+        case MP_BINARY_OP_EQUAL:
+            if (MP_OBJ_IS_TYPE(rhs_in, &ipaddress_ipv4address_type)) {
+                ipaddress_ipv4address_obj_t *lhs = MP_OBJ_TO_PTR(lhs_in);
+                ipaddress_ipv4address_obj_t *rhs = MP_OBJ_TO_PTR(rhs_in);
+                return mp_obj_new_bool(
+                    mp_obj_equal(common_hal_ipaddress_ipv4address_get_packed(lhs),
+                                 common_hal_ipaddress_ipv4address_get_packed(rhs)));
+
+            } else {
+                return mp_const_false;
+            }
+
+        default:
+            return MP_OBJ_NULL; // op not supported
+    }
+}
+
+//|     def __hash__(self) -> int:
+//|         """Returns a hash for the IPv4Address data."""
+//|         ...
+//|
+STATIC mp_obj_t ipaddress_ipv4address_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
+    switch (op) {
+        // Two Addresses are equal if their address bytes and address_type are equal
+        case MP_UNARY_OP_HASH: {
+            mp_obj_t bytes = common_hal_ipaddress_ipv4address_get_packed(MP_OBJ_TO_PTR(self_in));
+            GET_STR_HASH(bytes, h);
+            if (h == 0) {
+                GET_STR_DATA_LEN(bytes, data, len);
+                h = qstr_compute_hash(data, len);
+            }
+            return MP_OBJ_NEW_SMALL_INT(h);
+        }
+        default:
+            return MP_OBJ_NULL; // op not supported
+    }
+}
+
+STATIC void ipaddress_ipv4address_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    ipaddress_ipv4address_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_buffer_info_t buf_info;
+    mp_obj_t address_bytes = common_hal_ipaddress_ipv4address_get_packed(self);
+    mp_get_buffer_raise(address_bytes, &buf_info, MP_BUFFER_READ);
+
+    const uint8_t *buf = (uint8_t *) buf_info.buf;
+    mp_printf(print, "%d.%d.%d.%d", buf[0], buf[1], buf[2], buf[3]);
+}
+
+STATIC const mp_rom_map_elem_t ipaddress_ipv4address_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_packed),                 MP_ROM_PTR(&ipaddress_ipv4address_packed_obj) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(ipaddress_ipv4address_locals_dict, ipaddress_ipv4address_locals_dict_table);
+
+const mp_obj_type_t ipaddress_ipv4address_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_Address,
+    .make_new = ipaddress_ipv4address_make_new,
+    .print = ipaddress_ipv4address_print,
+    .unary_op = ipaddress_ipv4address_unary_op,
+    .binary_op = ipaddress_ipv4address_binary_op,
+    .locals_dict = (mp_obj_dict_t*)&ipaddress_ipv4address_locals_dict
+};
diff --git a/shared-bindings/ipaddress/IPv4Address.h b/shared-bindings/ipaddress/IPv4Address.h
new file mode 100644
index 000000000..b45cf3bac
--- /dev/null
+++ b/shared-bindings/ipaddress/IPv4Address.h
@@ -0,0 +1,38 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_IPADDRESS_IPV4ADDRESS_H
+#define MICROPY_INCLUDED_SHARED_BINDINGS_IPADDRESS_IPV4ADDRESS_H
+
+#include "shared-module/ipaddress/IPv4Address.h"
+
+extern const mp_obj_type_t ipaddress_ipv4address_type;
+
+mp_obj_t common_hal_ipaddress_new_ipv4address(uint32_t value);
+void common_hal_ipaddress_ipv4address_construct(ipaddress_ipv4address_obj_t* self, uint8_t* buf, size_t len);
+mp_obj_t common_hal_ipaddress_ipv4address_get_packed(ipaddress_ipv4address_obj_t* self);
+
+#endif // MICROPY_INCLUDED_SHARED_BINDINGS_IPADDRESS_IPV4ADDRESS_H
diff --git a/shared-bindings/ipaddress/__init__.c b/shared-bindings/ipaddress/__init__.c
new file mode 100644
index 000000000..7ec2984ef
--- /dev/null
+++ b/shared-bindings/ipaddress/__init__.c
@@ -0,0 +1,113 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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 "py/objexcept.h"
+#include "py/objstr.h"
+#include "py/parsenum.h"
+#include "py/runtime.h"
+#include "shared-bindings/ipaddress/__init__.h"
+#include "shared-bindings/ipaddress/IPv4Address.h"
+
+//| """
+//| The `ipaddress` module provides types for IP addresses. It is a subset of CPython's ipaddress
+//| module.
+//| """
+//|
+
+
+bool ipaddress_parse_ipv4address(const char* str_data, size_t str_len, uint32_t* ip_out) {
+    size_t period_count = 0;
+    size_t period_index[4] = {0, 0, 0, str_len};
+    for (size_t i = 0; i < str_len; i++) {
+        if (str_data[i] == '.') {
+            if (period_count < 3) {
+                period_index[period_count] = i;
+            }
+            period_count++;
+        }
+    }
+    if (period_count > 3) {
+        return false;
+    }
+
+    size_t last_period = 0;
+    if (ip_out != NULL) {
+        *ip_out = 0;
+    }
+    for (size_t i = 0; i < 4; i++) {
+        // Catch exceptions thrown by mp_parse_num_integer
+        nlr_buf_t nlr;
+        mp_obj_t octet;
+        if (nlr_push(&nlr) == 0) {
+            octet = mp_parse_num_integer((const char*) str_data + last_period, period_index[i] - last_period, 10, NULL);
+            nlr_pop();
+        } else {
+            return false;
+        }
+        last_period = period_index[i] + 1;
+        if (ip_out != NULL) {
+            mp_int_t int_octet = MP_OBJ_SMALL_INT_VALUE(octet);
+            *ip_out |= int_octet << (i * 8);
+        }
+    }
+    return true;
+}
+
+//| def ip_address(obj: Union[int]) -> IPv4Address:
+//|     """Return a corresponding IP address object or raise ValueError if not possible."""
+//|     ...
+//|
+
+STATIC mp_obj_t ipaddress_ip_address(mp_obj_t ip_in) {
+    uint32_t value;
+    if (mp_obj_get_int_maybe(ip_in, (mp_int_t*) &value)) {
+        // We're done.
+    } else if (MP_OBJ_IS_STR(ip_in)) {
+        GET_STR_DATA_LEN(ip_in, str_data, str_len);
+        if (!ipaddress_parse_ipv4address((const char*) str_data, str_len, &value)) {
+            mp_raise_ValueError(translate("Not a valid IP string"));
+        }
+    } else {
+        mp_raise_ValueError(translate("Only raw int supported for ip"));
+    }
+
+    return common_hal_ipaddress_new_ipv4address(value);
+}
+MP_DEFINE_CONST_FUN_OBJ_1(ipaddress_ip_address_obj, ipaddress_ip_address);
+
+STATIC const mp_rom_map_elem_t ipaddress_module_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__),      MP_ROM_QSTR(MP_QSTR_ipaddress) },
+    { MP_ROM_QSTR(MP_QSTR_ip_address),    MP_ROM_PTR(&ipaddress_ip_address_obj) },
+    { MP_ROM_QSTR(MP_QSTR_IPv4Address),   MP_ROM_PTR(&ipaddress_ipv4address_type) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(ipaddress_module_globals, ipaddress_module_globals_table);
+
+
+const mp_obj_module_t ipaddress_module = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t*)&ipaddress_module_globals,
+};
diff --git a/shared-bindings/ipaddress/__init__.h b/shared-bindings/ipaddress/__init__.h
new file mode 100644
index 000000000..a1c31775f
--- /dev/null
+++ b/shared-bindings/ipaddress/__init__.h
@@ -0,0 +1,36 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_IPADDRESS___INIT___H
+#define MICROPY_INCLUDED_SHARED_BINDINGS_IPADDRESS___INIT___H
+
+#include "shared-module/ipaddress/__init__.h"
+
+bool ipaddress_parse_ipv4address(const char* ip_str, size_t len, uint32_t* ip_out);
+
+mp_obj_t common_hal_ipaddress_new_ipv4address(uint32_t value);
+
+#endif // MICROPY_INCLUDED_SHARED_BINDINGS_IPADDRESS___INIT___H
diff --git a/shared-bindings/socketpool/Socket.c b/shared-bindings/socketpool/Socket.c
new file mode 100644
index 000000000..250e9c874
--- /dev/null
+++ b/shared-bindings/socketpool/Socket.c
@@ -0,0 +1,468 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * SPDX-FileCopyrightText: Copyright (c) 2014 Damien P. George
+ *               2018 Nick Moore for Adafruit Industries
+ *
+ * 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/socketpool/Socket.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include "lib/utils/context_manager_helpers.h"
+#include "py/objtuple.h"
+#include "py/objlist.h"
+#include "py/runtime.h"
+#include "py/mperrno.h"
+
+#include "esp_log.h"
+static const char* TAG = "socket binding";
+
+//| class Socket:
+//|     """TCP, UDP and RAW socket. Cannot be created directly. Instead, call
+//|        `SocketPool.socket()`.
+//|
+//|        Provides a subset of CPython's `socket.socket` API. It only implements the versions of
+//|        recv that do not allocate bytes objects."""
+//|
+
+//|     def __enter__(self) -> Socket:
+//|         """No-op used by Context Managers."""
+//|         ...
+//|
+//  Provided by context manager helper.
+
+//|     def __exit__(self) -> None:
+//|         """Automatically closes the Socket when exiting a context. See
+//|         :ref:`lifetime-and-contextmanagers` for more info."""
+//|         ...
+//|
+STATIC mp_obj_t socketpool_socket___exit__(size_t n_args, const mp_obj_t *args) {
+    (void)n_args;
+    common_hal_socketpool_socket_close(args[0]);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socketpool_socket___exit___obj, 4, 4, socketpool_socket___exit__);
+
+// //|     def bind(self, address: tuple) -> None:
+// //|         """Bind a socket to an address
+// //|
+// //|         :param ~tuple address: tuple of (remote_address, remote_port)"""
+// //|         ...
+// //|
+
+// STATIC mp_obj_t socketpool_socket_bind(mp_obj_t self_in, mp_obj_t addr_in) {
+//     // mod_network_socket_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+//     // // get address
+//     // uint8_t ip[MOD_NETWORK_IPADDR_BUF_SIZE];
+//     // mp_uint_t port = netutils_parse_inet_addr(addr_in, ip, NETUTILS_BIG);
+
+//     // // check if we need to select a NIC
+//     // socket_select_nic(self, ip);
+
+//     // // call the NIC to bind the socket
+//     // int _errno;
+//     // if (self->nic_type->bind(self, ip, port, &_errno) != 0) {
+//     //     mp_raise_OSError(_errno);
+//     // }
+
+//     return mp_const_none;
+// }
+// STATIC MP_DEFINE_CONST_FUN_OBJ_2(socketpool_socket_bind_obj, socketpool_socket_bind);
+
+// //|     def listen(self, backlog: int) -> None:
+// //|         """Set socket to listen for incoming connections
+// //|
+// //|         :param ~int backlog: length of backlog queue for waiting connetions"""
+// //|         ...
+// //|
+
+// STATIC mp_obj_t socketpool_socket_listen(mp_obj_t self_in, mp_obj_t backlog) {
+//     // mod_network_socket_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+//     // if (self->nic == MP_OBJ_NULL) {
+//     //     // not connected
+//     //     // TODO I think we can listen even if not bound...
+//     //     mp_raise_OSError(MP_ENOTCONN);
+//     // }
+
+//     // int _errno;
+//     // if (self->nic_type->listen(self, mp_obj_get_int(backlog), &_errno) != 0) {
+//     //     mp_raise_OSError(_errno);
+//     // }
+
+//     return mp_const_none;
+// }
+// STATIC MP_DEFINE_CONST_FUN_OBJ_2(socketpool_socket_listen_obj, socketpool_socket_listen);
+
+// //|     def accept(self) -> tuple:
+// //|         """Accept a connection on a listening socket of type SOCK_STREAM,
+// //|         creating a new socket of type SOCK_STREAM.
+// //|         Returns a tuple of (new_socket, remote_address)"""
+// //|
+
+// STATIC mp_obj_t socketpool_socket_accept(mp_obj_t self_in) {
+//     // mod_network_socket_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+//     // // create new socket object
+//     // // starts with empty NIC so that finaliser doesn't run close() method if accept() fails
+//     // mod_network_socket_obj_t *socket2 = m_new_obj_with_finaliser(mod_network_socket_obj_t);
+//     // socket2->base.type = &socket_type;
+//     // socket2->nic = MP_OBJ_NULL;
+//     // socket2->nic_type = NULL;
+
+//     // // accept incoming connection
+//     // uint8_t ip[MOD_NETWORK_IPADDR_BUF_SIZE];
+//     // mp_uint_t port;
+//     // int _errno;
+//     // if (self->nic_type->accept(self, socket2, ip, &port, &_errno) != 0) {
+//     //     mp_raise_OSError(_errno);
+//     // }
+
+//     // // new socket has valid state, so set the NIC to the same as parent
+//     // socket2->nic = self->nic;
+//     // socket2->nic_type = self->nic_type;
+
+//     // // make the return value
+//     // mp_obj_tuple_t *client = MP_OBJ_TO_PTR(mp_obj_new_tuple(2, NULL));
+//     // client->items[0] = MP_OBJ_FROM_PTR(socket2);
+//     // client->items[1] = netutils_format_inet_addr(ip, port, NETUTILS_BIG);
+
+//     return mp_const_none;
+// }
+// STATIC MP_DEFINE_CONST_FUN_OBJ_1(socketpool_socket_accept_obj, socketpool_socket_accept);
+
+//|     def close(self) -> None:
+//|         """Closes this Socket and makes its resources available to its SocketPool."""
+//|
+STATIC mp_obj_t socketpool_socket_close(mp_obj_t self_in) {
+    socketpool_socket_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_socketpool_socket_close(self);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(socketpool_socket_close_obj, socketpool_socket_close);
+
+//|     def connect(self, address: tuple) -> None:
+//|         """Connect a socket to a remote address
+//|
+//|         :param ~tuple address: tuple of (remote_address, remote_port)"""
+//|         ...
+//|
+
+STATIC mp_obj_t socketpool_socket_connect(mp_obj_t self_in, mp_obj_t addr_in) {
+    socketpool_socket_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+    mp_obj_t *addr_items;
+    mp_obj_get_array_fixed_n(addr_in, 2, &addr_items);
+
+    size_t hostlen;
+    const char* host = mp_obj_str_get_data(addr_items[0], &hostlen);
+    mp_int_t port = mp_obj_get_int(addr_items[1]);
+
+    bool ok = common_hal_socketpool_socket_connect(self, host, hostlen, port);
+    if (!ok) {
+        ESP_EARLY_LOGW(TAG, "socket connect failed");
+        mp_raise_OSError(0);
+    }
+
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(socketpool_socket_connect_obj, socketpool_socket_connect);
+
+//|     def send(self, bytes: ReadableBuffer) -> int:
+//|         """Send some bytes to the connected remote address.
+//|         Suits sockets of type SOCK_STREAM
+//|
+//|         :param ~bytes bytes: some bytes to send"""
+//|         ...
+//|
+
+STATIC mp_obj_t socketpool_socket_send(mp_obj_t self_in, mp_obj_t buf_in) {
+    socketpool_socket_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    if (common_hal_socketpool_socket_get_closed(self)) {
+        // Bad file number.
+        mp_raise_OSError(MP_EBADF);
+    }
+    if (!common_hal_socketpool_socket_get_connected(self)) {
+        mp_raise_BrokenPipeError();
+    }
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(buf_in, &bufinfo, MP_BUFFER_READ);
+    mp_int_t ret = common_hal_socketpool_socket_send(self, bufinfo.buf, bufinfo.len);
+    if (ret == -1) {
+        mp_raise_BrokenPipeError();
+    }
+    return mp_obj_new_int_from_uint(ret);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(socketpool_socket_send_obj, socketpool_socket_send);
+
+
+// helper function for socket_recv and socket_recv_into to handle common operations of both
+// STATIC mp_int_t _socket_recv_into(mod_network_socket_obj_t *sock, byte *buf, mp_int_t len) {
+//     mp_int_t ret = 0;
+//     // int _errno;
+//     // mp_int_t ret = sock->nic_type->recv(sock, buf, len, &_errno);
+//     // if (ret == -1) {
+//     //     mp_raise_OSError(_errno);
+//     // }
+//     return ret;
+// }
+
+
+//|     def recv_into(self, buffer: WriteableBuffer, bufsize: int) -> int:
+//|         """Reads some bytes from the connected remote address, writing
+//|         into the provided buffer. If bufsize <= len(buffer) is given,
+//|         a maximum of bufsize bytes will be read into the buffer. If no
+//|         valid value is given for bufsize, the default is the length of
+//|         the given buffer.
+//|
+//|         Suits sockets of type SOCK_STREAM
+//|         Returns an int of number of bytes read.
+//|
+//|         :param bytearray buffer: buffer to receive into
+//|         :param int bufsize: optionally, a maximum number of bytes to read."""
+//|         ...
+//|
+
+STATIC mp_obj_t socketpool_socket_recv_into(size_t n_args, const mp_obj_t *args) {
+    socketpool_socket_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    if (common_hal_socketpool_socket_get_closed(self)) {
+        // Bad file number.
+        mp_raise_OSError(MP_EBADF);
+    }
+    if (!common_hal_socketpool_socket_get_connected(self)) {
+        // not connected
+        mp_raise_OSError(MP_ENOTCONN);
+    }
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(args[1], &bufinfo, MP_BUFFER_WRITE);
+    mp_int_t len = bufinfo.len;
+    if (n_args == 3) {
+        mp_int_t given_len = mp_obj_get_int(args[2]);
+        if (given_len < len) {
+            len = given_len;
+        }
+    }
+
+    if (len == 0) {
+        return MP_OBJ_NEW_SMALL_INT(0);
+    }
+
+    mp_int_t ret = common_hal_socketpool_socket_recv_into(self, (byte*)bufinfo.buf, len);
+    return mp_obj_new_int_from_uint(ret);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socketpool_socket_recv_into_obj, 2, 3, socketpool_socket_recv_into);
+
+// //|     def sendto(self, bytes: ReadableBuffer, address: tuple) -> int:
+// //|         """Send some bytes to a specific address.
+// //|         Suits sockets of type SOCK_DGRAM
+// //|
+// //|         :param ~bytes bytes: some bytes to send
+// //|         :param ~tuple address: tuple of (remote_address, remote_port)"""
+// //|         ...
+// //|
+
+// STATIC mp_obj_t socketpool_socket_sendto(mp_obj_t self_in, mp_obj_t data_in, mp_obj_t addr_in) {
+//     // mod_network_socket_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+//     // // get the data
+//     // mp_buffer_info_t bufinfo;
+//     // mp_get_buffer_raise(data_in, &bufinfo, MP_BUFFER_READ);
+
+//     // // get address
+//     // uint8_t ip[MOD_NETWORK_IPADDR_BUF_SIZE];
+//     // mp_uint_t port = netutils_parse_inet_addr(addr_in, ip, NETUTILS_BIG);
+
+//     // // check if we need to select a NIC
+//     // socket_select_nic(self, ip);
+
+//     // // call the NIC to sendto
+//     // int _errno;
+//     // mp_int_t ret = self->nic_type->sendto(self, bufinfo.buf, bufinfo.len, ip, port, &_errno);
+//     // if (ret == -1) {
+//     //     mp_raise_OSError(_errno);
+//     // }
+//     mp_int_t ret = 0;
+
+//     return mp_obj_new_int(ret);
+// }
+// STATIC MP_DEFINE_CONST_FUN_OBJ_3(socketpool_socket_sendto_obj, socketpool_socket_sendto);
+
+// //|     def recvfrom(self, bufsize: int) -> Tuple[bytes, tuple]:
+// //|         """Reads some bytes from the connected remote address.
+// //|         Suits sockets of type SOCK_STREAM
+// //|
+// //|         Returns a tuple containing
+// //|         * a bytes() of length <= bufsize
+// //|         * a remote_address, which is a tuple of ip address and port number
+// //|
+// //|         :param ~int bufsize: maximum number of bytes to receive"""
+// //|         ...
+// //|
+
+// STATIC mp_obj_t socketpool_socket_recvfrom_into(mp_obj_t self_in, mp_obj_t len_in) {
+//     // mod_network_socket_obj_t *self = MP_OBJ_TO_PTR(self_in);
+//     // if (self->nic == MP_OBJ_NULL) {
+//     //     // not connected
+//     //     mp_raise_OSError(MP_ENOTCONN);
+//     // }
+//     // vstr_t vstr;
+//     // vstr_init_len(&vstr, mp_obj_get_int(len_in));
+//     // byte ip[4];
+//     // mp_uint_t port;
+//     // int _errno;
+//     // mp_int_t ret = self->nic_type->recvfrom(self, (byte*)vstr.buf, vstr.len, ip, &port, &_errno);
+//     // if (ret == -1) {
+//     //     mp_raise_OSError(_errno);
+//     // }
+//     mp_obj_t tuple[2];
+//     // if (ret == 0) {
+//     //     tuple[0] = mp_const_empty_bytes;
+//     // } else {
+//     //     vstr.len = ret;
+//     //     tuple[0] = mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
+//     // }
+//     // tuple[1] = netutils_format_inet_addr(ip, port, NETUTILS_BIG);
+//     return mp_obj_new_tuple(2, tuple);
+// }
+// STATIC MP_DEFINE_CONST_FUN_OBJ_2(socketpool_socket_recvfrom_into_obj, socketpool_socket_recvfrom_into);
+
+// //|     def setsockopt(self, level: int, optname: int, value: int) -> None:
+// //|         """Sets socket options"""
+// //|         ...
+// //|
+
+// STATIC mp_obj_t socketpool_socket_setsockopt(size_t n_args, const mp_obj_t *args) {
+//     // mod_network_socket_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+
+//     // mp_int_t level = mp_obj_get_int(args[1]);
+//     // mp_int_t opt = mp_obj_get_int(args[2]);
+
+//     // const void *optval;
+//     // mp_uint_t optlen;
+//     // mp_int_t val;
+//     // if (mp_obj_is_integer(args[3])) {
+//     //     val = mp_obj_get_int_truncated(args[3]);
+//     //     optval = &val;
+//     //     optlen = sizeof(val);
+//     // } else {
+//     //     mp_buffer_info_t bufinfo;
+//     //     mp_get_buffer_raise(args[3], &bufinfo, MP_BUFFER_READ);
+//     //     optval = bufinfo.buf;
+//     //     optlen = bufinfo.len;
+//     // }
+
+//     // int _errno;
+//     // if (self->nic_type->setsockopt(self, level, opt, optval, optlen, &_errno) != 0) {
+//     //     mp_raise_OSError(_errno);
+//     // }
+
+//     return mp_const_none;
+// }
+// STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socketpool_socket_setsockopt_obj, 4, 4, socketpool_socket_setsockopt);
+
+//|     def settimeout(self, value: int) -> None:
+//|         """Set the timeout value for this socket.
+//|
+//|         :param ~int value: timeout in seconds.  0 means non-blocking.  None means block indefinitely."""
+//|         ...
+//|
+
+STATIC mp_obj_t socketpool_socket_settimeout(mp_obj_t self_in, mp_obj_t timeout_in) {
+    socketpool_socket_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_uint_t timeout_ms;
+    if (timeout_in == mp_const_none) {
+        timeout_ms = -1;
+    } else {
+        #if MICROPY_PY_BUILTINS_FLOAT
+        timeout_ms = 1000 * mp_obj_get_float(timeout_in);
+        #else
+        timeout_ms = 1000 * mp_obj_get_int(timeout_in);
+        #endif
+    }
+    common_hal_socketpool_socket_settimeout(self, timeout_ms);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(socketpool_socket_settimeout_obj, socketpool_socket_settimeout);
+
+// //|     def setblocking(self, flag: bool) -> Optional[int]:
+// //|         """Set the blocking behaviour of this socket.
+// //|
+// //|         :param ~bool flag: False means non-blocking, True means block indefinitely."""
+// //|         ...
+// //|
+
+// // method socket.setblocking(flag)
+// STATIC mp_obj_t socketpool_socket_setblocking(mp_obj_t self_in, mp_obj_t blocking) {
+//     // if (mp_obj_is_true(blocking)) {
+//     //     return socket_settimeout(self_in, mp_const_none);
+//     // } else {
+//     //     return socket_settimeout(self_in, MP_OBJ_NEW_SMALL_INT(0));
+//     // }
+//     return mp_const_none;
+// }
+// STATIC MP_DEFINE_CONST_FUN_OBJ_2(socketpool_socket_setblocking_obj, socketpool_socket_setblocking);
+
+//|     def __hash__(self) -> int:
+//|         """Returns a hash for the Socket."""
+//|         ...
+//|
+STATIC mp_obj_t socketpool_socket_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
+    switch (op) {
+        case MP_UNARY_OP_HASH: {
+            return MP_OBJ_NEW_SMALL_INT(common_hal_socketpool_socket_get_hash(MP_OBJ_TO_PTR(self_in)));
+        }
+        default:
+            return MP_OBJ_NULL; // op not supported
+    }
+}
+
+STATIC const mp_rom_map_elem_t socketpool_socket_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&default___enter___obj) },
+    { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&socketpool_socket___exit___obj) },
+    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&socketpool_socket_close_obj) },
+    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&socketpool_socket_close_obj) },
+
+    // { MP_ROM_QSTR(MP_QSTR_bind), MP_ROM_PTR(&socketpool_socket_bind_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_listen), MP_ROM_PTR(&socketpool_socket_listen_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_accept), MP_ROM_PTR(&socketpool_socket_accept_obj) },
+    { MP_ROM_QSTR(MP_QSTR_connect), MP_ROM_PTR(&socketpool_socket_connect_obj) },
+    { MP_ROM_QSTR(MP_QSTR_send), MP_ROM_PTR(&socketpool_socket_send_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_sendto), MP_ROM_PTR(&socketpool_socket_sendto_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_recvfrom_into), MP_ROM_PTR(&socketpool_socket_recvfrom_into_obj) },
+    { MP_ROM_QSTR(MP_QSTR_recv_into), MP_ROM_PTR(&socketpool_socket_recv_into_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_setsockopt), MP_ROM_PTR(&socketpool_socket_setsockopt_obj) },
+    { MP_ROM_QSTR(MP_QSTR_settimeout), MP_ROM_PTR(&socketpool_socket_settimeout_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_setblocking), MP_ROM_PTR(&socketpool_socket_setblocking_obj) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(socketpool_socket_locals_dict, socketpool_socket_locals_dict_table);
+
+const mp_obj_type_t socketpool_socket_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_Socket,
+    .locals_dict = (mp_obj_dict_t*)&socketpool_socket_locals_dict,
+    .unary_op = socketpool_socket_unary_op,
+};
diff --git a/shared-bindings/socketpool/Socket.h b/shared-bindings/socketpool/Socket.h
new file mode 100644
index 000000000..f0be95c92
--- /dev/null
+++ b/shared-bindings/socketpool/Socket.h
@@ -0,0 +1,43 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_SOCKETPOOL_SOCKET_H
+#define MICROPY_INCLUDED_SHARED_BINDINGS_SOCKETPOOL_SOCKET_H
+
+#include "common-hal/socketpool/Socket.h"
+
+extern const mp_obj_type_t socketpool_socket_type;
+
+void common_hal_socketpool_socket_settimeout(socketpool_socket_obj_t* self, mp_uint_t timeout_ms);
+bool common_hal_socketpool_socket_connect(socketpool_socket_obj_t* self, const char* host, size_t hostlen, mp_int_t port);
+mp_uint_t common_hal_socketpool_socket_send(socketpool_socket_obj_t* self, const uint8_t* buf, mp_uint_t len);
+mp_uint_t common_hal_socketpool_socket_recv_into(socketpool_socket_obj_t* self, const uint8_t* buf, mp_uint_t len);
+void common_hal_socketpool_socket_close(socketpool_socket_obj_t* self);
+bool common_hal_socketpool_socket_get_closed(socketpool_socket_obj_t* self);
+bool common_hal_socketpool_socket_get_connected(socketpool_socket_obj_t* self);
+mp_uint_t common_hal_socketpool_socket_get_hash(socketpool_socket_obj_t* self);
+
+#endif // MICROPY_INCLUDED_SHARED_BINDINGS_SOCKETPOOL_SOCKET_H
diff --git a/shared-bindings/socketpool/SocketPool.c b/shared-bindings/socketpool/SocketPool.c
new file mode 100644
index 000000000..0eeebd691
--- /dev/null
+++ b/shared-bindings/socketpool/SocketPool.c
@@ -0,0 +1,162 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * SPDX-FileCopyrightText: Copyright (c) 2014 Damien P. George
+ *               2018 Nick Moore for Adafruit Industries
+ *
+ * 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 <stdio.h>
+#include <string.h>
+
+#include "py/objtuple.h"
+#include "py/objlist.h"
+#include "py/runtime.h"
+#include "py/mperrno.h"
+
+#include "shared-bindings/ipaddress/__init__.h"
+#include "shared-bindings/socketpool/Socket.h"
+#include "shared-bindings/socketpool/SocketPool.h"
+
+#include "esp_log.h"
+static const char* TAG = "socketpool binding";
+
+//| class SocketPool:
+//|     """A pool of socket resources available for the given radio. Only one
+//|        SocketPool can be created for each radio.
+//|
+//|        SocketPool should be used in place of CPython's socket which provides
+//|        a pool of sockets provided by the underlying OS."""
+//|
+
+STATIC mp_obj_t socketpool_socketpool_make_new(const mp_obj_type_t *type, size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
+    mp_arg_check_num(n_args, kw_args, 1, 1, false);
+
+    socketpool_socketpool_obj_t *s = m_new_obj_with_finaliser(socketpool_socketpool_obj_t);
+    s->base.type = &socketpool_socketpool_type;
+    mp_obj_t radio = args[0];
+
+    common_hal_socketpool_socketpool_construct(s, radio);
+
+    return MP_OBJ_FROM_PTR(s);
+}
+
+
+//|     def socket(self, family: int = AF_INET, type: int = SOCK_STREAM, proto: int = IPPROTO_TCP) -> None:
+//|         """Create a new socket
+//|
+//|         :param ~int family: AF_INET or AF_INET6
+//|         :param ~int type: SOCK_STREAM, SOCK_DGRAM or SOCK_RAW
+//|         :param ~int proto: IPPROTO_TCP, IPPROTO_UDP or IPPROTO_RAW (ignored)"""
+//|         ...
+//|
+STATIC mp_obj_t socketpool_socketpool_socket(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    mp_arg_check_num(n_args, kw_args, 0, 5, false);
+
+    socketpool_socketpool_obj_t *self = pos_args[0];
+    socketpool_socketpool_addressfamily_t family = SOCKETPOOL_AF_INET;
+    socketpool_socketpool_sock_t type = SOCKETPOOL_SOCK_STREAM;
+    if (n_args >= 2) {
+        family = mp_obj_get_int(pos_args[1]);
+        if (n_args >= 3) {
+            type = mp_obj_get_int(pos_args[2]);
+        }
+    }
+    return common_hal_socketpool_socket(self, family, type);
+}
+MP_DEFINE_CONST_FUN_OBJ_KW(socketpool_socketpool_socket_obj, 1, socketpool_socketpool_socket);
+
+//| def getaddrinfo(host: str, port: int, family: int = 0, type: int = 0, proto: int = 0, flags: int = 0) -> tuple:
+//|     """Gets the address information for a hostname and port
+//|
+//|     Returns the appropriate family, socket type, socket protocol and
+//|     address information to call socket.socket() and socket.connect() with,
+//|     as a tuple."""
+//|     ...
+//|
+
+STATIC mp_obj_t socketpool_socketpool_getaddrinfo(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_host, ARG_port, ARG_family, ARG_type, ARG_proto, ARG_flags };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_host, MP_ARG_OBJ | MP_ARG_REQUIRED },
+        { MP_QSTR_port, MP_ARG_INT | MP_ARG_REQUIRED },
+        { MP_QSTR_family, MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_type, MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_port, MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_flags, MP_ARG_INT, {.u_int = 0} },
+    };
+    socketpool_socketpool_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
+
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    const char *host = mp_obj_str_get_str(args[ARG_host].u_obj);
+    mp_int_t port = args[ARG_port].u_int;
+    mp_obj_t ip_str = mp_const_none;
+
+    if (strlen(host) > 0 && ipaddress_parse_ipv4address(host, strlen(host), NULL)) {
+        ip_str = args[ARG_host].u_obj;
+    }
+
+    if (ip_str == mp_const_none) {
+        ip_str = common_hal_socketpool_socketpool_gethostbyname(self, host);
+    }
+
+    if (ip_str == mp_const_none) {
+        ESP_EARLY_LOGW(TAG, "no ip str");
+        mp_raise_OSError(0);
+    }
+
+    mp_obj_tuple_t *tuple = MP_OBJ_TO_PTR(mp_obj_new_tuple(5, NULL));
+    tuple->items[0] = MP_OBJ_NEW_SMALL_INT(SOCKETPOOL_AF_INET);
+    tuple->items[1] = MP_OBJ_NEW_SMALL_INT(SOCKETPOOL_SOCK_STREAM);
+    tuple->items[2] = MP_OBJ_NEW_SMALL_INT(0);
+    tuple->items[3] = MP_OBJ_NEW_QSTR(MP_QSTR_);
+    mp_obj_tuple_t *sockaddr = MP_OBJ_TO_PTR(mp_obj_new_tuple(2, NULL));
+    sockaddr->items[0] = ip_str;
+    sockaddr->items[1] = MP_OBJ_NEW_SMALL_INT(port);
+    tuple->items[4] = MP_OBJ_FROM_PTR(sockaddr);
+    return mp_obj_new_list(1, (mp_obj_t*)&tuple);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(socketpool_socketpool_getaddrinfo_obj, 3, socketpool_socketpool_getaddrinfo);
+
+STATIC const mp_rom_map_elem_t socketpool_socketpool_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_socket), MP_ROM_PTR(&socketpool_socketpool_socket_obj) },
+    { MP_ROM_QSTR(MP_QSTR_getaddrinfo), MP_ROM_PTR(&socketpool_socketpool_getaddrinfo_obj) },
+
+    // class constants
+    { MP_ROM_QSTR(MP_QSTR_AF_INET), MP_ROM_INT(SOCKETPOOL_AF_INET) },
+    { MP_ROM_QSTR(MP_QSTR_AF_INET6), MP_ROM_INT(SOCKETPOOL_AF_INET6) },
+
+    { MP_ROM_QSTR(MP_QSTR_SOCK_STREAM), MP_ROM_INT(SOCKETPOOL_SOCK_STREAM) },
+    { MP_ROM_QSTR(MP_QSTR_SOCK_DGRAM), MP_ROM_INT(SOCKETPOOL_SOCK_DGRAM) },
+    { MP_ROM_QSTR(MP_QSTR_SOCK_RAW), MP_ROM_INT(SOCKETPOOL_SOCK_RAW) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(socketpool_socketpool_locals_dict, socketpool_socketpool_locals_dict_table);
+
+const mp_obj_type_t socketpool_socketpool_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_SocketPool,
+    .make_new = socketpool_socketpool_make_new,
+    .locals_dict = (mp_obj_dict_t*)&socketpool_socketpool_locals_dict,
+};
diff --git a/shared-bindings/socketpool/SocketPool.h b/shared-bindings/socketpool/SocketPool.h
new file mode 100644
index 000000000..b007aad8f
--- /dev/null
+++ b/shared-bindings/socketpool/SocketPool.h
@@ -0,0 +1,55 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_SOCKETPOOL_SOCKETPOOL_H
+#define MICROPY_INCLUDED_SHARED_BINDINGS_SOCKETPOOL_SOCKETPOOL_H
+
+#include "common-hal/socketpool/SocketPool.h"
+
+#include "shared-bindings/socketpool/Socket.h"
+
+extern const mp_obj_type_t socketpool_socketpool_type;
+
+typedef enum {
+    SOCKETPOOL_SOCK_STREAM,
+    SOCKETPOOL_SOCK_DGRAM,
+    SOCKETPOOL_SOCK_RAW
+} socketpool_socketpool_sock_t;
+
+typedef enum {
+    SOCKETPOOL_AF_INET,
+    SOCKETPOOL_AF_INET6
+} socketpool_socketpool_addressfamily_t;
+
+void common_hal_socketpool_socketpool_construct(socketpool_socketpool_obj_t* self, mp_obj_t radio);
+
+socketpool_socket_obj_t* common_hal_socketpool_socket(socketpool_socketpool_obj_t* self,
+    socketpool_socketpool_addressfamily_t family, socketpool_socketpool_sock_t type);
+
+mp_obj_t common_hal_socketpool_socketpool_gethostbyname(socketpool_socketpool_obj_t* self,
+    const char* host);
+
+#endif // MICROPY_INCLUDED_SHARED_BINDINGS_SOCKETPOOL_SOCKETPOOL_H
diff --git a/shared-bindings/socketpool/__init__.c b/shared-bindings/socketpool/__init__.c
new file mode 100644
index 000000000..d3f8ba302
--- /dev/null
+++ b/shared-bindings/socketpool/__init__.c
@@ -0,0 +1,53 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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 "py/objexcept.h"
+#include "py/objstr.h"
+#include "py/parsenum.h"
+#include "py/runtime.h"
+#include "shared-bindings/socketpool/__init__.h"
+#include "shared-bindings/socketpool/Socket.h"
+#include "shared-bindings/socketpool/SocketPool.h"
+
+//| """
+//| The `socketpool` module provides sockets through a pool. The pools themselves
+//| act like CPython's `socket` module.
+//| """
+//|
+
+STATIC const mp_rom_map_elem_t socketpool_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_socketpool) },
+
+    { MP_ROM_QSTR(MP_QSTR_SocketPool), MP_ROM_PTR(&socketpool_socketpool_type) },
+    { MP_ROM_QSTR(MP_QSTR_Socket), MP_ROM_PTR(&socketpool_socket_type) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(socketpool_globals, socketpool_globals_table);
+
+const mp_obj_module_t socketpool_module = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t*)&socketpool_globals,
+};
diff --git a/shared-bindings/socketpool/__init__.h b/shared-bindings/socketpool/__init__.h
new file mode 100644
index 000000000..a017e96c6
--- /dev/null
+++ b/shared-bindings/socketpool/__init__.h
@@ -0,0 +1,30 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_SOCKETPOOL___INIT___H
+#define MICROPY_INCLUDED_SHARED_BINDINGS_SOCKETPOOL___INIT___H
+
+#endif // MICROPY_INCLUDED_SHARED_BINDINGS_SOCKETPOOL___INIT___H
diff --git a/shared-bindings/ssl/SSLContext.c b/shared-bindings/ssl/SSLContext.c
new file mode 100644
index 000000000..d2c236d3b
--- /dev/null
+++ b/shared-bindings/ssl/SSLContext.c
@@ -0,0 +1,95 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * SPDX-FileCopyrightText: Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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 <stdio.h>
+#include <string.h>
+
+#include "py/objtuple.h"
+#include "py/objlist.h"
+#include "py/runtime.h"
+#include "py/mperrno.h"
+
+#include "shared-bindings/ssl/SSLContext.h"
+
+//| class SSLContext:
+//|     """Settings related to SSL that can be applied to a socket by wrapping it.
+//|        This is useful to provide SSL certificates to specific connections
+//|        rather than all of them."""
+//|
+
+STATIC mp_obj_t ssl_sslcontext_make_new(const mp_obj_type_t *type, size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
+    mp_arg_check_num(n_args, kw_args, 0, 1, false);
+
+    ssl_sslcontext_obj_t *s = m_new_obj(ssl_sslcontext_obj_t);
+    s->base.type = &ssl_sslcontext_type;
+
+    common_hal_ssl_sslcontext_construct(s);
+
+    return MP_OBJ_FROM_PTR(s);
+}
+
+//| def wrap_socket(sock: socketpool.Socket, *, server_side: bool = False, server_hostname: str = None) -> socketpool.Socket:
+//|     """Wraps the socket into a socket-compatible class that handles SSL negotiation.
+//|        The socket must be of type SOCK_STREAM."""
+//|     ...
+//|
+
+STATIC mp_obj_t ssl_sslcontext_wrap_socket(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_sock, ARG_server_side, ARG_server_hostname };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_sock, MP_ARG_OBJ | MP_ARG_REQUIRED },
+        { MP_QSTR_server_side, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false} },
+        { MP_QSTR_server_hostname, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+    };
+    ssl_sslcontext_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
+
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    const char *server_hostname = mp_obj_str_get_str(args[ARG_server_hostname].u_obj);
+    bool server_side = args[ARG_server_side].u_bool;
+    if (server_side && server_hostname != NULL) {
+        mp_raise_ValueError(translate("Server side context cannot have hostname"));
+    }
+
+    socketpool_socket_obj_t* sock = args[ARG_sock].u_obj;
+
+    return common_hal_ssl_sslcontext_wrap_socket(self, sock, server_side, server_hostname);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(ssl_sslcontext_wrap_socket_obj, 2, ssl_sslcontext_wrap_socket);
+
+STATIC const mp_rom_map_elem_t ssl_sslcontext_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_wrap_socket), MP_ROM_PTR(&ssl_sslcontext_wrap_socket_obj) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(ssl_sslcontext_locals_dict, ssl_sslcontext_locals_dict_table);
+
+const mp_obj_type_t ssl_sslcontext_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_SSLContext,
+    .make_new = ssl_sslcontext_make_new,
+    .locals_dict = (mp_obj_dict_t*)&ssl_sslcontext_locals_dict,
+};
diff --git a/shared-bindings/ssl/SSLContext.h b/shared-bindings/ssl/SSLContext.h
new file mode 100644
index 000000000..f7f985af7
--- /dev/null
+++ b/shared-bindings/ssl/SSLContext.h
@@ -0,0 +1,41 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_SSL_SSLCONTEXT_H
+#define MICROPY_INCLUDED_SHARED_BINDINGS_SSL_SSLCONTEXT_H
+
+#include "common-hal/ssl/SSLContext.h"
+
+#include "shared-bindings/socketpool/Socket.h"
+
+extern const mp_obj_type_t ssl_sslcontext_type;
+
+void common_hal_ssl_sslcontext_construct(ssl_sslcontext_obj_t* self);
+
+socketpool_socket_obj_t* common_hal_ssl_sslcontext_wrap_socket(ssl_sslcontext_obj_t* self,
+    socketpool_socket_obj_t* sock, bool server_side, const char* server_hostname);
+
+#endif // MICROPY_INCLUDED_SHARED_BINDINGS_SSL_SSLCONTEXT_H
diff --git a/shared-bindings/ssl/__init__.c b/shared-bindings/ssl/__init__.c
new file mode 100644
index 000000000..57f4e6f4a
--- /dev/null
+++ b/shared-bindings/ssl/__init__.c
@@ -0,0 +1,66 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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 "py/objexcept.h"
+#include "py/objstr.h"
+#include "py/parsenum.h"
+#include "py/runtime.h"
+#include "shared-bindings/ssl/__init__.h"
+#include "shared-bindings/ssl/SSLContext.h"
+
+//| """
+//| The `ssl` module provides SSL contexts to wrap sockets in.
+//| """
+//|
+
+//| def create_default_context() -> ssl.SSLContext:
+//|     """Return the default SSLContext."""
+//|     ...
+//|
+
+STATIC mp_obj_t ssl_create_default_context(void) {
+    ssl_sslcontext_obj_t *s = m_new_obj(ssl_sslcontext_obj_t);
+    s->base.type = &ssl_sslcontext_type;
+
+    common_hal_ssl_create_default_context(s);
+    return s;
+}
+MP_DEFINE_CONST_FUN_OBJ_0(ssl_create_default_context_obj, ssl_create_default_context);
+
+STATIC const mp_rom_map_elem_t ssl_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_ssl) },
+
+    { MP_ROM_QSTR(MP_QSTR_create_default_context), MP_ROM_PTR(&ssl_create_default_context_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_SSLContext), MP_ROM_PTR(&ssl_sslcontext_type) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(ssl_globals, ssl_globals_table);
+
+const mp_obj_module_t ssl_module = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t*)&ssl_globals,
+};
diff --git a/shared-bindings/ssl/__init__.h b/shared-bindings/ssl/__init__.h
new file mode 100644
index 000000000..5ddada64e
--- /dev/null
+++ b/shared-bindings/ssl/__init__.h
@@ -0,0 +1,34 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_SSL___INIT___H
+#define MICROPY_INCLUDED_SHARED_BINDINGS_SSL___INIT___H
+
+#include "common-hal/ssl/SSLContext.h"
+
+void common_hal_ssl_create_default_context(ssl_sslcontext_obj_t* self);
+
+#endif // MICROPY_INCLUDED_SHARED_BINDINGS_SSL___INIT___H
diff --git a/shared-bindings/wifi/Network.c b/shared-bindings/wifi/Network.c
new file mode 100644
index 000000000..b6d5e0901
--- /dev/null
+++ b/shared-bindings/wifi/Network.c
@@ -0,0 +1,107 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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 <string.h>
+
+#include "py/objproperty.h"
+#include "py/runtime.h"
+#include "shared-bindings/wifi/Network.h"
+
+//| class Network:
+//|     """A wifi network provided by a nearby access point.
+//|
+//|     """
+//|
+
+//|     def __init__(self) -> None:
+//|         """You cannot create an instance of `wifi.Network`. They are returned by `wifi.Radio.start_scanning_networks`."""
+//|         ...
+//|
+
+//|     ssid: str
+//|     """String id of the network"""
+//|
+STATIC mp_obj_t wifi_network_get_ssid(mp_obj_t self) {
+    return common_hal_wifi_network_get_ssid(self);
+
+}
+MP_DEFINE_CONST_FUN_OBJ_1(wifi_network_get_ssid_obj, wifi_network_get_ssid);
+
+const mp_obj_property_t wifi_network_ssid_obj = {
+    .base.type = &mp_type_property,
+    .proxy = { (mp_obj_t)&wifi_network_get_ssid_obj,
+               (mp_obj_t)&mp_const_none_obj,
+               (mp_obj_t)&mp_const_none_obj },
+};
+
+
+//|     rssi: int
+//|     """Signal strength of the network"""
+//|
+STATIC mp_obj_t wifi_network_get_rssi(mp_obj_t self) {
+    return common_hal_wifi_network_get_rssi(self);
+
+}
+MP_DEFINE_CONST_FUN_OBJ_1(wifi_network_get_rssi_obj, wifi_network_get_rssi);
+
+const mp_obj_property_t wifi_network_rssi_obj = {
+    .base.type = &mp_type_property,
+    .proxy = { (mp_obj_t)&wifi_network_get_rssi_obj,
+               (mp_obj_t)&mp_const_none_obj,
+               (mp_obj_t)&mp_const_none_obj },
+};
+
+
+//|     channel: int
+//|     """Channel number the network is operating on"""
+//|
+STATIC mp_obj_t wifi_network_get_channel(mp_obj_t self) {
+    return common_hal_wifi_network_get_channel(self);
+
+}
+MP_DEFINE_CONST_FUN_OBJ_1(wifi_network_get_channel_obj, wifi_network_get_channel);
+
+const mp_obj_property_t wifi_network_channel_obj = {
+    .base.type = &mp_type_property,
+    .proxy = { (mp_obj_t)&wifi_network_get_channel_obj,
+               (mp_obj_t)&mp_const_none_obj,
+               (mp_obj_t)&mp_const_none_obj },
+};
+
+
+STATIC const mp_rom_map_elem_t wifi_network_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_ssid), MP_ROM_PTR(&wifi_network_ssid_obj) },
+    { MP_ROM_QSTR(MP_QSTR_rssi), MP_ROM_PTR(&wifi_network_rssi_obj) },
+    { MP_ROM_QSTR(MP_QSTR_channel), MP_ROM_PTR(&wifi_network_channel_obj) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(wifi_network_locals_dict, wifi_network_locals_dict_table);
+
+const mp_obj_type_t wifi_network_type = {
+    .base = { &mp_type_type },
+    .name = MP_QSTR_Network,
+    .locals_dict = (mp_obj_t)&wifi_network_locals_dict,
+};
diff --git a/shared-bindings/wifi/Network.h b/shared-bindings/wifi/Network.h
new file mode 100644
index 000000000..6a7f7be4a
--- /dev/null
+++ b/shared-bindings/wifi/Network.h
@@ -0,0 +1,42 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_WIFI_NETWORK_H
+#define MICROPY_INCLUDED_SHARED_BINDINGS_WIFI_NETWORK_H
+
+#include <stdint.h>
+
+#include "common-hal/wifi/Network.h"
+
+#include "py/objstr.h"
+
+const mp_obj_type_t wifi_network_type;
+
+extern mp_obj_t common_hal_wifi_network_get_ssid(wifi_network_obj_t *self);
+extern mp_obj_t common_hal_wifi_network_get_rssi(wifi_network_obj_t *self);
+extern mp_obj_t common_hal_wifi_network_get_channel(wifi_network_obj_t *self);
+
+#endif // MICROPY_INCLUDED_SHARED_BINDINGS_WIFI_NETWORK_H
diff --git a/shared-bindings/wifi/Radio.c b/shared-bindings/wifi/Radio.c
new file mode 100644
index 000000000..329dcb1b5
--- /dev/null
+++ b/shared-bindings/wifi/Radio.c
@@ -0,0 +1,224 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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 <string.h>
+
+#include "py/objproperty.h"
+#include "py/runtime.h"
+#include "shared-bindings/wifi/__init__.h"
+
+//| class Radio:
+//|     """Native wifi radio.
+//|
+//|        This class manages the station and access point functionality of the native
+//|        Wifi radio.
+//|
+//|     """
+//|
+
+//|     def __init__(self) -> None:
+//|         """You cannot create an instance of `wifi.Radio`.
+//|         Use `wifi.radio` to access the sole instance available."""
+//|         ...
+//|
+
+//|     enabled: bool
+//|     """True when the wifi radio is enabled."""
+//|
+STATIC mp_obj_t wifi_radio_get_enabled(mp_obj_t self) {
+    return mp_obj_new_bool(common_hal_wifi_radio_get_enabled(self));
+
+}
+MP_DEFINE_CONST_FUN_OBJ_1(wifi_radio_get_enabled_obj, wifi_radio_get_enabled);
+
+const mp_obj_property_t wifi_radio_enabled_obj = {
+    .base.type = &mp_type_property,
+    .proxy = { (mp_obj_t)&wifi_radio_get_enabled_obj,
+               (mp_obj_t)&mp_const_none_obj,
+               (mp_obj_t)&mp_const_none_obj },
+};
+
+//|     mac_address: bytes
+//|     """MAC address of the wifi radio. (read-only)"""
+//|
+STATIC mp_obj_t wifi_radio_get_mac_address(mp_obj_t self) {
+    return MP_OBJ_FROM_PTR(common_hal_wifi_radio_get_mac_address(self));
+
+}
+MP_DEFINE_CONST_FUN_OBJ_1(wifi_radio_get_mac_address_obj, wifi_radio_get_mac_address);
+
+const mp_obj_property_t wifi_radio_mac_address_obj = {
+    .base.type = &mp_type_property,
+    .proxy = { (mp_obj_t)&wifi_radio_get_mac_address_obj,
+               (mp_obj_t)&mp_const_none_obj,
+               (mp_obj_t)&mp_const_none_obj },
+};
+
+
+//|     def start_scanning_networks(self, *, start_channel=1, stop_channel=11) -> Iterable[Network]:
+//|         """Scans for available wifi networks over the given channel range. Make sure the channels are allowed in your country."""
+//|         ...
+//|
+STATIC mp_obj_t wifi_radio_start_scanning_networks(mp_obj_t self_in) {
+    wifi_radio_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+    return common_hal_wifi_radio_start_scanning_networks(self);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(wifi_radio_start_scanning_networks_obj, wifi_radio_start_scanning_networks);
+
+//|     def stop_scanning_networks(self) -> None:
+//|         """Stop scanning for Wifi networks and free any resources used to do it."""
+//|         ...
+//|
+STATIC mp_obj_t wifi_radio_stop_scanning_networks(mp_obj_t self_in) {
+    wifi_radio_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+    common_hal_wifi_radio_stop_scanning_networks(self);
+
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(wifi_radio_stop_scanning_networks_obj, wifi_radio_stop_scanning_networks);
+
+//|     def connect(self, ssid: ReadableBuffer, password: ReadableBuffer = b"", *, channel: Optional[int] = 0, timeout: Optional[float] = None) -> bool:
+//|         """Connects to the given ssid and waits for an ip address. Reconnections are handled
+//|            automatically once one connection succeeds."""
+//|         ...
+//|
+STATIC mp_obj_t wifi_radio_connect(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_ssid, ARG_password, ARG_channel, ARG_timeout };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_ssid, MP_ARG_REQUIRED | MP_ARG_OBJ },
+        { MP_QSTR_password,  MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_channel, MP_ARG_KW_ONLY |  MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+    };
+
+    wifi_radio_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    mp_float_t timeout = 0;
+    if (args[ARG_timeout].u_obj != mp_const_none) {
+        timeout = mp_obj_get_float(args[ARG_timeout].u_obj);
+    }
+
+
+    mp_buffer_info_t ssid;
+    mp_get_buffer_raise(args[ARG_ssid].u_obj, &ssid, MP_BUFFER_READ);
+
+    mp_buffer_info_t password;
+    password.len = 0;
+    if (args[ARG_password].u_obj != MP_OBJ_NULL) {
+        mp_get_buffer_raise(args[ARG_password].u_obj, &password, MP_BUFFER_READ);
+        if (password.len > 0 && (password.len < 8 || password.len > 63)) {
+            mp_raise_ValueError(translate("WiFi password must be between 8 and 63 characters"));
+        }
+    }
+
+    wifi_radio_error_t error = common_hal_wifi_radio_connect(self, ssid.buf, ssid.len, password.buf, password.len, args[ARG_channel].u_int, timeout);
+    if (error == WIFI_RADIO_ERROR_AUTH) {
+        mp_raise_ConnectionError(translate("Authentication failure"));
+    } else if (error == WIFI_RADIO_ERROR_NO_AP_FOUND) {
+        mp_raise_ConnectionError(translate("No network with that ssid"));
+    } else if (error != WIFI_RADIO_ERROR_NONE) {
+        mp_raise_ConnectionError(translate("Unknown failure"));
+    }
+
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(wifi_radio_connect_obj, 1, wifi_radio_connect);
+
+//|     ipv4_address: Optional[ipaddress.IPv4Address]
+//|     """IP v4 Address of the radio when connected to an access point. None otherwise."""
+//|
+STATIC mp_obj_t wifi_radio_get_ipv4_address(mp_obj_t self) {
+    return common_hal_wifi_radio_get_ipv4_address(self);
+
+}
+MP_DEFINE_CONST_FUN_OBJ_1(wifi_radio_get_ipv4_address_obj, wifi_radio_get_ipv4_address);
+
+const mp_obj_property_t wifi_radio_ipv4_address_obj = {
+    .base.type = &mp_type_property,
+    .proxy = { (mp_obj_t)&wifi_radio_get_ipv4_address_obj,
+               (mp_obj_t)&mp_const_none_obj,
+               (mp_obj_t)&mp_const_none_obj },
+};
+
+//|     def ping(self, ip, *, timeout: float = 0.5) -> float:
+//|         """Ping an IP to test connectivity. Returns echo time in seconds.
+//|            Returns None when it times out."""
+//|         ...
+//|
+STATIC mp_obj_t wifi_radio_ping(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_ip, ARG_timeout };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_ip, MP_ARG_REQUIRED | MP_ARG_OBJ, },
+        { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+    };
+
+    wifi_radio_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    mp_float_t timeout = 0.5;
+    if (args[ARG_timeout].u_obj != mp_const_none) {
+        timeout = mp_obj_get_float(args[ARG_timeout].u_obj);
+    }
+
+    mp_int_t time_ms = common_hal_wifi_radio_ping(self, args[ARG_ip].u_obj, timeout);
+    if (time_ms == -1) {
+        return mp_const_none;
+    }
+
+    return mp_obj_new_float(time_ms / 1000.0);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(wifi_radio_ping_obj, 1, wifi_radio_ping);
+
+STATIC const mp_rom_map_elem_t wifi_radio_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_enabled), MP_ROM_PTR(&wifi_radio_enabled_obj) },
+    { MP_ROM_QSTR(MP_QSTR_mac_address), MP_ROM_PTR(&wifi_radio_mac_address_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_start_scanning_networks),    MP_ROM_PTR(&wifi_radio_start_scanning_networks_obj) },
+    { MP_ROM_QSTR(MP_QSTR_stop_scanning_networks),    MP_ROM_PTR(&wifi_radio_stop_scanning_networks_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_connect),    MP_ROM_PTR(&wifi_radio_connect_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_connect_to_enterprise),    MP_ROM_PTR(&wifi_radio_connect_to_enterprise_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_ipv4_address),    MP_ROM_PTR(&wifi_radio_ipv4_address_obj) },
+
+    // { MP_ROM_QSTR(MP_QSTR_access_point_active),   MP_ROM_PTR(&wifi_radio_access_point_active_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_start_access_point), MP_ROM_PTR(&wifi_radio_start_access_point_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_ping), MP_ROM_PTR(&wifi_radio_ping_obj) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(wifi_radio_locals_dict, wifi_radio_locals_dict_table);
+
+const mp_obj_type_t wifi_radio_type = {
+    .base = { &mp_type_type },
+    .name = MP_QSTR_Radio,
+    .locals_dict = (mp_obj_t)&wifi_radio_locals_dict,
+};
diff --git a/shared-bindings/wifi/Radio.h b/shared-bindings/wifi/Radio.h
new file mode 100644
index 000000000..812814f9e
--- /dev/null
+++ b/shared-bindings/wifi/Radio.h
@@ -0,0 +1,60 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_WIFI_RADIO_H
+#define MICROPY_INCLUDED_SHARED_BINDINGS_WIFI_RADIO_H
+
+#include <stdint.h>
+
+#include "common-hal/wifi/Radio.h"
+
+#include "py/objstr.h"
+
+const mp_obj_type_t wifi_radio_type;
+
+
+typedef enum {
+    WIFI_RADIO_ERROR_NONE,
+    WIFI_RADIO_ERROR_UNKNOWN,
+    WIFI_RADIO_ERROR_AUTH,
+    WIFI_RADIO_ERROR_NO_AP_FOUND
+} wifi_radio_error_t;
+
+extern bool common_hal_wifi_radio_get_enabled(wifi_radio_obj_t *self);
+extern void common_hal_wifi_radio_set_enabled(wifi_radio_obj_t *self, bool enabled);
+
+extern mp_obj_t common_hal_wifi_radio_get_mac_address(wifi_radio_obj_t *self);
+
+extern mp_obj_t common_hal_wifi_radio_start_scanning_networks(wifi_radio_obj_t *self);
+extern void common_hal_wifi_radio_stop_scanning_networks(wifi_radio_obj_t *self);
+
+extern wifi_radio_error_t common_hal_wifi_radio_connect(wifi_radio_obj_t *self, uint8_t* ssid, size_t ssid_len, uint8_t* password, size_t password_len, uint8_t channel, mp_float_t timeout);
+
+extern mp_obj_t common_hal_wifi_radio_get_ipv4_address(wifi_radio_obj_t *self);
+
+extern mp_int_t common_hal_wifi_radio_ping(wifi_radio_obj_t *self, mp_obj_t ip_address, mp_float_t timeout);
+
+#endif // MICROPY_INCLUDED_SHARED_BINDINGS_WIFI_RADIO_H
diff --git a/shared-bindings/wifi/ScannedNetworks.c b/shared-bindings/wifi/ScannedNetworks.c
new file mode 100644
index 000000000..c927d7282
--- /dev/null
+++ b/shared-bindings/wifi/ScannedNetworks.c
@@ -0,0 +1,73 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Dan Halbert for Adafruit Industries
+ * Copyright (c) 2018 Artur Pacholec
+ * Copyright (c) 2017 Glenn Ruben Bakke
+ *
+ * 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 <string.h>
+
+#include "py/objproperty.h"
+#include "py/runtime.h"
+#include "shared-bindings/wifi/ScannedNetworks.h"
+
+#include "esp_log.h"
+static const char *TAG = "cp iternext";
+
+//| class ScannedNetworks:
+//|     """Iterates over all `wifi.Network` objects found while scanning. This object is always created
+//|     by a `wifi.Radio`: it has no user-visible constructor."""
+//|
+STATIC mp_obj_t scannednetworks_iternext(mp_obj_t self_in) {
+    mp_check_self(MP_OBJ_IS_TYPE(self_in, &wifi_scannednetworks_type));
+    wifi_scannednetworks_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_obj_t network = common_hal_wifi_scannednetworks_next(self);
+    if (network != mp_const_none) {
+        return network;
+    }
+
+    ESP_EARLY_LOGI(TAG, "stop iteration");
+    return MP_OBJ_STOP_ITERATION;
+}
+
+//|     def __init__(self) -> None:
+//|         """Cannot be instantiated directly. Use `wifi.Radio.start_scanning_networks`."""
+//|         ...
+//|
+//|     def __iter__(self) -> Iterator[Network]:
+//|         """Returns itself since it is the iterator."""
+//|         ...
+//|
+//|     def __next__(self) -> Network:
+//|         """Returns the next `wifi.Network`.
+//|            Raises `StopIteration` if scanning is finished and no other results are available."""
+//|         ...
+//|
+
+const mp_obj_type_t wifi_scannednetworks_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_ScannedNetworks,
+    .getiter = mp_identity_getiter,
+    .iternext = scannednetworks_iternext,
+};
diff --git a/shared-bindings/wifi/ScannedNetworks.h b/shared-bindings/wifi/ScannedNetworks.h
new file mode 100644
index 000000000..8e0aa435d
--- /dev/null
+++ b/shared-bindings/wifi/ScannedNetworks.h
@@ -0,0 +1,39 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Dan Halbert for Adafruit Industries
+ * Copyright (c) 2018 Artur Pacholec
+ * Copyright (c) 2017 Glenn Ruben Bakke
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_WIFI_SCANNEDNETWORKS_H
+#define MICROPY_INCLUDED_SHARED_BINDINGS_WIFI_SCANNEDNETWORKS_H
+
+#include "py/obj.h"
+#include "common-hal/wifi/ScannedNetworks.h"
+
+extern const mp_obj_type_t wifi_scannednetworks_type;
+
+mp_obj_t common_hal_wifi_scannednetworks_next(wifi_scannednetworks_obj_t *self);
+
+#endif // MICROPY_INCLUDED_SHARED_BINDINGS_WIFI_SCANNEDNETWORKS_H
diff --git a/shared-bindings/wifi/__init__.c b/shared-bindings/wifi/__init__.c
new file mode 100644
index 000000000..352ceb331
--- /dev/null
+++ b/shared-bindings/wifi/__init__.c
@@ -0,0 +1,70 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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 "py/objexcept.h"
+#include "py/runtime.h"
+#include "shared-bindings/wifi/__init__.h"
+#include "shared-bindings/wifi/Network.h"
+#include "shared-bindings/wifi/Radio.h"
+
+//| """
+//| The `wifi` module provides necessary low-level functionality for managing wifi
+//| wifi connections. Use `socketpool` for communicating over the network."""
+//|
+//| radio: Radio
+//| """Wifi radio used to manage both station and AP modes.
+//| This object is the sole instance of `wifi.Radio`."""
+//|
+
+
+// Called when wifi is imported.
+STATIC mp_obj_t wifi___init__(void) {
+    common_hal_wifi_init();
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(wifi___init___obj, wifi___init__);
+
+
+STATIC const mp_rom_map_elem_t wifi_module_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__),             MP_ROM_QSTR(MP_QSTR_wifi) },
+    { MP_ROM_QSTR(MP_QSTR_Network),              MP_ROM_PTR(&wifi_network_type) },
+    { MP_ROM_QSTR(MP_QSTR_Radio),                MP_ROM_PTR(&wifi_radio_type) },
+
+    // Properties
+    { MP_ROM_QSTR(MP_QSTR_radio),                MP_ROM_PTR(&common_hal_wifi_radio_obj) },
+
+    // Initialization
+    { MP_ROM_QSTR(MP_QSTR___init__),             MP_ROM_PTR(&wifi___init___obj) },
+
+};
+
+STATIC MP_DEFINE_CONST_DICT(wifi_module_globals, wifi_module_globals_table);
+
+
+const mp_obj_module_t wifi_module = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t*)&wifi_module_globals,
+};
diff --git a/shared-bindings/wifi/__init__.h b/shared-bindings/wifi/__init__.h
new file mode 100644
index 000000000..c06ee16be
--- /dev/null
+++ b/shared-bindings/wifi/__init__.h
@@ -0,0 +1,38 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_WIFI___INIT___H
+#define MICROPY_INCLUDED_SHARED_BINDINGS_WIFI___INIT___H
+
+#include "py/objlist.h"
+
+#include "shared-bindings/wifi/Radio.h"
+
+extern wifi_radio_obj_t common_hal_wifi_radio_obj;
+
+void common_hal_wifi_init(void);
+
+#endif // MICROPY_INCLUDED_SHARED_BINDINGS_WIFI___INIT___H
diff --git a/shared-module/ipaddress/IPv4Address.c b/shared-module/ipaddress/IPv4Address.c
new file mode 100644
index 000000000..f573d9d0a
--- /dev/null
+++ b/shared-module/ipaddress/IPv4Address.c
@@ -0,0 +1,39 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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 "py/obj.h"
+
+#include "shared-bindings/ipaddress/__init__.h"
+#include "shared-bindings/ipaddress/IPv4Address.h"
+
+
+void common_hal_ipaddress_ipv4address_construct(ipaddress_ipv4address_obj_t* self, uint8_t* buf, size_t len) {
+    self->ip_bytes = mp_obj_new_bytes(buf, len);
+}
+
+mp_obj_t common_hal_ipaddress_ipv4address_get_packed(ipaddress_ipv4address_obj_t* self) {
+    return self->ip_bytes;
+}
diff --git a/shared-module/ipaddress/IPv4Address.h b/shared-module/ipaddress/IPv4Address.h
new file mode 100644
index 000000000..3f2bde091
--- /dev/null
+++ b/shared-module/ipaddress/IPv4Address.h
@@ -0,0 +1,37 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_SHARED_MODULE_IPADDRESS_IPV4ADDRESS_H
+#define MICROPY_INCLUDED_SHARED_MODULE_IPADDRESS_IPV4ADDRESS_H
+
+#include "py/obj.h"
+
+typedef struct {
+    mp_obj_base_t base;
+    mp_obj_t ip_bytes;
+} ipaddress_ipv4address_obj_t;
+
+#endif // MICROPY_INCLUDED_SHARED_MODULE_IPADDRESS_IPV4ADDRESS_H
diff --git a/shared-module/ipaddress/__init__.c b/shared-module/ipaddress/__init__.c
new file mode 100644
index 000000000..a8f8e1caf
--- /dev/null
+++ b/shared-module/ipaddress/__init__.c
@@ -0,0 +1,35 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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/ipaddress/__init__.h"
+#include "shared-bindings/ipaddress/IPv4Address.h"
+
+mp_obj_t common_hal_ipaddress_new_ipv4address(uint32_t value) {
+    ipaddress_ipv4address_obj_t* self = m_new_obj(ipaddress_ipv4address_obj_t);
+    self->base.type = &ipaddress_ipv4address_type;
+    common_hal_ipaddress_ipv4address_construct(self, (uint8_t*) &value, 4);
+    return MP_OBJ_FROM_PTR(self);
+}
diff --git a/shared-module/ipaddress/__init__.h b/shared-module/ipaddress/__init__.h
new file mode 100644
index 000000000..7d5f2c220
--- /dev/null
+++ b/shared-module/ipaddress/__init__.h
@@ -0,0 +1,36 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_SHARED_MODULE_IPADDRESS___INIT___H
+#define MICROPY_INCLUDED_SHARED_MODULE_IPADDRESS___INIT___H
+
+#include <stdint.h>
+
+#include "py/obj.h"
+
+mp_obj_t common_hal_ipaddress_new_ipv4(uint32_t value);
+
+#endif // MICROPY_INCLUDED_SHARED_MODULE_IPADDRESS___INIT___H
diff --git a/supervisor/port.h b/supervisor/port.h
index ad5b3cf32..ddb96bd52 100644
--- a/supervisor/port.h
+++ b/supervisor/port.h
@@ -69,6 +69,8 @@ uint32_t *port_heap_get_bottom(void);
 // Get heap top address
 uint32_t *port_heap_get_top(void);
 
+supervisor_allocation* port_fixed_heap(void);
+
 // Save and retrieve a word from memory that is preserved over reset. Used for safe mode.
 void port_set_saved_word(uint32_t);
 uint32_t port_get_saved_word(void);
diff --git a/supervisor/shared/safe_mode.c b/supervisor/shared/safe_mode.c
index 3275cc66f..29a0a6a4f 100644
--- a/supervisor/shared/safe_mode.c
+++ b/supervisor/shared/safe_mode.c
@@ -133,6 +133,10 @@ void print_safe_mode_message(safe_mode_t reason) {
                 serial_write_compressed(translate("The CircuitPython heap was corrupted because the stack was too small.\nPlease increase the stack size if you know how, or if not:"));
                 serial_write_compressed(FILE_AN_ISSUE);
                 return;
+            case NO_HEAP:
+                serial_write_compressed(translate("CircuitPython was unable to allocate the heap.\n"));
+                serial_write_compressed(FILE_AN_ISSUE);
+                return;
             default:
                 break;
         }
diff --git a/supervisor/shared/safe_mode.h b/supervisor/shared/safe_mode.h
index c160739ae..7d3cd63b5 100644
--- a/supervisor/shared/safe_mode.h
+++ b/supervisor/shared/safe_mode.h
@@ -42,6 +42,7 @@ typedef enum {
   FLASH_WRITE_FAIL,
   MEM_MANAGE,
   WATCHDOG_RESET,
+  NO_HEAP,
 } safe_mode_t;
 
 safe_mode_t wait_for_safe_mode_reset(void);