#include <stdio.h>

#include <stdint.h>

#include "ST7735.h"

#include "msp.h"

// 16 rows (0 to 15) and 21 characters (0 to 20)

// Requires (11 + size*size*6*8) bytes of transmission for each character

uint32_t StX=0; // position along the horizonal axis 0 to 20

uint32_t StY=0; // position along the vertical axis 0 to 15

uint16_t StTextColor = ST7735_YELLOW;

uint16_t TextColor = 0;

uint16_t BgColor = 0xFFFF;

uint8_t TextSize = 1;

#define ST7735_NOP 0x00

#define ST7735_SWRESET 0x01

#define ST7735_RDDID 0x04

#define ST7735_RDDST 0x09

#define ST7735_SLPIN 0x10

#define ST7735_SLPOUT 0x11

#define ST7735_PTLON 0x12

#define ST7735_NORON 0x13

#define ST7735_INVOFF 0x20

#define ST7735_INVON 0x21

#define ST7735_DISPOFF 0x28

#define ST7735_DISPON 0x29

#define ST7735_CASET 0x2A

#define ST7735_RASET 0x2B

#define ST7735_RAMWR 0x2C

#define ST7735_RAMRD 0x2E

#define ST7735_PTLAR 0x30

#define ST7735_COLMOD 0x3A

#define ST7735_MADCTL 0x36

#define ST7735_FRMCTR1 0xB1

#define ST7735_FRMCTR2 0xB2

#define ST7735_FRMCTR3 0xB3

#define ST7735_INVCTR 0xB4

#define ST7735_DISSET5 0xB6

#define ST7735_PWCTR1 0xC0

#define ST7735_PWCTR2 0xC1

#define ST7735_PWCTR3 0xC2

#define ST7735_PWCTR4 0xC3

#define ST7735_PWCTR5 0xC4

#define ST7735_VMCTR1 0xC5

#define ST7735_RDID1 0xDA

#define ST7735_RDID2 0xDB

#define ST7735_RDID3 0xDC

#define ST7735_RDID4 0xDD

#define ST7735_PWCTR6 0xFC

#define ST7735_GMCTRP1 0xE0

#define ST7735_GMCTRN1 0xE1

#define TFT_CS (*((volatile uint8_t *)0x40004C82)) /* Port 9 Output, bit 4 is TFT CS */

#define TFT_CS_BIT 0x10 // CS normally controlled by hardware

#define DC (*((volatile uint8_t *)0x40004C82)) /* Port 9 Output, bit 2 is DC */

#define DC_BIT 0x04

#define RESET (*((volatile uint8_t *)0x40004C82)) /* Port 9 Output, bit 3 is RESET*/

#define RESET_BIT 0x08

#define ST7735_TFTWIDTH 128

#define ST7735_TFTHEIGHT 160

#define ST7735_NOP 0x00

#define ST7735_SWRESET 0x01

#define ST7735_RDDID 0x04

#define ST7735_RDDST 0x09

#define ST7735_SLPIN 0x10

#define ST7735_SLPOUT 0x11

#define ST7735_PTLON 0x12

#define ST7735_NORON 0x13

#define ST7735_INVOFF 0x20

#define ST7735_INVON 0x21

#define ST7735_DISPOFF 0x28

#define ST7735_DISPON 0x29

#define ST7735_CASET 0x2A

#define ST7735_RASET 0x2B

#define ST7735_RAMWR 0x2C

#define ST7735_RAMRD 0x2E

#define ST7735_PTLAR 0x30

#define ST7735_COLMOD 0x3A

#define ST7735_MADCTL 0x36

#define ST7735_FRMCTR1 0xB1

#define ST7735_FRMCTR2 0xB2

#define ST7735_FRMCTR3 0xB3

#define ST7735_INVCTR 0xB4

#define ST7735_DISSET5 0xB6

#define ST7735_PWCTR1 0xC0

#define ST7735_PWCTR2 0xC1

#define ST7735_PWCTR3 0xC2

#define ST7735_PWCTR4 0xC3

#define ST7735_PWCTR5 0xC4

#define ST7735_VMCTR1 0xC5

#define ST7735_RDID1 0xDA

#define ST7735_RDID2 0xDB

#define ST7735_RDID3 0xDC

#define ST7735_RDID4 0xDD

#define ST7735_PWCTR6 0xFC

#define ST7735_GMCTRP1 0xE0

#define ST7735_GMCTRN1 0xE1

// standard ascii 5x7 font

// originally from glcdfont.c from Adafruit project

