Add Quarter scan panel in 3 steps

[board707]

I am goimg to show how I added support for my 1/4 scan panel to the library.

It is a p10 32x16 1/4 scan matrix, and what is typical for 32x16 panels is that not only 4 lines are updated simultaneously, but the pixels are connected in an ambiguous order, which at first glance seems random.
First, I tried to use the panel with the code from Four_Scan_Panel example. Let's change the dimensions of the matrix

 // Panel configuration
  #define PANEL_RES_X 32 // Number of pixels wide of each INDIVIDUAL panel module. 
  #define PANEL_RES_Y 16 // Number of pixels tall of each INDIVIDUAL panel module.
  
  #define NUM_ROWS 1 // Number of rows of chained INDIVIDUAL PANELS
  #define NUM_COLS 1 // Number of INDIVIDUAL PANELS per ROW

and select the scanning mode:
FourScanPanel->setPhysicalPanelScanRate(FOUR_SCAN_16PX_HIGH);

Instead of graphics, we will paint the panel pixel by pixel with the selected color:

void loop() {

 for (int i = 0; i < FourScanPanel->height(); i++)
  {
    for (int j = 0; j < FourScanPanel->width(); j++)
    {
      FourScanPanel->drawPixel(j, i, FourScanPanel->color565(255, 0, 0));
      delay(30);
    }
  }

  delay(2000);
  dma_display->clearScreen();

} // end loop

The result shown on video:

stage1a.mp4

It can be seen that the panel is not working correctly. The main sign of this is that the entire cycle is completed, but the pixels on the panel are not fully lit.
(to be continued)

[board707]

Part 2
Let's try to figure out why this happens. Below is the code of the getCoords() method from the ESP32-VirtualMatrixPanel-I2S-DMA.h file, the part related to 4 scan matrices (lines 374-425) (some comments skipped)

 if ((panel_scan_rate == FOUR_SCAN_32PX_HIGH) || (panel_scan_rate == FOUR_SCAN_64PX_HIGH))
    {

	if (panel_scan_rate == FOUR_SCAN_64PX_HIGH)
	{
	    // https://github.com/mrfaptastic/ESP32-HUB75-MatrixPanel-DMA/issues/345#issuecomment-1510401192
	    if ((virt_y & 8) != ((virt_y & 16) >> 1)) { virt_y = (virt_y & 0b11000) ^ 0b11000 + (virt_y & 0b11100111); }
	}


        if ((virt_y & 8) == 0)
        {
            coords.x += ((coords.x / panelResX) + 1) * panelResX; // 1st, 3rd 'block' of 8 rows of pixels, offset by panel width in DMA buffer
        }
        else
        {
            coords.x += (coords.x / panelResX) * panelResX; // 2nd, 4th 'block' of 8 rows of pixels, offset by panel width in DMA buffer
        }

        coords.y = (virt_y >> 4) * 8 + (virt_y & 0b00000111);
    }
    else if (panel_scan_rate == FOUR_SCAN_16PX_HIGH)
    {
        if ((virt_y & 8) == 0)
        {
            coords.x += (panelResX >> 2) * (((coords.x & 0xFFF0) >> 4) + 1); // 1st, 3rd 'block' of 8 rows of pixels, offset by panel width in DMA buffer
        }
        else
        {
            coords.x += (panelResX >> 2) * (((coords.x & 0xFFF0) >> 4)); // 2nd, 4th 'block' of 8 rows of pixels, offset by panel width in DMA buffer
        }

        if (virt_y < 32)
            coords.y = (virt_y >> 4) * 8 + (virt_y & 0b00000111);
        else
        {
            coords.y = ((virt_y - 32) >> 4) * 8 + (virt_y & 0b00000111);
            coords.x += 256;
        }
    }

we are interested in the part that relates to 16 pixels height panels - that is, after this condition:

else if (panel_scan_rate == FOUR_SCAN_16PX_HIGH)

To be honest, I don’t really understand what exactly is written here. In my opinion, this code belongs to some old version, and now it just not works. The video in the previous message confirms this. And even stronger proof that this code is incorrect will be that I change it and the matrix will work.
On the contrary, the code for 32 pixels height panels looks quite logical:

if ((virt_y & 8) == 0)
        {
            coords.x += ((coords.x / panelResX) + 1) * panelResX; // 1st, 3rd 'block' of 8 rows of pixels, offset by panel width in DMA buffer
        }
        else
        {
            coords.x += (coords.x / panelResX) * panelResX; // 2nd, 4th 'block' of 8 rows of pixels, offset by panel width in DMA buffer
        }

        coords.y = (virt_y >> 4) * 8 + (virt_y & 0b00000111);

it only needs to be adjusted a little to be used with 16 pixels height:

if ((virt_y & 4) == 0)
        {
            coords.x += ((coords.x / panelResX) + 1) * panelResX; // 1st, 3rd 'block' of 8 rows of pixels, offset by panel width in DMA buffer
        }
        else
        {
            coords.x += (coords.x / panelResX) * panelResX; // 2nd, 4th 'block' of 8 rows of pixels, offset by panel width in DMA buffer
        }

        coords.y = (virt_y >> 3) * 4 + (virt_y & 0b00000011);

The result:

stage2a.mp4

Looks better.
You may not agree with me - after all, the matrix is filled in almost as randomly as before. But this just doesn’t matter - it’s easy to fix. The main thing that has changed is that the panel is now completely filled

[board707]

Part 3.
In the previous video, the panel is filled in parts of 8 pixels. This can be called a "pixel base". This is the key point that distinguishes "Four_scan" panels with complex pixel mappings from "regular" and Two scan ones. Why don't the patterns from regular panels fit the Four_scan? Because the patterns of regular panels are uses as pixel base the length of an entire panel and in most Four scan panels the pixel base is smaller.
Now look how the picture on the panel changes if you replace the panel length in the code with a pixel base of 8 pixels:

stage3a.mp4

The edited code:

uint8_t pxbase =8;   // pixel base
if ((virt_y & 4) == 0)
        {
            coords.x += ((coords.x / pxbase) + 1) * pxbase; // 1st, 3rd 'block' of 8 rows of pixels, offset by panel width in DMA buffer
        }
        else
        {
            coords.x += (coords.x / pxbase) * pxbase; // 2nd, 4th 'block' of 8 rows of pixels, offset by panel width in DMA buffer
        }

 coords.y = (virt_y >> 3) * 4 + (virt_y & 0b00000011);

The difference is amazing. Almost exactly what we need. The only issue that in the first four lines each "pixel base" are filled in in reverse order.
It's easy to fix. The coordinate of a point within the pixel base is expressed as x % 8. To run the points in reverse order, you need to write it like this 7 - x%8.
The code will be like this:

uint8_t pxbase =8;   // pixel base
if ((virt_y & 4) == 0)
        {
            coords.x = (coords.x / pxbase)*2*pxbase  + pxbase  + 7 - (coords.x & 0x7); // 1st, 3rd 'block' of 8 rows of pixels, offset by panel width in DMA buffer
        }
        else
        {
            coords.x += (coords.x / pxbase) * pxbase; // 2nd, 4th 'block' of 8 rows of pixels, offset by panel width in DMA buffer
        }

 coords.y = (virt_y >> 3) * 4 + (virt_y & 0b00000011);

And video

finala.mp4

@mrcodetastic , thanks for the library.

[Q3trit]

Hi! @board707 i successfully made my panel work till stage3a.mp4, i had to flip the IF arguments like this.

uint8_t pxbase =8;   // pixel base
	if ((virt_y & 4) == 0)	
	{
		coords.x += (coords.x / pxbase) * pxbase;
	}
	else
	{
	 	coords.x += ((coords.x / pxbase) + 1) * pxbase;
	}
	coords.y = (virt_y >> 3) * 4 + (virt_y & 0b00000011);

But when i attempted to fix "7 - x%8" issue, by modifying the ELSE argument like this:

uint8_t pxbase =8;   // pixel base
	if ((virt_y & 4) == 0)	
	{
		coords.x += (coords.x / pxbase) * pxbase;
	}
	else
	{
		coords.x = (coords.x / pxbase)*2*pxbase  + pxbase  + 7 - (coords.x & 0x7);
	}
	coords.y = (virt_y >> 3) * 4 + (virt_y & 0b00000011);

The result is attached.

P10_VirtualMxPanel_test001.mp4

I think i dont have clear how this line works:

coords.x = (coords.x / pxbase)*2*pxbase + pxbase + 7 - (coords.x & 0x7);
Thanks in advance.

