RGB Matrix Library

Hi all

I wanted to create a word clock with a RGB LED Matrix. I bought the 32x32 LED RGB Matrix off Adafruit (Product ID: 1484) and it looks awesome.
I 3D printed a front plate with the letters cut out.
my next idea was to combine it with a DCF77 module. but that wasnt reliable enough to use in the final version.
So i settled for a RTC. (Chip DS3231) which communicates with Arduino over I2C.
It doesnt seem to be working. I assume that the two librarys dont work together because they define a same thing in 2 different ways.
This is the whole code (im very sorry, some words are in swiss german, those are only variables to describe the time tho and could be chosen freely):

//-------Librarys Realtime Clock---------
//#include <Wire.h>
//#include "DS3231.h"

//-------Librarys LED Matrix-------------
#include <gamma.h>
#include <RGBmatrixPanel.h>

#include <Adafruit_GFX.h>
#include <Adafruit_SPITFT.h>
#include <Adafruit_SPITFT_Macros.h>
#include <gfxfont.h>


//------Defines for LED Matrix----------
#define CLK  8
#define OE   9
#define LAT 10
#define A   A0
#define B   A1
#define C   A2
#define D   A3

//--------Colour Variables-------------
int red, green, blue;

//--------All Pins for LED Matrix------
RGBmatrixPanel matrix(A, B, C, D, CLK, LAT, OE, false);

//---------Realtime Clock--------------
RTClib RTC;

void setup()
{
  matrix.begin();
  Wire.begin();
 
  red = 0;
  green = 7;
  blue = 0;
}

void loop()
{
  delay(100);

  DateTime now = RTC.now();
  
  //clear Matrix
  matrix.fillScreen(0);
  
  //write the time to the Matrix
  es();
  isch();

  switch(int stund = now.hour())
  {
    case 1:
    {
      eis();
      break;
    }
    case 2:
    {
      zwei();
      break;
    }
    case 3:
    {
      drue();
      break;
    }
    case 4:
    {
      vieri();
      break;
    }
    case 5:
    {
      fuefi();
      break;
    }
    case 6:
    {
      saechsi();
      break;
    }
    case 7:
    {
      sibni();
      break;
    }
    case 8:
    {
      achti();
      break;
    }
    case 9:
    {
      nueni();
      break;
    }
    case 10:
    {
      zaeni();
      break;
    }
    case 11:
    {
      elfi();
      break;
    }
    case 12:
    {
      zwoelfi();
      break;
    }
  }
  
  switch(int minuute = now.minute())
  {
    case 1:
    {
      //progressBalk
      break;
    }
    case 2:
    {
      //progressBalk
      break;
    }
    case 3:
    {
      //progressBalk
      break;
    }
    case 4:
    {
      //progressBalk
      break;
    }
    case 5:
    {
      fuef();
      ab();
      //progressBalk
      break;
    }
    case 6:
    {
      fuef();
      ab();
      //progressBalk
      break;
    }
    case 7:
    {
      fuef();
      ab();
      //progressBalk
      break;
    }
    
//i think you get the point here... ;)
    
    case 55:
    {
      fuef();
      vor();
      //progressBalk
      break;
    }
    case 56:
    {
      fuef();
      vor();
      //progressBalk
      break;
    }
    case 57:
    {
      fuef();
      vor();
      //progressBalk
      break;
    }
    case 58:
    {
      fuef();
      vor();
      //progressBalk
      break;
    }
    case 59:
    {
      fuef();
      vor();
      //progressBalk
      break;
    }
    case 0:
    {
      //progressBalk
      break;
    }
  }
}

void es(void)
{
  matrix.fillRect(5, 1, 4, 3, matrix.Color333(red, green, blue));
}

void isch(void)
{
  matrix.fillRect(11, 1, 8, 3, matrix.Color333(red, green, blue));
}

void fuef(void)
{
  matrix.fillRect(21, 1, 6, 3, matrix.Color333(red, green, blue));
}

void viertl(void)
{
  matrix.fillRect(5, 4, 12, 3, matrix.Color333(red, green, blue));
}

void zaeae(void)
{
  matrix.fillRect(21, 4, 6, 3, matrix.Color333(red, green, blue));
}

void zwaenzg(void)
{
  matrix.fillRect(5, 7, 12, 3, matrix.Color333(red, green, blue));
}

void vor(void)
{
  matrix.fillRect(21, 7, 6, 3, matrix.Color333(red, green, blue));
}

void ab(void)
{
  matrix.fillRect(5, 10, 4, 3, matrix.Color333(red, green, blue));
}

void halbi(void)
{
  matrix.fillRect(11, 10, 10, 3, matrix.Color333(red, green, blue));
}

void eis(void)
{
  matrix.fillRect(5, 13, 6, 3, matrix.Color333(red, green, blue));
}

void zwei(void)
{
  matrix.fillRect(11, 13, 8, 3, matrix.Color333(red, green, blue));
}

void drue(void)
{
  matrix.fillRect(21, 13, 6, 3, matrix.Color333(red, green, blue));
}

void vieri(void)
{
  matrix.fillRect(5, 16, 10, 3, matrix.Color333(red, green, blue));
}

void fuefi(void)
{
  matrix.fillRect(15, 16, 8, 3, matrix.Color333(red, green, blue));
}

void saechsi(void)
{
  matrix.fillRect(5, 19, 12, 3, matrix.Color333(red, green, blue));
}

void sibni(void)
{
  matrix.fillRect(18, 19, 10, 3, matrix.Color333(red, green, blue));
}

void achti(void)
{
  matrix.fillRect(5, 22, 10, 3, matrix.Color333(red, green, blue));
}

