diff --git a/micropython/modules/breakout_encoder_wheel/breakout_encoder_wheel.c b/micropython/modules/breakout_encoder_wheel/breakout_encoder_wheel.c
index 4af83f03..2ba0e26a 100644
--- a/micropython/modules/breakout_encoder_wheel/breakout_encoder_wheel.c
+++ b/micropython/modules/breakout_encoder_wheel/breakout_encoder_wheel.c
@@ -8,28 +8,54 @@
 MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutEncoderWheel_set_address_obj, 2, BreakoutEncoderWheel_set_address);
 MP_DEFINE_CONST_FUN_OBJ_1(BreakoutEncoderWheel_get_interrupt_flag_obj, BreakoutEncoderWheel_get_interrupt_flag);
 MP_DEFINE_CONST_FUN_OBJ_1(BreakoutEncoderWheel_clear_interrupt_flag_obj, BreakoutEncoderWheel_clear_interrupt_flag);
-MP_DEFINE_CONST_FUN_OBJ_1(BreakoutEncoderWheel_get_direction_obj, BreakoutEncoderWheel_get_direction);
-MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutEncoderWheel_set_direction_obj, 2, BreakoutEncoderWheel_set_direction);
-MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutEncoderWheel_set_brightness_obj, 2, BreakoutEncoderWheel_set_brightness);
-MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutEncoderWheel_set_led_obj, 4, BreakoutEncoderWheel_set_led);
-MP_DEFINE_CONST_FUN_OBJ_1(BreakoutEncoderWheel_available_obj, BreakoutEncoderWheel_available);
-MP_DEFINE_CONST_FUN_OBJ_1(BreakoutEncoderWheel_read_obj, BreakoutEncoderWheel_read);
+
+MP_DEFINE_CONST_FUN_OBJ_2(BreakoutEncoderWheel_pressed_obj, BreakoutEncoderWheel_pressed);
+MP_DEFINE_CONST_FUN_OBJ_1(BreakoutEncoderWheel_count_obj, BreakoutEncoderWheel_count);
+MP_DEFINE_CONST_FUN_OBJ_1(BreakoutEncoderWheel_delta_obj, BreakoutEncoderWheel_delta);
+MP_DEFINE_CONST_FUN_OBJ_1(BreakoutEncoderWheel_step_obj, BreakoutEncoderWheel_step);
+MP_DEFINE_CONST_FUN_OBJ_1(BreakoutEncoderWheel_turn_obj, BreakoutEncoderWheel_turn);
+MP_DEFINE_CONST_FUN_OBJ_1(BreakoutEncoderWheel_zero_obj, BreakoutEncoderWheel_zero);
+MP_DEFINE_CONST_FUN_OBJ_1(BreakoutEncoderWheel_revolutions_obj, BreakoutEncoderWheel_revolutions);
+MP_DEFINE_CONST_FUN_OBJ_1(BreakoutEncoderWheel_degrees_obj, BreakoutEncoderWheel_degrees);
+MP_DEFINE_CONST_FUN_OBJ_1(BreakoutEncoderWheel_radians_obj, BreakoutEncoderWheel_radians);
+MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutEncoderWheel_direction_obj, 1, BreakoutEncoderWheel_direction);
+
+MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutEncoderWheel_set_rgb_obj, 2, BreakoutEncoderWheel_set_rgb);
+MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutEncoderWheel_set_hsv_obj, 2, BreakoutEncoderWheel_set_hsv);
 MP_DEFINE_CONST_FUN_OBJ_1(BreakoutEncoderWheel_clear_obj, BreakoutEncoderWheel_clear);
