Merge remote-tracking branch 'adafruit/main' into native_wifi

14 files changed, 326 insertions, 111 deletions

diff --git a/shared-bindings/_bleio/Adapter.h b/shared-bindings/_bleio/Adapter.h
index 352373357..c56dbb01c 100644
--- a/shared-bindings/_bleio/Adapter.h
+++ b/shared-bindings/_bleio/Adapter.h
@@ -35,7 +35,7 @@
 #include "py/objstr.h"
 #include "shared-module/_bleio/Address.h"
 
-const mp_obj_type_t bleio_adapter_type;
+extern const mp_obj_type_t bleio_adapter_type;
 
 extern bool common_hal_bleio_adapter_get_advertising(bleio_adapter_obj_t *self);
 extern bool common_hal_bleio_adapter_get_enabled(bleio_adapter_obj_t *self);
diff --git a/shared-bindings/_bleio/Service.h b/shared-bindings/_bleio/Service.h
index 273c6bd98..3af427f95 100644
--- a/shared-bindings/_bleio/Service.h
+++ b/shared-bindings/_bleio/Service.h
@@ -34,7 +34,7 @@
 
 #include "py/objtuple.h"
 
-const mp_obj_type_t bleio_service_type;
+extern const mp_obj_type_t bleio_service_type;
 
 // Private version that doesn't allocate on the heap
 extern uint32_t _common_hal_bleio_service_construct(bleio_service_obj_t *self, bleio_uuid_obj_t *uuid, bool is_secondary, mp_obj_list_t * characteristic_list);
diff --git a/shared-bindings/displayio/Bitmap.c b/shared-bindings/displayio/Bitmap.c
index 0a45bbdfd..5a2fc785f 100644
--- a/shared-bindings/displayio/Bitmap.c
+++ b/shared-bindings/displayio/Bitmap.c
@@ -172,7 +172,109 @@ STATIC mp_obj_t bitmap_subscr(mp_obj_t self_in, mp_obj_t index_obj, mp_obj_t val
     return mp_const_none;
 }
 
-//|     def fill(self, value: int) -> None:
+//|     def blit(self, x: int, y: int, source_bitmap: bitmap, *, x1: int, y1: int, x2: int, y2: int, skip_index: int) -> None:
+//|         """Inserts the source_bitmap region defined by rectangular boundaries
+//|                     (x1,y1) and (x2,y2) into the bitmap at the specified (x,y) location.
+//|
+//|         :param int x: Horizontal pixel location in bitmap where source_bitmap upper-left
+//|                       corner will be placed
+//|         :param int y: Vertical pixel location in bitmap where source_bitmap upper-left
+//|                       corner will be placed
+//|         :param bitmap source_bitmap: Source bitmap that contains the graphical region to be copied
+//|         :param int x1: Minimum x-value for rectangular bounding box to be copied from the source bitmap
+//|         :param int y1: Minimum y-value for rectangular bounding box to be copied from the source bitmap
+//|         :param int x2: Maximum x-value (exclusive) for rectangular bounding box to be copied from the source bitmap
+//|         :param int y2: Maximum y-value (exclusive) for rectangular bounding box to be copied from the source bitmap
+//|         :param int skip_index: bitmap palette index in the source that will not be copied,
+//|                                set to None to copy all pixels"""
+//|         ...
+//|
+STATIC mp_obj_t displayio_bitmap_obj_blit(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args){
+    enum {ARG_x, ARG_y, ARG_source, ARG_x1, ARG_y1, ARG_x2, ARG_y2, ARG_skip_index};
+    static const mp_arg_t allowed_args[] = {
+        {MP_QSTR_x, MP_ARG_REQUIRED | MP_ARG_INT},
+        {MP_QSTR_y, MP_ARG_REQUIRED | MP_ARG_INT},
+        {MP_QSTR_source_bitmap, MP_ARG_REQUIRED | MP_ARG_OBJ},
+        {MP_QSTR_x1, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
+        {MP_QSTR_y1, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
+        {MP_QSTR_x2, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} }, // None convert to source->width
+        {MP_QSTR_y2, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} }, // None convert to source->height
+        {MP_QSTR_skip_index, MP_ARG_OBJ | MP_ARG_KW_ONLY, {.u_obj=mp_const_none} },
+    };
+    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);
+
+    displayio_bitmap_t *self = MP_OBJ_TO_PTR(pos_args[0]);
+
+    int16_t x = args[ARG_x].u_int;
+    int16_t y = args[ARG_y].u_int;
+
+    displayio_bitmap_t *source = MP_OBJ_TO_PTR(args[ARG_source].u_obj);
+
+    // ensure that the target bitmap (self) has at least as many `bits_per_value` as the source
+    if (self->bits_per_value < source->bits_per_value) {
+        mp_raise_ValueError(translate("source palette too large"));
+    }
+
+    int16_t x1 = args[ARG_x1].u_int;
+    int16_t y1 = args[ARG_y1].u_int;
+    int16_t x2, y2;
+    // if x2 or y2 is None, then set as the maximum size of the source bitmap
+    if ( args[ARG_x2].u_obj == mp_const_none ) {
+        x2 = source->width;
+    } else {
+        x2 = mp_obj_get_int(args[ARG_x2].u_obj);
+    }
+    //int16_t y2;
+    if ( args[ARG_y2].u_obj == mp_const_none ) {
+        y2 = source->height;
+    } else {
+        y2 = mp_obj_get_int(args[ARG_y2].u_obj);
+    }
+
+    // Check x,y are within self (target) bitmap boundary
+    if ( (x < 0) || (y < 0) || (x > self->width) || (y > self->height) ) {
+            mp_raise_ValueError(translate("out of range of target"));
+    }
+    // Check x1,y1,x2,y2 are within source bitmap boundary
+    if ( (x1 < 0) || (x1 > source->width)  ||
+        (y1 < 0) || (y1 > source->height) ||
+        (x2 < 0) || (x2 > source->width)  ||
+        (y2 < 0) || (y2 > source->height) ) {
+            mp_raise_ValueError(translate("out of range of source"));
+    }
+
+    // Ensure x1 < x2 and y1 < y2
+    if (x1 > x2) {
+        int16_t temp=x2;
+        x2=x1;
+        x1=temp;
+    }
+    if (y1 > y2) {
+        int16_t temp=y2;
+        y2=y1;
+        y1=temp;
+    }
+
+    uint32_t skip_index;
+    bool skip_index_none; // flag whether skip_value was None
+
+    if (args[ARG_skip_index].u_obj == mp_const_none ) {
+        skip_index = 0;
+        skip_index_none = true;
+    } else {
+        skip_index = mp_obj_get_int(args[ARG_skip_index].u_obj);
+        skip_index_none = false;
+    }
+
+    common_hal_displayio_bitmap_blit(self, x, y, source, x1, y1, x2, y2, skip_index, skip_index_none);
+
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_KW(displayio_bitmap_blit_obj, 4, displayio_bitmap_obj_blit);
+// `displayio_bitmap_obj_blit` requires at least 4 arguments
+
+//|     def fill(self, value: Any) -> None:
 //|         """Fills the bitmap with the supplied palette index value."""
 //|         ...
 //|
