Compare commits

...

19 commits

Author SHA1 Message Date
Melissa LeBlanc-Williams
2f917ad72b bumped version for release 2020-07-27 16:14:06 -07:00
Melissa LeBlanc-Williams
aad1e5e77a
Merge pull request #48 from makermelissa/master
Fix warnings and chip detection
2020-07-27 16:08:49 -07:00
Melissa LeBlanc-Williams
ebc64f235b Fix warnings and chip detection 2020-07-27 15:19:23 -07:00
siddacious
9b701b6d5a
Update library.properties 2020-02-17 18:17:38 -08:00
Limor "Ladyada" Fried
5eb5a21ac9
Merge pull request #42 from manuaatitya/fix-compilation-issue
Fixed Compilation issue due to not datatype assigned for textsize var…
2020-02-07 18:11:14 -05:00
siddacious
f93482daf4
Update library.properties 2020-01-16 11:36:14 -08:00
manu_aatitya
22b7aaf899 Fixed Compilation issue due to not datatype assigned for textsize variable 2020-01-15 21:13:48 +05:30
ladyada
5b2bead71b clang 2020-01-13 19:17:10 -05:00
Limor "Ladyada" Fried
94d08c244f
Merge pull request #39 from dherrada/patch-1
Changed name in library.properties
2019-11-16 22:49:03 -05:00
dherrada
dfded750b1
Changed name 2019-11-16 22:42:48 -05:00
Limor "Ladyada" Fried
4ff23d2e7b
Merge pull request #38 from hoffmannjan/master
travis + library.properties + image + readme
2019-08-10 16:20:30 -04:00
Jan Hoffmann
838ed8df3b
Update README.md 2019-08-08 18:09:10 +02:00
Jan Hoffmann
7462aa6034 travis disabled 2019-08-08 17:55:10 +02:00
Jan Hoffmann
2006f6a454 pde -> ino 2019-08-07 17:00:39 +02:00
Jan Hoffmann
1f6ced8df5 travis fixes 2019-08-07 16:56:44 +02:00
Jan Hoffmann
40db73b341 removed readme.txt 2019-08-07 16:32:39 +02:00
Jan Hoffmann
96d067bdc7 added image 2019-08-07 16:30:51 +02:00
Jan Hoffmann
4b120b2fc4 added readme 2019-08-07 16:30:17 +02:00
Jan Hoffmann
99aba1fb73 added travis and library properties 2019-08-07 16:26:38 +02:00
12 changed files with 1172 additions and 904 deletions

File diff suppressed because it is too large Load diff

View file

