PicoVector Enhancements & PicoGraphics Layers

drivers/hub75/hub75.cpp

@@ -2,6 +2,8 @@
 #include <algorithm>
 #include <cmath>
 
+#include "hardware/clocks.h"
+
 #include "hub75.hpp"
 
 namespace pimoroni {
@@ -37,10 +39,48 @@ Hub75::Hub75(uint width, uint height, Pixel *buffer, PanelType panel_type, bool
     }
 
     if (brightness == 0) {
+#if PICO_RP2350
+        brightness = 6;
+#else
         if (width >= 64) brightness = 6;
         if (width >= 96) brightness = 3;
         if (width >= 128) brightness = 2;
         if (width >= 160) brightness = 1;
+#endif
+    }
+
+    switch (color_order) {
+        case COLOR_ORDER::RGB:
+            r_shift = 0;
+            g_shift = 10;
+            b_shift = 20;
+            break;
+        case COLOR_ORDER::RBG:
+            r_shift = 0;
+            g_shift = 20;
+            b_shift = 10;
+            break;
+        case COLOR_ORDER::GRB:
+            r_shift = 20;
+            g_shift = 0;
+            b_shift = 10;
+            break;
+        case COLOR_ORDER::GBR:
+            r_shift = 10;
+            g_shift = 20;
+            b_shift = 0;
+            break;
+        case COLOR_ORDER::BRG:
+            r_shift = 10;
+            g_shift = 00;
+            b_shift = 20;
+            break;
+        case COLOR_ORDER::BGR:
+            r_shift = 20;
+            g_shift = 10;
+            b_shift = 0;
+            break;
+
     }
 }
 