@@ -192,6 +294,7 @@ MP_DEFINE_CONST_FUN_OBJ_2(displayio_bitmap_fill_obj, displayio_bitmap_obj_fill);
 STATIC const mp_rom_map_elem_t displayio_bitmap_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_height), MP_ROM_PTR(&displayio_bitmap_height_obj) },
     { MP_ROM_QSTR(MP_QSTR_width), MP_ROM_PTR(&displayio_bitmap_width_obj) },
+    { MP_ROM_QSTR(MP_QSTR_blit), MP_ROM_PTR(&displayio_bitmap_blit_obj) },
     { MP_ROM_QSTR(MP_QSTR_fill), MP_ROM_PTR(&displayio_bitmap_fill_obj) },
 
 };
diff --git a/shared-bindings/displayio/Bitmap.h b/shared-bindings/displayio/Bitmap.h
index 46c337329..00cd98b0a 100644
--- a/shared-bindings/displayio/Bitmap.h
+++ b/shared-bindings/displayio/Bitmap.h
@@ -40,6 +40,9 @@ uint16_t common_hal_displayio_bitmap_get_height(displayio_bitmap_t *self);
 uint16_t common_hal_displayio_bitmap_get_width(displayio_bitmap_t *self);
 uint32_t common_hal_displayio_bitmap_get_bits_per_value(displayio_bitmap_t *self);
 void common_hal_displayio_bitmap_set_pixel(displayio_bitmap_t *bitmap, int16_t x, int16_t y, uint32_t value);
+void common_hal_displayio_bitmap_blit(displayio_bitmap_t *self, int16_t x, int16_t y, displayio_bitmap_t *source,
+                                        int16_t x1, int16_t y1, int16_t x2, int16_t y2,
+                                        uint32_t skip_index, bool skip_index_none);
 uint32_t common_hal_displayio_bitmap_get_pixel(displayio_bitmap_t *bitmap, int16_t x, int16_t y);
 void common_hal_displayio_bitmap_fill(displayio_bitmap_t *bitmap, uint32_t value);
 
diff --git a/shared-bindings/gnss/PositionFix.h b/shared-bindings/gnss/PositionFix.h
index 34090872c..0fd595fc6 100644
--- a/shared-bindings/gnss/PositionFix.h
+++ b/shared-bindings/gnss/PositionFix.h
@@ -13,7 +13,7 @@ typedef enum {
     POSITIONFIX_3D,
 } gnss_positionfix_t;
 
-const mp_obj_type_t gnss_positionfix_type;
+extern const mp_obj_type_t gnss_positionfix_type;
 
 gnss_positionfix_t gnss_positionfix_obj_to_type(mp_obj_t obj);
 mp_obj_t gnss_positionfix_type_to_obj(gnss_positionfix_t mode);