@ -7,9 +7,9 @@
#define _ADAFRUIT_TFTLCD_H_ #define _ADAFRUIT_TFTLCD_H_
#if ARDUINO >= 100 #if ARDUINO >= 100
#include "Arduino.h" #include "Arduino.h"
#else #else
#include "WProgram.h" #include "WProgram.h"
#endif #endif
#include <Adafruit_GFX.h> #include <Adafruit_GFX.h>
@ -21,78 +21,72 @@
class Adafruit_TFTLCD : public Adafruit_GFX { 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(uint8_t cs, uint8_t cd, uint8_t wr, uint8_t rd, uint8_t rst);
Adafruit_TFTLCD(void); Adafruit_TFTLCD(void);
void begin(uint16_t id = 0x9325); void begin(uint16_t id = 0x9325);
void drawPixel(int16_t x, int16_t y, uint16_t color); 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 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 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 fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t c);
void fillScreen(uint16_t color); void fillScreen(uint16_t color);
void reset(void); void reset(void);
void setRegisters8(uint8_t *ptr, uint8_t n); void setRegisters8(uint8_t *ptr, uint8_t n);
void setRegisters16(uint16_t *ptr, uint8_t n); void setRegisters16(uint16_t *ptr, uint8_t n);
void setRotation(uint8_t x); void setRotation(uint8_t x);
// These methods are public in order for BMP examples to work: // These methods are public in order for BMP examples to work:
void setAddrWindow(int x1, int y1, int x2, int y2); void setAddrWindow(int x1, int y1, int x2, int y2);
void pushColors(uint16_t *data, uint8_t len, boolean first); void pushColors(uint16_t *data, uint8_t len, boolean first);
uint16_t color565(uint8_t r, uint8_t g, uint8_t b), uint16_t color565(uint8_t r, uint8_t g, uint8_t b),
readPixel(int16_t x, int16_t y), readPixel(int16_t x, int16_t y), readID(void);
readID(void);
uint32_t readReg(uint8_t r); uint32_t readReg(uint8_t r);
private: private:
void init(),
void init(), // These items may have previously been defined as macros
// These items may have previously been defined as macros // in pin_magic.h. If not, function versions are declared:
// in pin_magic.h. If not, function versions are declared:
#ifndef write8 #ifndef write8
write8(uint8_t value), write8(uint8_t value),
#endif #endif
#ifndef setWriteDir #ifndef setWriteDir
setWriteDir(void), setWriteDir(void),
#endif #endif
#ifndef setReadDir #ifndef setReadDir
setReadDir(void), setReadDir(void),
#endif #endif
#ifndef writeRegister8 #ifndef writeRegister8
writeRegister8(uint8_t a, uint8_t d), writeRegister8(uint8_t a, uint8_t d),
#endif #endif
#ifndef writeRegister16 #ifndef writeRegister16
writeRegister16(uint16_t a, uint16_t d), writeRegister16(uint16_t a, uint16_t d),
#endif #endif
writeRegister24(uint8_t a, uint32_t d), writeRegister24(uint8_t a, uint32_t d),
writeRegister32(uint8_t a, uint32_t d), writeRegister32(uint8_t a, uint32_t d),
#ifndef writeRegisterPair #ifndef writeRegisterPair
writeRegisterPair(uint8_t aH, uint8_t aL, uint16_t d), writeRegisterPair(uint8_t aH, uint8_t aL, uint16_t d),
#endif #endif
setLR(void), setLR(void), flood(uint16_t color, uint32_t len);
flood(uint16_t color, uint32_t len); uint8_t driver;
uint8_t driver;
#ifndef read8 #ifndef read8
uint8_t read8fn(void); uint8_t read8fn(void);
#define read8isFunctionalized #define read8isFunctionalized
#endif #endif
#ifndef USE_ADAFRUIT_SHIELD_PINOUT #ifndef USE_ADAFRUIT_SHIELD_PINOUT
#ifdef __AVR__ #ifdef __AVR__
volatile uint8_t *csPort , *cdPort , *wrPort , *rdPort; volatile uint8_t *csPort, *cdPort, *wrPort, *rdPort;
uint8_t csPinSet , cdPinSet , wrPinSet , rdPinSet , uint8_t csPinSet, cdPinSet, wrPinSet, rdPinSet, csPinUnset, cdPinUnset,
csPinUnset, cdPinUnset, wrPinUnset, rdPinUnset, wrPinUnset, rdPinUnset, _reset;
_reset; #endif
#endif #if defined(__SAM3X8E__)
#if defined(__SAM3X8E__) Pio *csPort, *cdPort, *wrPort, *rdPort;
Pio *csPort , *cdPort , *wrPort , *rdPort; uint32_t csPinSet, cdPinSet, wrPinSet, rdPinSet, csPinUnset, cdPinUnset,
uint32_t csPinSet , cdPinSet , wrPinSet , rdPinSet , wrPinUnset, rdPinUnset, _reset;
csPinUnset, cdPinUnset, wrPinUnset, rdPinUnset, #endif
_reset;
#endif
#endif #endif
}; };

19
README.md Normal file
View file

@ -0,0 +1,19 @@
# 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.

View file

@ -1,21 +0,0 @@
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

BIN
assets/image.jpg Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 129 KiB

10
library.properties Normal file
View file

@ -0,0 +1,10 @@
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

View file