+MP_DEFINE_CONST_FUN_OBJ_1(BreakoutEncoderWheel_show_obj, BreakoutEncoderWheel_show);
+
+MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutEncoderWheel_gpio_pin_mode_obj, 2, BreakoutEncoderWheel_gpio_pin_mode);
+MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutEncoderWheel_gpio_pin_value_obj, 2, BreakoutEncoderWheel_gpio_pin_value);
+MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutEncoderWheel_gpio_pwm_load_obj, 1, BreakoutEncoderWheel_gpio_pwm_load);
+MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutEncoderWheel_gpio_pwm_frequency_obj, 2, BreakoutEncoderWheel_gpio_pwm_frequency);
 
 /***** Binding of Methods *****/
 STATIC const mp_rom_map_elem_t BreakoutEncoderWheel_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_set_address), MP_ROM_PTR(&BreakoutEncoderWheel_set_address_obj) },
     { MP_ROM_QSTR(MP_QSTR_get_interrupt_flag), MP_ROM_PTR(&BreakoutEncoderWheel_get_interrupt_flag_obj) },
     { MP_ROM_QSTR(MP_QSTR_clear_interrupt_flag), MP_ROM_PTR(&BreakoutEncoderWheel_clear_interrupt_flag_obj) },
-    { MP_ROM_QSTR(MP_QSTR_get_direction), MP_ROM_PTR(&BreakoutEncoderWheel_get_direction_obj) },
-    { MP_ROM_QSTR(MP_QSTR_set_direction), MP_ROM_PTR(&BreakoutEncoderWheel_set_direction_obj) },
-    { MP_ROM_QSTR(MP_QSTR_set_brightness), MP_ROM_PTR(&BreakoutEncoderWheel_set_brightness_obj) },
-    { MP_ROM_QSTR(MP_QSTR_set_led), MP_ROM_PTR(&BreakoutEncoderWheel_set_led_obj) },
-    { MP_ROM_QSTR(MP_QSTR_available), MP_ROM_PTR(&BreakoutEncoderWheel_available_obj) },
-    { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&BreakoutEncoderWheel_read_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_pressed), MP_ROM_PTR(&BreakoutEncoderWheel_pressed_obj) },
+    { MP_ROM_QSTR(MP_QSTR_count), MP_ROM_PTR(&BreakoutEncoderWheel_count_obj) },
+    { MP_ROM_QSTR(MP_QSTR_delta), MP_ROM_PTR(&BreakoutEncoderWheel_delta_obj) },
+    { MP_ROM_QSTR(MP_QSTR_step), MP_ROM_PTR(&BreakoutEncoderWheel_step_obj) },
+    { MP_ROM_QSTR(MP_QSTR_turn), MP_ROM_PTR(&BreakoutEncoderWheel_turn_obj) },
+    { MP_ROM_QSTR(MP_QSTR_zero), MP_ROM_PTR(&BreakoutEncoderWheel_zero_obj) },
+    { MP_ROM_QSTR(MP_QSTR_revolutions), MP_ROM_PTR(&BreakoutEncoderWheel_revolutions_obj) },
+    { MP_ROM_QSTR(MP_QSTR_degrees), MP_ROM_PTR(&BreakoutEncoderWheel_degrees_obj) },
+    { MP_ROM_QSTR(MP_QSTR_radians), MP_ROM_PTR(&BreakoutEncoderWheel_radians_obj) },
+    { MP_ROM_QSTR(MP_QSTR_direction), MP_ROM_PTR(&BreakoutEncoderWheel_direction_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_set_rgb), MP_ROM_PTR(&BreakoutEncoderWheel_set_rgb_obj) },
+    { MP_ROM_QSTR(MP_QSTR_set_hsv), MP_ROM_PTR(&BreakoutEncoderWheel_set_hsv_obj) },
     { MP_ROM_QSTR(MP_QSTR_clear), MP_ROM_PTR(&BreakoutEncoderWheel_clear_obj) },