static const uint8_t Font[] = {

0x00, 0x00, 0x00, 0x00, 0x00,

0x3E, 0x5B, 0x4F, 0x5B, 0x3E,

0x3E, 0x6B, 0x4F, 0x6B, 0x3E,

0x1C, 0x3E, 0x7C, 0x3E, 0x1C,

0x18, 0x3C, 0x7E, 0x3C, 0x18,

0x1C, 0x57, 0x7D, 0x57, 0x1C,

0x1C, 0x5E, 0x7F, 0x5E, 0x1C,

0x00, 0x18, 0x3C, 0x18, 0x00,

0xFF, 0xE7, 0xC3, 0xE7, 0xFF,

0x00, 0x18, 0x24, 0x18, 0x00,

0xFF, 0xE7, 0xDB, 0xE7, 0xFF,

0x30, 0x48, 0x3A, 0x06, 0x0E,

0x26, 0x29, 0x79, 0x29, 0x26,

0x40, 0x7F, 0x05, 0x05, 0x07,

0x40, 0x7F, 0x05, 0x25, 0x3F,

0x5A, 0x3C, 0xE7, 0x3C, 0x5A,

0x7F, 0x3E, 0x1C, 0x1C, 0x08,

0x08, 0x1C, 0x1C, 0x3E, 0x7F,

0x14, 0x22, 0x7F, 0x22, 0x14,

0x5F, 0x5F, 0x00, 0x5F, 0x5F,

0x06, 0x09, 0x7F, 0x01, 0x7F,

0x00, 0x66, 0x89, 0x95, 0x6A,

0x60, 0x60, 0x60, 0x60, 0x60,

0x94, 0xA2, 0xFF, 0xA2, 0x94,

0x08, 0x04, 0x7E, 0x04, 0x08,

0x10, 0x20, 0x7E, 0x20, 0x10,

0x08, 0x08, 0x2A, 0x1C, 0x08,

0x08, 0x1C, 0x2A, 0x08, 0x08,

0x1E, 0x10, 0x10, 0x10, 0x10,

0x0C, 0x1E, 0x0C, 0x1E, 0x0C,

0x30, 0x38, 0x3E, 0x38, 0x30,

0x06, 0x0E, 0x3E, 0x0E, 0x06,

0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x5F, 0x00, 0x00,

0x00, 0x07, 0x00, 0x07, 0x00,

0x14, 0x7F, 0x14, 0x7F, 0x14,

0x24, 0x2A, 0x7F, 0x2A, 0x12,

0x23, 0x13, 0x08, 0x64, 0x62,

0x36, 0x49, 0x56, 0x20, 0x50,

0x00, 0x08, 0x07, 0x03, 0x00,

0x00, 0x1C, 0x22, 0x41, 0x00,

0x00, 0x41, 0x22, 0x1C, 0x00,

0x2A, 0x1C, 0x7F, 0x1C, 0x2A,

0x08, 0x08, 0x3E, 0x08, 0x08,

0x00, 0x80, 0x70, 0x30, 0x00,

0x08, 0x08, 0x08, 0x08, 0x08,

0x00, 0x00, 0x60, 0x60, 0x00,

0x20, 0x10, 0x08, 0x04, 0x02,

0x3E, 0x51, 0x49, 0x45, 0x3E, // 0

0x00, 0x42, 0x7F, 0x40, 0x00, // 1

0x72, 0x49, 0x49, 0x49, 0x46, // 2

0x21, 0x41, 0x49, 0x4D, 0x33, // 3

0x18, 0x14, 0x12, 0x7F, 0x10, // 4

0x27, 0x45, 0x45, 0x45, 0x39, // 5

0x3C, 0x4A, 0x49, 0x49, 0x31, // 6

0x41, 0x21, 0x11, 0x09, 0x07, // 7

0x36, 0x49, 0x49, 0x49, 0x36, // 8

0x46, 0x49, 0x49, 0x29, 0x1E, // 9

0x00, 0x00, 0x14, 0x00, 0x00,

0x00, 0x40, 0x34, 0x00, 0x00,

0x00, 0x08, 0x14, 0x22, 0x41,

0x14, 0x14, 0x14, 0x14, 0x14,

0x00, 0x41, 0x22, 0x14, 0x08,

0x02, 0x01, 0x59, 0x09, 0x06,

0x3E, 0x41, 0x5D, 0x59, 0x4E,

0x7C, 0x12, 0x11, 0x12, 0x7C, // A

0x7F, 0x49, 0x49, 0x49, 0x36, // B

0x3E, 0x41, 0x41, 0x41, 0x22, // C

0x7F, 0x41, 0x41, 0x41, 0x3E, // D

0x7F, 0x49, 0x49, 0x49, 0x41, // E

0x7F, 0x09, 0x09, 0x09, 0x01, // F

0x3E, 0x41, 0x41, 0x51, 0x73, // G

0x7F, 0x08, 0x08, 0x08, 0x7F, // H

0x00, 0x41, 0x7F, 0x41, 0x00, // I

0x20, 0x40, 0x41, 0x3F, 0x01, // J

0x7F, 0x08, 0x14, 0x22, 0x41, // K

0x7F, 0x40, 0x40, 0x40, 0x40, // L

0x7F, 0x02, 0x1C, 0x02, 0x7F, // M

0x7F, 0x04, 0x08, 0x10, 0x7F, // N

0x3E, 0x41, 0x41, 0x41, 0x3E, // O

0x7F, 0x09, 0x09, 0x09, 0x06, // P

0x3E, 0x41, 0x51, 0x21, 0x5E, // Q

0x7F, 0x09, 0x19, 0x29, 0x46, // R

0x26, 0x49, 0x49, 0x49, 0x32, // S

0x03, 0x01, 0x7F, 0x01, 0x03, // T

0x3F, 0x40, 0x40, 0x40, 0x3F, // U

0x1F, 0x20, 0x40, 0x20, 0x1F, // V

0x3F, 0x40, 0x38, 0x40, 0x3F, // W

0x63, 0x14, 0x08, 0x14, 0x63, // X

0x03, 0x04, 0x78, 0x04, 0x03, // Y

0x61, 0x59, 0x49, 0x4D, 0x43, // Z

0x00, 0x7F, 0x41, 0x41, 0x41,

0x02, 0x04, 0x08, 0x10, 0x20,

0x00, 0x41, 0x41, 0x41, 0x7F,

0x04, 0x02, 0x01, 0x02, 0x04,

0x40, 0x40, 0x40, 0x40, 0x40,

0x00, 0x03, 0x07, 0x08, 0x00,

0x20, 0x54, 0x54, 0x78, 0x40, // a

0x7F, 0x28, 0x44, 0x44, 0x38, // b

0x38, 0x44, 0x44, 0x44, 0x28, // c

0x38, 0x44, 0x44, 0x28, 0x7F, // d

0x38, 0x54, 0x54, 0x54, 0x18, // e

0x00, 0x08, 0x7E, 0x09, 0x02, // f

0x18, 0xA4, 0xA4, 0x9C, 0x78, // g

0x7F, 0x08, 0x04, 0x04, 0x78, // h

0x00, 0x44, 0x7D, 0x40, 0x00, // i

0x20, 0x40, 0x40, 0x3D, 0x00, // j

0x7F, 0x10, 0x28, 0x44, 0x00, // k

0x00, 0x41, 0x7F, 0x40, 0x00, // l

0x7C, 0x04, 0x78, 0x04, 0x78, // m

0x7C, 0x08, 0x04, 0x04, 0x78, // n

0x38, 0x44, 0x44, 0x44, 0x38, // o

0xFC, 0x18, 0x24, 0x24, 0x18, // p

0x18, 0x24, 0x24, 0x18, 0xFC, // q

0x7C, 0x08, 0x04, 0x04, 0x08, // r

0x48, 0x54, 0x54, 0x54, 0x24, // s

0x04, 0x04, 0x3F, 0x44, 0x24, // t

0x3C, 0x40, 0x40, 0x20, 0x7C, // u

0x1C, 0x20, 0x40, 0x20, 0x1C, // v

0x3C, 0x40, 0x30, 0x40, 0x3C, // w

0x44, 0x28, 0x10, 0x28, 0x44, // x

0x4C, 0x90, 0x90, 0x90, 0x7C, // y

0x44, 0x64, 0x54, 0x4C, 0x44, // z

0x00, 0x08, 0x36, 0x41, 0x00,

0x00, 0x00, 0x77, 0x00, 0x00,

0x00, 0x41, 0x36, 0x08, 0x00,

0x02, 0x01, 0x02, 0x04, 0x02,

0x3C, 0x26, 0x23, 0x26, 0x3C,

0x1E, 0xA1, 0xA1, 0x61, 0x12,

0x3A, 0x40, 0x40, 0x20, 0x7A,

0x38, 0x54, 0x54, 0x55, 0x59,

0x21, 0x55, 0x55, 0x79, 0x41,

0x21, 0x54, 0x54, 0x78, 0x41,

0x21, 0x55, 0x54, 0x78, 0x40,

0x20, 0x54, 0x55, 0x79, 0x40,

0x0C, 0x1E, 0x52, 0x72, 0x12,

0x39, 0x55, 0x55, 0x55, 0x59,

0x39, 0x54, 0x54, 0x54, 0x59,

0x39, 0x55, 0x54, 0x54, 0x58,

0x00, 0x00, 0x45, 0x7C, 0x41,

0x00, 0x02, 0x45, 0x7D, 0x42,

0x00, 0x01, 0x45, 0x7C, 0x40,

0xF0, 0x29, 0x24, 0x29, 0xF0,

0xF0, 0x28, 0x25, 0x28, 0xF0,

0x7C, 0x54, 0x55, 0x45, 0x00,

0x20, 0x54, 0x54, 0x7C, 0x54,

0x7C, 0x0A, 0x09, 0x7F, 0x49,

0x32, 0x49, 0x49, 0x49, 0x32,

0x32, 0x48, 0x48, 0x48, 0x32,

0x32, 0x4A, 0x48, 0x48, 0x30,

0x3A, 0x41, 0x41, 0x21, 0x7A,

0x3A, 0x42, 0x40, 0x20, 0x78,

0x00, 0x9D, 0xA0, 0xA0, 0x7D,

0x39, 0x44, 0x44, 0x44, 0x39,

0x3D, 0x40, 0x40, 0x40, 0x3D,

0x3C, 0x24, 0xFF, 0x24, 0x24,

0x48, 0x7E, 0x49, 0x43, 0x66,

0x2B, 0x2F, 0xFC, 0x2F, 0x2B,

0xFF, 0x09, 0x29, 0xF6, 0x20,

0xC0, 0x88, 0x7E, 0x09, 0x03,

0x20, 0x54, 0x54, 0x79, 0x41,

0x00, 0x00, 0x44, 0x7D, 0x41,

0x30, 0x48, 0x48, 0x4A, 0x32,

0x38, 0x40, 0x40, 0x22, 0x7A,

0x00, 0x7A, 0x0A, 0x0A, 0x72,

0x7D, 0x0D, 0x19, 0x31, 0x7D,

0x26, 0x29, 0x29, 0x2F, 0x28,

0x26, 0x29, 0x29, 0x29, 0x26,

0x30, 0x48, 0x4D, 0x40, 0x20,

0x38, 0x08, 0x08, 0x08, 0x08,

0x08, 0x08, 0x08, 0x08, 0x38,

0x2F, 0x10, 0xC8, 0xAC, 0xBA,

0x2F, 0x10, 0x28, 0x34, 0xFA,

0x00, 0x00, 0x7B, 0x00, 0x00,

0x08, 0x14, 0x2A, 0x14, 0x22,

0x22, 0x14, 0x2A, 0x14, 0x08,

0xAA, 0x00, 0x55, 0x00, 0xAA,

0xAA, 0x55, 0xAA, 0x55, 0xAA,

0x00, 0x00, 0x00, 0xFF, 0x00,

0x10, 0x10, 0x10, 0xFF, 0x00,

0x14, 0x14, 0x14, 0xFF, 0x00,

0x10, 0x10, 0xFF, 0x00, 0xFF,

0x10, 0x10, 0xF0, 0x10, 0xF0,

0x14, 0x14, 0x14, 0xFC, 0x00,

0x14, 0x14, 0xF7, 0x00, 0xFF,

0x00, 0x00, 0xFF, 0x00, 0xFF,

0x14, 0x14, 0xF4, 0x04, 0xFC,

0x14, 0x14, 0x17, 0x10, 0x1F,

0x10, 0x10, 0x1F, 0x10, 0x1F,

0x14, 0x14, 0x14, 0x1F, 0x00,

0x10, 0x10, 0x10, 0xF0, 0x00,

0x00, 0x00, 0x00, 0x1F, 0x10,

0x10, 0x10, 0x10, 0x1F, 0x10,

0x10, 0x10, 0x10, 0xF0, 0x10,

0x00, 0x00, 0x00, 0xFF, 0x10,

0x10, 0x10, 0x10, 0x10, 0x10,

0x10, 0x10, 0x10, 0xFF, 0x10,

0x00, 0x00, 0x00, 0xFF, 0x14,

0x00, 0x00, 0xFF, 0x00, 0xFF,

0x00, 0x00, 0x1F, 0x10, 0x17,

0x00, 0x00, 0xFC, 0x04, 0xF4,

0x14, 0x14, 0x17, 0x10, 0x17,

0x14, 0x14, 0xF4, 0x04, 0xF4,

0x00, 0x00, 0xFF, 0x00, 0xF7,

0x14, 0x14, 0x14, 0x14, 0x14,

0x14, 0x14, 0xF7, 0x00, 0xF7,

0x14, 0x14, 0x14, 0x17, 0x14,

0x10, 0x10, 0x1F, 0x10, 0x1F,

0x14, 0x14, 0x14, 0xF4, 0x14,

0x10, 0x10, 0xF0, 0x10, 0xF0,

0x00, 0x00, 0x1F, 0x10, 0x1F,

0x00, 0x00, 0x00, 0x1F, 0x14,

0x00, 0x00, 0x00, 0xFC, 0x14,

0x00, 0x00, 0xF0, 0x10, 0xF0,

0x10, 0x10, 0xFF, 0x10, 0xFF,

0x14, 0x14, 0x14, 0xFF, 0x14,

0x10, 0x10, 0x10, 0x1F, 0x00,

0x00, 0x00, 0x00, 0xF0, 0x10,

0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

0xF0, 0xF0, 0xF0, 0xF0, 0xF0,

0xFF, 0xFF, 0xFF, 0x00, 0x00,

0x00, 0x00, 0x00, 0xFF, 0xFF,

0x0F, 0x0F, 0x0F, 0x0F, 0x0F,

0x38, 0x44, 0x44, 0x38, 0x44,

0x7C, 0x2A, 0x2A, 0x3E, 0x14,

0x7E, 0x02, 0x02, 0x06, 0x06,

0x02, 0x7E, 0x02, 0x7E, 0x02,

0x63, 0x55, 0x49, 0x41, 0x63,

0x38, 0x44, 0x44, 0x3C, 0x04,

0x40, 0x7E, 0x20, 0x1E, 0x20,

0x06, 0x02, 0x7E, 0x02, 0x02,

0x99, 0xA5, 0xE7, 0xA5, 0x99,

0x1C, 0x2A, 0x49, 0x2A, 0x1C,

0x4C, 0x72, 0x01, 0x72, 0x4C,

0x30, 0x4A, 0x4D, 0x4D, 0x30,

0x30, 0x48, 0x78, 0x48, 0x30,

0xBC, 0x62, 0x5A, 0x46, 0x3D,

0x3E, 0x49, 0x49, 0x49, 0x00,

0x7E, 0x01, 0x01, 0x01, 0x7E,

0x2A, 0x2A, 0x2A, 0x2A, 0x2A,

0x44, 0x44, 0x5F, 0x44, 0x44,

0x40, 0x51, 0x4A, 0x44, 0x40,

0x40, 0x44, 0x4A, 0x51, 0x40,

0x00, 0x00, 0xFF, 0x01, 0x03,

0xE0, 0x80, 0xFF, 0x00, 0x00,

0x08, 0x08, 0x6B, 0x6B, 0x08,

0x36, 0x12, 0x36, 0x24, 0x36,

0x06, 0x0F, 0x09, 0x0F, 0x06,

0x00, 0x00, 0x18, 0x18, 0x00,

0x00, 0x00, 0x10, 0x10, 0x00,

0x30, 0x40, 0xFF, 0x01, 0x01,

0x00, 0x1F, 0x01, 0x01, 0x1E,

0x00, 0x19, 0x1D, 0x17, 0x12,

0x00, 0x3C, 0x3C, 0x3C, 0x3C,

0x00, 0x00, 0x00, 0x00, 0x00,

};

