Pico Scroll: Refactor to class.

2023-03-13 19:39:33 +00:00 · 2023-03-13 19:39:33 +00:00 · 044313551b
commit 044313551b
--- a/libraries/pico_scroll/pico_scroll.cpp
+++ b/libraries/pico_scroll/pico_scroll.cpp
@ -35,6 +35,11 @@ enum reg {

 namespace pimoroni {

+  PicoScroll::~PicoScroll() {
+    clear();
+    update();
+  }
+
  void PicoScroll::init() {
    // setup i2c interface
    i2c_init(i2c0, 400000);
--- a/libraries/pico_scroll/pico_scroll.hpp
+++ b/libraries/pico_scroll/pico_scroll.hpp
@ -19,6 +19,7 @@ namespace pimoroni {
    uint8_t __fb[BUFFER_SIZE];
  
  public:
+    ~PicoScroll();
    void init();
    void update();
    void set_pixels(const char *pixels);
--- a/libraries/pico_scroll/pico_scroll_font.cpp
+++ b/libraries/pico_scroll/pico_scroll_font.cpp
@ -1,4 +1,5 @@
 #include "pico_scroll_font.hpp"
+#include <string.h>

 /* static font data */
 static const unsigned char __bitmap[256][5] = {
@ -135,13 +136,15 @@ static const unsigned char __bitmap[256][5] = {
 /* render a text string to a pre-allocated buffer - strlen(text) * 6 bytes */
 int render_text(const char *text, unsigned int nchr, unsigned char *buffer, unsigned int nbfr) {
    // TODO check nbfr >= 6 * nchr
+    memset(buffer, 0, nbfr);

    for (unsigned int i = 0; i < nchr; i++) {
        const unsigned char *symbol = __bitmap[(unsigned int)text[i]];
        for (unsigned int j = 0; j < 5; j++) {
-            buffer[i * 6 + j] = symbol[j];
+            unsigned int offset = i * 6 + j;
+            if (offset >= nbfr) return -1;
+            buffer[offset] = symbol[j];
        }
-        buffer[i * 6 + 5] = 0x0;
    }
    return 0;
 }
--- a/micropython/examples/pico_scroll/demo.py
+++ b/micropython/examples/pico_scroll/demo.py
@ -1,30 +1,28 @@
 import time
-import picoscroll as scroll
+from picoscroll import PicoScroll, WIDTH, HEIGHT
+
+scroll = PicoScroll()

-scroll.init()
 i = 0
 loop = 18
 br_mult = 1
 br_pressed = 32
 tail = 12

-width = scroll.get_width()
-height = scroll.get_height()
-
 while True:
    scroll.clear()
-    for y in range(0, height):
-        for x in range(0, width):
+    for y in range(0, HEIGHT):
+        for x in range(0, WIDTH):
            if x < 3 and y < 3 and scroll.is_pressed(scroll.BUTTON_A):
                scroll.set_pixel(x, y, br_pressed)
            elif x < 3 and y > 3 and scroll.is_pressed(scroll.BUTTON_B):
                scroll.set_pixel(x, y, br_pressed)
-            elif x > width - 4 and y < 3 and scroll.is_pressed(scroll.BUTTON_X):
+            elif x > WIDTH - 4 and y < 3 and scroll.is_pressed(scroll.BUTTON_X):
                scroll.set_pixel(x, y, br_pressed)
-            elif x > width - 4 and y > 3 and scroll.is_pressed(scroll.BUTTON_Y):
+            elif x > WIDTH - 4 and y > 3 and scroll.is_pressed(scroll.BUTTON_Y):
                scroll.set_pixel(x, y, br_pressed)
            else:
-                m = (x + (y * width)) % loop
+                m = (x + (y * WIDTH)) % loop
                for b in range(0, loop):
                    if m == (i + (loop - b)) % loop and b < tail:
                        scroll.set_pixel(x, y, br_mult * (tail - b))
--- a/micropython/examples/pico_scroll/scroll_text.py
+++ b/micropython/examples/pico_scroll/scroll_text.py
@ -1,7 +1,7 @@
 import time
-import picoscroll as scroll
+from picoscroll import PicoScroll

-scroll.init()
+scroll = PicoScroll()

 while True:
    scroll.scroll_text("Hello World", 128, 80)
--- a/micropython/modules/pico_scroll/README.md
+++ b/micropython/modules/pico_scroll/README.md
@ -5,28 +5,27 @@ Our Pico Scroll Pack offers a 17x7 white LED matrix for your Raspberry Pi Pico.
 We've included helper functions to handle every aspect of drawing to the matrix and interfacing with the buttons. See the [function reference](#function-reference) for details.

 - [Example Program](#example-program)
- [Function Reference](#function-reference)
-  - [init](#init)
-  - [get_width](#get_width)
-  - [get_height](#get_height)
-  - [set_pixel](#set_pixel)
-  - [set_pixels](#set_pixels)
-  - [show_text](#show_text)
-  - [scroll_text](#scroll_text)
-  - [show_bitmap_1d](#show_bitmap_1d)
+- [Function reference](#function-reference)
+  - [get\_width](#get_width)
+  - [get\_height](#get_height)
+  - [set\_pixel](#set_pixel)
+  - [set\_pixels](#set_pixels)
+  - [show\_text](#show_text)
+  - [scroll\_text](#scroll_text)
+  - [show\_bitmap\_1d](#show_bitmap_1d)
  - [update](#update)
  - [clear](#clear)
-  - [is_pressed](#is_pressed)
+  - [is\_pressed](#is_pressed)

 ## Example Program

 The following example sets up the matrix, sets each pixel to an increasing brightnesses level, and then clears the matrix only after button A is pressed.

 ```python
-import picoscroll
+from picoscroll import PicoScroll

 # Initialise the board
-picoscroll.init()
+picoscroll = PicoScroll()

 brightness = 0

@ -51,14 +50,6 @@ picoscroll.update()

 ## Function reference

-### init
-
-Sets up the Pico Scroll Pack. The `init` function must be called before any other functions as it configures the required pins on the Pico board.
-
-```python
-picoscroll.init()
-```
-
 ### get_width
 ### get_height

--- a/micropython/modules/pico_scroll/pico_scroll.c
+++ b/micropython/modules/pico_scroll/pico_scroll.c
@ -15,22 +15,21 @@ enum buttons
 ////////////////////////////////////////////////////////////////////////////////////////////////////

 /***** Module Functions *****/
-STATIC MP_DEFINE_CONST_FUN_OBJ_0(picoscroll_init_obj, picoscroll_init);
-STATIC MP_DEFINE_CONST_FUN_OBJ_0(picoscroll_get_width_obj, picoscroll_get_width);
-STATIC MP_DEFINE_CONST_FUN_OBJ_0(picoscroll_get_height_obj, picoscroll_get_height);
-STATIC MP_DEFINE_CONST_FUN_OBJ_0(picoscroll_update_obj, picoscroll_update);
-STATIC MP_DEFINE_CONST_FUN_OBJ_3(picoscroll_set_pixel_obj, picoscroll_set_pixel);
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(picoscroll_set_pixels_obj, picoscroll_set_pixels);
-STATIC MP_DEFINE_CONST_FUN_OBJ_3(picoscroll_show_text_obj, picoscroll_show_text);
-STATIC MP_DEFINE_CONST_FUN_OBJ_3(picoscroll_scroll_text_obj, picoscroll_scroll_text);
-STATIC MP_DEFINE_CONST_FUN_OBJ_3(picoscroll_show_bitmap_1d_obj, picoscroll_show_bitmap_1d);
-STATIC MP_DEFINE_CONST_FUN_OBJ_0(picoscroll_clear_obj, picoscroll_clear);
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(picoscroll_is_pressed_obj, picoscroll_is_pressed);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(picoscroll___del___obj, picoscroll___del__);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(picoscroll_get_width_obj, picoscroll_get_width);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(picoscroll_get_height_obj, picoscroll_get_height);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(picoscroll_update_obj, picoscroll_update);
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(picoscroll_set_pixel_obj, 4, 4, picoscroll_set_pixel);
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(picoscroll_set_pixels_obj, picoscroll_set_pixels);
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(picoscroll_show_text_obj, 4, 4, picoscroll_show_text);
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(picoscroll_scroll_text_obj, 4, 4, picoscroll_scroll_text);
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(picoscroll_show_bitmap_1d_obj, 4, 4, picoscroll_show_bitmap_1d);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(picoscroll_clear_obj, picoscroll_clear);
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(picoscroll_is_pressed_obj, picoscroll_is_pressed);

-/***** Globals Table *****/
-STATIC const mp_map_elem_t picoscroll_globals_table[] = {
-    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_picoscroll) },
-    { MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&picoscroll_init_obj) },    
+/* Class Methods */
+STATIC const mp_rom_map_elem_t picoscroll_locals[] = {
+    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&picoscroll___del___obj) },  
    { MP_ROM_QSTR(MP_QSTR_get_width), MP_ROM_PTR(&picoscroll_get_width_obj) },
    { MP_ROM_QSTR(MP_QSTR_get_height), MP_ROM_PTR(&picoscroll_get_height_obj) },
    { MP_ROM_QSTR(MP_QSTR_update), MP_ROM_PTR(&picoscroll_update_obj) },
@ -40,15 +39,44 @@ STATIC const mp_map_elem_t picoscroll_globals_table[] = {
    { MP_ROM_QSTR(MP_QSTR_scroll_text), MP_ROM_PTR(&picoscroll_scroll_text_obj) },
    { MP_ROM_QSTR(MP_QSTR_show_bitmap_1d), MP_ROM_PTR(&picoscroll_show_bitmap_1d_obj) },
    { MP_ROM_QSTR(MP_QSTR_clear), MP_ROM_PTR(&picoscroll_clear_obj) },
-    { MP_ROM_QSTR(MP_QSTR_is_pressed), MP_ROM_PTR(&picoscroll_is_pressed_obj) },        
+    { MP_ROM_QSTR(MP_QSTR_is_pressed), MP_ROM_PTR(&picoscroll_is_pressed_obj) },
    { MP_ROM_QSTR(MP_QSTR_BUTTON_A), MP_ROM_INT(BUTTON_A) },
    { MP_ROM_QSTR(MP_QSTR_BUTTON_B), MP_ROM_INT(BUTTON_B) },
    { MP_ROM_QSTR(MP_QSTR_BUTTON_X), MP_ROM_INT(BUTTON_X) },
    { MP_ROM_QSTR(MP_QSTR_BUTTON_Y), MP_ROM_INT(BUTTON_Y) },
 };
-STATIC MP_DEFINE_CONST_DICT(mp_module_picoscroll_globals, picoscroll_globals_table);
+STATIC MP_DEFINE_CONST_DICT(mp_module_picoscroll_locals, picoscroll_locals);
+
+#ifdef MP_DEFINE_CONST_OBJ_TYPE
+MP_DEFINE_CONST_OBJ_TYPE(
+    PicoScroll_type,
+    MP_QSTR_PicoScroll,
+    MP_TYPE_FLAG_NONE,
+    make_new, picoscroll_make_new,
+    locals_dict, (mp_obj_dict_t*)&mp_module_picoscroll_locals
+);
+#else
+const mp_obj_type_t PicoScroll_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_PicoScroll,
+    .make_new = picoscroll_make_new,
+    .locals_dict = (mp_obj_dict_t*)&mp_module_picoscroll_locals,
+};
+#endif
+
+/* Module Globals */
+STATIC const mp_map_elem_t picoscroll_globals[] = {
+    { MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_picoscroll) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_PicoScroll), (mp_obj_t)&PicoScroll_type },
+    { MP_ROM_QSTR(MP_QSTR_WIDTH), MP_ROM_INT(17) },
+    { MP_ROM_QSTR(MP_QSTR_HEIGHT), MP_ROM_INT(7) },
+    { MP_ROM_QSTR(MP_QSTR_BUTTON_A), MP_ROM_INT(BUTTON_A) },
+    { MP_ROM_QSTR(MP_QSTR_BUTTON_B), MP_ROM_INT(BUTTON_B) },
+    { MP_ROM_QSTR(MP_QSTR_BUTTON_X), MP_ROM_INT(BUTTON_X) },
+    { MP_ROM_QSTR(MP_QSTR_BUTTON_Y), MP_ROM_INT(BUTTON_Y) },
+};
+STATIC MP_DEFINE_CONST_DICT(mp_module_picoscroll_globals, picoscroll_globals);

-/***** Module Definition *****/
 const mp_obj_module_t picoscroll_user_cmodule = {
    .base = { &mp_type_module },
    .globals = (mp_obj_dict_t*)&mp_module_picoscroll_globals,
--- a/micropython/modules/pico_scroll/pico_scroll.cpp
+++ b/micropython/modules/pico_scroll/pico_scroll.cpp
@ -1,3 +1,4 @@
+#include <cstdio>
 #include "hardware/spi.h"
 #include "hardware/sync.h"
 #include "pico/binary_info.h"
@ -5,6 +6,7 @@

 #include "micropython/modules/util.hpp"
 #include "libraries/pico_scroll/pico_scroll.hpp"
+#include "libraries/pico_scroll/pico_scroll_font.hpp"

 using namespace pimoroni;

@ -14,163 +16,194 @@ PicoScroll *scroll = nullptr;
 extern "C" {
 #include "pico_scroll.h"

-#define NOT_INITIALISED_MSG     "Cannot call this function, as picoscroll is not initialised. Call picoscroll.init() first."
 #define BUFFER_TOO_SMALL_MSG "bytearray too small: len(image) < width * height."
 #define INCORRECT_SIZE_MSG "Scroll height wrong: > 8 pixels."

-mp_obj_t picoscroll_init() {
-    if(scroll == nullptr)
-        scroll = m_tracked_alloc_class(PicoScroll);
-    scroll->init();
+typedef struct _PicoScroll_obj_t {
+    mp_obj_base_t base;
+    PicoScroll* scroll;
+} PicoScroll_obj_t;
+
+mp_obj_t picoscroll_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+    _PicoScroll_obj_t *self = nullptr;
+
+    self = m_new_obj_with_finaliser(PicoScroll_obj_t);
+    self->base.type = &PicoScroll_type;
+
+    self->scroll = m_new_class(PicoScroll);
+    self->scroll->init();
+
+    return MP_OBJ_FROM_PTR(self);
+}
+
+mp_obj_t picoscroll___del__(mp_obj_t self_in) {
+    PicoScroll_obj_t *self = MP_OBJ_TO_PTR2(self_in, PicoScroll_obj_t);
+    m_del_class(PicoScroll, self->scroll);
    return mp_const_none;
 }

-mp_obj_t picoscroll_get_width() {
+mp_obj_t picoscroll_get_width(mp_obj_t self_in) {
+    (void)self_in;
    return mp_obj_new_int(PicoScroll::WIDTH);
 }

-mp_obj_t picoscroll_get_height() {
+mp_obj_t picoscroll_get_height(mp_obj_t self_in) {
+    (void)self_in;
    return mp_obj_new_int(PicoScroll::HEIGHT);
 }

-mp_obj_t picoscroll_update() {
-    if(scroll != nullptr)
-        scroll->update();
-    else
-        mp_raise_msg(&mp_type_RuntimeError, NOT_INITIALISED_MSG);
+mp_obj_t picoscroll_update(mp_obj_t self_in) {
+    PicoScroll_obj_t *self = MP_OBJ_TO_PTR2(self_in, PicoScroll_obj_t);
+    self->scroll->update();
    return mp_const_none;
 }

-mp_obj_t picoscroll_set_pixel(mp_obj_t x_obj, mp_obj_t y_obj, mp_obj_t v_obj) {
-    if (scroll != nullptr) {
-        int x = mp_obj_get_int(x_obj);
-        int y = mp_obj_get_int(y_obj);
-        int val = mp_obj_get_int(v_obj);
+mp_obj_t picoscroll_set_pixel(mp_uint_t n_args, const mp_obj_t *args) {
+    (void)n_args; //Unused input parameter, we know it's self + 3
+   
+    PicoScroll_obj_t *self = MP_OBJ_TO_PTR2(args[0], PicoScroll_obj_t);

-        if (x < 0 || x >= PicoScroll::WIDTH || y < 0 || y >= PicoScroll::HEIGHT)
-            mp_raise_ValueError("x or y out of range.");
-        else {
-            if (val < 0 || val > 255)
-                mp_raise_ValueError("val out of range. Expected 0 to 255");
-            else
-                scroll->set_pixel(x, y, val);
+    int x = mp_obj_get_int(args[1]);
+    int y = mp_obj_get_int(args[2]);
+    int val = mp_obj_get_int(args[3]);
+
+    if (x < 0 || x >= PicoScroll::WIDTH || y < 0 || y >= PicoScroll::HEIGHT)
+        mp_raise_ValueError("x or y out of range.");
+    if (val < 0 || val > 255)
+        mp_raise_ValueError("val out of range. Expected 0 to 255");
+
+    self->scroll->set_pixel(x, y, val);
+
+    return mp_const_none;
+}
+
+mp_obj_t picoscroll_scroll_text(mp_uint_t n_args, const mp_obj_t *args) {
+    (void)n_args; //Unused input parameter, we know it's self + 3
+   
+    PicoScroll_obj_t *self = MP_OBJ_TO_PTR2(args[0], PicoScroll_obj_t);
+
+    int brightness = mp_obj_get_int(args[2]);
+    int delay_ms = mp_obj_get_int(args[3]);
+
+    if(mp_obj_is_str_or_bytes(args[1])) {
+        GET_STR_DATA_LEN(args[1], str, str_len);
+
+        int draw_buffer_len = 6 * str_len;
+        char *draw_buffer = m_new(char, draw_buffer_len);
+
+        render_text((const char *)str, str_len, (unsigned char *)draw_buffer, draw_buffer_len);
+
+        for (int offset = -PicoScroll::WIDTH; offset < draw_buffer_len; offset++) {
+            self->scroll->clear();
+            self->scroll->set_bitmap_1d((const char *)draw_buffer, draw_buffer_len, brightness, offset);
+            self->scroll->update();
+    MICROPY_EVENT_POLL_HOOK
+            sleep_ms(delay_ms);
        }
-    } else
-        mp_raise_msg(&mp_type_RuntimeError, NOT_INITIALISED_MSG);

-    return mp_const_none;
-}
+        m_free(draw_buffer);

-mp_obj_t picoscroll_scroll_text(mp_obj_t text_obj, mp_obj_t brightness_obj,
-                                mp_obj_t delay_ms_obj) {
-    if (scroll != nullptr) {
-        mp_buffer_info_t bufinfo;
-        mp_get_buffer_raise(text_obj, &bufinfo, MP_BUFFER_READ);
-        int brightness = mp_obj_get_int(brightness_obj);
-        int delay_ms = mp_obj_get_int(delay_ms_obj);
-
-        scroll->scroll_text((const char *)bufinfo.buf, bufinfo.len, brightness, delay_ms);
-
-    } else {
-        mp_raise_msg(&mp_type_RuntimeError, NOT_INITIALISED_MSG);
+        self->scroll->clear();
+        self->scroll->update();
    }

    return mp_const_none;
 }

-mp_obj_t picoscroll_show_text(mp_obj_t text_obj, mp_obj_t brightness_obj,
-                              mp_obj_t offset_obj) {
-    if (scroll != nullptr) {
-        mp_buffer_info_t bufinfo;
-        mp_get_buffer_raise(text_obj, &bufinfo, MP_BUFFER_READ);
-        int brightness = mp_obj_get_int(brightness_obj);
-        int offset = mp_obj_get_int(offset_obj);
+mp_obj_t picoscroll_show_text(mp_uint_t n_args, const mp_obj_t *args) {
+    (void)n_args; //Unused input parameter, we know it's self + 3
+   
+    PicoScroll_obj_t *self = MP_OBJ_TO_PTR2(args[0], PicoScroll_obj_t);

-        scroll->set_text((const char *)bufinfo.buf, bufinfo.len, brightness, offset);
-    } else {
-        mp_raise_msg(&mp_type_RuntimeError, NOT_INITIALISED_MSG);
+    int brightness = mp_obj_get_int(args[2]);
+    int offset = mp_obj_get_int(args[3]);
+
+    if(mp_obj_is_str_or_bytes(args[1])) {
+        GET_STR_DATA_LEN(args[1], str, str_len);
+
+        int draw_buffer_len = 6 * str_len;
+        char *draw_buffer = m_new(char, draw_buffer_len);
+
+        render_text((const char *)str, str_len, (unsigned char *)draw_buffer, draw_buffer_len);
+        self->scroll->set_bitmap_1d((const char *)draw_buffer, draw_buffer_len, brightness, offset);
+
+        m_free(draw_buffer);
    }

    return mp_const_none;
 }

-mp_obj_t picoscroll_set_pixels(mp_obj_t image_obj) {
-    if (scroll != nullptr) {
-        mp_buffer_info_t bufinfo;
-        mp_get_buffer_raise(image_obj, &bufinfo, MP_BUFFER_RW);
+mp_obj_t picoscroll_set_pixels(mp_obj_t self_in, mp_obj_t image_obj) {
+    PicoScroll_obj_t *self = MP_OBJ_TO_PTR2(self_in, PicoScroll_obj_t);

-        if (bufinfo.len < (PicoScroll::WIDTH * PicoScroll::HEIGHT)) {
-            mp_raise_msg(&mp_type_IndexError, BUFFER_TOO_SMALL_MSG);
-        }
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(image_obj, &bufinfo, MP_BUFFER_RW);

-        scroll->set_pixels((const char*)bufinfo.buf);
-    } else
-        mp_raise_msg(&mp_type_RuntimeError, NOT_INITIALISED_MSG);
-
-    return mp_const_none;
-}
-
-mp_obj_t picoscroll_show_bitmap_1d(mp_obj_t bitmap_obj, mp_obj_t brightness_obj,
-                                   mp_obj_t offset_obj) {
-    if (scroll != nullptr) {
-        mp_buffer_info_t bufinfo;
-        mp_get_buffer_raise(bitmap_obj, &bufinfo, MP_BUFFER_RW);
-        int offset = mp_obj_get_int(offset_obj);
-        int brightness = mp_obj_get_int(brightness_obj);
-        int length = bufinfo.len;
-
-        // clear the scroll, so only need to write visible bytes
-        scroll->clear();
-
-        if ((offset < -PicoScroll::WIDTH) || (offset > length)) {
-            return mp_const_none;
-        }
-
-        scroll->set_bitmap_1d((const char *)bufinfo.buf, bufinfo.len, brightness, offset);
-    } else {
-        mp_raise_msg(&mp_type_RuntimeError, NOT_INITIALISED_MSG);
+    if (bufinfo.len < (PicoScroll::WIDTH * PicoScroll::HEIGHT)) {
+        mp_raise_msg(&mp_type_IndexError, BUFFER_TOO_SMALL_MSG);
    }

+    self->scroll->set_pixels((const char*)bufinfo.buf);
+
    return mp_const_none;
 }

-mp_obj_t picoscroll_clear() {
-    if (scroll != nullptr)
-        scroll->clear();
-    else
-        mp_raise_msg(&mp_type_RuntimeError, NOT_INITIALISED_MSG);
+mp_obj_t picoscroll_show_bitmap_1d(mp_uint_t n_args, const mp_obj_t *args) {
+    (void)n_args; //Unused input parameter, we know it's self + 3
+   
+    PicoScroll_obj_t *self = MP_OBJ_TO_PTR2(args[0], PicoScroll_obj_t);
+
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(args[1], &bufinfo, MP_BUFFER_RW);
+    int offset = mp_obj_get_int(args[3]);
+    int brightness = mp_obj_get_int(args[2]);
+    int length = bufinfo.len;
+
+    // clear the scroll, so only need to write visible bytes
+    self->scroll->clear();
+
+    if ((offset < -PicoScroll::WIDTH) || (offset > length)) {
+        return mp_const_none;
+    }
+
+    self->scroll->set_bitmap_1d((const char *)bufinfo.buf, bufinfo.len, brightness, offset);
+
    return mp_const_none;
 }

-mp_obj_t picoscroll_is_pressed(mp_obj_t button_obj) {
+mp_obj_t picoscroll_clear(mp_obj_t self_in) {
+    PicoScroll_obj_t *self = MP_OBJ_TO_PTR2(self_in, PicoScroll_obj_t);
+    self->scroll->clear();
+    return mp_const_none;
+}
+
+mp_obj_t picoscroll_is_pressed(mp_obj_t self_in, mp_obj_t button_obj) {
+    PicoScroll_obj_t *self = MP_OBJ_TO_PTR2(self_in, PicoScroll_obj_t);
+
    bool buttonPressed = false;
-    
-    if(scroll != nullptr) {
-        int buttonID = mp_obj_get_int(button_obj);    
-        switch(buttonID) {
-        case 0:
-            buttonPressed = scroll->is_pressed(PicoScroll::A);
-            break;

-        case 1:
-            buttonPressed = scroll->is_pressed(PicoScroll::B);
-            break;
+    int buttonID = mp_obj_get_int(button_obj);    
+    switch(buttonID) {
+    case 0:
+        buttonPressed = self->scroll->is_pressed(PicoScroll::A);
+        break;

-        case 2:
-            buttonPressed = scroll->is_pressed(PicoScroll::X);
-            break;
+    case 1:
+        buttonPressed = self->scroll->is_pressed(PicoScroll::B);
+        break;

-        case 3:
-            buttonPressed = scroll->is_pressed(PicoScroll::Y);
-            break;
+    case 2:
+        buttonPressed = self->scroll->is_pressed(PicoScroll::X);
+        break;

-        default:
-            mp_raise_ValueError("button not valid. Expected 0 to 3");
-            break;
-        }
+    case 3:
+        buttonPressed = self->scroll->is_pressed(PicoScroll::Y);
+        break;
+
+    default:
+        mp_raise_ValueError("button not valid. Expected 0 to 3");
+        break;
    }
-    else
-        mp_raise_msg(&mp_type_RuntimeError, NOT_INITIALISED_MSG);

    return buttonPressed ? mp_const_true : mp_const_false;
 }
--- a/micropython/modules/pico_scroll/pico_scroll.h
+++ b/micropython/modules/pico_scroll/pico_scroll.h
@ -1,15 +1,19 @@
 // Include MicroPython API.
 #include "py/runtime.h"
+#include "py/objstr.h"
+
+extern const mp_obj_type_t PicoScroll_type;

 // Declare the functions we'll make available in Python
-extern mp_obj_t picoscroll_init();
-extern mp_obj_t picoscroll_get_width();
-extern mp_obj_t picoscroll_get_height();
-extern mp_obj_t picoscroll_update();
-extern mp_obj_t picoscroll_set_pixel(mp_obj_t x_obj, mp_obj_t y_obj, mp_obj_t v_obj);
-extern mp_obj_t picoscroll_set_pixels(mp_obj_t image_obj);
-extern mp_obj_t picoscroll_show_text(mp_obj_t text_obj, mp_obj_t brightness, mp_obj_t offset);
-extern mp_obj_t picoscroll_scroll_text(mp_obj_t text_obj, mp_obj_t brightness, mp_obj_t delay);
-extern mp_obj_t picoscroll_show_bitmap_1d(mp_obj_t bitmap_obj, mp_obj_t brightness, mp_obj_t offset);
-extern mp_obj_t picoscroll_clear();
-extern mp_obj_t picoscroll_is_pressed(mp_obj_t button_obj);
+extern mp_obj_t picoscroll_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args);
+extern mp_obj_t picoscroll___del__(mp_obj_t self_in);
+extern mp_obj_t picoscroll_get_width(mp_obj_t self_in);
+extern mp_obj_t picoscroll_get_height(mp_obj_t self_in);
+extern mp_obj_t picoscroll_update(mp_obj_t self_in);
+extern mp_obj_t picoscroll_set_pixel(mp_uint_t n_args, const mp_obj_t *args);
+extern mp_obj_t picoscroll_set_pixels(mp_obj_t self_in, mp_obj_t image_obj);
+extern mp_obj_t picoscroll_show_text(mp_uint_t n_args, const mp_obj_t *args);
+extern mp_obj_t picoscroll_scroll_text(mp_uint_t n_args, const mp_obj_t *args);
+extern mp_obj_t picoscroll_show_bitmap_1d(mp_uint_t n_args, const mp_obj_t *args);
+extern mp_obj_t picoscroll_clear(mp_obj_t self_in);
+extern mp_obj_t picoscroll_is_pressed(mp_obj_t self_in, mp_obj_t button_obj);