I’m aware of the minimum refresh rate and refresh rate settings; however, I don’t believe I can set the refresh rate at 120 Hz and actually GET that refresh rate, precisely. Am I correct, or am I just missing something that is easily tweaked?

This same question has possibly been asked in a variety of ways, but I was unable to find my answer.

Thanks for your help!

I have a system using teensy 4.1 and a shield I produced based on the smartmatrix shield. It works perfectly with the 1/4 rgb matrix I use for years. This time, my supplier delivered a 1/2 scan matrix.

I was able to adapt the sketch to run stable in the 1/2 scan. My issue is the matrix.setBrightness doesn’t change anything on the LEDs. There is something I can tweak on the library to be able to use the brightness control on the matrix? Curiously the background brightness control works, but the results for the 2 commands are very different (using the 1/4scan boards), specially regarding the color management. And I’m having to tweak the color mapping for the other layers that doesn’t have setBrightness. Will be much easier to be able to use the matrix.setBrightness in the entire board.

Do you need more info about panel models to be able to help? Can I help you to help me?

Thanks!

A most important innovation - a support of (some) sPWM-type LED drivers - a new type of drivers for HUB75 panels, which almost no open-source library supports yet.
The main feature of these drivers is the integrated SRAM for the entire matrix, rather than just a single line, as in standard panels. This means that once you’ve loaded an image onto the panel, you don’t need to constantly refresh it—the matrix driver does it automatically.
Unfortunately, another specialty of these chips is the paucity of documentation, which greatly complicates software development for them. Therefore, the software for these drivers remains experimental for now.

The drivers, supported in the release: ICND2153 / FM6353, FM6363, FM6373, DP3264 and ICND2055.

StevenFarmer:

Yeah problem is that it needs to be done for multiple layers.

I don’t think this approach is optimal. The transformation function should be shared across all layers and all data types.
In my library, I’ve built the transformation into a low-level single-pixel output method, which is used by all drawing and text output functions.

Regarding your question about the possibility of using different matrices in a single screen, you still haven’t given a precise description of your “old” panels. But judging by the fact that they didn’t require special mapping, these panels most likely have a 1/16 scan, while the new panels have a scan 1/8.
I don’t think combining panels with different scan rates is a good idea; at least, I don’t see how it could be done.

these are my old panels. They work fine when using kPanelType = 10

These are my new panels. They have a wild mapping. I would use them for the bottom line of panels of my matrix.

Thats what the mapping looks like: The blue sector contains the field for x 0-63 and y = 0-8.

Yellow has y 8-15. Green has y =16-23 and pink 24-31.

Each sector is splitted in 4 “sub sectors” which depends what x value it is.

On the software site i use this correction funtion (this is the example for the background layer.. the pain is that you need to do that multiple times for layers)

void DoBackgroundPixelcorrection()

{

//Example setup with two panels. Just the bottom panel (row 32-63 needs fixing)

  rgb24 *buffer = backgroundLayer.backBuffer();

//first store the bottom array in a colorarray

  rgb24 colorarray[64*32];

  for(int x=0;x<64;x++)

  {

    for(int y=0;y < 32; y++)

    {

      colorarray[kMatrixWidth*y + x] = buffer[kMatrixWidth*(y+32) + x];

    }

  }

  //now write

    for(int x=0;x<64;x++)

  {

    for(int y=0;y < 32; y++)

    {

      int x_new = (((y / 8) % 2)== 0 ? 16 : 0)+((x / 16)% 2)*32 + x % 16;

      int y_new = (x <32 ? 8 : 0)+ y % 8 +(y > 15 ? 16 : 0);

      buffer[kMatrixWidth*(y_new+32) + x_new] =colorarray[kMatrixWidth*y + x];

    }

  }

}

int x_new = (((y / 8) % 2)== 0 ? 16 : 0)+((x / 16)% 2)*32 + x % 16;

new calculated x contains of three parts.

1. checks the y component. If it is between 0-7 or 16 and 23 we add 16 to x

(((y / 8) % 2)== 0 ? 16 : 0)