static uint8_t ColStart, RowStart; // some displays need this changed

static uint8_t Rotation; // 0 to 3

static enum initRFlags TabColor;

static int16_t _width = ST7735_TFTWIDTH; // this could probably be a constant, except it is used in Adafruit_GFX and depends on image rotation

static int16_t _height = ST7735_TFTHEIGHT;

// The Data/Command pin must be valid when the eighth bit is

// sent. The eUSCI module has no hardware input or output

// FIFOs, so this implementation is much simpler than it was

// for the Tiva LaunchPads.

// All operations wait until all data has been sent,

// configure the Data/Command pin, queue the message, and

// return the reply once it comes in.

// This is a helper function that sends an 8-bit command to the LCD.

// Inputs: c 8-bit code to transmit

// Outputs: 8-bit reply

// Assumes: UCA3 and Port 9 have already been initialized and enabled

uint8_t static writecommand(uint8_t c) {

TFT_CS &= ~TFT_CS_BIT;

// __delay_cycles(1000);

// TFT_CS |= TFT_CS_BIT;

while((UCA3IFG&0x0002)==0x0000){}; // wait until UCA3TXBUF empty

DC &= ~DC_BIT;

UCA3TXBUF = c; // command out

while((UCA3IFG&0x0001)==0x0000){}; // wait until UCA3RXBUF full

// TFT_CS &= ~TFT_CS_BIT;

TFT_CS |= TFT_CS_BIT;

return UCA3RXBUF; // return the response

}