@@ -58,26 +98,16 @@ void Hub75::set_color(uint x, uint y, Pixel c) {
 }
 
 void Hub75::set_pixel(uint x, uint y, uint8_t r, uint8_t g, uint8_t b) {
-    switch(color_order) {
-        case COLOR_ORDER::RGB:
-            set_color(x, y, Pixel(r, g, b));
-            break;
-        case COLOR_ORDER::RBG:
-            set_color(x, y, Pixel(r, b, g));
-            break;
-        case COLOR_ORDER::GRB:
-            set_color(x, y, Pixel(g, r, b));
-            break;
-        case COLOR_ORDER::GBR:
-            set_color(x, y, Pixel(g, b, r));
-            break;
-        case COLOR_ORDER::BRG:
-            set_color(x, y, Pixel(b, r, g));
-            break;
-        case COLOR_ORDER::BGR:
-            set_color(x, y, Pixel(b, g, r));
-            break;
+    int offset = 0;
+    if(x >= width || y >= height) return;
+    if(y >= height / 2) {
+        y -= height / 2;
+        offset = (y * width + x) * 2;
+        offset += 1;
+    } else {
+        offset = (y * width + x) * 2;
     }
+    back_buffer[offset] = (GAMMA_10BIT[b] << b_shift) | (GAMMA_10BIT[g] << g_shift) | (GAMMA_10BIT[r] << r_shift);
 }
 
 void Hub75::FM6126A_write_register(uint16_t value, uint8_t position) {
@@ -117,6 +147,8 @@ void Hub75::start(irq_handler_t handler) {
             FM6126A_setup();
         }
 
+        uint latch_cycles = clock_get_hz(clk_sys) / 4000000;
+
         // Claim the PIO so we can clean it upon soft restart
         pio_sm_claim(pio, sm_data);
         pio_sm_claim(pio, sm_row);
@@ -128,7 +160,7 @@ void Hub75::start(irq_handler_t handler) {
             row_prog_offs = pio_add_program(pio, &hub75_row_program);
         }
         hub75_data_rgb888_program_init(pio, sm_data, data_prog_offs, DATA_BASE_PIN, pin_clk);
-        hub75_row_program_init(pio, sm_row, row_prog_offs, ROWSEL_BASE_PIN, ROWSEL_N_PINS, pin_stb);
+        hub75_row_program_init(pio, sm_row, row_prog_offs, ROWSEL_BASE_PIN, ROWSEL_N_PINS, pin_stb, latch_cycles);
 
         // Prevent flicker in Python caused by the smaller dataset just blasting through the PIO too quickly
         pio_sm_set_clkdiv(pio, sm_data, width <= 32 ? 2.0f : 1.0f);
@@ -247,28 +279,88 @@ void Hub75::dma_complete() {
 
 void Hub75::update(PicoGraphics *graphics) {
     if(graphics->pen_type == PicoGraphics::PEN_RGB888) {
-        uint32_t *p = (uint32_t *)graphics->frame_buffer;
-        for(uint y = 0; y < height; y++) {
-            for(uint x = 0; x < width; x++) {
-                uint32_t col = *p;
-                uint8_t r = (col & 0xff0000) >> 16;
-                uint8_t g = (col & 0x00ff00) >>  8;
-                uint8_t b = (col & 0x0000ff) >>  0;
-                set_pixel(x, y, r, g, b);
-                p++;
+        uint8_t *p = (uint8_t *)graphics->frame_buffer;
+        if(graphics->bounds.w == int32_t(width / 2) && graphics->bounds.h == int32_t(height * 2)) {
+            for(int y = 0; y <  graphics->bounds.h; y++) {
+                int offsety = 0;
+                int sy = y;
+                int basex = 0;
+
+                // Assuming our canvas is 128x128 and our display is 256x64,
+                // consisting of 2x128x64 panels, remap the bottom half
+                // of the canvas to the right-half of the display,
+                // This gives us an optional square arrangement.
+                if (sy >= int(height)) {
+                    sy -= height;
+                    basex = width / 2;
+                } else {
+                    // Awkward hack to *TEMPORARILY* rotate the top panel
+                    sy = height - 1 - sy;
+                    basex = (width / 2) - 1;
+                }
+
+                // Interlace the top and bottom halves of the panel.
+                // Since these are scanned out simultaneously to two chains
+                // of shift registers we need each pair of rows
+                // (N and N + height / 2) to be adjacent in the buffer.
+                offsety = width * 2;
+                if(sy >= int(height / 2)) {
+                    sy -= height / 2;
+                    offsety *= sy;
+                    offsety += 1;
+                } else {
+                    offsety *= sy;
+                }
+
+                for(int x = 0; x < graphics->bounds.w; x++) {
+                    int sx = x;
+                    uint8_t b = *p++;
+                    uint8_t g = *p++;
+                    uint8_t r = *p++;
+
+                    // Assumes width / 2 is even.
+                    if (basex & 1) {
+                        sx = basex - sx;
+                    } else {
+                        sx += basex;
+                    }
+                    int offset = offsety + sx * 2;
+
+                    back_buffer[offset] = (GAMMA_10BIT[b] << b_shift) | (GAMMA_10BIT[g] << g_shift) | (GAMMA_10BIT[r] << r_shift);
+
+                    // Skip the empty byte in out 32-bit aligned 24-bit colour.
+                    p++;
+                }
             }
-        }
-    }
-    else if(graphics->pen_type == PicoGraphics::PEN_RGB565) {
-        uint16_t *p = (uint16_t *)graphics->frame_buffer;
-        for(uint y = 0; y < height; y++) {
-            for(uint x = 0; x < width; x++) {
-                uint16_t col = __builtin_bswap16(*p);
-                uint8_t r = (col & 0b1111100000000000) >> 8;
-                uint8_t g = (col & 0b0000011111100000) >> 3;
-                uint8_t b = (col & 0b0000000000011111) << 3;
-                set_pixel(x, y, r, g, b);
-                p++;
+        } else {
+            for(uint y = 0; y < height; y++) {
+                for(uint x = 0; x < width; x++) {
+                    int offset = 0;
+                    int sy = y;
+                    int sx = x;
+                    uint8_t b = *p++;
+                    uint8_t g = *p++;
+                    uint8_t r = *p++;
+
+                    // Interlace the top and bottom halves of the panel.
+                    // Since these are scanned out simultaneously to two chains
+                    // of shift registers we need each pair of rows
+                    // (N and N + height / 2) to be adjacent in the buffer.
+                    offset = width * 2;
+                    if(sy >= int(height / 2)) {
+                        sy -= height / 2;
+                        offset *= sy;
+                        offset += 1;
+                    } else {
+                        offset *= sy;
+                    }
+                    offset += sx * 2;
+
+                    back_buffer[offset] = (GAMMA_10BIT[b] << b_shift) | (GAMMA_10BIT[g] << g_shift) | (GAMMA_10BIT[r] << r_shift);
+
+                    // Skip the empty byte in out 32-bit aligned 24-bit colour.
+                    p++;
+                }
             }
         }
     }

drivers/hub75/hub75.hpp

@@ -65,6 +65,9 @@ class Hub75 {
     };
     uint width;
     uint height;
+    uint r_shift = 0;
+    uint g_shift = 10;
+    uint b_shift = 20;
     Pixel *back_buffer;
     bool managed_buffer = false;
     PanelType panel_type;

drivers/hub75/hub75.pio

@@ -21,7 +21,10 @@
 
 .wrap_target
     out pins, 5 [1]    side 0x2 ; Deassert OEn, output row select
-    out x, 27   [7]    side 0x3 ; Pulse LATCH, get OEn pulse width
+    mov x, y    [3]    side 0x3 ; Pulse LATCH
+wait_loop:
+    jmp x-- wait_loop  side 0x2 ; Wait for row to latch
+    out x, 27          side 0x2 ; Get OEn pulse width
 pulse_loop:
     jmp x-- pulse_loop side 0x0 ; Assert OEn for x+1 cycles
 .wrap
@@ -43,13 +46,16 @@ pulse_loop:
 
 .wrap_target
     out pins, 5 [1]    side 0x3 ; Deassert OEn, output row select
-    out x, 27   [7]    side 0x2 ; Pulse LATCH, get OEn pulse width
+    mov x, y    [3]    side 0x2 ; Pulse LATCH
+wait_loop:
+    jmp x-- wait_loop  side 0x3 ; Wait for row to latch
+    out x, 27          side 0x3 ; Get OEn pulse width
 pulse_loop:
     jmp x-- pulse_loop side 0x1 ; Assert OEn for x+1 cycles
 .wrap
 
 % c-sdk {
-static inline void hub75_row_program_init(PIO pio, uint sm, uint offset, uint row_base_pin, uint n_row_pins, uint latch_base_pin) {
+static inline void hub75_row_program_init(PIO pio, uint sm, uint offset, uint row_base_pin, uint n_row_pins, uint latch_base_pin, uint latch_cycles) {
     pio_sm_set_consecutive_pindirs(pio, sm, row_base_pin, n_row_pins, true);
     pio_sm_set_consecutive_pindirs(pio, sm, latch_base_pin, 2, true);
     for (uint i = row_base_pin; i < row_base_pin + n_row_pins; ++i)
@@ -62,6 +68,8 @@ static inline void hub75_row_program_init(PIO pio, uint sm, uint offset, uint ro
     sm_config_set_sideset_pins(&c, latch_base_pin);
     sm_config_set_out_shift(&c, true, true, 32);
     pio_sm_init(pio, sm, offset, &c);
+    pio_sm_exec(pio, sm, pio_encode_out(pio_y, 32));
+    pio_sm_put(pio, sm, latch_cycles);
     pio_sm_set_enabled(pio, sm, true);
 }
 

drivers/plasma/apa102.cpp

@@ -4,10 +4,26 @@
 namespace plasma {
 
 APA102::APA102(uint num_leds, PIO pio, uint sm, uint pin_dat, uint pin_clk, uint freq, RGB* buffer) : buffer(buffer), num_leds(num_leds), pio(pio), sm(sm) {
+    // NOTE: This sets the gpio_base for *the entire PIO* not just this state machine
+    uint range_max = std::max(pin_dat, pin_clk);
+    uint range_min = std::min(pin_dat, pin_clk);
+
+    // Both pins in 16-48 range
+    if(range_max >= 32 && range_min >= 16) {
+        pio_set_gpio_base(pio, 16);
+    // Both pins in 0-31 range
+    } else if(range_max <= 31) {
+        pio_set_gpio_base(pio, 0);
+    // Pins in different ranges: invalid combo!
+    } else {
+        // TODO: Need some means to notify the caller
+        pio_set_gpio_base(pio, 0);
+    }
+
     pio_program_offset = pio_add_program(pio, &apa102_program);
 
-    pio_sm_set_pins_with_mask(pio, sm, 0, (1u << pin_clk) | (1u << pin_dat));
-    pio_sm_set_pindirs_with_mask(pio, sm, ~0u, (1u << pin_clk) | (1u << pin_dat));
+    pio_sm_set_pins_with_mask(pio, sm, 0, (1u << (pin_clk - pio_get_gpio_base(pio))) | (1u << (pin_dat - pio_get_gpio_base(pio))));
+    pio_sm_set_pindirs_with_mask(pio, sm, ~0u, (1u << (pin_clk - pio_get_gpio_base(pio))) | (1u << (pin_dat - pio_get_gpio_base(pio))));
     pio_gpio_init(pio, pin_clk);
     pio_gpio_init(pio, pin_dat);
 

drivers/plasma/ws2812.cpp

@@ -4,6 +4,9 @@
 namespace plasma {
 
 WS2812::WS2812(uint num_leds, PIO pio, uint sm, uint pin, uint freq, bool rgbw, COLOR_ORDER color_order, RGB* buffer) : buffer(buffer), num_leds(num_leds), color_order(color_order), pio(pio), sm(sm) {
+    // NOTE: This sets the gpio_base for *the entire PIO* not just this state machine
+    pio_set_gpio_base(pio, pin >= 32 ? 16 : 0);
+
     pio_program_offset = pio_add_program(pio, &ws2812_program);
 
     pio_gpio_init(pio, pin);

drivers/st7735/st7735.cpp

@@ -165,7 +165,7 @@ namespace pimoroni {
 
   // Native 16-bit framebuffer update
   void ST7735::update(PicoGraphics *graphics) {
-    if(graphics->pen_type == PicoGraphics::PEN_RGB565) {
+    if(graphics->pen_type == PicoGraphics::PEN_RGB565 && graphics->layers == 1) {
       command(reg::RAMWR, width * height * sizeof(uint16_t), (const char*)graphics->frame_buffer);
     } else {
       command(reg::RAMWR);

drivers/st7789/st7789.cpp

@@ -282,7 +282,7 @@ namespace pimoroni {
   void ST7789::update(PicoGraphics *graphics) {
     uint8_t cmd = reg::RAMWR;
 
-    if(graphics->pen_type == PicoGraphics::PEN_RGB565) { // Display buffer is screen native
+    if(graphics->pen_type == PicoGraphics::PEN_RGB565 && graphics->layers == 1) { // Display buffer is screen native
       command(cmd, width * height * sizeof(uint16_t), (const char*)graphics->frame_buffer);
     } else {
       gpio_put(dc, 0); // command mode

examples/CMakeLists.txt

@@ -63,3 +63,4 @@ add_subdirectory(galactic_unicorn)
 add_subdirectory(gfx_pack)
 add_subdirectory(cosmic_unicorn)
 add_subdirectory(stellar_unicorn)
+add_subdirectory(pico_w_explorer)

examples/pico_display_2/CMakeLists.txt

@@ -1,14 +1,3 @@
 add_subdirectory(mandelbrot)
-
-set(OUTPUT_NAME pico_display2_demo)
-
-add_executable(
-  ${OUTPUT_NAME}
-  pico_display_2_demo.cpp
-)
-
-# Pull in pico libraries that we need
-target_link_libraries(${OUTPUT_NAME} pico_stdlib hardware_spi hardware_pwm hardware_dma rgbled button pico_display_2 st7789 pico_graphics)
-
-# create map/bin/hex file etc.
-pico_add_extra_outputs(${OUTPUT_NAME})
+include(pico_display_2_demo.cmake)
+include(pico_display_2_vector.cmake)

examples/pico_display_2/pico_display_2_demo.cmake

@@ -0,0 +1,10 @@
+add_executable(
+  pico_display_2_demo
+  pico_display_2_demo.cpp
+)
+
+# Pull in pico libraries that we need
+target_link_libraries(pico_display_2_demo pico_stdlib hardware_spi hardware_pwm hardware_dma rgbled button pico_display_2 st7789 pico_graphics)
+
+# create map/bin/hex file etc.
+pico_add_extra_outputs(pico_display_2_demo)