2. checks if x is between 16-31 or 48-63. If yes we add 32 to x

((x / 16)% 2)*32

3. Add the remaining part of x (x mod 16)

x % 16;

For y we do it likewise

1. Check out x

(x <32 ? 8 : 0)

if x <32 we need to go in yellow or pink sector therefore add 8

2. Check if y is in top or bottom sector by checking if it is bigger as 15

(y > 15 ? 16 : 0)

3. Add the remaining y component

y % 8

So with these two formulas for example

x/y (0/0) translates to (16/8) which is the first pixel in the yellow sector. And (63/31) translates to (47/23) which is also matching with this wild mapping.

Yeah problem is that it needs to be done for multiple layers. When using fonts I used to print to a canvas and sorted pixels in the canvas. After doing that i pasted that stuff into an indexed layer

I thought there might be just an array which stores all LED-Adresses. Would it be possible to just exchange adresses there? Or would it be possible to give the bottom line another panel mapping?

https://tchapi.github.io/Adafruit-GFX-Font-Customiser/

tmagafas84:

Ihave tried different fonts for my task but the letters are not perfect.

I assume you can add your own fonts to the library. Unfortunately, I have no experience with this; you’d be better off opening an issue on the library’s GitHub page and asking there.

#include <ESP32-VirtualMatrixPanel-I2S-DMA.h>

#include <Adafruit_GFX.h>

#include “FreeSansBold8pt7b.h”

#include “FreeSans6pt7b.h”

#define PANEL_RES_X 80

#define PANEL_RES_Y 40

#define PANEL_CHAIN 1

#define R1_PIN 25

#define G1_PIN 26

#define B1_PIN 27

#define R2_PIN 14

#define G2_PIN 12

#define B2_PIN 13

#define A_PIN 23

#define B_PIN 19

#define C_PIN 5

#define D_PIN 17

#define E_PIN 32

#define LAT_PIN 4

#define OE_PIN 15

#define CLK_PIN 16

MatrixPanel_I2S_DMA *dma_display = nullptr;

void setup()

{

Serial.begin(115200);

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, 

  PANEL_RES_Y, 

  PANEL_CHAIN, 

  \_pins        

);

dma_display = new MatrixPanel_I2S_DMA(mxconfig);

dma_display->begin();

dma_display->setBrightness8(255);

dma_display->clearScreen();

dma_display->setCursor(0, 8);

dma_display->setFont(&FreeSansBold8pt7b);

dma_display->setTextColor(dma_display->color565(0, 255, 0));

dma_display->print(“MEETING”);

dma_display->setCursor(0, 30);

dma_display->setFont(&FreeSans6pt7b);

dma_display->setTextColor(dma_display->color565(0, 255, 255));

dma_display->print(“IN PROGRESS”);

}

void loop()

{

delay(1000);

}

tmagafas84:

so the SM16208SC is the driver?

Yes, SM16208sc is a driver, and SM5166 is a standard type multiplexer. Your panel doesn’t has any specific and should be compatible with any HUB75 library.

For ESP32 board I would recommend using ESP32-HUB75-MatrixPanel-DMA library. I don’t know much about Smart Matrix and I can hardly help with it.
You also could use a Raspberry Pico RP2040 board with DMD_STM32 library.

The panel sizes are just parameters that can be easily adjusted in code. There’s no fundamental difference between running 64x32 16s and 80x40 20s panels.

If you’re using libraries I know, I could help you with the setup. First, find the examples in the library and try running them. If you encounter any issues, please post here with the example code.

with PxMatrix i made something good but i had the E channel to be not connected.
with Smart Matrix i had nothing.

i dont know if my board is not compatible.
i dont know if i had to use jumper beetween hub75 input and output.
i dont know which library i must use.

almost everything i google is about 64x32 and 16 scan.
i feel very confused.

tmagafas84:

i have SM5166PF led driver. is this common i think and compatible with library.

The chip SM5166 is not a led driver, it is “multiplexer”, i.e. row switching chip. For the driver type you have to look up other chips on the panel.
But taking into account the fact that you were able to output some letters to the panel, It seems that your panels are compatible with… what the library you using now?