void nueni(void)
{
  matrix.fillRect(15, 22, 8, 3, matrix.Color333(red, green, blue));
}

void zaeni(void)
{
  matrix.fillRect(5, 25, 8, 3, matrix.Color333(red, green, blue));
}

void elfi(void)
{
  matrix.fillRect(18, 25, 8, 3, matrix.Color333(red, green, blue));
}

void zwoelfi(void)
{
  matrix.fillRect(5, 28, 12, 3, matrix.Color333(red, green, blue));
}

It would be awesome if i could get a tipp about whats the problem.
Im quite stuck at the moment.

Every help is deeply apprechiated!
Greetings from switzerland and thanks in advance!

Cheers Fabian :):slight_smile:

It doesnt seem to be working.

Either it works properly, or it doesn't. It should be quite clear whether it works, or it doesn't.

The code you posted does something, which you didn't disclose.
You expect it to do something, which you didn't disclose.

Without your hardware or your observations, we can't help you.

Providing your observations will be easier, and cheaper, that shipping each of us the hardware so we can see what is actually happening.

I am useing an Arduino Uno with an Adafruit RGB Matrix Shield (Adafruit RGB Matrix Shield for Arduino : ID 2601 : $5.95 : Adafruit Industries, Unique & fun DIY electronics and kits) and the 32x32 RGB Shield (32x32 RGB LED Matrix Panel - 6mm pitch : ID 1484 : $39.95 : Adafruit Industries, Unique & fun DIY electronics and kits) from Adafruit aswell.

The RTC i use has SDA and SCL Connections and a DS3231 chip on it.

My observations:

  1. if i uncomment everything that has to do the RTC module, especially the Wire library. The RGB Matrix displays the rectangles i define in the lower part of the code. (in the switch case statements i use fix values) i cant take a picture right now, because a friend borrowed my Arduino Board, but if it helps i can post pictures later.
  2. if i include the Wire.h library into the code modified as described in point 1. all the RGB Matrix buggs out and lights up some random lines. (again i can post pictures later if it would help.)
  3. if i take the same approach described in point 1. but uncommenting all lines that have to do with the RGB Matrix and just post the time of the RTC module on the Serial Display every 200ms, it prints the correct time untill i uncomment matrix.fillScreen(0);

I hope this shows my problem better

I suspect it has something to do with pin 10 being used by both the wire.h & the ledmatrix..

Wire doesn't use pin 10. It only uses A4 and A5 on the Uno. SPI does use pin 10. I see that Faziban has added #include directives for the Adafruit SPITFT library. This is odd since the library is not used in the code and they make no mention of a TFT display in the description of their project. Without looking at the code, I don't know whether that library would cause the described issue. However, if it's not being used, I would certainly recommend removing those #include directives regardless.

Hi Pert
Doesnt wire use SDA and SCL pins on the Arduino Board? (the 2 pins closest to the reset button) Because i have connected the RTC Module to those pins and it seems to be working fine.

pert:
I see that Faziban has added #include directives for the Adafruit SPITFT library.

I have tried it with removing all Librarys except "RGBMatrixPanel.h" and it doesnt solve the problem.

@Deva_Rishi
But i also expect that the wire and the RGBMatrixPanel Library both define/use a same pin/port/...
I have also tried to strip the RGBMatrixPanel library to the least i need. Because it is written to support multiple boards and processors, which i dont need. That didnt help either.

Thanks very much for the help and suggestions!
Ill keep trying and keep you up to date.

Cheers Fabian

Faziban:
Hi Pert
Doesnt wire use SDA and SCL pins on the Arduino Board? (the 2 pins closest to the reset button) Because i have connected the RTC Module to those pins and it seems to be working fine.

That's correct. On your Uno, those are also pins A4 and A5.

Okay. Thanks :slight_smile:
i have just checked what ports are used for the RGB Matrix.

 // Ports for "standard" boards (Arduino Uno, Duemilanove, etc.)
 #define DATAPORT PORTD
 #define DATADIR  DDRD
 #define CLKPORT  PORTB

But that shouldnt affect the RTC Module, right?
Because the RTC Module only needs 4 onnections:

  • GND
  • 5V
  • SDA
  • SCL

And those arent binded to a port, right?

Btw. its this Library: RGB-matrix-Panel/colorwheel_32x32.ino at master · adafruit/RGB-matrix-Panel · GitHub

And those arent binded to a port, right?

Sure they are.

But luckily SDA/SCL or Arduino A4/A5 on an Uno, are bound to atmega328 - PORTC (bits PC4 / PC5)

Check an atmega328P Pinout

@michael_x

Oh okay, so that cant be the problem either. Thanks very much!
any suggestions on what to try? include the Wire.h
Library into the RGBMatrixPanel.h
Library?

Cheers Fabian

  1. if i include the Wire.h library into the code modified as described in point 1. all the RGB Matrix buggs out and lights up some random lines. (again i can post pictures later if it would help.)

you modified the wire.h ? because ? anyway, if you modify a library, the best practice is to rename the files (and classes) and modify that, and then refer to those newly named classes or any other code that uses the same library may malfunction. I am not really sure if you actually meant "modified wire.h" ?

Deva_Rishi:
you modified the wire.h

That wasnt said of me very clearly in that part, sorry. i meant, when i included the <Wire.h> library to the modified code. And i wanted to refer to the code modification of my 1. point.
Sorry for not stating that clear enough

So where did you get the RGBmatrixPanel.h, ? it appears that the Arduino does have to have quite a lot of CPU power dedicated to these shields (and is possibly turning off interrupts) which might compremise the functionality of the I2C.
I suppose btw that you were also commenting out Wire.begin();