-    { MP_ROM_QSTR(MP_QSTR_DIRECTION_CW), MP_ROM_INT(1) },
-    { MP_ROM_QSTR(MP_QSTR_DIRECTION_CCW), MP_ROM_INT(0) },
+    { MP_ROM_QSTR(MP_QSTR_show), MP_ROM_PTR(&BreakoutEncoderWheel_show_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_gpio_pin_mode), MP_ROM_PTR(&BreakoutEncoderWheel_gpio_pin_mode_obj) },
+    { MP_ROM_QSTR(MP_QSTR_gpio_pin_value), MP_ROM_PTR(&BreakoutEncoderWheel_gpio_pin_value_obj) },
+    { MP_ROM_QSTR(MP_QSTR_gpio_pwm_load), MP_ROM_PTR(&BreakoutEncoderWheel_gpio_pwm_load_obj) },
+    { MP_ROM_QSTR(MP_QSTR_gpio_pwm_frequency), MP_ROM_PTR(&BreakoutEncoderWheel_gpio_pwm_frequency_obj) },
 };
 STATIC MP_DEFINE_CONST_DICT(BreakoutEncoderWheel_locals_dict, BreakoutEncoderWheel_locals_dict_table);
 
@@ -56,10 +82,34 @@ const mp_obj_type_t breakout_encoder_wheel_BreakoutEncoderWheel_type = {
 // breakout_encoder_wheel Module
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+/***** Module Constants *****/
+const mp_rom_obj_tuple_t breakout_encoder_wheel_gpio_pins = {
+    {&mp_type_tuple}, 3, { MP_ROM_INT(7), MP_ROM_INT(8), MP_ROM_INT(9), },
+};
+
 /***** Globals Table *****/
 STATIC const mp_map_elem_t breakout_encoder_wheel_globals_table[] = {
     { MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_breakout_encoder_wheel) },
     { MP_OBJ_NEW_QSTR(MP_QSTR_BreakoutEncoderWheel), (mp_obj_t)&breakout_encoder_wheel_BreakoutEncoderWheel_type },
+
+    { MP_ROM_QSTR(MP_QSTR_I2C_ADDR), MP_ROM_INT(0x13) },
+    { MP_ROM_QSTR(MP_QSTR_DEFAULT_LED_I2C_ADDR), MP_ROM_INT(0x77) },
+    { MP_ROM_QSTR(MP_QSTR_ALTERNATE_LED_I2C_ADDR), MP_ROM_INT(0x74) },
+
+    { MP_ROM_QSTR(MP_QSTR_NUM_LEDS), MP_ROM_INT(24) },
+    { MP_ROM_QSTR(MP_QSTR_NUM_BUTTONS), MP_ROM_INT(5) },
+    { MP_ROM_QSTR(MP_QSTR_NUM_GPIOS), MP_ROM_INT(3) },
+
+    { MP_ROM_QSTR(MP_QSTR_UP), MP_ROM_INT(0) },
+    { MP_ROM_QSTR(MP_QSTR_DOWN), MP_ROM_INT(1) },
+    { MP_ROM_QSTR(MP_QSTR_LEFT), MP_ROM_INT(2) },
+    { MP_ROM_QSTR(MP_QSTR_RIGHT), MP_ROM_INT(3) },
+    { MP_ROM_QSTR(MP_QSTR_CENTRE), MP_ROM_INT(5) },
+
+    { MP_ROM_QSTR(MP_QSTR_GP7), MP_ROM_INT(7) },
+    { MP_ROM_QSTR(MP_QSTR_GP8), MP_ROM_INT(8) },
+    { MP_ROM_QSTR(MP_QSTR_GP9), MP_ROM_INT(9) },
+    { MP_ROM_QSTR(MP_QSTR_GPIOS), MP_ROM_PTR(&breakout_encoder_wheel_gpio_pins) },
 };
 STATIC MP_DEFINE_CONST_DICT(mp_module_breakout_encoder_wheel_globals, breakout_encoder_wheel_globals_table);
 
diff --git a/micropython/modules/breakout_encoder_wheel/breakout_encoder_wheel.cpp b/micropython/modules/breakout_encoder_wheel/breakout_encoder_wheel.cpp
index 87a1153e..4d6c78f6 100644
--- a/micropython/modules/breakout_encoder_wheel/breakout_encoder_wheel.cpp
+++ b/micropython/modules/breakout_encoder_wheel/breakout_encoder_wheel.cpp
@@ -76,96 +76,222 @@ mp_obj_t BreakoutEncoderWheel_clear_interrupt_flag(mp_obj_t self_in) {
     return mp_const_none;
 }
 
