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
17 changed files with 1261 additions and 1438 deletions
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@ -1,46 +0,0 @@
-Thank you for opening an issue on an Adafruit Arduino library repository.  To
-improve the speed of resolution please review the following guidelines and
-common troubleshooting steps below before creating the issue:
-
- **Do not use GitHub issues for troubleshooting projects and issues.**  Instead use
-  the forums at http://forums.adafruit.com to ask questions and troubleshoot why
-  something isn't working as expected.  In many cases the problem is a common issue
-  that you will more quickly receive help from the forum community.  GitHub issues
-  are meant for known defects in the code.  If you don't know if there is a defect
-  in the code then start with troubleshooting on the forum first.
-
- **If following a tutorial or guide be sure you didn't miss a step.** Carefully
-  check all of the steps and commands to run have been followed.  Consult the
-  forum if you're unsure or have questions about steps in a guide/tutorial.
-
- **For Arduino projects check these very common issues to ensure they don't apply**:
-
-  - For uploading sketches or communicating with the board make sure you're using
-    a **USB data cable** and **not** a **USB charge-only cable**.  It is sometimes
-    very hard to tell the difference between a data and charge cable!  Try using the
-    cable with other devices or swapping to another cable to confirm it is not
-    the problem.
-
-  - **Be sure you are supplying adequate power to the board.**  Check the specs of
-    your board and plug in an external power supply.  In many cases just
-    plugging a board into your computer is not enough to power it and other
-    peripherals.
-
-  - **Double check all soldering joints and connections.**  Flakey connections
-    cause many mysterious problems.  See the [guide to excellent soldering](https://learn.adafruit.com/adafruit-guide-excellent-soldering/tools) for examples of good solder joints.
-
-  - **Ensure you are using an official Arduino or Adafruit board.** We can't
-    guarantee a clone board will have the same functionality and work as expected
-    with this code and don't support them.
-
-If you're sure this issue is a defect in the code and checked the steps above
-please fill in the following fields to provide enough troubleshooting information.
-You may delete the guideline and text above to just leave the following details:
-
- Arduino board:  **INSERT ARDUINO BOARD NAME/TYPE HERE**
-
- Arduino IDE version (found in Arduino -> About Arduino menu):  **INSERT ARDUINO
-  VERSION HERE**
-
- List the steps to reproduce the problem below (if possible attach a sketch or
-  copy the sketch code in too): **LIST REPRO STEPS BELOW**
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@ -1,26 +0,0 @@
-Thank you for creating a pull request to contribute to Adafruit's GitHub code!
-Before you open the request please review the following guidelines and tips to
-help it be more easily integrated:
-
- **Describe the scope of your change--i.e. what the change does and what parts
-  of the code were modified.**  This will help us understand any risks of integrating
-  the code.
-
- **Describe any known limitations with your change.**  For example if the change
-  doesn't apply to a supported platform of the library please mention it.
-
- **Please run any tests or examples that can exercise your modified code.**  We
-  strive to not break users of the code and running tests/examples helps with this
-  process.
-
-Thank you again for contributing!  We will try to test and integrate the change
-as soon as we can, but be aware we have many GitHub repositories to manage and
-can't immediately respond to every request.  There is no need to bump or check in
-on a pull request (it will clutter the discussion of the request).
-
-Also don't be worried if the request is closed or not integrated--sometimes the
-priorities of Adafruit's GitHub code (education, ease of use) might not match the
-priorities of the pull request.  Don't fret, the open source community thrives on
-forks and GitHub makes it easy to keep your changes in a forked repo.
-
-After reviewing the guidelines above you can delete this text from the pull request.
--- a/Adafruit_TFTLCD.cpp
+++ b/Adafruit_TFTLCD.cpp
--- a/Adafruit_TFTLCD.h
+++ b/Adafruit_TFTLCD.h
@ -7,86 +7,94 @@
 #define _ADAFRUIT_TFTLCD_H_

 #if ARDUINO >= 100
-#include "Arduino.h"
+ #include "Arduino.h"
 #else
-#include "WProgram.h"
+ #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 1
+//#define USE_ADAFRUIT_SHIELD_PINOUT

 class Adafruit_TFTLCD : public Adafruit_GFX {

-public:
+ public:
+
  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);
-  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);
+  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);
+           readPixel(int16_t x, int16_t y),
+           readID(void);
+
  uint32_t readReg(uint8_t r);

-private:
-  void init(),
-  // These items may have previously been defined as macros
-  // in pin_magic.h.  If not, function versions are declared:
+ private:
+
+  void     init(),
+           // These items may have previously been defined as macros
+           // in pin_magic.h.  If not, function versions are declared:
 #ifndef write8
-      write8(uint8_t value),
+           write8(uint8_t value),
 #endif
 #ifndef setWriteDir
-      setWriteDir(void),
+           setWriteDir(void),
 #endif
 #ifndef setReadDir
-      setReadDir(void),
+           setReadDir(void),
 #endif
 #ifndef writeRegister8
-      writeRegister8(uint8_t a, uint8_t d),
+           writeRegister8(uint8_t a, uint8_t d),
 #endif
 #ifndef writeRegister16
-      writeRegister16(uint16_t a, uint16_t d),
+           writeRegister16(uint16_t a, uint16_t d),
+#endif
+#ifndef writeRegister32
+           writeRegister32(uint16_t a, uint32_t d),
 #endif
-      writeRegister24(uint8_t a, uint32_t d),
-      writeRegister32(uint8_t a, uint32_t d),
 #ifndef writeRegisterPair