diff --git a/shared-bindings/gnss/SatelliteSystem.h b/shared-bindings/gnss/SatelliteSystem.h
index 17f155002..02cd17db2 100644
--- a/shared-bindings/gnss/SatelliteSystem.h
+++ b/shared-bindings/gnss/SatelliteSystem.h
@@ -16,7 +16,7 @@ typedef enum {
     SATELLITESYSTEM_QZSS_L1S   = (1U << 4),
 } gnss_satellitesystem_t;
 
-const mp_obj_type_t gnss_satellitesystem_type;
+extern const mp_obj_type_t gnss_satellitesystem_type;
 
 gnss_satellitesystem_t gnss_satellitesystem_obj_to_type(mp_obj_t obj);
 mp_obj_t gnss_satellitesystem_type_to_obj(gnss_satellitesystem_t mode);
diff --git a/shared-bindings/pulseio/PulseOut.c b/shared-bindings/pulseio/PulseOut.c
index 3d35f0544..2b787df4f 100644
--- a/shared-bindings/pulseio/PulseOut.c
+++ b/shared-bindings/pulseio/PulseOut.c
@@ -32,7 +32,7 @@
 
 #include "shared-bindings/microcontroller/Pin.h"
 #include "shared-bindings/pulseio/PulseOut.h"
-#include "shared-bindings/pulseio/PWMOut.h"
+#include "shared-bindings/pwmio/PWMOut.h"
 #include "shared-bindings/util.h"
 #include "supervisor/shared/translate.h"
 
@@ -41,19 +41,20 @@
 //|        pulsed signal consists of timed on and off periods. Unlike PWM, there is no set duration
 //|        for on and off pairs."""
 //|
-//|     def __init__(self, carrier: PWMOut) -> None:
+//|     def __init__(self, carrier: pwmio.PWMOut) -> None:
 //|         """Create a PulseOut object associated with the given PWMout object.
 //|
-//|         :param ~pulseio.PWMOut carrier: PWMOut that is set to output on the desired pin.
+//|         :param ~pwmio.PWMOut carrier: PWMOut that is set to output on the desired pin.
 //|
 //|         Send a short series of pulses::
 //|
 //|           import array
 //|           import pulseio
+//|           import pwmio
 //|           import board
 //|
 //|           # 50% duty cycle at 38kHz.
-//|           pwm = pulseio.PWMOut(board.D13, frequency=38000, duty_cycle=32768)
+//|           pwm = pwmio.PWMOut(board.D13, frequency=38000, duty_cycle=32768)
 //|           pulse = pulseio.PulseOut(pwm)
 //|           #                             on   off     on    off    on
 //|           pulses = array.array('H', [65000, 1000, 65000, 65000, 1000])
@@ -64,20 +65,28 @@
 //|           pulse.send(pulses)"""
 //|         ...
 //|
-STATIC mp_obj_t pulseio_pulseout_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);
-    mp_obj_t carrier_obj = args[0];
-
-    if (!MP_OBJ_IS_TYPE(carrier_obj, &pulseio_pwmout_type)) {
-        mp_raise_TypeError_varg(translate("Expected a %q"), pulseio_pwmout_type.name);
-    }
-
-    // create Pulse object from the given pin
+STATIC mp_obj_t pulseio_pulseout_make_new(const mp_obj_type_t *type, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     pulseio_pulseout_obj_t *self = m_new_obj(pulseio_pulseout_obj_t);
     self->base.type = &pulseio_pulseout_type;
 
-    common_hal_pulseio_pulseout_construct(self, (pulseio_pwmout_obj_t *)MP_OBJ_TO_PTR(carrier_obj));
-
+    mp_obj_t carrier_obj = pos_args[0];
+    if (MP_OBJ_IS_TYPE(carrier_obj, &pwmio_pwmout_type)) {
+        // Use a PWMOut Carrier
+        mp_arg_check_num(n_args, kw_args, 1, 1, false);
+        common_hal_pulseio_pulseout_construct(self, (pwmio_pwmout_obj_t *)MP_OBJ_TO_PTR(carrier_obj), NULL, 0, 0);
+    } else {
+        // Use a Pin, frequency, and duty cycle
+        enum { ARG_pin, ARG_frequency};
+        static const mp_arg_t allowed_args[] = {
+            { MP_QSTR_pin, MP_ARG_REQUIRED | MP_ARG_OBJ },
+            { MP_QSTR_frequency, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 38000} },
+            { MP_QSTR_duty_cycle, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1<<15} },
+        };
+        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 mcu_pin_obj_t* pin = validate_obj_is_free_pin(args[ARG_pin].u_obj);
+        common_hal_pulseio_pulseout_construct(self, NULL, pin, args[ARG_frequency].u_int, args[ARG_frequency].u_int);
+    }
     return MP_OBJ_FROM_PTR(self);
 }
 
diff --git a/shared-bindings/pulseio/PulseOut.h b/shared-bindings/pulseio/PulseOut.h
index 390910ff6..49dc555fe 100644
--- a/shared-bindings/pulseio/PulseOut.h
+++ b/shared-bindings/pulseio/PulseOut.h
@@ -29,12 +29,16 @@
 
 #include "common-hal/microcontroller/Pin.h"
 #include "common-hal/pulseio/PulseOut.h"