[board707]

Hi
Could you show a video before editing the ELSE argument?

[Q3trit]

Thanks for your prompt response.

Heres the code of the attached video, before modifying the ELSE argument;
(Its the same code as your's but with inverted IF's arguments, with your code it fills the 2nd block before the 1st one.)

uint8_t pxbase =8;   // pixel base
	if ((virt_y & 4) == 0)	
	{
		coords.x += (coords.x / pxbase) * pxbase;
	}
	else
	{
		coords.x += ((coords.x / pxbase) + 1) * pxbase;
	}
	coords.y = (virt_y >> 3) * 4 + (virt_y & 0b00000011);

P10_VirtualMxPanel_test002.mp4

Regards,

[board707]

Try this:

uint8_t pxbase =8;   // pixel base
	if ((virt_y & 4) == 0)	
	{
		coords.x = (coords.x / pxbase)*2*pxbase  + 7 - (coords.x & 0x7);
	}
	else
	{
		coords.x += ((coords.x / pxbase) + 1) * pxbase;
	}
   coords.y = (virt_y >> 3) * 4 + (virt_y & 0b00000011);

[Q3trit]

Thanks buddy! A tequila bottle is waiting for you on your next visit to MxCity.

It has a minor issue when refreshing the green color, I guess it's because of the delay.

P10_VirtualMxPanel_test003.mp4

[board707]

Thanks @mrcodetastic to the fix #621, it is now possible to add your own Quarter_Scan panel coordinate transformations without changing the main library code. To do this, it is enough to define a new virtual panel class directly in the sketch, inheriting it from the library's VirtualMatrixPanel class and define in it your own getCoords() function.
Below I have presented an example of such use, converting it from the standard Four_Scan_Panel.ino code:
(the new important parts are between /* ==== */ lines).

/*************************************************************************
   Description:

   The underlying implementation of the ESP32-HUB75-MatrixPanel-I2S-DMA only
   supports output to HALF scan panels - which means outputting
   two lines at the same time, 16 or 32 rows apart if a 32px or 64px high panel
   respectively.
   This cannot be changed at the DMA layer as it would require a messy and complex
   rebuild of the library's internals.

   However, it is possible to connect QUARTER (i.e. FOUR lines updated in parallel)
   scan panels to this same library and
   'trick' the output to work correctly on these panels by way of adjusting the
   pixel co-ordinates that are 'sent' to the ESP32-HUB75-MatrixPanel-I2S-DMA
   library.

 **************************************************************************/

/* Use a custom Virtual Display class to re-map co-ordinates such that they draw
   correctly on a 32x16 1/4 Scan panel (or chain of such panels).
*/
#include "ESP32-VirtualMatrixPanel-I2S-DMA.h"

/* ================================================== */
// Define custom class derived from VirtualMatrixPanel
class EightPxBasePanel : public VirtualMatrixPanel
{
  public:
    using VirtualMatrixPanel::VirtualMatrixPanel; // inherit VirtualMatrixPanel's constructor(s)

  protected:

    VirtualCoords getCoords(int16_t x, int16_t y);  // custom getCoords() method for specific pixel mapping

};

// define custom getCoords() method for specific pixel mapping
inline VirtualCoords EightPxBasePanel ::getCoords(int16_t x, int16_t y) {

  coords = VirtualMatrixPanel::getCoords(x, y); // first call base class method to update coords for chaining approach

  if ( coords.x == -1 || coords.y == -1 ) { // Co-ordinates go from 0 to X-1 remember! width() and height() are out of range!
    return coords;
  }


  uint8_t pxbase = 8;  // pixel base
  if ((coords.y & 4) == 0)
  {
    coords.x = (coords.x / pxbase) * 2 * pxbase  + pxbase  + 7 - (coords.x & 0x7); // 1st, 3rd 'block' of 8 rows of pixels, offset by panel width in DMA buffer
  }
  else
  {
    coords.x += (coords.x / pxbase) * pxbase; // 2nd, 4th 'block' of 8 rows of pixels, offset by panel width in DMA buffer
  }

  coords.y = (coords.y >> 3) * 4 + (coords.y & 0b00000011);

  return coords;
}
/* ================================================== */
// Panel configuration
#define PANEL_RES_X 32 // Number of pixels wide of each INDIVIDUAL panel module. 
#define PANEL_RES_Y 16 // Number of pixels tall of each INDIVIDUAL panel module.