-      writeRegisterPair(uint8_t aH, uint8_t aL, uint16_t d),
+           writeRegisterPair(uint8_t aH, uint8_t aL, uint16_t d),
 #endif
-      setLR(void), flood(uint16_t color, uint32_t len);
-  uint8_t driver;
+           setLR(void),
+           flood(uint16_t color, uint32_t len);
+  uint8_t  driver;

 #ifndef read8
-  uint8_t read8fn(void);
-#define read8isFunctionalized
+  uint8_t  read8fn(void);
+  #define  read8isFunctionalized
 #endif

 #ifndef USE_ADAFRUIT_SHIELD_PINOUT

-#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
+  #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/README.md
+++ b/README.md
@ -1,19 +0,0 @@
-# Adafruit library for 8-bit TFT LCDs such as ILI9325, ILI9328, etc
-
-This is a library for our Adafruit 16-channel PWM & Servo driver, shield or FeatherWing
-
-<a href="https://www.adafruit.com/products/335"><img src="assets/image.jpg" height="300"/></a>
-
-Pick one up today in the adafruit shop!
-  * https://www.adafruit.com/product/335
-  * https://www.adafruit.com/product/376
-
-These displays use 8-bit parallel to communicate, 12 or 13 pins are required to interface (RST is optional).
-
-Adafruit invests time and resources providing this open source code, please support Adafruit and open-source hardware by purchasing products from Adafruit!
-
-Written by Limor Fried/Ladyada for Adafruit Industries. BSD license, check license.txt for more information. 
-
-All text above must be included in any redistribution
-
-To install, use the Arduino Library Manager and search for "Adafruit 2.8" TFT display Library" and install the library.
--- a/README.txt
+++ b/README.txt
@ -0,0 +1,21 @@
+This is a library for the Adafruit 2.8" TFT display.
+This library works with the Adafruit 2.8" TFT Breakout w/SD card
+  ----> http://www.adafruit.com/products/335
+as well as Adafruit TFT Touch Shield
+  ----> http://www.adafruit.com/products/376
+ 
+Check out the links above for our tutorials and wiring diagrams.
+These displays use 8-bit parallel to communicate, 12 or 13 pins are required
+to interface (RST is optional).
+Adafruit invests time and resources providing this open source code,
+please support Adafruit and open-source hardware by purchasing
+products from Adafruit!
+
+Written by Limor Fried/Ladyada for Adafruit Industries.
+MIT license, all text above must be included in any redistribution
+
+To download. click the DOWNLOADS button in the top right corner, rename the uncompressed folder Adafruit_TFTLCD. Check that the Adafruit_TFTLCD folder contains Adafruit_TFTLCD.cpp and Adafruit_TFTLCD.
+
+Place the Adafruit_TFT library folder your <arduinosketchfolder>/libraries/ folder. You may need to create the libraries subfolder if its your first library. Restart the IDE
+
+Also requires the Adafruit_GFX library for Arduino. https://github.com/adafruit/Adafruit-GFX-Library
--- a/assets/image.jpg
+++ b/assets/image.jpg
--- a/examples/graphicstest/graphicstest.pde
+++ b/examples/graphicstest/graphicstest.pde
@ -53,8 +53,6 @@ void setup(void) {
  Serial.println(F("Using Adafruit 2.8\" TFT Breakout Board Pinout"));
 #endif

-  Serial.print("TFT size is "); Serial.print(tft.width()); Serial.print("x"); Serial.println(tft.height());
-
  tft.reset();

  uint16_t identifier = tft.readID();
@ -65,10 +63,6 @@ void setup(void) {
    Serial.println(F("Found ILI9328 LCD driver"));
  } else if(identifier == 0x7575) {
    Serial.println(F("Found HX8347G LCD driver"));
-  } else if(identifier == 0x9341) {
-    Serial.println(F("Found ILI9341 LCD driver"));
-  } else if(identifier == 0x8357) {
-    Serial.println(F("Found HX8357D LCD driver"));
  } else {
    Serial.print(F("Unknown LCD driver chip: "));
    Serial.println(identifier, HEX);
@ -383,3 +377,4 @@ unsigned long testFilledRoundRects() {

  return micros() - start;
 }
+
--- 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
@ -63,10 +63,6 @@ void setup(void) {
    Serial.println(F("Found ILI9328 LCD driver"));
  } else if(identifier == 0x7575) {
    Serial.println(F("Found HX8347G LCD driver"));
-  } else if(identifier == 0x9341) {
-    Serial.println(F("Found ILI9341 LCD driver"));
-  } else if(identifier == 0x8357) {
-    Serial.println(F("Found HX8357D LCD driver"));
  } else {
    Serial.print(F("Unknown LCD driver chip: "));
    Serial.println(identifier, HEX);
--- a/examples/tftbmp/tftbmp.pde
+++ b/examples/tftbmp/tftbmp.pde
@ -1,12 +1,11 @@
 // BMP-loading example specifically for the TFTLCD breakout board.
 // If using the Arduino shield, use the tftbmp_shield.pde sketch instead!
-// If using an Arduino Mega make sure to use its hardware SPI pins, OR make
-// sure the SD library is configured for 'soft' SPI in the file Sd2Card.h.
+// If using an Arduino Mega, make sure the SD library is configured for
+// 'soft' SPI in the file Sd2Card.h.

 #include <Adafruit_GFX.h>    // Core graphics library
 #include <Adafruit_TFTLCD.h> // Hardware-specific library
 #include <SD.h>
-#include <SPI.h>

 // The control pins for the LCD can be assigned to any digital or
 // analog pins...but we'll use the analog pins as this allows us to
@ -54,10 +53,6 @@ void setup()
    Serial.println(F("Found ILI9328 LCD driver"));
  } else if(identifier == 0x7575) {
    Serial.println(F("Found HX8347G LCD driver"));
-  } else if(identifier == 0x9341) {
-    Serial.println(F("Found ILI9341 LCD driver"));
-  } else if(identifier == 0x8357) {
-    Serial.println(F("Found HX8357D LCD driver"));
  } else {
    Serial.print(F("Unknown LCD driver chip: "));
    Serial.println(identifier, HEX);
--- a/examples/tftbmp_shield/tftbmp_shield.pde
+++ b/examples/tftbmp_shield/tftbmp_shield.pde
@ -1,8 +1,7 @@
 // BMP-loading example specifically for the TFTLCD Arduino shield.
 // If using the breakout board, use the tftbmp.pde sketch instead!
-// If using an Arduino Mega and your sheild does not use the ICSP header for 
-// SPI, make sure the SD library is configured for 'soft' SPI in the file Sd2Card.h.
-// If in doubt, update the library to use 'soft' SPI.
+// If using an Arduino Mega, make sure the SD library is configured for
+// 'soft' SPI in the file Sd2Card.h.

 #include <Adafruit_GFX.h>    // Core graphics library
 #include <Adafruit_TFTLCD.h> // Hardware-specific library
@ -30,8 +29,6 @@ void setup()
    Serial.println(F("Found ILI9328 LCD driver"));
  } else if(identifier == 0x7575) {
    Serial.println(F("Found HX8347G LCD driver"));
-  } else if(identifier == 0x9341) {
-    Serial.println(F("Found ILI9341 LCD driver"));
  } else {
    Serial.print(F("Unknown LCD driver chip: "));
    Serial.println(identifier, HEX);
--- a/examples/tftpaint/tftpaint.ino
+++ b/examples/tftpaint/tftpaint.ino
@ -97,19 +97,9 @@ void setup(void) {
    Serial.println(F("Found ILI9328 LCD driver"));
  } else if(identifier == 0x7575) {
    Serial.println(F("Found HX8347G LCD driver"));
-  } else if(identifier == 0x9341) {
-    Serial.println(F("Found ILI9341 LCD driver"));
-  } else if(identifier == 0x8357) {
-    Serial.println(F("Found HX8357D LCD driver"));
  } else {
    Serial.print(F("Unknown LCD driver chip: "));
    Serial.println(identifier, HEX);
-    Serial.println(F("If using the Adafruit 2.8\" TFT Arduino shield, the line:"));
-    Serial.println(F("  #define USE_ADAFRUIT_SHIELD_PINOUT"));
-    Serial.println(F("should appear in the library header (Adafruit_TFT.h)."));
-    Serial.println(F("If using the breakout board, it should NOT be #defined!"));
-    Serial.println(F("Also if using the breakout, double-check that all wiring"));
-    Serial.println(F("matches the tutorial."));
    return;
  }

@ -137,7 +127,7 @@ void setup(void) {
 void loop()
 {
  digitalWrite(13, HIGH);
-  TSPoint p = ts.getPoint();
+  Point p = ts.getPoint();
  digitalWrite(13, LOW);

  // if sharing pins, you'll need to fix the directions of the touchscreen pins
--- a/examples/tftpaint_shield/tftpaint_shield.ino
+++ b/examples/tftpaint_shield/tftpaint_shield.ino
@ -103,7 +103,7 @@ void setup(void) {
 void loop()
 {
  digitalWrite(13, HIGH);
-  TSPoint p = ts.getPoint();
+  Point p = ts.getPoint();
  digitalWrite(13, LOW);

  // if sharing pins, you'll need to fix the directions of the touchscreen pins
--- a/library.properties
+++ b/library.properties
@ -1,10 +0,0 @@
-name=Adafruit TFTLCD Library
-version=1.0.3
-author=Adafruit
-maintainer=Adafruit <info@adafruit.com>
-sentence=Adafruit 2.8" TFT display Library
-paragraph=Adafruit 2.8" TFT display Library
-category=Display
-url=https://github.com/adafruit/TFTLCD-Library
-architectures=*
-depends=Adafruit GFX Library
--- a/pin_magic.h
+++ b/pin_magic.h
@ -54,417 +54,345 @@
 // This code burns 7 cycles (437.5 nS) doing nothing; the RJMPs are
 // equivalent to two NOPs each, final NOP burns the 7th cycle, and the
 // last line is a radioactive mutant emoticon.
-#define DELAY7                                                                 \
-  asm volatile("rjmp .+0"                                                      \
-               "\n\t"                                                          \
-               "rjmp .+0"                                                      \
-               "\n\t"                                                          \
-               "rjmp .+0"                                                      \
-               "\n\t"                                                          \
-               "nop"                                                           \
-               "\n" ::);
+#define DELAY7        \
+  asm volatile(      \
+    "rjmp .+0" "\n\t" \
+    "rjmp .+0" "\n\t" \
+    "rjmp .+0" "\n\t" \
+    "nop"      "\n"   \
+    ::);

-#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega328P__) ||               \
-    defined(__AVR_ATmega328__) || defined(__AVR_ATmega8__)
+// 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" \
+    "nop"      "\n"   \
+    ::);

-// Arduino Uno, Duemilanove, etc.
+#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega328P__) || defined (__AVR_ATmega328__) || defined(__AVR_ATmega8__)

-#ifdef USE_ADAFRUIT_SHIELD_PINOUT
+ // Arduino Uno, Duemilanove, etc.

-// LCD control lines:
-// RD (read), WR (write), CD (command/data), CS (chip select)
-#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
-#define CS_MASK B00001000
+ #ifdef USE_ADAFRUIT_SHIELD_PINOUT

-// These are macros for I/O operations...
+  // LCD control lines:
+  // RD (read), WR (write), CD (command/data), CS (chip select)
+  #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
+  #define CS_MASK B00001000

-// Write 8-bit value to LCD data lines
-#define write8inline(d)                                                        \
-  {                                                                            \
-    PORTD = (PORTD & B00101111) | ((d)&B11010000);                             \
-    PORTB = (PORTB & B11010000) | ((d)&B00101111);                             \
-    WR_STROBE;                                                                 \
-  } // STROBEs are defined later
+  // These are macros for I/O operations...

-// Read 8-bit value from LCD data lines.  The signle argument
-// is a destination variable; this isn't a function and doesn't
-// return a value in the conventional sense.
-#define read8inline(result)                                                    \
-  {                                                                            \
-    RD_ACTIVE;                                                                 \
-    DELAY7;                                                                    \
-    result = (PIND & B11010000) | (PINB & B00101111);                          \
-    RD_IDLE;                                                                   \
-  }
+  // Write 8-bit value to LCD data lines
+  #define write8inline(d) {                          \
+    PORTD = (PORTD & B00101111) | ((d) & B11010000); \
+    PORTB = (PORTB & B11010000) | ((d) & B00101111); \
+    WR_STROBE; } // STROBEs are defined later

-// These set the PORT directions as required before the write and read
-// operations.  Because write operations are much more common than reads,
-// the data-reading functions in the library code set the PORT(s) to
-// input before a read, and restore them back to the write state before
-// returning.  This avoids having to set it for output inside every
-// drawing method.  The default state has them initialized for writes.
-#define setWriteDirInline()                                                    \
-  {                                                                            \
-    DDRD |= B11010000;                                                         \
-    DDRB |= B00101111;                                                         \
-  }
-#define setReadDirInline()                                                     \
-  {                                                                            \
-    DDRD &= ~B11010000;                                                        \
-    DDRB &= ~B00101111;                                                        \
-  }
+  // Read 8-bit value from LCD data lines.  The signle argument
+  // is a destination variable; this isn't a function and doesn't
+  // return a value in the conventional sense.
+  #define read8inline(result) {                       \
+    RD_ACTIVE;                                        \
+    DELAY7;                                           \
+    result = (PIND & B11010000) | (PINB & B00101111); \
+    RD_IDLE; }

-#else // Uno w/Breakout board
+  // These set the PORT directions as required before the write and read
+  // operations.  Because write operations are much more common than reads,
+  // the data-reading functions in the library code set the PORT(s) to
+  // input before a read, and restore them back to the write state before
+  // returning.  This avoids having to set it for output inside every
+  // drawing method.  The default state has them initialized for writes.
+  #define setWriteDirInline() { DDRD |=  B11010000; DDRB |=  B00101111; }
+  #define setReadDirInline()  { DDRD &= ~B11010000; DDRB &= ~B00101111; }

-#define write8inline(d)                                                        \
-  {                                                                            \
-    PORTD = (PORTD & B00000011) | ((d)&B11111100);                             \
-    PORTB = (PORTB & B11111100) | ((d)&B00000011);                             \
-    WR_STROBE;                                                                 \
-  }
-#define read8inline(result)                                                    \
-  {                                                                            \
-    RD_ACTIVE;                                                                 \
-    DELAY7;                                                                    \
-    result = (PIND & B11111100) | (PINB & B00000011);                          \
-    RD_IDLE;                                                                   \
-  }
-#define setWriteDirInline()                                                    \
-  {                                                                            \
-    DDRD |= B11111100;                                                         \
-    DDRB |= B00000011;                                                         \
-  }
-#define setReadDirInline()                                                     \
-  {                                                                            \
-    DDRD &= ~B11111100;                                                        \
-    DDRB &= ~B00000011;                                                        \
-  }
+ #else // Uno w/Breakout board

-#endif
+  #define write8inline(d) {                          \
+    PORTD = (PORTD & B00000011) | ((d) & B11111100); \
+    PORTB = (PORTB & B11111100) | ((d) & B00000011); \
+    WR_STROBE; }
+  #define read8inline(result) {                       \
+    RD_ACTIVE;                                        \
+    DELAY7;                                           \
+    result = (PIND & B11111100) | (PINB & B00000011); \
+    RD_IDLE; }
+  #define setWriteDirInline() { DDRD |=  B11111100; DDRB |=  B00000011; }
+  #define setReadDirInline()  { DDRD &= ~B11111100; DDRB &= ~B00000011; }

-// As part of the inline control, macros reference other macros...if any
-// of these are left undefined, an equivalent function version (non-inline)
-// is declared later.  The Uno has a moderate amount of program space, so
-// only write8() is inlined -- that one provides the most performance
-// benefit, but unfortunately also generates the most bloat.  This is
-// why only certain cases are inlined for each board.
-#define write8 write8inline
+ #endif

-#elif defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2561__) ||            \
-    defined(__AVR_ATmega2560__) || defined(__AVR_ATmega1280__)
+  // As part of the inline control, macros reference other macros...if any
+  // of these are left undefined, an equivalent function version (non-inline)
+  // is declared later.  The Uno has a moderate amount of program space, so
+  // only write8() is inlined -- that one provides the most performance
+  // benefit, but unfortunately also generates the most bloat.  This is
+  // why only certain cases are inlined for each board.
+  #define write8 write8inline

-// Arduino Mega, ADK, etc.
+#elif defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2561__) || defined(__AVR_ATmega2560__) || defined(__AVR_ATmega1280__) 

-#ifdef USE_ADAFRUIT_SHIELD_PINOUT
+ // Arduino Mega, ADK, etc.

-#define RD_PORT PORTF
-#define WR_PORT PORTF
-#define CD_PORT PORTF
-#define CS_PORT PORTF
-#define RD_MASK B00000001
-#define WR_MASK B00000010
-#define CD_MASK B00000100
-#define CS_MASK B00001000
+ #ifdef USE_ADAFRUIT_SHIELD_PINOUT

-#define write8inline(d)                                                        \
-  {                                                                            \
-    PORTH =                                                                    \
-        (PORTH & B10000111) | (((d)&B11000000) >> 3) | (((d)&B00000011) << 5); \
-    PORTB = (PORTB & B01001111) | (((d)&B00101100) << 2);                      \
-    PORTG = (PORTG & B11011111) | (((d)&B00010000) << 1);                      \
-    WR_STROBE;                                                                 \
-  }
-#define read8inline(result)                                                    \
-  {                                                                            \
-    RD_ACTIVE;                                                                 \
-    DELAY7;                                                                    \
-    result = ((PINH & B00011000) << 3) | ((PINB & B10110000) >> 2) |           \
-             ((PING & B00100000) >> 1) | ((PINH & B01100000) >> 5);            \
-    RD_IDLE;                                                                   \
-  }
-#define setWriteDirInline()                                                    \
-  {                                                                            \
-    DDRH |= B01111000;                                                         \
-    DDRB |= B10110000;                                                         \
-    DDRG |= B00100000;                                                         \
-  }
-#define setReadDirInline()                                                     \
-  {                                                                            \
-    DDRH &= ~B01111000;                                                        \
-    DDRB &= ~B10110000;                                                        \
-    DDRG &= ~B00100000;                                                        \
-  }
+  #define RD_PORT PORTF
+  #define WR_PORT PORTF
+  #define CD_PORT PORTF
+  #define CS_PORT PORTF
+  #define RD_MASK B00000001
+  #define WR_MASK B00000010
+  #define CD_MASK B00000100
+  #define CS_MASK B00001000

-#else // Mega w/Breakout board
+  #define write8inline(d) {                                              \
+    PORTH = (PORTH&B10000111)|(((d)&B11000000)>>3)|(((d)&B00000011)<<5); \
+    PORTB = (PORTB&B01001111)|(((d)&B00101100)<<2);                      \
+    PORTG = (PORTG&B11011111)|(((d)&B00010000)<<1);                      \
+    WR_STROBE; }
+  #define read8inline(result) {                                      \
+    RD_ACTIVE;                                                       \
+    DELAY7;                                                          \
+    result = ((PINH & B00011000) << 3) | ((PINB & B10110000) >> 2) | \
+             ((PING & B00100000) >> 1) | ((PINH & B01100000) >> 5);  \
+    RD_IDLE; }
+  #define setWriteDirInline() {                                   \
+    DDRH |=  B01111000; DDRB |=  B10110000; DDRG |=  B00100000; }
+  #define setReadDirInline()  {                                   \
+    DDRH &= ~B01111000; DDRB &= ~B10110000; DDRG &= ~B00100000; }

