Pico Scroll: Refactor to class.

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);

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);

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;
 }

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 y in range(0, HEIGHT):
-        for x in range(0, width):
+        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))

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)

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)
+- [Function reference](#function-reference)
-  - [init](#init)
+  - [get\_width](#get_width)
-  - [get_width](#get_width)
+  - [get\_height](#get_height)
-  - [get_height](#get_height)
+  - [set\_pixel](#set_pixel)
-  - [set_pixel](#set_pixel)
+  - [set\_pixels](#set_pixels)
-  - [set_pixels](#set_pixels)
+  - [show\_text](#show_text)
-  - [show_text](#show_text)
+  - [scroll\_text](#scroll_text)
-  - [scroll_text](#scroll_text)
+  - [show\_bitmap\_1d](#show_bitmap_1d)
-  - [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
 

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_1(picoscroll___del___obj, picoscroll___del__);
-STATIC MP_DEFINE_CONST_FUN_OBJ_0(picoscroll_get_width_obj, picoscroll_get_width);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(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_1(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_1(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_VAR_BETWEEN(picoscroll_set_pixel_obj, 4, 4, picoscroll_set_pixel);
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(picoscroll_set_pixels_obj, picoscroll_set_pixels);
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(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_VAR_BETWEEN(picoscroll_show_text_obj, 4, 4, picoscroll_show_text);
-STATIC MP_DEFINE_CONST_FUN_OBJ_3(picoscroll_scroll_text_obj, picoscroll_scroll_text);
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(picoscroll_scroll_text_obj, 4, 4, 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_VAR_BETWEEN(picoscroll_show_bitmap_1d_obj, 4, 4, picoscroll_show_bitmap_1d);
-STATIC MP_DEFINE_CONST_FUN_OBJ_0(picoscroll_clear_obj, picoscroll_clear);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(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_2(picoscroll_is_pressed_obj, picoscroll_is_pressed);
 
-/***** Globals Table *****/
+/* Class Methods */
-STATIC const mp_map_elem_t picoscroll_globals_table[] = {
+STATIC const mp_rom_map_elem_t picoscroll_locals[] = {
-    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_picoscroll) },
+    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&picoscroll___del___obj) },  
-    { MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&picoscroll_init_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,

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() {
+typedef struct _PicoScroll_obj_t {
-    if(scroll == nullptr)
+    mp_obj_base_t base;
-        scroll = m_tracked_alloc_class(PicoScroll);
+    PicoScroll* scroll;
-    scroll->init();
+} 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() {
+mp_obj_t picoscroll_update(mp_obj_t self_in) {
-    if(scroll != nullptr)
+    PicoScroll_obj_t *self = MP_OBJ_TO_PTR2(self_in, PicoScroll_obj_t);
-        scroll->update();
+    self->scroll->update();
-    else
-        mp_raise_msg(&mp_type_RuntimeError, NOT_INITIALISED_MSG);
     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) {
+mp_obj_t picoscroll_set_pixel(mp_uint_t n_args, const mp_obj_t *args) {
-    if (scroll != nullptr) {
+    (void)n_args; //Unused input parameter, we know it's self + 3
-        int x = mp_obj_get_int(x_obj);
+   
-        int y = mp_obj_get_int(y_obj);
+    PicoScroll_obj_t *self = MP_OBJ_TO_PTR2(args[0], PicoScroll_obj_t);
-        int val = mp_obj_get_int(v_obj);
 
-        if (x < 0 || x >= PicoScroll::WIDTH || y < 0 || y >= PicoScroll::HEIGHT)
+    int x = mp_obj_get_int(args[1]);
-            mp_raise_ValueError("x or y out of range.");
+    int y = mp_obj_get_int(args[2]);
-        else {
+    int val = mp_obj_get_int(args[3]);
-            if (val < 0 || val > 255)
+
-                mp_raise_ValueError("val out of range. Expected 0 to 255");
+    if (x < 0 || x >= PicoScroll::WIDTH || y < 0 || y >= PicoScroll::HEIGHT)
-            else
+        mp_raise_ValueError("x or y out of range.");
-                scroll->set_pixel(x, y, val);
+    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,
+        self->scroll->clear();
-                                mp_obj_t delay_ms_obj) {
+        self->scroll->update();
-    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);
     }
 
     return mp_const_none;
 }
 
-mp_obj_t picoscroll_show_text(mp_obj_t text_obj, mp_obj_t brightness_obj,
+mp_obj_t picoscroll_show_text(mp_uint_t n_args, const mp_obj_t *args) {
-                              mp_obj_t offset_obj) {
+    (void)n_args; //Unused input parameter, we know it's self + 3
-    if (scroll != nullptr) {
+   
-        mp_buffer_info_t bufinfo;
+    PicoScroll_obj_t *self = MP_OBJ_TO_PTR2(args[0], PicoScroll_obj_t);
-        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);
 
-        scroll->set_text((const char *)bufinfo.buf, bufinfo.len, brightness, offset);
+    int brightness = mp_obj_get_int(args[2]);
-    } else {
+    int offset = mp_obj_get_int(args[3]);
-        mp_raise_msg(&mp_type_RuntimeError, NOT_INITIALISED_MSG);
+
+    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) {
+mp_obj_t picoscroll_set_pixels(mp_obj_t self_in, mp_obj_t image_obj) {
-    if (scroll != nullptr) {
+    PicoScroll_obj_t *self = MP_OBJ_TO_PTR2(self_in, PicoScroll_obj_t);
-        mp_buffer_info_t bufinfo;
-        mp_get_buffer_raise(image_obj, &bufinfo, MP_BUFFER_RW);
 
-        if (bufinfo.len < (PicoScroll::WIDTH * PicoScroll::HEIGHT)) {
+    mp_buffer_info_t bufinfo;
-            mp_raise_msg(&mp_type_IndexError, BUFFER_TOO_SMALL_MSG);
+    mp_get_buffer_raise(image_obj, &bufinfo, MP_BUFFER_RW);
-        }
 
-        scroll->set_pixels((const char*)bufinfo.buf);
+    if (bufinfo.len < (PicoScroll::WIDTH * PicoScroll::HEIGHT)) {
-    } else
+        mp_raise_msg(&mp_type_IndexError, BUFFER_TOO_SMALL_MSG);
-        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);
     }
 
+    self->scroll->set_pixels((const char*)bufinfo.buf);
+
     return mp_const_none;
 }
 
-mp_obj_t picoscroll_clear() {
+mp_obj_t picoscroll_show_bitmap_1d(mp_uint_t n_args, const mp_obj_t *args) {
-    if (scroll != nullptr)
+    (void)n_args; //Unused input parameter, we know it's self + 3
-        scroll->clear();
+   
-    else
+    PicoScroll_obj_t *self = MP_OBJ_TO_PTR2(args[0], PicoScroll_obj_t);
-        mp_raise_msg(&mp_type_RuntimeError, NOT_INITIALISED_MSG);
+
+    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:
+    int buttonID = mp_obj_get_int(button_obj);    
-            buttonPressed = scroll->is_pressed(PicoScroll::B);
+    switch(buttonID) {
-            break;
+    case 0:
+        buttonPressed = self->scroll->is_pressed(PicoScroll::A);
+        break;
 
-        case 2:
+    case 1:
-            buttonPressed = scroll->is_pressed(PicoScroll::X);
+        buttonPressed = self->scroll->is_pressed(PicoScroll::B);
-            break;
+        break;
 
-        case 3:
+    case 2:
-            buttonPressed = scroll->is_pressed(PicoScroll::Y);
+        buttonPressed = self->scroll->is_pressed(PicoScroll::X);
-            break;
+        break;
 
-        default:
+    case 3:
-            mp_raise_ValueError("button not valid. Expected 0 to 3");
+        buttonPressed = self->scroll->is_pressed(PicoScroll::Y);
-            break;
+        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;
 }

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_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_get_width();
+extern mp_obj_t picoscroll___del__(mp_obj_t self_in);
-extern mp_obj_t picoscroll_get_height();
+extern mp_obj_t picoscroll_get_width(mp_obj_t self_in);
-extern mp_obj_t picoscroll_update();
+extern mp_obj_t picoscroll_get_height(mp_obj_t self_in);
-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_update(mp_obj_t self_in);
-extern mp_obj_t picoscroll_set_pixels(mp_obj_t image_obj);
+extern mp_obj_t picoscroll_set_pixel(mp_uint_t n_args, const mp_obj_t *args);
-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_set_pixels(mp_obj_t self_in, mp_obj_t image_obj);
-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_text(mp_uint_t n_args, const mp_obj_t *args);
-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_scroll_text(mp_uint_t n_args, const mp_obj_t *args);
-extern mp_obj_t picoscroll_clear();
+extern mp_obj_t picoscroll_show_bitmap_1d(mp_uint_t n_args, const mp_obj_t *args);
-extern mp_obj_t picoscroll_is_pressed(mp_obj_t button_obj);
+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);