-mp_obj_t BreakoutEncoderWheel_get_direction(mp_obj_t self_in) {
-    //breakout_encoder_wheel_BreakoutEncoderWheel_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_encoder_wheel_BreakoutEncoderWheel_obj_t);
-    //return mp_obj_new_bool(self->breakout->get_direction());
+extern mp_obj_t BreakoutEncoderWheel_pressed(mp_obj_t self_in, mp_obj_t button_in) {
+    breakout_encoder_wheel_BreakoutEncoderWheel_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_encoder_wheel_BreakoutEncoderWheel_obj_t);
+    int button = mp_obj_get_int(button_in);
+
+    if(button < 0 || button >= 5) {
+        mp_raise_ValueError("button out of range. Expected 0 to 4")
+    }
+
+    return mp_obj_new_bool(self->breakout->pressed(button));
+}
+
+extern mp_obj_t BreakoutEncoderWheel_count(mp_obj_t self_in) {
+    breakout_encoder_wheel_BreakoutEncoderWheel_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_encoder_wheel_BreakoutEncoderWheel_obj_t);
+    return mp_obj_new_int(self->breakout->count());
+}
+
+extern mp_obj_t BreakoutEncoderWheel_delta(mp_obj_t self_in) {
+    breakout_encoder_wheel_BreakoutEncoderWheel_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_encoder_wheel_BreakoutEncoderWheel_obj_t);
+    return mp_obj_new_int(self->breakout->delta());
+}
+
+extern mp_obj_t BreakoutEncoderWheel_step(mp_obj_t self_in) {
+    breakout_encoder_wheel_BreakoutEncoderWheel_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_encoder_wheel_BreakoutEncoderWheel_obj_t);
+    return mp_obj_new_int(self->breakout->step());
+}
+
+extern mp_obj_t BreakoutEncoderWheel_turn(mp_obj_t self_in) {
+    breakout_encoder_wheel_BreakoutEncoderWheel_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_encoder_wheel_BreakoutEncoderWheel_obj_t);
+    return mp_obj_new_int(self->breakout->turn());
+}
+
+extern mp_obj_t BreakoutEncoderWheel_zero(mp_obj_t self_in) {
+    breakout_encoder_wheel_BreakoutEncoderWheel_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_encoder_wheel_BreakoutEncoderWheel_obj_t);
+    self->breakout->zero();
+
     return mp_const_none;
 }
 
-mp_obj_t BreakoutEncoderWheel_set_direction(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    enum { ARG_self, ARG_clockwise };
+extern mp_obj_t BreakoutEncoderWheel_revolutions(mp_obj_t self_in) {
+    breakout_encoder_wheel_BreakoutEncoderWheel_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_encoder_wheel_BreakoutEncoderWheel_obj_t);
+    return mp_obj_new_float(self->breakout->revolutions());
+}
+
+extern mp_obj_t BreakoutEncoderWheel_degrees(mp_obj_t self_in) {
+    breakout_encoder_wheel_BreakoutEncoderWheel_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_encoder_wheel_BreakoutEncoderWheel_obj_t);
+    return mp_obj_new_float(self->breakout->degrees());
+}
+
+extern mp_obj_t BreakoutEncoderWheel_radians(mp_obj_t self_in) {
+    breakout_encoder_wheel_BreakoutEncoderWheel_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_encoder_wheel_BreakoutEncoderWheel_obj_t);
+    return mp_obj_new_float(self->breakout->radians());
+}
+
+extern mp_obj_t BreakoutEncoderWheel_direction(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_self, ARG_direction };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
-        { MP_QSTR_clockwise, MP_ARG_REQUIRED | MP_ARG_BOOL },
+        { MP_QSTR_direction, MP_ARG_OBJ, { .u_obj = mp_const_none }},
     };
 