i want to use 1 panel P4. and i read that i must bridge from the hub75 input with hub75 output so have a chain about R1,G1,B1,R0,G0,BO as a big one shift register when want to connect more of that module, so i dont need jumpers for my project. right?

i follow the wiring from library and some pre examples of it but no luck at all. i have the E with ESP32 GPIO 15

All have the same ground,
i dont know where to start and how to verify every step.
i think that i act right but the result is none.

i have SM5166PF led driver. is this common i think and compatible with library.

tmagafas84:

i will try with esp32.

Hi @tmagafas84
Were you able to run the panel on ESP32?

tmagafas84:

for now the best result is the code i have at post.

The code in your post above merely is not suited to 80x40 1/20 matrix. As I mentioned, you should to define a pin for E line and init display object with a correct scan rate.

Also keep in mind that a number of pins on the ESP8266 controller have limitations in their use, which is why these pins are not recommended for use:

Crucial Pin Restrictions (Boot Modes):

• GPIO0 (D3): Must be HIGH at boot. Connected to FLASH button.
• GPIO2 (D4): Must be HIGH at boot.
• GPIO15 (D8): Must be LOW at boot.
• GPIO16 (D0): Can be used as GPIO, but does not support analogWrite.
• GPIO1/GPIO3 (TX/RX): Used for serial debugging; avoid using as GPIO

Because of the above, the 8266 controller simply doesn’t have enough pins for a direct connection. This is why the PxMatrix library uses a special connection scheme where all color pins are connected to one pin.

Some time ago I used esp8266 with HUB75 panels to test purpose… If you want, I can look at which pins I use to connect on the 8266 controller.
But I would recommend using an ESP32 or RP2040.

for now the best result is the code i have at post.
but not the best

tmagafas84:

#define P_LAT 16
#define P_A 5
#define P_B 4
#define P_C 15
#define P_D 12
#define P_OE 2

PxMATRIX display(80, 40, P_LAT, P_OE, P_A, P_B, P_C, P_D);

To work with this panel you must to define a full set of ABCDE pins. As we can see in the code below, you omit to define the E line.

I am currently using the PxMatrix library and Adafruit GFX fonts (e.g. FreeSansBold12pt7b) to get a clear and readable result. The panel works, but I would appreciate help with correct wiring (pin connections, scan type considerations) and best practices in the code to ensure stable refresh, no flickering, and proper font rendering on a 1/20 scan panel.

If anyone has experience with ESP8266 + P4 (80×40) panels, especially regarding wiring or configuration details, your guidance would be very helpful. Thank you in advance.

#include <ESP8266WiFi.h>

#include <Ticker.h>

#include <PxMatrix.h>

Ticker display_ticker;

#define P_LAT 16

#define P_A 5

#define P_B 4

#define P_C 15

#define P_D 12

#define P_OE 2

PxMATRIX display(80, 40, P_LAT, P_OE, P_A, P_B, P_C, P_D);

uint8_t display_draw_time = 30;

void display_updater() {

display.display(display_draw_time);

}

void setup() {

WiFi.mode(WIFI_OFF);

WiFi.forceSleepBegin();

delay(1);

display.begin(16);

display_ticker.attach(0.002, display_updater);

display.fillScreen(display.color565(0, 0, 0));

display.setTextWrap(false);

display.setTextColor(display.color565(255, 0, 0));

display.setTextSize(1);

display.setCursor(18, 8);

display.print(“MEETING”);

display.setTextColor(display.color565(0, 255, 255));

display.setCursor(5, 23);

display.print(“in progress”);

}

void loop() { }

R1 → D7

G1 → R2

B1 → G2

R2 → R1

G2 → G1

B2 → B1

E → D3

A → D1

B → D2

C → D8

D → D6

CLK → D5

LAT → D0

OE → D4

GND → GND

one more isuue regarding panel Colour order is BBGGRR. how to set it

Asif_Ruikar:

can you send me code

No, I don’t have a code.