It is stated with the Library, that the CPU is used to 40% by the Library.
And i dont really think i can change anything about the CPU useage of the Library.

(and is possibly turning off interrupts)

That sounds more and more possible to me.

Yes i was also commenting out Wire.begin();
I took an Arduino program that was purely dedicated to the RGB Matrix and added the line #include <Wire.h> at the beginning of the Code. That was enough to stop the Display from functionalling properly and not lighting up the rectangles i programmed, but some lines of the Matrix.

how about you post the code of the library (RGbmatrix.h) within code tags of course and we can have a look together. Although it seems quite clear that you will probably will need a different solution for your time keeping. (this may be an extra arduino core to take care of it)

Thanks very much!

In the .h File i coul probably delete some more code that is processor spesific and that i dont need, because i use an Arduino Uno. But i just deleted the few lines where i was 120% i dont need them.
This is the RGBmatrixPanel.h File:

#ifndef RGBMATRIXPANEL_H
#define RGBMATRIXPANEL_H

#if ARDUINO >= 100
 #include "Arduino.h"
#else
 #include "WProgram.h"
 #include "pins_arduino.h"
#endif
#include "Adafruit_GFX.h"

#if defined(__AVR__)
  typedef uint8_t  PortType;
#elif defined(__arm__) || defined(__xtensa__)
  typedef uint32_t PortType; // Formerly 'RwReg' but interfered w/CMCIS header
#endif

class RGBmatrixPanel : public Adafruit_GFX {

 public:

  // Constructor for 32x32 panel (adds 'd' pin):
  RGBmatrixPanel(uint8_t a, uint8_t b, uint8_t c, uint8_t d,
    uint8_t clk, uint8_t lat, uint8_t oe, boolean dbuf, uint8_t width=32
#if defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_ARCH_ESP32)
    ,uint8_t *pinlist=NULL
#endif
    );

  void
    begin(void),
    drawPixel(int16_t x, int16_t y, uint16_t c),
    fillScreen(uint16_t c),
    updateDisplay(void),
    swapBuffers(boolean),
    dumpMatrix(void);
  uint8_t
    *backBuffer(void);
  uint16_t
    Color333(uint8_t r, uint8_t g, uint8_t b),
    Color444(uint8_t r, uint8_t g, uint8_t b),
    Color888(uint8_t r, uint8_t g, uint8_t b),
    Color888(uint8_t r, uint8_t g, uint8_t b, boolean gflag),
    ColorHSV(long hue, uint8_t sat, uint8_t val, boolean gflag);

 private:

  uint8_t         *matrixbuff[2];
  uint8_t          nRows;
  volatile uint8_t backindex;
  volatile boolean swapflag;

  // Init/alloc code common to both constructors:
  void init(uint8_t rows, uint8_t a, uint8_t b, uint8_t c,
    uint8_t clk, uint8_t lat, uint8_t oe, boolean dbuf, 
    uint8_t width
#if defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_ARCH_ESP32)
            ,uint8_t *rgbpins
#endif
  );

  uint8_t  _clk, _lat, _oe, _a, _b, _c, _d; // Pin numbers
  PortType clkmask, latmask, oemask,        // Pin bitmasks
           addramask, addrbmask, addrcmask, addrdmask;
  // PORT register pointers (CLKPORT is hardcoded on AVR)
  volatile PortType *latport, *oeport,
                    *addraport, *addrbport, *addrcport, *addrdport;

#if defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_ARCH_ESP32)
  uint8_t  rgbpins[6];                      // Pin numbers for 2x R,G,B bits
  volatile PortType *outsetreg, *outclrreg; // PORT bit set, clear registers
  PortType           rgbclkmask;            // Mask of all RGB bits + CLK
  PortType           expand[256];           // 6-to-32 bit converter table
#endif

  // Counters/pointers for interrupt handler:
  volatile uint8_t row, plane;
  volatile uint8_t *buffptr;
};

#endif // RGBMATRIXPANEL_H

I will post the ".cpp" File in a new reply.

first part of "RGBmatrixPanel.cpp"

/*
RGBmatrixPanel Arduino library for Adafruit 16x32 and 32x32 RGB LED
matrix panels.  Pick one up at:
  http://www.adafruit.com/products/420
  http://www.adafruit.com/products/607

This version uses a few tricks to achieve better performance and/or
lower CPU utilization:

- To control LED brightness, traditional PWM is eschewed in favor of
  Binary Code Modulation, which operates through a succession of periods
  each twice the length of the preceeding one (rather than a direct
  linear count a la PWM).  It's explained well here:

    http://www.batsocks.co.uk/readme/art_bcm_1.htm

  I was initially skeptical, but it works exceedingly well in practice!
  And this uses considerably fewer CPU cycles than software PWM.

- Although many control pins are software-configurable in the user's
  code, a couple things are tied to specific PORT registers.  It's just
  a lot faster this way -- port lookups take time.  Please see the notes
  later regarding wiring on "alternative" Arduino boards.

- A tiny bit of inline assembly language is used in the most speed-
  critical section.  The C++ compiler wasn't making optimal use of the
  instruction set in what seemed like an obvious chunk of code.  Since
  it's only a few short instructions, this loop is also "unrolled" --
  each iteration is stated explicitly, not through a control loop.

Written by Limor Fried/Ladyada & Phil Burgess/PaintYourDragon for
Adafruit Industries.
BSD license, all text above must be included in any redistribution.
*/

#include "RGBmatrixPanel.h"
#include "gamma.h"

#ifdef ARDUINO_ARCH_ESP32
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "driver/timer.h"
#endif