@ -54,300 +54,417 @@
// This code burns 7 cycles (437.5 nS) doing nothing; the RJMPs are // 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 // equivalent to two NOPs each, final NOP burns the 7th cycle, and the
// last line is a radioactive mutant emoticon. // last line is a radioactive mutant emoticon.
#define DELAY7 \ #define DELAY7 \
asm volatile( \ asm volatile("rjmp .+0" \
"rjmp .+0" "\n\t" \ "\n\t" \
"rjmp .+0" "\n\t" \ "rjmp .+0" \
"rjmp .+0" "\n\t" \ "\n\t" \
"nop" "\n" \ "rjmp .+0" \
::); "\n\t" \
"nop" \
"\n" ::);
#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega328P__) || defined (__AVR_ATmega328__) || defined(__AVR_ATmega8__) #if defined(__AVR_ATmega168__) || defined(__AVR_ATmega328P__) || \
defined(__AVR_ATmega328__) || defined(__AVR_ATmega8__)
// Arduino Uno, Duemilanove, etc. // Arduino Uno, Duemilanove, etc.
#ifdef USE_ADAFRUIT_SHIELD_PINOUT #ifdef USE_ADAFRUIT_SHIELD_PINOUT
// LCD control lines: // LCD control lines:
// RD (read), WR (write), CD (command/data), CS (chip select) // RD (read), WR (write), CD (command/data), CS (chip select)
#define RD_PORT PORTC /*pin A0 */ #define RD_PORT PORTC /*pin A0 */
#define WR_PORT PORTC /*pin A1 */ #define WR_PORT PORTC /*pin A1 */
#define CD_PORT PORTC /*pin A2 */ #define CD_PORT PORTC /*pin A2 */
#define CS_PORT PORTC /*pin A3 */ #define CS_PORT PORTC /*pin A3 */
#define RD_MASK B00000001 #define RD_MASK B00000001
#define WR_MASK B00000010 #define WR_MASK B00000010
#define CD_MASK B00000100 #define CD_MASK B00000100
#define CS_MASK B00001000 #define CS_MASK B00001000
// These are macros for I/O operations... // These are macros for I/O operations...
// Write 8-bit value to LCD data lines // Write 8-bit value to LCD data lines
#define write8inline(d) { \ #define write8inline(d) \
PORTD = (PORTD & B00101111) | ((d) & B11010000); \ { \
PORTB = (PORTB & B11010000) | ((d) & B00101111); \ PORTD = (PORTD & B00101111) | ((d)&B11010000); \
WR_STROBE; } // STROBEs are defined later PORTB = (PORTB & B11010000) | ((d)&B00101111); \
WR_STROBE; \
} // STROBEs are defined later
// Read 8-bit value from LCD data lines. The signle argument // Read 8-bit value from LCD data lines. The signle argument
// is a destination variable; this isn't a function and doesn't // is a destination variable; this isn't a function and doesn't
// return a value in the conventional sense. // return a value in the conventional sense.
#define read8inline(result) { \ #define read8inline(result) \
RD_ACTIVE; \ { \
DELAY7; \ RD_ACTIVE; \
result = (PIND & B11010000) | (PINB & B00101111); \ DELAY7; \
RD_IDLE; } result = (PIND & B11010000) | (PINB & B00101111); \
RD_IDLE; \
}
// These set the PORT directions as required before the write and read // These set the PORT directions as required before the write and read
// operations. Because write operations are much more common than reads, // operations. Because write operations are much more common than reads,
// the data-reading functions in the library code set the PORT(s) to // 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 // input before a read, and restore them back to the write state before
// returning. This avoids having to set it for output inside every // returning. This avoids having to set it for output inside every
// drawing method. The default state has them initialized for writes. // drawing method. The default state has them initialized for writes.
#define setWriteDirInline() { DDRD |= B11010000; DDRB |= B00101111; } #define setWriteDirInline() \
#define setReadDirInline() { DDRD &= ~B11010000; DDRB &= ~B00101111; } { \
DDRD |= B11010000; \
DDRB |= B00101111; \
}
#define setReadDirInline() \
{ \
DDRD &= ~B11010000; \
DDRB &= ~B00101111; \
}
#else // Uno w/Breakout board #else // Uno w/Breakout board
#define write8inline(d) { \ #define write8inline(d) \
PORTD = (PORTD & B00000011) | ((d) & B11111100); \ { \
PORTB = (PORTB & B11111100) | ((d) & B00000011); \ PORTD = (PORTD & B00000011) | ((d)&B11111100); \
WR_STROBE; } PORTB = (PORTB & B11111100) | ((d)&B00000011); \
#define read8inline(result) { \ WR_STROBE; \
RD_ACTIVE; \ }
DELAY7; \ #define read8inline(result) \
result = (PIND & B11111100) | (PINB & B00000011); \ { \
RD_IDLE; } RD_ACTIVE; \
#define setWriteDirInline() { DDRD |= B11111100; DDRB |= B00000011; } DELAY7; \
#define setReadDirInline() { DDRD &= ~B11111100; DDRB &= ~B00000011; } result = (PIND & B11111100) | (PINB & B00000011); \
RD_IDLE; \
}
#define setWriteDirInline() \
{ \
DDRD |= B11111100; \
DDRB |= B00000011; \
}
#define setReadDirInline() \
{ \
DDRD &= ~B11111100; \
DDRB &= ~B00000011; \
}
#endif #endif
// As part of the inline control, macros reference other macros...if any // As part of the inline control, macros reference other macros...if any
// of these are left undefined, an equivalent function version (non-inline) // of these are left undefined, an equivalent function version (non-inline)
// is declared later. The Uno has a moderate amount of program space, so // is declared later. The Uno has a moderate amount of program space, so
// only write8() is inlined -- that one provides the most performance // only write8() is inlined -- that one provides the most performance
// benefit, but unfortunately also generates the most bloat. This is // benefit, but unfortunately also generates the most bloat. This is
// why only certain cases are inlined for each board. // why only certain cases are inlined for each board.
#define write8 write8inline #define write8 write8inline
#elif defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2561__) || defined(__AVR_ATmega2560__) || defined(__AVR_ATmega1280__) #elif defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2561__) || \
defined(__AVR_ATmega2560__) || defined(__AVR_ATmega1280__)
// Arduino Mega, ADK, etc. // Arduino Mega, ADK, etc.
#ifdef USE_ADAFRUIT_SHIELD_PINOUT #ifdef USE_ADAFRUIT_SHIELD_PINOUT
#define RD_PORT PORTF #define RD_PORT PORTF
#define WR_PORT PORTF #define WR_PORT PORTF
#define CD_PORT PORTF #define CD_PORT PORTF
#define CS_PORT PORTF #define CS_PORT PORTF
#define RD_MASK B00000001 #define RD_MASK B00000001
#define WR_MASK B00000010 #define WR_MASK B00000010
#define CD_MASK B00000100 #define CD_MASK B00000100
#define CS_MASK B00001000 #define CS_MASK B00001000
#define write8inline(d) { \ #define write8inline(d) \
PORTH = (PORTH&B10000111)|(((d)&B11000000)>>3)|(((d)&B00000011)<<5); \ { \
PORTB = (PORTB&B01001111)|(((d)&B00101100)<<2); \ PORTH = \
PORTG = (PORTG&B11011111)|(((d)&B00010000)<<1); \ (PORTH & B10000111) | (((d)&B11000000) >> 3) | (((d)&B00000011) << 5); \
WR_STROBE; } PORTB = (PORTB & B01001111) | (((d)&B00101100) << 2); \
#define read8inline(result) { \ PORTG = (PORTG & B11011111) | (((d)&B00010000) << 1); \
RD_ACTIVE; \ WR_STROBE; \
DELAY7; \ }
result = ((PINH & B00011000) << 3) | ((PINB & B10110000) >> 2) | \ #define read8inline(result) \
((PING & B00100000) >> 1) | ((PINH & B01100000) >> 5); \ { \
RD_IDLE; } RD_ACTIVE; \
#define setWriteDirInline() { \ DELAY7; \
DDRH |= B01111000; DDRB |= B10110000; DDRG |= B00100000; } result = ((PINH & B00011000) << 3) | ((PINB & B10110000) >> 2) | \
#define setReadDirInline() { \ ((PING & B00100000) >> 1) | ((PINH & B01100000) >> 5); \
DDRH &= ~B01111000; DDRB &= ~B10110000; DDRG &= ~B00100000; } RD_IDLE; \
}
#define setWriteDirInline() \
{ \
DDRH |= B01111000; \
DDRB |= B10110000; \
DDRG |= B00100000; \
}
#define setReadDirInline() \
{ \
DDRH &= ~B01111000; \
DDRB &= ~B10110000; \
DDRG &= ~B00100000; \
}
#else // Mega w/Breakout board #else // Mega w/Breakout board
#define write8inline(d) { PORTA = (d); WR_STROBE; } #define write8inline(d) \
#define read8inline(result) { \ { \
RD_ACTIVE; \ PORTA = (d); \
DELAY7; \ WR_STROBE; \
result = PINA; \ }
RD_IDLE; } #define read8inline(result) \
#define setWriteDirInline() DDRA = 0xff { \
#define setReadDirInline() DDRA = 0 RD_ACTIVE; \
DELAY7; \
result = PINA; \
RD_IDLE; \
}
#define setWriteDirInline() DDRA = 0xff
#define setReadDirInline() DDRA = 0
#endif #endif
// All of the functions are inlined on the Arduino Mega. When using the // All of the functions are inlined on the Arduino Mega. When using the
// breakout board, the macro versions aren't appreciably larger than the // breakout board, the macro versions aren't appreciably larger than the
// function equivalents, and they're super simple and fast. When using // function equivalents, and they're super simple and fast. When using
// the shield, the macros become pretty complicated...but this board has // 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 // 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. // up program space, some macros can be removed, at a minor cost in speed.
#define write8 write8inline #define write8 write8inline
#define read8 read8inline #define read8 read8inline
#define setWriteDir setWriteDirInline #define setWriteDir setWriteDirInline
#define setReadDir setReadDirInline #define setReadDir setReadDirInline
#define writeRegister8 writeRegister8inline #define writeRegister8 writeRegister8inline
#define writeRegister16 writeRegister16inline #define writeRegister16 writeRegister16inline
#define writeRegisterPair writeRegisterPairInline #define writeRegisterPair writeRegisterPairInline
#elif defined(__AVR_ATmega32U4__) #elif defined(__AVR_ATmega32U4__)
// Arduino Leonardo // Arduino Leonardo
#ifdef USE_ADAFRUIT_SHIELD_PINOUT #ifdef USE_ADAFRUIT_SHIELD_PINOUT
#define RD_PORT PORTF #define RD_PORT PORTF
#define WR_PORT PORTF #define WR_PORT PORTF
#define CD_PORT PORTF #define CD_PORT PORTF
#define CS_PORT PORTF #define CS_PORT PORTF
#define RD_MASK B10000000 #define RD_MASK B10000000
#define WR_MASK B01000000 #define WR_MASK B01000000
#define CD_MASK B00100000 #define CD_MASK B00100000
#define CS_MASK B00010000 #define CS_MASK B00010000
#define write8inline(d) { \ #define write8inline(d) \
PORTE = (PORTE & B10111111) | (((d) & B10000000)>>1); \ { \
PORTD = (PORTD & B01101111) | (((d) & B01000000)<<1) | ((d) & B00010000); \ PORTE = (PORTE & B10111111) | (((d)&B10000000) >> 1); \
PORTC = (PORTC & B01111111) | (((d) & B00100000)<<2); \ PORTD = (PORTD & B01101111) | (((d)&B01000000) << 1) | ((d)&B00010000); \
PORTB = (PORTB & B00001111) | (((d) & B00001111)<<4); \ PORTC = (PORTC & B01111111) | (((d)&B00100000) << 2); \
WR_STROBE; } PORTB = (PORTB & B00001111) | (((d)&B00001111) << 4); \
#define read8inline(result) { \ WR_STROBE; \
RD_ACTIVE; \ }
DELAY7; \ #define read8inline(result) \
result = ((PINE & B01000000) << 1) | ((PIND & B10000000) >> 1) | \ { \
((PINC & B10000000) >> 2) | ((PINB & B11110000) >> 4) | \ RD_ACTIVE; \
(PIND & B00010000); \ DELAY7; \
RD_IDLE; } result = ((PINE & B01000000) << 1) | ((PIND & B10000000) >> 1) | \
#define setWriteDirInline() { \ ((PINC & B10000000) >> 2) | ((PINB & B11110000) >> 4) | \
DDRE |= B01000000; DDRD |= B10010000; \ (PIND & B00010000); \
DDRC |= B10000000; DDRB |= B11110000; } RD_IDLE; \
#define setReadDirInline() { \ }
DDRE &= ~B01000000; DDRD &= ~B10010000; \ #define setWriteDirInline() \
DDRC &= ~B10000000; DDRB &= ~B11110000; } { \
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) { \ #define write8inline(d) \
uint8_t dr1 = (d) >> 1, dl1 = (d) << 1; \ { \
PORTE = (PORTE & B10111111) | (dr1 & B01000000); \ uint8_t dr1 = (d) >> 1, dl1 = (d) << 1; \
PORTD = (PORTD & B01101100) | (dl1 & B10000000) | (((d) & B00001000)>>3) |\ PORTE = (PORTE & B10111111) | (dr1 & B01000000); \
(dr1 & B00000010) | ((d) & B00010000); \ PORTD = (PORTD & B01101100) | (dl1 & B10000000) | (((d)&B00001000) >> 3) | \
PORTC = (PORTC & B10111111) | (dl1 & B01000000); \ (dr1 & B00000010) | ((d)&B00010000); \
PORTB = (PORTB & B11001111) |(((d) & B00000011)<<4); \ PORTC = (PORTC & B10111111) | (dl1 & B01000000); \
WR_STROBE; } PORTB = (PORTB & B11001111) | (((d)&B00000011) << 4); \
#define read8inline(result) { \ WR_STROBE; \
RD_ACTIVE; \ }
DELAY7; \ #define read8inline(result) \
result = (((PINE & B01000000) | (PIND & B00000010)) << 1) | \ { \
(((PINC & B01000000) | (PIND & B10000000)) >> 1) | \ RD_ACTIVE; \
((PIND & B00000001) << 3) | ((PINB & B00110000) >> 4) | \ DELAY7; \
(PIND & B00010000); \ result = (((PINE & B01000000) | (PIND & B00000010)) << 1) | \
RD_IDLE; } (((PINC & B01000000) | (PIND & B10000000)) >> 1) | \
#define setWriteDirInline() { \ ((PIND & B00000001) << 3) | ((PINB & B00110000) >> 4) | \
DDRE |= B01000000; DDRD |= B10010011; \ (PIND & B00010000); \
DDRC |= B01000000; DDRB |= B00110000; } RD_IDLE; \
#define setReadDirInline() { \ }
DDRE &= ~B01000000; DDRD &= ~B10010011; \ #define setWriteDirInline() \
DDRC &= ~B01000000; DDRB &= ~B00110000; } { \
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 // On the Leonardo, only the write8() macro is used -- though even that
// might be excessive given the code size and available program space // might be excessive given the code size and available program space
// on this board. You may need to disable this to get any sizable // on this board. You may need to disable this to get any sizable
// program to compile. // program to compile.
#define write8 write8inline #define write8 write8inline
#elif defined(__SAM3X8E__) #elif defined(__SAM3X8E__)
// Arduino Due // Arduino Due
#ifdef USE_ADAFRUIT_SHIELD_PINOUT #ifdef USE_ADAFRUIT_SHIELD_PINOUT
#define RD_PORT PIOA /*pin A0 */ #define RD_PORT PIOA /*pin A0 */
#define WR_PORT PIOA /*pin A1 */ #define WR_PORT PIOA /*pin A1 */
#define CD_PORT PIOA /*pin A2 */ #define CD_PORT PIOA /*pin A2 */
#define CS_PORT PIOA /*pin A3 */ #define CS_PORT PIOA /*pin A3 */
#define RD_MASK 0x00010000 #define RD_MASK 0x00010000
#define WR_MASK 0x01000000 #define WR_MASK 0x01000000
#define CD_MASK 0x00800000 #define CD_MASK 0x00800000
#define CS_MASK 0x00400000 #define CS_MASK 0x00400000
#define write8inline(d) { \ #define write8inline(d) \
PIO_Set(PIOD, (((d) & 0x08)<<(7-3))); \ { \
PIO_Clear(PIOD, (((~d) & 0x08)<<(7-3))); \ PIO_Set(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(PIOD, (((~d) & 0x08) << (7 - 3))); \
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(PIOC, (((d)&0x01) << (22 - 0)) | (((d)&0x02) << (21 - 1)) | \
PIO_Set(PIOB, (((d) & 0x20)<<(27-5))); \ (((d)&0x04) << (29 - 2)) | (((d)&0x10) << (26 - 4)) | \
PIO_Clear(PIOB, (((~d) & 0x20)<<(27-5))); \ (((d)&0x40) << (24 - 6)) | (((d)&0x80) << (23 - 7))); \
WR_STROBE; } 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) { \ #define read8inline(result) \
RD_ACTIVE; \ { \
delayMicroseconds(1); \ \
result = (((PIOC->PIO_PDSR & (1<<23)) >> (23-7)) | ((PIOC->PIO_PDSR & (1<<24)) >> (24-6)) | \ RD_ACTIVE; \
((PIOB->PIO_PDSR & (1<<27)) >> (27-5)) | ((PIOC->PIO_PDSR & (1<<26)) >> (26-4)) | \ delayMicroseconds(1); \
((PIOD->PIO_PDSR & (1<< 7)) >> ( 7-3)) | ((PIOC->PIO_PDSR & (1<<29)) >> (29-2)) | \ result = (((PIOC->PIO_PDSR & (1 << 23)) >> (23 - 7)) | \
((PIOC->PIO_PDSR & (1<<21)) >> (21-1)) | ((PIOC->PIO_PDSR & (1<<22)) >> (22-0))); \ ((PIOC->PIO_PDSR & (1 << 24)) >> (24 - 6)) | \
RD_IDLE;} ((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() { \ #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; \ PIOD->PIO_MDDR |= 0x00000080; /*PIOD->PIO_SODR = 0x00000080;*/ \
PIOB->PIO_MDDR |= 0x08000000; /*PIOB->PIO_SODR = 0x08000000;*/ PIOB->PIO_OER |= 0x08000000; PIOB->PIO_PER |= 0x08000000; } 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() { \ #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; \ pmc_enable_periph_clk(ID_PIOD); \
PIOC->PIO_PUDR |= 0x25E00000; PIOC->PIO_IFDR |= 0x25E00000; PIOC->PIO_ODR |= 0x25E00000; PIOC->PIO_PER |= 0x25E00000; \ pmc_enable_periph_clk(ID_PIOC); \
PIOB->PIO_PUDR |= 0x08000000; PIOB->PIO_IFDR |= 0x08000000; PIOB->PIO_ODR |= 0x08000000; PIOB->PIO_PER |= 0x08000000; } pmc_enable_periph_clk(ID_PIOB); \
PIOD->PIO_PUDR |= 0x00000080; \
// Control signals are ACTIVE LOW (idle is HIGH) PIOD->PIO_IFDR |= 0x00000080; \
// Command/Data: LOW = command, HIGH = data PIOD->PIO_ODR |= 0x00000080; \
// These are single-instruction operations and always inline PIOD->PIO_PER |= 0x00000080; \
#define RD_ACTIVE RD_PORT->PIO_CODR |= RD_MASK PIOC->PIO_PUDR |= 0x25E00000; \
#define RD_IDLE RD_PORT->PIO_SODR |= RD_MASK PIOC->PIO_IFDR |= 0x25E00000; \
#define WR_ACTIVE WR_PORT->PIO_CODR |= WR_MASK PIOC->PIO_ODR |= 0x25E00000; \
#define WR_IDLE WR_PORT->PIO_SODR |= WR_MASK PIOC->PIO_PER |= 0x25E00000; \
#define CD_COMMAND CD_PORT->PIO_CODR |= CD_MASK PIOB->PIO_PUDR |= 0x08000000; \
#define CD_DATA CD_PORT->PIO_SODR |= CD_MASK PIOB->PIO_IFDR |= 0x08000000; \
#define CS_ACTIVE CS_PORT->PIO_CODR |= CS_MASK PIOB->PIO_ODR |= 0x08000000; \
#define CS_IDLE CS_PORT->PIO_SODR |= CS_MASK 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 #else // Due w/Breakout board
#define write8inline(d) { \ #define write8inline(d) \
PIO_Set(PIOC, (((d) & 0xFF)<<1)); \ { \
PIO_Clear(PIOC, (((~d) & 0xFF)<<1)); \ PIO_Set(PIOC, (((d)&0xFF) << 1)); \
WR_STROBE; } PIO_Clear(PIOC, (((~d) & 0xFF) << 1)); \
WR_STROBE; \
}
#define read8inline(result) { \ #define read8inline(result) \
RD_ACTIVE; \ { \
delayMicroseconds(1); \ RD_ACTIVE; \
result = ((PIOC->PIO_PDSR & 0x1FE) >> 1); \ delayMicroseconds(1); \
RD_IDLE;} result = ((PIOC->PIO_PDSR & 0x1FE) >> 1); \
RD_IDLE; \
}
#define setWriteDirInline() { \ #define setWriteDirInline() \
PIOC->PIO_MDDR |= 0x000001FE; /*PIOC->PIO_SODR |= 0x000001FE;*/ PIOC->PIO_OER |= 0x000001FE; PIOC->PIO_PER |= 0x000001FE; } { \
PIOC->PIO_MDDR |= 0x000001FE; /*PIOC->PIO_SODR |= 0x000001FE;*/ \
PIOC->PIO_OER |= 0x000001FE; \
PIOC->PIO_PER |= 0x000001FE; \
}
#define setReadDirInline() { \ #define setReadDirInline() \
pmc_enable_periph_clk( ID_PIOC ) ; \ { \
PIOC->PIO_PUDR |= 0x000001FE; PIOC->PIO_IFDR |= 0x000001FE; PIOC->PIO_ODR |= 0x000001FE; PIOC->PIO_PER |= 0x000001FE; } 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. // When using the TFT breakout board, control pins are configurable.
#define RD_ACTIVE rdPort->PIO_CODR |= rdPinSet //PIO_Clear(rdPort, rdPinSet) #define RD_ACTIVE rdPort->PIO_CODR |= rdPinSet // PIO_Clear(rdPort, rdPinSet)
#define RD_IDLE rdPort->PIO_SODR |= rdPinSet //PIO_Set(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_ACTIVE wrPort->PIO_CODR |= wrPinSet // PIO_Clear(wrPort, wrPinSet)
#define WR_IDLE wrPort->PIO_SODR |= wrPinSet //PIO_Set(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_COMMAND cdPort->PIO_CODR |= cdPinSet // PIO_Clear(cdPort, cdPinSet)
#define CD_DATA cdPort->PIO_SODR |= cdPinSet //PIO_Set(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_ACTIVE csPort->PIO_CODR |= csPinSet // PIO_Clear(csPort, csPinSet)
#define CS_IDLE csPort->PIO_SODR |= csPinSet //PIO_Set(csPort, csPinSet) #define CS_IDLE csPort->PIO_SODR |= csPinSet // PIO_Set(csPort, csPinSet)
#endif
#endif
#else #else
#error "Board type unsupported / not recognized" #error "Board type unsupported / not recognized"
#endif #endif
@ -356,54 +473,81 @@
#ifdef USE_ADAFRUIT_SHIELD_PINOUT #ifdef USE_ADAFRUIT_SHIELD_PINOUT
// Control signals are ACTIVE LOW (idle is HIGH) // Control signals are ACTIVE LOW (idle is HIGH)
// Command/Data: LOW = command, HIGH = data // Command/Data: LOW = command, HIGH = data
// These are single-instruction operations and always inline // These are single-instruction operations and always inline
#define RD_ACTIVE RD_PORT &= ~RD_MASK #define RD_ACTIVE RD_PORT &= ~RD_MASK
#define RD_IDLE RD_PORT |= RD_MASK #define RD_IDLE RD_PORT |= RD_MASK
#define WR_ACTIVE WR_PORT &= ~WR_MASK #define WR_ACTIVE WR_PORT &= ~WR_MASK
#define WR_IDLE WR_PORT |= WR_MASK #define WR_IDLE WR_PORT |= WR_MASK
#define CD_COMMAND CD_PORT &= ~CD_MASK #define CD_COMMAND CD_PORT &= ~CD_MASK
#define CD_DATA CD_PORT |= CD_MASK #define CD_DATA CD_PORT |= CD_MASK
#define CS_ACTIVE CS_PORT &= ~CS_MASK #define CS_ACTIVE CS_PORT &= ~CS_MASK
#define CS_IDLE CS_PORT |= CS_MASK #define CS_IDLE CS_PORT |= CS_MASK
#else // Breakout board #else // Breakout board
// When using the TFT breakout board, control pins are configurable. // When using the TFT breakout board, control pins are configurable.
#define RD_ACTIVE *rdPort &= rdPinUnset #define RD_ACTIVE *rdPort &= rdPinUnset
#define RD_IDLE *rdPort |= rdPinSet #define RD_IDLE *rdPort |= rdPinSet
#define WR_ACTIVE *wrPort &= wrPinUnset #define WR_ACTIVE *wrPort &= wrPinUnset
#define WR_IDLE *wrPort |= wrPinSet #define WR_IDLE *wrPort |= wrPinSet
#define CD_COMMAND *cdPort &= cdPinUnset #define CD_COMMAND *cdPort &= cdPinUnset
#define CD_DATA *cdPort |= cdPinSet #define CD_DATA *cdPort |= cdPinSet
#define CS_ACTIVE *csPort &= csPinUnset #define CS_ACTIVE *csPort &= csPinUnset
#define CS_IDLE *csPort |= csPinSet #define CS_IDLE *csPort |= csPinSet
#endif #endif
#endif #endif
// Data write strobe, ~2 instructions and always inline // Data write strobe, ~2 instructions and always inline
#define WR_STROBE { WR_ACTIVE; WR_IDLE; } #define WR_STROBE \
{ \
WR_ACTIVE; \
WR_IDLE; \
}
// These higher-level operations are usually functionalized, // These higher-level operations are usually functionalized,
// except on Mega where's there's gobs and gobs of program space. // except on Mega where's there's gobs and gobs of program space.
// Set value of TFT register: 8-bit address, 8-bit value // Set value of TFT register: 8-bit address, 8-bit value
#define writeRegister8inline(a, d) { \ #define writeRegister8inline(a, d) \
CD_COMMAND; write8(a); CD_DATA; write8(d); } { \
CD_COMMAND; \
write8(a); \
CD_DATA; \
write8(d); \
}
// Set value of TFT register: 16-bit address, 16-bit value // Set value of TFT register: 16-bit address, 16-bit value
// See notes at top about macro expansion, hence hi & lo temp vars // See notes at top about macro expansion, hence hi & lo temp vars
#define writeRegister16inline(a, d) { \ #define writeRegister16inline(a, d) \
uint8_t hi, lo; \ { \
hi = (a) >> 8; lo = (a); CD_COMMAND; write8(hi); write8(lo); \ uint8_t hi, lo; \
hi = (d) >> 8; lo = (d); CD_DATA ; write8(hi); write8(lo); } hi = (a) >> 8; \
lo = (a); \
CD_COMMAND; \
write8(hi); \
write8(lo); \
hi = (d) >> 8; \
lo = (d); \
CD_DATA; \
write8(hi); \
write8(lo); \
}
// Set value of 2 TFT registers: Two 8-bit addresses (hi & lo), 16-bit value // 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) \
uint8_t hi = (d) >> 8, lo = (d); \ { \
CD_COMMAND; write8(aH); CD_DATA; write8(hi); \ uint8_t hi = (d) >> 8, lo = (d); \
CD_COMMAND; write8(aL); CD_DATA; write8(lo); } CD_COMMAND; \
write8(aH); \
CD_DATA; \
write8(hi); \
CD_COMMAND; \
write8(aL); \
CD_DATA; \
write8(lo); \
}
#endif // _pin_magic_ #endif // _pin_magic_

View file

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