+    // Parse args.
     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);
 
-    //breakout_encoder_wheel_BreakoutEncoderWheel_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_encoder_wheel_BreakoutEncoderWheel_obj_t);
+    breakout_encoder_wheel_BreakoutEncoderWheel_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_encoder_wheel_BreakoutEncoderWheel_obj_t);
 
-    //self->breakout->set_direction(args[ARG_clockwise].u_bool ? BreakoutEncoderWheel::DIRECTION_CW : BreakoutEncoderWheel::DIRECTION_CCW);
-
-    return mp_const_none;
+    if(n_args <= 1) {
+        return mp_obj_new_int(self->breakout->direction());
+    }
+    else {
+        int direction = mp_obj_get_int(args[ARG_direction].u_obj);
+        if(direction < 0 || direction > 1) {
+            mp_raise_ValueError("direction out of range. Expected NORMAL_DIR (0) or REVERSED_DIR (1)");
+        }
+        self->breakout->direction((Direction)direction);
+        return mp_const_none;
+    }
 }
 
-mp_obj_t BreakoutEncoderWheel_set_brightness(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    enum { ARG_self, ARG_brightness };
-    static const mp_arg_t allowed_args[] = {
-        { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
-        { MP_QSTR_brightness, MP_ARG_REQUIRED | MP_ARG_OBJ },
-    };
-
-    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);
-    
-    //breakout_encoder_wheel_BreakoutEncoderWheel_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_encoder_wheel_BreakoutEncoderWheel_obj_t);
-
-    float brightness = mp_obj_get_float(args[ARG_brightness].u_obj);
-    if(brightness < 0 || brightness > 1.0f)
-        mp_raise_ValueError("brightness out of range. Expected 0.0 to 1.0");
-    //else
-        //self->breakout->set_brightness(brightness);
-
-    return mp_const_none;
-}
-
-mp_obj_t BreakoutEncoderWheel_set_led(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    enum { ARG_self, ARG_r, ARG_g, ARG_b, ARG_w };
+extern mp_obj_t BreakoutEncoderWheel_set_rgb(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_self, ARG_index, ARG_r, ARG_g, ARG_b };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
+        { MP_QSTR_index, MP_ARG_REQUIRED | MP_ARG_INT },
         { MP_QSTR_r, MP_ARG_REQUIRED | MP_ARG_INT },
         { MP_QSTR_g, MP_ARG_REQUIRED | MP_ARG_INT },
         { MP_QSTR_b, MP_ARG_REQUIRED | MP_ARG_INT },
     };
 
+    // Parse args.
     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);
 
-    //breakout_encoder_wheel_BreakoutEncoderWheel_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_encoder_wheel_BreakoutEncoderWheel_obj_t);
+    breakout_encoder_wheel_BreakoutEncoderWheel_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_encoder_wheel_BreakoutEncoderWheel_obj_t);
 
+    int index = args[ARG_index].u_int;
     int r = args[ARG_r].u_int;
     int g = args[ARG_g].u_int;
     int b = args[ARG_b].u_int;
 
-    if(r < 0 || r > 255)
+    if(index < 0 || index >= 24)
+        mp_raise_ValueError("index out of range. Expected 0 to 23");
+    else if(r < 0 || r > 255)
         mp_raise_ValueError("r out of range. Expected 0 to 255");
     else if(g < 0 || g > 255)
         mp_raise_ValueError("g out of range. Expected 0 to 255");
     else if(b < 0 || b > 255)
         mp_raise_ValueError("b out of range. Expected 0 to 255");
-    //else
-        //self->breakout->set_led(r, g, b);
+    else
+        self->breakout->set_rgb(index, r, g, b);
 
     return mp_const_none;
 }
 