-#define write8inline(d)                                                        \
-  {                                                                            \
-    PORTA = (d);                                                               \
-    WR_STROBE;                                                                 \
-  }
-#define read8inline(result)                                                    \
-  {                                                                            \
-    RD_ACTIVE;                                                                 \
-    DELAY7;                                                                    \
-    result = PINA;                                                             \
-    RD_IDLE;                                                                   \
-  }
-#define setWriteDirInline() DDRA = 0xff
-#define setReadDirInline() DDRA = 0
+ #else // Mega w/Breakout board

-#endif
+  #define write8inline(d)   { PORTA = (d); WR_STROBE; }
+  #define read8inline(result) { \
+    RD_ACTIVE;                  \
+    DELAY7;                     \
+    result = PINA;              \
+    RD_IDLE; }
+  #define setWriteDirInline() DDRA  = 0xff
+  #define setReadDirInline()  DDRA  = 0

-// All of the functions are inlined on the Arduino Mega.  When using the
-// breakout board, the macro versions aren't appreciably larger than the
-// function equivalents, and they're super simple and fast.  When using
-// the shield, the macros become pretty complicated...but this board has
-// so much code space, the macros are used anyway.  If you need to free
-// up program space, some macros can be removed, at a minor cost in speed.
-#define write8 write8inline
-#define read8 read8inline
-#define setWriteDir setWriteDirInline
-#define setReadDir setReadDirInline
-#define writeRegister8 writeRegister8inline
-#define writeRegister16 writeRegister16inline
-#define writeRegisterPair writeRegisterPairInline
+ #endif
+
+  // All of the functions are inlined on the Arduino Mega.  When using the
+  // breakout board, the macro versions aren't appreciably larger than the
+  // function equivalents, and they're super simple and fast.  When using
+  // the shield, the macros become pretty complicated...but this board has
+  // so much code space, the macros are used anyway.  If you need to free
+  // up program space, some macros can be removed, at a minor cost in speed.
+  #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(__AVR_ATmega32U4__)