-#include "common-hal/pulseio/PWMOut.h"
+#include "common-hal/pwmio/PWMOut.h"
 
 extern const mp_obj_type_t pulseio_pulseout_type;
 
 extern void common_hal_pulseio_pulseout_construct(pulseio_pulseout_obj_t* self,
-    const pulseio_pwmout_obj_t* carrier);
+                                            const pwmio_pwmout_obj_t* carrier,
+                                            const mcu_pin_obj_t* pin,
+                                            uint32_t frequency,
+                                            uint16_t duty_cycle);
+
 extern void common_hal_pulseio_pulseout_deinit(pulseio_pulseout_obj_t* self);
 extern bool common_hal_pulseio_pulseout_deinited(pulseio_pulseout_obj_t* self);
 extern void common_hal_pulseio_pulseout_send(pulseio_pulseout_obj_t* self,
diff --git a/shared-bindings/pulseio/__init__.c b/shared-bindings/pulseio/__init__.c
index 87946e5f0..bfe9635f0 100644
--- a/shared-bindings/pulseio/__init__.c
+++ b/shared-bindings/pulseio/__init__.c
@@ -33,40 +33,29 @@
 #include "shared-bindings/pulseio/__init__.h"
 #include "shared-bindings/pulseio/PulseIn.h"
 #include "shared-bindings/pulseio/PulseOut.h"
-#include "shared-bindings/pulseio/PWMOut.h"
+#include "shared-bindings/pwmio/PWMOut.h"
 
-//| """Support for pulse based protocols
+//| """Support for individual pulse based protocols
 //|
 //| The `pulseio` module contains classes to provide access to basic pulse IO.
+//| Individual pulses are commonly used in infrared remotes and in DHT
+//| temperature sensors.
+//|
+//|
+//| .. warning:: PWMOut is moving to `pwmio` and will be removed from `pulseio`
+//|    in CircuitPython 7.
 //|
-
 //| All classes change hardware state and should be deinitialized when they
 //| are no longer needed if the program continues after use. To do so, either
 //| call :py:meth:`!deinit` or use a context manager. See
-//| :ref:`lifetime-and-contextmanagers` for more info.
-//|
-//| For example::
-//|
-//|   import pulseio
-//|   import time
-//|   from board import *
-//|
-//|   pwm = pulseio.PWMOut(D13)
-//|   pwm.duty_cycle = 2 ** 15
-//|   time.sleep(0.1)
-//|
-//| This example will initialize the the device, set
-//| :py:data:`~pulseio.PWMOut.duty_cycle`, and then sleep 0.1 seconds.
-//| CircuitPython will automatically turn off the PWM when it resets all
-//| hardware after program completion. Use ``deinit()`` or a ``with`` statement
-//| to do it yourself."""
+//| :ref:`lifetime-and-contextmanagers` for more info."""
 //|
 
 STATIC const mp_rom_map_elem_t pulseio_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_pulseio) },
     { MP_ROM_QSTR(MP_QSTR_PulseIn), MP_ROM_PTR(&pulseio_pulsein_type) },
     { MP_ROM_QSTR(MP_QSTR_PulseOut), MP_ROM_PTR(&pulseio_pulseout_type) },
-    { MP_ROM_QSTR(MP_QSTR_PWMOut), MP_ROM_PTR(&pulseio_pwmout_type) },
+    { MP_ROM_QSTR(MP_QSTR_PWMOut), MP_ROM_PTR(&pwmio_pwmout_type) },
 };
 
 STATIC MP_DEFINE_CONST_DICT(pulseio_module_globals, pulseio_module_globals_table);
diff --git a/shared-bindings/pulseio/PWMOut.c b/shared-bindings/pwmio/PWMOut.c
index e9b6c45d2..da0755592 100644
--- a/shared-bindings/pulseio/PWMOut.c
+++ b/shared-bindings/pwmio/PWMOut.c
@@ -31,7 +31,7 @@
 #include "py/runtime.h"
 
 #include "shared-bindings/microcontroller/Pin.h"
-#include "shared-bindings/pulseio/PWMOut.h"
+#include "shared-bindings/pwmio/PWMOut.h"
 #include "shared-bindings/util.h"
 #include "supervisor/shared/translate.h"
 
@@ -55,33 +55,33 @@
 //|
 //|         Simple LED fade::
 //|
-//|           import pulseio
+//|           import pwmio
 //|           import board
 //|
-//|           pwm = pulseio.PWMOut(board.D13)     # output on D13
+//|           pwm = pwmio.PWMOut(board.D13)     # output on D13
 //|           pwm.duty_cycle = 2 ** 15            # Cycles the pin with 50% duty cycle (half of 2 ** 16) at the default 500hz
 //|
 //|         PWM at specific frequency (servos and motors)::
 //|
-//|           import pulseio
+//|           import pwmio
 //|           import board
 //|