Please consult the library documentation about panel chaining:

Also, it would probably be more useful to ask questions in the library repo, rather than on this forum, which is dedicated to another project.

So it is a fairly standard matrix, that can be used without any specific settings

P10 RGB (32x16, 8Scan, A,B&C address line)

has a standard mappings, so you don’t need to include a “custom class derived from VirtualMatrixPanel” to your code.

Use a standard examples.

Asif_Ruikar:

think it’s high Refresh rate panel.ie. 3840Hz

As far as I can see, no. There are ICN2038S - standard drivers.

Frequency doesn’t matter. It is possible to lower the frequency if needed.

The driver model is what matters.

It’s not supported the above 1920Hz.

It’s not supported the above 1920Hz.

• P10 Panel Test - Display Numbers 1-12
• For 2x6 P10 panels (32x16 each)
  */

#include <Adafruit_GFX.h>
#include “ESP32-HUB75-MatrixPanel-I2S-DMA.h”
#include “ESP32-VirtualMatrixPanel-I2S-DMA.h”
#include “Fonts/Font9x14.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

};

// 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;
}

// ================= P10 MATRIX CONFIGURATION =================
#define R1_PIN 4
#define G1_PIN 16
#define B1_PIN 17
#define R2_PIN 21
#define G2_PIN 25
#define B2_PIN 26
#define A_PIN 19
#define B_PIN 23
#define C_PIN 18
#define D_PIN -1
#define E_PIN -1
#define LAT_PIN 22
#define OE_PIN 2
#define CLK_PIN 14

// Panel configuration
#define PANEL_RES_X 32 // P10 width
#define PANEL_RES_Y 16 // P10 height
#define NUM_ROWS 2 // 2 rows of panels
#define NUM_COLS 6 // 6 columns of panels
#define PANEL_CHAIN_LEN NUM_ROWS*NUM_COLS

#define VIRTUAL_MATRIX_CHAIN_TYPE CHAIN_TOP_RIGHT_DOWN

#define SERPENT true
#define TOPTDOWN true

// ================= GLOBAL OBJECTS =================
MatrixPanel_I2S_DMA *dma_display = nullptr;

CustomPxBasePanel *FourScanPanel = nullptr;

// ================= DISPLAY VARIABLES =================
uint16_t myRED, myGREEN, myBLUE, myYELLOW, myWHITE, myBLACK;

void setup() {
Serial.begin(115200);
delay(1000);

Serial.println(“\n\n========================================”);
Serial.println(“P10 Panel Test - Numbers 1-12”);
Serial.println(“2x6 P10 Panels (32x16 each)”);
Serial.println(“========================================”);

// Initialize display
Serial.println(“Initializing display…”);

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
);

// Set pin assignments
mxconfig.gpio.r1 = R1_PIN;
mxconfig.gpio.g1 = G1_PIN;
mxconfig.gpio.b1 = B1_PIN;
mxconfig.gpio.r2 = R2_PIN;
mxconfig.gpio.g2 = G2_PIN;
mxconfig.gpio.b2 = B2_PIN;
mxconfig.gpio.a = A_PIN;
mxconfig.gpio.b = B_PIN;
mxconfig.gpio.c = C_PIN;
mxconfig.gpio.d = D_PIN;
mxconfig.gpio.e = E_PIN;
mxconfig.gpio.lat = LAT_PIN;
mxconfig.gpio.oe = OE_PIN;
mxconfig.gpio.clk = CLK_PIN;

// P10 specific settings
mxconfig.driver = HUB75_I2S_CFG::FM6124;
mxconfig.i2sspeed = HUB75_I2S_CFG::HZ_10M;
mxconfig.clkphase = false;
mxconfig.latch_blanking = 4;
mxconfig.min_refresh_rate = 150;

dma_display = new MatrixPanel_I2S_DMA(mxconfig);

if (!dma_display->begin()) {
Serial.println(“Display init failed!”);
while(1);
}

dma_display->setBrightness8(128);
dma_display->clearScreen();
delay(100);