#ifndef _swap_int16_t
#define _swap_int16_t(a, b) { int16_t t = a; a = b; b = t; }
#endif

// A full PORT register is required for the data lines, though only the
// top 6 output bits are used.  For performance reasons, the port # cannot
// be changed via library calls, only by changing constants in the library.
// For similar reasons, the clock pin is only semi-configurable...it can
// be specified as any pin within a specific PORT register stated below.

#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
 // Arduino Mega is now tested and confirmed, with the following caveats:
 // Because digital pins 2-7 don't map to a contiguous port register,
 // the Mega requires connecting the matrix data lines to different pins.
 // Digital pins 24-29 are used for the data interface, and 22 & 23 are
 // unavailable for other outputs because the software needs to write to
 // the full PORTA register for speed.  Clock may be any pin on PORTB --
 // on the Mega, this CAN'T be pins 8 or 9 (these are on PORTH), thus the
 // wiring will need to be slightly different than the tutorial's
 // explanation on the Uno, etc.  Pins 10-13 are all fair game for the
 // clock, as are pins 50-53.
 #define DATAPORT PORTA
 #define DATADIR  DDRA
 #define CLKPORT  PORTB
#elif defined(__AVR_ATmega32U4__)
 // Arduino Leonardo: this is vestigial code an unlikely to ever be
 // finished -- DO NOT USE!!!  Unlike the Uno, digital pins 2-7 do NOT
 // map to a contiguous port register, dashing our hopes for compatible
 // wiring.  Making this work would require significant changes both to
 // the bit-shifting code in the library, and how this board is wired to
 // the LED matrix.  Bummer.
 #define DATAPORT PORTD
 #define DATADIR  DDRD
 #define CLKPORT  PORTB
#elif defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_ARCH_ESP32)
  // Support for ATSAMD21-based boards, done with PortType!
#else
 // Ports for "standard" boards (Arduino Uno, Duemilanove, etc.)
 #define DATAPORT PORTD
 #define DATADIR  DDRD
 #define CLKPORT  PORTB
#endif

#define nPlanes 4

// The fact that the display driver interrupt stuff is tied to the
// singular Timer1 doesn't really take well to object orientation with
// multiple RGBmatrixPanel instances.  The solution at present is to
// allow instances, but only one is active at any given time, via its
// begin() method.  The implementation is still incomplete in parts;
// the prior active panel really should be gracefully disabled, and a
// stop() method should perhaps be added...assuming multiple instances
// are even an actual need.
static RGBmatrixPanel *activePanel = NULL;

// Code common to both the 16x32 and 32x32 constructors:
void RGBmatrixPanel::init(uint8_t rows, uint8_t a, uint8_t b, uint8_t c,
  uint8_t clk, uint8_t lat, uint8_t oe, boolean dbuf, uint8_t width
#if defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_ARCH_ESP32)
  ,uint8_t *pinlist
#endif
  ) {
#if defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_ARCH_ESP32)
  // R1, G1, B1, R2, G2, B2 pins
  static const uint8_t defaultrgbpins[] = { 2,3,4,5,6,7 };
  memcpy(rgbpins, pinlist ? pinlist : defaultrgbpins, sizeof rgbpins);
#if defined(ARDUINO_ARCH_SAMD)
  // All six RGB pins MUST be on the same PORT # as CLK
  int clkportnum = g_APinDescription[clk].ulPort;
  for(uint8_t i=0; i<6; i++) {
    if(g_APinDescription[rgbpins[i]].ulPort != clkportnum) return;
  }
#endif
#endif

  nRows = rows; // Number of multiplexed rows; actual height is 2X this

  // Allocate and initialize matrix buffer:
  int buffsize  = width * nRows * 3, // x3 = 3 bytes holds 4 planes "packed"
      allocsize = (dbuf == true) ? (buffsize * 2) : buffsize;
  if(NULL == (matrixbuff[0] = (uint8_t *)malloc(allocsize))) return;
  memset(matrixbuff[0], 0, allocsize);
  // If not double-buffered, both buffers then point to the same address:
  matrixbuff[1] = (dbuf == true) ? &matrixbuff[0][buffsize] : matrixbuff[0];

  // Save pin numbers for use by begin() method later.
  _a   = a;
  _b   = b;
  _c   = c;
  _clk = clk;
  _lat = lat;
  _oe  = oe;

  // Look up port registers and pin masks ahead of time,
  // avoids many slow digitalWrite() calls later.
  clkmask   = digitalPinToBitMask(clk);
  latport   = portOutputRegister(digitalPinToPort(lat));
  latmask   = digitalPinToBitMask(lat);
  oeport    = portOutputRegister(digitalPinToPort(oe));
  oemask    = digitalPinToBitMask(oe);
  addraport = portOutputRegister(digitalPinToPort(a));
  addramask = digitalPinToBitMask(a);
  addrbport = portOutputRegister(digitalPinToPort(b));
  addrbmask = digitalPinToBitMask(b);
  addrcport = portOutputRegister(digitalPinToPort(c));
  addrcmask = digitalPinToBitMask(c); 
  plane     = nPlanes - 1;
  row       = nRows   - 1;
  swapflag  = false;
  backindex = 0;     // Array index of back buffer
}

the second part of "RGBmatrixPanel.h":

// Constructor for 32x32 or 32x64 panel:
RGBmatrixPanel::RGBmatrixPanel(
  uint8_t a, uint8_t b, uint8_t c, uint8_t d,
  uint8_t clk, uint8_t lat, uint8_t oe, boolean dbuf, uint8_t width
#if defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_ARCH_ESP32)
    ,uint8_t *pinlist
#endif
  ) : Adafruit_GFX(width, 32) {

  init(16, a, b, c, clk, lat, oe, dbuf, width
#if defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_ARCH_ESP32)
    ,pinlist
#endif
  );

  // Init a few extra 32x32-specific elements:
  _d        = d;
  addrdport = portOutputRegister(digitalPinToPort(d));
  addrdmask = digitalPinToBitMask(d);
}