-// Arduino Leonardo
+ // Arduino Leonardo

-#ifdef USE_ADAFRUIT_SHIELD_PINOUT
+ #ifdef USE_ADAFRUIT_SHIELD_PINOUT

-#define RD_PORT PORTF
-#define WR_PORT PORTF
-#define CD_PORT PORTF
-#define CS_PORT PORTF
-#define RD_MASK B10000000
-#define WR_MASK B01000000
-#define CD_MASK B00100000
-#define CS_MASK B00010000
+  #define RD_PORT PORTF
+  #define WR_PORT PORTF
+  #define CD_PORT PORTF
+  #define CS_PORT PORTF
+  #define RD_MASK B10000000
+  #define WR_MASK B01000000
+  #define CD_MASK B00100000
+  #define CS_MASK B00010000

-#define write8inline(d)                                                        \
-  {                                                                            \
-    PORTE = (PORTE & B10111111) | (((d)&B10000000) >> 1);                      \
-    PORTD = (PORTD & B01101111) | (((d)&B01000000) << 1) | ((d)&B00010000);    \
-    PORTC = (PORTC & B01111111) | (((d)&B00100000) << 2);                      \
-    PORTB = (PORTB & B00001111) | (((d)&B00001111) << 4);                      \
-    WR_STROBE;                                                                 \
-  }
-#define read8inline(result)                                                    \
-  {                                                                            \
-    RD_ACTIVE;                                                                 \
-    DELAY7;                                                                    \
-    result = ((PINE & B01000000) << 1) | ((PIND & B10000000) >> 1) |           \
-             ((PINC & B10000000) >> 2) | ((PINB & B11110000) >> 4) |           \
-             (PIND & B00010000);                                               \
-    RD_IDLE;                                                                   \
-  }
-#define setWriteDirInline()                                                    \
-  {                                                                            \
-    DDRE |= B01000000;                                                         \
-    DDRD |= B10010000;                                                         \
-    DDRC |= B10000000;                                                         \
-    DDRB |= B11110000;                                                         \
-  }
-#define setReadDirInline()                                                     \
-  {                                                                            \
-    DDRE &= ~B01000000;                                                        \
-    DDRD &= ~B10010000;                                                        \
-    DDRC &= ~B10000000;                                                        \
-    DDRB &= ~B11110000;                                                        \
-  }
+  #define write8inline(d) {                                                   \
+    PORTE = (PORTE & B10111111) | (((d) & B10000000)>>1);                     \
+    PORTD = (PORTD & B01101111) | (((d) & B01000000)<<1) | ((d) & B00010000); \
+    PORTC = (PORTC & B01111111) | (((d) & B00100000)<<2);                     \
+    PORTB = (PORTB & B00001111) | (((d) & B00001111)<<4);                     \
+    WR_STROBE; }
+  #define read8inline(result) {                                      \
+    RD_ACTIVE;                                                       \
+    DELAY7;                                                          \
+    result = ((PINE & B01000000) << 1) | ((PIND & B10000000) >> 1) | \
+             ((PINC & B10000000) >> 2) | ((PINB & B11110000) >> 4) | \
+              (PIND & B00010000);                                    \
+    RD_IDLE; }
+  #define setWriteDirInline() {               \
+    DDRE |=  B01000000; DDRD |=  B10010000;   \
+    DDRC |=  B10000000; DDRB |=  B11110000; }
+  #define setReadDirInline() {                \
+    DDRE &= ~B01000000; DDRD &= ~B10010000;   \
+    DDRC &= ~B10000000; DDRB &= ~B11110000; }