// This is a helper function that sends a piece of 8-bit data to the LCD.

// Inputs: c 8-bit data to transmit

// Outputs: 8-bit reply

// Assumes: UCA3 and Port 9 have already been initialized and enabled

uint8_t static writedata(uint8_t c) {

TFT_CS &= ~TFT_CS_BIT;

// __delay_cycles(1000);

// TFT_CS |= TFT_CS_BIT; while((UCA3IFG&0x0002)==0x0000){}; // wait until UCA3TXBUF empty

DC |= DC_BIT;

UCA3TXBUF = c; // data out

while((UCA3IFG&0x0001)==0x0000){}; // wait until UCA3RXBUF full

// TFT_CS &= ~TFT_CS_BIT;

TFT_CS |= TFT_CS_BIT; return UCA3RXBUF; // return the response

}

// delay function for testing

// which delays about 8.1*ulCount cycles

#ifdef __TI_COMPILER_VERSION__

//Code Composer Studio Code

void parrotdelay(unsigned long ulCount){

__asm ( "pdloop: subs r0, #1\n"

" bne pdloop\n");

}

#else

//Keil uVision Code

__asm void

parrotdelay(unsigned long ulCount)

{

subs r0, #1

bne parrotdelay

bx lr

}

#endif

// Subroutine to wait 1 msec

