tested and working with microtouchx

fix baddie in due merge, compilable
doesn't work on microtouchx though
2013-09-23 19:48:31 -04:00 · 2013-09-23 14:02:09 -04:00 · 2013-09-23 13:21:56 -04:00 · 2013-09-23 13:21:34 -04:00 · 2013-09-23 13:20:41 -04:00 · 2013-08-20 12:26:03 -04:00
11 changed files with 1065 additions and 72 deletions
--- a/Adafruit_TFTLCD.cpp
+++ b/Adafruit_TFTLCD.cpp
@ -4,8 +4,14 @@
 // Graphics library by ladyada/adafruit with init code from Rossum
 // MIT license

+#if defined(__SAM3X8E__)
+	#include <include/pio.h>
+    #define PROGMEM
+    #define pgm_read_byte(addr) (*(const unsigned char *)(addr))
+    #define pgm_read_word(addr) (*(const unsigned short *)(addr))
+#endif
 #ifdef __AVR__
-#include <avr/pgmspace.h>
+	#include <avr/pgmspace.h>
 #endif
 #include "pins_arduino.h"
 #include "wiring_private.h"
@ -18,6 +24,7 @@
 // LCD controller chip identifiers
 #define ID_932X    0
 #define ID_7575    1
+#define ID_9341    2
 #define ID_UNKNOWN 0xFF

 // Register names from Peter Barrett's Microtouch code
@ -82,19 +89,66 @@
 #define HX8347G_ROWADDREND_LO      0x09
 #define HX8347G_MEMACCESS          0x16

+#define ILI9341_SOFTRESET          0x01
+#define ILI9341_SLEEPIN            0x10
+#define ILI9341_SLEEPOUT           0x11
+#define ILI9341_NORMALDISP         0x13
+#define ILI9341_INVERTOFF          0x20
+#define ILI9341_INVERTON           0x21
+#define ILI9341_GAMMASET           0x26
+#define ILI9341_DISPLAYOFF         0x28
+#define ILI9341_DISPLAYON          0x29
+#define ILI9341_COLADDRSET         0x2A
+#define ILI9341_PAGEADDRSET        0x2B
+#define ILI9341_MEMORYWRITE        0x2C
+#define ILI9341_PIXELFORMAT        0x3A
+#define ILI9341_FRAMECONTROL       0xB1
+#define ILI9341_DISPLAYFUNC        0xB6
+#define ILI9341_ENTRYMODE          0xB7
+#define ILI9341_POWERCONTROL1      0xC0
+#define ILI9341_POWERCONTROL2      0xC1
+#define ILI9341_VCOMCONTROL1       0xC5
+#define ILI9341_VCOMCONTROL2       0xC7
+#define ILI9341_MEMCONTROL         0x36
+
 // Constructor for breakout board (configurable LCD control lines).
 // Can still use this w/shield, but parameters are ignored.
 Adafruit_TFTLCD::Adafruit_TFTLCD(
-  uint8_t cs, uint8_t cd, uint8_t wr, uint8_t rd, uint8_t reset) :
+  uint8_t cs, uint8_t cd, uint8_t wr, uint8_t rd, uint8_t rst) :
  Adafruit_GFX(TFTWIDTH, TFTHEIGHT) {
+  setup(cs, cd, wr, rd, rst);
+}

