Merge remote-tracking branch 'adafruit/master'

Author: rfugina

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

examples/testshapes_32x64/testshapes_32x64.ino

@@ -0,0 +1,121 @@
+// testshapes demo for RGBmatrixPanel library.
+// Demonstrates the drawing abilities of the RGBmatrixPanel library.
+// For 32x32 RGB LED matrix.
+
+// NOTE THIS CAN ONLY BE USED ON A MEGA! NOT ENOUGH RAM ON UNO!
+
+#include <Adafruit_GFX.h>   // Core graphics library
+#include <RGBmatrixPanel.h> // Hardware-specific library
+
+// If your 32x32 matrix has the SINGLE HEADER input,
+// use this pinout:
+#define CLK 12  // MUST be on PORTB!
+#define OE  13
+#define LAT A0
+
+#define A   10
+#define B   A2
+#define C   11
+#define D   A1
+
+RGBmatrixPanel matrix(A, B, C, D, CLK, LAT, OE, false, 64);
+
+void setup() {
+
+  matrix.begin();
+  
+  // draw a pixel in solid white
+  matrix.drawPixel(0, 0, matrix.Color333(7, 7, 7)); 
+  delay(500);
+
+  // fix the screen with green
+  matrix.fillRect(0, 0, matrix.width(), matrix.height(), matrix.Color333(0, 7, 0));
+  delay(500);
+
+  // draw a box in yellow
+  matrix.drawRect(0, 0, matrix.width(), matrix.height(), matrix.Color333(7, 7, 0));
+  delay(500);
+  
+  // draw an 'X' in red
+  matrix.drawLine(0, 0, matrix.width()-1, matrix.height()-1, matrix.Color333(7, 0, 0));
+  matrix.drawLine(matrix.width()-1, 0, 0, matrix.height()-1, matrix.Color333(7, 0, 0));
+  delay(500);
+  
+  // draw a blue circle
+  matrix.drawCircle(10, 10, 10, matrix.Color333(0, 0, 7));
+  delay(500);
+  
+  // fill a violet circle
+  matrix.fillCircle(40, 21, 10, matrix.Color333(7, 0, 7));
+  delay(500);
+  
+  // fill the screen with 'black'
+  matrix.fillScreen(matrix.Color333(0, 0, 0));
+  
+  // draw some text!
+  matrix.setTextSize(1);     // size 1 == 8 pixels high
+  matrix.setTextWrap(false); // Don't wrap at end of line - will do ourselves
+
+  matrix.setCursor(8, 0);    // start at top left, with 8 pixel of spacing
+  uint8_t w = 0;
+  char *str = "AdafruitIndustries";
+  for (w=0; w<8; w++) {
+    matrix.setTextColor(Wheel(w));
+    matrix.print(str[w]);
+  }
+  matrix.setCursor(2, 8);    // next line
+  for (w=8; w<18; w++) {
+    matrix.setTextColor(Wheel(w));
+    matrix.print(str[w]);
+  }
+  matrix.println();
+  //matrix.setTextColor(matrix.Color333(4,4,4));
+  //matrix.println("Industries");
+  matrix.setTextColor(matrix.Color333(7,7,7));
+  matrix.println("LED MATRIX!");
+  
+  // print each letter with a rainbow color
+  matrix.setTextColor(matrix.Color333(7,0,0));
+  matrix.print('3');
+  matrix.setTextColor(matrix.Color333(7,4,0)); 
+  matrix.print('2');
+  matrix.setTextColor(matrix.Color333(7,7,0));
+  matrix.print('x');
+  matrix.setTextColor(matrix.Color333(4,7,0)); 
+  matrix.print('6');
+  matrix.setTextColor(matrix.Color333(0,7,0));  
+  matrix.print('4');
+  matrix.setCursor(34, 24);  
+  matrix.setTextColor(matrix.Color333(0,7,7)); 
+  matrix.print("*");
+  matrix.setTextColor(matrix.Color333(0,4,7)); 
+  matrix.print('R');
+  matrix.setTextColor(matrix.Color333(0,0,7));
+  matrix.print('G');
+  matrix.setTextColor(matrix.Color333(4,0,7)); 
+  matrix.print("B");
+  matrix.setTextColor(matrix.Color333(7,0,4)); 
+  matrix.println("*");
+
+
+  // whew!
+}
+
+void loop() {
+  // do nothing
+}
+
+
+// Input a value 0 to 24 to get a color value.
+// The colours are a transition r - g - b - back to r.
+uint16_t Wheel(byte WheelPos) {
+  if(WheelPos < 8) {
+   return matrix.Color333(7 - WheelPos, WheelPos, 0);
+  } else if(WheelPos < 16) {
+   WheelPos -= 8;
+   return matrix.Color333(0, 7-WheelPos, WheelPos);
+  } else {
+   WheelPos -= 16;
+   return matrix.Color333(0, WheelPos, 7 - WheelPos);
+  }
+}