Mapping for our ICN2037-based 64x32 1/8 scan panels

[MicroframeDev1]

Working color map for the following 64x32 color panels:
Markings: 2020-06-24. DH5-64X32-8S-A-V1.0.
Chips:
ICN2037 LED Driver
RUC7258D 3 of 8 row mux
74HC245KA Octal bus transceiver. Used to regenerate signal for next panel.

main.h

#include <FastLED.h>

#define BAUD_RATE       115200  // serial debug port baud rate

main.cpp

#ifdef IDF_BUILD
#include <stdio.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <driver/gpio.h>
#include "sdkconfig.h"
#endif

#include <Arduino.h>
#include "xtensa/core-macros.h"
#include "main.h"

#define R1 13
#define G1 12
#define BL1 02
#define R2 23
#define G2 19
#define BL2 22
#define CH_A 32
#define CH_B 33
#define CH_C 25
#define CH_D -1                                                                     //'D' is mapped to 15. Use with 1/16 scan panels.
#define CH_E -1                                                                     //'E' is mapped to 21. Use with 1/32 scan panels.
#define CLK 14
#define LAT 26
#define OE 27

#define PANEL_RES_X 64                                                              //Number of pixels wide of each INDIVIDUAL panel module. 
#define PANEL_RES_Y 32                                                              //Number of pixels tall of each INDIVIDUAL panel module.

#include <ESP32-HUB75-VirtualMatrixPanel_T.hpp>

MatrixPanel_I2S_DMA *dma_display = nullptr;

    //Mapping for ICN2037-based 64x32 1/8 scan panels
    //While the panel layout is 64x32, it is wired as 128x16.
    //Condenses 32 rows into 16 and interlaces the data for the two rows.

    //v1. 5042us.
    // struct CustomICN2037ScanMapping {
    //     static VirtualCoords apply(VirtualCoords vc, int panel_pixel_base) {
    //         //Layout 64x32. Extract the local coords in this panel
    //         VirtualCoords lc;
    //         lc.x = vc.x % 64;
    //         lc.y = vc.y % 32;

    //         //What quadrant are we in?
    //         int xdiv = (vc.x / 32) & 0x01;                                          //x = (0..31), (32..63), etc
    //         int ydiv = (vc.y / 8) & 0x03;                                           //y = (0..7), (8..15), etc

    //         //Panel offset     
    //         int PanXcnt = vc.x / 64;                                                //Adjust for additional x panels
    //         int PanYcnt = vc.y / 32;                                                //Adjust for additional y panels

    //         //Map to physical pixel location
    //         VirtualCoords out;
    //         out.x = 0;
    //         out.y = 0;
    //         //Panel offset
    //         out.x += PanXcnt * 128;
    //         out.y += PanYcnt * 16;
    //         //Local offset
    //         out.x += lc.x;
    //         out.y += lc.y;

    //         switch(ydiv) {
    //             case 0:
    //                 switch(xdiv) {
    //                     case 0:
    //                         out.x += 32;
    //                         out.y += 0;
    //                         break;
    //                     case 1:
    //                         out.x += 64;
    //                         out.y += 0;
    //                         break;
    //                 }
    //                 break;
    //             case 1:
    //                 switch(xdiv) {
    //                     case 0:
    //                         out.x += 0;
    //                         out.y += -8;
    //                         break;
    //                     case 1:
    //                         out.x += 32;
    //                         out.y += -8;
    //                         break;
    //                 }
    //                 break;
    //             case 2:
    //                 switch(xdiv) {
    //                     case 0:
    //                         out.x += 32;
    //                         out.y += -8;
    //                         break;
    //                     case 1:
    //                         out.x += 64;
    //                         out.y += -8;
    //                         break;
    //                 }
    //                 break;
    //             case 3:
    //                 switch(xdiv) {
    //                     case 0:
    //                         out.x += 0;
    //                         out.y += -16;
    //                         break;
    //                     case 1:
    //                         out.x += 32;
    //                         out.y += -16;
    //                         break;
    //                 }
    //                 break;
    //         }

    //         //Serial.printf("(%3d, %3d) -> (%3d, %3d) -> (%3d, %3d) pxb: %d\r\n", vc.x, vc.y, lc.x, lc.y, out.x, out.y, panel_pixel_base);

    //         return out;
    //     }
    // };

    //v2. 4479us.
    // struct CustomICN2037ScanMapping {
    //     static VirtualCoords apply(VirtualCoords vc, int panel_pixel_base) {
    //         //Layout 64x32. Extract the local coords in this panel
    //         VirtualCoords lc;
    //         lc.x = vc.x & 63u;
    //         lc.y = vc.y & 31u;

    //         //Panel offset     
    //         int PanXcnt = vc.x >> 6;                                                //Adjust for additional x panels. PanXcnt = vc.x / 64.
    //         int PanYcnt = vc.y >> 5;                                                //Adjust for additional y panels. PanYcnt = vc.y / 32.

    //         //What quadrant are we in?
    //         int xdiv = (vc.x >> 5) & 1;                                             //Left/right column. (vc.x / 32) & 0x01.
    //         int ydiv = (vc.y >> 3) & 3;                                             //Odd/even row. y = (0..7), (8..15), etc. ydiv = (vc.y / 8) & 0x03.

    //         //Map to physical pixel location
    //         VirtualCoords out;
    //         //Panel offset
    //         out.x = PanXcnt << 7;                                                   //PanXcnt * 128;
    //         out.y = PanYcnt << 4;                                                   //PanYcnt * 16
    //         //Local offset
    //         out.x += lc.x;
    //         out.y += lc.y;

    //         //X mapping:
    //         //If ydiv is even, then +32.
    //         //If xdiv>=32 (right half of panel), then +32.
    //         out.x += 32u * ((ydiv & 1) ^ 1);
    //         out.x += 32 * xdiv;

    //         //Y mapping:
    //         //Condense 32 rows into 16.
    //         //Subtracts 0, 8, or 16.
    //         out.y -= ((vc.y + 8) >> 4) * 8;

    //         return out;
    //     }
    // };

    //v3. 4393us.  Same timing with dma_display instead of VirtualDisplay (no scan mapping): 3090us.
    struct CustomICN2037ScanMapping {
        static VirtualCoords apply(VirtualCoords vc, int panel_pixel_base) {
            //Layout 64x32 -> 128x16.
            //Panel offset + Local offset
            vc.x = 
                ((vc.x >> 6) * 128) +                                               //Panel X offset. PanXcnt = vc.x / 64.
                (vc.x & 63u) +                                                      //LocalX
                (32 * (
                    (((vc.y >> 3) & 1) ^ 1) +                                       //If y/8 row is even, then +32.
                    ((vc.x >> 5) & 1)                                               //If LocalX >= 32 (right half of panel), then +32.
                ));

            vc.y =
                ((vc.y >> 5) * 16) +                                                //Panel Y offset. PanYcnt = vc.y / 32.
                (vc.y & 31u) -                                                      //Local Y
                (((vc.y + 8) >> 4) * 8);                                            //Condense 32 rows into 16. Subtracts 0, 8, or 16.

            return vc;
        }
    };

    // Virtual display using custom mapper
    VirtualMatrixPanel_T<CHAIN_BOTTOM_RIGHT_UP_ZZ, CustomICN2037ScanMapping>* virtualDisp = nullptr;