#if defined(ARDUINO_ARCH_SAMD)
#define TIMER         TC4
#define IRQN          TC4_IRQn
#define IRQ_HANDLER   TC4_Handler
#define TIMER_GCLK_ID TC4_GCLK_ID
#elif defined(ARDUINO_ARCH_ESP32)
IRAM_ATTR void IRQ_HANDLER(void *);
#endif

void RGBmatrixPanel::begin(void) {

  backindex   = 0;                         // Back buffer
  buffptr     = matrixbuff[1 - backindex]; // -> front buffer
  activePanel = this;                      // For interrupt hander

  // Enable all comm & address pins as outputs, set default states:
  pinMode(_clk, OUTPUT); digitalWrite(_clk, LOW);  // Low
  pinMode(_lat, OUTPUT); *latport   &= ~latmask;   // Low
  pinMode(_oe , OUTPUT); *oeport    |= oemask;     // High (disable output)
  pinMode(_a  , OUTPUT); *addraport &= ~addramask; // Low
  pinMode(_b  , OUTPUT); *addrbport &= ~addrbmask; // Low
  pinMode(_c  , OUTPUT); *addrcport &= ~addrcmask; // Low
  if(nRows > 8) {
    pinMode(_d, OUTPUT); *addrdport &= ~addrdmask; // Low
  }

#if defined(__AVR__)

  // The high six bits of the data port are set as outputs;
  // Might make this configurable in the future, but not yet.
  DATADIR  = B11111100;
  DATAPORT = 0;

#elif defined(ARDUINO_ARCH_SAMD)

  // Semi-configurable RGB bits; must be on same PORT as CLK
  int clkportnum = g_APinDescription[_clk].ulPort;
#ifdef __SAMD51__ // No IOBUS on SAMD51
  outsetreg = &(PORT->Group[clkportnum].OUTSET.reg);
  outclrreg = &(PORT->Group[clkportnum].OUTCLR.reg);
#else
  outsetreg = &(PORT_IOBUS->Group[clkportnum].OUTSET.reg);
  outclrreg = &(PORT_IOBUS->Group[clkportnum].OUTCLR.reg);
#endif

  PortType rgbmask[6];
  clkmask = rgbclkmask = digitalPinToBitMask(_clk);
  for(uint8_t i=0; i<6; i++) {
    pinMode(rgbpins[i], OUTPUT);
    rgbmask[i]  = digitalPinToBitMask(rgbpins[i]); // Pin bit mask
    rgbclkmask |= rgbmask[i];                      // Add to RGB+CLK bit mask
  }
  for(int i=0; i<256; i++) {
    expand[i] = 0;
    if(i & 0x04) expand[i] |= rgbmask[0];
    if(i & 0x08) expand[i] |= rgbmask[1];
    if(i & 0x10) expand[i] |= rgbmask[2];
    if(i & 0x20) expand[i] |= rgbmask[3];
    if(i & 0x40) expand[i] |= rgbmask[4];
    if(i & 0x80) expand[i] |= rgbmask[5];
  }
#elif defined(ARDUINO_ARCH_ESP32)
  // Semi-configurable RGB bits; must be on same PORT as CLK
  if (_clk < 32) {
	  outsetreg = &GPIO.out_w1ts;
	  outclrreg = &GPIO.out_w1tc;
  } else {
	  outsetreg =  (volatile PortType*) &(GPIO.out1_w1ts);
	  outclrreg =  (volatile PortType*) &(GPIO.out1_w1tc);
  }

    PortType rgbmask[6];
    clkmask = rgbclkmask = digitalPinToBitMask(_clk);
    for(uint8_t i=0; i<6; i++) {
      pinMode(rgbpins[i], OUTPUT);
      rgbmask[i]  = digitalPinToBitMask(rgbpins[i]); // Pin bit mask
      rgbclkmask |= rgbmask[i];                      // Add to RGB+CLK bit mask
    }
    for(int i=0; i<256; i++) {
      expand[i] = 0;
      if(i & 0x04) expand[i] |= rgbmask[0];
      if(i & 0x08) expand[i] |= rgbmask[1];
      if(i & 0x10) expand[i] |= rgbmask[2];
      if(i & 0x20) expand[i] |= rgbmask[3];
      if(i & 0x40) expand[i] |= rgbmask[4];
      if(i & 0x80) expand[i] |= rgbmask[5];
    }
#endif

#if defined(ARDUINO_ARCH_ESP32)
    timer_config_t tim_config;
    tim_config.divider = 2; // Run Timer at 40 MHz
    tim_config.counter_dir = TIMER_COUNT_UP;
    tim_config.counter_en = TIMER_PAUSE;
    tim_config.alarm_en = true;
    tim_config.auto_reload = true;
    tim_config.intr_type = TIMER_INTR_LEVEL;

    timer_init(TIMER_GROUP_1, TIMER_0, &tim_config);
    /* Timer's counter will initially start from value below.
    	 Also, if auto_reload is set, this value will be automatically reload on alarm */
    timer_set_counter_value(TIMER_GROUP_1, TIMER_0, 0x00000000ULL);
    /* Configure the alarm value and the interrupt on alarm. */
    timer_set_alarm_value(TIMER_GROUP_1, TIMER_0, 10000);
    timer_enable_intr(TIMER_GROUP_1, TIMER_0);
    timer_isr_register(TIMER_GROUP_1, TIMER_0, IRQ_HANDLER,
    		(void *) TIMER_0, ESP_INTR_FLAG_IRAM, NULL);

    timer_start(TIMER_GROUP_1, TIMER_0);
#endif

#if defined(__AVR__)
  // Set up Timer1 for interrupt:
  TCCR1A  = _BV(WGM11); // Mode 14 (fast PWM), OC1A off
  TCCR1B  = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // Mode 14, no prescale
  ICR1    = 100;
  TIMSK1 |= _BV(TOIE1); // Enable Timer1 interrupt
  sei();                // Enable global interrupts
#endif

#if defined(ARDUINO_ARCH_SAMD)
#ifdef __SAMD51__
  // Set up generic clock gen 2 as source for TC4
  // Datasheet recommends setting GENCTRL register in a single write,
  // so a temp value is used here to more easily construct a value.
  GCLK_GENCTRL_Type genctrl;
  genctrl.bit.SRC      = GCLK_GENCTRL_SRC_DFLL_Val; // 48 MHz source
  genctrl.bit.GENEN    = 1; // Enable
  genctrl.bit.OE       = 1;
  genctrl.bit.DIVSEL   = 0; // Do not divide clock source
  genctrl.bit.DIV      = 0;
  GCLK->GENCTRL[2].reg = genctrl.reg;
  while(GCLK->SYNCBUSY.bit.GENCTRL1 == 1);

  GCLK->PCHCTRL[TIMER_GCLK_ID].bit.CHEN = 0;
  while(GCLK->PCHCTRL[TIMER_GCLK_ID].bit.CHEN); // Wait for disable
  GCLK_PCHCTRL_Type pchctrl;
  pchctrl.bit.GEN                  = GCLK_PCHCTRL_GEN_GCLK2_Val;
  pchctrl.bit.CHEN                 = 1;
  GCLK->PCHCTRL[TIMER_GCLK_ID].reg = pchctrl.reg;
  while(!GCLK->PCHCTRL[TIMER_GCLK_ID].bit.CHEN); // Wait for enable

  // Counter must first be disabled to configure it
  TIMER->COUNT16.CTRLA.reg &= ~TC_CTRLA_ENABLE;
  while(TIMER->COUNT16.SYNCBUSY.bit.STATUS);

  TIMER->COUNT16.CTRLA.reg =  // Configure timer counter
    TC_CTRLA_PRESCALER_DIV1 | // 1:1 Prescale
    TC_CTRLA_MODE_COUNT16;    // 16-bit counter mode

  TIMER->COUNT16.WAVE.bit.WAVEGEN = 1; // Match frequency mode (MFRQ)

  TIMER->COUNT16.CTRLBSET.reg = TCC_CTRLBCLR_DIR; // Count DOWN
  while(TIMER->COUNT16.SYNCBUSY.bit.CTRLB);

  TIMER->COUNT16.CC[0].reg = 10000; // Compare value for channel 0
  while(TIMER->COUNT16.SYNCBUSY.bit.CC0);

  TIMER->COUNT16.INTENSET.reg = TC_INTENSET_OVF; // Enable overflow interrupt

  NVIC_DisableIRQ(IRQN);
  NVIC_ClearPendingIRQ(IRQN);
  NVIC_SetPriority(IRQN, 0); // Top priority
  NVIC_EnableIRQ(IRQN);

  // Enable TCx
  TIMER->COUNT16.CTRLA.reg |= TC_CTRLA_ENABLE;
  while(TIMER->COUNT16.SYNCBUSY.bit.STATUS);
#else
  // Enable GCLK for TC4 and COUNTER (timer counter input clock)
  GCLK->CLKCTRL.reg = (uint16_t)(GCLK_CLKCTRL_CLKEN |
    GCLK_CLKCTRL_GEN_GCLK0 | GCLK_CLKCTRL_ID(GCM_TC4_TC5));
  while(GCLK->STATUS.bit.SYNCBUSY == 1);

  // Counter must first be disabled to configure it
  TIMER->COUNT16.CTRLA.reg &= ~TC_CTRLA_ENABLE;
  while(TIMER->COUNT16.STATUS.bit.SYNCBUSY);

  TIMER->COUNT16.CTRLA.reg =  // Configure timer counter
    TC_CTRLA_PRESCALER_DIV1 | // 1:1 Prescale
    TC_CTRLA_WAVEGEN_MFRQ   | // Match frequency generation mode (MFRQ)
    TC_CTRLA_MODE_COUNT16;    // 16-bit counter mode
  while(TIMER->COUNT16.STATUS.bit.SYNCBUSY);

//  TIMER->COUNT16.CTRLBCLR.reg = TCC_CTRLBCLR_DIR; // Count up
  TIMER->COUNT16.CTRLBSET.reg = TCC_CTRLBCLR_DIR; // Count DOWN
  while(TIMER->COUNT16.STATUS.bit.SYNCBUSY);

  TIMER->COUNT16.CC[0].reg = 10000; // Compare value for channel 0
  while(TIMER->COUNT16.STATUS.bit.SYNCBUSY);

  TIMER->COUNT16.INTENSET.reg = TC_INTENSET_OVF; // Enable overflow interrupt

  NVIC_DisableIRQ(IRQN);
  NVIC_ClearPendingIRQ(IRQN);
  NVIC_SetPriority(IRQN, 0); // Top priority
  NVIC_EnableIRQ(IRQN);

  // Enable TCx
  TIMER->COUNT16.CTRLA.reg |= TC_CTRLA_ENABLE;
  while(TIMER->COUNT16.STATUS.bit.SYNCBUSY);
#endif // SAMD21
#endif // ARDUINO_ARCH_SAMD
}