// Inputs: n number of 1 msec to wait

// Outputs: None

// Notes: ...

void Delay1ms(uint32_t n){

while(n){

parrotdelay(5901); // 1 msec, tuned at 48 MHz

n--;

}

}

void DelayWait10ms(uint32_t n)

{

Delay1ms(n*10);

}

// Rather than a bazillion writecommand() and writedata() calls, screen

// initialization commands and arguments are organized in these tables

// stored in ROM. The table may look bulky, but that's mostly the

// formatting -- storage-wise this is hundreds of bytes more compact

// than the equivalent code. Companion function follows.

#define DELAY 0x80

static const uint8_t

Bcmd[] = { // Initialization commands for 7735B screens

18, // 18 commands in list:

ST7735_SWRESET, DELAY, // 1: Software reset, no args, w/delay

50, // 50 ms delay

ST7735_SLPOUT , DELAY, // 2: Out of sleep mode, no args, w/delay

255, // 255 = 500 ms delay

ST7735_COLMOD , 1+DELAY, // 3: Set color mode, 1 arg + delay:

0x05, // 16-bit color

10, // 10 ms delay

ST7735_FRMCTR1, 3+DELAY, // 4: Frame rate control, 3 args + delay:

0x00, // fastest refresh

0x06, // 6 lines front porch

0x03, // 3 lines back porch

10, // 10 ms delay

ST7735_MADCTL , 1 , // 5: Memory access ctrl (directions), 1 arg:

0x08, // Row addr/col addr, bottom to top refresh

ST7735_DISSET5, 2 , // 6: Display settings #5, 2 args, no delay:

0x15, // 1 clk cycle nonoverlap, 2 cycle gate

// rise, 3 cycle osc equalize

0x02, // Fix on VTL

ST7735_INVCTR , 1 , // 7: Display inversion control, 1 arg:

0x0, // Line inversion

ST7735_PWCTR1 , 2+DELAY, // 8: Power control, 2 args + delay:

0x02, // GVDD = 4.7V

0x70, // 1.0uA

10, // 10 ms delay

ST7735_PWCTR2 , 1 , // 9: Power control, 1 arg, no delay:

0x05, // VGH = 14.7V, VGL = -7.35V

ST7735_PWCTR3 , 2 , // 10: Power control, 2 args, no delay:

0x01, // Opamp current small

0x02, // Boost frequency

ST7735_VMCTR1 , 2+DELAY, // 11: Power control, 2 args + delay:

0x3C, // VCOMH = 4V

0x38, // VCOML = -1.1V

10, // 10 ms delay

ST7735_PWCTR6 , 2 , // 12: Power control, 2 args, no delay:

0x11, 0x15,

ST7735_GMCTRP1,16 , // 13: Magical unicorn dust, 16 args, no delay:

0x09, 0x16, 0x09, 0x20, // (seriously though, not sure what

0x21, 0x1B, 0x13, 0x19, // these config values represent)

0x17, 0x15, 0x1E, 0x2B,

0x04, 0x05, 0x02, 0x0E,

ST7735_GMCTRN1,16+DELAY, // 14: Sparkles and rainbows, 16 args + delay:

0x0B, 0x14, 0x08, 0x1E, // (ditto)

0x22, 0x1D, 0x18, 0x1E,

0x1B, 0x1A, 0x24, 0x2B,

0x06, 0x06, 0x02, 0x0F,

10, // 10 ms delay

ST7735_CASET , 4 , // 15: Column addr set, 4 args, no delay:

0x00, 0x02, // XSTART = 2

0x00, 0x81, // XEND = 129

ST7735_RASET , 4 , // 16: Row addr set, 4 args, no delay:

0x00, 0x02, // XSTART = 1

0x00, 0x81, // XEND = 160

ST7735_NORON , DELAY, // 17: Normal display on, no args, w/delay

10, // 10 ms delay

ST7735_DISPON , DELAY, // 18: Main screen turn on, no args, w/delay

255 }; // 255 = 500 ms delay

static const uint8_t

Rcmd1[] = { // Init for 7735R, part 1 (red or green tab)

15, // 15 commands in list:

ST7735_SWRESET, DELAY, // 1: Software reset, 0 args, w/delay

150, // 150 ms delay

ST7735_SLPOUT , DELAY, // 2: Out of sleep mode, 0 args, w/delay

255, // 500 ms delay

ST7735_FRMCTR1, 3 , // 3: Frame rate ctrl - normal mode, 3 args:

0x01, 0x2C, 0x2D, // Rate = fosc/(1x2+40) * (LINE+2C+2D)

ST7735_FRMCTR2, 3 , // 4: Frame rate control - idle mode, 3 args:

0x01, 0x2C, 0x2D, // Rate = fosc/(1x2+40) * (LINE+2C+2D)

ST7735_FRMCTR3, 6 , // 5: Frame rate ctrl - partial mode, 6 args:

0x01, 0x2C, 0x2D, // Dot inversion mode

0x01, 0x2C, 0x2D, // Line inversion mode

ST7735_INVCTR , 1 , // 6: Display inversion ctrl, 1 arg, no delay:

0x07, // No inversion

ST7735_PWCTR1 , 3 , // 7: Power control, 3 args, no delay:

0xA2,

0x02, // -4.6V

0x84, // AUTO mode

ST7735_PWCTR2 , 1 , // 8: Power control, 1 arg, no delay:

0xC5, // VGH25 = 2.4C VGSEL = -10 VGH = 3 * AVDD

ST7735_PWCTR3 , 2 , // 9: Power control, 2 args, no delay:

0x0A, // Opamp current small

0x00, // Boost frequency

ST7735_PWCTR4 , 2 , // 10: Power control, 2 args, no delay:

0x8A, // BCLK/2, Opamp current small & Medium low

0x2A,

ST7735_PWCTR5 , 2 , // 11: Power control, 2 args, no delay:

0x8A, 0xEE,

ST7735_VMCTR1 , 1 , // 12: Power control, 1 arg, no delay:

0x0E,

ST7735_INVOFF , 0 , // 13: Don't invert display, no args, no delay

ST7735_MADCTL , 1 , // 14: Memory access control (directions), 1 arg:

0xC8, // row addr/col addr, bottom to top refresh

ST7735_COLMOD , 1 , // 15: set color mode, 1 arg, no delay:

0x05 }; // 16-bit color

