Datasheet

this page is three 10x8 tiles assembled from NeoPixel strip.

Once the matrix is defined, the remainder of the project is similar to Adafruit_NeoPixel. Remember

to use matrix.begin() in the setup() function and matrix.show() to update the display after drawing.

The setBrightness() function is also available. The library includes a couple of example sketches for

reference.

Other Layouts

For any other cases that are not uniformly tiled, you can provide your own function to remap X/Y

coordinates to NeoPixel strip indices. This function should accept two unsigned 16-bit arguments

(pixel X, Y coordinates) and return an unsigned 16-bit value (corresponding strip index). The

simplest row-major progressive function might resemble this:

That’s a crude example. Yours might be designed for pixels arranged in a spiral (easy wiring), or a

Hilbert curve.

The function is then enabled using setRemapFunction():

RAM Again

On a per-pixel basis, Adafruit_NeoMatrix is no more memory-hungry than Adafruit_NeoPixel,

requiring 3 bytes of RAM per pixel. But the number of pixels in a two-dimensional display takes off

exponentially…a 16x16 display requires four times the memory of an 8x8 display, or about 768

bytes of RAM (nearly half the available space on an Arduino Uno). It can be anywhere from tricky to

impossible to combine large displays with memory-hungry libraries such as SD or ffft.

Gamma Correction

Because the Adafruit_GFX library was originally designed for LCDs (having limited color fidelity), it

handles colors as 16-bit values (rather than the full 24 bits that NeoPixels are capable of). This is

not the big loss it might seem. A quirk of human vision makes bright colors less discernible than dim

ones. The Adafruit_NeoMatrix library uses gamma correction to select brightness levels that are

visually (though not numerically) equidistant. There are 32 levels for red and blue, 64 levels for

green.

The Color() function performs the necessary conversion; you don’t need to do any math. It accepts

8-bit red, green and blue values, and returns a gamma-corrected 16-bit color that can then be

uint16_t myRemapFn(uint16_t x, uint16_t y) {

return WIDTH * y + x;

}

matrix.setRemapFunction(myRemapFn);