-#else // Leonardo w/Breakout board
+ #else // Leonardo w/Breakout board

-#define write8inline(d)                                                        \
-  {                                                                            \
-    uint8_t dr1 = (d) >> 1, dl1 = (d) << 1;                                    \
-    PORTE = (PORTE & B10111111) | (dr1 & B01000000);                           \
-    PORTD = (PORTD & B01101100) | (dl1 & B10000000) | (((d)&B00001000) >> 3) | \
-            (dr1 & B00000010) | ((d)&B00010000);                               \
-    PORTC = (PORTC & B10111111) | (dl1 & B01000000);                           \
-    PORTB = (PORTB & B11001111) | (((d)&B00000011) << 4);                      \
-    WR_STROBE;                                                                 \
-  }
-#define read8inline(result)                                                    \
-  {                                                                            \
-    RD_ACTIVE;                                                                 \
-    DELAY7;                                                                    \
-    result = (((PINE & B01000000) | (PIND & B00000010)) << 1) |                \
-             (((PINC & B01000000) | (PIND & B10000000)) >> 1) |                \
-             ((PIND & B00000001) << 3) | ((PINB & B00110000) >> 4) |           \
-             (PIND & B00010000);                                               \
-    RD_IDLE;                                                                   \
-  }
-#define setWriteDirInline()                                                    \
-  {                                                                            \
-    DDRE |= B01000000;                                                         \
-    DDRD |= B10010011;                                                         \
-    DDRC |= B01000000;                                                         \
-    DDRB |= B00110000;                                                         \
-  }
-#define setReadDirInline()                                                     \
-  {                                                                            \
-    DDRE &= ~B01000000;                                                        \
-    DDRD &= ~B10010011;                                                        \
-    DDRC &= ~B01000000;                                                        \
-    DDRB &= ~B00110000;                                                        \
-  }
+  #define write8inline(d) {                                                   \
+    uint8_t dr1 = (d) >> 1, dl1 = (d) << 1;                                   \
+    PORTE = (PORTE & B10111111) | (dr1 & B01000000);                          \
+    PORTD = (PORTD & B01101100) | (dl1 & B10000000) | (((d) & B00001000)>>3) |\
+                                  (dr1 & B00000010) |  ((d) & B00010000);     \
+    PORTC = (PORTC & B10111111) | (dl1 & B01000000);                          \
+    PORTB = (PORTB & B11001111) |(((d) & B00000011)<<4);                      \
+    WR_STROBE; }
+  #define read8inline(result) {                                       \
+    RD_ACTIVE;                                                        \
+    DELAY7;                                                           \
+    result = (((PINE & B01000000) | (PIND & B00000010)) << 1) |       \
+             (((PINC & B01000000) | (PIND & B10000000)) >> 1) |       \
+              ((PIND & B00000001) << 3) | ((PINB & B00110000) >> 4) | \
+               (PIND & B00010000);                                    \
+    RD_IDLE; }
+  #define setWriteDirInline() {               \
+    DDRE |=  B01000000; DDRD |=  B10010011;   \
+    DDRC |=  B01000000; DDRB |=  B00110000; }
+  #define setReadDirInline() {                \
+    DDRE &= ~B01000000; DDRD &= ~B10010011;   \
+    DDRC &= ~B01000000; DDRB &= ~B00110000; }

