First test of support for dual hub75s

Author: ZodiusInfuser

drivers/hub75/hub75.cpp

@@ -8,9 +8,28 @@
 
 namespace pimoroni {
 
-Hub75::Hub75(uint width, uint height, Pixel *buffer, PanelType panel_type, bool inverted_stb, COLOR_ORDER color_order)
- : width(width), height(height), panel_type(panel_type), inverted_stb(inverted_stb), color_order(color_order)
+Hub75::Hub75(uint width, uint height, Pixel *buffer, PanelType panel_type, bool inverted_stb, COLOR_ORDER color_order, bool duo)
+ : width(width), height(height), panel_type(panel_type), inverted_stb(inverted_stb), color_order(color_order), duo_mode(duo)
  {
+    if(duo) {
+        pin_r0 += 32;
+        pin_g0 += 32;
+        pin_b0 += 32;
+        pin_r1 += 32;
+        pin_g1 += 32;
+        pin_b1 += 32;
+        pin_row_a += 32;
+        pin_row_b += 32;
+        pin_row_c += 32;
+        pin_row_d += 32;
+        pin_row_e += 32;
+        pin_clk += 32;
+        pin_stb += 32;
+        pin_oe += 32;
+        pio = pio1;
+        pio_set_gpio_base(pio, 16);
+    }
+
     // Set up allllll the GPIO
     gpio_init(pin_r0); gpio_set_function(pin_r0, GPIO_FUNC_SIO); gpio_set_dir(pin_r0, true); gpio_put(pin_r0, 0);
     gpio_init(pin_g0); gpio_set_function(pin_g0, GPIO_FUNC_SIO); gpio_set_dir(pin_g0, true); gpio_put(pin_g0, 0);
@@ -159,8 +178,15 @@ void Hub75::start(irq_handler_t handler) {
         } else {
             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, latch_cycles);
+
+        if(duo_mode) {
+            hub75_data_rgb888_program_init(pio, sm_data, data_prog_offs, DUO_DATA_BASE_PIN, pin_clk);
+            hub75_row_program_init(pio, sm_row, row_prog_offs, DUO_ROWSEL_BASE_PIN, ROWSEL_N_PINS, pin_stb, latch_cycles);
+        }
+        else {
+            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, 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);

drivers/hub75/hub75.hpp

@@ -17,6 +17,9 @@ const uint ROWSEL_BASE_PIN = 6;
 const uint ROWSEL_N_PINS = 5;
 const uint BIT_DEPTH = 10;
 
+const uint DUO_DATA_BASE_PIN = 0 + 32;
+const uint DUO_ROWSEL_BASE_PIN = 6 + 32;
+
 /*
 10-bit gamma table, allowing us to gamma correct our 8-bit colour values up
 to 10-bit without losing dynamic range.
@@ -86,6 +89,7 @@ class Hub75 {
     PanelType panel_type;
     bool inverted_stb = false;
     COLOR_ORDER color_order;
+    bool duo_mode = false;
     Pixel background = 0;
 
     // DMA & PIO
@@ -140,7 +144,7 @@ class Hub75 {
     Hub75(uint width, uint height) : Hub75(width, height, nullptr) {};
     Hub75(uint width, uint height, Pixel *buffer) : Hub75(width, height, buffer, PANEL_GENERIC) {};
     Hub75(uint width, uint height, Pixel *buffer, PanelType panel_type) : Hub75(width, height, buffer, panel_type, false) {};
-    Hub75(uint width, uint height, Pixel *buffer, PanelType panel_type, bool inverted_stb, COLOR_ORDER color_order=COLOR_ORDER::RGB);
+    Hub75(uint width, uint height, Pixel *buffer, PanelType panel_type, bool inverted_stb, COLOR_ORDER color_order=COLOR_ORDER::RGB, bool duo=false);
     ~Hub75();
 
     void FM6126A_write_register(uint16_t value, uint8_t position);

drivers/hub75/hub75.pio

@@ -56,16 +56,16 @@ pulse_loop:
 
 % 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, 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);
+    pio_sm_set_consecutive_pindirs(pio, sm, row_base_pin - pio_get_gpio_base(pio), n_row_pins, true);
+    pio_sm_set_consecutive_pindirs(pio, sm, latch_base_pin - pio_get_gpio_base(pio), 2, true);
     for (uint i = row_base_pin; i < row_base_pin + n_row_pins; ++i)
         pio_gpio_init(pio, i);
     pio_gpio_init(pio, latch_base_pin);
     pio_gpio_init(pio, latch_base_pin + 1);
 
     pio_sm_config c = hub75_row_program_get_default_config(offset);
-    sm_config_set_out_pins(&c, row_base_pin, n_row_pins);
-    sm_config_set_sideset_pins(&c, latch_base_pin);
+    sm_config_set_out_pins(&c, row_base_pin - pio_get_gpio_base(pio), n_row_pins);
+    sm_config_set_sideset_pins(&c, latch_base_pin - pio_get_gpio_base(pio));
     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));
@@ -135,15 +135,15 @@ public shift1:              ; R1 G1 B1 (Bottom half of 64x64 displays)
 
 % c-sdk {
 static inline void hub75_data_rgb888_program_init(PIO pio, uint sm, uint offset, uint rgb_base_pin, uint clock_pin) {
-    pio_sm_set_consecutive_pindirs(pio, sm, rgb_base_pin, 6, true);
-    pio_sm_set_consecutive_pindirs(pio, sm, clock_pin, 1, true);
+    pio_sm_set_consecutive_pindirs(pio, sm, rgb_base_pin - pio_get_gpio_base(pio), 6, true);
+    pio_sm_set_consecutive_pindirs(pio, sm, clock_pin - pio_get_gpio_base(pio), 1, true);
     for (uint i = rgb_base_pin; i < rgb_base_pin + 6; ++i)
         pio_gpio_init(pio, i);
     pio_gpio_init(pio, clock_pin);
 
     pio_sm_config c = hub75_data_rgb888_program_get_default_config(offset);
-    sm_config_set_out_pins(&c, rgb_base_pin, 6);
-    sm_config_set_sideset_pins(&c, clock_pin);
+    sm_config_set_out_pins(&c, rgb_base_pin - pio_get_gpio_base(pio), 6);
+    sm_config_set_sideset_pins(&c, clock_pin - pio_get_gpio_base(pio));
     sm_config_set_out_shift(&c, true, true, 32);
     // ISR shift to left. R0 ends up at bit 5. We push it up to MSB and then flip the register.
     sm_config_set_in_shift(&c, false, false, 32);

micropython/modules/hub75/hub75.cpp

@@ -86,7 +86,8 @@ mp_obj_t Hub75_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, c
         ARG_buffer,
         ARG_panel_type,
         ARG_stb_invert,
-        ARG_color_order
+        ARG_color_order,
+        ARG_duo
     };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_width, MP_ARG_REQUIRED | MP_ARG_INT },
@@ -95,6 +96,7 @@ mp_obj_t Hub75_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, c
         { MP_QSTR_panel_type, MP_ARG_INT, {.u_int = 0} },
         { MP_QSTR_stb_invert, MP_ARG_INT, {.u_int = 0} },
         { MP_QSTR_color_order, MP_ARG_INT, {.u_int = (uint8_t)Hub75::COLOR_ORDER::RGB} },
+        { MP_QSTR_duo, MP_ARG_INT, {.u_int = 0} },
     };
 
     // Parse args.
@@ -106,6 +108,7 @@ mp_obj_t Hub75_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, c
     PanelType paneltype = (PanelType)args[ARG_panel_type].u_int;
     bool stb_invert = args[ARG_stb_invert].u_int;
     Hub75::COLOR_ORDER color_order = (Hub75::COLOR_ORDER)args[ARG_color_order].u_int;
+    bool duo_mode = args[ARG_duo].u_int;
 
     Pixel *buffer = nullptr;
 
@@ -122,7 +125,7 @@ mp_obj_t Hub75_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, c
 
     hub75_obj = mp_obj_malloc_with_finaliser(_Hub75_obj_t, &Hub75_type);
     hub75_obj->buf = buffer;
-    hub75_obj->hub75 = m_new_class(Hub75, width, height, buffer, paneltype, stb_invert, color_order);
+    hub75_obj->hub75 = m_new_class(Hub75, width, height, buffer, paneltype, stb_invert, color_order, duo_mode);
 
     return MP_OBJ_FROM_PTR(hub75_obj);
 }