void setup() {
    Serial.begin(BAUD_RATE);
    HUB75_I2S_CFG::i2s_pins _pins={R1, G1, BL1, R2, G2, BL2, CH_A, CH_B, CH_C, CH_D, CH_E, LAT, OE, CLK};

   // Normal 64x32 DMA config
    HUB75_I2S_CFG mxconfig(
        PANEL_RES_X*2,
        PANEL_RES_Y/2,
        2,
        _pins
    );

    //mxconfig.driver = HUB75_I2S_CFG::SHIFTREG;                                      //ICN2037 LED driver doesn't need any special config.
    //mxconfig.line_decoder = HUB75_I2S_CFG::TYPE138;                                 //3 to 8 decoder for RUC7258D
    mxconfig.i2sspeed = HUB75_I2S_CFG::HZ_10M;                                      //10Mhz.  Only valid rates are 10 or 20M. See esp32_i2s_parallel_dma.cpp.
    mxconfig.clkphase = false;                                                      //ICN2037 uses positive clock edge. false=rising edge.
    mxconfig.setPixelColorDepthBits(2);
    mxconfig.latch_blanking = DEFAULT_LAT_BLANKING;
    /**
    * Setup physical DMA LED display output.
    */
   dma_display = new MatrixPanel_I2S_DMA(mxconfig);
   dma_display->begin();
   dma_display->setBrightness8(255); //0-255
   dma_display->clearScreen();

   virtualDisp = new VirtualMatrixPanel_T<CHAIN_BOTTOM_RIGHT_UP_ZZ, CustomICN2037ScanMapping>(1, 2, PANEL_RES_X, PANEL_RES_Y);

   // Pass a reference to the DMA display to the VirtualMatrixPanel_T class
   virtualDisp->setDisplay(*dma_display);

   log_i("VH=%i VW=%i", virtualDisp->height(), virtualDisp->width());
}