static const uint8_t

Rcmd2green[] = { // Init for 7735R, part 2 (green tab only)

2, // 2 commands in list:

ST7735_CASET , 4 , // 1: Column addr set, 4 args, no delay:

0x00, 0x02, // XSTART = 0

0x00, 0x7F+0x02, // XEND = 127

ST7735_RASET , 4 , // 2: Row addr set, 4 args, no delay:

0x00, 0x01, // XSTART = 0

0x00, 0x9F+0x01 }; // XEND = 159

static const uint8_t

Rcmd2red[] = { // Init for 7735R, part 2 (red tab only)

2, // 2 commands in list:

ST7735_CASET , 4 , // 1: Column addr set, 4 args, no delay:

0x00, 0x00, // XSTART = 0

0x00, 0x7F, // XEND = 127

ST7735_RASET , 4 , // 2: Row addr set, 4 args, no delay:

0x00, 0x00, // XSTART = 0

0x00, 0x9F }; // XEND = 159

static const uint8_t

Rcmd3[] = { // Init for 7735R, part 3 (red or green tab)

4, // 4 commands in list:

ST7735_GMCTRP1, 16 , // 1: Magical unicorn dust, 16 args, no delay:

0x02, 0x1c, 0x07, 0x12,

0x37, 0x32, 0x29, 0x2d,

0x29, 0x25, 0x2B, 0x39,

0x00, 0x01, 0x03, 0x10,

ST7735_GMCTRN1, 16 , // 2: Sparkles and rainbows, 16 args, no delay:

0x03, 0x1d, 0x07, 0x06,

0x2E, 0x2C, 0x29, 0x2D,

0x2E, 0x2E, 0x37, 0x3F,

0x00, 0x00, 0x02, 0x10,

ST7735_NORON , DELAY, // 3: Normal display on, no args, w/delay

10, // 10 ms delay

ST7735_DISPON , DELAY, // 4: Main screen turn on, no args w/delay

100 }; // 100 ms delay

// Companion code to the above tables. Reads and issues

// a series of LCD commands stored in ROM byte array.

void static commandList(const uint8_t *addr) {

uint8_t numCommands, numArgs;

uint16_t ms;

numCommands = *(addr++); // Number of commands to follow

while(numCommands--) { // For each command...

writecommand(*(addr++)); // Read, issue command

numArgs = *(addr++); // Number of args to follow

ms = numArgs & DELAY; // If hibit set, delay follows args

numArgs &= ~DELAY; // Mask out delay bit

while(numArgs--) { // For each argument...

writedata(*(addr++)); // Read, issue argument

}

if(ms) {

ms = *(addr++); // Read post-command delay time (ms)

if(ms == 255) ms = 500; // If 255, delay for 500 ms

Delay1ms(ms);

}

}

}

// Initialization code common to both 'B' and 'R' type displays

void static commonInit(const uint8_t *cmdList) {

ColStart = RowStart = 0; // May be overridden in init func

// toggle RST low to reset; CS low so it'll listen to us

// UCA3STE is temporarily used as GPIO

P9SEL0 &= ~0x0C;

P9SEL1 &= ~0x0C; // configure P9.2 (D/C), P9.3 (Reset), and P9.4 (TFT_CS) as GPIO

P9DIR |= 0x1C; // make P9.2 (D/C), P9.3 (Reset), and P9.4 (TFT_CS) out

TFT_CS &= ~TFT_CS_BIT;

RESET |= RESET_BIT;

Delay1ms(500);

RESET &= ~RESET_BIT;

Delay1ms(500);

RESET |= RESET_BIT;

Delay1ms(500);

// initialize eUSCI

UCA3CTLW0 = 0x0001; // hold the eUSCI module in reset mode

// configure UCA3CTLW0 for:

// bit15 UCCKPH = 1; data shifts in on first edge, out on following edge

// bit14 UCCKPL = 0; clock is low when inactive

// bit13 UCMSB = 1; MSB first

// bit12 UC7BIT = 0; 8-bit data

// bit11 UCMST = 1; master mode

// bits10-9 UCMODEx = 00; UCSTE active low

// bit8 UCSYNC = 1; synchronous mode

// bits7-6 UCSSELx = 2; eUSCI clock SMCLK

// bits5-2 reserved

// bit1 UCSTEM = 0; UCSTE pin enables slave

// bit0 UCSWRST = 1; reset enabled

UCA3CTLW0 = 0xA981;

// set the baud rate for the eUSCI which gets its clock from SMCLK

// Clock_Init48MHz() from ClockSystem.c sets SMCLK = HFXTCLK/4 = 12 MHz

// if the SMCLK is set to 12 MHz, divide by 3 for 4 MHz baud clock

UCA3BRW = 3;

// modulation is not used in SPI mode, so clear UCA3MCTLW

UCA3MCTLW = 0;

P9SEL0 |= 0xE0;

P9SEL1 &= ~0xE0;

P9SEL0 &= ~0x0C;

P9SEL1 &= ~0x0C; // configure P9.7, P9.5, and P9.4 as primary module function

UCA3CTLW0 &= ~0x0001; // enable eUSCI module

UCA3IE &= ~0x0003; // disable interrupts

if(cmdList) commandList(cmdList);

}