+// Constructor for shield (fixed LCD control lines)
+Adafruit_TFTLCD::Adafruit_TFTLCD(void) : Adafruit_GFX(TFTWIDTH, TFTHEIGHT) {
+  init();
+}
+
+void Adafruit_TFTLCD::setup(uint8_t cs, uint8_t cd, uint8_t wr, uint8_t rd, uint8_t rst)
+{
 #ifndef USE_ADAFRUIT_SHIELD_PINOUT
  // Convert pin numbers to registers and bitmasks
-  _reset     = reset;
-  csPort     = portOutputRegister(digitalPinToPort(cs));
-  cdPort     = portOutputRegister(digitalPinToPort(cd));
-  wrPort     = portOutputRegister(digitalPinToPort(wr));
-  rdPort     = portOutputRegister(digitalPinToPort(rd));
+  _reset     = rst;
+  #ifdef __AVR__
+    #if defined(CORE_ADAX) || defined(VARIANT_MICROTOUCHX)
+      csPort     = (uint8_t*)portRegister(digitalPinToPort(cs));
+      cdPort     = (uint8_t*)portRegister(digitalPinToPort(cd));
+      wrPort     = (uint8_t*)portRegister(digitalPinToPort(wr));
+      rdPort     = (uint8_t*)portRegister(digitalPinToPort(rd));
+    #else
+      csPort     = portOutputRegister(digitalPinToPort(cs));
+      cdPort     = portOutputRegister(digitalPinToPort(cd));
+      wrPort     = portOutputRegister(digitalPinToPort(wr));
+      rdPort     = portOutputRegister(digitalPinToPort(rd));
+    #endif
+  #endif
+  #if defined(__SAM3X8E__)
+    csPort     = digitalPinToPort(cs);
+    cdPort     = digitalPinToPort(cd);
+    wrPort     = digitalPinToPort(wr);
+    rdPort     = digitalPinToPort(rd);
+  #endif
+
  csPinSet   = digitalPinToBitMask(cs);
  cdPinSet   = digitalPinToBitMask(cd);
  wrPinSet   = digitalPinToBitMask(wr);
@ -103,28 +157,28 @@ Adafruit_TFTLCD::Adafruit_TFTLCD(
  cdPinUnset = ~cdPinSet;
  wrPinUnset = ~wrPinSet;
  rdPinUnset = ~rdPinSet;
-  *csPort   |=  csPinSet; // Set all control bits to HIGH (idle)
-  *cdPort   |=  cdPinSet; // Signals are ACTIVE LOW
-  *wrPort   |=  wrPinSet;
-  *rdPort   |=  rdPinSet;
-  pinMode(cs, OUTPUT);    // Enable outputs
-  pinMode(cd, OUTPUT);
-  pinMode(wr, OUTPUT);
-  pinMode(rd, OUTPUT);
-  if(reset) {
-    digitalWrite(reset, HIGH);
-    pinMode(reset, OUTPUT);
-  }
+
+  #ifdef __AVR__
+    pinMode(cs, OUTPUT);
+    pinMode(cd, OUTPUT);
+    pinMode(wr, OUTPUT);
+    pinMode(rd, OUTPUT);
+    digitalWrite(cs, HIGH);
+    digitalWrite(cd, HIGH);
+    digitalWrite(wr, HIGH);
+    digitalWrite(rd, HIGH);
+  #endif
+  #if defined(__SAM3X8E__)
+    csPort->PIO_SODR  |=  csPinSet; // Set all control bits to HIGH (idle)
+    cdPort->PIO_SODR  |=  cdPinSet; // Signals are ACTIVE LOW
+    wrPort->PIO_SODR  |=  wrPinSet;
+    rdPort->PIO_SODR  |=  rdPinSet;
+  #endif
 #endif

  init();
 }

-// Constructor for shield (fixed LCD control lines)
-Adafruit_TFTLCD::Adafruit_TFTLCD(void) : Adafruit_GFX(TFTWIDTH, TFTHEIGHT) {
-  init();
-}
-
 // Initialization common to both shield & breakout configs
 void Adafruit_TFTLCD::init(void) {

@ -260,6 +314,7 @@ static const uint16_t ILI932x_regValues[] PROGMEM = {
 };

 void Adafruit_TFTLCD::begin(uint16_t id) {
+
  uint8_t i = 0;

  reset();
@ -278,6 +333,32 @@ void Adafruit_TFTLCD::begin(uint16_t id) {
    setRotation(rotation);
    setAddrWindow(0, 0, TFTWIDTH-1, TFTHEIGHT-1);

+  } else if (id == 0x9341) {
+
+    uint16_t a, d;
+    driver = ID_9341;
+    CS_ACTIVE;
+    writeRegister8(ILI9341_SOFTRESET, 0);
+    delay(50);
+    writeRegister8(ILI9341_DISPLAYOFF, 0);
+
+    writeRegister8(ILI9341_POWERCONTROL1, 0x23);
+    writeRegister8(ILI9341_POWERCONTROL2, 0x10);
+    writeRegister16(ILI9341_VCOMCONTROL1, 0x2B2B);
+    writeRegister8(ILI9341_VCOMCONTROL2, 0xC0);
+    writeRegister8(ILI9341_MEMCONTROL, 0x48);
+    writeRegister8(ILI9341_PIXELFORMAT, 0x55);
+    writeRegister16(ILI9341_FRAMECONTROL, 0x001B);
+    
+    writeRegister8(ILI9341_ENTRYMODE, 0x07);
+    /* writeRegister32(ILI9341_DISPLAYFUNC, 0x0A822700);*/
+
+    writeRegister8(ILI9341_SLEEPOUT, 0);
+    delay(150);
+    writeRegister8(ILI9341_DISPLAYON, 0);
+    delay(500);
+    setAddrWindow(0, 0, TFTWIDTH-1, TFTHEIGHT-1);
+
  } else if(id == 0x7575) {

    uint8_t a, d;
@ -301,18 +382,23 @@ void Adafruit_TFTLCD::begin(uint16_t id) {
 void Adafruit_TFTLCD::reset(void) {

  CS_IDLE;
+//  CD_DATA;
  WR_IDLE;
  RD_IDLE;

 #ifdef USE_ADAFRUIT_SHIELD_PINOUT
+  pinMode(5, OUTPUT);
  digitalWrite(5, LOW);
-  delay(2);
+  delay(1);
  digitalWrite(5, HIGH);
+  delay(1);
 #else
  if(_reset) {
+    pinMode(_reset, OUTPUT);
    digitalWrite(_reset, LOW);
-    delay(2);
+    delay(1);
    digitalWrite(_reset, HIGH);
+    delay(1);
  }
 #endif

@ -320,8 +406,9 @@ void Adafruit_TFTLCD::reset(void) {
  CS_ACTIVE;
  CD_COMMAND;
  write8(0x00);
-  for(uint8_t i=0; i<3; i++) WR_STROBE; // Three extra 0x00s
+  for(uint8_t i=0; i<7; i++) WR_STROBE; // Three extra 0x00s
  CS_IDLE;
+  delay(100);
 }

 // Sets the LCD address window (and address counter, on 932X).
@ -388,6 +475,18 @@ void Adafruit_TFTLCD::setAddrWindow(int x1, int y1, int x2, int y2) {
    writeRegisterPair(HX8347G_COLADDREND_HI  , HX8347G_COLADDREND_LO  , x2);
    writeRegisterPair(HX8347G_ROWADDREND_HI  , HX8347G_ROWADDREND_LO  , y2);

+  } else if (driver == ID_9341) {
+    uint32_t t;
+
+    t = x1;
+    t <<= 16;
+    t |= x2;
+    writeRegister32(ILI9341_COLADDRSET, t);
+    t = y1;
+    t <<= 16;
+    t |= y2;
+    writeRegister32(ILI9341_PAGEADDRSET, t);
+
  }
  CS_IDLE;
 }
@ -415,8 +514,14 @@ void Adafruit_TFTLCD::flood(uint16_t color, uint32_t len) {

  CS_ACTIVE;
  CD_COMMAND;
-  if(driver == ID_932X) write8(0x00); // High byte of GRAM register...
-  write8(0x22); // Write data to GRAM
+  if (driver == ID_9341) {
+    write8(0x2C);
+  } else if (driver == ID_932X) {
+    write8(0x00); // High byte of GRAM register...
+    write8(0x22); // Write data to GRAM
+  } else {
+    write8(0x22); // Write data to GRAM
+  }

  // Write first pixel normally, decrement counter by 1
  CD_DATA;
@ -556,6 +661,9 @@ void Adafruit_TFTLCD::fillScreen(uint16_t color) {
    writeRegister16(0x0020, x);
    writeRegister16(0x0021, y);

+  } else if (driver == ID_9341) {
+    setAddrWindow(0, 0, _width - 1, _height - 1);
+
  } else if(driver == ID_7575) {

    // For the 7575, there is no settable address pointer, instead the
@ -612,6 +720,13 @@ void Adafruit_TFTLCD::drawPixel(int16_t x, int16_t y, uint16_t color) {
    hi = color >> 8; lo = color;
    CD_COMMAND; write8(0x22); CD_DATA; write8(hi); write8(lo);

+  } else if (driver == ID_9341) {
+    setAddrWindow(x, y, 239, 319);
+    CS_ACTIVE;
+    CD_COMMAND; 
+    write8(0x2C);
+    CD_DATA; 
+    write8(color >> 8); write8(color);
  }
  CS_IDLE;
 }
@ -660,7 +775,7 @@ void Adafruit_TFTLCD::setRotation(uint8_t x) {
    // For 932X, init default full-screen address window:
    setAddrWindow(0, 0, _width - 1, _height - 1); // CS_IDLE happens here

-  } if(driver == ID_7575) {
+  } else if(driver == ID_7575) {

    uint8_t t;
    switch(rotation) {
@ -746,12 +861,31 @@ uint16_t Adafruit_TFTLCD::readPixel(int16_t x, int16_t y) {
    return (((uint16_t)r & B11111000) << 8) |
           (((uint16_t)g & B11111100) << 3) |
           (           b              >> 3);
-  } else return 0;
+  } else if(driver == ID_9341) {
+    uint8_t hi, lo;
+    setReadDir(); // Set up LCD data port(s) for READ operations
+    CD_DATA;
+    read8(hi);
+    read8(lo);
+    setWriteDir(); // Restore LCD data port(s) to WRITE configuration
+    CS_IDLE;
+    return ((uint16_t)hi << 8) | lo;
+  }
+  return 0;
 }

 // Ditto with the read/write port directions, as above.
 uint16_t Adafruit_TFTLCD::readID(void) {

+  #if defined(VARIANT_MICROTOUCHX)
+  uint32_t id;
+
+  id = readReg(0xD3);
+  if (id == 0x9341) {
+    return id;
+  }
+  #endif
+
  uint8_t hi, lo;

  CS_ACTIVE;
@ -768,6 +902,28 @@ uint16_t Adafruit_TFTLCD::readID(void) {
  return (hi << 8) | lo;
 }

+uint32_t Adafruit_TFTLCD::readReg(uint8_t r) {
+  uint32_t id = 0;
+
+  #if defined(VARIANT_MICROTOUCHX)
+  // try reading register #4
+  CS_ACTIVE;
+  CD_COMMAND;
+  write8(r);
+  setReadDir();  // Set up LCD data port(s) for READ operations
+  CD_DATA;
+  uint8_t a, b, c, d;
+  read8(a);
+  read8(b);
+  read8(c);
+  read8(d);
+  CS_IDLE;
+  setWriteDir();  // Restore LCD data port(s) to WRITE configuration
+  id = ((uint32_t)a << 24) | ((uint32_t)b << 16) | ((uint32_t)c << 8) | ((uint32_t)d << 0);
+  #endif
+  return id;
+}
+
 // Pass 8-bit (each) R,G,B, get back 16-bit packed color
 uint16_t Adafruit_TFTLCD::color565(uint8_t r, uint8_t g, uint8_t b) {
  return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
@ -814,6 +970,12 @@ void Adafruit_TFTLCD::writeRegister16(uint16_t a, uint16_t d) {
 }
 #endif

+#ifndef writeRegister32
+void Adafruit_TFTLCD::writeRegister32(uint8_t a, uint32_t d) {
+  writeRegister32inline(a, d);
+}
+#endif
+
 #ifndef writeRegisterPair
 void Adafruit_TFTLCD::writeRegisterPair(uint8_t aH, uint8_t aL, uint16_t d) {
  writeRegisterPairInline(aH, aL, d);
--- a/Adafruit_TFTLCD.h
+++ b/Adafruit_TFTLCD.h
@ -11,11 +11,12 @@
 #else
 #include "WProgram.h"
 #endif
+
 #include <Adafruit_GFX.h>

 // **** IF USING THE LCD BREAKOUT BOARD, COMMENT OUT THIS NEXT LINE. ****
 // **** IF USING THE LCD SHIELD, LEAVE THE LINE ENABLED:             ****
-#define USE_ADAFRUIT_SHIELD_PINOUT
+//#define USE_ADAFRUIT_SHIELD_PINOUT

 class Adafruit_TFTLCD : public Adafruit_GFX {

@ -24,24 +25,27 @@ class Adafruit_TFTLCD : public Adafruit_GFX {
  Adafruit_TFTLCD(uint8_t cs, uint8_t cd, uint8_t wr, uint8_t rd, uint8_t rst);
  Adafruit_TFTLCD(void);

-  void     begin(uint16_t id = 0x9325),
-           drawPixel(int16_t x, int16_t y, uint16_t color),
-           drawFastHLine(int16_t x0, int16_t y0, int16_t w, uint16_t color),
-           drawFastVLine(int16_t x0, int16_t y0, int16_t h, uint16_t color),
-           fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t c),
-           fillScreen(uint16_t color),
-           reset(void),
-           setRegisters8(uint8_t *ptr, uint8_t n),
-           setRegisters16(uint16_t *ptr, uint8_t n),
-           setRotation(uint8_t x),
-           // These methods are public in order for BMP examples to work:
-           setAddrWindow(int x1, int y1, int x2, int y2),
-           pushColors(uint16_t *data, uint8_t len, boolean first);
+  void     setup(uint8_t cs, uint8_t cd, uint8_t wr, uint8_t rd, uint8_t rst);
+  void     begin(uint16_t id = 0x9325);
+  void     drawPixel(int16_t x, int16_t y, uint16_t color);
+  void     drawFastHLine(int16_t x0, int16_t y0, int16_t w, uint16_t color);
+  void     drawFastVLine(int16_t x0, int16_t y0, int16_t h, uint16_t color);
+  void     fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t c);
+  void     fillScreen(uint16_t color);
+  void     reset(void);
+  void     setRegisters8(uint8_t *ptr, uint8_t n);
+  void     setRegisters16(uint16_t *ptr, uint8_t n);
+  void     setRotation(uint8_t x);
+       // These methods are public in order for BMP examples to work:
+  void     setAddrWindow(int x1, int y1, int x2, int y2);
+  void     pushColors(uint16_t *data, uint8_t len, boolean first);

  uint16_t color565(uint8_t r, uint8_t g, uint8_t b),
           readPixel(int16_t x, int16_t y),
           readID(void);

+  uint32_t readReg(uint8_t r);
+
 private:

  void     init(),
@ -62,21 +66,36 @@ class Adafruit_TFTLCD : public Adafruit_GFX {
 #ifndef writeRegister16
           writeRegister16(uint16_t a, uint16_t d),
 #endif
+#ifndef writeRegister32
+           writeRegister32(uint16_t a, uint32_t d),
+#endif
 #ifndef writeRegisterPair
           writeRegisterPair(uint8_t aH, uint8_t aL, uint16_t d),
 #endif
           setLR(void),
           flood(uint16_t color, uint32_t len);
  uint8_t  driver;
+
 #ifndef read8
  uint8_t  read8fn(void);
  #define  read8isFunctionalized
 #endif
+
 #ifndef USE_ADAFRUIT_SHIELD_PINOUT
-  volatile uint8_t *csPort    , *cdPort    , *wrPort    , *rdPort;
-  uint8_t           csPinSet  ,  cdPinSet  ,  wrPinSet  ,  rdPinSet  ,
-                    csPinUnset,  cdPinUnset,  wrPinUnset,  rdPinUnset,
-                   _reset;
+
+  #ifdef __AVR__
+    volatile uint8_t *csPort    , *cdPort    , *wrPort    , *rdPort;
+	uint8_t           csPinSet  ,  cdPinSet  ,  wrPinSet  ,  rdPinSet  ,
+					  csPinUnset,  cdPinUnset,  wrPinUnset,  rdPinUnset,
+					  _reset;
+  #endif
+  #if defined(__SAM3X8E__)
+    Pio *csPort    , *cdPort    , *wrPort    , *rdPort;
+	uint32_t          csPinSet  ,  cdPinSet  ,  wrPinSet  ,  rdPinSet  ,
+					  csPinUnset,  cdPinUnset,  wrPinUnset,  rdPinUnset,
+					  _reset;
+  #endif
+
 #endif
 };

--- a/examples/graphicstest/graphicstest.pde
+++ b/examples/graphicstest/graphicstest.pde
--- a/examples/graphicstestx/graphicstestx.pde
+++ b/examples/graphicstestx/graphicstestx.pde
@ -0,0 +1,351 @@
+// This is the same "graphicstest" demo, except modified
+// to work on a XMEGA A3BU Xplained board
+// DO NOT DEFINE "USE_ADAFRUIT_SHIELD_PINOUT" in Adafruit_TFTLCD.h
+// the pin mapping are different, and Serial4 is used for debug messages
+// SEE RELEVANT COMMENTS IN Adafruit_TFTLCD.h FOR SETUP.
+
+#include <Adafruit_GFX.h>    // Core graphics library
+#include <Adafruit_TFTLCD.h> // Hardware-specific library
+
+#define LCD_CS		31	// PA4
+#define LCD_CD		38	// PB3
+#define LCD_WR		37	// PB2
+#define LCD_RD		36	// PB1
+#define LCD_RESET	35	// PA0
+
+// Frank: On the XMEGA256A3BU-Xplained, PORTC is connected to the LCD data bus directly
+
+Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);
+
+// Assign human-readable names to some common 16-bit color values:
+#define	BLACK   0x0000
+#define	BLUE    0x001F
+#define	RED     0xF800
+#define	GREEN   0x07E0
+#define CYAN    0x07FF
+#define MAGENTA 0xF81F
+#define YELLOW  0xFFE0
+#define WHITE   0xFFFF
+
+void setup(void) {
+  Serial4.begin(9600);
+  Serial4.println("TFT LCD test");
+
+  tft.reset();
+
+  uint16_t identifier = tft.readID();
+
+  if(identifier == 0x9325) {
+    Serial4.println(F("Found ILI9325 LCD driver"));
+  } else if(identifier == 0x9328) {
+    Serial4.println(F("Found ILI9328 LCD driver"));
+  } else if(identifier == 0x7575) {
+    Serial4.println(F("Found HX8347G LCD driver"));
+  } else {
+    Serial4.print(F("Unknown LCD driver chip: "));
+    Serial4.println(identifier, HEX);    
+    return;
+  }
+
+  tft.begin(identifier);
+
+  Serial4.println(F("Benchmark                Time (microseconds)"));
+
+  Serial4.print(F("Screen fill              "));
+  Serial4.println(testFillScreen());
+  delay(500);
+
+  Serial4.print(F("Text                     "));
+  Serial4.println(testText());
+  delay(3000);
+
+  Serial4.print(F("Lines                    "));
+  Serial4.println(testLines(CYAN));
+  delay(500);
+
+  Serial4.print(F("Horiz/Vert Lines         "));
+  Serial4.println(testFastLines(RED, BLUE));
+  delay(500);
+
+  Serial4.print(F("Rectangles (outline)     "));
+  Serial4.println(testRects(GREEN));
+  delay(500);
+
+  Serial4.print(F("Rectangles (filled)      "));
+  Serial4.println(testFilledRects(YELLOW, MAGENTA));
+  delay(500);
+
+  Serial4.print(F("Circles (filled)         "));
+  Serial4.println(testFilledCircles(10, MAGENTA));
+
+  Serial4.print(F("Circles (outline)        "));
+  Serial4.println(testCircles(10, WHITE));
+  delay(500);
+
+  Serial4.print(F("Triangles (outline)      "));
+  Serial4.println(testTriangles());
+  delay(500);
+
+  Serial4.print(F("Triangles (filled)       "));
+  Serial4.println(testFilledTriangles());
+  delay(500);
+
+  Serial4.print(F("Rounded rects (outline)  "));
+  Serial4.println(testRoundRects());
+  delay(500);
+
+  Serial4.print(F("Rounded rects (filled)   "));
+  Serial4.println(testFilledRoundRects());
+  delay(500);
+
+  Serial4.println(F("Done!"));
+}
+
+void loop(void) {
+  for(uint8_t rotation=0; rotation<4; rotation++) {
+    tft.setRotation(rotation);
+    testText();
+    delay(2000);
+  }
+}
+
+unsigned long testFillScreen() {
+  unsigned long start = micros();
+  tft.fillScreen(BLACK);
+  tft.fillScreen(RED);
+  tft.fillScreen(GREEN);
+  tft.fillScreen(BLUE);
+  tft.fillScreen(BLACK);
+  return micros() - start;
+}
+
+unsigned long testText() {
+  tft.fillScreen(BLACK);
+  unsigned long start = micros();
+  tft.setCursor(0, 0);
+  tft.setTextColor(WHITE);  tft.setTextSize(1);
+  tft.println("Hello World!");
+  tft.setTextColor(YELLOW); tft.setTextSize(2);
+  tft.println(1234.56);
+  tft.setTextColor(RED);    tft.setTextSize(3);
+  tft.println(0xDEADBEEF, HEX);
+  tft.println();
+  tft.setTextColor(GREEN);
+  tft.setTextSize(5);
+  tft.println("Groop");
+  tft.setTextSize(2);
+  tft.println("I implore thee,");
+  tft.setTextSize(1);
+  tft.println("my foonting turlingdromes.");
+  tft.println("And hooptiously drangle me");
+  tft.println("with crinkly bindlewurdles,");
+  tft.println("Or I will rend thee");
+  tft.println("in the gobberwarts");
+  tft.println("with my blurglecruncheon,");
+  tft.println("see if I don't!");
+  return micros() - start;
+}
+
+unsigned long testLines(uint16_t color) {
+  unsigned long start, t;
+  int           x1, y1, x2, y2,
+                w = tft.width(),
+                h = tft.height();
+
+  tft.fillScreen(BLACK);
+
+  x1 = y1 = 0;
+  y2    = h - 1;
+  start = micros();
+  for(x2=0; x2<w; x2+=6) tft.drawLine(x1, y1, x2, y2, color);
+  x2    = w - 1;
+  for(y2=0; y2<h; y2+=6) tft.drawLine(x1, y1, x2, y2, color);
+  t     = micros() - start; // fillScreen doesn't count against timing
+
+  tft.fillScreen(BLACK);
+
+  x1    = w - 1;
+  y1    = 0;
+  y2    = h - 1;
+  start = micros();
+  for(x2=0; x2<w; x2+=6) tft.drawLine(x1, y1, x2, y2, color);
+  x2    = 0;
+  for(y2=0; y2<h; y2+=6) tft.drawLine(x1, y1, x2, y2, color);
+  t    += micros() - start;
+
+  tft.fillScreen(BLACK);
+
+  x1    = 0;
+  y1    = h - 1;
+  y2    = 0;
+  start = micros();
+  for(x2=0; x2<w; x2+=6) tft.drawLine(x1, y1, x2, y2, color);
+  x2    = w - 1;
+  for(y2=0; y2<h; y2+=6) tft.drawLine(x1, y1, x2, y2, color);
+  t    += micros() - start;
+
+  tft.fillScreen(BLACK);
+
+  x1    = w - 1;
+  y1    = h - 1;
+  y2    = 0;
+  start = micros();
+  for(x2=0; x2<w; x2+=6) tft.drawLine(x1, y1, x2, y2, color);
+  x2    = 0;
+  for(y2=0; y2<h; y2+=6) tft.drawLine(x1, y1, x2, y2, color);
+
+  return micros() - start;
+}
+
+unsigned long testFastLines(uint16_t color1, uint16_t color2) {
+  unsigned long start;
+  int           x, y, w = tft.width(), h = tft.height();
+
+  tft.fillScreen(BLACK);
+  start = micros();
+  for(y=0; y<h; y+=5) tft.drawFastHLine(0, y, w, color1);
+  for(x=0; x<w; x+=5) tft.drawFastVLine(x, 0, h, color2);
+
+  return micros() - start;
+}
+
+unsigned long testRects(uint16_t color) {
+  unsigned long start;
+  int           n, i, i2,
+                cx = tft.width()  / 2,
+                cy = tft.height() / 2;
+
+  tft.fillScreen(BLACK);
+  n     = min(tft.width(), tft.height());
+  start = micros();
+  for(i=2; i<n; i+=6) {
+    i2 = i / 2;
+    tft.drawRect(cx-i2, cy-i2, i, i, color);
+  }
+
+  return micros() - start;
+}
+
+unsigned long testFilledRects(uint16_t color1, uint16_t color2) {
+  unsigned long start, t = 0;
+  int           n, i, i2,
+                cx = tft.width()  / 2 - 1,
+                cy = tft.height() / 2 - 1;
+
+  tft.fillScreen(BLACK);
+  n = min(tft.width(), tft.height());
+  for(i=n; i>0; i-=6) {
+    i2    = i / 2;
+    start = micros();
+    tft.fillRect(cx-i2, cy-i2, i, i, color1);
+    t    += micros() - start;
+    // Outlines are not included in timing results
+    tft.drawRect(cx-i2, cy-i2, i, i, color2);
+  }
+
+  return t;
+}
+
+unsigned long testFilledCircles(uint8_t radius, uint16_t color) {
+  unsigned long start;
+  int x, y, w = tft.width(), h = tft.height(), r2 = radius * 2;
+
+  tft.fillScreen(BLACK);
+  start = micros();
+  for(x=radius; x<w; x+=r2) {
+    for(y=radius; y<h; y+=r2) {
+      tft.fillCircle(x, y, radius, color);
+    }
+  }
+
+  return micros() - start;
+}
+
+unsigned long testCircles(uint8_t radius, uint16_t color) {
+  unsigned long start;
+  int           x, y, r2 = radius * 2,
+                w = tft.width()  + radius,
+                h = tft.height() + radius;
+
+  // Screen is not cleared for this one -- this is
+  // intentional and does not affect the reported time.
+  start = micros();
+  for(x=0; x<w; x+=r2) {
+    for(y=0; y<h; y+=r2) {
+      tft.drawCircle(x, y, radius, color);
+    }
+  }
+
+  return micros() - start;
+}
+
+unsigned long testTriangles() {
+  unsigned long start;
+  int           n, i, cx = tft.width()  / 2 - 1,
+                      cy = tft.height() / 2 - 1;
+
+  tft.fillScreen(BLACK);
+  n     = min(cx, cy);
+  start = micros();
+  for(i=0; i<n; i+=5) {
+    tft.drawTriangle(
+      cx    , cy - i, // peak
+      cx - i, cy + i, // bottom left
+      cx + i, cy + i, // bottom right
+      tft.color565(0, 0, i));
+  }
+
+  return micros() - start;
+}
+
+unsigned long testFilledTriangles() {
+  unsigned long start, t = 0;
+  int           i, cx = tft.width()  / 2 - 1,
+                   cy = tft.height() / 2 - 1;
+
+  tft.fillScreen(BLACK);
+  start = micros();
+  for(i=min(cx,cy); i>10; i-=5) {
+    start = micros();
+    tft.fillTriangle(cx, cy - i, cx - i, cy + i, cx + i, cy + i,
+      tft.color565(0, i, i));
+    t += micros() - start;
+    tft.drawTriangle(cx, cy - i, cx - i, cy + i, cx + i, cy + i,
+      tft.color565(i, i, 0));
+  }
+
+  return t;
+}
+
+unsigned long testRoundRects() {
+  unsigned long start;
+  int           w, i, i2,
+                cx = tft.width()  / 2 - 1,
+                cy = tft.height() / 2 - 1;
+
+  tft.fillScreen(BLACK);
+  w     = min(tft.width(), tft.height());
+  start = micros();
+  for(i=0; i<w; i+=6) {
+    i2 = i / 2;
+    tft.drawRoundRect(cx-i2, cy-i2, i, i, i/8, tft.color565(i, 0, 0));
+  }
+
+  return micros() - start;
+}
+
+unsigned long testFilledRoundRects() {
+  unsigned long start;
+  int           i, i2,
+                cx = tft.width()  / 2 - 1,
+                cy = tft.height() / 2 - 1;
+
+  tft.fillScreen(BLACK);
+  start = micros();
+  for(i=min(tft.width(), tft.height()); i>20; i-=6) {
+    i2 = i / 2;
+    tft.fillRoundRect(cx-i2, cy-i2, i, i, i/8, tft.color565(0, i, 0));
+  }
+
+  return micros() - start;
+}
--- a/examples/rotationtest/rotationtest.pde
+++ b/examples/rotationtest/rotationtest.pde
--- a/examples/tftbmp/tftbmp.pde
+++ b/examples/tftbmp/tftbmp.pde
--- a/examples/tftbmp_shield/tftbmp_shield.pde
+++ b/examples/tftbmp_shield/tftbmp_shield.pde
--- a/examples/tftpaint/tftpaint.ino
+++ b/examples/tftpaint/tftpaint.ino
@ -6,6 +6,11 @@
 #include <Adafruit_TFTLCD.h> // Hardware-specific library
 #include <TouchScreen.h>

+#if defined(__SAM3X8E__)
+    #undef __FlashStringHelper::F(string_literal)
+    #define F(string_literal) string_literal
+#endif
+
 // When using the BREAKOUT BOARD only, use these 8 data lines to the LCD:
 // For the Arduino Uno, Duemilanove, Diecimila, etc.:
 //   D0 connects to digital pin 8  (Notice these are
@ -16,8 +21,28 @@
 //   D5 connects to digital pin 5
 //   D6 connects to digital pin 6
 //   D7 connects to digital pin 7
+
 // For the Arduino Mega, use digital pins 22 through 29
 // (on the 2-row header at the end of the board).
+//   D0 connects to digital pin 22
+//   D1 connects to digital pin 23
+//   D2 connects to digital pin 24
+//   D3 connects to digital pin 25
+//   D4 connects to digital pin 26
+//   D5 connects to digital pin 27
+//   D6 connects to digital pin 28
+//   D7 connects to digital pin 29
+
+// For the Arduino Due, use digital pins 33 through 40
+// (on the 2-row header at the end of the board).
+//   D0 connects to digital pin 33
+//   D1 connects to digital pin 34
+//   D2 connects to digital pin 35
+//   D3 connects to digital pin 36
+//   D4 connects to digital pin 37
+//   D5 connects to digital pin 38
+//   D6 connects to digital pin 39
+//   D7 connects to digital pin 40

 #define YP A3  // must be an analog pin, use "An" notation!
 #define XM A2  // must be an analog pin, use "An" notation!
--- a/examples/tftpaint_shield/glcdfont.c
+++ b/examples/tftpaint_shield/glcdfont.c
@ -0,0 +1,264 @@
+
+#ifndef FONT5X7_H
+#define FONT5X7_H
+
+// standard ascii 5x7 font
+
+static unsigned char  font[]  = {
+        0x00, 0x00, 0x00, 0x00, 0x00,   
+	0x3E, 0x5B, 0x4F, 0x5B, 0x3E, 	
+	0x3E, 0x6B, 0x4F, 0x6B, 0x3E, 	
+	0x1C, 0x3E, 0x7C, 0x3E, 0x1C, 
+	0x18, 0x3C, 0x7E, 0x3C, 0x18, 
+	0x1C, 0x57, 0x7D, 0x57, 0x1C, 
+	0x1C, 0x5E, 0x7F, 0x5E, 0x1C, 
+	0x00, 0x18, 0x3C, 0x18, 0x00, 
+	0xFF, 0xE7, 0xC3, 0xE7, 0xFF, 
+	0x00, 0x18, 0x24, 0x18, 0x00, 
+	0xFF, 0xE7, 0xDB, 0xE7, 0xFF, 
+	0x30, 0x48, 0x3A, 0x06, 0x0E, 
+	0x26, 0x29, 0x79, 0x29, 0x26, 
+	0x40, 0x7F, 0x05, 0x05, 0x07, 
+	0x40, 0x7F, 0x05, 0x25, 0x3F, 
+	0x5A, 0x3C, 0xE7, 0x3C, 0x5A, 
+	0x7F, 0x3E, 0x1C, 0x1C, 0x08, 
+	0x08, 0x1C, 0x1C, 0x3E, 0x7F, 
+	0x14, 0x22, 0x7F, 0x22, 0x14, 
+	0x5F, 0x5F, 0x00, 0x5F, 0x5F, 
+	0x06, 0x09, 0x7F, 0x01, 0x7F, 
+	0x00, 0x66, 0x89, 0x95, 0x6A, 
+	0x60, 0x60, 0x60, 0x60, 0x60, 
+	0x94, 0xA2, 0xFF, 0xA2, 0x94, 
+	0x08, 0x04, 0x7E, 0x04, 0x08, 
+	0x10, 0x20, 0x7E, 0x20, 0x10, 
+	0x08, 0x08, 0x2A, 0x1C, 0x08, 
+	0x08, 0x1C, 0x2A, 0x08, 0x08, 
+	0x1E, 0x10, 0x10, 0x10, 0x10, 
+	0x0C, 0x1E, 0x0C, 0x1E, 0x0C, 
+	0x30, 0x38, 0x3E, 0x38, 0x30, 
+	0x06, 0x0E, 0x3E, 0x0E, 0x06, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x5F, 0x00, 0x00, 
+	0x00, 0x07, 0x00, 0x07, 0x00, 
+	0x14, 0x7F, 0x14, 0x7F, 0x14, 
+	0x24, 0x2A, 0x7F, 0x2A, 0x12, 
+	0x23, 0x13, 0x08, 0x64, 0x62, 
+	0x36, 0x49, 0x56, 0x20, 0x50, 
+	0x00, 0x08, 0x07, 0x03, 0x00, 
+	0x00, 0x1C, 0x22, 0x41, 0x00, 
+	0x00, 0x41, 0x22, 0x1C, 0x00, 
+	0x2A, 0x1C, 0x7F, 0x1C, 0x2A, 
+	0x08, 0x08, 0x3E, 0x08, 0x08, 
+	0x00, 0x80, 0x70, 0x30, 0x00, 
+	0x08, 0x08, 0x08, 0x08, 0x08, 
+	0x00, 0x00, 0x60, 0x60, 0x00, 
+	0x20, 0x10, 0x08, 0x04, 0x02, 
+	0x3E, 0x51, 0x49, 0x45, 0x3E, 
+	0x00, 0x42, 0x7F, 0x40, 0x00, 
+	0x72, 0x49, 0x49, 0x49, 0x46, 
+	0x21, 0x41, 0x49, 0x4D, 0x33, 
+	0x18, 0x14, 0x12, 0x7F, 0x10, 
+	0x27, 0x45, 0x45, 0x45, 0x39, 
+	0x3C, 0x4A, 0x49, 0x49, 0x31, 
+	0x41, 0x21, 0x11, 0x09, 0x07, 
+	0x36, 0x49, 0x49, 0x49, 0x36, 
+	0x46, 0x49, 0x49, 0x29, 0x1E, 
+	0x00, 0x00, 0x14, 0x00, 0x00, 
+	0x00, 0x40, 0x34, 0x00, 0x00, 
+	0x00, 0x08, 0x14, 0x22, 0x41, 
+	0x14, 0x14, 0x14, 0x14, 0x14, 
+	0x00, 0x41, 0x22, 0x14, 0x08, 
+	0x02, 0x01, 0x59, 0x09, 0x06, 
+	0x3E, 0x41, 0x5D, 0x59, 0x4E, 
+	0x7C, 0x12, 0x11, 0x12, 0x7C, 
+	0x7F, 0x49, 0x49, 0x49, 0x36, 
+	0x3E, 0x41, 0x41, 0x41, 0x22, 
+	0x7F, 0x41, 0x41, 0x41, 0x3E, 
+	0x7F, 0x49, 0x49, 0x49, 0x41, 
+	0x7F, 0x09, 0x09, 0x09, 0x01, 
+	0x3E, 0x41, 0x41, 0x51, 0x73, 
+	0x7F, 0x08, 0x08, 0x08, 0x7F, 
+	0x00, 0x41, 0x7F, 0x41, 0x00, 
+	0x20, 0x40, 0x41, 0x3F, 0x01, 
+	0x7F, 0x08, 0x14, 0x22, 0x41, 
+	0x7F, 0x40, 0x40, 0x40, 0x40, 
+	0x7F, 0x02, 0x1C, 0x02, 0x7F, 
+	0x7F, 0x04, 0x08, 0x10, 0x7F, 
+	0x3E, 0x41, 0x41, 0x41, 0x3E, 
+	0x7F, 0x09, 0x09, 0x09, 0x06, 
+	0x3E, 0x41, 0x51, 0x21, 0x5E, 
+	0x7F, 0x09, 0x19, 0x29, 0x46, 
+	0x26, 0x49, 0x49, 0x49, 0x32, 
+	0x03, 0x01, 0x7F, 0x01, 0x03, 
+	0x3F, 0x40, 0x40, 0x40, 0x3F, 
+	0x1F, 0x20, 0x40, 0x20, 0x1F, 
+	0x3F, 0x40, 0x38, 0x40, 0x3F, 
+	0x63, 0x14, 0x08, 0x14, 0x63, 
+	0x03, 0x04, 0x78, 0x04, 0x03, 
+	0x61, 0x59, 0x49, 0x4D, 0x43, 
+	0x00, 0x7F, 0x41, 0x41, 0x41, 
+	0x02, 0x04, 0x08, 0x10, 0x20, 
+	0x00, 0x41, 0x41, 0x41, 0x7F, 
+	0x04, 0x02, 0x01, 0x02, 0x04, 
+	0x40, 0x40, 0x40, 0x40, 0x40, 
+	0x00, 0x03, 0x07, 0x08, 0x00, 
+	0x20, 0x54, 0x54, 0x78, 0x40, 
+	0x7F, 0x28, 0x44, 0x44, 0x38, 
+	0x38, 0x44, 0x44, 0x44, 0x28, 
+	0x38, 0x44, 0x44, 0x28, 0x7F, 
+	0x38, 0x54, 0x54, 0x54, 0x18, 
+	0x00, 0x08, 0x7E, 0x09, 0x02, 
+	0x18, 0xA4, 0xA4, 0x9C, 0x78, 
+	0x7F, 0x08, 0x04, 0x04, 0x78, 
+	0x00, 0x44, 0x7D, 0x40, 0x00, 
+	0x20, 0x40, 0x40, 0x3D, 0x00, 
+	0x7F, 0x10, 0x28, 0x44, 0x00, 
+	0x00, 0x41, 0x7F, 0x40, 0x00, 
+	0x7C, 0x04, 0x78, 0x04, 0x78, 
+	0x7C, 0x08, 0x04, 0x04, 0x78, 
+	0x38, 0x44, 0x44, 0x44, 0x38, 
+	0xFC, 0x18, 0x24, 0x24, 0x18, 
+	0x18, 0x24, 0x24, 0x18, 0xFC, 
+	0x7C, 0x08, 0x04, 0x04, 0x08, 
+	0x48, 0x54, 0x54, 0x54, 0x24, 
+	0x04, 0x04, 0x3F, 0x44, 0x24, 
+	0x3C, 0x40, 0x40, 0x20, 0x7C, 
+	0x1C, 0x20, 0x40, 0x20, 0x1C, 
+	0x3C, 0x40, 0x30, 0x40, 0x3C, 
+	0x44, 0x28, 0x10, 0x28, 0x44, 
+	0x4C, 0x90, 0x90, 0x90, 0x7C, 
+	0x44, 0x64, 0x54, 0x4C, 0x44, 
+	0x00, 0x08, 0x36, 0x41, 0x00, 
+	0x00, 0x00, 0x77, 0x00, 0x00, 
+	0x00, 0x41, 0x36, 0x08, 0x00, 
+	0x02, 0x01, 0x02, 0x04, 0x02, 
+	0x3C, 0x26, 0x23, 0x26, 0x3C, 
+	0x1E, 0xA1, 0xA1, 0x61, 0x12, 
+	0x3A, 0x40, 0x40, 0x20, 0x7A, 
+	0x38, 0x54, 0x54, 0x55, 0x59, 
+	0x21, 0x55, 0x55, 0x79, 0x41, 
+	0x21, 0x54, 0x54, 0x78, 0x41, 
+	0x21, 0x55, 0x54, 0x78, 0x40, 
+	0x20, 0x54, 0x55, 0x79, 0x40, 
+	0x0C, 0x1E, 0x52, 0x72, 0x12, 
+	0x39, 0x55, 0x55, 0x55, 0x59, 
+	0x39, 0x54, 0x54, 0x54, 0x59, 
+	0x39, 0x55, 0x54, 0x54, 0x58, 
+	0x00, 0x00, 0x45, 0x7C, 0x41, 
+	0x00, 0x02, 0x45, 0x7D, 0x42, 
+	0x00, 0x01, 0x45, 0x7C, 0x40, 
+	0xF0, 0x29, 0x24, 0x29, 0xF0, 
+	0xF0, 0x28, 0x25, 0x28, 0xF0, 
+	0x7C, 0x54, 0x55, 0x45, 0x00, 
+	0x20, 0x54, 0x54, 0x7C, 0x54, 
+	0x7C, 0x0A, 0x09, 0x7F, 0x49, 
+	0x32, 0x49, 0x49, 0x49, 0x32, 
+	0x32, 0x48, 0x48, 0x48, 0x32, 
+	0x32, 0x4A, 0x48, 0x48, 0x30, 
+	0x3A, 0x41, 0x41, 0x21, 0x7A, 
+	0x3A, 0x42, 0x40, 0x20, 0x78, 
+	0x00, 0x9D, 0xA0, 0xA0, 0x7D, 
+	0x39, 0x44, 0x44, 0x44, 0x39, 
+	0x3D, 0x40, 0x40, 0x40, 0x3D, 
+	0x3C, 0x24, 0xFF, 0x24, 0x24, 
+	0x48, 0x7E, 0x49, 0x43, 0x66, 
+	0x2B, 0x2F, 0xFC, 0x2F, 0x2B, 
+	0xFF, 0x09, 0x29, 0xF6, 0x20, 
+	0xC0, 0x88, 0x7E, 0x09, 0x03, 
+	0x20, 0x54, 0x54, 0x79, 0x41, 
+	0x00, 0x00, 0x44, 0x7D, 0x41, 
+	0x30, 0x48, 0x48, 0x4A, 0x32, 
+	0x38, 0x40, 0x40, 0x22, 0x7A, 
+	0x00, 0x7A, 0x0A, 0x0A, 0x72, 
+	0x7D, 0x0D, 0x19, 0x31, 0x7D, 
+	0x26, 0x29, 0x29, 0x2F, 0x28, 
+	0x26, 0x29, 0x29, 0x29, 0x26, 
+	0x30, 0x48, 0x4D, 0x40, 0x20, 
+	0x38, 0x08, 0x08, 0x08, 0x08, 
+	0x08, 0x08, 0x08, 0x08, 0x38, 
+	0x2F, 0x10, 0xC8, 0xAC, 0xBA, 
+	0x2F, 0x10, 0x28, 0x34, 0xFA, 
+	0x00, 0x00, 0x7B, 0x00, 0x00, 
+	0x08, 0x14, 0x2A, 0x14, 0x22, 
+	0x22, 0x14, 0x2A, 0x14, 0x08, 
+	0xAA, 0x00, 0x55, 0x00, 0xAA, 
+	0xAA, 0x55, 0xAA, 0x55, 0xAA, 
+	0x00, 0x00, 0x00, 0xFF, 0x00, 
+	0x10, 0x10, 0x10, 0xFF, 0x00, 
+	0x14, 0x14, 0x14, 0xFF, 0x00, 
+	0x10, 0x10, 0xFF, 0x00, 0xFF, 
+	0x10, 0x10, 0xF0, 0x10, 0xF0, 
+	0x14, 0x14, 0x14, 0xFC, 0x00, 
+	0x14, 0x14, 0xF7, 0x00, 0xFF, 
+	0x00, 0x00, 0xFF, 0x00, 0xFF, 
+	0x14, 0x14, 0xF4, 0x04, 0xFC, 
+	0x14, 0x14, 0x17, 0x10, 0x1F, 
+	0x10, 0x10, 0x1F, 0x10, 0x1F, 
+	0x14, 0x14, 0x14, 0x1F, 0x00, 
+	0x10, 0x10, 0x10, 0xF0, 0x00, 
+	0x00, 0x00, 0x00, 0x1F, 0x10, 
+	0x10, 0x10, 0x10, 0x1F, 0x10, 
+	0x10, 0x10, 0x10, 0xF0, 0x10, 
+	0x00, 0x00, 0x00, 0xFF, 0x10, 
+	0x10, 0x10, 0x10, 0x10, 0x10, 
+	0x10, 0x10, 0x10, 0xFF, 0x10, 
+	0x00, 0x00, 0x00, 0xFF, 0x14, 
+	0x00, 0x00, 0xFF, 0x00, 0xFF, 
+	0x00, 0x00, 0x1F, 0x10, 0x17, 
+	0x00, 0x00, 0xFC, 0x04, 0xF4, 
+	0x14, 0x14, 0x17, 0x10, 0x17, 
+	0x14, 0x14, 0xF4, 0x04, 0xF4, 
+	0x00, 0x00, 0xFF, 0x00, 0xF7, 
+	0x14, 0x14, 0x14, 0x14, 0x14, 
+	0x14, 0x14, 0xF7, 0x00, 0xF7, 
+	0x14, 0x14, 0x14, 0x17, 0x14, 
+	0x10, 0x10, 0x1F, 0x10, 0x1F, 
+	0x14, 0x14, 0x14, 0xF4, 0x14, 
+	0x10, 0x10, 0xF0, 0x10, 0xF0, 
+	0x00, 0x00, 0x1F, 0x10, 0x1F, 
+	0x00, 0x00, 0x00, 0x1F, 0x14, 
+	0x00, 0x00, 0x00, 0xFC, 0x14, 
+	0x00, 0x00, 0xF0, 0x10, 0xF0, 
+	0x10, 0x10, 0xFF, 0x10, 0xFF, 
+	0x14, 0x14, 0x14, 0xFF, 0x14, 
+	0x10, 0x10, 0x10, 0x1F, 0x00, 
+	0x00, 0x00, 0x00, 0xF0, 0x10, 
+	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
+	0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 
+	0xFF, 0xFF, 0xFF, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0xFF, 0xFF, 
+	0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 
+	0x38, 0x44, 0x44, 0x38, 0x44, 
+	0x7C, 0x2A, 0x2A, 0x3E, 0x14, 
+	0x7E, 0x02, 0x02, 0x06, 0x06, 
+	0x02, 0x7E, 0x02, 0x7E, 0x02, 
+	0x63, 0x55, 0x49, 0x41, 0x63, 
+	0x38, 0x44, 0x44, 0x3C, 0x04, 
+	0x40, 0x7E, 0x20, 0x1E, 0x20, 
+	0x06, 0x02, 0x7E, 0x02, 0x02, 
+	0x99, 0xA5, 0xE7, 0xA5, 0x99, 
+	0x1C, 0x2A, 0x49, 0x2A, 0x1C, 
+	0x4C, 0x72, 0x01, 0x72, 0x4C, 
+	0x30, 0x4A, 0x4D, 0x4D, 0x30, 
+	0x30, 0x48, 0x78, 0x48, 0x30, 
+	0xBC, 0x62, 0x5A, 0x46, 0x3D, 
+	0x3E, 0x49, 0x49, 0x49, 0x00, 
+	0x7E, 0x01, 0x01, 0x01, 0x7E, 
+	0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 
+	0x44, 0x44, 0x5F, 0x44, 0x44, 
+	0x40, 0x51, 0x4A, 0x44, 0x40, 
+	0x40, 0x44, 0x4A, 0x51, 0x40, 
+	0x00, 0x00, 0xFF, 0x01, 0x03, 
+	0xE0, 0x80, 0xFF, 0x00, 0x00, 
+	0x08, 0x08, 0x6B, 0x6B, 0x08,
+	0x36, 0x12, 0x36, 0x24, 0x36, 
+	0x06, 0x0F, 0x09, 0x0F, 0x06, 
+	0x00, 0x00, 0x18, 0x18, 0x00, 
+	0x00, 0x00, 0x10, 0x10, 0x00, 
+	0x30, 0x40, 0xFF, 0x01, 0x01, 
+	0x00, 0x1F, 0x01, 0x01, 0x1E, 
+	0x00, 0x19, 0x1D, 0x17, 0x12, 
+	0x00, 0x3C, 0x3C, 0x3C, 0x3C, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 
+};
+#endif
--- a/examples/tftpaint_shield/tftpaint_shield.ino
+++ b/examples/tftpaint_shield/tftpaint_shield.ino
@ -5,6 +5,11 @@
 #include <Adafruit_TFTLCD.h> // Hardware-specific library
 #include <TouchScreen.h>

+#if defined(__SAM3X8E__)
+    #undef __FlashStringHelper::F(string_literal)
+    #define F(string_literal) string_literal
+#endif
+
 #ifndef USE_ADAFRUIT_SHIELD_PINOUT 
 #error "This sketch is intended for use with the TFT LCD Shield. Make sure that USE_ADAFRUIT_SHIELD_PINOUT is #defined in the Adafruit_TFTLCD.h library file."
 #endif
@ -15,10 +20,17 @@
 #define YM 7   // can be a digital pin
 #define XP 6   // can be a digital pin

-#define TS_MINX 150
-#define TS_MINY 120
-#define TS_MAXX 920
-#define TS_MAXY 940
+#ifdef __SAM3X8E__
+  #define TS_MINX 125
+  #define TS_MINY 170
+  #define TS_MAXX 880
+  #define TS_MAXY 940
+#else
+  #define TS_MINX  150
+  #define TS_MINY  120
+  #define TS_MAXX  920
+  #define TS_MAXY  940
+#endif

 // For better pressure precision, we need to know the resistance
 // between X+ and X- Use any multimeter to read it
--- a/pin_magic.h
+++ b/pin_magic.h
@ -32,11 +32,12 @@
 // given for each supported board.

 // Shield pin usage:
-// LCD Data Bit :   7   6   5   4   3   2   1   0
-// Digital pin #:   7   6  13   4  11  10   9   8
-// Uno port/pin : PD7 PD6 PB5 PD4 PB3 PB2 PB1 PB0
-// Mega port/pin: PH4 PH3 PB7 PG5 PB5 PB4 PH6 PH5
-// Leo port/pin : PE6 PD7 PC7 PD4 PB7 PB6 PB5 PB4
+// LCD Data Bit :    7    6    5    4    3    2    1    0
+// Digital pin #:    7    6   13    4   11   10    9    8
+// Uno port/pin :  PD7  PD6  PB5  PD4  PB3  PB2  PB1  PB0
+// Mega port/pin:  PH4  PH3  PB7  PG5  PB5  PB4  PH6  PH5
+// Leo port/pin :  PE6  PD7  PC7  PD4  PB7  PB6  PB5  PB4
+// Due port/pin : PC23 PC24 PB27 PC26  PD7 PC29 PC21 PC22
 // Breakout pin usage:
 // LCD Data Bit :   7   6   5   4   3   2   1   0
 // Uno dig. pin :   7   6   5   4   3   2   9   8
@ -45,6 +46,8 @@
 // Mega port/pin: PA7 PA6 PA5 PA4 PA3 PA2 PA1 PA0 (one contiguous PORT)
 // Leo dig. pin :   7   6   5   4   3   2   9   8
 // Leo port/pin : PE6 PD7 PC6 PD4 PD0 PD1 PB5 PB4
+// Due dig. pin :  40  39  38  37  36  35  34  33
+// Due port/pin : PC8 PC7 PC6 PC5 PC4 PC3 PC2 PC1 (one contiguous PORT. -ish…)

 // Pixel read operations require a minimum 400 nS delay from RD_ACTIVE
 // to polling the input pins.  At 16 MHz, one machine cycle is 62.5 nS.
@ -52,7 +55,19 @@
 // equivalent to two NOPs each, final NOP burns the 7th cycle, and the
 // last line is a radioactive mutant emoticon.
 #define DELAY7        \
-  asm volatile(       \
+  asm volatile(      \
+    "rjmp .+0" "\n\t" \
+    "rjmp .+0" "\n\t" \
+    "rjmp .+0" "\n\t" \
+    "nop"      "\n"   \
+    ::);
+
+// Xmega runs at 32 MHz instead of 16, so 13 cycle delays are needed
+#define DELAY13       \
+  asm volatile(      \
+    "rjmp .+0" "\n\t" \
+    "rjmp .+0" "\n\t" \
+    "rjmp .+0" "\n\t" \
    "rjmp .+0" "\n\t" \
    "rjmp .+0" "\n\t" \
    "rjmp .+0" "\n\t" \
@ -67,10 +82,10 @@

  // LCD control lines:
  // RD (read), WR (write), CD (command/data), CS (chip select)
-  #define RD_PORT PORTC
-  #define WR_PORT PORTC
-  #define CD_PORT PORTC
-  #define CS_PORT PORTC
+  #define RD_PORT PORTC				/*pin A0 */
+  #define WR_PORT PORTC				/*pin A1 */
+  #define CD_PORT PORTC				/*pin A2 */
+  #define CS_PORT PORTC				/*pin A3 */
  #define RD_MASK B00000001
  #define WR_MASK B00000010
  #define CD_MASK B00000100
@ -182,6 +197,7 @@
  #define setReadDir        setReadDirInline
  #define writeRegister8    writeRegister8inline
  #define writeRegister16   writeRegister16inline
+  #define writeRegister32   writeRegister32inline
  #define writeRegisterPair writeRegisterPairInline

 #elif defined(__AVR_ATmega32U4__)
@ -252,13 +268,136 @@
  // program to compile.
  #define write8 write8inline

+#elif defined(VARIANT_ADAX256A3BU)
+
+	#define write8inline(d)		do { PORTC_OUT = d; WR_STROBE; } while (0)
+	#define read8inline(result)	do { RD_ACTIVE; DELAY13; result = PORTC_IN; RD_IDLE; } while (0)
+	#define setWriteDirInline()	do { PORTC_DIR = 0xFF; } while (0)
+	#define setReadDirInline()	do { PORTC_DIR = 0x00; } while (0)
+
+	#define write8            write8inline
+	#define read8             read8inline
+	#define setWriteDir       setWriteDirInline
+	#define setReadDir        setReadDirInline
+	#define writeRegister8    writeRegister8inline
+	#define writeRegister16   writeRegister16inline
+	#define writeRegister32   writeRegister32inline
+	#define writeRegisterPair writeRegisterPairInline
+
+#elif defined(VARIANT_MICROTOUCHX)
+
+	#define write8inline(d)		do { PORTA_OUT = d; WR_STROBE; } while (0)
+	#define read8inline(result)	do { RD_ACTIVE; DELAY13; result = PORTA_IN; RD_IDLE; } while (0)
+	#define setWriteDirInline()	do { PORTA_DIR = 0xFF; } while (0)
+	#define setReadDirInline()	do { PORTA_DIR = 0x00; } while (0)
+
+	#define write8            write8inline
+	#define read8             read8inline
+	#define setWriteDir       setWriteDirInline
+	#define setReadDir        setReadDirInline
+	#define writeRegister8    writeRegister8inline
+	#define writeRegister16   writeRegister16inline
+	#define writeRegister32   writeRegister32inline
+	#define writeRegisterPair writeRegisterPairInline
+
+#elif defined(__SAM3X8E__)
+
+// Arduino Due
+
+ #ifdef USE_ADAFRUIT_SHIELD_PINOUT
+
+  #define RD_PORT PIOA				/*pin A0 */	
+  #define WR_PORT PIOA				/*pin A1 */
+  #define CD_PORT PIOA				/*pin A2 */
+  #define CS_PORT PIOA				/*pin A3 */
+  #define RD_MASK 0x00010000
+  #define WR_MASK 0x01000000
+  #define CD_MASK 0x00800000
+  #define CS_MASK 0x00400000
+
+  #define write8inline(d) { \
+   PIO_Set(PIOD, (((d) & 0x08)<<(7-3))); \
+   PIO_Clear(PIOD, (((~d) & 0x08)<<(7-3))); \
+   PIO_Set(PIOC, (((d) & 0x01)<<(22-0)) | (((d) & 0x02)<<(21-1))| (((d) & 0x04)<<(29-2))| (((d) & 0x10)<<(26-4))| (((d) & 0x40)<<(24-6))| (((d) & 0x80)<<(23-7))); \
+   PIO_Clear(PIOC, (((~d) & 0x01)<<(22-0)) | (((~d) & 0x02)<<(21-1))| (((~d) & 0x04)<<(29-2))| (((~d) & 0x10)<<(26-4))| (((~d) & 0x40)<<(24-6))| (((~d) & 0x80)<<(23-7))); \
+   PIO_Set(PIOB, (((d) & 0x20)<<(27-5))); \
+   PIO_Clear(PIOB, (((~d) & 0x20)<<(27-5))); \
+   WR_STROBE; }
+
+  #define read8inline(result) { \    
+   RD_ACTIVE;   \
+   delayMicroseconds(1);      \
+   result = (((PIOC->PIO_PDSR & (1<<23)) >> (23-7)) | ((PIOC->PIO_PDSR & (1<<24)) >> (24-6)) | \
+             ((PIOB->PIO_PDSR & (1<<27)) >> (27-5)) | ((PIOC->PIO_PDSR & (1<<26)) >> (26-4)) | \
+             ((PIOD->PIO_PDSR & (1<< 7)) >> ( 7-3)) | ((PIOC->PIO_PDSR & (1<<29)) >> (29-2)) | \
+             ((PIOC->PIO_PDSR & (1<<21)) >> (21-1)) | ((PIOC->PIO_PDSR & (1<<22)) >> (22-0))); \
+   RD_IDLE;}
+
+  #define setWriteDirInline() { \
+   PIOD->PIO_MDDR |=  0x00000080; /*PIOD->PIO_SODR =  0x00000080;*/ PIOD->PIO_OER |=  0x00000080; PIOD->PIO_PER |=  0x00000080; \
+   PIOC->PIO_MDDR |=  0x25E00000; /*PIOC->PIO_SODR =  0x25E00000;*/ PIOC->PIO_OER |=  0x25E00000; PIOC->PIO_PER |=  0x25E00000; \
+   PIOB->PIO_MDDR |=  0x08000000; /*PIOB->PIO_SODR =  0x08000000;*/ PIOB->PIO_OER |=  0x08000000; PIOB->PIO_PER |=  0x08000000; }
+
+  #define setReadDirInline() { \
+	  pmc_enable_periph_clk( ID_PIOD ) ;	  pmc_enable_periph_clk( ID_PIOC ) ;	  pmc_enable_periph_clk( ID_PIOB ) ; \
+   PIOD->PIO_PUDR |=  0x00000080; PIOD->PIO_IFDR |=  0x00000080; PIOD->PIO_ODR |=  0x00000080; PIOD->PIO_PER |=  0x00000080; \
+   PIOC->PIO_PUDR |=  0x25E00000; PIOC->PIO_IFDR |=  0x25E00000; PIOC->PIO_ODR |=  0x25E00000; PIOC->PIO_PER |=  0x25E00000; \
+   PIOB->PIO_PUDR |=  0x08000000; PIOB->PIO_IFDR |=  0x08000000; PIOB->PIO_ODR |=  0x08000000; PIOB->PIO_PER |=  0x08000000; }
+
+   // Control signals are ACTIVE LOW (idle is HIGH)
+   // Command/Data: LOW = command, HIGH = data
+   // These are single-instruction operations and always inline
+   #define RD_ACTIVE  RD_PORT->PIO_CODR |= RD_MASK
+   #define RD_IDLE    RD_PORT->PIO_SODR |= RD_MASK
+   #define WR_ACTIVE  WR_PORT->PIO_CODR |= WR_MASK
+   #define WR_IDLE    WR_PORT->PIO_SODR |= WR_MASK
+   #define CD_COMMAND CD_PORT->PIO_CODR |= CD_MASK
+   #define CD_DATA    CD_PORT->PIO_SODR |= CD_MASK
+   #define CS_ACTIVE  CS_PORT->PIO_CODR |= CS_MASK
+   #define CS_IDLE    CS_PORT->PIO_SODR |= CS_MASK
+
+
+#else // Due w/Breakout board
+
+    #define write8inline(d) { \
+		PIO_Set(PIOC, (((d) & 0xFF)<<1)); \
+		PIO_Clear(PIOC, (((~d) & 0xFF)<<1)); \
+		WR_STROBE; }
+
+    #define read8inline(result) { \
+		RD_ACTIVE;   \
+		delayMicroseconds(1);      \
+		result = ((PIOC->PIO_PDSR & 0x1FE) >> 1); \
+		RD_IDLE;}
+
+    #define setWriteDirInline() { \
+	    PIOC->PIO_MDDR |=  0x000001FE; /*PIOC->PIO_SODR |=  0x000001FE;*/ PIOC->PIO_OER |=  0x000001FE; PIOC->PIO_PER |=  0x000001FE; }
+
+    #define setReadDirInline() { \
+		pmc_enable_periph_clk( ID_PIOC ) ; \
+		PIOC->PIO_PUDR |=  0x000001FE; PIOC->PIO_IFDR |=  0x000001FE; PIOC->PIO_ODR |=  0x000001FE; PIOC->PIO_PER |=  0x000001FE; }
+
+    // When using the TFT breakout board, control pins are configurable.
+    #define RD_ACTIVE	rdPort->PIO_CODR |= rdPinSet		//PIO_Clear(rdPort, rdPinSet)
+    #define RD_IDLE		rdPort->PIO_SODR |= rdPinSet		//PIO_Set(rdPort, rdPinSet)	
+    #define WR_ACTIVE	wrPort->PIO_CODR |= wrPinSet		//PIO_Clear(wrPort, wrPinSet)
+    #define WR_IDLE		wrPort->PIO_SODR |= wrPinSet		//PIO_Set(wrPort, wrPinSet)
+    #define CD_COMMAND	cdPort->PIO_CODR |= cdPinSet		//PIO_Clear(cdPort, cdPinSet)
+    #define CD_DATA		cdPort->PIO_SODR |= cdPinSet		//PIO_Set(cdPort, cdPinSet)
+    #define CS_ACTIVE	csPort->PIO_CODR |= csPinSet		//PIO_Clear(csPort, csPinSet)
+    #define CS_IDLE		csPort->PIO_SODR |= csPinSet		//PIO_Set(csPort, csPinSet)
+
+ #endif
+
+
 #else

 #error "Board type unsupported / not recognized"

 #endif

-// Stuff common to all Arduino board types:
+#if !defined(__SAM3X8E__)
+// Stuff common to all Arduino AVR board types:

 #ifdef USE_ADAFRUIT_SHIELD_PINOUT

@ -274,6 +413,17 @@
 #define CS_ACTIVE  CS_PORT &= ~CS_MASK
 #define CS_IDLE    CS_PORT |=  CS_MASK

+#elif defined(CORE_ADAX) || defined(CORE_MICROTOUCHX)
+
+ #define RD_ACTIVE  ((PORT_t*)rdPort)->OUTCLR = rdPinSet
+ #define RD_IDLE    ((PORT_t*)rdPort)->OUTSET = rdPinSet
+ #define WR_ACTIVE  ((PORT_t*)wrPort)->OUTCLR = wrPinSet
+ #define WR_IDLE    ((PORT_t*)wrPort)->OUTSET = wrPinSet
+ #define CD_COMMAND ((PORT_t*)cdPort)->OUTCLR = cdPinSet
+ #define CD_DATA    ((PORT_t*)cdPort)->OUTSET = cdPinSet
+ #define CS_ACTIVE  ((PORT_t*)csPort)->OUTCLR = csPinSet
+ #define CS_IDLE    ((PORT_t*)csPort)->OUTSET = csPinSet
+
 #else // Breakout board

 // When using the TFT breakout board, control pins are configurable.
@ -285,30 +435,40 @@
 #define CD_DATA    *cdPort |=  cdPinSet
 #define CS_ACTIVE  *csPort &=  csPinUnset
 #define CS_IDLE    *csPort |=  csPinSet
-
+#endif
 #endif

 // Data write strobe, ~2 instructions and always inline
-#define WR_STROBE { WR_ACTIVE; WR_IDLE; }
+#define WR_STROBE do { WR_ACTIVE; WR_IDLE; } while (0)

 // These higher-level operations are usually functionalized,
 // except on Mega where's there's gobs and gobs of program space.

 // Set value of TFT register: 8-bit address, 8-bit value
-#define writeRegister8inline(a, d) { \
-  CD_COMMAND; write8(a); CD_DATA; write8(d); }
+#define writeRegister8inline(a, d) do { \
+  CD_COMMAND; write8(a); CD_DATA; write8(d); } while (0)

 // Set value of TFT register: 16-bit address, 16-bit value
 // See notes at top about macro expansion, hence hi & lo temp vars
