add 32x64 support

Author: ladyada

RGBmatrixPanel.cpp

@@ -87,12 +87,12 @@ 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 sclk, uint8_t latch, uint8_t oe, boolean dbuf) {
+  uint8_t sclk, uint8_t latch, uint8_t oe, boolean dbuf, uint8_t width) {
 
   nRows = rows; // Number of multiplexed rows; actual height is 2X this
 
   // Allocate and initialize matrix buffer:
-  int buffsize  = 32 * nRows * 3, // x3 = 3 bytes holds 4 planes "packed"
+  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);
@@ -132,16 +132,16 @@ RGBmatrixPanel::RGBmatrixPanel(
   uint8_t sclk, uint8_t latch, uint8_t oe, boolean dbuf) :
   Adafruit_GFX(32, 16) {
 
-  init(8, a, b, c, sclk, latch, oe, dbuf);
+  init(8, a, b, c, sclk, latch, oe, dbuf, 32);
 }
 
-// Constructor for 32x32 panel:
+// Constructor for 32x32 or 32x64 panel:
 RGBmatrixPanel::RGBmatrixPanel(
   uint8_t a, uint8_t b, uint8_t c, uint8_t d,
-  uint8_t sclk, uint8_t latch, uint8_t oe, boolean dbuf) :
-  Adafruit_GFX(32, 32) {
+  uint8_t sclk, uint8_t latch, uint8_t oe, boolean dbuf, uint8_t width) :
+  Adafruit_GFX(width, 32) {
 
-  init(16, a, b, c, sclk, latch, oe, dbuf);
+  init(16, a, b, c, sclk, latch, oe, dbuf, width);
 
   // Init a few extra 32x32-specific elements:
   _d        = d;
@@ -303,11 +303,11 @@ void RGBmatrixPanel::drawPixel(int16_t x, int16_t y, uint16_t c) {
     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[64] &= ~B00000011;            // Plane 0 R,G mask out in one op
-    if(r & 1) ptr[64] |=  B00000001;  // Plane 0 R: 64 bytes ahead, bit 0
-    if(g & 1) ptr[64] |=  B00000010;  // Plane 0 G: 64 bytes ahead, bit 1
-    if(b & 1) ptr[32] |=  B00000001;  // Plane 0 B: 32 bytes ahead, bit 0
-    else      ptr[32] &= ~B00000001;  // Plane 0 B unset; mask out
+    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.
@@ -323,8 +323,8 @@ void RGBmatrixPanel::drawPixel(int16_t x, int16_t y, uint16_t c) {
     // 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[32] |=  B00000010; // Plane 0 R: 32 bytes ahead, bit 1
-    else       ptr[32] &= ~B00000010; // Plane 0 R unset; mask out
+    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) {
@@ -342,7 +342,7 @@ void RGBmatrixPanel::fillScreen(uint16_t c) {
     // 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, 32 * nRows * 3);
+    memset(matrixbuff[backindex], c, _width * nRows * 3);
   } else {
     // Otherwise, need to handle it the long way:
     Adafruit_GFX::fillScreen(c);
@@ -367,7 +367,7 @@ void RGBmatrixPanel::swapBuffers(boolean copy) {
     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], 32 * nRows * 3);
+      memcpy(matrixbuff[backindex], matrixbuff[1-backindex], _width * nRows * 3);
   }
 }
 
@@ -378,7 +378,7 @@ void RGBmatrixPanel::swapBuffers(boolean copy) {
 // back into the display using a pgm_read_byte() loop.
 void RGBmatrixPanel::dumpMatrix(void) {
 
-  int i, buffsize = 32 * nRows * 3;
+  int i, buffsize = _width * nRows * 3;
 
   Serial.print("\n\n"
     "#include <avr/pgmspace.h>\n\n"
@@ -543,7 +543,14 @@ void RGBmatrixPanel::updateDisplay(void) {
     pew pew pew pew pew pew pew pew
     pew pew pew pew pew pew pew pew
 
-    buffptr += 32;
+      if (_width == 64) {
+    pew pew pew pew pew pew pew pew
+    pew pew pew pew pew pew pew pew
+    pew pew pew pew pew pew pew pew
+    pew pew pew pew pew pew pew pew
+      }
+
+    buffptr = ptr; //+= 32;
 
   } else { // 920 ticks from TCNT1=0 (above) to end of function
 
@@ -556,11 +563,11 @@ void RGBmatrixPanel::updateDisplay(void) {
     // output for plane 0 is handled while plane 3 is being displayed...
     // because binary coded modulation is used (not PWM), that plane
     // has the longest display interval, so the extra work fits.
-    for(i=0; i<32; i++) {
+    for(i=0; i<_width; i++) {
       DATAPORT =
         ( ptr[i]    << 6)         |
-        ((ptr[i+32] << 4) & 0x30) |
-        ((ptr[i+64] << 2) & 0x0C);
+        ((ptr[i+_width] << 4) & 0x30) |
+        ((ptr[i+_width*2] << 2) & 0x0C);
       SCLKPORT = tick; // Clock lo
       SCLKPORT = tock; // Clock hi
     } 

RGBmatrixPanel.h

@@ -16,7 +16,7 @@ class RGBmatrixPanel : public Adafruit_GFX {
 
   // Constructor for 32x32 panel (adds 'd' pin):
   RGBmatrixPanel(uint8_t a, uint8_t b, uint8_t c, uint8_t d,
-    uint8_t sclk, uint8_t latch, uint8_t oe, boolean dbuf);
+    uint8_t sclk, uint8_t latch, uint8_t oe, boolean dbuf, uint8_t width=32);
 
   void
     begin(void),
@@ -43,7 +43,8 @@ class RGBmatrixPanel : public Adafruit_GFX {
 
   // Init/alloc code common to both constructors:
   void init(uint8_t rows, uint8_t a, uint8_t b, uint8_t c,
-    uint8_t sclk, uint8_t latch, uint8_t oe, boolean dbuf);
+	    uint8_t sclk, uint8_t latch, uint8_t oe, boolean dbuf, 
+	    uint8_t width);
 
   // PORT register pointers, pin bitmasks, pin numbers:
   volatile uint8_t