580 lines
14 KiB
C++
580 lines
14 KiB
C++
// IMPORTANT: LIBRARY MUST BE SPECIFICALLY CONFIGURED FOR EITHER TFT SHIELD
|
|
// OR BREAKOUT BOARD USAGE. SEE RELEVANT COMMENTS IN Adafruit_ILI9341_8bit_AS.h
|
|
|
|
// Graphics library by ladyada/adafruit with init code from Rossum
|
|
// MIT license
|
|
|
|
#include <avr/pgmspace.h>
|
|
|
|
#include "pins_arduino.h"
|
|
|
|
#include "wiring_private.h"
|
|
#include "Adafruit_ILI9341_8bit_AS.h"
|
|
|
|
#if defined __AVR_ATmega328P__
|
|
#include "pin_magic_UNO.h"
|
|
#endif
|
|
|
|
#if defined __AVR_ATmega2560__
|
|
#include "pin_magic_MEGA.h"
|
|
#endif
|
|
|
|
|
|
//#define TFTWIDTH 320
|
|
//#define TFTHEIGHT 480
|
|
|
|
#define TFTWIDTH 240
|
|
#define TFTHEIGHT 320
|
|
|
|
// LCD controller chip identifiers
|
|
#define ID_9341 2
|
|
|
|
#include "registers.h"
|
|
|
|
// Constructor for breakout board (configurable LCD control lines).
|
|
// Can still use this w/shield, but parameters are ignored.
|
|
|
|
Adafruit_ILI9341_8bit_AS::Adafruit_ILI9341_8bit_AS(uint8_t cs, uint8_t cd, uint8_t wr, uint8_t rd, uint8_t reset) : Adafruit_GFX_AS(TFTWIDTH, TFTHEIGHT) {
|
|
|
|
#ifndef USE_ADAFRUIT_SHIELD_PINOUT
|
|
// Convert pin numbers to registers and bitmasks
|
|
_reset = reset;
|
|
|
|
csPort = portOutputRegister(digitalPinToPort(cs));
|
|
cdPort = portOutputRegister(digitalPinToPort(cd));
|
|
wrPort = portOutputRegister(digitalPinToPort(wr));
|
|
rdPort = portOutputRegister(digitalPinToPort(rd));
|
|
|
|
csPinSet = digitalPinToBitMask(cs);
|
|
cdPinSet = digitalPinToBitMask(cd);
|
|
wrPinSet = digitalPinToBitMask(wr);
|
|
rdPinSet = digitalPinToBitMask(rd);
|
|
csPinUnset = ~csPinSet;
|
|
cdPinUnset = ~cdPinSet;
|
|
wrPinUnset = ~wrPinSet;
|
|
rdPinUnset = ~rdPinSet;
|
|
|
|
*csPort |= csPinSet; // Set all control bits to HIGH (idle)
|
|
*cdPort |= cdPinSet; // Signals are ACTIVE LOW
|
|
*wrPort |= wrPinSet;
|
|
*rdPort |= rdPinSet;
|
|
|
|
pinMode(cs, OUTPUT); // Enable outputs
|
|
pinMode(cd, OUTPUT);
|
|
pinMode(wr, OUTPUT);
|
|
pinMode(rd, OUTPUT);
|
|
|
|
if(reset) {
|
|
digitalWrite(reset, HIGH);
|
|
pinMode(reset, OUTPUT);
|
|
}
|
|
#endif
|
|
|
|
init();
|
|
}
|
|
|
|
// Constructor for shield (fixed LCD control lines)
|
|
Adafruit_ILI9341_8bit_AS::Adafruit_ILI9341_8bit_AS(void) : Adafruit_GFX_AS(TFTWIDTH, TFTHEIGHT) {
|
|
init();
|
|
}
|
|
|
|
// Initialization common to both shield & breakout configs
|
|
void Adafruit_ILI9341_8bit_AS::init(void) {
|
|
|
|
#ifdef USE_ADAFRUIT_SHIELD_PINOUT
|
|
CS_IDLE; // Set all control bits to idle state
|
|
WR_IDLE;
|
|
RD_IDLE;
|
|
CD_DATA;
|
|
digitalWrite(5, HIGH); // Reset line
|
|
pinMode(A3, OUTPUT); // Enable outputs
|
|
pinMode(A2, OUTPUT);
|
|
pinMode(A1, OUTPUT);
|
|
pinMode(A0, OUTPUT);
|
|
pinMode( 5, OUTPUT);
|
|
#endif
|
|
|
|
setWriteDir(); // Set up LCD data port(s) for WRITE operations
|
|
|
|
rotation = 0;
|
|
cursor_y = cursor_x = 0;
|
|
textsize = 1;
|
|
textcolor = 0xFFFF;
|
|
_width = TFTWIDTH;
|
|
_height = TFTHEIGHT;
|
|
}
|
|
|
|
// Initialization command tables for different LCD controllers
|
|
#define ILI9341_8bit_AS_DELAY 0xFF
|
|
static const uint8_t HX8347G_regValues[] PROGMEM = {
|
|
0x2E , 0x89,
|
|
0x29 , 0x8F,
|
|
0x2B , 0x02,
|
|
0xE2 , 0x00,
|
|
0xE4 , 0x01,
|
|
0xE5 , 0x10,
|
|
0xE6 , 0x01,
|
|
0xE7 , 0x10,
|
|
0xE8 , 0x70,
|
|
0xF2 , 0x00,
|
|
0xEA , 0x00,
|
|
0xEB , 0x20,
|
|
0xEC , 0x3C,
|
|
0xED , 0xC8,
|
|
0xE9 , 0x38,
|
|
0xF1 , 0x01,
|
|
|
|
// skip gamma, do later
|
|
|
|
0x1B , 0x1A,
|
|
0x1A , 0x02,
|
|
0x24 , 0x61,
|
|
0x25 , 0x5C,
|
|
|
|
0x18 , 0x36,
|
|
0x19 , 0x01,
|
|
0x1F , 0x88,
|
|
ILI9341_8bit_AS_DELAY , 5 , // delay 5 ms
|
|
0x1F , 0x80,
|
|
ILI9341_8bit_AS_DELAY , 5 ,
|
|
0x1F , 0x90,
|
|
ILI9341_8bit_AS_DELAY , 5 ,
|
|
0x1F , 0xD4,
|
|
ILI9341_8bit_AS_DELAY , 5 ,
|
|
0x17 , 0x05,
|
|
|
|
0x36 , 0x09,
|
|
0x28 , 0x38,
|
|
ILI9341_8bit_AS_DELAY , 40 ,
|
|
0x28 , 0x3C,
|
|
|
|
0x02 , 0x00,
|
|
0x03 , 0x00,
|
|
0x04 , 0x00,
|
|
0x05 , 0xEF,
|
|
0x06 , 0x00,
|
|
0x07 , 0x00,
|
|
0x08 , 0x01,
|
|
0x09 , 0x3F
|
|
};
|
|
|
|
void Adafruit_ILI9341_8bit_AS::begin(uint16_t id) {
|
|
uint8_t i = 0;
|
|
|
|
reset();
|
|
|
|
delay(200);
|
|
|
|
uint16_t a, d;
|
|
driver = ID_9341;
|
|
CS_ACTIVE;
|
|
writeRegister8(ILI9341_SOFTRESET, 0);
|
|
delay(50);
|
|
writeRegister8(ILI9341_DISPLAYOFF, 0);
|
|
|
|
writeRegister8(ILI9341_POWERCONTROL1, 0x23);
|
|
writeRegister8(ILI9341_POWERCONTROL2, 0x10);
|
|
writeRegister16(ILI9341_VCOMCONTROL1, 0x2B2B);
|
|
writeRegister8(ILI9341_VCOMCONTROL2, 0xC0);
|
|
writeRegister8(ILI9341_MEMCONTROL, ILI9341_MADCTL_MY | ILI9341_MADCTL_BGR);
|
|
writeRegister8(ILI9341_PIXELFORMAT, 0x55);
|
|
writeRegister16(ILI9341_FRAMECONTROL, 0x001B);
|
|
|
|
writeRegister8(ILI9341_ENTRYMODE, 0x07);
|
|
/* writeRegister32(ILI9341_DISPLAYFUNC, 0x0A822700);*/
|
|
|
|
writeRegister8(ILI9341_SLEEPOUT, 0);
|
|
delay(150);
|
|
writeRegister8(ILI9341_DISPLAYON, 0);
|
|
delay(500);
|
|
setAddrWindow(0, 0, TFTWIDTH-1, TFTHEIGHT-1);
|
|
return;
|
|
}
|
|
|
|
void Adafruit_ILI9341_8bit_AS::reset(void) {
|
|
|
|
CS_IDLE;
|
|
// CD_DATA;
|
|
WR_IDLE;
|
|
RD_IDLE;
|
|
|
|
#ifdef USE_ADAFRUIT_SHIELD_PINOUT
|
|
digitalWrite(5, LOW);
|
|
delay(2);
|
|
digitalWrite(5, HIGH);
|
|
#else
|
|
// if we have a reset pin defined ( _reset )
|
|
if(_reset) {
|
|
digitalWrite(_reset, LOW);
|
|
delay(2);
|
|
digitalWrite(_reset, HIGH);
|
|
}
|
|
#endif
|
|
|
|
// Data transfer sync
|
|
CS_ACTIVE;
|
|
CD_COMMAND;
|
|
write8(0x00);
|
|
for(uint8_t i=0; i<3; i++) WR_STROBE; // Three extra 0x00s
|
|
CS_IDLE;
|
|
|
|
// let the display recover from the reset
|
|
delay(500);
|
|
|
|
}
|
|
|
|
// Sets the LCD address window (and address counter, on 932X).
|
|
// Relevant to rect/screen fills and H/V lines. Input coordinates are
|
|
// assumed pre-sorted (e.g. x2 >= x1).
|
|
void Adafruit_ILI9341_8bit_AS::setAddrWindow(int x1, int y1, int x2, int y2) {
|
|
CS_ACTIVE;
|
|
uint32_t t;
|
|
t = x1;
|
|
t <<= 16;
|
|
t |= x2;
|
|
writeRegister32(ILI9341_COLADDRSET, t); // HX8357D uses same registers!
|
|
t = y1;
|
|
t <<= 16;
|
|
t |= y2;
|
|
writeRegister32(ILI9341_PAGEADDRSET, t); // HX8357D uses same registers!
|
|
CS_IDLE;
|
|
}
|
|
|
|
// Fast block fill operation for fillScreen, fillRect, H/V line, etc.
|
|
// Requires setAddrWindow() has previously been called to set the fill
|
|
// bounds. 'len' is inclusive, MUST be >= 1.
|
|
void Adafruit_ILI9341_8bit_AS::flood(uint16_t color, uint32_t len) {
|
|
uint16_t blocks;
|
|
uint8_t i, hi = color >> 8,
|
|
lo = color;
|
|
|
|
CS_ACTIVE;
|
|
CD_COMMAND;
|
|
write8(0x2C);
|
|
|
|
// Write first pixel normally, decrement counter by 1
|
|
CD_DATA;
|
|
write8(hi);
|
|
write8(lo);
|
|
len--;
|
|
|
|
blocks = (uint16_t)(len / 64); // 64 pixels/block
|
|
if(hi == lo) {
|
|
// High and low bytes are identical. Leave prior data
|
|
// on the port(s) and just toggle the write strobe.
|
|
while(blocks--) {
|
|
i = 16; // 64 pixels/block / 4 pixels/pass
|
|
do {
|
|
WR_STROBE; WR_STROBE; WR_STROBE; WR_STROBE; // 2 bytes/pixel
|
|
WR_STROBE; WR_STROBE; WR_STROBE; WR_STROBE; // x 4 pixels
|
|
} while(--i);
|
|
}
|
|
// Fill any remaining pixels (1 to 64)
|
|
for(i = (uint8_t)len & 63; i--; ) {
|
|
WR_STROBE;
|
|
WR_STROBE;
|
|
}
|
|
} else {
|
|
while(blocks--) {
|
|
i = 16; // 64 pixels/block / 4 pixels/pass
|
|
do {
|
|
write8(hi); write8(lo); write8(hi); write8(lo);
|
|
write8(hi); write8(lo); write8(hi); write8(lo);
|
|
} while(--i);
|
|
}
|
|
for(i = (uint8_t)len & 63; i--; ) {
|
|
write8(hi);
|
|
write8(lo);
|
|
}
|
|
}
|
|
CS_IDLE;
|
|
}
|
|
|
|
void Adafruit_ILI9341_8bit_AS::drawFastHLine(int16_t x, int16_t y, int16_t length,
|
|
uint16_t color)
|
|
{
|
|
int16_t x2;
|
|
|
|
// Initial off-screen clipping
|
|
if((length <= 0 ) ||
|
|
(y < 0 ) || ( y >= _height) ||
|
|
(x >= _width) || ((x2 = (x+length-1)) < 0 )) return;
|
|
|
|
if(x < 0) { // Clip left
|
|
length += x;
|
|
x = 0;
|
|
}
|
|
if(x2 >= _width) { // Clip right
|
|
x2 = _width - 1;
|
|
length = x2 - x + 1;
|
|
}
|
|
|
|
setAddrWindow(x, y, x2, y);
|
|
flood(color, length);
|
|
}
|
|
|
|
void Adafruit_ILI9341_8bit_AS::drawFastVLine(int16_t x, int16_t y, int16_t length,
|
|
uint16_t color)
|
|
{
|
|
int16_t y2;
|
|
|
|
// Initial off-screen clipping
|
|
if((length <= 0 ) ||
|
|
(x < 0 ) || ( x >= _width) ||
|
|
(y >= _height) || ((y2 = (y+length-1)) < 0 )) return;
|
|
if(y < 0) { // Clip top
|
|
length += y;
|
|
y = 0;
|
|
}
|
|
if(y2 >= _height) { // Clip bottom
|
|
y2 = _height - 1;
|
|
length = y2 - y + 1;
|
|
}
|
|
|
|
setAddrWindow(x, y, x, y2);
|
|
flood(color, length);
|
|
}
|
|
|
|
void Adafruit_ILI9341_8bit_AS::fillRect(int16_t x1, int16_t y1, int16_t w, int16_t h,
|
|
uint16_t fillcolor) {
|
|
int16_t x2, y2;
|
|
|
|
// Initial off-screen clipping
|
|
if( (w <= 0 ) || (h <= 0 ) ||
|
|
(x1 >= _width) || (y1 >= _height) ||
|
|
((x2 = x1+w-1) < 0 ) || ((y2 = y1+h-1) < 0 )) return;
|
|
if(x1 < 0) { // Clip left
|
|
w += x1;
|
|
x1 = 0;
|
|
}
|
|
if(y1 < 0) { // Clip top
|
|
h += y1;
|
|
y1 = 0;
|
|
}
|
|
if(x2 >= _width) { // Clip right
|
|
x2 = _width - 1;
|
|
w = x2 - x1 + 1;
|
|
}
|
|
if(y2 >= _height) { // Clip bottom
|
|
y2 = _height - 1;
|
|
h = y2 - y1 + 1;
|
|
}
|
|
|
|
setAddrWindow(x1, y1, x2, y2);
|
|
flood(fillcolor, (uint32_t)w * (uint32_t)h);
|
|
}
|
|
|
|
void Adafruit_ILI9341_8bit_AS::fillScreen(uint16_t color) {
|
|
|
|
// For these, there is no settable address pointer, instead the
|
|
// address window must be set for each drawing operation. However,
|
|
// this display takes rotation into account for the parameters, no
|
|
// need to do extra rotation math here.
|
|
setAddrWindow(0, 0, _width - 1, _height - 1);
|
|
flood(color, (long)TFTWIDTH * (long)TFTHEIGHT);
|
|
}
|
|
|
|
void Adafruit_ILI9341_8bit_AS::drawPixel(int16_t x, int16_t y, uint16_t color) {
|
|
|
|
// Clip
|
|
if((x < 0) || (y < 0) || (x >= _width) || (y >= _height)) return;
|
|
|
|
CS_ACTIVE;
|
|
setAddrWindow(x, y, _width-1, _height-1);
|
|
CS_ACTIVE;
|
|
CD_COMMAND;
|
|
write8(0x2C);
|
|
CD_DATA;
|
|
write8(color >> 8); write8(color);
|
|
CS_IDLE;
|
|
}
|
|
|
|
// Issues 'raw' an array of 16-bit color values to the LCD; used
|
|
// externally by BMP examples. Assumes that setWindowAddr() has
|
|
// previously been set to define the bounds. Max 255 pixels at
|
|
// a time (BMP examples read in small chunks due to limited RAM).
|
|
void Adafruit_ILI9341_8bit_AS::pushColors(uint16_t *data, uint8_t len, boolean first) {
|
|
uint16_t color;
|
|
uint8_t hi, lo;
|
|
CS_ACTIVE;
|
|
if(first == true) { // Issue GRAM write command only on first call
|
|
CD_COMMAND;
|
|
|
|
write8(0x2C);
|
|
}
|
|
CD_DATA;
|
|
while(len--) {
|
|
color = *data++;
|
|
hi = color >> 8; // Don't simplify or merge these
|
|
lo = color; // lines, there's macro shenanigans
|
|
write8(hi); // going on.
|
|
write8(lo);
|
|
}
|
|
CS_IDLE;
|
|
}
|
|
|
|
void Adafruit_ILI9341_8bit_AS::setRotation(uint8_t x) {
|
|
|
|
// Call parent rotation func first -- sets up rotation flags, etc.
|
|
Adafruit_GFX_AS::setRotation(x);
|
|
// Then perform hardware-specific rotation operations...
|
|
|
|
CS_ACTIVE;
|
|
uint16_t t;
|
|
|
|
switch (rotation) {
|
|
case 2:
|
|
t = ILI9341_MADCTL_MX | ILI9341_MADCTL_BGR;
|
|
break;
|
|
case 3:
|
|
t = ILI9341_MADCTL_MV | ILI9341_MADCTL_BGR;
|
|
break;
|
|
case 0:
|
|
t = ILI9341_MADCTL_MY | ILI9341_MADCTL_BGR;
|
|
break;
|
|
case 1:
|
|
t = ILI9341_MADCTL_MX | ILI9341_MADCTL_MY | ILI9341_MADCTL_MV | ILI9341_MADCTL_BGR;
|
|
break;
|
|
}
|
|
writeRegister8(ILI9341_MADCTL, t ); // MADCTL
|
|
// For 9341, init default full-screen address window:
|
|
setAddrWindow(0, 0, _width - 1, _height - 1); // CS_IDLE happens here
|
|
|
|
writeRegister8(ILI9341_MADCTL, t ); // MADCTL
|
|
// For 8357, init default full-screen address window:
|
|
setAddrWindow(0, 0, _width - 1, _height - 1); // CS_IDLE happens here
|
|
}
|
|
|
|
#ifdef read8isFunctionalized
|
|
#define read8(x) x=read8fn()
|
|
#endif
|
|
|
|
// Because this function is used infrequently, it configures the ports for
|
|
// the read operation, reads the data, then restores the ports to the write
|
|
// configuration. Write operations happen a LOT, so it's advantageous to
|
|
// leave the ports in that state as a default.
|
|
uint16_t Adafruit_ILI9341_8bit_AS::readPixel(int16_t x, int16_t y) {
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Ditto with the read/write port directions, as above.
|
|
uint16_t Adafruit_ILI9341_8bit_AS::readID(void) {
|
|
uint16_t id = readReg(0xD3);
|
|
return id;
|
|
}
|
|
|
|
uint32_t Adafruit_ILI9341_8bit_AS::readReg(uint8_t r) {
|
|
uint32_t id;
|
|
uint8_t x;
|
|
|
|
// try reading register #4
|
|
CS_ACTIVE;
|
|
CD_COMMAND;
|
|
write8(r);
|
|
setReadDir(); // Set up LCD data port(s) for READ operations
|
|
CD_DATA;
|
|
delayMicroseconds(50);
|
|
read8(x);
|
|
id = x; // Do not merge or otherwise simplify
|
|
id <<= 8; // these lines. It's an unfortunate
|
|
read8(x);
|
|
id |= x; // shenanigans that are going on.
|
|
id <<= 8; // these lines. It's an unfortunate
|
|
read8(x);
|
|
id |= x; // shenanigans that are going on.
|
|
id <<= 8; // these lines. It's an unfortunate
|
|
read8(x);
|
|
id |= x; // shenanigans that are going on.
|
|
CS_IDLE;
|
|
setWriteDir(); // Restore LCD data port(s) to WRITE configuration
|
|
|
|
return id;
|
|
}
|
|
|
|
// Pass 8-bit (each) R,G,B, get back 16-bit packed color
|
|
uint16_t Adafruit_ILI9341_8bit_AS::color565(uint8_t r, uint8_t g, uint8_t b) {
|
|
return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
|
|
}
|
|
|
|
// For I/O macros that were left undefined, declare function
|
|
// versions that reference the inline macros just once:
|
|
|
|
#ifndef write8
|
|
void Adafruit_ILI9341_8bit_AS::write8(uint8_t value) {
|
|
write8inline(value);
|
|
}
|
|
#endif
|
|
|
|
#ifdef read8isFunctionalized
|
|
uint8_t Adafruit_ILI9341_8bit_AS::read8fn(void) {
|
|
uint8_t result;
|
|
read8inline(result);
|
|
return result;
|
|
}
|
|
#endif
|
|
|
|
#ifndef setWriteDir
|
|
void Adafruit_ILI9341_8bit_AS::setWriteDir(void) {
|
|
setWriteDirInline();
|
|
}
|
|
#endif
|
|
|
|
#ifndef setReadDir
|
|
void Adafruit_ILI9341_8bit_AS::setReadDir(void) {
|
|
setReadDirInline();
|
|
}
|
|
#endif
|
|
|
|
#ifndef writeRegister8
|
|
void Adafruit_ILI9341_8bit_AS::writeRegister8(uint8_t a, uint8_t d) {
|
|
writeRegister8inline(a, d);
|
|
}
|
|
#endif
|
|
|
|
#ifndef writeRegister16
|
|
void Adafruit_ILI9341_8bit_AS::writeRegister16(uint16_t a, uint16_t d) {
|
|
writeRegister16inline(a, d);
|
|
}
|
|
#endif
|
|
|
|
#ifndef writeRegisterPair
|
|
void Adafruit_ILI9341_8bit_AS::writeRegisterPair(uint8_t aH, uint8_t aL, uint16_t d) {
|
|
writeRegisterPairInline(aH, aL, d);
|
|
}
|
|
#endif
|
|
|
|
|
|
void Adafruit_ILI9341_8bit_AS::writeRegister24(uint8_t r, uint32_t d) {
|
|
CS_ACTIVE;
|
|
CD_COMMAND;
|
|
write8(r);
|
|
CD_DATA;
|
|
delayMicroseconds(10);
|
|
write8(d >> 16);
|
|
delayMicroseconds(10);
|
|
write8(d >> 8);
|
|
delayMicroseconds(10);
|
|
write8(d);
|
|
CS_IDLE;
|
|
|
|
}
|
|
|
|
|
|
void Adafruit_ILI9341_8bit_AS::writeRegister32(uint8_t r, uint32_t d) {
|
|
CS_ACTIVE;
|
|
CD_COMMAND;
|
|
write8(r);
|
|
CD_DATA;
|
|
delayMicroseconds(10);
|
|
write8(d >> 24);
|
|
delayMicroseconds(10);
|
|
write8(d >> 16);
|
|
delayMicroseconds(10);
|
|
write8(d >> 8);
|
|
delayMicroseconds(10);
|
|
write8(d);
|
|
CS_IDLE;
|
|
|
|
}
|