-#define writeRegister16inline(a, d) { \
+#define writeRegister16inline(a, d) do { \
  uint8_t hi, lo; \
  hi = (a) >> 8; lo = (a); CD_COMMAND; write8(hi); write8(lo); \
-  hi = (d) >> 8; lo = (d); CD_DATA   ; write8(hi); write8(lo); }
+  hi = (d) >> 8; lo = (d); CD_DATA   ; write8(hi); write8(lo); } while (0)
+
+// Set value of TFT register: 8-bit address, 32-bit value
+// only used for ID_9341
+// See notes at top about macro expansion, hence hi & lo temp vars
+#define writeRegister32inline(a, d) do { \
+  CS_ACTIVE; CD_COMMAND;\
+  write8(a);\
+  CD_DATA;\
+  write8(d >> 24); write8(d >> 16); write8(d >> 8); write8(d); \
+  CS_IDLE; } while (0)

 // Set value of 2 TFT registers: Two 8-bit addresses (hi & lo), 16-bit value
-#define writeRegisterPairInline(aH, aL, d) { \
+#define writeRegisterPairInline(aH, aL, d) do { \
  uint8_t hi = (d) >> 8, lo = (d); \
  CD_COMMAND; write8(aH); CD_DATA; write8(hi); \
-  CD_COMMAND; write8(aL); CD_DATA; write8(lo); }
+  CD_COMMAND; write8(aL); CD_DATA; write8(lo); } while(0)

 #endif // _pin_magic_
Author	SHA1	Message	Date
Frank Zhao	bed0a09f54	tested and working with microtouchx	2013-09-23 19:48:31 -04:00
Frank Zhao	67a3652b26	fix baddie in due merge, compilable doesn't work on microtouchx though	2013-09-23 14:02:09 -04:00
driverblock	4a07aa2b42	Restored Restored files mistakenly deleted	2013-09-23 13:21:56 -04:00
driverblock	07b5fb3f10	merge follies	2013-09-23 13:21:34 -04:00
driverblock	a8bf039fa7	Merge branch 'Due' Conflicts: Adafruit_TFTLCD.cpp Adafruit_TFTLCD.h pin_magic.h	2013-09-23 13:20:41 -04:00
Frank Zhao	d019918913	put setup back in constructor, after fixing core	2013-08-20 12:26:03 -04:00
Frank Zhao	d8f88e76a4	updated usage example after fixing core	2013-08-20 02:27:27 -04:00
Frank Zhao	2b2727074e	added reset back in did not affect my testing	2013-08-19 11:30:47 -04:00
Frank Zhao	2f61770de5	made work on XMEGA, requires the "ADAX Core"	2013-08-17 19:09:43 -04:00