void loop(){
    static unsigned long s1, s2;

    virtualDisp->clearScreen();
    delay(100);

    s1 = micros();
    for (int y=0; y<32; y++) {
        for (int x=0; x<128; x+=1) {
            virtualDisp->drawPixelRGB888(x, y, 255, 0, 0);
            //delay(50); //Enable to see pixel filling
        }
    }
    s2 = micros();
    log_i("%lu us", s2-s1);
  
    delay(2000);
}

Also works for 8 bit color.

This color map works for our color panels. Please don't ask me to fix your mapping.

[MicroframeDev1]

platformio.ini:

[platformio]
default_envs = esp32-D
description = HUB75 ESP32 I2S DMA test patterns example
;src_dir = src

[env]
platform = https://github.com/pioarduino/platform-espressif32/releases/download/53.03.13/platform-espressif32.zip       ;Arduino 3.1.3
;platform = https://github.com/pioarduino/platform-espressif32/releases/download/55.03.30-2/platform-espressif32.zip

board = featheresp32
upload_speed = 460800
monitor_speed = 115200
monitor_filters = time, colorize, esp32_exception_decoder
lib_deps =
    fastled/FastLED
    Wire
    adafruit/Adafruit BusIO
    adafruit/Adafruit GFX Library
    https://github.com/mrfaptastic/ESP32-HUB75-MatrixPanel-I2S-DMA.git

[env:esp32-R]
framework = arduino
build_flags =
    -D CORE_DEBUG_LEVEL=2

[env:esp32-D]
framework = arduino
build_type = debug
build_flags =
    -D CORE_DEBUG_LEVEL=5
	-Wl,--print-memory-usage

[env:esp32idf]
framework = arduino, espidf

[board707]

This color map works for our color panels.

So you should have named your topic "Mapping for our panels."

With actual name your title creates the false impression that this is a universal mapping for any 64x32 s8 panels on a ICN2037 driver, which is incorrect.

I see in the code that you tried three mapping options with different execution times. Why didn't you test the mapping offered in the library? It's significantly shorter in code size than your variants. It would be interesting to compare the speed.

[MicroframeDev1]

@board707 Updated title.

Will test and reply. Initially we were unable to get the default mappings to work.

[MicroframeDev1]

Tests:
PANEL_SCAN_TYPE = FOUR_SCAN_16PX_HIGH
Write is interlaced and broken up into 16 different quadrants. Incorrect.
Timing with 2 panels: 6632us.

PANEL_SCAN_TYPE = FOUR_SCAN_32PX_HIGH
Write is broken up into 16 different quadrants. Incorrect.
Timing with 2 panels: 6633us.

Our code with the correct mapping (for our panel) runs in 4393us.

The division in the following code may be slowing down performance:

		if constexpr (ScanType == FOUR_SCAN_16PX_HIGH) 
		{
			if ((coords.y & 4) == 0) {
				coords.x += (((coords.x / panel_pixel_base) + 1) * panel_pixel_base);
			} else {
				coords.x += ((coords.x / panel_pixel_base) * panel_pixel_base);
			}
			
			coords.y = (coords.y >> 3) * 4 + (coords.y & 0b00000011);
		}

Changing the code to

		if constexpr (ScanType == FOUR_SCAN_16PX_HIGH) 
		{
			if ((coords.y & 4) == 0) {
				coords.x += (((coords.x >> 6) + 1) * panel_pixel_base);
			} else {
				coords.x += ((coords.x >> 6) * panel_pixel_base);
			}
			
			coords.y = (coords.y >> 3) * 4 + (coords.y & 0b00000011);
		}

speeds it up slightly: 6614us.
Caution: ">> 6" divides by 64, which only works if the panel is 64 pixels wide.

Hope that helps!

[MicroframeDev1]

Update: retested our custom mapper and now it's benchmarking at 6470. Use that number when comparing to above. I added a build flag "build_type = debug" that apparently slows down the program.

[board707]

if constexpr (ScanType == FOUR_SCAN_16PX_HIGH)

