Jack Berkhout / SPI_TFT_ILI9225

Uses the same fonts as the SPI_TFT_ILI9341 Library (I have many, and a html/php font editor for that)

SPI_TFT_ILI9225.cpp@11:70409b34b74d, 2016-11-23 (annotated)

Committer:
JackB
Date:
Wed Nov 23 12:43:29 2016 +0000
Revision:
11:70409b34b74d
Parent:
10:a640680b5309
Child:
12:64165e7ad897
Improved comments

Who changed what in which revision?

UserRevisionLine numberNew contents of line
JackB 0:cc1fb45bc3ad 1 /*
JackB 11:70409b34b74d 2 Ported from arduino to mbed platform by Arman Safikhani 31-08-2015
JackB 0:cc1fb45bc3ad 3 Jack: Many thanks Arman!
JackB 0:cc1fb45bc3ad 4
JackB 11:70409b34b74d 5 Changed a lot of things by Jack Berkhout 23-11-2016
JackB 11:70409b34b74d 6
JackB 11:70409b34b74d 7 Used for 2.2" Serial SPI TFT Color LCD Module for Arduino
JackB 11:70409b34b74d 8 176*220 resolution / 11-pin / ILI9225 IC driver
JackB 11:70409b34b74d 9 https://www.fasttech.com/product/3842400-2-2-serial-spi-tft-color-lcd-module-for-arduino
JackB 11:70409b34b74d 10
JackB 1:8e447a4c8995 11 - uses the same fonts as the SPI_TFT_ILI9341 Library (I have many, and a html/php font editor for that)
JackB 0:cc1fb45bc3ad 12 - some code removed, some added, some changed
JackB 0:cc1fb45bc3ad 13 - the led backlight is using a PWM output, so it can be adjusted (0.0f = off - 1.0f = on)
JackB 0:cc1fb45bc3ad 14 - added formatted printf
JackB 0:cc1fb45bc3ad 15 - added claim as standard output on stream
JackB 2:e213811335ac 16 - Orientation definitions are now related to the SD card slot location (front view)
JackB 11:70409b34b74d 17 - hline and vline added, also used by outline reactangles, with drastical performance improvement (15 times)
JackB 0:cc1fb45bc3ad 18 */
JackB 0:cc1fb45bc3ad 19
JackB 0:cc1fb45bc3ad 20 #include "SPI_TFT_ILI9225.h"
JackB 0:cc1fb45bc3ad 21 #define bitRead(value, bit) (((value) >> (bit)) & 0x01)
JackB 0:cc1fb45bc3ad 22
JackB 0:cc1fb45bc3ad 23 int font_color, x_font, y_font;
JackB 0:cc1fb45bc3ad 24 char highlight, fa_num;
JackB 0:cc1fb45bc3ad 25 int effect = 0, italic = 0;
JackB 0:cc1fb45bc3ad 26 unsigned int highlight_color;
JackB 0:cc1fb45bc3ad 27 /* Global Variables */
JackB 0:cc1fb45bc3ad 28 int x_text = 0, y_text = 0;
JackB 0:cc1fb45bc3ad 29 int x_base = 0;
JackB 0:cc1fb45bc3ad 30
JackB 0:cc1fb45bc3ad 31 // Constructor when using software SPI. All output pins are configurable.
JackB 0:cc1fb45bc3ad 32 TFT_22_ILI9225::TFT_22_ILI9225(PinName sdi, PinName clk, PinName cs, PinName rs, PinName rst, PinName led, const char *name) :
JackB 0:cc1fb45bc3ad 33 spi(sdi, NC, clk), _cs(cs), _rs(rs), _rst(rst), _led(led), Stream(name)
JackB 0:cc1fb45bc3ad 34 {
JackB 0:cc1fb45bc3ad 35 spi.frequency(24000000);
JackB 0:cc1fb45bc3ad 36 spi.format(8, 0);
JackB 0:cc1fb45bc3ad 37
JackB 0:cc1fb45bc3ad 38 // PWM output to control backlight
JackB 0:cc1fb45bc3ad 39 _led.period_ms(10);
JackB 0:cc1fb45bc3ad 40
JackB 0:cc1fb45bc3ad 41 // --- claim ---
JackB 0:cc1fb45bc3ad 42 _row = 0;
JackB 0:cc1fb45bc3ad 43 _column = 0;
JackB 0:cc1fb45bc3ad 44 if (name == NULL) {
JackB 0:cc1fb45bc3ad 45 _path = NULL;
JackB 0:cc1fb45bc3ad 46 } else {
JackB 0:cc1fb45bc3ad 47 _path = new char[strlen(name) + 2];
JackB 0:cc1fb45bc3ad 48 sprintf(_path, "/%s", name);
JackB 0:cc1fb45bc3ad 49 }
JackB 0:cc1fb45bc3ad 50 // --- /claim ---
JackB 0:cc1fb45bc3ad 51
JackB 0:cc1fb45bc3ad 52 init();
JackB 0:cc1fb45bc3ad 53 }
JackB 0:cc1fb45bc3ad 54
JackB 7:2616ae4dd315 55 bool TFT_22_ILI9225::claim (FILE *stream)
JackB 7:2616ae4dd315 56 {
JackB 0:cc1fb45bc3ad 57 if ( _path == NULL) {
JackB 0:cc1fb45bc3ad 58 fprintf(stderr, "claim requires a name to be given in the instantioator of the TextDisplay instance!\r\n");
JackB 0:cc1fb45bc3ad 59 return false;
JackB 0:cc1fb45bc3ad 60 }
JackB 0:cc1fb45bc3ad 61 if (freopen(_path, "w", stream) == NULL) {
JackB 0:cc1fb45bc3ad 62 // Failed, should not happen
JackB 0:cc1fb45bc3ad 63 return false;
JackB 0:cc1fb45bc3ad 64 }
JackB 0:cc1fb45bc3ad 65 // make sure we use line buffering
JackB 0:cc1fb45bc3ad 66 setvbuf(stdout, NULL, _IOLBF, ILI9225_CHARS_PER_LINE);
JackB 0:cc1fb45bc3ad 67 return true;
JackB 0:cc1fb45bc3ad 68 }
JackB 0:cc1fb45bc3ad 69
JackB 10:a640680b5309 70 void TFT_22_ILI9225::_orientCoordinates(uint16_t &x, uint16_t &y)
JackB 7:2616ae4dd315 71 {
JackB 0:cc1fb45bc3ad 72 switch (_orientation) {
JackB 0:cc1fb45bc3ad 73 case 0: // ok
JackB 0:cc1fb45bc3ad 74 break;
JackB 0:cc1fb45bc3ad 75 case 1: // ok
JackB 10:a640680b5309 76 y = _maxY - y - 1;
JackB 10:a640680b5309 77 _swap(x, y);
JackB 0:cc1fb45bc3ad 78 break;
JackB 0:cc1fb45bc3ad 79 case 2: // ok
JackB 10:a640680b5309 80 x = _maxX - x - 1;
JackB 10:a640680b5309 81 y = _maxY - y - 1;
JackB 0:cc1fb45bc3ad 82 break;
JackB 0:cc1fb45bc3ad 83 case 3: // ok
JackB 10:a640680b5309 84 x = _maxX - x - 1;
JackB 10:a640680b5309 85 _swap(x, y);
JackB 0:cc1fb45bc3ad 86 break;
JackB 0:cc1fb45bc3ad 87 }
JackB 0:cc1fb45bc3ad 88 }
JackB 0:cc1fb45bc3ad 89
JackB 7:2616ae4dd315 90 void TFT_22_ILI9225::_setWindowMax(void)
JackB 7:2616ae4dd315 91 {
JackB 0:cc1fb45bc3ad 92 _setWindow(0, 0, maxX(), maxY());
JackB 0:cc1fb45bc3ad 93 }
JackB 0:cc1fb45bc3ad 94
JackB 7:2616ae4dd315 95 void TFT_22_ILI9225::_setWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1)
JackB 7:2616ae4dd315 96 {
JackB 0:cc1fb45bc3ad 97 _orientCoordinates(x0, y0);
JackB 0:cc1fb45bc3ad 98 _orientCoordinates(x1, y1);
JackB 0:cc1fb45bc3ad 99
JackB 0:cc1fb45bc3ad 100 if (x1 < x0) _swap(x0, x1);
JackB 0:cc1fb45bc3ad 101 if (y1 < y0) _swap(y0, y1);
JackB 0:cc1fb45bc3ad 102
JackB 0:cc1fb45bc3ad 103 _writeRegister(ILI9225_HORIZONTAL_WINDOW_ADDR1, x1);
JackB 0:cc1fb45bc3ad 104 _writeRegister(ILI9225_HORIZONTAL_WINDOW_ADDR2, x0);
JackB 0:cc1fb45bc3ad 105
JackB 0:cc1fb45bc3ad 106 _writeRegister(ILI9225_VERTICAL_WINDOW_ADDR1, y1);
JackB 0:cc1fb45bc3ad 107 _writeRegister(ILI9225_VERTICAL_WINDOW_ADDR2, y0);
JackB 0:cc1fb45bc3ad 108
JackB 0:cc1fb45bc3ad 109 _writeRegister(ILI9225_RAM_ADDR_SET1, x0);
JackB 0:cc1fb45bc3ad 110 _writeRegister(ILI9225_RAM_ADDR_SET2, y0);
JackB 0:cc1fb45bc3ad 111
JackB 0:cc1fb45bc3ad 112 _writeCommand(0x00, 0x22);
JackB 0:cc1fb45bc3ad 113 }
JackB 0:cc1fb45bc3ad 114
JackB 0:cc1fb45bc3ad 115 void TFT_22_ILI9225::init()
JackB 0:cc1fb45bc3ad 116 {
JackB 0:cc1fb45bc3ad 117 // Turn off backlight
JackB 0:cc1fb45bc3ad 118 setBacklight(0.0f);
JackB 0:cc1fb45bc3ad 119
JackB 0:cc1fb45bc3ad 120 // Initialization Code
JackB 0:cc1fb45bc3ad 121 _rst = 0;// Pull the reset pin low to reset ILI9225
JackB 0:cc1fb45bc3ad 122 wait_ms(10);
JackB 0:cc1fb45bc3ad 123 _rst = 1;// Pull the reset pin high to release the ILI9225C from the reset status
JackB 0:cc1fb45bc3ad 124 wait_ms(50);
JackB 0:cc1fb45bc3ad 125
JackB 0:cc1fb45bc3ad 126 /* Start Initial Sequence */
JackB 0:cc1fb45bc3ad 127 /* Set SS bit and direction output from S528 to S1 */
JackB 0:cc1fb45bc3ad 128 _writeRegister(ILI9225_POWER_CTRL1, 0x0000); // Set SAP,DSTB,STB
JackB 0:cc1fb45bc3ad 129 _writeRegister(ILI9225_POWER_CTRL2, 0x0000); // Set APON,PON,AON,VCI1EN,VC
JackB 0:cc1fb45bc3ad 130 _writeRegister(ILI9225_POWER_CTRL3, 0x0000); // Set BT,DC1,DC2,DC3
JackB 0:cc1fb45bc3ad 131 _writeRegister(ILI9225_POWER_CTRL4, 0x0000); // Set GVDD
JackB 0:cc1fb45bc3ad 132 _writeRegister(ILI9225_POWER_CTRL5, 0x0000); // Set VCOMH/VCOML voltage
JackB 0:cc1fb45bc3ad 133 wait_ms(40);
JackB 0:cc1fb45bc3ad 134
JackB 0:cc1fb45bc3ad 135 // Power-on sequence
JackB 0:cc1fb45bc3ad 136 _writeRegister(ILI9225_POWER_CTRL2, 0x0018); // Set APON,PON,AON,VCI1EN,VC
JackB 0:cc1fb45bc3ad 137 _writeRegister(ILI9225_POWER_CTRL3, 0x6121); // Set BT,DC1,DC2,DC3
JackB 0:cc1fb45bc3ad 138 _writeRegister(ILI9225_POWER_CTRL4, 0x006F); // Set GVDD /*007F 0088 */
JackB 0:cc1fb45bc3ad 139 _writeRegister(ILI9225_POWER_CTRL5, 0x495F); // Set VCOMH/VCOML voltage
JackB 0:cc1fb45bc3ad 140 _writeRegister(ILI9225_POWER_CTRL1, 0x0800); // Set SAP,DSTB,STB
JackB 0:cc1fb45bc3ad 141 wait_ms(10);
JackB 0:cc1fb45bc3ad 142 _writeRegister(ILI9225_POWER_CTRL2, 0x103B); // Set APON,PON,AON,VCI1EN,VC
JackB 0:cc1fb45bc3ad 143 wait_ms(50);
JackB 0:cc1fb45bc3ad 144
JackB 0:cc1fb45bc3ad 145 _writeRegister(ILI9225_DRIVER_OUTPUT_CTRL, 0x011C); // set the display line number and display direction
JackB 0:cc1fb45bc3ad 146 _writeRegister(ILI9225_LCD_AC_DRIVING_CTRL, 0x0100); // set 1 line inversion
JackB 0:cc1fb45bc3ad 147 _writeRegister(ILI9225_ENTRY_MODE, 0x1030); // set GRAM write direction and BGR=1.
JackB 0:cc1fb45bc3ad 148 _writeRegister(ILI9225_DISP_CTRL1, 0x0000); // Display off
JackB 0:cc1fb45bc3ad 149 _writeRegister(ILI9225_BLANK_PERIOD_CTRL1, 0x0808); // set the back porch and front porch
JackB 0:cc1fb45bc3ad 150 _writeRegister(ILI9225_FRAME_CYCLE_CTRL, 0x1100); // set the clocks number per line
JackB 0:cc1fb45bc3ad 151 _writeRegister(ILI9225_INTERFACE_CTRL, 0x0000); // CPU interface
JackB 0:cc1fb45bc3ad 152 _writeRegister(ILI9225_OSC_CTRL, 0x0D01); // Set Osc /*0e01*/
JackB 0:cc1fb45bc3ad 153 _writeRegister(ILI9225_VCI_RECYCLING, 0x0020); // Set VCI recycling
JackB 0:cc1fb45bc3ad 154 _writeRegister(ILI9225_RAM_ADDR_SET1, 0x0000); // RAM Address
JackB 0:cc1fb45bc3ad 155 _writeRegister(ILI9225_RAM_ADDR_SET2, 0x0000); // RAM Address
JackB 0:cc1fb45bc3ad 156
JackB 0:cc1fb45bc3ad 157 /* Set GRAM area */
JackB 0:cc1fb45bc3ad 158 _writeRegister(ILI9225_GATE_SCAN_CTRL, 0x0000);
JackB 0:cc1fb45bc3ad 159 _writeRegister(ILI9225_VERTICAL_SCROLL_CTRL1, 0x00DB);
JackB 0:cc1fb45bc3ad 160 _writeRegister(ILI9225_VERTICAL_SCROLL_CTRL2, 0x0000);
JackB 0:cc1fb45bc3ad 161 _writeRegister(ILI9225_VERTICAL_SCROLL_CTRL3, 0x0000);
JackB 0:cc1fb45bc3ad 162 _writeRegister(ILI9225_PARTIAL_DRIVING_POS1, 0x00DB);
JackB 0:cc1fb45bc3ad 163 _writeRegister(ILI9225_PARTIAL_DRIVING_POS2, 0x0000);
JackB 0:cc1fb45bc3ad 164 _writeRegister(ILI9225_HORIZONTAL_WINDOW_ADDR1, 0x00AF);
JackB 0:cc1fb45bc3ad 165 _writeRegister(ILI9225_HORIZONTAL_WINDOW_ADDR2, 0x0000);
JackB 0:cc1fb45bc3ad 166 _writeRegister(ILI9225_VERTICAL_WINDOW_ADDR1, 0x00DB);
JackB 0:cc1fb45bc3ad 167 _writeRegister(ILI9225_VERTICAL_WINDOW_ADDR2, 0x0000);
JackB 0:cc1fb45bc3ad 168
JackB 0:cc1fb45bc3ad 169 /* Set GAMMA curve */
JackB 0:cc1fb45bc3ad 170 _writeRegister(ILI9225_GAMMA_CTRL1, 0x0000);
JackB 0:cc1fb45bc3ad 171 _writeRegister(ILI9225_GAMMA_CTRL2, 0x0808);
JackB 0:cc1fb45bc3ad 172 _writeRegister(ILI9225_GAMMA_CTRL3, 0x080A);
JackB 0:cc1fb45bc3ad 173 _writeRegister(ILI9225_GAMMA_CTRL4, 0x000A);
JackB 0:cc1fb45bc3ad 174 _writeRegister(ILI9225_GAMMA_CTRL5, 0x0A08);
JackB 0:cc1fb45bc3ad 175 _writeRegister(ILI9225_GAMMA_CTRL6, 0x0808);
JackB 0:cc1fb45bc3ad 176 _writeRegister(ILI9225_GAMMA_CTRL7, 0x0000);
JackB 0:cc1fb45bc3ad 177 _writeRegister(ILI9225_GAMMA_CTRL8, 0x0A00);
JackB 0:cc1fb45bc3ad 178 _writeRegister(ILI9225_GAMMA_CTRL9, 0x0710);
JackB 0:cc1fb45bc3ad 179 _writeRegister(ILI9225_GAMMA_CTRL10, 0x0710);
JackB 0:cc1fb45bc3ad 180
JackB 0:cc1fb45bc3ad 181 _writeRegister(ILI9225_DISP_CTRL1, 0x0012);
JackB 0:cc1fb45bc3ad 182 wait_ms(50);
JackB 0:cc1fb45bc3ad 183 _writeRegister(ILI9225_DISP_CTRL1, 0x1017);
JackB 0:cc1fb45bc3ad 184
JackB 0:cc1fb45bc3ad 185 cls();
JackB 0:cc1fb45bc3ad 186 linespacing(0);
JackB 0:cc1fb45bc3ad 187 setBacklight(1.0f);
JackB 5:dad648238df3 188 setOrientation(ILI9225_LANDSCAPE_B);
JackB 0:cc1fb45bc3ad 189 foreground(COLOR_WHITE);
JackB 0:cc1fb45bc3ad 190 background(COLOR_BLACK);
JackB 0:cc1fb45bc3ad 191 }
JackB 0:cc1fb45bc3ad 192
JackB 7:2616ae4dd315 193 void TFT_22_ILI9225::cls()
JackB 7:2616ae4dd315 194 {
JackB 0:cc1fb45bc3ad 195 setBacklightOff();
JackB 0:cc1fb45bc3ad 196 _setWindowMax();
JackB 0:cc1fb45bc3ad 197 _rs = 1;
JackB 0:cc1fb45bc3ad 198 _cs = 0;
JackB 0:cc1fb45bc3ad 199 for (uint16_t i = width() * height(); i > 0; i--) {
JackB 0:cc1fb45bc3ad 200 spi.write(0x00);
JackB 0:cc1fb45bc3ad 201 spi.write(0x00);
JackB 0:cc1fb45bc3ad 202 }
JackB 0:cc1fb45bc3ad 203 _cs = 1;
JackB 0:cc1fb45bc3ad 204 setBacklightOn();
JackB 0:cc1fb45bc3ad 205 gotoxy(0, 0);
JackB 0:cc1fb45bc3ad 206 }
JackB 0:cc1fb45bc3ad 207
JackB 0:cc1fb45bc3ad 208 void TFT_22_ILI9225::fill(uint16_t color)
JackB 0:cc1fb45bc3ad 209 {
JackB 5:dad648238df3 210 fillrect(0, 0, maxX(), maxY(), color);
JackB 0:cc1fb45bc3ad 211 }
JackB 0:cc1fb45bc3ad 212
JackB 7:2616ae4dd315 213 void TFT_22_ILI9225::invert(bool flag)
JackB 7:2616ae4dd315 214 {
JackB 0:cc1fb45bc3ad 215 _writeCommand(0x00, flag ? ILI9225C_INVON : ILI9225C_INVOFF);
JackB 0:cc1fb45bc3ad 216 }
JackB 0:cc1fb45bc3ad 217
JackB 7:2616ae4dd315 218 void TFT_22_ILI9225::setBacklight(double brightness)
JackB 7:2616ae4dd315 219 {
JackB 0:cc1fb45bc3ad 220 // PWM output to control backlight
JackB 0:cc1fb45bc3ad 221 _brightness = brightness;
JackB 0:cc1fb45bc3ad 222 _led.write(pow(brightness, 2)); // power(x, 2): For the eye better brightness response
JackB 0:cc1fb45bc3ad 223 }
JackB 0:cc1fb45bc3ad 224
JackB 7:2616ae4dd315 225 void TFT_22_ILI9225::setBacklightOff(void)
JackB 7:2616ae4dd315 226 {
JackB 0:cc1fb45bc3ad 227 _led.write(0.0f);
JackB 0:cc1fb45bc3ad 228 }
JackB 0:cc1fb45bc3ad 229
JackB 7:2616ae4dd315 230 void TFT_22_ILI9225::setBacklightOn(void)
JackB 7:2616ae4dd315 231 {
JackB 0:cc1fb45bc3ad 232 setBacklight(_brightness);
JackB 0:cc1fb45bc3ad 233 }
JackB 0:cc1fb45bc3ad 234
JackB 10:a640680b5309 235 void TFT_22_ILI9225::setDisplay(bool flag)
JackB 10:a640680b5309 236 {
JackB 0:cc1fb45bc3ad 237 if (flag) {
JackB 0:cc1fb45bc3ad 238 _writeRegister(0x00ff, 0x0000);
JackB 0:cc1fb45bc3ad 239 _writeRegister(ILI9225_POWER_CTRL1, 0x0000);
JackB 0:cc1fb45bc3ad 240 wait_ms(50);
JackB 0:cc1fb45bc3ad 241 _writeRegister(ILI9225_DISP_CTRL1, 0x1017);
JackB 0:cc1fb45bc3ad 242 wait_ms(200);
JackB 0:cc1fb45bc3ad 243 }
JackB 0:cc1fb45bc3ad 244 else {
JackB 0:cc1fb45bc3ad 245 _writeRegister(0x00ff, 0x0000);
JackB 0:cc1fb45bc3ad 246 _writeRegister(ILI9225_DISP_CTRL1, 0x0000);
JackB 0:cc1fb45bc3ad 247 wait_ms(50);
JackB 0:cc1fb45bc3ad 248 _writeRegister(ILI9225_POWER_CTRL1, 0x0003);
JackB 0:cc1fb45bc3ad 249 wait_ms(200);
JackB 0:cc1fb45bc3ad 250 }
JackB 0:cc1fb45bc3ad 251 }
JackB 0:cc1fb45bc3ad 252
JackB 8:a569bc50b552 253 void TFT_22_ILI9225::setOrientation(uint8_t orientation)
JackB 8:a569bc50b552 254 {
JackB 0:cc1fb45bc3ad 255 _orientation = orientation % 4;
JackB 3:41e8d7dc279a 256 // Entry Mode (R03h)
JackB 3:41e8d7dc279a 257 // 0x1000 AM = 0: Horizontal, I/D[1:0] = 00: Horizontal: decrement, Vertical: decrement - ILI9225_PORTRAIT_R
JackB 3:41e8d7dc279a 258 // 0x1010 AM = 0: Horizontal, I/D[1:0] = 01: Horizontal: increment, Vertical: decrement
JackB 3:41e8d7dc279a 259 // 0x1020 AM = 0: Horizontal, I/D[1:0] = 10: Horizontal: decrement, Vertical: increment
JackB 3:41e8d7dc279a 260 // 0x1030 AM = 0: Horizontal, I/D[1:0] = 11: Horizontal: increment, Vertical: increment - ILI9225_PORTRAIT_L
JackB 3:41e8d7dc279a 261 // 0x1008 AM = 1: Vertical, I/D[1:0] = 00: Horizontal: decrement, Vertical: decrement
JackB 3:41e8d7dc279a 262 // 0x1018 AM = 1: Vertical, I/D[1:0] = 01: Horizontal: increment, Vertical: decrement - ILI9225_LANDSCAPE_T
JackB 3:41e8d7dc279a 263 // 0x1028 AM = 1: Vertical, I/D[1:0] = 10: Horizontal: decrement, Vertical: increment - ILI9225_LANDSCAPE_B
JackB 3:41e8d7dc279a 264 // 0x1038 AM = 1: Vertical, I/D[1:0] = 11: Horizontal: increment, Vertical: increment
JackB 9:680f6c9940b3 265
JackB 0:cc1fb45bc3ad 266 switch (_orientation) {
JackB 3:41e8d7dc279a 267 case ILI9225_PORTRAIT_L:
JackB 3:41e8d7dc279a 268 // 0x1030 AM = 0: Horizontal, I/D[1:0] = 11: Horizontal: increment, Vertical: increment
JackB 9:680f6c9940b3 269 _entryMode = 0x1030;
JackB 3:41e8d7dc279a 270 _maxX = ILI9225_LCD_WIDTH;
JackB 3:41e8d7dc279a 271 _maxY = ILI9225_LCD_HEIGHT;
JackB 3:41e8d7dc279a 272 break;
JackB 3:41e8d7dc279a 273 case ILI9225_LANDSCAPE_B:
JackB 3:41e8d7dc279a 274 // 0x1028 AM = 1: Vertical, I/D[1:0] = 10: Horizontal: decrement, Vertical: increment
JackB 9:680f6c9940b3 275 _entryMode = 0x1028;
JackB 3:41e8d7dc279a 276 _maxX = ILI9225_LCD_HEIGHT;
JackB 3:41e8d7dc279a 277 _maxY = ILI9225_LCD_WIDTH;
JackB 3:41e8d7dc279a 278 break;
JackB 3:41e8d7dc279a 279 case ILI9225_PORTRAIT_R:
JackB 3:41e8d7dc279a 280 // 0x1000 AM = 0: Horizontal, I/D[1:0] = 00: Horizontal: decrement, Vertical: decrement
JackB 9:680f6c9940b3 281 _entryMode = 0x1000;
JackB 3:41e8d7dc279a 282 _maxX = ILI9225_LCD_WIDTH;
JackB 3:41e8d7dc279a 283 _maxY = ILI9225_LCD_HEIGHT;
JackB 3:41e8d7dc279a 284 break;
JackB 3:41e8d7dc279a 285 case ILI9225_LANDSCAPE_T:
JackB 3:41e8d7dc279a 286 // 0x1018 AM = 1: Vertical, I/D[1:0] = 01: Horizontal: increment, Vertical: decrement
JackB 9:680f6c9940b3 287 _entryMode = 0x1018;
JackB 3:41e8d7dc279a 288 _maxX = ILI9225_LCD_HEIGHT;
JackB 3:41e8d7dc279a 289 _maxY = ILI9225_LCD_WIDTH;
JackB 3:41e8d7dc279a 290 break;
JackB 0:cc1fb45bc3ad 291 }
JackB 9:680f6c9940b3 292 _writeRegister(ILI9225_ENTRY_MODE, _entryMode); // set GRAM write direction and BGR=1.
JackB 0:cc1fb45bc3ad 293 }
JackB 0:cc1fb45bc3ad 294
JackB 10:a640680b5309 295 uint8_t TFT_22_ILI9225::getOrientation()
JackB 10:a640680b5309 296 {
JackB 0:cc1fb45bc3ad 297 return _orientation;
JackB 0:cc1fb45bc3ad 298 }
JackB 0:cc1fb45bc3ad 299
JackB 5:dad648238df3 300 // Graphics functions
JackB 5:dad648238df3 301
JackB 10:a640680b5309 302 void TFT_22_ILI9225::pixel(uint16_t x1, uint16_t y1, uint16_t color)
JackB 10:a640680b5309 303 {
JackB 5:dad648238df3 304 if ((x1 >= _maxX) || (y1 >= _maxY)) return;
JackB 0:cc1fb45bc3ad 305
JackB 5:dad648238df3 306 _setWindow(x1, y1, x1 + 1, y1 + 1);
JackB 5:dad648238df3 307 _orientCoordinates(x1, y1);
JackB 5:dad648238df3 308 _rs = 1;
JackB 5:dad648238df3 309 _cs = 0;
JackB 5:dad648238df3 310 spi.write(color >> 8);
JackB 5:dad648238df3 311 spi.write(color & 0xff);
JackB 5:dad648238df3 312 _cs = 1;
JackB 0:cc1fb45bc3ad 313 }
JackB 0:cc1fb45bc3ad 314
JackB 10:a640680b5309 315 void TFT_22_ILI9225::line(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t color)
JackB 10:a640680b5309 316 {
JackB 0:cc1fb45bc3ad 317 // Classic Bresenham algorithm
JackB 0:cc1fb45bc3ad 318 int16_t steep = abs(y2 - y1) > abs(x2 - x1);
JackB 0:cc1fb45bc3ad 319 int16_t dx, dy;
JackB 0:cc1fb45bc3ad 320
JackB 0:cc1fb45bc3ad 321 if (steep) {
JackB 0:cc1fb45bc3ad 322 _swap(x1, y1);
JackB 0:cc1fb45bc3ad 323 _swap(x2, y2);
JackB 0:cc1fb45bc3ad 324 }
JackB 0:cc1fb45bc3ad 325
JackB 0:cc1fb45bc3ad 326 if (x1 > x2) {
JackB 0:cc1fb45bc3ad 327 _swap(x1, x2);
JackB 0:cc1fb45bc3ad 328 _swap(y1, y2);
JackB 0:cc1fb45bc3ad 329 }
JackB 0:cc1fb45bc3ad 330
JackB 0:cc1fb45bc3ad 331 dx = x2 - x1;
JackB 0:cc1fb45bc3ad 332 dy = abs(y2 - y1);
JackB 0:cc1fb45bc3ad 333
JackB 0:cc1fb45bc3ad 334 int16_t err = dx / 2;
JackB 0:cc1fb45bc3ad 335 int16_t ystep;
JackB 0:cc1fb45bc3ad 336
JackB 0:cc1fb45bc3ad 337 if (y1 < y2) ystep = 1;
JackB 0:cc1fb45bc3ad 338 else ystep = -1;
JackB 0:cc1fb45bc3ad 339
JackB 0:cc1fb45bc3ad 340
JackB 0:cc1fb45bc3ad 341 for (; x1 <= x2; x1++) {
JackB 5:dad648238df3 342 if (steep) pixel(y1, x1, color);
JackB 5:dad648238df3 343 else pixel(x1, y1, color);
JackB 0:cc1fb45bc3ad 344
JackB 0:cc1fb45bc3ad 345 err -= dy;
JackB 0:cc1fb45bc3ad 346 if (err < 0) {
JackB 0:cc1fb45bc3ad 347 y1 += ystep;
JackB 0:cc1fb45bc3ad 348 err += dx;
JackB 0:cc1fb45bc3ad 349 }
JackB 0:cc1fb45bc3ad 350 }
JackB 0:cc1fb45bc3ad 351 }
JackB 0:cc1fb45bc3ad 352
JackB 9:680f6c9940b3 353 void TFT_22_ILI9225::hline(uint16_t x1, uint16_t x2, uint16_t y, uint16_t color)
JackB 9:680f6c9940b3 354 {
JackB 9:680f6c9940b3 355 _writeRegister(ILI9225_ENTRY_MODE, 0x1028); // set GRAM write direction and BGR=1.
JackB 9:680f6c9940b3 356 _setWindow(x1, y, x2 + 1, y + 1);
JackB 9:680f6c9940b3 357 if (x2 < x1) {
JackB 9:680f6c9940b3 358 _swap(x1, x2);
JackB 9:680f6c9940b3 359 }
JackB 9:680f6c9940b3 360 _rs = 1;
JackB 9:680f6c9940b3 361 _cs = 0;
JackB 9:680f6c9940b3 362 for (uint16_t x = x1; x <= x2; x++) {
JackB 9:680f6c9940b3 363 spi.write(color >> 8);
JackB 9:680f6c9940b3 364 spi.write(color & 0xff);
JackB 7:2616ae4dd315 365 }
JackB 9:680f6c9940b3 366 _cs = 1;
JackB 9:680f6c9940b3 367 _writeRegister(ILI9225_ENTRY_MODE, _entryMode); // set GRAM write direction and BGR=1.
JackB 7:2616ae4dd315 368 }
JackB 7:2616ae4dd315 369
JackB 9:680f6c9940b3 370 void TFT_22_ILI9225::vline(uint16_t x, uint16_t y1, uint16_t y2, uint16_t color)
JackB 9:680f6c9940b3 371 {
JackB 9:680f6c9940b3 372 _writeRegister(ILI9225_ENTRY_MODE, 0x1010); // set GRAM write direction and BGR=1.
JackB 9:680f6c9940b3 373 _setWindow(x, y1, x + 1, y2 + 1);
JackB 9:680f6c9940b3 374 if (y2 < y1) {
JackB 9:680f6c9940b3 375 _swap(y1, y2);
JackB 9:680f6c9940b3 376 }
JackB 9:680f6c9940b3 377 _rs = 1;
JackB 9:680f6c9940b3 378 _cs = 0;
JackB 9:680f6c9940b3 379 for (uint16_t y = y1; y <= y2; y++) {
JackB 9:680f6c9940b3 380 spi.write(color >> 8);
JackB 9:680f6c9940b3 381 spi.write(color & 0xff);
JackB 7:2616ae4dd315 382 }
JackB 9:680f6c9940b3 383 _cs = 1;
JackB 9:680f6c9940b3 384 _writeRegister(ILI9225_ENTRY_MODE, _entryMode); // set GRAM write direction and BGR=1.
JackB 7:2616ae4dd315 385 }
JackB 7:2616ae4dd315 386
JackB 5:dad648238df3 387 void TFT_22_ILI9225::rect(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t color) {
JackB 7:2616ae4dd315 388
JackB 7:2616ae4dd315 389 vline(x1, y1, y2, color);
JackB 7:2616ae4dd315 390 hline(x1, x2, y1, color);
JackB 7:2616ae4dd315 391 hline(x1, x2, y2, color);
JackB 7:2616ae4dd315 392 vline(x2, y1, y2, color);
JackB 5:dad648238df3 393 }
JackB 5:dad648238df3 394
JackB 10:a640680b5309 395 void TFT_22_ILI9225::fillrect(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t color)
JackB 10:a640680b5309 396 {
JackB 5:dad648238df3 397 _setWindow(x1, y1, x2, y2);
JackB 5:dad648238df3 398 _startData();
JackB 5:dad648238df3 399 for (uint16_t t = (y2 - y1 + 1) * (x2 - x1 + 1); t > 0; t--) {
JackB 5:dad648238df3 400 _writeData(color);
JackB 5:dad648238df3 401 }
JackB 5:dad648238df3 402 _endData();
JackB 5:dad648238df3 403 }
JackB 5:dad648238df3 404
JackB 10:a640680b5309 405 void TFT_22_ILI9225::circle(uint16_t x0, uint16_t y0, uint16_t r, uint16_t color)
JackB 10:a640680b5309 406 {
JackB 5:dad648238df3 407 int16_t f = 1 - r;
JackB 5:dad648238df3 408 int16_t ddF_x = 1;
JackB 5:dad648238df3 409 int16_t ddF_y = -2 * r;
JackB 5:dad648238df3 410 int16_t x = 0;
JackB 5:dad648238df3 411 int16_t y = r;
JackB 5:dad648238df3 412
JackB 5:dad648238df3 413 pixel(x0, y0 + r, color);
JackB 5:dad648238df3 414 pixel(x0, y0 - r, color);
JackB 5:dad648238df3 415 pixel(x0 + r, y0, color);
JackB 5:dad648238df3 416 pixel(x0 - r, y0, color);
JackB 0:cc1fb45bc3ad 417
JackB 5:dad648238df3 418 while (x < y) {
JackB 5:dad648238df3 419 if (f >= 0) {
JackB 5:dad648238df3 420 y--;
JackB 5:dad648238df3 421 ddF_y += 2;
JackB 5:dad648238df3 422 f += ddF_y;
JackB 5:dad648238df3 423 }
JackB 5:dad648238df3 424 x++;
JackB 5:dad648238df3 425 ddF_x += 2;
JackB 5:dad648238df3 426 f += ddF_x;
JackB 5:dad648238df3 427
JackB 5:dad648238df3 428 pixel(x0 + x, y0 + y, color);
JackB 5:dad648238df3 429 pixel(x0 - x, y0 + y, color);
JackB 5:dad648238df3 430 pixel(x0 + x, y0 - y, color);
JackB 5:dad648238df3 431 pixel(x0 - x, y0 - y, color);
JackB 5:dad648238df3 432 pixel(x0 + y, y0 + x, color);
JackB 5:dad648238df3 433 pixel(x0 - y, y0 + x, color);
JackB 5:dad648238df3 434 pixel(x0 + y, y0 - x, color);
JackB 5:dad648238df3 435 pixel(x0 - y, y0 - x, color);
JackB 5:dad648238df3 436 }
JackB 5:dad648238df3 437 }
JackB 5:dad648238df3 438
JackB 10:a640680b5309 439 void TFT_22_ILI9225::fillcircle(uint8_t x0, uint8_t y0, uint8_t radius, uint16_t color)
JackB 10:a640680b5309 440 {
JackB 5:dad648238df3 441 int16_t f = 1 - radius;
JackB 5:dad648238df3 442 int16_t ddF_x = 1;
JackB 5:dad648238df3 443 int16_t ddF_y = -2 * radius;
JackB 5:dad648238df3 444 int16_t x = 0;
JackB 5:dad648238df3 445 int16_t y = radius;
JackB 5:dad648238df3 446
JackB 5:dad648238df3 447 while (x < y) {
JackB 5:dad648238df3 448 if (f >= 0) {
JackB 5:dad648238df3 449 y--;
JackB 5:dad648238df3 450 ddF_y += 2;
JackB 5:dad648238df3 451 f += ddF_y;
JackB 5:dad648238df3 452 }
JackB 5:dad648238df3 453 x++;
JackB 5:dad648238df3 454 ddF_x += 2;
JackB 5:dad648238df3 455 f += ddF_x;
JackB 5:dad648238df3 456
JackB 5:dad648238df3 457 line(x0 + x, y0 + y, x0 - x, y0 + y, color); // bottom
JackB 5:dad648238df3 458 line(x0 + x, y0 - y, x0 - x, y0 - y, color); // top
JackB 5:dad648238df3 459 line(x0 + y, y0 - x, x0 + y, y0 + x, color); // right
JackB 5:dad648238df3 460 line(x0 - y, y0 - x, x0 - y, y0 + x, color); // left
JackB 5:dad648238df3 461 }
JackB 5:dad648238df3 462 fillrect(x0 - x, y0 - y, x0 + x, y0 + y, color);
JackB 5:dad648238df3 463 }
JackB 0:cc1fb45bc3ad 464
JackB 10:a640680b5309 465 void TFT_22_ILI9225::triangle(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t x3, uint16_t y3, uint16_t color)
JackB 10:a640680b5309 466 {
JackB 5:dad648238df3 467 line(x1, y1, x2, y2, color);
JackB 5:dad648238df3 468 line(x2, y2, x3, y3, color);
JackB 5:dad648238df3 469 line(x3, y3, x1, y1, color);
JackB 5:dad648238df3 470 }
JackB 5:dad648238df3 471
JackB 10:a640680b5309 472 void TFT_22_ILI9225::filltriangle(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t x3, uint16_t y3, uint16_t color)
JackB 10:a640680b5309 473 {
JackB 5:dad648238df3 474 uint16_t a, b, y, last;
JackB 5:dad648238df3 475
JackB 5:dad648238df3 476 // Sort coordinates by Y order (y3 >= y2 >= y1)
JackB 5:dad648238df3 477 if (y1 > y2) {
JackB 5:dad648238df3 478 _swap(y1, y2); _swap(x1, x2);
JackB 5:dad648238df3 479 }
JackB 5:dad648238df3 480 if (y2 > y3) {
JackB 5:dad648238df3 481 _swap(y3, y2); _swap(x3, x2);
JackB 5:dad648238df3 482 }
JackB 5:dad648238df3 483 if (y1 > y2) {
JackB 5:dad648238df3 484 _swap(y1, y2); _swap(x1, x2);
JackB 5:dad648238df3 485 }
JackB 5:dad648238df3 486
JackB 5:dad648238df3 487 if (y1 == y3) { // Handle awkward all-on-same-line case as its own thing
JackB 5:dad648238df3 488 a = b = x1;
JackB 5:dad648238df3 489 if (x2 < a) a = x2;
JackB 5:dad648238df3 490 else if (x2 > b) b = x2;
JackB 5:dad648238df3 491 if (x3 < a) a = x3;
JackB 5:dad648238df3 492 else if (x3 > b) b = x3;
JackB 5:dad648238df3 493 line(a, y1, b, y1, color);
JackB 5:dad648238df3 494 return;
JackB 5:dad648238df3 495 }
JackB 5:dad648238df3 496
JackB 5:dad648238df3 497 uint16_t dx11 = x2 - x1,
JackB 5:dad648238df3 498 dy11 = y2 - y1,
JackB 5:dad648238df3 499 dx12 = x3 - x1,
JackB 5:dad648238df3 500 dy12 = y3 - y1,
JackB 5:dad648238df3 501 dx22 = x3 - x2,
JackB 5:dad648238df3 502 dy22 = y3 - y2,
JackB 5:dad648238df3 503 sa = 0,
JackB 5:dad648238df3 504 sb = 0;
JackB 5:dad648238df3 505
JackB 5:dad648238df3 506 // For upper part of triangle, find scanline crossings for segments
JackB 5:dad648238df3 507 // 0-1 and 0-2. If y2=y3 (flat-bottomed triangle), the scanline y2
JackB 5:dad648238df3 508 // is included here (and second loop will be skipped, avoiding a /0
JackB 5:dad648238df3 509 // error there), otherwise scanline y2 is skipped here and handled
JackB 5:dad648238df3 510 // in the second loop...which also avoids a /0 error here if y1=y2
JackB 5:dad648238df3 511 // (flat-topped triangle).
JackB 5:dad648238df3 512 if (y2 == y3) last = y2; // Include y2 scanline
JackB 5:dad648238df3 513 else last = y2 - 1; // Skip it
JackB 5:dad648238df3 514
JackB 5:dad648238df3 515 for (y = y1; y <= last; y++) {
JackB 5:dad648238df3 516 a = x1 + sa / dy11;
JackB 5:dad648238df3 517 b = x1 + sb / dy12;
JackB 5:dad648238df3 518 sa += dx11;
JackB 5:dad648238df3 519 sb += dx12;
JackB 5:dad648238df3 520 /* longhand:
JackB 5:dad648238df3 521 a = x1 + (x2 - x1) * (y - y1) / (y2 - y1);
JackB 5:dad648238df3 522 b = x1 + (x3 - x1) * (y - y1) / (y3 - y1);
JackB 5:dad648238df3 523 */
JackB 5:dad648238df3 524 if (a > b) _swap(a, b);
JackB 5:dad648238df3 525 line(a, y, b, y, color);
JackB 5:dad648238df3 526 }
JackB 5:dad648238df3 527
JackB 5:dad648238df3 528 // For lower part of triangle, find scanline crossings for segments
JackB 5:dad648238df3 529 // 0-2 and 1-2. This loop is skipped if y2=y3.
JackB 5:dad648238df3 530 sa = dx22 * (y - y2);
JackB 5:dad648238df3 531 sb = dx12 * (y - y1);
JackB 5:dad648238df3 532 for (; y <= y3; y++) {
JackB 5:dad648238df3 533 a = x2 + sa / dy22;
JackB 5:dad648238df3 534 b = x1 + sb / dy12;
JackB 5:dad648238df3 535 sa += dx22;
JackB 5:dad648238df3 536 sb += dx12;
JackB 5:dad648238df3 537 /* longhand:
JackB 5:dad648238df3 538 a = x2 + (x3 - x2) * (y - y2) / (y3 - y2);
JackB 5:dad648238df3 539 b = x1 + (x3 - x1) * (y - y1) / (y3 - y1);
JackB 5:dad648238df3 540 */
JackB 5:dad648238df3 541 if (a > b) _swap(a, b);
JackB 5:dad648238df3 542 line(a, y, b, y, color);
JackB 5:dad648238df3 543 }
JackB 0:cc1fb45bc3ad 544 }
JackB 0:cc1fb45bc3ad 545
JackB 8:a569bc50b552 546 void TFT_22_ILI9225::roundrect(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t rad, bool fill, uint16_t color)
JackB 8:a569bc50b552 547 {
JackB 8:a569bc50b552 548 signed int a, b, P;
JackB 8:a569bc50b552 549
JackB 8:a569bc50b552 550 a = 0; // increment by 1
JackB 8:a569bc50b552 551 b = rad; // decrement by 1 using P
JackB 8:a569bc50b552 552 P = 1 - rad;
JackB 8:a569bc50b552 553
JackB 8:a569bc50b552 554 if (fill)
JackB 8:a569bc50b552 555 {
JackB 8:a569bc50b552 556 fillrect(x1, y1 + rad, x2, y2 - rad, color);
JackB 8:a569bc50b552 557
JackB 8:a569bc50b552 558 do
JackB 8:a569bc50b552 559 {
JackB 8:a569bc50b552 560 fillrect(x1 - a + rad, y1 - b + rad, a + x2 - rad, y1 - b + rad, color); // 8 --> 1
JackB 8:a569bc50b552 561 fillrect(x1 - b + rad, y1 - a + rad, b + x2 - rad, y1 - a + rad, color); // 7 --> 2
JackB 8:a569bc50b552 562 fillrect(x1 - b + rad, a + y2 - rad, b + x2 - rad, a + y2 - rad, color); // 6 --> 3
JackB 8:a569bc50b552 563 fillrect(x1 - a + rad, b + y2 - rad, a + x2 - rad, b + y2 - rad, color); // 5 --> 4
JackB 8:a569bc50b552 564
JackB 8:a569bc50b552 565 if (P < 0)
JackB 8:a569bc50b552 566 P += 3 + 2 * a++;
JackB 8:a569bc50b552 567 else
JackB 8:a569bc50b552 568 P += 5 + 2 * (a++ - b--);
JackB 8:a569bc50b552 569
JackB 8:a569bc50b552 570 } while (a <= b);
JackB 8:a569bc50b552 571 }
JackB 8:a569bc50b552 572 else
JackB 8:a569bc50b552 573 {
JackB 8:a569bc50b552 574 hline(x1 + rad, x2 - rad, y1, color); // top
JackB 8:a569bc50b552 575 hline(x1 + rad, x2 - rad, y2, color); // bottom
JackB 8:a569bc50b552 576 vline(x1, y1 + rad, y2 - rad, color); // left
JackB 8:a569bc50b552 577 vline(x2, y1 + rad, y2 - rad, color); // right
JackB 8:a569bc50b552 578
JackB 8:a569bc50b552 579 do
JackB 8:a569bc50b552 580 {
JackB 8:a569bc50b552 581 pixel(a + x2 - rad, y1 - b + rad, color); // `````` Segment 1
JackB 8:a569bc50b552 582 pixel(b + x2 - rad, y1 - a + rad, color); // `````` Segment 2
JackB 8:a569bc50b552 583
JackB 8:a569bc50b552 584 pixel(b + x2 - rad, a + y2 - rad, color); // `````` Segment 3
JackB 8:a569bc50b552 585 pixel(a + x2 - rad, b + y2 - rad, color); // `````` Segment 4
JackB 8:a569bc50b552 586
JackB 8:a569bc50b552 587 pixel(x1 - a + rad, b + y2 - rad, color); // `````` Segment 5
JackB 8:a569bc50b552 588 pixel(x1 - b + rad, a + y2 - rad, color); // `````` Segment 6
JackB 8:a569bc50b552 589
JackB 8:a569bc50b552 590 pixel(x1 - b + rad, y1 - a + rad, color); // `````` Segment 7
JackB 8:a569bc50b552 591 pixel(x1 - a + rad, y1 - b + rad, color); // `````` Segment 8
JackB 8:a569bc50b552 592
JackB 8:a569bc50b552 593 if (P < 0)
JackB 8:a569bc50b552 594 P += 3 + 2 * a++;
JackB 8:a569bc50b552 595 else
JackB 8:a569bc50b552 596 P += 5 + 2 * (a++ - b--);
JackB 8:a569bc50b552 597 } while (a <= b);
JackB 8:a569bc50b552 598 }
JackB 8:a569bc50b552 599 }
JackB 8:a569bc50b552 600
JackB 10:a640680b5309 601 uint8_t TFT_22_ILI9225::fontX(void)
JackB 10:a640680b5309 602 {
JackB 10:a640680b5309 603 return font[FONT_HORZ];
JackB 10:a640680b5309 604 }
JackB 10:a640680b5309 605
JackB 10:a640680b5309 606 uint8_t TFT_22_ILI9225::fontY(void)
JackB 10:a640680b5309 607 {
JackB 10:a640680b5309 608 return font[FONT_VERT];
JackB 10:a640680b5309 609 }
JackB 10:a640680b5309 610
JackB 10:a640680b5309 611 uint16_t TFT_22_ILI9225::maxX(void)
JackB 10:a640680b5309 612 {
JackB 0:cc1fb45bc3ad 613 return _maxX - 1;
JackB 0:cc1fb45bc3ad 614 }
JackB 0:cc1fb45bc3ad 615
JackB 10:a640680b5309 616 uint16_t TFT_22_ILI9225::maxY(void)
JackB 10:a640680b5309 617 {
JackB 0:cc1fb45bc3ad 618 return _maxY - 1;
JackB 0:cc1fb45bc3ad 619 }
JackB 0:cc1fb45bc3ad 620
JackB 10:a640680b5309 621 uint16_t TFT_22_ILI9225::width(void)
JackB 10:a640680b5309 622 {
JackB 0:cc1fb45bc3ad 623 return _maxX;
JackB 0:cc1fb45bc3ad 624 }
JackB 0:cc1fb45bc3ad 625
JackB 10:a640680b5309 626 uint16_t TFT_22_ILI9225::height(void)
JackB 10:a640680b5309 627 {
JackB 0:cc1fb45bc3ad 628 return _maxY;
JackB 0:cc1fb45bc3ad 629 }
JackB 0:cc1fb45bc3ad 630
JackB 10:a640680b5309 631 uint16_t TFT_22_ILI9225::setColor(uint8_t red8, uint8_t green8, uint8_t blue8)
JackB 10:a640680b5309 632 {
JackB 0:cc1fb45bc3ad 633 // rgb16 = red5 green6 blue5
JackB 0:cc1fb45bc3ad 634 return (red8 >> 3) << 11 | (green8 >> 2) << 5 | (blue8 >> 3);
JackB 0:cc1fb45bc3ad 635 }
JackB 0:cc1fb45bc3ad 636
JackB 10:a640680b5309 637 void TFT_22_ILI9225::splitColor(uint16_t rgb, uint8_t &red, uint8_t &green, uint8_t &blue)
JackB 10:a640680b5309 638 {
JackB 0:cc1fb45bc3ad 639 // rgb16 = red5 green6 blue5
JackB 0:cc1fb45bc3ad 640
JackB 0:cc1fb45bc3ad 641 red = (rgb & 0xF800) >> 11 << 3;
JackB 0:cc1fb45bc3ad 642 green = (rgb & 0x7E0) >> 5 << 2;
JackB 0:cc1fb45bc3ad 643 blue = (rgb & 0x1F) << 3;
JackB 0:cc1fb45bc3ad 644 }
JackB 0:cc1fb45bc3ad 645
JackB 10:a640680b5309 646 void TFT_22_ILI9225::_swap(uint16_t &a, uint16_t &b)
JackB 10:a640680b5309 647 {
JackB 0:cc1fb45bc3ad 648 uint16_t w = a;
JackB 0:cc1fb45bc3ad 649 a = b;
JackB 0:cc1fb45bc3ad 650 b = w;
JackB 0:cc1fb45bc3ad 651 }
JackB 0:cc1fb45bc3ad 652
JackB 10:a640680b5309 653 void TFT_22_ILI9225::_writeCommand(uint8_t HI, uint8_t LO)
JackB 10:a640680b5309 654 {
JackB 0:cc1fb45bc3ad 655 _rs = 0;
JackB 0:cc1fb45bc3ad 656 _cs = 0;
JackB 0:cc1fb45bc3ad 657 spi.write(HI);
JackB 0:cc1fb45bc3ad 658 spi.write(LO);
JackB 0:cc1fb45bc3ad 659 _cs = 1;
JackB 0:cc1fb45bc3ad 660 }
JackB 0:cc1fb45bc3ad 661
JackB 10:a640680b5309 662 void TFT_22_ILI9225::_writeData(uint16_t data)
JackB 10:a640680b5309 663 {
JackB 0:cc1fb45bc3ad 664 spi.write(data >> 8);
JackB 0:cc1fb45bc3ad 665 spi.write(data & 0xff);
JackB 0:cc1fb45bc3ad 666 // spi.write(data);
JackB 0:cc1fb45bc3ad 667 }
JackB 0:cc1fb45bc3ad 668
JackB 10:a640680b5309 669 void TFT_22_ILI9225::_startData(void)
JackB 10:a640680b5309 670 {
JackB 0:cc1fb45bc3ad 671 _rs = 1;
JackB 0:cc1fb45bc3ad 672 _cs = 0;
JackB 0:cc1fb45bc3ad 673 // spi.format(16, 0); // New mbed library can't use 16 bit spi anymore on this platform
JackB 0:cc1fb45bc3ad 674 }
JackB 0:cc1fb45bc3ad 675
JackB 10:a640680b5309 676 void TFT_22_ILI9225::_endData(void)
JackB 10:a640680b5309 677 {
JackB 0:cc1fb45bc3ad 678 _cs = 1;
JackB 0:cc1fb45bc3ad 679 // spi.format(8, 0);
JackB 0:cc1fb45bc3ad 680 }
JackB 0:cc1fb45bc3ad 681
JackB 10:a640680b5309 682 void TFT_22_ILI9225::_writeRegister(uint16_t reg, uint16_t data)
JackB 10:a640680b5309 683 {
JackB 0:cc1fb45bc3ad 684 _writeCommand(reg >> 8, reg & 0xff);
JackB 0:cc1fb45bc3ad 685 _startData();
JackB 0:cc1fb45bc3ad 686 _writeData(data);
JackB 0:cc1fb45bc3ad 687 _endData();
JackB 0:cc1fb45bc3ad 688 }
JackB 0:cc1fb45bc3ad 689
JackB 10:a640680b5309 690 void TFT_22_ILI9225::setFont(unsigned char* f)
JackB 10:a640680b5309 691 {
JackB 0:cc1fb45bc3ad 692 font = f;
JackB 0:cc1fb45bc3ad 693 }
JackB 0:cc1fb45bc3ad 694
JackB 0:cc1fb45bc3ad 695 int TFT_22_ILI9225::putc(int value)
JackB 0:cc1fb45bc3ad 696 {
JackB 0:cc1fb45bc3ad 697 if (value == '\n') { // new line
JackB 0:cc1fb45bc3ad 698 char_x = 0;
JackB 0:cc1fb45bc3ad 699 char_y = char_y + (font[FONT_VERT] + char_line_spacing);
JackB 0:cc1fb45bc3ad 700 if (char_y >= height() - (font[FONT_VERT] + char_line_spacing)) {
JackB 0:cc1fb45bc3ad 701 char_y = 0;
JackB 0:cc1fb45bc3ad 702 }
JackB 0:cc1fb45bc3ad 703 return value;
JackB 0:cc1fb45bc3ad 704 }
JackB 0:cc1fb45bc3ad 705 if ((value < 32) || (value > 127)) {
JackB 0:cc1fb45bc3ad 706 return value;
JackB 0:cc1fb45bc3ad 707 }
JackB 0:cc1fb45bc3ad 708 character(char_x, char_y, value);
JackB 0:cc1fb45bc3ad 709 return value;
JackB 0:cc1fb45bc3ad 710 }
JackB 0:cc1fb45bc3ad 711
JackB 0:cc1fb45bc3ad 712 void TFT_22_ILI9225::character(int x, int y, int c)
JackB 0:cc1fb45bc3ad 713 {
JackB 3:41e8d7dc279a 714 unsigned int hor, vert, offset, bpl, i, j, b;
JackB 0:cc1fb45bc3ad 715 unsigned char* zeichen;
JackB 0:cc1fb45bc3ad 716 unsigned char z,w;
JackB 0:cc1fb45bc3ad 717
JackB 0:cc1fb45bc3ad 718 if ((c < 31) || (c > 127)) return; // test char range
JackB 0:cc1fb45bc3ad 719
JackB 0:cc1fb45bc3ad 720 // read font parameter from start of array
JackB 0:cc1fb45bc3ad 721 offset = font[FONT_LENGTH]; // bytes / char
JackB 0:cc1fb45bc3ad 722 hor = font[FONT_HORZ]; // get hor size of font
JackB 0:cc1fb45bc3ad 723 vert = font[FONT_VERT]; // get vert size of font
JackB 0:cc1fb45bc3ad 724 bpl = font[FONT_BYTES_VERT]; // bytes per line
JackB 0:cc1fb45bc3ad 725
JackB 0:cc1fb45bc3ad 726 if (char_x + hor > width()) {
JackB 0:cc1fb45bc3ad 727 char_x = 0;
JackB 0:cc1fb45bc3ad 728 char_y = char_y + vert + char_line_spacing;
JackB 0:cc1fb45bc3ad 729 if (char_y >= height() - (vert + char_line_spacing)) {
JackB 0:cc1fb45bc3ad 730 char_y = 0;
JackB 0:cc1fb45bc3ad 731 }
JackB 0:cc1fb45bc3ad 732 }
JackB 0:cc1fb45bc3ad 733 _setWindow(char_x, char_y, (char_x+hor)-1, (char_y+vert)-1);
JackB 0:cc1fb45bc3ad 734
JackB 0:cc1fb45bc3ad 735 zeichen = &font[((c -32) * offset) + 4]; // start of char bitmap
JackB 0:cc1fb45bc3ad 736 w = zeichen[0]; // width of actual char
JackB 0:cc1fb45bc3ad 737 _startData();
JackB 0:cc1fb45bc3ad 738
JackB 4:44a66bd8c16c 739 // Portrait
JackB 4:44a66bd8c16c 740 for (j = 0; j < vert; j++) { // vert line
JackB 4:44a66bd8c16c 741 for (i = 0; i < hor; i++) { // horz line
JackB 4:44a66bd8c16c 742 z = zeichen[bpl * i + ((j & 0xF8) >> 3)+1];
JackB 4:44a66bd8c16c 743 b = 1 << (j & 0x07);
JackB 4:44a66bd8c16c 744 if (( z & b ) == 0x00) {
JackB 4:44a66bd8c16c 745 spi.write(_background >> 8);
JackB 4:44a66bd8c16c 746 spi.write(_background & 0xff);
JackB 4:44a66bd8c16c 747 } else {
JackB 4:44a66bd8c16c 748 spi.write(_foreground >> 8);
JackB 4:44a66bd8c16c 749 spi.write(_foreground & 0xff);
JackB 0:cc1fb45bc3ad 750 }
JackB 4:44a66bd8c16c 751 }
JackB 4:44a66bd8c16c 752 }
JackB 0:cc1fb45bc3ad 753
JackB 0:cc1fb45bc3ad 754 _endData();
JackB 0:cc1fb45bc3ad 755 _setWindowMax();
JackB 0:cc1fb45bc3ad 756 if ((w + 2) < hor) { // x offset to next char
JackB 0:cc1fb45bc3ad 757 char_x += w + 2;
JackB 0:cc1fb45bc3ad 758 } else char_x += hor;
JackB 0:cc1fb45bc3ad 759 }
JackB 0:cc1fb45bc3ad 760
JackB 10:a640680b5309 761 void TFT_22_ILI9225::foreground(uint16_t color)
JackB 10:a640680b5309 762 {
JackB 10:a640680b5309 763 _foreground = color;
JackB 0:cc1fb45bc3ad 764 }
JackB 0:cc1fb45bc3ad 765
JackB 10:a640680b5309 766 void TFT_22_ILI9225::background(uint16_t color)
JackB 10:a640680b5309 767 {
JackB 10:a640680b5309 768 _background = color;
JackB 0:cc1fb45bc3ad 769 }
JackB 0:cc1fb45bc3ad 770
JackB 0:cc1fb45bc3ad 771 void TFT_22_ILI9225::locate(int x, int y)
JackB 0:cc1fb45bc3ad 772 {
JackB 0:cc1fb45bc3ad 773 char_x = x;
JackB 0:cc1fb45bc3ad 774 char_y = y;
JackB 0:cc1fb45bc3ad 775 }
JackB 0:cc1fb45bc3ad 776
JackB 0:cc1fb45bc3ad 777 void TFT_22_ILI9225::gotoxy(int x, int y)
JackB 0:cc1fb45bc3ad 778 {
JackB 0:cc1fb45bc3ad 779 char_x = x * font[FONT_HORZ];
JackB 0:cc1fb45bc3ad 780 char_y = y * (font[FONT_VERT] + char_line_spacing);
JackB 0:cc1fb45bc3ad 781 }
JackB 0:cc1fb45bc3ad 782
JackB 0:cc1fb45bc3ad 783 void TFT_22_ILI9225::home(void)
JackB 0:cc1fb45bc3ad 784 {
JackB 0:cc1fb45bc3ad 785 gotoxy(0, 0);
JackB 0:cc1fb45bc3ad 786 }
JackB 0:cc1fb45bc3ad 787
JackB 0:cc1fb45bc3ad 788 void TFT_22_ILI9225::linespacing(int line_spacing)
JackB 0:cc1fb45bc3ad 789 {
JackB 0:cc1fb45bc3ad 790 char_line_spacing = line_spacing;
JackB 0:cc1fb45bc3ad 791 }
JackB 0:cc1fb45bc3ad 792
JackB 0:cc1fb45bc3ad 793 int TFT_22_ILI9225::columns()
JackB 0:cc1fb45bc3ad 794 {
JackB 0:cc1fb45bc3ad 795 return width() / font[FONT_HORZ];
JackB 0:cc1fb45bc3ad 796 }
JackB 0:cc1fb45bc3ad 797
JackB 0:cc1fb45bc3ad 798 int TFT_22_ILI9225::rows()
JackB 0:cc1fb45bc3ad 799 {
JackB 0:cc1fb45bc3ad 800 return height() / font[FONT_VERT];
JackB 0:cc1fb45bc3ad 801 }
JackB 0:cc1fb45bc3ad 802
JackB 0:cc1fb45bc3ad 803 void TFT_22_ILI9225::unicode2ascii(char *uni_str, char *ascii_str)
JackB 0:cc1fb45bc3ad 804 {
JackB 0:cc1fb45bc3ad 805 int counter = 0;
JackB 0:cc1fb45bc3ad 806 int Uch = 0;
JackB 0:cc1fb45bc3ad 807 char chl, chh;
JackB 0:cc1fb45bc3ad 808
JackB 0:cc1fb45bc3ad 809
JackB 0:cc1fb45bc3ad 810 while (*uni_str)
JackB 0:cc1fb45bc3ad 811 {
JackB 0:cc1fb45bc3ad 812 chl = *uni_str++;
JackB 0:cc1fb45bc3ad 813 chh = *uni_str++;
JackB 0:cc1fb45bc3ad 814
JackB 0:cc1fb45bc3ad 815 Uch = 0;
JackB 0:cc1fb45bc3ad 816 Uch = ((Uch | chh) << 8) | chl;
JackB 0:cc1fb45bc3ad 817
JackB 0:cc1fb45bc3ad 818 if (Uch > 1574 && Uch < 1591)
JackB 0:cc1fb45bc3ad 819 *(ascii_str + counter) = (char)(Uch - 1376);
JackB 0:cc1fb45bc3ad 820 else if (Uch > 1590 && Uch < 1595)
JackB 0:cc1fb45bc3ad 821 *(ascii_str + counter) = (char)(Uch - 1375);
JackB 0:cc1fb45bc3ad 822 else if (Uch > 1600 && Uch < 1603)
JackB 0:cc1fb45bc3ad 823 *(ascii_str + counter) = (char)(Uch - 1380);
JackB 0:cc1fb45bc3ad 824 else if (Uch == 1705)
JackB 0:cc1fb45bc3ad 825 *(ascii_str + counter) = (char)(Uch - 1482);
JackB 0:cc1fb45bc3ad 826 else if (Uch == 1604)
JackB 0:cc1fb45bc3ad 827 *(ascii_str + counter) = (char)(Uch - 1379);
JackB 0:cc1fb45bc3ad 828 else if (Uch > 1604 && Uch < 1609)
JackB 0:cc1fb45bc3ad 829 *(ascii_str + counter) = (char)(Uch - 1378);
JackB 0:cc1fb45bc3ad 830 else if (Uch == 1740)
JackB 0:cc1fb45bc3ad 831 *(ascii_str + counter) = (char)(Uch - 1503);
JackB 0:cc1fb45bc3ad 832 else if (Uch == 1574)
JackB 0:cc1fb45bc3ad 833 *(ascii_str + counter) = (char)(Uch - 1381);
JackB 0:cc1fb45bc3ad 834 else if (Uch == 1662)
JackB 0:cc1fb45bc3ad 835 *(ascii_str + counter) = (char)(Uch - 1533);
JackB 0:cc1fb45bc3ad 836 else if (Uch == 1670)
JackB 0:cc1fb45bc3ad 837 *(ascii_str + counter) = (char)(Uch - 1529);
JackB 0:cc1fb45bc3ad 838 else if (Uch == 1688)
JackB 0:cc1fb45bc3ad 839 *(ascii_str + counter) = (char)(Uch - 1546);
JackB 0:cc1fb45bc3ad 840 else if (Uch == 1711)
JackB 0:cc1fb45bc3ad 841 *(ascii_str + counter) = (char)(Uch - 1567);
JackB 0:cc1fb45bc3ad 842 else if (Uch == 1570)
JackB 0:cc1fb45bc3ad 843 *(ascii_str + counter) = (char)(Uch - 1376);
JackB 0:cc1fb45bc3ad 844 else if (Uch > 1631 && Uch < 1642)
JackB 0:cc1fb45bc3ad 845 *(ascii_str + counter) = (char)(Uch - 1584);
JackB 0:cc1fb45bc3ad 846 else if (Uch == 65536)
JackB 0:cc1fb45bc3ad 847 *(ascii_str + counter) = NULL;
JackB 0:cc1fb45bc3ad 848 else
JackB 0:cc1fb45bc3ad 849 *(ascii_str + counter) = (char)Uch;
JackB 0:cc1fb45bc3ad 850
JackB 0:cc1fb45bc3ad 851
JackB 0:cc1fb45bc3ad 852 counter++;
JackB 0:cc1fb45bc3ad 853
JackB 0:cc1fb45bc3ad 854 }
JackB 0:cc1fb45bc3ad 855 *(ascii_str + counter) = NULL;
JackB 0:cc1fb45bc3ad 856 }
JackB 0:cc1fb45bc3ad 857