-mp_obj_t BreakoutEncoderWheel_available(mp_obj_t self_in) {
-    //breakout_encoder_wheel_BreakoutEncoderWheel_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_encoder_wheel_BreakoutEncoderWheel_obj_t);
-    //return mp_obj_new_bool(self->breakout->available());
+extern mp_obj_t BreakoutEncoderWheel_set_hsv(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_self, ARG_index, ARG_h, ARG_s, ARG_v };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
+        { MP_QSTR_index, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_h, MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_s, MP_ARG_INT, { .u_obj = mp_const_none }},
+        { MP_QSTR_v, MP_ARG_INT, { .u_obj = mp_const_none }},
+    };
+
+    // Parse args.
+    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);
+
+    breakout_encoder_wheel_BreakoutEncoderWheel_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_encoder_wheel_BreakoutEncoderWheel_obj_t);
+
+    int index = args[ARG_index].u_int;
+    float h = mp_obj_get_float(args[ARG_h].u_obj);
+
+    float s = 1.0f;
+    if (args[ARG_s].u_obj != mp_const_none) {
+        s = mp_obj_get_float(args[ARG_s].u_obj);
+    }
+
+    float v = 1.0f;
+    if (args[ARG_v].u_obj != mp_const_none) {
+        v = mp_obj_get_float(args[ARG_v].u_obj);
+    }
+
+    if(index < 0 || index >= 24)
+        mp_raise_ValueError("index out of range. Expected 0 to 23");
+    else
+        self->breakout->set_hsv(index, h, s, v);
+
     return mp_const_none;
 }
 
-mp_obj_t BreakoutEncoderWheel_read(mp_obj_t self_in) {
-    //breakout_encoder_wheel_BreakoutEncoderWheel_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_encoder_wheel_BreakoutEncoderWheel_obj_t);
-    //return mp_obj_new_int(self->breakout->read());
+extern mp_obj_t BreakoutEncoderWheel_clear(mp_obj_t self_in) {
+    breakout_encoder_wheel_BreakoutEncoderWheel_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_encoder_wheel_BreakoutEncoderWheel_obj_t);
+    self->breakout->clear();
+
     return mp_const_none;
 }
 
-mp_obj_t BreakoutEncoderWheel_clear(mp_obj_t self_in) {
-    //breakout_encoder_wheel_BreakoutEncoderWheel_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_encoder_wheel_BreakoutEncoderWheel_obj_t);
-    //self->breakout->clear();
+extern mp_obj_t BreakoutEncoderWheel_show(mp_obj_t self_in) {
+    breakout_encoder_wheel_BreakoutEncoderWheel_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_encoder_wheel_BreakoutEncoderWheel_obj_t);
+    self->breakout->show();
 
     return mp_const_none;
 }
+
+extern mp_obj_t BreakoutEncoderWheel_gpio_pin_mode(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    //breakout_encoder_wheel_BreakoutEncoderWheel_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_encoder_wheel_BreakoutEncoderWheel_obj_t);
+
+    return mp_const_none;
+}
+
+extern mp_obj_t BreakoutEncoderWheel_gpio_pin_value(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    //breakout_encoder_wheel_BreakoutEncoderWheel_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_encoder_wheel_BreakoutEncoderWheel_obj_t);
+
+    return mp_const_none;
+}
+
+extern mp_obj_t BreakoutEncoderWheel_gpio_pwm_load(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_self, ARG_wait_for_load };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
+        { MP_QSTR_wait_for_load, MP_ARG_BOOL, { .u_bool = false }},
+    };
+
+    // Parse args.
+    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);
+
+    breakout_encoder_wheel_BreakoutEncoderWheel_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_encoder_wheel_BreakoutEncoderWheel_obj_t);
+
+    bool wait_for_load = args[ARG_wait_for_load].u_bool;
+    self->breakout->gpio_pwm_load(wait_for_load);
+
+    return mp_const_none;
+}
+
+extern mp_obj_t BreakoutEncoderWheel_gpio_pwm_frequency(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_self, ARG_frequency, ARG_load, ARG_wait_for_load };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
+        { MP_QSTR_frequency, MP_ARG_REQUIRED | MP_ARG_OBJ },
+        { MP_QSTR_load, MP_ARG_BOOL, { .u_bool = false }},
+        { MP_QSTR_wait_for_load, MP_ARG_BOOL, { .u_bool = false }},
+    };
+
+    // Parse args.
+    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);
+
+    breakout_encoder_wheel_BreakoutEncoderWheel_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_encoder_wheel_BreakoutEncoderWheel_obj_t);
+    float frequency = mp_obj_get_float(args[ARG_frequency].u_obj);
+    bool load = args[ARG_load].u_bool;
+    bool wait_for_load = args[ARG_wait_for_load].u_bool;
+
+    int period = self->breakout->gpio_pwm_frequency(frequency, load, wait_for_load);
+
+    return mp_obj_new_int(period);
+}
 }