#define NUM_ROWS 1 // Number of rows of chained INDIVIDUAL PANELS
#define NUM_COLS 1 // Number of INDIVIDUAL PANELS per ROW

// ^^^ NOTE: DEFAULT EXAMPLE SETUP IS FOR A CHAIN OF TWO x 1/8 SCAN PANELS

// Change this to your needs, for details on VirtualPanel pls read the PDF!
#define SERPENT true
#define TOPDOWN false
#define VIRTUAL_MATRIX_CHAIN_TYPE CHAIN_TOP_RIGHT_DOWN

// placeholder for the matrix object
MatrixPanel_I2S_DMA *dma_display = nullptr;

// placeholder for the virtual display object
EightPxBasePanel   *FourScanPanel = nullptr;

/******************************************************************************
   Setup!
 ******************************************************************************/
void setup()
{
  delay(250);

  Serial.begin(115200);
  Serial.println(""); Serial.println(""); Serial.println("");
  Serial.println("*****************************************************");
  Serial.println("*         1/8 Scan Panel Demonstration              *");
  Serial.println("*****************************************************");

  /*
       // 62x32 1/8 Scan Panels don't have a D and E pin!

       HUB75_I2S_CFG::i2s_pins _pins = {
        R1_PIN, G1_PIN, B1_PIN, R2_PIN, G2_PIN, B2_PIN,
        A_PIN, B_PIN, C_PIN, D_PIN, E_PIN,
        LAT_PIN, OE_PIN, CLK_PIN
       };
  */
  HUB75_I2S_CFG mxconfig(
    PANEL_RES_X * 2,            // DO NOT CHANGE THIS
    PANEL_RES_Y / 2,            // DO NOT CHANGE THIS
    NUM_ROWS * NUM_COLS         // DO NOT CHANGE THIS
    //,_pins            // Uncomment to enable custom pins
  );

  mxconfig.clkphase = false; // Change this if you see pixels showing up shifted wrongly by one column the left or right.

  //mxconfig.driver   = HUB75_I2S_CFG::FM6126A;     // in case that we use panels based on FM6126A chip, we can set it here before creating MatrixPanel_I2S_DMA object

  // OK, now we can create our matrix object
  dma_display = new MatrixPanel_I2S_DMA(mxconfig);

  // let's adjust default brightness to about 75%
  dma_display->setBrightness8(40);    // range is 0-255, 0 - 0%, 255 - 100%

  // Allocate memory and start DMA display
  if ( not dma_display->begin() )
    Serial.println("****** !KABOOM! I2S memory allocation failed ***********");


  dma_display->clearScreen();
  delay(500);

  // create FourScanPanellay object based on our newly created dma_display object
  FourScanPanel = new EightPxBasePanel ((*dma_display), NUM_ROWS, NUM_COLS, PANEL_RES_X, PANEL_RES_Y,    VIRTUAL_MATRIX_CHAIN_TYPE);

  // THE IMPORTANT BIT BELOW!
  // FOUR_SCAN_16PX_HIGH
  // FOUR_SCAN_32PX_HIGH
// **** You don't need to set PhysicalPanelScanRate when use your own virtual panel class
  //FourScanPanel->setPhysicalPanelScanRate(FOUR_SCAN_16PX_HIGH);
}


// Test the pixel mapping - fill the panel pixel by pixel
void loop() {


  for (int i = 0; i < FourScanPanel->height(); i++)
  {
    for (int j = 0; j < FourScanPanel->width(); j++)
    {

      FourScanPanel->drawPixel(j, i, FourScanPanel->color565(255, 0, 0));
      delay(30);
    }
  }

  delay(2000);
  dma_display->clearScreen();

} // end loop

!!! Important note - you don't need to set PhysicalPanelScanRate when use your own virtual panel class.

[board707]

See the #677 as practical example of using the technology discussed above.

[MyHJU]

Tried everything from #677 , also set pxbase to 1.
The chip is FM6124D.
What i'm ending with is this:

VID_20240925_155859.mp4

[MyHJU]

Thanks for your fast reply, will do it !

[board707]

Issue solved in #680

[board707]

Another using the "pixbase" approach see in #618 (64x32 1/8s) and #637 (40x20 1/5s)