FM6124EJ-32x32 pixel LED board

[bitwlzxzq]

I am using an ESP32P4 to control a 32x32 pixel LED board. The control chip should be an FM6124EJ. Currently, the compilation is fine, but the program fails to initialize. If I change to a different control chip, the display is still not normal.
FM6124A: FM6124 initialization not yet implemented
LED board . HUB75: shift driver initialization failed:ESP_ERR_NOT_SUPPORTED
simple_colors:failed to initialize HUB75 driver!

`

#include "hub75.h"
#include "board_config.h"
#include <esp_log.h>
#include <freertos/FreeRTOS.h> // NOLINT(misc-header-include-cycle)
#include <freertos/task.h>

static const char *const TAG = "simple_colors";

extern "C" void app_main() {
ESP_LOGI(TAG, "HUB75 Simple Colors Example Starting...");

// Load configuration from menuconfig
// Hub75Config config = getMenuConfigSettings();
Hub75Config config{};
config.panel_width = 32;
config.panel_height = 32;
config.shift_driver = Hub75ShiftDriver::FM6124; // Try this if GENERIC doesn't work

// Set GPIO pins (example for ESP32-S3)
config.pins.r1 = 42; config.pins.g1 = 41; config.pins.b1 = 40;
config.pins.r2 = 38; config.pins.g2 = 39; config.pins.b2 = 37;
config.pins.a = 45; config.pins.b = 36; config.pins.c = 48;
config.pins.d = 35; config.pins.e = 21;
config.pins.lat = 47; config.pins.oe = 6; config.pins.clk = 2;

// Print configuration summary
ESP_LOGI(TAG, "Configuration:");
ESP_LOGI(TAG, " Panel: %dx%d pixels (%d-bit, %d Hz min refresh)", config.panel_width, config.panel_height,
HUB75_BIT_DEPTH, config.min_refresh_rate);
ESP_LOGI(TAG, " Layout: %dx%d panels (total %dx%d display)", config.layout_cols, config.layout_rows,
config.panel_width * config.layout_cols, config.panel_height * config.layout_rows);

// Print pin configuration
printPinConfig(config.pins);

// Create driver instance
Hub75Driver driver(config);

// Initialize and start continuous refresh
if (!driver.begin()) {
ESP_LOGE(TAG, "Failed to initialize HUB75 driver!");
return;
}

ESP_LOGI(TAG, "Driver initialized successfully");
ESP_LOGI(TAG, "Display: %dx%d pixels", driver.get_width(), driver.get_height());

// Clear display
driver.clear();

// Draw colored squares in corners
// Uses both fill() (optimized) and set_pixel() loops to demonstrate both APIs
const uint16_t square_size = 8;

// Top-left: Red (using fill - optimized for solid rectangles)
driver.fill(0, 0, square_size, square_size, 255, 0, 0);

// Top-right: Green (using set_pixel loop - for comparison)
for (uint16_t y = 0; y < square_size; y++) {
for (uint16_t x = driver.get_width() - square_size; x < driver.get_width(); x++) {
driver.set_pixel(x, y, 0, 255, 0);
}
}

// Bottom-left: Blue (using set_pixel loop - for comparison)
for (uint16_t y = driver.get_height() - square_size; y < driver.get_height(); y++) {
for (uint16_t x = 0; x < square_size; x++) {
driver.set_pixel(x, y, 0, 0, 255);
}
}

// Bottom-right: White (using fill - optimized for solid rectangles)
driver.fill(driver.get_width() - square_size, driver.get_height() - square_size, square_size, square_size, 255, 255,
255);

// Draw center cross in cyan
uint16_t cx = driver.get_width() / 2;
uint16_t cy = driver.get_height() / 2;

// Horizontal line
for (uint16_t x = cx - 10; x <= cx + 10; x++) {
driver.set_pixel(x, cy, 0, 255, 255);
}

// Vertical line
for (uint16_t y = cy - 10; y <= cy + 10; y++) {
driver.set_pixel(cx, y, 0, 255, 255);
}

ESP_LOGI(TAG, "Test pattern displayed");
ESP_LOGI(TAG, "Expected output:");
ESP_LOGI(TAG, " - Red square in top-left corner");
ESP_LOGI(TAG, " - Green square in top-right corner");
ESP_LOGI(TAG, " - Blue square in bottom-left corner");
ESP_LOGI(TAG, " - White square in bottom-right corner");
ESP_LOGI(TAG, " - Cyan cross in center");

// Idle loop (display continues refresh via DMA)
while (true) {
vTaskDelay(pdMS_TO_TICKS(1000));
}
}

`