//------------ST7735_InitB------------

// Initialization for ST7735B screens.

// Input: none

// Output: none

void ST7735_InitB(void) {

commonInit(Bcmd);

ST7735_SetCursor(0,0);

StTextColor = ST7735_YELLOW;

ST7735_FillScreen(0); // set screen to black

}

//------------ST7735_InitR------------

// Initialization for ST7735R screens (green or red tabs).

// Input: option one of the enumerated options depending on tabs

// Output: none

void ST7735_InitR(enum initRFlags option) {

commonInit(Rcmd1);

if(option == INITR_GREENTAB) {

commandList(Rcmd2green);

ColStart = 2;

RowStart = 1;

} else {

// colstart, rowstart left at default '0' values

commandList(Rcmd2red);

}

commandList(Rcmd3);

// if black, change MADCTL color filter

if (option == INITR_BLACKTAB) {

writecommand(ST7735_MADCTL);

writedata(0xC0);

}

TabColor = option;

ST7735_SetCursor(0,0);

StTextColor = ST7735_YELLOW;

ST7735_FillScreen(0); // set screen to black

}

// Set the region of the screen RAM to be modified

// Pixel colors are sent left to right, top to bottom

// (same as Font table is encoded; different from regular bitmap)

// Requires 11 bytes of transmission

void static setAddrWindow(uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1) {

writecommand(ST7735_CASET); // Column addr set

writedata(0x00);

writedata(x0+ColStart); // XSTART

writedata(0x00);

writedata(x1+ColStart); // XEND

writecommand(ST7735_RASET); // Row addr set

writedata(0x00);

writedata(y0+RowStart); // YSTART

writedata(0x00);

writedata(y1+RowStart); // YEND

writecommand(ST7735_RAMWR); // write to RAM

}

// Send two bytes of data, most significant byte first

// Requires 2 bytes of transmission

void static pushColor(uint16_t color) {

writedata((uint8_t)(color >> 8));

writedata((uint8_t)color);

}

//------------ST7735_DrawPixel------------

// Color the pixel at the given coordinates with the given color.

// Requires 13 bytes of transmission

// Input: x horizontal position of the pixel, columns from the left edge

// must be less than 128

// 0 is on the left, 126 is near the right

// y vertical position of the pixel, rows from the top edge

// must be less than 160

// 159 is near the wires, 0 is the side opposite the wires

// color 16-bit color, which can be produced by ST7735_Color565()

// Output: none

void ST7735_DrawPixel(int16_t x, int16_t y, uint16_t color) {

if((x < 0) || (x >= _width) || (y < 0) || (y >= _height)) return;

// setAddrWindow(x,y,x+1,y+1); // original code, bug???

setAddrWindow(x,y,x,y);

pushColor(color);

}

//------------ST7735_FillScreen------------

// Fill the screen with the given color.

// Requires 40,971 bytes of transmission

// Input: color 16-bit color, which can be produced by ST7735_Color565()

// Output: none

void ST7735_FillScreen(uint16_t color) {

ST7735_FillRect(0, 0, _width, _height, color); // original

// screen is actually 129 by 161 pixels, x 0 to 128, y goes from 0 to 160

}

//------------ST7735_FillRect------------

// Draw a filled rectangle at the given coordinates with the given width, height, and color.

// Requires (11 + 2*w*h) bytes of transmission (assuming image fully on screen)

// Input: x horizontal position of the top left corner of the rectangle, columns from the left edge

// y vertical position of the top left corner of the rectangle, rows from the top edge

// w horizontal width of the rectangle

// h vertical height of the rectangle

// color 16-bit color, which can be produced by ST7735_Color565()

// Output: none

void ST7735_FillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color) {

uint8_t hi = color >> 8, lo = color;

// rudimentary clipping (drawChar w/big text requires this)

if((x >= _width) || (y >= _height)) return;

if((x + w - 1) >= _width) w = _width - x;

if((y + h - 1) >= _height) h = _height - y;

setAddrWindow(x, y, x+w-1, y+h-1);

for(y=h; y>0; y--) {

for(x=w; x>0; x--) {

writedata(hi);

writedata(lo);

}

}

}

//------------ST7735_Color565------------

// Pass 8-bit (each) R,G,B and get back 16-bit packed color.

// Input: r red value

// g green value

// b blue value

// Output: 16-bit color

uint16_t ST7735_Color565(uint8_t r, uint8_t g, uint8_t b) {

return ((b & 0xF8) << 8) | ((g & 0xFC) << 3) | (r >> 3);

}

//------------ST7735_SwapColor------------

// Swaps the red and blue values of the given 16-bit packed color;

// green is unchanged.

// Input: x 16-bit color in format B, G, R

// Output: 16-bit color in format R, G, B

uint16_t ST7735_SwapColor(uint16_t x) {

return (x << 11) | (x & 0x07E0) | (x >> 11);

}

//------------ST7735_DrawBitmap------------

// Displays a 16-bit color BMP image. A bitmap file that is created

// by a PC image processing program has a header and may be padded

// with dummy columns so the data have four byte alignment. This

// function assumes that all of that has been stripped out, and the

// array image[] has one 16-bit halfword for each pixel to be

// displayed on the screen (encoded in reverse order, which is

// standard for bitmap files). An array can be created in this

// format from a 24-bit-per-pixel .bmp file using the associated

// converter program.

// (x,y) is the screen location of the lower left corner of BMP image

// Requires (11 + 2*w*h) bytes of transmission (assuming image fully on screen)