// Create virtual display - TRY DIFFERENT CHAIN TYPES HERE
// Start with CHAIN_TOP_LEFT_DOWN (most common)
FourScanPanel = new CustomPxBasePanel(
(*dma_display),
NUM_ROWS, // 2 rows
NUM_COLS, // 6 columns
PANEL_RES_X, // 32 width per panel
PANEL_RES_Y, // 16 height per panel
VIRTUAL_MATRIX_CHAIN_TYPE // Try this first
// Other options:
// CHAIN_TOP_RIGHT_DOWN
// CHAIN_BOTTOM_LEFT_UP
// CHAIN_BOTTOM_RIGHT_UP
);

// Try different scan rates for P10
// FourScanPanel->setPhysicalPanelScanRate(FOUR_SCAN_16PX_HIGH);
// FourScanPanel->setPhysicalPanelScanRate(FOUR_SCAN_32PX_HIGH);

// Initialize colors
myRED = dma_display->color565(255, 0, 0);
myGREEN = dma_display->color565(0, 255, 0);
myBLUE = dma_display->color565(0, 0, 255);
myYELLOW = dma_display->color565(255, 255, 0);
myWHITE = dma_display->color565(255, 255, 255);
myBLACK = dma_display->color565(0, 0, 0);

Serial.println(“\nDisplay initialized successfully!”);
Serial.println("Virtual Display Size: " + String(FourScanPanel->width()) + “x” + String(FourScanPanel->height()));

// Run test patterns
testAllPanels();
testPanelNumbers();
}

void testAllPanels() {
Serial.println(“\n=== TEST 1: Fill each panel with different colors ===”);

uint16_t colors = {myRED, myGREEN, myBLUE, myYELLOW, myWHITE};

for(int row = 0; row < NUM_ROWS; row++) {
for(int col = 0; col < NUM_COLS; col++) {
int panelNum = row * NUM_COLS + col + 1;
int startX = col * PANEL_RES_X;
int startY = row * PANEL_RES_Y;

  // Fill panel with color
  FourScanPanel->fillRect(startX, startY, PANEL_RES_X, PANEL_RES_Y, colors[panelNum % 5]);
  
  Serial.print("Panel ");
  Serial.print(panelNum);
  Serial.print(" filled at (");
  Serial.print(startX);
  Serial.print(",");
  Serial.print(startY);
  Serial.println(")");
  
  delay(1000);
}

}

delay(2000);
FourScanPanel->fillScreen(myBLACK);
}

void testPanelNumbers() {
Serial.println(“\n=== TEST 2: Display panel numbers 1-12 ===”);

FourScanPanel->fillScreen(myBLACK);

// Set font
FourScanPanel->setFont(&Font9x14);
FourScanPanel->setTextColor(myWHITE);

for(int row = 0; row < NUM_ROWS; row++) {
for(int col = 0; col < NUM_COLS; col++) {
int panelNum = row * NUM_COLS + col + 1;
int panelCenterX = col * PANEL_RES_X + (PANEL_RES_X / 2) - 4;
int panelCenterY = row * PANEL_RES_Y + (PANEL_RES_Y / 2) + 4;

  FourScanPanel->setCursor(panelCenterX, panelCenterY);
  FourScanPanel->print(panelNum);
  
  Serial.print("Panel ");
  Serial.print(panelNum);
  Serial.print(" number at (");
  Serial.print(panelCenterX);
  Serial.print(",");
  Serial.print(panelCenterY);
  Serial.println(")");
}

}

// Also draw borders for reference
FourScanPanel->setTextColor(myRED);
FourScanPanel->setCursor(1, 1);
FourScanPanel->print(“TEST”);

// Draw red border around entire display
for(int x = 0; x < FourScanPanel->width(); x++) {
FourScanPanel->drawPixel(x, 0, myRED);
FourScanPanel->drawPixel(x, FourScanPanel->height() - 1, myRED);
}
for(int y = 0; y < FourScanPanel->height(); y++) {
FourScanPanel->drawPixel(0, y, myRED);
FourScanPanel->drawPixel(FourScanPanel->width() - 1, y, myRED);
}

Serial.println(“\nNumbers displayed. Check if panels show 1-12 in order.”);
Serial.println(“If numbers are out of order, change CHAIN_TYPE in code.”);
}