[stuartparmenter]

A few things to try / look at:

• FM6124 should use the same init as FM6126A -- try that if you didn't', so I'll fix it to not error out and just fallback to that case. I assume GENERIC isn't working?
• I've had a lot of issues just with using dupot cables from my P4 to a panel -- it works fine sometimes, and totally fails to show anything. I wasted so much time while building the P4 code because of this thinking my code was broken. I think mostly because hub75 panels want 5V inputs and the P4 pins are all 3.3V, so without a level shifter you might be just getting bit by the same thing. I wish I could say I found a reliable fix -- a lot of pushing, pulling, nudging the pins usually gets it working. Lowering the clock rate might help avoid signal loss a bit.
• Double check the P4 pins aren't strapping pins or used for other things and don't have weird data on them -- I had to move mine around to different pins for a bit to find ones that were totally clean

[bitwlzxzq]

I chose generic, and the problem is probably caused by incomplete initialization.

[bitwlzxzq]

I carefully examined the LED; the interface on it is a 74HC245.
The program can now run, but the LED is not lit.
I changed the pins to avoid the audio, SD card, and LCD pins connected to the system board.

[bitwlzxzq]

There's new progress; the LEDs are lit, but only 32*8 rows are illuminated.

// Set GPIO pins (example for ESP32-P4)
config.pins.r1 = 46; config.pins.g1 = 47; config.pins.b1 = 48;
config.pins.r2 = 49; config.pins.g2 = 50; config.pins.b2 = 51;
config.pins.a = 27; config.pins.b = 28; config.pins.c = 29;
config.pins.d = 30;
    config.pins.e = 31;
config.pins.lat = 22; config.pins.oe = 41; config.pins.clk = 23;