// Input: x horizontal position of the bottom left corner of the image, columns from the left edge

// y vertical position of the bottom left corner of the image, rows from the top edge

// image pointer to a 16-bit color BMP image

// w number of pixels wide

// h number of pixels tall

// Output: none

// Must be less than or equal to 128 pixels wide by 160 pixels high

void ST7735_DrawBitmap(int16_t x, int16_t y, const uint16_t *image, int16_t w, int16_t h){

int16_t skipC = 0; // non-zero if columns need to be skipped due to clipping

int16_t originalWidth = w; // save this value; even if not all columns fit on the screen, the image is still this width in ROM

int i = w*(h - 1);

if((x >= _width) || ((y - h + 1) >= _height) || ((x + w) <= 0) || (y < 0)){

return; // image is totally off the screen, do nothing

}

if((w > _width) || (h > _height)){ // image is too wide for the screen, do nothing

//***This isn't necessarily a fatal error, but it makes the

//following logic much more complicated, since you can have

//an image that exceeds multiple boundaries and needs to be

//clipped on more than one side.

return;

}

if((x + w - 1) >= _width){ // image exceeds right of screen

skipC = (x + w) - _width; // skip cut off columns

w = _width - x;

}

if((y - h + 1) < 0){ // image exceeds top of screen

i = i - (h - y - 1)*originalWidth; // skip the last cut off rows

h = y + 1;

}

if(x < 0){ // image exceeds left of screen

w = w + x;

skipC = -1*x; // skip cut off columns

i = i - x; // skip the first cut off columns

x = 0;

}

if(y >= _height){ // image exceeds bottom of screen

h = h - (y - _height + 1);

y = _height - 1;

}

setAddrWindow(x, y-h+1, x+w-1, y);

for(y=0; y<h; y=y+1){

for(x=0; x<w; x=x+1){

// send the top 8 bits

writedata((uint8_t)(image[i] >> 8));

// send the bottom 8 bits

writedata((uint8_t)image[i]);

i = i + 1; // go to the next pixel

}

i = i + skipC;

i = i - 2*originalWidth;

}

}

//------------ST7735_DrawCharS------------

// Simple character draw function. This is the same function from

// Adafruit_GFX.c but adapted for this processor. However, each call

// to ST7735_DrawPixel() calls setAddrWindow(), which needs to send

// many extra data and commands. If the background color is the same

// as the text color, no background will be printed, and text can be

// drawn right over existing images without covering them with a box.

// Requires (11 + 2*size*size)*6*8 bytes of transmission (image fully on screen; textcolor != bgColor)

// Input: x horizontal position of the top left corner of the character, columns from the left edge

// y vertical position of the top left corner of the character, rows from the top edge

// c character to be printed

// textColor 16-bit color of the character

// bgColor 16-bit color of the background

// size number of pixels per character pixel (e.g. size==2 prints each pixel of font as 2x2 square)

// Output: none

void ST7735_DrawCharS(int16_t x, int16_t y, char c, int16_t textColor, int16_t bgColor, uint8_t size){

uint8_t line; // vertical column of pixels of character in font

int32_t i, j;

if((x >= _width) || // Clip right

(y >= _height) || // Clip bottom

((x + 5 * size - 1) < 0) || // Clip left

((y + 8 * size - 1) < 0)) // Clip top

return;

for (i=0; i<6; i++ ) {

if (i == 5)

line = 0x0;

else

line = Font[(c*5)+i];

for (j = 0; j<8; j++) {

if (line & 0x1) {

if (size == 1) // default size

ST7735_DrawPixel(x+i, y+j, textColor);

else { // big size

ST7735_FillRect(x+(i*size), y+(j*size), size, size, textColor);

}

} else if (bgColor != textColor) {

if (size == 1) // default size

ST7735_DrawPixel(x+i, y+j, bgColor);

else { // big size

ST7735_FillRect(x+i*size, y+j*size, size, size, bgColor);

}

}

line >>= 1;

}

}

}

//------------ST7735_DrawChar------------

// Advanced character draw function. This is similar to the function

// from Adafruit_GFX.c but adapted for this processor. However, this

// function only uses one call to setAddrWindow(), which allows it to

// run at least twice as fast.

// Requires (11 + size*size*6*8) bytes of transmission (assuming image fully on screen)

// Input: x horizontal position of the top left corner of the character, columns from the left edge

// y vertical position of the top left corner of the character, rows from the top edge

// c character to be printed

// textColor 16-bit color of the character

// bgColor 16-bit color of the background

// size number of pixels per character pixel (e.g. size==2 prints each pixel of font as 2x2 square)

// Output: none

void ST7735_DrawChar(int16_t x, int16_t y, char c, int16_t textColor, int16_t bgColor, uint8_t size){

uint8_t line; // horizontal row of pixels of character

int32_t col, row, i, j;// loop indices

if(((x + 5*size - 1) >= _width) || // Clip right

((y + 8*size - 1) >= _height) || // Clip bottom

((x + 5*size - 1) < 0) || // Clip left

((y + 8*size - 1) < 0)){ // Clip top

return;

}

setAddrWindow(x, y, x+6*size-1, y+8*size-1);

line = 0x01; // print the top row first

// print the rows, starting at the top

for(row=0; row<8; row=row+1){

for(i=0; i<size; i=i+1){

// print the columns, starting on the left

for(col=0; col<5; col=col+1){

if(Font[(c*5)+col]&line){

// bit is set in Font, print pixel(s) in text color

for(j=0; j<size; j=j+1){

pushColor(textColor);

}

} else{

// bit is cleared in Font, print pixel(s) in background color

for(j=0; j<size; j=j+1){

pushColor(bgColor);

}

}

}

// print blank column(s) to the right of character

for(j=0; j<size; j=j+1){

pushColor(bgColor);

}

}

line = line<<1; // move up to the next row

}

}

//------------ST7735_DrawString------------

// String draw function.