-#endif
+ #endif

-// On the Leonardo, only the write8() macro is used -- though even that
-// might be excessive given the code size and available program space
-// on this board.  You may need to disable this to get any sizable
-// program to compile.
-#define write8 write8inline
+  // On the Leonardo, only the write8() macro is used -- though even that
+  // might be excessive given the code size and available program space
+  // on this board.  You may need to disable this to get any sizable
+  // 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
+ #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 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 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 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 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;                                               \
-  }
+  #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

-// 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 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 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 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;                                               \
-  }
+    #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)
+    // 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

-#endif

 #else

-#error "Board type unsupported / not recognized"
+ #error "Board type unsupported / not recognized"

 #endif

@ -473,81 +401,74 @@

 #ifdef USE_ADAFRUIT_SHIELD_PINOUT

-// 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 &= ~RD_MASK
-#define RD_IDLE RD_PORT |= RD_MASK
-#define WR_ACTIVE WR_PORT &= ~WR_MASK
-#define WR_IDLE WR_PORT |= WR_MASK
-#define CD_COMMAND CD_PORT &= ~CD_MASK
-#define CD_DATA CD_PORT |= CD_MASK
-#define CS_ACTIVE CS_PORT &= ~CS_MASK
-#define CS_IDLE CS_PORT |= CS_MASK
+ // 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 &= ~RD_MASK
+ #define RD_IDLE    RD_PORT |=  RD_MASK
+ #define WR_ACTIVE  WR_PORT &= ~WR_MASK
+ #define WR_IDLE    WR_PORT |=  WR_MASK
+ #define CD_COMMAND CD_PORT &= ~CD_MASK
+ #define CD_DATA    CD_PORT |=  CD_MASK
+ #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.
-#define RD_ACTIVE *rdPort &= rdPinUnset
-#define RD_IDLE *rdPort |= rdPinSet
-#define WR_ACTIVE *wrPort &= wrPinUnset
-#define WR_IDLE *wrPort |= wrPinSet
-#define CD_COMMAND *cdPort &= cdPinUnset
-#define CD_DATA *cdPort |= cdPinSet
-#define CS_ACTIVE *csPort &= csPinUnset
-#define CS_IDLE *csPort |= csPinSet
-
+ // When using the TFT breakout board, control pins are configurable.
+ #define RD_ACTIVE  *rdPort &=  rdPinUnset
+ #define RD_IDLE    *rdPort |=  rdPinSet
+ #define WR_ACTIVE  *wrPort &=  wrPinUnset
+ #define WR_IDLE    *wrPort |=  wrPinSet
+ #define CD_COMMAND *cdPort &=  cdPinUnset
+ #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)                                            \
-  {                                                                            \
-    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);                                                                \
-  }
+#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); } 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)                                     \
-  {                                                                            \
-    uint8_t hi = (d) >> 8, lo = (d);                                           \
-    CD_COMMAND;                                                                \
-    write8(aH);                                                                \
-    CD_DATA;                                                                   \
-    write8(hi);                                                                \
-    CD_COMMAND;                                                                \
-    write8(aL);                                                                \
-    CD_DATA;                                                                   \
-    write8(lo);                                                                \
-  }
+#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); } while(0)

 #endif // _pin_magic_