the thirt part:

// Original RGBmatrixPanel library used 3/3/3 color.  Later version used
// 4/4/4.  Then Adafruit_GFX (core library used across all Adafruit
// display devices now) standardized on 5/6/5.  The matrix still operates
// internally on 4/4/4 color, but all the graphics functions are written
// to expect 5/6/5...the matrix lib will truncate the color components as
// needed when drawing.  These next functions are mostly here for the
// benefit of older code using one of the original color formats.

// Promote 3/3/3 RGB to Adafruit_GFX 5/6/5
uint16_t RGBmatrixPanel::Color333(uint8_t r, uint8_t g, uint8_t b) {
  // RRRrrGGGgggBBBbb
  return ((r & 0x7) << 13) | ((r & 0x6) << 10) |
         ((g & 0x7) <<  8) | ((g & 0x7) <<  5) |
         ((b & 0x7) <<  2) | ((b & 0x6) >>  1);
}

// Promote 4/4/4 RGB to Adafruit_GFX 5/6/5
uint16_t RGBmatrixPanel::Color444(uint8_t r, uint8_t g, uint8_t b) {
  // RRRRrGGGGggBBBBb
  return ((r & 0xF) << 12) | ((r & 0x8) << 8) |
         ((g & 0xF) <<  7) | ((g & 0xC) << 3) |
         ((b & 0xF) <<  1) | ((b & 0x8) >> 3);
}