You tested an incorrect code. Accordingly to the name of define it is a code for 16px high panels - i.e 32x16 or similar. Your panel is 32px height.
Of course, the mapping shown in the library examples is just a basic one. It doesn't automatically adapt to any matrix. So it's not surprising that it produced an incorrect image on your panel. It should be customized first.
But it has two advantages: i) the customization can be done very easy for most panels by changing just two or three lines of code; and ii) while configured for a single panel, it works on panel chain of any length without modification (meaning it doesn't need to be adjusted to the screen length, like your last code).

If you're interested, I can customize the mapping for your panel remotely. To do this, you need to run the Pixel_Mapping_Test library example (without changing anything) and show a video of it running on your panel.

Addition:
Alternatively you can customize the mapping yourself using the procedure described in the example's Readme.

[MicroframeDev1]

Thank you for the offer, but I'm quite happy with our custom map. That said, I've seen your work on other posts. You are a rock star!
It's amazing what this library can do. Thankful.

[vladimirkirilov785-blip]

Hello,
I'm glad there are people who deal with these displays. Is anyone interested /for a fee/ in helping me to drive my display with esp32-s3 and Arduino?
The display is P4, 64x32, 1/8 scan, Outdoor, 256x128mm. ICN2037.

I'm just more of a hardware guy than a programmer and I'm having a hard time..

and here are my esp32-s3 pins :

[board707]

Hi
Could you show a clear picture of the panel whole view (rear side) ?

[vladimirkirilov785-blip]

hello, here is photo of the display

https://www.aliexpress.com/item/1005008493095319.html?spm=a2g0o.order_list.order_list_main.5.72ff1802vdlOHA#nav-specification

[board707]

Very unusual panel... See an empty places for T1-T4 chips:

[board707]

Please run the library example Pixel_Mapping_Test and show the video.
Do not forget to set correct panel size and pins in the code.

[vladimirkirilov785-blip]

i run this test, but nothing. Completely dark panel :(.
i check signals several times and all pins seems connected correct.

I asked chineses for some test code, but i do not believe they will provide.

Ahh, i didn't know it will be so hard making this working. I choose this display because it is Outdoor and 256x128mm, perfect dimensions for me.

I am posting the test code:

`

#include <Arduino.h>

#include "ESP32-VirtualMatrixPanel-I2S-DMA.h"

// Define custom class derived from VirtualMatrixPanel
class CustomPxBasePanel : 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 R1 42
#define G1 41
#define BL1 40
#define R2 38
#define G2 39
#define BL2 37
#define CH_A 45
#define CH_B 36
#define CH_C 48
#define CH_D -1 //'D' is mapped to 15. Use with 1/16 scan panels.
#define CH_E -1 //'E' is mapped to 21. Use with 1/32 scan panels.
#define CLK 2
#define LAT 47
#define OE 14

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

coords = VirtualMatrixPanel::getCoords(x, y); // 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 = panelResX; // pixel base
// mapper for panels with 32 pixs height (64x32 or 32x32)
if (panelResY == 32)
{
if ((coords.y & 8) == 0)
{
coords.x += ((coords.x / pxbase) + 1) * pxbase; // 1st, 3rd 'block' of 8 rows of pixels
}
else
{
coords.x += (coords.x / pxbase) * pxbase; // 2nd, 4th 'block' of 8 rows of pixels
}
coords.y = (coords.y >> 4) * 8 + (coords.y & 0b00000111);
}

// mapper for panels with 16 pixs height (32x16 1/4)
else if (panelResY == 16)
{
if ((coords.y & 4) == 0)
{
// 1. Normal line, from left to right
coords.x += ((coords.x / pxbase) + 1) * pxbase; // 1st, 3rd 'block' of 4 rows of pixels
//2. in case the line filled from right to left, use this (and comment 1st)
//coords.x = ((coords.x / pxbase) + 1) * 2 * pxbase - (coords.x % pxbase) - 1;
}
else
{
coords.x += (coords.x / pxbase) * pxbase; // 2nd, 4th 'block' of 4 rows of pixels
}
coords.y = (coords.y >> 3) * 4 + (coords.y & 0b00000011);
}
return coords;
}

// Panel configuration
#define PANEL_RES_X 64 // Number of pixels wide of each INDIVIDUAL panel module.
#define PANEL_RES_Y 32 // Number of pixels tall of each INDIVIDUAL panel module.

// Use a single panel for tests
#define NUM_ROWS 1 // Number of rows of chained INDIVIDUAL PANELS
#define NUM_COLS 1 // Number of INDIVIDUAL PANELS per ROW

// Chain settings, do not cnahge
#define SERPENT true
#define TOPDOWN false
#define VIRTUAL_MATRIX_CHAIN_TYPE CHAIN_BOTTOM_RIGHT_UP

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

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

void setup() {

HUB75_I2S_CFG::i2s_pins _pins={R1, G1, BL1, R2, G2, BL2, CH_A, CH_B, CH_C, CH_D, CH_E, LAT, OE, CLK};

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.

// 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 CustomPxBasePanel ((*dma_display), NUM_ROWS, NUM_COLS, PANEL_RES_X, PANEL_RES_Y, VIRTUAL_MATRIX_CHAIN_TYPE);
}

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();
}`

[board707]

i run this test, but nothing. Completely dark panel :(.

This is quite strange. Usually, there's always some image, even if it's very distorted and unreadable...
I'm not quite sure what to do with your matrix.

Try adding a
mxconfig.line_decoder = HUB75_I2S_CFG::SM5368;

just after line

mxconfig.clkphase = false;

(this line somewhere about line 110 in the original example)

[vladimirkirilov785-blip]

Hello, it was my fault. Opposite cable in the connector :(.

Now, i run this code and have the following video:

`#include "ESP32-VirtualMatrixPanel-I2S-DMA.h"
#define R1_PIN 42
#define G1_PIN 41
#define B1_PIN 40
#define R2_PIN 38
#define G2_PIN 39
#define B2_PIN 37
#define A_PIN 45
#define B_PIN 36
#define C_PIN 48
#define D_PIN -1
#define E_PIN -1
#define LAT_PIN 47
#define OE_PIN 14
#define CLK_PIN 2
// Define custom class derived from VirtualMatrixPanel
class CustomPxBasePanel : 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

};

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

coords = VirtualMatrixPanel::getCoords(x, y); // 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 = panelResX; // pixel base
// mapper for panels with 32 pixs height (64x32 or 32x32)
if (panelResY == 32)
{
if ((coords.y & 8) == 0)
{
coords.x += ((coords.x / pxbase) + 1) * pxbase; // 1st, 3rd 'block' of 8 rows of pixels
}
else
{
coords.x += (coords.x / pxbase) * pxbase; // 2nd, 4th 'block' of 8 rows of pixels
}
coords.y = (coords.y >> 4) * 8 + (coords.y & 0b00000111);
}

// mapper for panels with 16 pixs height (32x16 1/4)
else if (panelResY == 16)
{
if ((coords.y & 4) == 0)
{
// 1. Normal line, from left to right
coords.x += ((coords.x / pxbase) + 1) * pxbase; // 1st, 3rd 'block' of 4 rows of pixels
//2. in case the line filled from right to left, use this (and comment 1st)
//coords.x = ((coords.x / pxbase) + 1) * 2 * pxbase - (coords.x % pxbase) - 1;
}
else
{
coords.x += (coords.x / pxbase) * pxbase; // 2nd, 4th 'block' of 4 rows of pixels
}
coords.y = (coords.y >> 3) * 4 + (coords.y & 0b00000011);
}
return coords;
}

// Panel configuration
#define PANEL_RES_X 64 // Number of pixels wide of each INDIVIDUAL panel module.
#define PANEL_RES_Y 32 // Number of pixels tall of each INDIVIDUAL panel module.

// Use a single panel for tests
#define NUM_ROWS 1 // Number of rows of chained INDIVIDUAL PANELS
#define NUM_COLS 1 // Number of INDIVIDUAL PANELS per ROW

// Chain settings, do not cnahge
#define SERPENT true
#define TOPDOWN false
#define VIRTUAL_MATRIX_CHAIN_TYPE CHAIN_BOTTOM_RIGHT_UP

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

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

/******************************************************************************
Setup!
******************************************************************************/
void setup()
{
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.

// 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 CustomPxBasePanel ((*dma_display), NUM_ROWS, NUM_COLS, PANEL_RES_X, PANEL_RES_Y, VIRTUAL_MATRIX_CHAIN_TYPE);

}

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
`

MicrosoftTeams-video.mp4

[board707]

@vladimirkirilov785-blip
It seems that your pixel mapping scheme is correct.
You can use it in the projects.

[vladimirkirilov785-blip]

Hi again,
i am trying to adjust the brightness, but this code dma_display->setBrightness8(50); didnt change anything.

Is there is some workaraound? Thanks