--- a/registers.h
+++ b/registers.h
@ -1,167 +0,0 @@
-// Register names from Peter Barrett's Microtouch code
-#define ILI932X_START_OSC 0x00
-#define ILI932X_DRIV_OUT_CTRL 0x01
-#define ILI932X_DRIV_WAV_CTRL 0x02
-#define ILI932X_ENTRY_MOD 0x03
-#define ILI932X_RESIZE_CTRL 0x04
-#define ILI932X_DISP_CTRL1 0x07
-#define ILI932X_DISP_CTRL2 0x08
-#define ILI932X_DISP_CTRL3 0x09
-#define ILI932X_DISP_CTRL4 0x0A
-#define ILI932X_RGB_DISP_IF_CTRL1 0x0C
-#define ILI932X_FRM_MARKER_POS 0x0D
-#define ILI932X_RGB_DISP_IF_CTRL2 0x0F
-#define ILI932X_POW_CTRL1 0x10
-#define ILI932X_POW_CTRL2 0x11
-#define ILI932X_POW_CTRL3 0x12
-#define ILI932X_POW_CTRL4 0x13
-#define ILI932X_GRAM_HOR_AD 0x20
-#define ILI932X_GRAM_VER_AD 0x21
-#define ILI932X_RW_GRAM 0x22
-#define ILI932X_POW_CTRL7 0x29
-#define ILI932X_FRM_RATE_COL_CTRL 0x2B
-#define ILI932X_GAMMA_CTRL1 0x30
-#define ILI932X_GAMMA_CTRL2 0x31
-#define ILI932X_GAMMA_CTRL3 0x32
-#define ILI932X_GAMMA_CTRL4 0x35
-#define ILI932X_GAMMA_CTRL5 0x36
-#define ILI932X_GAMMA_CTRL6 0x37
-#define ILI932X_GAMMA_CTRL7 0x38
-#define ILI932X_GAMMA_CTRL8 0x39
-#define ILI932X_GAMMA_CTRL9 0x3C
-#define ILI932X_GAMMA_CTRL10 0x3D
-#define ILI932X_HOR_START_AD 0x50
-#define ILI932X_HOR_END_AD 0x51
-#define ILI932X_VER_START_AD 0x52
-#define ILI932X_VER_END_AD 0x53
-#define ILI932X_GATE_SCAN_CTRL1 0x60
-#define ILI932X_GATE_SCAN_CTRL2 0x61
-#define ILI932X_GATE_SCAN_CTRL3 0x6A
-#define ILI932X_PART_IMG1_DISP_POS 0x80
-#define ILI932X_PART_IMG1_START_AD 0x81
-#define ILI932X_PART_IMG1_END_AD 0x82
-#define ILI932X_PART_IMG2_DISP_POS 0x83
-#define ILI932X_PART_IMG2_START_AD 0x84
-#define ILI932X_PART_IMG2_END_AD 0x85
-#define ILI932X_PANEL_IF_CTRL1 0x90
-#define ILI932X_PANEL_IF_CTRL2 0x92
-#define ILI932X_PANEL_IF_CTRL3 0x93
-#define ILI932X_PANEL_IF_CTRL4 0x95
-#define ILI932X_PANEL_IF_CTRL5 0x97
-#define ILI932X_PANEL_IF_CTRL6 0x98
-
-#define HX8347G_COLADDRSTART_HI 0x02
-#define HX8347G_COLADDRSTART_LO 0x03
-#define HX8347G_COLADDREND_HI 0x04
-#define HX8347G_COLADDREND_LO 0x05
-#define HX8347G_ROWADDRSTART_HI 0x06
-#define HX8347G_ROWADDRSTART_LO 0x07
-#define HX8347G_ROWADDREND_HI 0x08
-#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
-#define ILI9341_MADCTL 0x36
-
-#define ILI9341_MADCTL_MY 0x80
-#define ILI9341_MADCTL_MX 0x40
-#define ILI9341_MADCTL_MV 0x20
-#define ILI9341_MADCTL_ML 0x10
-#define ILI9341_MADCTL_RGB 0x00
-#define ILI9341_MADCTL_BGR 0x08
-#define ILI9341_MADCTL_MH 0x04
-
-#define HX8357_NOP 0x00
-#define HX8357_SWRESET 0x01
-#define HX8357_RDDID 0x04
-#define HX8357_RDDST 0x09
-
-#define HX8357B_RDPOWMODE 0x0A
-#define HX8357B_RDMADCTL 0x0B
-#define HX8357B_RDCOLMOD 0x0C
-#define HX8357B_RDDIM 0x0D
-#define HX8357B_RDDSDR 0x0F
-
-#define HX8357_SLPIN 0x10
-#define HX8357_SLPOUT 0x11
-#define HX8357B_PTLON 0x12
-#define HX8357B_NORON 0x13
-
-#define HX8357_INVOFF 0x20
-#define HX8357_INVON 0x21
-#define HX8357_DISPOFF 0x28
-#define HX8357_DISPON 0x29
-
-#define HX8357_CASET 0x2A
-#define HX8357_PASET 0x2B
-#define HX8357_RAMWR 0x2C
-#define HX8357_RAMRD 0x2E
-
-#define HX8357B_PTLAR 0x30
-#define HX8357_TEON 0x35
-#define HX8357_TEARLINE 0x44
-#define HX8357_MADCTL 0x36
-#define HX8357_COLMOD 0x3A
-
-#define HX8357_SETOSC 0xB0
-#define HX8357_SETPWR1 0xB1
-#define HX8357B_SETDISPLAY 0xB2
-#define HX8357_SETRGB 0xB3
-#define HX8357D_SETCOM 0xB6
-
-#define HX8357B_SETDISPMODE 0xB4
-#define HX8357D_SETCYC 0xB4
-#define HX8357B_SETOTP 0xB7
-#define HX8357D_SETC 0xB9
-
-#define HX8357B_SET_PANEL_DRIVING 0xC0
-#define HX8357D_SETSTBA 0xC0
-#define HX8357B_SETDGC 0xC1
-#define HX8357B_SETID 0xC3
-#define HX8357B_SETDDB 0xC4
-#define HX8357B_SETDISPLAYFRAME 0xC5
-#define HX8357B_GAMMASET 0xC8
-#define HX8357B_SETCABC 0xC9
-#define HX8357_SETPANEL 0xCC
-
-#define HX8357B_SETPOWER 0xD0
-#define HX8357B_SETVCOM 0xD1
-#define HX8357B_SETPWRNORMAL 0xD2
-
-#define HX8357B_RDID1 0xDA
-#define HX8357B_RDID2 0xDB
-#define HX8357B_RDID3 0xDC
-#define HX8357B_RDID4 0xDD
-
-#define HX8357D_SETGAMMA 0xE0
-
-#define HX8357B_SETGAMMA 0xC8
-#define HX8357B_SETPANELRELATED 0xE9
-
-#define HX8357B_MADCTL_MY 0x80
-#define HX8357B_MADCTL_MX 0x40
-#define HX8357B_MADCTL_MV 0x20
-#define HX8357B_MADCTL_ML 0x10
-#define HX8357B_MADCTL_RGB 0x00
-#define HX8357B_MADCTL_BGR 0x08
-#define HX8357B_MADCTL_MH 0x04
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