-//|           pwm = pulseio.PWMOut(board.D13, frequency=50)
+//|           pwm = pwmio.PWMOut(board.D13, frequency=50)
 //|           pwm.duty_cycle = 2 ** 15                  # Cycles the pin with 50% duty cycle (half of 2 ** 16) at 50hz
 //|
 //|         Variable frequency (usually tones)::
 //|
-//|           import pulseio
+//|           import pwmio
 //|           import board
 //|           import time
 //|
-//|           pwm = pulseio.PWMOut(board.D13, duty_cycle=2 ** 15, frequency=440, variable_frequency=True)
+//|           pwm = pwmio.PWMOut(board.D13, duty_cycle=2 ** 15, frequency=440, variable_frequency=True)
 //|           time.sleep(0.2)
 //|           pwm.frequency = 880
 //|           time.sleep(0.1)"""
 //|         ...
 //|
-STATIC mp_obj_t pulseio_pwmout_make_new(const mp_obj_type_t *type, size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
+STATIC mp_obj_t pwmio_pwmout_make_new(const mp_obj_type_t *type, size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
     enum { ARG_pin, ARG_duty_cycle, ARG_frequency, ARG_variable_frequency };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_pin, MP_ARG_REQUIRED | MP_ARG_OBJ, },
@@ -99,9 +99,9 @@ STATIC mp_obj_t pulseio_pwmout_make_new(const mp_obj_type_t *type, size_t n_args
     bool variable_frequency = parsed_args[ARG_variable_frequency].u_bool;
 
     // create PWM object from the given pin
-    pulseio_pwmout_obj_t *self = m_new_obj(pulseio_pwmout_obj_t);
-    self->base.type = &pulseio_pwmout_type;
-    pwmout_result_t result = common_hal_pulseio_pwmout_construct(self, pin, duty_cycle, frequency, variable_frequency);
+    pwmio_pwmout_obj_t *self = m_new_obj(pwmio_pwmout_obj_t);
+    self->base.type = &pwmio_pwmout_type;
+    pwmout_result_t result = common_hal_pwmio_pwmout_construct(self, pin, duty_cycle, frequency, variable_frequency);
     if (result == PWMOUT_INVALID_PIN) {
         mp_raise_ValueError(translate("Invalid pin"));
     } else if (result == PWMOUT_INVALID_FREQUENCY) {
@@ -119,15 +119,15 @@ STATIC mp_obj_t pulseio_pwmout_make_new(const mp_obj_type_t *type, size_t n_args
 //|         """Deinitialises the PWMOut and releases any hardware resources for reuse."""
 //|         ...
 //|
-STATIC mp_obj_t pulseio_pwmout_deinit(mp_obj_t self_in) {
-    pulseio_pwmout_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    common_hal_pulseio_pwmout_deinit(self);
+STATIC mp_obj_t pwmio_pwmout_deinit(mp_obj_t self_in) {
+    pwmio_pwmout_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_pwmio_pwmout_deinit(self);
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(pulseio_pwmout_deinit_obj, pulseio_pwmout_deinit);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(pwmio_pwmout_deinit_obj, pwmio_pwmout_deinit);
 
-STATIC void check_for_deinit(pulseio_pwmout_obj_t *self) {
-    if (common_hal_pulseio_pwmout_deinited(self)) {
+STATIC void check_for_deinit(pwmio_pwmout_obj_t *self) {
+    if (common_hal_pwmio_pwmout_deinited(self)) {
         raise_deinited_error();
     }
 }
@@ -143,12 +143,12 @@ STATIC void check_for_deinit(pulseio_pwmout_obj_t *self) {
 //|         :ref:`lifetime-and-contextmanagers` for more info."""
 //|         ...
 //|
-STATIC mp_obj_t pulseio_pwmout_obj___exit__(size_t n_args, const mp_obj_t *args) {
+STATIC mp_obj_t pwmio_pwmout_obj___exit__(size_t n_args, const mp_obj_t *args) {
     (void)n_args;
-    common_hal_pulseio_pwmout_deinit(args[0]);
+    common_hal_pwmio_pwmout_deinit(args[0]);
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pulseio_pwmout___exit___obj, 4, 4, pulseio_pwmout_obj___exit__);
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pwmio_pwmout___exit___obj, 4, 4, pwmio_pwmout_obj___exit__);
 
 //|     duty_cycle: int
 //|     """16 bit value that dictates how much of one cycle is high (1) versus low
@@ -160,29 +160,29 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pulseio_pwmout___exit___obj, 4, 4, pu
 //|     Reading this property will return the value from the internal representation,
 //|     so it may differ from the value set."""
 //|
-STATIC mp_obj_t pulseio_pwmout_obj_get_duty_cycle(mp_obj_t self_in) {
-    pulseio_pwmout_obj_t *self = MP_OBJ_TO_PTR(self_in);
+STATIC mp_obj_t pwmio_pwmout_obj_get_duty_cycle(mp_obj_t self_in) {
+    pwmio_pwmout_obj_t *self = MP_OBJ_TO_PTR(self_in);
     check_for_deinit(self);
-    return MP_OBJ_NEW_SMALL_INT(common_hal_pulseio_pwmout_get_duty_cycle(self));
+    return MP_OBJ_NEW_SMALL_INT(common_hal_pwmio_pwmout_get_duty_cycle(self));
 }
-MP_DEFINE_CONST_FUN_OBJ_1(pulseio_pwmout_get_duty_cycle_obj, pulseio_pwmout_obj_get_duty_cycle);
+MP_DEFINE_CONST_FUN_OBJ_1(pwmio_pwmout_get_duty_cycle_obj, pwmio_pwmout_obj_get_duty_cycle);
 
-STATIC mp_obj_t pulseio_pwmout_obj_set_duty_cycle(mp_obj_t self_in, mp_obj_t duty_cycle) {
-    pulseio_pwmout_obj_t *self = MP_OBJ_TO_PTR(self_in);
+STATIC mp_obj_t pwmio_pwmout_obj_set_duty_cycle(mp_obj_t self_in, mp_obj_t duty_cycle) {
+    pwmio_pwmout_obj_t *self = MP_OBJ_TO_PTR(self_in);
     check_for_deinit(self);
     mp_int_t duty = mp_obj_get_int(duty_cycle);
     if (duty < 0 || duty > 0xffff) {
         mp_raise_ValueError(translate("PWM duty_cycle must be between 0 and 65535 inclusive (16 bit resolution)"));
     }
-   common_hal_pulseio_pwmout_set_duty_cycle(self, duty);
+   common_hal_pwmio_pwmout_set_duty_cycle(self, duty);
    return mp_const_none;
 }
-MP_DEFINE_CONST_FUN_OBJ_2(pulseio_pwmout_set_duty_cycle_obj, pulseio_pwmout_obj_set_duty_cycle);
+MP_DEFINE_CONST_FUN_OBJ_2(pwmio_pwmout_set_duty_cycle_obj, pwmio_pwmout_obj_set_duty_cycle);
 
-const mp_obj_property_t pulseio_pwmout_duty_cycle_obj = {
+const mp_obj_property_t pwmio_pwmout_duty_cycle_obj = {
     .base.type = &mp_type_property,
-    .proxy = {(mp_obj_t)&pulseio_pwmout_get_duty_cycle_obj,
-              (mp_obj_t)&pulseio_pwmout_set_duty_cycle_obj,
+    .proxy = {(mp_obj_t)&pwmio_pwmout_get_duty_cycle_obj,
+              (mp_obj_t)&pwmio_pwmout_set_duty_cycle_obj,
               (mp_obj_t)&mp_const_none_obj},
 };
 
@@ -196,50 +196,50 @@ const mp_obj_property_t pulseio_pwmout_duty_cycle_obj = {
 //|     from the original duty cycle value. This should happen without any need
 //|     to manually re-set the duty cycle."""
 //|
-STATIC mp_obj_t pulseio_pwmout_obj_get_frequency(mp_obj_t self_in) {
-    pulseio_pwmout_obj_t *self = MP_OBJ_TO_PTR(self_in);
+STATIC mp_obj_t pwmio_pwmout_obj_get_frequency(mp_obj_t self_in) {
+    pwmio_pwmout_obj_t *self = MP_OBJ_TO_PTR(self_in);
     check_for_deinit(self);
-    return MP_OBJ_NEW_SMALL_INT(common_hal_pulseio_pwmout_get_frequency(self));
+    return MP_OBJ_NEW_SMALL_INT(common_hal_pwmio_pwmout_get_frequency(self));
 }
-MP_DEFINE_CONST_FUN_OBJ_1(pulseio_pwmout_get_frequency_obj, pulseio_pwmout_obj_get_frequency);
+MP_DEFINE_CONST_FUN_OBJ_1(pwmio_pwmout_get_frequency_obj, pwmio_pwmout_obj_get_frequency);
 
-STATIC mp_obj_t pulseio_pwmout_obj_set_frequency(mp_obj_t self_in, mp_obj_t frequency) {
-    pulseio_pwmout_obj_t *self = MP_OBJ_TO_PTR(self_in);
+STATIC mp_obj_t pwmio_pwmout_obj_set_frequency(mp_obj_t self_in, mp_obj_t frequency) {
+    pwmio_pwmout_obj_t *self = MP_OBJ_TO_PTR(self_in);
     check_for_deinit(self);
-    if (!common_hal_pulseio_pwmout_get_variable_frequency(self)) {
+    if (!common_hal_pwmio_pwmout_get_variable_frequency(self)) {
         mp_raise_AttributeError(translate(
             "PWM frequency not writable when variable_frequency is False on "
             "construction."));
     }
-   common_hal_pulseio_pwmout_set_frequency(self, mp_obj_get_int(frequency));
+   common_hal_pwmio_pwmout_set_frequency(self, mp_obj_get_int(frequency));
    return mp_const_none;
 }
-MP_DEFINE_CONST_FUN_OBJ_2(pulseio_pwmout_set_frequency_obj, pulseio_pwmout_obj_set_frequency);
+MP_DEFINE_CONST_FUN_OBJ_2(pwmio_pwmout_set_frequency_obj, pwmio_pwmout_obj_set_frequency);
 
-const mp_obj_property_t pulseio_pwmout_frequency_obj = {
+const mp_obj_property_t pwmio_pwmout_frequency_obj = {
     .base.type = &mp_type_property,
-    .proxy = {(mp_obj_t)&pulseio_pwmout_get_frequency_obj,
-              (mp_obj_t)&pulseio_pwmout_set_frequency_obj,
+    .proxy = {(mp_obj_t)&pwmio_pwmout_get_frequency_obj,
+              (mp_obj_t)&pwmio_pwmout_set_frequency_obj,
               (mp_obj_t)&mp_const_none_obj},
 };
 
-STATIC const mp_rom_map_elem_t pulseio_pwmout_locals_dict_table[] = {
+STATIC const mp_rom_map_elem_t pwmio_pwmout_locals_dict_table[] = {
     // Methods
-    { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&pulseio_pwmout_deinit_obj) },
+    { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&pwmio_pwmout_deinit_obj) },
     { MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&default___enter___obj) },
-    { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&pulseio_pwmout___exit___obj) },
+    { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&pwmio_pwmout___exit___obj) },
 
     // Properties
-    { MP_ROM_QSTR(MP_QSTR_duty_cycle), MP_ROM_PTR(&pulseio_pwmout_duty_cycle_obj) },
-    { MP_ROM_QSTR(MP_QSTR_frequency), MP_ROM_PTR(&pulseio_pwmout_frequency_obj) },
+    { MP_ROM_QSTR(MP_QSTR_duty_cycle), MP_ROM_PTR(&pwmio_pwmout_duty_cycle_obj) },
+    { MP_ROM_QSTR(MP_QSTR_frequency), MP_ROM_PTR(&pwmio_pwmout_frequency_obj) },
     // TODO(tannewt): Add enabled to determine whether the signal is output
     // without giving up the resources. Useful for IR output.
 };
-STATIC MP_DEFINE_CONST_DICT(pulseio_pwmout_locals_dict, pulseio_pwmout_locals_dict_table);
+STATIC MP_DEFINE_CONST_DICT(pwmio_pwmout_locals_dict, pwmio_pwmout_locals_dict_table);
 
-const mp_obj_type_t pulseio_pwmout_type = {
+const mp_obj_type_t pwmio_pwmout_type = {
     { &mp_type_type },
     .name = MP_QSTR_PWMOut,
-    .make_new = pulseio_pwmout_make_new,
-    .locals_dict = (mp_obj_dict_t*)&pulseio_pwmout_locals_dict,
+    .make_new = pwmio_pwmout_make_new,
+    .locals_dict = (mp_obj_dict_t*)&pwmio_pwmout_locals_dict,
 };
diff --git a/shared-bindings/pulseio/PWMOut.h b/shared-bindings/pwmio/PWMOut.h
index c72278e0e..1a99914ea 100644
--- a/shared-bindings/pulseio/PWMOut.h
+++ b/shared-bindings/pwmio/PWMOut.h
@@ -24,13 +24,13 @@
  * THE SOFTWARE.
  */
 
-#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_PULSEIO_PWMOUT_H
-#define MICROPY_INCLUDED_SHARED_BINDINGS_PULSEIO_PWMOUT_H
+#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_PWMIO_PWMOUT_H
+#define MICROPY_INCLUDED_SHARED_BINDINGS_PWMIO_PWMOUT_H
 
 #include "common-hal/microcontroller/Pin.h"
-#include "common-hal/pulseio/PWMOut.h"
+#include "common-hal/pwmio/PWMOut.h"
 
-extern const mp_obj_type_t pulseio_pwmout_type;
+extern const mp_obj_type_t pwmio_pwmout_type;
 
 typedef enum {
     PWMOUT_OK,
@@ -40,19 +40,19 @@ typedef enum {
     PWMOUT_ALL_TIMERS_IN_USE
 } pwmout_result_t;
 
-extern pwmout_result_t common_hal_pulseio_pwmout_construct(pulseio_pwmout_obj_t* self,
+extern pwmout_result_t common_hal_pwmio_pwmout_construct(pwmio_pwmout_obj_t* self,
     const mcu_pin_obj_t* pin, uint16_t duty, uint32_t frequency,
     bool variable_frequency);
-extern void common_hal_pulseio_pwmout_deinit(pulseio_pwmout_obj_t* self);
-extern bool common_hal_pulseio_pwmout_deinited(pulseio_pwmout_obj_t* self);
-extern void common_hal_pulseio_pwmout_set_duty_cycle(pulseio_pwmout_obj_t* self, uint16_t duty);
-extern uint16_t common_hal_pulseio_pwmout_get_duty_cycle(pulseio_pwmout_obj_t* self);
-extern void common_hal_pulseio_pwmout_set_frequency(pulseio_pwmout_obj_t* self, uint32_t frequency);
-extern uint32_t common_hal_pulseio_pwmout_get_frequency(pulseio_pwmout_obj_t* self);
-extern bool common_hal_pulseio_pwmout_get_variable_frequency(pulseio_pwmout_obj_t* self);
+extern void common_hal_pwmio_pwmout_deinit(pwmio_pwmout_obj_t* self);
+extern bool common_hal_pwmio_pwmout_deinited(pwmio_pwmout_obj_t* self);
+extern void common_hal_pwmio_pwmout_set_duty_cycle(pwmio_pwmout_obj_t* self, uint16_t duty);
+extern uint16_t common_hal_pwmio_pwmout_get_duty_cycle(pwmio_pwmout_obj_t* self);
+extern void common_hal_pwmio_pwmout_set_frequency(pwmio_pwmout_obj_t* self, uint32_t frequency);
+extern uint32_t common_hal_pwmio_pwmout_get_frequency(pwmio_pwmout_obj_t* self);
+extern bool common_hal_pwmio_pwmout_get_variable_frequency(pwmio_pwmout_obj_t* self);
 
 // This is used by the supervisor to claim PWMOut devices indefinitely.
-extern void common_hal_pulseio_pwmout_never_reset(pulseio_pwmout_obj_t *self);
-extern void common_hal_pulseio_pwmout_reset_ok(pulseio_pwmout_obj_t *self);
+extern void common_hal_pwmio_pwmout_never_reset(pwmio_pwmout_obj_t *self);
+extern void common_hal_pwmio_pwmout_reset_ok(pwmio_pwmout_obj_t *self);
 
-#endif // MICROPY_INCLUDED_SHARED_BINDINGS_PULSEIO_PWMOUT_H
+#endif // MICROPY_INCLUDED_SHARED_BINDINGS_PWMIO_PWMOUT_H
diff --git a/shared-bindings/pwmio/__init__.c b/shared-bindings/pwmio/__init__.c
new file mode 100644
index 000000000..a51383703
--- /dev/null
+++ b/shared-bindings/pwmio/__init__.c
@@ -0,0 +1,73 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2016 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 <stdint.h>
+
+#include "py/obj.h"
+#include "py/runtime.h"
+
+#include "shared-bindings/microcontroller/Pin.h"
+#include "shared-bindings/pwmio/__init__.h"
+#include "shared-bindings/pwmio/PWMOut.h"
+
+//| """Support for PWM based protocols
+//|
+//| The `pwmio` module contains classes to provide access to basic pulse IO.
+//|
+
+//| All classes change hardware state and should be deinitialized when they
+//| are no longer needed if the program continues after use. To do so, either
+//| call :py:meth:`!deinit` or use a context manager. See
+//| :ref:`lifetime-and-contextmanagers` for more info.
+//|
+//| For example::
+//|
+//|   import pwmio
+//|   import time
+//|   from board import *
+//|
+//|   pwm = pwmio.PWMOut(D13)
+//|   pwm.duty_cycle = 2 ** 15
+//|   time.sleep(0.1)
+//|
+//| This example will initialize the the device, set
+//| :py:data:`~pwmio.PWMOut.duty_cycle`, and then sleep 0.1 seconds.
+//| CircuitPython will automatically turn off the PWM when it resets all
+//| hardware after program completion. Use ``deinit()`` or a ``with`` statement
+//| to do it yourself."""
+//|
+
+STATIC const mp_rom_map_elem_t pwmio_module_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_pwmio) },
+    { MP_ROM_QSTR(MP_QSTR_PWMOut), MP_ROM_PTR(&pwmio_pwmout_type) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(pwmio_module_globals, pwmio_module_globals_table);
+
+const mp_obj_module_t pwmio_module = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t*)&pwmio_module_globals,
+};
diff --git a/shared-bindings/pwmio/__init__.h b/shared-bindings/pwmio/__init__.h
new file mode 100644
index 000000000..93c70377d
--- /dev/null
+++ b/shared-bindings/pwmio/__init__.h
@@ -0,0 +1,34 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2016 Scott Shawcroft
+ *
+ * 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_PWMIO___INIT___H
+#define MICROPY_INCLUDED_SHARED_BINDINGS_PWMIO___INIT___H
+
+#include "py/obj.h"
+
+// Nothing now.
+
+#endif  // MICROPY_INCLUDED_SHARED_BINDINGS_PWMIO___INIT___H
diff --git a/shared-bindings/watchdog/WatchDogMode.h b/shared-bindings/watchdog/WatchDogMode.h
index 68022671f..fb09445a9 100644
--- a/shared-bindings/watchdog/WatchDogMode.h
+++ b/shared-bindings/watchdog/WatchDogMode.h
@@ -35,7 +35,7 @@ typedef enum {
     WATCHDOGMODE_RESET,
 } watchdog_watchdogmode_t;
 
-const mp_obj_type_t watchdog_watchdogmode_type;
+extern const mp_obj_type_t watchdog_watchdogmode_type;
 
 watchdog_watchdogmode_t watchdog_watchdogmode_obj_to_type(mp_obj_t obj);
 mp_obj_t watchdog_watchdogmode_type_to_obj(watchdog_watchdogmode_t mode);