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@17:b120858d05ff, 2016-11-23 (annotated)

Committer:
JackB
Date:
Wed Nov 23 22:42:30 2016 +0000
Revision:
17:b120858d05ff
Parent:
16:4dd508313fce 
Comment added

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