`

[bitwlzxzq]

Hub75ScanWiring::SCAN_32_32PX_FULL
1/32 scan
How to modify the scanning method

[stuartparmenter]

Hub75ScanWiring::SCAN_32_32PX_FULL
1/32 scan
How to modify the scanning method

Take a look at #101 for an example. They have to be added to the library as things are right now

[bitwlzxzq]

I modified the program using AI, but it's still incomplete.

[bitwlzxzq]

Is the display effect the same as the image?

[bitwlzxzq]

Modified scan_patterns.h to add a 1/32 refresh operation.

[bitwlzxzq]

// SPDX-FileCopyrightText: 2025 Stuart Parmenter
// SPDX-License-Identifier: MIT

// @file scan_patterns.h
// @brief Scan pattern coordinate remapping

// Based on https://github.com/mrcodetastic/ESP32-HUB75-MatrixPanel-DMA

#pragma once

#include "hub75_types.h"
#include "hub75_config.h"
#include <esp_idf_version.h>

namespace hub75 {

// Coordinate pair
struct Coords {
uint16_t x;
uint16_t y;
};

// ============================================================================
// Four-Scan Panel Dimension Helpers
// ============================================================================

/**

• @brief Check if scan wiring pattern requires dimension adjustments
• 1/4 and 1/8 scan panels have internal wiring that requires:
• • DMA buffer width to be doubled
• • Number of row addresses to be halved
• • Coordinate remapping with segment interleaving
    */
    attribute((always_inline)) HUB75_CONST inline constexpr bool is_four_scan_wiring(Hub75ScanWiring wiring) {
    return wiring == Hub75ScanWiring::SCAN_1_4_16PX_HIGH || wiring == Hub75ScanWiring::SCAN_1_8_32PX_HIGH ||
    wiring == Hub75ScanWiring::SCAN_1_8_32PX_FULL || wiring == Hub75ScanWiring::SCAN_1_8_40PX_HIGH ||
    wiring == Hub75ScanWiring::SCAN_1_8_64PX_HIGH || wiring == Hub75ScanWiring::SCAN_1_32_32PX_FULL;
    }
    attribute((always_inline)) HUB75_CONST inline constexpr bool is_double_dma_width_scan(
    Hub75ScanWiring wiring) {

return wiring == Hub75ScanWiring::SCAN_1_4_16PX_HIGH ||
wiring == Hub75ScanWiring::SCAN_1_8_32PX_HIGH ||
wiring == Hub75ScanWiring::SCAN_1_8_32PX_FULL ||
wiring == Hub75ScanWiring::SCAN_1_8_40PX_HIGH ||
wiring == Hub75ScanWiring::SCAN_1_8_64PX_HIGH ||
wiring == Hub75ScanWiring::SCAN_1_32_32PX_FULL;
}
/**

• @brief Get effective DMA buffer width for a panel configuration

• For standard panels: panel_width * layout_rows * layout_cols

• For 1/4 or 1/8 scan panels: panel_width * 2 * layout_rows * layout_cols
  /
  attribute((always_inline)) HUB75_CONST inline constexpr uint16_t get_effective_dma_width(Hub75ScanWiring wiring,
  uint16_t panel_width,
  uint16_t layout_rows,
  uint16_t layout_cols) {
  const uint16_t multiplier = is_double_dma_width_scan(wiring) ? 2 : 1;
  return panel_width * multiplier * layout_rows * layout_cols;
  // switch (wiring)
  // {
  // case Hub75ScanWiring::STANDARD_TWO_SCAN:
  // / code */
  // return panel_height;

  // default:
  // return panel_height;
  // }
  }

/**

• @brief Get number of row addresses (num_rows) for a panel configuration

• Standard panels: panel_height / 2 (upper/lower halves)

• 1/4 or 1/8 scan panels: panel_height / 4 (physical height is halved)
  /
  attribute((always_inline)) HUB75_CONST inline constexpr uint16_t get_effective_num_rows(Hub75ScanWiring wiring,
  uint16_t panel_height) {
  if(wiring ==Hub75ScanWiring::SCAN_1_32_32PX_FULL){
  return panel_height;
  }
  return is_four_scan_wiring(wiring) ? (panel_height / 4) : (panel_height / 2);
  // switch (wiring)
  // {
  // case Hub75ScanWiring::STANDARD_TWO_SCAN:
  // / code */
  // return panel_height/2;

  // default:
  // return panel_height/2;
  // }
  }

/**

• @brief Get pixel segment size for four-scan coordinate remapping

• Four-scan panels interleave pixel segments based on Y position.

• The segment size determines the interleaving boundary.

• For SCAN_1_4_16PX_HIGH (16px high, 1/4 scan): segments of panel_width

• For SCAN_1_8_32PX_HIGH (32px high, 1/8 scan): 16-pixel segments

• For SCAN_1_8_64PX_HIGH (64px high, 1/8 scan): segments of panel_width

• @return Segment size in pixels for coordinate remapping
  */
  attribute((always_inline)) HUB75_CONST HUB75_IRAM inline constexpr uint16_t get_four_scan_segment_size(
  Hub75ScanWiring wiring, uint16_t panel_width, uint16_t panel_height) {
  switch (wiring) {
  case Hub75ScanWiring::SCAN_1_8_32PX_HIGH:
  // 32px high 1/8 scan panels use 16-pixel segments
  // Formula: panel_width / (panel_height / 8) = panel_width / 4
  // For 64x32: 64 / 4 = 16
  if (panel_height < 8)
  return panel_width; // Defensive check for invalid config
  return panel_width / (panel_height / 8);
  case Hub75ScanWiring::SCAN_1_8_32PX_FULL:
  // 32px high 1/8 scan panels with full-width segments (e.g. P4-1921-64x32-8S)
  // Shift register: [row_N+8 x0..63 | row_N x0..63] 锟?no interleaving
  return panel_width;
  case Hub75ScanWiring::SCAN_1_8_40PX_HIGH:
  case Hub75ScanWiring::SCAN_1_4_16PX_HIGH:
  case Hub75ScanWiring::SCAN_1_8_64PX_HIGH:

  default:
  // These use panel_width as segment size
  return panel_width;
  }
  }

// Scan pattern coordinate remapping
// Transforms logical pixel coordinates to physical shift register positions
class ScanPatternRemap {
public:
// Remap coordinates based on scan pattern
// @PARAM c Input coordinates
// @PARAM pattern Scan pattern type
// @PARAM panel_width Width of single panel
// @PARAM panel_height Height of single panel (used for segment size calculation)
// @return Remapped coordinates
attribute((always_inline)) static HUB75_CONST HUB75_IRAM constexpr Coords remap(Coords c, Hub75ScanWiring pattern,
uint16_t panel_width,
uint16_t panel_height) {
switch (pattern) {
case Hub75ScanWiring::STANDARD_TWO_SCAN:
// No transformation needed
return c;

  case Hub75ScanWiring::SCAN_1_4_16PX_HIGH: {
    // 16px high 1/4 scan panels
    // Uses panel_width as segment size
    if ((c.y & 4) == 0) {
      c.x += (((c.x / panel_width) + 1) * panel_width);
    } else {
      c.x += ((c.x / panel_width) * panel_width);
    }
    c.y = (c.y >> 3) * 4 + (c.y & 0b00000011);
    return c;
  }

  case Hub75ScanWiring::SCAN_1_8_32PX_HIGH: {
    // 32px high 1/8 scan panels
    // Segment size = panel_width / (panel_height / 8)
    // For typical 64x32 panel: 64 / 4 = 16-pixel segments
    const uint16_t segment_size = get_four_scan_segment_size(pattern, panel_width, panel_height);

    if ((c.y & 8) == 0) {
      c.x += (((c.x / segment_size) + 1) * segment_size);
    } else {
      c.x += ((c.x / segment_size) * segment_size);
    }
    c.y = (c.y >> 4) * 8 + (c.y & 0b00000111);
    return c;
  }

  case Hub75ScanWiring::SCAN_1_8_32PX_FULL: {
    // 32px high 1/8 scan, full-width (panel_width) segments
    // X-transform: same as SCAN_1_8_40PX_HIGH (full-width split)
    // Y-transform: same as SCAN_1_8_32PX_HIGH (correct for 32px)
    if ((c.y & 8) == 0) {
      c.x += (((c.x / panel_width) + 1) * panel_width);
    } else {
      c.x += ((c.x / panel_width) * panel_width);
    }
    c.y = (c.y >> 4) * 8 + (c.y & 0b00000111);
    return c;
  }

  case Hub75ScanWiring::SCAN_1_8_40PX_HIGH: {
    // 40px high 1/8 scan panels use 10-pixel row blocks
    if ((c.y & 8) == 0) {
      c.x += (((c.x / panel_width) + 1) * panel_width);
    } else {
      c.x += ((c.x / panel_width) * panel_width);
    }
    c.y = (c.y / 20) * 10 + (c.y % 10);
    return c;
  }

  case Hub75ScanWiring::SCAN_1_8_64PX_HIGH: {
    // 64px high 1/8 scan panels
    // Extra remapping for 64px high panels
    if ((c.y & 8) != ((c.y & 16) >> 1)) {
      c.y = (((c.y & 0b11000) ^ 0b11000) + (c.y & 0b11100111));
    }
    if ((c.y & 8) == 0) {
      c.x += (((c.x / panel_width) + 1) * panel_width);
    } else {
      c.x += ((c.x / panel_width) * panel_width);
    }
    c.y = (c.y >> 4) * 8 + (c.y & 0b00000111);
    return c;
  }
  case Hub75ScanWiring::SCAN_1_32_32PX_FULL:{
	constexpr uint16_t stride = 32;
	// uint16_t panel_index = c.x /panel_width;
	// uint16_t local_x = c.x %panel_width;
	// uint16_t panel_base = panel_index*(panel_width*2);
	if((c.y&1)==0){
		c.x+=stride;
		// local_x +=panel_width;
	}
	// c.x =panel_base +local_x;
	// c.y>>=1; 
	return c;
  }
  default:
    return c;
}

}
};

// ============================================================================
// Compile-Time Validation (ESP-IDF 5.x only - requires consteval/GCC 9+)
// ============================================================================

#if ESP_IDF_VERSION_MAJOR >= 5
namespace { // Anonymous namespace for compile-time validation

// Validate standard scan is identity transform
consteval bool test_standard_scan_identity() {
constexpr Coords input = {32, 16};
constexpr uint16_t panel_width = 64;
constexpr uint16_t panel_height = 32;
constexpr Coords output =
ScanPatternRemap::remap(input, Hub75ScanWiring::STANDARD_TWO_SCAN, panel_width, panel_height);
return (output.x == input.x) && (output.y == input.y);
}

// Validate four-scan doesn't overflow coordinates
consteval bool test_four_scan_no_overflow() {
constexpr Coords input = {63, 63};
constexpr uint16_t panel_width = 64;

constexpr Coords out16 = ScanPatternRemap::remap(input, Hub75ScanWiring::SCAN_1_4_16PX_HIGH, panel_width, 16);
// constexpr Coords out32 = ScanPatternRemap::remap(input, Hub75ScanWiring::SCAN_1_8_32PX_HIGH, panel_width, 32);
constexpr Coords out32 = ScanPatternRemap::remap(input, Hub75ScanWiring::SCAN_1_32_32PX_FULL, panel_width, 64);

constexpr Coords out40 = ScanPatternRemap::remap(input, Hub75ScanWiring::SCAN_1_8_40PX_HIGH, panel_width, 40);
constexpr Coords out64 = ScanPatternRemap::remap(input, Hub75ScanWiring::SCAN_1_8_64PX_HIGH, panel_width, 64);

return (out16.x < 256 && out16.y < 256) && (out32.x < 256 && out32.y < 256) && (out40.x < 256 && out40.y < 256) &&
(out64.x < 256 && out64.y < 256);
}

// Validate segment size calculation for 64x32 1/8 scan panel
consteval bool test_1_8_scan_32px_segment_size() {
constexpr uint16_t panel_width = 64;
constexpr uint16_t panel_height = 32;
constexpr uint16_t segment_size =
get_four_scan_segment_size(Hub75ScanWiring::SCAN_1_8_32PX_HIGH, panel_width, panel_height);
// For 64x32 panel: segment_size = 64 / (32 / 8) = 64 / 4 = 16
return segment_size == 16;
}

// Validate DMA dimension calculations for four-scan panels
consteval bool test_1_8_scan_dma_dimensions() {
constexpr uint16_t panel_width = 64;
constexpr uint16_t panel_height = 32;

// For 64x32 1/8 scan panel:
// dma_width = panel_width * 2 = 128
constexpr uint16_t dma_width = get_effective_dma_width(Hub75ScanWiring::SCAN_1_8_32PX_HIGH, panel_width, 1, 1);
// num_rows = panel_height / 4 = 8
constexpr uint16_t num_rows = get_effective_num_rows(Hub75ScanWiring::SCAN_1_8_32PX_HIGH, panel_height);

return dma_width == 128 && num_rows == 8;
}
consteval bool test_1_32_scan_remap() {
constexpr uint16_t panel_width = 32;
constexpr uint16_t panel_height = 32;

//y=0
{
constexpr Coords in = {0, 0};

constexpr Coords out =
    ScanPatternRemap::remap(
        in,
        Hub75ScanWiring::SCAN_1_32_32PX_FULL,
        panel_width,
        panel_height);

if (out.x != 32 || out.y != 0)
  return false;

}
// y=1
{
constexpr Coords in = {0, 1};

constexpr Coords out =
    ScanPatternRemap::remap(
        in,
        Hub75ScanWiring::SCAN_1_32_32PX_FULL,
        panel_width,
        panel_height);

if (out.x != 0 || out.y != 1)
  return false;

}
// y=2
{
constexpr Coords in = {0, 2};

constexpr Coords out =
	ScanPatternRemap::remap(
		in,
		Hub75ScanWiring::SCAN_1_32_32PX_FULL,
		panel_width,
		panel_height);

if (out.x != 32 || out.y != 2)
return false;

}

return true;
}
// Validate coordinate remapping for 64x32 1/8 scan panel
consteval bool test_1_8_scan_32px_remap() {
constexpr uint16_t panel_width = 64;
constexpr uint16_t panel_height = 32;

// Test pixel at (0, 0) - should remap to x=16 (segment interleave), y=0
constexpr Coords in1 = {0, 0};
constexpr Coords out1 = ScanPatternRemap::remap(in1, Hub75ScanWiring::SCAN_1_8_32PX_HIGH, panel_width, panel_height);
// y & 8 == 0, so x += ((0/16) + 1) * 16 = 16
if (out1.x != 16 || out1.y != 0)
return false;

// Test pixel at (0, 8) - should remap to x=0, y=0
constexpr Coords in2 = {0, 8};
constexpr Coords out2 = ScanPatternRemap::remap(in2, Hub75ScanWiring::SCAN_1_8_32PX_HIGH, panel_width, panel_height);
// y & 8 != 0, so x += (0/16) * 16 = 0
// y = (8 >> 4) * 8 + (8 & 0b111) = 0 * 8 + 0 = 0
if (out2.x != 0 || out2.y != 0)
return false;

// Test pixel at (16, 0) - should remap to x=48, y=0
constexpr Coords in3 = {16, 0};
constexpr Coords out3 = ScanPatternRemap::remap(in3, Hub75ScanWiring::SCAN_1_8_32PX_HIGH, panel_width, panel_height);
// y & 8 == 0, so x += ((16/16) + 1) * 16 = 32, total = 16 + 32 = 48
if (out3.x != 48 || out3.y != 0)
return false;

return true;
}

// Test 40px panel coordinate remapping
consteval bool test_1_8_scan_40px_remap() {
constexpr uint16_t panel_width = 80;
constexpr uint16_t panel_height = 40;

// Test y=0 -> y=0
constexpr Coords in1 = {0, 0};
constexpr Coords out1 = ScanPatternRemap::remap(in1, Hub75ScanWiring::SCAN_1_8_40PX_HIGH, panel_width, panel_height);
// y = (0 / 20) * 10 + (0 % 10) = 0
if (out1.y != 0)
return false;

// Test y=20 -> y=10 (second 10-pixel block)
constexpr Coords in2 = {0, 20};
constexpr Coords out2 = ScanPatternRemap::remap(in2, Hub75ScanWiring::SCAN_1_8_40PX_HIGH, panel_width, panel_height);
// y = (20 / 20) * 10 + (20 % 10) = 10
if (out2.y != 10)
return false;

// Test y=5 -> y=5
constexpr Coords in3 = {0, 5};
constexpr Coords out3 = ScanPatternRemap::remap(in3, Hub75ScanWiring::SCAN_1_8_40PX_HIGH, panel_width, panel_height);
// y = (5 / 20) * 10 + (5 % 10) = 5
if (out3.y != 5)
return false;

return true;
}

// Test multi-panel DMA dimensions
consteval bool test_1_8_scan_chained_panels() {
// 2x2 layout of 64x32 1/8 scan panels
constexpr uint16_t dma_width = get_effective_dma_width(Hub75ScanWiring::SCAN_1_8_32PX_HIGH, 64, 2, 2);
// Expected: 64 * 2 (four-scan) * 2 * 2 = 512
return dma_width == 512;
}

static_assert(test_standard_scan_identity(), "Standard scan must be identity transform");
static_assert(test_four_scan_no_overflow(), "Four-scan patterns produce out-of-bounds coordinates");
static_assert(test_1_8_scan_32px_segment_size(), "SCAN_1_8_32PX_HIGH segment size should be 16 for 64x32 panel");
static_assert(test_1_8_scan_dma_dimensions(), "1/8 scan DMA dimensions incorrect");
static_assert(test_1_8_scan_32px_remap(), "SCAN_1_8_32PX_HIGH coordinate remapping incorrect");
static_assert(test_1_8_scan_40px_remap(), "SCAN_1_8_40PX_HIGH coordinate remapping incorrect");
static_assert(test_1_8_scan_chained_panels(), "Multi-panel DMA dimensions incorrect");
static_assert(test_1_32_scan_remap(), "1/32 scan remap failed");
} // namespace
#endif // ESP_IDF_VERSION_MAJOR >= 5

} // namespace hub75

The multiple panels are displaying incorrectly because my code for displaying a single panel is hardcoded. How can I modify it to accommodate multiple panels?

[stuartparmenter]

I can take a look at your changes in the next couple days and suggest a did, thanks for digging in!

[bitwlzxzq]

Did you modify the 1/32 program?

[stuartparmenter]

Have you tried all the existing scan wiring enum values?

I.e.:

Hub75ScanWiring::SCAN_1_8_32PX_HIGH
Hub75ScanWiring::SCAN_1_8_32PX_FULL

It seems like one of those should work, but if not it would be straight forward to add a new one