\ No newline at end of file
diff --git a/micropython/modules/breakout_encoder_wheel/breakout_encoder_wheel.h b/micropython/modules/breakout_encoder_wheel/breakout_encoder_wheel.h
index c85739e4..c03926f2 100644
--- a/micropython/modules/breakout_encoder_wheel/breakout_encoder_wheel.h
+++ b/micropython/modules/breakout_encoder_wheel/breakout_encoder_wheel.h
@@ -9,10 +9,24 @@ extern mp_obj_t BreakoutEncoderWheel_make_new(const mp_obj_type_t *type, size_t
 extern mp_obj_t BreakoutEncoderWheel_set_address(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
 extern mp_obj_t BreakoutEncoderWheel_get_interrupt_flag(mp_obj_t self_in);
 extern mp_obj_t BreakoutEncoderWheel_clear_interrupt_flag(mp_obj_t self_in);
-extern mp_obj_t BreakoutEncoderWheel_get_direction(mp_obj_t self_in);
-extern mp_obj_t BreakoutEncoderWheel_set_direction(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
-extern mp_obj_t BreakoutEncoderWheel_set_brightness(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
-extern mp_obj_t BreakoutEncoderWheel_set_led(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
-extern mp_obj_t BreakoutEncoderWheel_available(mp_obj_t self_in);
-extern mp_obj_t BreakoutEncoderWheel_read(mp_obj_t self_in);
-extern mp_obj_t BreakoutEncoderWheel_clear(mp_obj_t self_in);
\ No newline at end of file
+
+extern mp_obj_t BreakoutEncoderWheel_pressed(mp_obj_t self_in, mp_obj_t button_in);
+extern mp_obj_t BreakoutEncoderWheel_count(mp_obj_t self_in);
+extern mp_obj_t BreakoutEncoderWheel_delta(mp_obj_t self_in);
+extern mp_obj_t BreakoutEncoderWheel_step(mp_obj_t self_in);
+extern mp_obj_t BreakoutEncoderWheel_turn(mp_obj_t self_in);
+extern mp_obj_t BreakoutEncoderWheel_zero(mp_obj_t self_in);
+extern mp_obj_t BreakoutEncoderWheel_revolutions(mp_obj_t self_in);
+extern mp_obj_t BreakoutEncoderWheel_degrees(mp_obj_t self_in);
+extern mp_obj_t BreakoutEncoderWheel_radians(mp_obj_t self_in);
+extern mp_obj_t BreakoutEncoderWheel_direction(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+
+extern mp_obj_t BreakoutEncoderWheel_set_rgb(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+extern mp_obj_t BreakoutEncoderWheel_set_hsv(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+extern mp_obj_t BreakoutEncoderWheel_clear(mp_obj_t self_in);
+extern mp_obj_t BreakoutEncoderWheel_show(mp_obj_t self_in);
+
+extern mp_obj_t BreakoutEncoderWheel_gpio_pin_mode(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+extern mp_obj_t BreakoutEncoderWheel_gpio_pin_value(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+extern mp_obj_t BreakoutEncoderWheel_gpio_pwm_load(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+extern mp_obj_t BreakoutEncoderWheel_gpio_pwm_frequency(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);