void loop() {
// Flash the numbers
static unsigned long lastChange = 0;
static bool showNumbers = true;

if(millis() - lastChange > 2000) {
lastChange = millis();
showNumbers = !showNumbers;

if(showNumbers) {
  testPanelNumbers();
} else {
  FourScanPanel->fillScreen(myBLACK);
  FourScanPanel->setTextColor(myGREEN);
  FourScanPanel->setFont(&Font9x14);
  FourScanPanel->setCursor(60, 14);
  FourScanPanel->print("2x6 P10");
}

}
} Output showing in 1st row : 1st and 3rd 4 row glowing and in 2Row : 2nd and 4th 4 Row glowing. Help me out with it

I’m more of a tinkerer than a programmer, but with some AI help I got Aurora running on a Teensy 4.1 with SmartLEDShield v5.
Patterns, audio-reactive visuals, GIFs, TXT messages, and the clock all work. JSON isn’t working yet, but it’s fully playable!

Check it out here: [GitHub link]

Hopefully this helps anyone who wants to run Aurora on a Teensy 4.1!

But with this you wrote me aboat Q2-Q4 only.

Also, please specify the driver designations, for example for UR7, UG7, UB7… etc

And what is the text on Q2 - Q4 chips?

Could you share the schematic or a list of parts? It would help me understand how to configure my own version.

Thank you!

I have tried running other examples, switching the port I connect to in the panels, and have not been able to get the panels to turn on at all, as I mentioned, I’d appreciate any advice on this. Thanks everyone!

Code:
#define USE_ADAFRUIT_GFX_LAYERS
#include <MatrixHardware_Teensy4_ShieldV5.h>
#include <SmartMatrix.h>

#define COLOR_DEPTH 24
const uint16_t kMatrixWidth = 128;
const uint16_t kMatrixHeight = 64;
const uint8_t kRefreshDepth = 36;
const uint8_t kDmaBufferRows = 4;
const uint8_t kPanelType = SM_PANELTYPE_HUB75_32ROW_MOD16SCAN;
const uint32_t kMatrixOptions = (SM_HUB75_OPTIONS_NONE);
const uint8_t kBackgroundLayerOptions = (SM_BACKGROUND_OPTIONS_NONE);
const uint8_t kScrollingLayerOptions = (SM_SCROLLING_OPTIONS_NONE);
const uint8_t kIndexedLayerOptions = (SM_INDEXED_OPTIONS_NONE);

Specs HB75 panel:
Module Size: 320x160x5.35mm
Signal Interface Mode: HUB75
Module Resolution: 128x64 pixels
Scans Mode: 1/32
Max Power Consumption: 22.5W
Gray Level: 12-16 Bits
Chip number I can read off the back: DP3364S 5A0201

Speedy-VI:

He does not mention an ESP32-S3

Sorry, but ESP32 controller family doesn’t supported by my library.

He is far,far more knowledgeable than me about controlling various different driver chips found on these panels. You should check out his list of supported LED drivers in his WIKI. The FM6363 is listed as a Furman s-PWM based chip, which his DMD_STM32 library can control. Based on his Quick Start Guide, I think you can use an STM32 or an RP2040 Pico. He does not mention an ESP32-S3 so I don’t know if this MCU can run his library. His instructions for how to get everything set up are very detailed, so I think it you go through it step by step, you will be able to get the FM6363 base matrix working. Good luck!

edit to add - I noticed you said your panel has FM6363C. I don’t know if these are the same as the FM6363 listed in board707’s Wiki. Sometimes an added character doesn’t make any difference and sometimes it does.

But the strange thing is that line D and E are connected to GND, measured with a digital tester, it seems that lines D and E are not used.

To finish complicating it, use the FM6363C chip, which is why I will arrive at this forum.

Before I throw it away, I ask, do I have any chance of handling it with any ESP?
Thank you very much now.