Parallel RG for HUB12 cards

[wsandor]

Hi Everybody,
I would like to share some new features I addad to the library for my own purposes, but they might be useful for others also. The main goal I wanted to achive is to be able to use HUB12 RG panels (previously I used them with an Atmel microcontroller) and use RGB panels also with the same new driver card, based on the RP2040 microcontroller.
Based on the monochrome_parallel part of the library I wrote my RG_parallel part, which can outputs to 4 rows of HUB12 RG cards parallel.

If we choose the outputs properly and if 1/16 scanning for RGB is enough, then we can use the same pins for RGB also (not the same time)

And to be able to choose the place of the first RGB card I also extended the library with a new connect scheme -CONNECT_TOPDOWN:

And here is the connection diagramm of the output connectors:

Here is an example of the DMD init from the main program:

#define DISPLAYS_ACROSS 3
#define DISPLAYS_DOWN 2

//#define DualColor   // for RG panels

#ifdef DualColor
  #include "DMD_RG_Parallel.h"
  // mux pins - A, B
  #define DMD_PIN_A 8  //ADX2
  #define DMD_PIN_B 9  //ADX3
  #define DMD_PIN_nOE 12
  #define DMD_PIN_SCLK 11   //LAT

  uint8_t pins[] = {10,0,1,2,3,4,5,6,7}; // CLK, R0, G0, R1, G1, R2, G2, R3, G3
  
  #define MATRIX_TYPE RG16x8_S1 //RG32x16_S4
  //Fire up the DMD object as dmd
  DMD_RG_Parallel<MATRIX_TYPE> dmd(DMD_PIN_A, DMD_PIN_B, DMD_PIN_nOE, DMD_PIN_SCLK, pins, DISPLAYS_ACROSS, DISPLAYS_DOWN,ENABLE_DUAL_BUFFER);
  
  static const uint16_t SCREENWIDTH = DMD_RG_Parallel <MATRIX_TYPE>::modWidth * DISPLAYS_ACROSS;
  static const uint16_t SCREENHEIGHT = DMD_RG_Parallel <MATRIX_TYPE>::modHeight * DISPLAYS_DOWN;
#else         // for RGB panels
  #include "DMD_RGB.h"
  // ==== DMD_RGB pins ====
  // mux pins - A, B, C... all mux pins must be selected from same port!
  #define DMD_PIN_A 6  //ADX0
  #define DMD_PIN_B 7  //ADX1
  #define DMD_PIN_C 8  //ADX2
  #define DMD_PIN_D 9  //ADX3
  //#define DMD_PIN_E 10
  uint8_t mux_list[] = { DMD_PIN_A , DMD_PIN_B , DMD_PIN_C , DMD_PIN_D};

  // pin OE must be one of PB0 PB1 PA6 PA7
  #define DMD_PIN_nOE 12
  #define DMD_PIN_SCLK 11  //LAT

  // Pins for R0, G0, B0, R1, G1, B1 channels and for clock.
  uint8_t custom_rgbpins[] = {10,0,1,2,3,4,5 }; // CLK, R0, G0, B0, R1, G1, B1
 
  // Color depth - <COLOR_4BITS> or <COLOR_1BITS>
  #define COLOR_DEPTH COLOR_4BITS
  
  #define MATRIX_TYPE RGB32x16_S4_P10RGB_3535_4S_V3_6   

  // Fire up the DMD object as dmd<MATRIX_TYPE, COLOR_DEPTH>
  DMD_RGB <MATRIX_TYPE, COLOR_DEPTH> dmd(mux_list, DMD_PIN_nOE, DMD_PIN_SCLK, custom_rgbpins, DISPLAYS_ACROSS, DISPLAYS_DOWN, ENABLE_DUAL_BUFFER); 
  
  static const uint16_t SCREENWIDTH = DMD_RGB <MATRIX_TYPE, COLOR_DEPTH>::modWidth * DISPLAYS_ACROSS;
  static const uint16_t SCREENHEIGHT = DMD_RGB <MATRIX_TYPE, COLOR_DEPTH>::modHeight * DISPLAYS_DOWN;
#endif

I've added two new constants to the matrix definition: modWidth and modHeight which are the sizes in pixels of the used modules. With the aid of them only DISPLAYS_ACROSS and DISPLAYS_DOWN should be set at the beginning and if the matrix type is set them the matrix size can be easily calculated. (Maybe this can be done from the original code also, but I couldn't find how)

Limitations:
-The work is still in progress, so some parts may not work as expected.
-I've left the STM parts in the code, but this part probably broken as I only dealt with the RP2040.
-The parallel RG part works with 1 bit color depth only. (as the original monochrome_parallel)
-The new CONNECT_TOPDOWN scheme is only implemented in the new RGB matrix types that I've added.

And here are the code: (it is based on VERSION 0.9.4 of the original library)
DMD_RG_Parallel.zip

[board707]

Thanks for the detailed explanation. I finally figured out which connection you meant.
On RP2040 boards the number of parallel output lines can be even more than 8 - if you change the data buffer format from 8-bit to 16-bit. For STM32 boards, a different principle of output to the matrix is ​​used, and one of the lines must be given to the CLK signal. So the current library code can only support 7 parallel outputs - to which you can only connect three rows of RG matrices
Regarding the code - it seems to me that it would be easier to inherit your class from DMD_Monochrome_Parallel - you could use ready-made methods for outputting data to a matrix, determining coordinates, and scrolling.

Unfortunately, I doubt that I will add your class to the main library - since I do not have RG matrices for tests

[wsandor]

On RP2040 boards the number of parallel output lines can be even more than 8 - if you change the data buffer format from 8-bit to 16-bit.

It could be interesting. For RG the 4 outputs are enough for me - because this way it is compatible with my old Atmel card, but for RGB a 2nd output would be great. The problem is that the RP2040 has not too many pins and I need some for other functions also.

Regarding the code - it seems to me that it would be easier to inherit your class from DMD_Monochrome_Parallel - you could use ready-made methods for outputting data to a matrix, determining coordinates, and scrolling.

Basically I copied DMD_Monochrome_Parallel and changed what needed. You are right it might be easier to just inherit from it, but in this way it become independent from it.