// Demote 8/8/8 to Adafruit_GFX 5/6/5
// If no gamma flag passed, assume linear color
uint16_t RGBmatrixPanel::Color888(uint8_t r, uint8_t g, uint8_t b) {
  return ((uint16_t)(r & 0xF8) << 8) | ((uint16_t)(g & 0xFC) << 3) | (b >> 3);
}

// 8/8/8 -> gamma -> 5/6/5
uint16_t RGBmatrixPanel::Color888(
  uint8_t r, uint8_t g, uint8_t b, boolean gflag) {
  if(gflag) { // Gamma-corrected color?
    r = pgm_read_byte(&gamma_table[r]); // Gamma correction table maps
    g = pgm_read_byte(&gamma_table[g]); // 8-bit input to 4-bit output
    b = pgm_read_byte(&gamma_table[b]);
    return ((uint16_t)r << 12) | ((uint16_t)(r & 0x8) << 8) | // 4/4/4->5/6/5
           ((uint16_t)g <<  7) | ((uint16_t)(g & 0xC) << 3) |
           (          b <<  1) | (           b        >> 3);
  } // else linear (uncorrected) color
  return ((uint16_t)(r & 0xF8) << 8) | ((uint16_t)(g & 0xFC) << 3) | (b >> 3);
}

uint16_t RGBmatrixPanel::ColorHSV(
  long hue, uint8_t sat, uint8_t val, boolean gflag) {

  uint8_t  r, g, b, lo;
  uint16_t s1, v1;

  // Hue
  hue %= 1536;             // -1535 to +1535
  if(hue < 0) hue += 1536; //     0 to +1535
  lo = hue & 255;          // Low byte  = primary/secondary color mix
  switch(hue >> 8) {       // High byte = sextant of colorwheel
    case 0 : r = 255     ; g =  lo     ; b =   0     ; break; // R to Y
    case 1 : r = 255 - lo; g = 255     ; b =   0     ; break; // Y to G
    case 2 : r =   0     ; g = 255     ; b =  lo     ; break; // G to C
    case 3 : r =   0     ; g = 255 - lo; b = 255     ; break; // C to B
    case 4 : r =  lo     ; g =   0     ; b = 255     ; break; // B to M
    default: r = 255     ; g =   0     ; b = 255 - lo; break; // M to R
  }

  // Saturation: add 1 so range is 1 to 256, allowig a quick shift operation
  // on the result rather than a costly divide, while the type upgrade to int
  // avoids repeated type conversions in both directions.
  s1 = sat + 1;
  r  = 255 - (((255 - r) * s1) >> 8);
  g  = 255 - (((255 - g) * s1) >> 8);
  b  = 255 - (((255 - b) * s1) >> 8);

  // Value (brightness) & 16-bit color reduction: similar to above, add 1
  // to allow shifts, and upgrade to int makes other conversions implicit.
  v1 = val + 1;
  if(gflag) { // Gamma-corrected color?
    r = pgm_read_byte(&gamma_table[(r * v1) >> 8]); // Gamma correction table maps
    g = pgm_read_byte(&gamma_table[(g * v1) >> 8]); // 8-bit input to 4-bit output
    b = pgm_read_byte(&gamma_table[(b * v1) >> 8]);
  } else { // linear (uncorrected) color
    r = (r * v1) >> 12; // 4-bit results
    g = (g * v1) >> 12;
    b = (b * v1) >> 12;
  }
  return (r << 12) | ((r & 0x8) << 8) | // 4/4/4 -> 5/6/5
         (g <<  7) | ((g & 0xC) << 3) |
         (b <<  1) | ( b        >> 3);
}

the fourth part:

void RGBmatrixPanel::drawPixel(int16_t x, int16_t y, uint16_t c) {
  uint8_t r, g, b, bit, limit, *ptr;

  if((x < 0) || (x >= _width) || (y < 0) || (y >= _height)) return;

  switch(rotation) {
   case 1:
    _swap_int16_t(x, y);
    x = WIDTH  - 1 - x;
    break;
   case 2:
    x = WIDTH  - 1 - x;
    y = HEIGHT - 1 - y;
    break;
   case 3:
    _swap_int16_t(x, y);
    y = HEIGHT - 1 - y;
    break;
  }

  // Adafruit_GFX uses 16-bit color in 5/6/5 format, while matrix needs
  // 4/4/4.  Pluck out relevant bits while separating into R,G,B:
  r =  c >> 12;        // RRRRrggggggbbbbb
  g = (c >>  7) & 0xF; // rrrrrGGGGggbbbbb
  b = (c >>  1) & 0xF; // rrrrrggggggBBBBb

  // Loop counter stuff
  bit   = 2;
  limit = 1 << nPlanes;

  if(y < nRows) {
    // Data for the upper half of the display is stored in the lower
    // bits of each byte.
    ptr = &matrixbuff[backindex][y * WIDTH * (nPlanes - 1) + x]; // Base addr
    // Plane 0 is a tricky case -- its data is spread about,
    // stored in least two bits not used by the other planes.
    ptr[WIDTH*2] &= ~B00000011;           // Plane 0 R,G mask out in one op
    if(r & 1) ptr[WIDTH*2] |=  B00000001; // Plane 0 R: 64 bytes ahead, bit 0
    if(g & 1) ptr[WIDTH*2] |=  B00000010; // Plane 0 G: 64 bytes ahead, bit 1
    if(b & 1) ptr[WIDTH]   |=  B00000001; // Plane 0 B: 32 bytes ahead, bit 0
    else      ptr[WIDTH]   &= ~B00000001; // Plane 0 B unset; mask out
    // The remaining three image planes are more normal-ish.
    // Data is stored in the high 6 bits so it can be quickly
    // copied to the DATAPORT register w/6 output lines.
    for(; bit < limit; bit <<= 1) {
      *ptr &= ~B00011100;            // Mask out R,G,B in one op
      if(r & bit) *ptr |= B00000100; // Plane N R: bit 2
      if(g & bit) *ptr |= B00001000; // Plane N G: bit 3
      if(b & bit) *ptr |= B00010000; // Plane N B: bit 4
      ptr  += WIDTH;                 // Advance to next bit plane
    }
  } else {
    // Data for the lower half of the display is stored in the upper
    // bits, except for the plane 0 stuff, using 2 least bits.
    ptr = &matrixbuff[backindex][(y - nRows) * WIDTH * (nPlanes - 1) + x];
    *ptr &= ~B00000011;                  // Plane 0 G,B mask out in one op
    if(r & 1)  ptr[WIDTH] |=  B00000010; // Plane 0 R: 32 bytes ahead, bit 1
    else       ptr[WIDTH] &= ~B00000010; // Plane 0 R unset; mask out
    if(g & 1) *ptr        |=  B00000001; // Plane 0 G: bit 0
    if(b & 1) *ptr        |=  B00000010; // Plane 0 B: bit 0
    for(; bit < limit; bit <<= 1) {
      *ptr &= ~B11100000;            // Mask out R,G,B in one op
      if(r & bit) *ptr |= B00100000; // Plane N R: bit 5
      if(g & bit) *ptr |= B01000000; // Plane N G: bit 6
      if(b & bit) *ptr |= B10000000; // Plane N B: bit 7
      ptr  += WIDTH;                 // Advance to next bit plane
    }
  }
}

void RGBmatrixPanel::fillScreen(uint16_t c) {
  if((c == 0x0000) || (c == 0xffff)) {
    // For black or white, all bits in frame buffer will be identically
    // set or unset (regardless of weird bit packing), so it's OK to just
    // quickly memset the whole thing:
    memset(matrixbuff[backindex], c, WIDTH * nRows * 3);
  } else {
    // Otherwise, need to handle it the long way:
    Adafruit_GFX::fillScreen(c);
  }
}

// Return address of back buffer -- can then load/store data directly
uint8_t *RGBmatrixPanel::backBuffer() {
  return matrixbuff[backindex];
}

// For smooth animation -- drawing always takes place in the "back" buffer;
// this method pushes it to the "front" for display.  Passing "true", the
// updated display contents are then copied to the new back buffer and can
// be incrementally modified.  If "false", the back buffer then contains
// the old front buffer contents -- your code can either clear this or
// draw over every pixel.  (No effect if double-buffering is not enabled.)
void RGBmatrixPanel::swapBuffers(boolean copy) {
  if(matrixbuff[0] != matrixbuff[1]) {
    // To avoid 'tearing' display, actual swap takes place in the interrupt
    // handler, at the end of a complete screen refresh cycle.
    swapflag = true;                  // Set flag here, then...
    while(swapflag == true) delay(1); // wait for interrupt to clear it
    if(copy == true)
      memcpy(matrixbuff[backindex], matrixbuff[1-backindex], WIDTH * nRows * 3);
  }
}

// Dump display contents to the Serial Monitor, adding some formatting to
// simplify copy-and-paste of data as a PROGMEM-embedded image for another
// sketch.  If using multiple dumps this way, you'll need to edit the
// output to change the 'img' name for each.  Data can then be loaded
// back into the display using a pgm_read_byte() loop.
void RGBmatrixPanel::dumpMatrix(void) {

  int i, buffsize = WIDTH * nRows * 3;

  Serial.print(F("\n\n"
    "#include <avr/pgmspace.h>\n\n"
    "static const uint8_t PROGMEM img[] = {\n  "));

  for(i=0; i<buffsize; i++) {
    Serial.print(F("0x"));
    if(matrixbuff[backindex][i] < 0x10) Serial.write('0');
    Serial.print(matrixbuff[backindex][i],HEX);
    if(i < (buffsize - 1)) {
      if((i & 7) == 7) Serial.print(F(",\n  "));
      else             Serial.write(',');
    }
  }
  Serial.println(F("\n};"));
}