411 lines
18 KiB
C
411 lines
18 KiB
C
#ifndef _pin_magic_
|
|
#define _pin_magic_
|
|
|
|
// This header file serves two purposes:
|
|
//
|
|
// 1) Isolate non-portable MCU port- and pin-specific identifiers and
|
|
// operations so the library code itself remains somewhat agnostic
|
|
// (PORTs and pin numbers are always referenced through macros).
|
|
//
|
|
// 2) GCC doesn't always respect the "inline" keyword, so this is a
|
|
// ham-fisted manner of forcing the issue to minimize function calls.
|
|
// This sometimes makes the library a bit bigger than before, but fast++.
|
|
// However, because they're macros, we need to be SUPER CAREFUL about
|
|
// parameters -- for example, write8(x) may expand to multiple PORT
|
|
// writes that all refer to x, so it needs to be a constant or fixed
|
|
// variable and not something like *ptr++ (which, after macro
|
|
// expansion, may increment the pointer repeatedly and run off into
|
|
// la-la land). Macros also give us fine-grained control over which
|
|
// operations are inlined on which boards (balancing speed against
|
|
// available program space).
|
|
|
|
// When using the TFT shield, control and data pins exist in set physical
|
|
// locations, but the ports and bitmasks corresponding to each vary among
|
|
// boards. A separate set of pin definitions is given for each supported
|
|
// board type.
|
|
// When using the TFT breakout board, control pins are configurable but
|
|
// the data pins are still fixed -- making every data pin configurable
|
|
// would be much too slow. The data pin layouts are not the same between
|
|
// the shield and breakout configurations -- for the latter, pins were
|
|
// chosen to keep the tutorial wiring manageable more than making optimal
|
|
// use of ports and bitmasks. So there's a second set of pin definitions
|
|
// given for each supported board.
|
|
|
|
// Shield pin usage:
|
|
// LCD Data Bit : 7 6 5 4 3 2 1 0
|
|
// Digital pin #: 7 6 13 4 11 10 9 8
|
|
// Uno port/pin : PD7 PD6 PB5 PD4 PB3 PB2 PB1 PB0
|
|
// Mega port/pin: PH4 PH3 PB7 PG5 PB5 PB4 PH6 PH5
|
|
// Leo port/pin : PE6 PD7 PC7 PD4 PB7 PB6 PB5 PB4
|
|
// Due port/pin : PC23 PC24 PB27 PC26 PD7 PC29 PC21 PC22
|
|
// Breakout pin usage:
|
|
// LCD Data Bit : 7 6 5 4 3 2 1 0
|
|
// Uno dig. pin : 7 6 5 4 3 2 9 8
|
|
// Uno port/pin : PD7 PD6 PD5 PD4 PD3 PD2 PB1 PB0
|
|
// Mega dig. pin: 29 28 27 26 25 24 23 22
|
|
// Mega port/pin: PA7 PA6 PA5 PA4 PA3 PA2 PA1 PA0 (one contiguous PORT)
|
|
// Leo dig. pin : 7 6 5 4 3 2 9 8
|
|
// Leo port/pin : PE6 PD7 PC6 PD4 PD0 PD1 PB5 PB4
|
|
// Due dig. pin : 40 39 38 37 36 35 34 33
|
|
// Due port/pin : PC8 PC7 PC6 PC5 PC4 PC3 PC2 PC1 (one contiguous PORT. -ish…)
|
|
|
|
// Pixel read operations require a minimum 400 nS delay from RD_ACTIVE
|
|
// to polling the input pins. At 16 MHz, one machine cycle is 62.5 nS.
|
|
// 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" \
|
|
::);
|
|
|
|
#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega328P__) || defined (__AVR_ATmega328__) || defined(__AVR_ATmega8__)
|
|
|
|
// Arduino Uno, Duemilanove, etc.
|
|
|
|
#ifdef USE_ADAFRUIT_SHIELD_PINOUT
|
|
|
|
// 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
|
|
|
|
// These are macros for I/O operations...
|
|
|
|
// 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
|
|
|
|
// 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; }
|
|
|
|
// 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; }
|
|
|
|
#else // Uno w/Breakout board
|
|
|
|
#define write8inline(d) { \
|
|
PORTD = (PORTD & B00000111) | ((d) & B11111000); \
|
|
PORTB = (PORTB & B11111100) | ((d) & B00000011); \
|
|
PORTC = (PORTC & B11011111) | (((d) & B00000100) << 3); \
|
|
WR_STROBE; }
|
|
#define read8inline(result) { \
|
|
RD_ACTIVE; \
|
|
DELAY7; \
|
|
result = (PIND & B11111000) | (PINB & B00000011) | ((PINC & B00100000) >> 3); \
|
|
RD_IDLE; }
|
|
#define setWriteDirInline() { DDRD |= B11111000; DDRB |= B00000011; DDRC |= B00100000; }
|
|
#define setReadDirInline() { DDRD &= ~B11111000; DDRB &= ~B00000011; DDRC &= ~B00100000; }
|
|
|
|
#endif
|
|
|
|
// 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
|
|
|
|
#elif defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2561__) || defined(__AVR_ATmega2560__) || defined(__AVR_ATmega1280__)
|
|
|
|
// Arduino Mega, ADK, etc.
|
|
|
|
#ifdef USE_ADAFRUIT_SHIELD_PINOUT
|
|
|
|
#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
|
|
|
|
#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; }
|
|
|
|
#else // Mega w/Breakout board
|
|
|
|
#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
|
|
|
|
#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 writeRegisterPair writeRegisterPairInline
|
|
|
|
#elif defined(__AVR_ATmega32U4__)
|
|
|
|
// Arduino Leonardo
|
|
|
|
#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 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
|
|
|
|
#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
|
|
|
|
// 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(__SAM3X8E__)
|
|
|
|
// Arduino Due
|
|
|
|
#ifdef USE_ADAFRUIT_SHIELD_PINOUT
|
|
|
|
#define RD_PORT PIOA /*pin A0 */
|
|
#define WR_PORT PIOA /*pin A1 */
|
|
#define CD_PORT PIOA /*pin A2 */
|
|
#define CS_PORT PIOA /*pin A3 */
|
|
#define RD_MASK 0x00010000
|
|
#define WR_MASK 0x01000000
|
|
#define CD_MASK 0x00800000
|
|
#define CS_MASK 0x00400000
|
|
|
|
#define write8inline(d) { \
|
|
PIO_Set(PIOD, (((d) & 0x08)<<(7-3))); \
|
|
PIO_Clear(PIOD, (((~d) & 0x08)<<(7-3))); \
|
|
PIO_Set(PIOC, (((d) & 0x01)<<(22-0)) | (((d) & 0x02)<<(21-1))| (((d) & 0x04)<<(29-2))| (((d) & 0x10)<<(26-4))| (((d) & 0x40)<<(24-6))| (((d) & 0x80)<<(23-7))); \
|
|
PIO_Clear(PIOC, (((~d) & 0x01)<<(22-0)) | (((~d) & 0x02)<<(21-1))| (((~d) & 0x04)<<(29-2))| (((~d) & 0x10)<<(26-4))| (((~d) & 0x40)<<(24-6))| (((~d) & 0x80)<<(23-7))); \
|
|
PIO_Set(PIOB, (((d) & 0x20)<<(27-5))); \
|
|
PIO_Clear(PIOB, (((~d) & 0x20)<<(27-5))); \
|
|
WR_STROBE; }
|
|
|
|
#define read8inline(result) { \
|
|
RD_ACTIVE; \
|
|
delayMicroseconds(1); \
|
|
result = (((PIOC->PIO_PDSR & (1<<23)) >> (23-7)) | ((PIOC->PIO_PDSR & (1<<24)) >> (24-6)) | \
|
|
((PIOB->PIO_PDSR & (1<<27)) >> (27-5)) | ((PIOC->PIO_PDSR & (1<<26)) >> (26-4)) | \
|
|
((PIOD->PIO_PDSR & (1<< 7)) >> ( 7-3)) | ((PIOC->PIO_PDSR & (1<<29)) >> (29-2)) | \
|
|
((PIOC->PIO_PDSR & (1<<21)) >> (21-1)) | ((PIOC->PIO_PDSR & (1<<22)) >> (22-0))); \
|
|
RD_IDLE;}
|
|
|
|
#define setWriteDirInline() { \
|
|
PIOD->PIO_MDDR |= 0x00000080; /*PIOD->PIO_SODR = 0x00000080;*/ PIOD->PIO_OER |= 0x00000080; PIOD->PIO_PER |= 0x00000080; \
|
|
PIOC->PIO_MDDR |= 0x25E00000; /*PIOC->PIO_SODR = 0x25E00000;*/ PIOC->PIO_OER |= 0x25E00000; PIOC->PIO_PER |= 0x25E00000; \
|
|
PIOB->PIO_MDDR |= 0x08000000; /*PIOB->PIO_SODR = 0x08000000;*/ PIOB->PIO_OER |= 0x08000000; PIOB->PIO_PER |= 0x08000000; }
|
|
|
|
#define setReadDirInline() { \
|
|
pmc_enable_periph_clk( ID_PIOD ) ; pmc_enable_periph_clk( ID_PIOC ) ; pmc_enable_periph_clk( ID_PIOB ) ; \
|
|
PIOD->PIO_PUDR |= 0x00000080; PIOD->PIO_IFDR |= 0x00000080; PIOD->PIO_ODR |= 0x00000080; PIOD->PIO_PER |= 0x00000080; \
|
|
PIOC->PIO_PUDR |= 0x25E00000; PIOC->PIO_IFDR |= 0x25E00000; PIOC->PIO_ODR |= 0x25E00000; PIOC->PIO_PER |= 0x25E00000; \
|
|
PIOB->PIO_PUDR |= 0x08000000; PIOB->PIO_IFDR |= 0x08000000; PIOB->PIO_ODR |= 0x08000000; PIOB->PIO_PER |= 0x08000000; }
|
|
|
|
// Control signals are ACTIVE LOW (idle is HIGH)
|
|
// Command/Data: LOW = command, HIGH = data
|
|
// These are single-instruction operations and always inline
|
|
#define RD_ACTIVE RD_PORT->PIO_CODR |= RD_MASK
|
|
#define RD_IDLE RD_PORT->PIO_SODR |= RD_MASK
|
|
#define WR_ACTIVE WR_PORT->PIO_CODR |= WR_MASK
|
|
#define WR_IDLE WR_PORT->PIO_SODR |= WR_MASK
|
|
#define CD_COMMAND CD_PORT->PIO_CODR |= CD_MASK
|
|
#define CD_DATA CD_PORT->PIO_SODR |= CD_MASK
|
|
#define CS_ACTIVE CS_PORT->PIO_CODR |= CS_MASK
|
|
#define CS_IDLE CS_PORT->PIO_SODR |= CS_MASK
|
|
|
|
|
|
#else // Due w/Breakout board
|
|
|
|
#define write8inline(d) { \
|
|
PIO_Set(PIOC, (((d) & 0xFF)<<1)); \
|
|
PIO_Clear(PIOC, (((~d) & 0xFF)<<1)); \
|
|
WR_STROBE; }
|
|
|
|
#define read8inline(result) { \
|
|
RD_ACTIVE; \
|
|
delayMicroseconds(1); \
|
|
result = ((PIOC->PIO_PDSR & 0x1FE) >> 1); \
|
|
RD_IDLE;}
|
|
|
|
#define setWriteDirInline() { \
|
|
PIOC->PIO_MDDR |= 0x000001FE; /*PIOC->PIO_SODR |= 0x000001FE;*/ PIOC->PIO_OER |= 0x000001FE; PIOC->PIO_PER |= 0x000001FE; }
|
|
|
|
#define setReadDirInline() { \
|
|
pmc_enable_periph_clk( ID_PIOC ) ; \
|
|
PIOC->PIO_PUDR |= 0x000001FE; PIOC->PIO_IFDR |= 0x000001FE; PIOC->PIO_ODR |= 0x000001FE; PIOC->PIO_PER |= 0x000001FE; }
|
|
|
|
// When using the TFT breakout board, control pins are configurable.
|
|
#define RD_ACTIVE rdPort->PIO_CODR |= rdPinSet //PIO_Clear(rdPort, rdPinSet)
|
|
#define RD_IDLE rdPort->PIO_SODR |= rdPinSet //PIO_Set(rdPort, rdPinSet)
|
|
#define WR_ACTIVE wrPort->PIO_CODR |= wrPinSet //PIO_Clear(wrPort, wrPinSet)
|
|
#define WR_IDLE wrPort->PIO_SODR |= wrPinSet //PIO_Set(wrPort, wrPinSet)
|
|
#define CD_COMMAND cdPort->PIO_CODR |= cdPinSet //PIO_Clear(cdPort, cdPinSet)
|
|
#define CD_DATA cdPort->PIO_SODR |= cdPinSet //PIO_Set(cdPort, cdPinSet)
|
|
#define CS_ACTIVE csPort->PIO_CODR |= csPinSet //PIO_Clear(csPort, csPinSet)
|
|
#define CS_IDLE csPort->PIO_SODR |= csPinSet //PIO_Set(csPort, csPinSet)
|
|
|
|
#endif
|
|
|
|
|
|
#else
|
|
|
|
#error "Board type unsupported / not recognized"
|
|
|
|
#endif
|
|
|
|
#if !defined(__SAM3X8E__)
|
|
// Stuff common to all Arduino AVR board types:
|
|
|
|
#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
|
|
|
|
#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
|
|
|
|
#endif
|
|
#endif
|
|
|
|
// Data write strobe, ~2 instructions and always inline
|
|
#define WR_STROBE { WR_ACTIVE; WR_IDLE; }
|
|
|
|
// 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); }
|
|
|
|
// 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); }
|
|
|
|
// 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); }
|
|
|
|
#endif // _pin_magic_
|