Tomas Kucera / RA8875

LCD LIB

Dependents:   HagridOS5

Fork of RA8875 by David Smart

RA8875.cpp@151:8f4c87e5cb9b, 2018-02-21 (annotated)

Committer:
Hagrid
Date:
Wed Feb 21 14:57:21 2018 +0000
Revision:
151:8f4c87e5cb9b
Parent:
150:35a4db3081c1 
Add feature to my project

Who changed what in which revision?

UserRevisionLine numberNew contents of line
WiredHome 19:3f82c1161fd2 1 /// RA8875 Display Controller Library.
WiredHome 73:f22a18707b5e 2 ///
WiredHome 68:ab08efabfc88 3 /// This is being created for a Raio RA8875-based display from buydisplay.com,
WiredHome 80:cc4fab58179c 4 /// which is 480 x 272 using a 4-wire SPI interface. Support is provided for
WiredHome 80:cc4fab58179c 5 /// both a keypad and a resistive touch-screen.
WiredHome 80:cc4fab58179c 6 ///
WiredHome 134:f028ed71a0af 7 /// This driver has been fully tested with an 800 x 480 variant (also using
WiredHome 133:e36dcfc2d756 8 /// 4-wire SPI).
WiredHome 19:3f82c1161fd2 9 ///
WiredHome 134:f028ed71a0af 10 /// 20161106: Updated the initialization to set the various registers based on
WiredHome 134:f028ed71a0af 11 /// the BuyDisplay.com example code. This altered several registers
WiredHome 134:f028ed71a0af 12 /// for the 800x480 display driver.
WiredHome 19:3f82c1161fd2 13 ///
WiredHome 19:3f82c1161fd2 14 #include "RA8875.h"
WiredHome 19:3f82c1161fd2 15
WiredHome 145:5eb2492acdda 16 //#include "Utility.h" // private memory manager
WiredHome 145:5eb2492acdda 17 #ifndef UTILITY_H
WiredHome 145:5eb2492acdda 18 #define swMalloc malloc // use the standard
WiredHome 145:5eb2492acdda 19 #define swFree free
WiredHome 145:5eb2492acdda 20 #endif
WiredHome 145:5eb2492acdda 21
WiredHome 41:2956a0a221e5 22 //#define DEBUG "RAIO"
WiredHome 19:3f82c1161fd2 23 // ...
WiredHome 19:3f82c1161fd2 24 // INFO("Stuff to show %d", var); // new-line is automatically appended
WiredHome 19:3f82c1161fd2 25 //
WiredHome 19:3f82c1161fd2 26 #if (defined(DEBUG) && !defined(TARGET_LPC11U24))
WiredHome 98:ecebed9b80b2 27 #define INFO(x, ...) std::printf("[INF %s %4d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
WiredHome 98:ecebed9b80b2 28 #define WARN(x, ...) std::printf("[WRN %s %4d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
WiredHome 98:ecebed9b80b2 29 #define ERR(x, ...) std::printf("[ERR %s %4d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
WiredHome 98:ecebed9b80b2 30 static void HexDump(const char * title, const uint8_t * p, int count)
WiredHome 73:f22a18707b5e 31 {
WiredHome 73:f22a18707b5e 32 int i;
WiredHome 73:f22a18707b5e 33 char buf[100] = "0000: ";
WiredHome 73:f22a18707b5e 34
WiredHome 73:f22a18707b5e 35 if (*title)
WiredHome 73:f22a18707b5e 36 INFO("%s", title);
WiredHome 73:f22a18707b5e 37 for (i=0; i<count; ) {
WiredHome 73:f22a18707b5e 38 sprintf(buf + strlen(buf), "%02X ", *(p+i));
WiredHome 73:f22a18707b5e 39 if ((++i & 0x0F) == 0x00) {
WiredHome 73:f22a18707b5e 40 INFO("%s", buf);
WiredHome 73:f22a18707b5e 41 if (i < count)
WiredHome 73:f22a18707b5e 42 sprintf(buf, "%04X: ", i);
WiredHome 73:f22a18707b5e 43 else
WiredHome 73:f22a18707b5e 44 buf[0] = '\0';
WiredHome 73:f22a18707b5e 45 }
WiredHome 73:f22a18707b5e 46 }
WiredHome 73:f22a18707b5e 47 if (strlen(buf))
WiredHome 73:f22a18707b5e 48 INFO("%s", buf);
WiredHome 73:f22a18707b5e 49 }
WiredHome 19:3f82c1161fd2 50 #else
WiredHome 19:3f82c1161fd2 51 #define INFO(x, ...)
WiredHome 19:3f82c1161fd2 52 #define WARN(x, ...)
WiredHome 19:3f82c1161fd2 53 #define ERR(x, ...)
WiredHome 73:f22a18707b5e 54 #define HexDump(a, b, c)
WiredHome 19:3f82c1161fd2 55 #endif
WiredHome 19:3f82c1161fd2 56
WiredHome 109:7b94f06f085b 57 // Defaults. Users can override this with the init() method.
WiredHome 19:3f82c1161fd2 58 #define RA8875_DISPLAY_WIDTH 480
WiredHome 19:3f82c1161fd2 59 #define RA8875_DISPLAY_HEIGHT 272
WiredHome 43:3becae133285 60 #define RA8875_COLORDEPTH_BPP 16 /* Not an API */
WiredHome 19:3f82c1161fd2 61
WiredHome 19:3f82c1161fd2 62 #ifdef PERF_METRICS
WiredHome 19:3f82c1161fd2 63 #define PERFORMANCE_RESET performance.reset()
WiredHome 19:3f82c1161fd2 64 #define REGISTERPERFORMANCE(a) RegisterPerformance(a)
WiredHome 68:ab08efabfc88 65 #define COUNTIDLETIME(a) CountIdleTime(a)
WiredHome 73:f22a18707b5e 66 static const char *metricsName[] = {
WiredHome 109:7b94f06f085b 67 "Cls", "Pixel", "Pixel Stream", "Boolean Stream",
WiredHome 41:2956a0a221e5 68 "Read Pixel", "Read Pixel Stream",
WiredHome 73:f22a18707b5e 69 "Line",
WiredHome 73:f22a18707b5e 70 "Rectangle", "Rounded Rectangle",
WiredHome 68:ab08efabfc88 71 "Triangle", "Circle", "Ellipse"
WiredHome 19:3f82c1161fd2 72 };
WiredHome 91:ca5f829e6d27 73 uint16_t commandsUsed[256]; // track which commands are used with simple counter of number of hits.
WiredHome 19:3f82c1161fd2 74 #else
WiredHome 19:3f82c1161fd2 75 #define PERFORMANCE_RESET
WiredHome 19:3f82c1161fd2 76 #define REGISTERPERFORMANCE(a)
WiredHome 68:ab08efabfc88 77 #define COUNTIDLETIME(a)
WiredHome 19:3f82c1161fd2 78 #endif
WiredHome 19:3f82c1161fd2 79
WiredHome 73:f22a18707b5e 80 // When it is going to poll a register for completion, how many
WiredHome 19:3f82c1161fd2 81 // uSec should it wait between each polling activity.
WiredHome 19:3f82c1161fd2 82 #define POLLWAITuSec 10
WiredHome 19:3f82c1161fd2 83
WiredHome 75:ca78388cfd77 84 // Private RawKeyMap for the Keyboard interface
WiredHome 79:544eb4964795 85 static const uint8_t DefaultKeyMap[22] = {
WiredHome 77:9206c13aa527 86 0,
WiredHome 77:9206c13aa527 87 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
WiredHome 75:ca78388cfd77 88 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
WiredHome 75:ca78388cfd77 89 255
WiredHome 77:9206c13aa527 90 };
WiredHome 75:ca78388cfd77 91
WiredHome 79:544eb4964795 92 static const char * ErrMessages[] = {
WiredHome 79:544eb4964795 93 "noerror", ///< no errors, command completed successfully
WiredHome 89:04575562c961 94 "bad parameter", ///< one or more parameters are invalid
WiredHome 89:04575562c961 95 "file not found", ///< specified file could not be found
WiredHome 89:04575562c961 96 "not bmp format", ///< file is not a .bmp file
WiredHome 89:04575562c961 97 "not ico format", ///< file is not a .ico file
WiredHome 89:04575562c961 98 "not supported format", ///< file format is not yet supported
WiredHome 89:04575562c961 99 "image too big", ///< image is too large for the screen
WiredHome 89:04575562c961 100 "not enough ram", ///< could not allocate ram for scanline
WiredHome 125:7a0b70f56550 101 "touch cal. timeout", ///< calibration could not complete in time
WiredHome 125:7a0b70f56550 102 "external abort", ///< during an idle callback, the user code initiated an abort
WiredHome 79:544eb4964795 103 };
WiredHome 19:3f82c1161fd2 104
WiredHome 124:1690a7ae871c 105 RA8875::RA8875(PinName mosi, PinName miso, PinName sclk, PinName csel, PinName reset,
WiredHome 124:1690a7ae871c 106 const char *name)
WiredHome 58:26658a56112a 107 : GraphicsDisplay(name)
WiredHome 58:26658a56112a 108 , spi(mosi, miso, sclk)
WiredHome 19:3f82c1161fd2 109 , cs(csel)
WiredHome 19:3f82c1161fd2 110 , res(reset)
WiredHome 19:3f82c1161fd2 111 {
WiredHome 124:1690a7ae871c 112 useTouchPanel = TP_NONE;
WiredHome 124:1690a7ae871c 113 m_irq = NULL;
WiredHome 124:1690a7ae871c 114 m_i2c = NULL;
WiredHome 96:40b74dd3695b 115 c_callback = NULL;
WiredHome 96:40b74dd3695b 116 obj_callback = NULL;
WiredHome 96:40b74dd3695b 117 method_callback = NULL;
WiredHome 123:2f45e80fec5f 118 idle_callback = NULL;
WiredHome 19:3f82c1161fd2 119 }
WiredHome 19:3f82c1161fd2 120
WiredHome 124:1690a7ae871c 121
WiredHome 124:1690a7ae871c 122 RA8875::RA8875(PinName mosi, PinName miso, PinName sclk, PinName csel, PinName reset,
WiredHome 124:1690a7ae871c 123 PinName sda, PinName scl, PinName irq, const char * name)
WiredHome 124:1690a7ae871c 124 : GraphicsDisplay(name)
WiredHome 124:1690a7ae871c 125 , spi(mosi, miso, sclk)
WiredHome 124:1690a7ae871c 126 , cs(csel)
WiredHome 124:1690a7ae871c 127 , res(reset)
WiredHome 124:1690a7ae871c 128 {
WiredHome 124:1690a7ae871c 129 useTouchPanel = TP_CAP;
WiredHome 124:1690a7ae871c 130 m_irq = new InterruptIn(irq);
WiredHome 124:1690a7ae871c 131 m_i2c = new I2C(sda, scl);
WiredHome 124:1690a7ae871c 132 c_callback = NULL;
WiredHome 124:1690a7ae871c 133 obj_callback = NULL;
WiredHome 124:1690a7ae871c 134 method_callback = NULL;
WiredHome 124:1690a7ae871c 135 idle_callback = NULL;
WiredHome 124:1690a7ae871c 136
WiredHome 124:1690a7ae871c 137 // Cap touch panel config
WiredHome 124:1690a7ae871c 138 m_addr = (FT5206_I2C_ADDRESS << 1);
WiredHome 124:1690a7ae871c 139 m_i2c->frequency(FT5206_I2C_FREQUENCY);
WiredHome 124:1690a7ae871c 140
WiredHome 124:1690a7ae871c 141 // Interrupt
WiredHome 124:1690a7ae871c 142 m_irq->mode(PullUp);
WiredHome 124:1690a7ae871c 143 m_irq->enable_irq();
WiredHome 150:35a4db3081c1 144 #if MBED_LIBRARY_VERSION > 122 // Is this the right version?
WiredHome 145:5eb2492acdda 145 m_irq->fall(callback(this, &RA8875::TouchPanelISR));
WiredHome 150:35a4db3081c1 146 #else
WiredHome 150:35a4db3081c1 147 m_irq->fall(this, &RA8875::TouchPanelISR);
WiredHome 150:35a4db3081c1 148 #endif
WiredHome 124:1690a7ae871c 149 TouchPanelInit();
WiredHome 124:1690a7ae871c 150 }
WiredHome 124:1690a7ae871c 151
WiredHome 124:1690a7ae871c 152
WiredHome 19:3f82c1161fd2 153 //RA8875::~RA8875()
WiredHome 19:3f82c1161fd2 154 //{
WiredHome 19:3f82c1161fd2 155 //}
WiredHome 19:3f82c1161fd2 156
WiredHome 131:5bd6ba2ee4a1 157 RetCode_t RA8875::init(int width, int height, int color_bpp, uint8_t poweron, bool keypadon, bool touchscreenon)
WiredHome 79:544eb4964795 158 {
WiredHome 98:ecebed9b80b2 159 font = NULL; // no external font, use internal.
WiredHome 98:ecebed9b80b2 160 pKeyMap = DefaultKeyMap; // set default key map
WiredHome 98:ecebed9b80b2 161 _select(false); // deselect the display
WiredHome 98:ecebed9b80b2 162 frequency(RA8875_DEFAULT_SPI_FREQ); // data rate
WiredHome 79:544eb4964795 163 Reset();
WiredHome 134:f028ed71a0af 164 // Set PLL based on display size from buy-display.com sample code
WiredHome 134:f028ed71a0af 165 if (width == 800) {
WiredHome 134:f028ed71a0af 166 WriteCommand(0x88, 0x0C); // PLLC1 - Phase Lock Loop registers
WiredHome 134:f028ed71a0af 167 } else {
WiredHome 134:f028ed71a0af 168 WriteCommand(0x88, 0x0B); // PLLC1 - Phase Lock Loop registers
WiredHome 134:f028ed71a0af 169 }
WiredHome 79:544eb4964795 170 wait_ms(1);
WiredHome 79:544eb4964795 171 WriteCommand(0x89, 0x02);
WiredHome 79:544eb4964795 172 wait_ms(1);
WiredHome 79:544eb4964795 173
WiredHome 79:544eb4964795 174 // System Config Register (SYSR)
WiredHome 105:4f116006ba1f 175 screenbpp = color_bpp;
WiredHome 79:544eb4964795 176 if (color_bpp == 16) {
WiredHome 79:544eb4964795 177 WriteCommand(0x10, 0x0C); // 16-bpp (65K colors) color depth, 8-bit interface
WiredHome 79:544eb4964795 178 } else { // color_bpp == 8
WiredHome 79:544eb4964795 179 WriteCommand(0x10, 0x00); // 8-bpp (256 colors)
WiredHome 79:544eb4964795 180 }
WiredHome 134:f028ed71a0af 181
WiredHome 134:f028ed71a0af 182 // Set Pixel Clock Setting Register (PCSR) based on display size from buy-display.com sample code
WiredHome 134:f028ed71a0af 183 if (width == 800) {
WiredHome 134:f028ed71a0af 184 WriteCommand(0x04, 0x81); // PDAT on PCLK falling edge, PCLK = 4 x System Clock
WiredHome 134:f028ed71a0af 185 wait_ms(1);
WiredHome 134:f028ed71a0af 186
WiredHome 134:f028ed71a0af 187 // Horizontal Settings
WiredHome 134:f028ed71a0af 188 screenwidth = width;
WiredHome 134:f028ed71a0af 189 WriteCommand(0x14, width/8 - 1); //HDWR//Horizontal Display Width Setting Bit[6:0]
WiredHome 134:f028ed71a0af 190 WriteCommand(0x15, 0x00); //HNDFCR//Horizontal Non-Display Period fine tune Bit[3:0]
WiredHome 134:f028ed71a0af 191 WriteCommand(0x16, 0x03); //HNDR//Horizontal Non-Display Period Bit[4:0]
WiredHome 134:f028ed71a0af 192 WriteCommand(0x17, 0x03); //HSTR//HSYNC Start Position[4:0]
WiredHome 134:f028ed71a0af 193 WriteCommand(0x18, 0x0B); //HPWR//HSYNC Polarity ,The period width of HSYNC.
WiredHome 134:f028ed71a0af 194
WiredHome 134:f028ed71a0af 195 // Vertical Settings
WiredHome 134:f028ed71a0af 196 screenheight = height;
WiredHome 134:f028ed71a0af 197 WriteCommand(0x19, (height-1)&0xFF); //VDHR0 //Vertical Display Height Bit [7:0]
WiredHome 134:f028ed71a0af 198 WriteCommand(0x1a, (height-1)>>8); //VDHR1 //Vertical Display Height Bit [8]
WiredHome 134:f028ed71a0af 199 WriteCommand(0x1b, 0x20); //VNDR0 //Vertical Non-Display Period Bit [7:0]
WiredHome 134:f028ed71a0af 200 WriteCommand(0x1c, 0x00); //VNDR1 //Vertical Non-Display Period Bit [8]
WiredHome 134:f028ed71a0af 201 WriteCommand(0x1d, 0x16); //VSTR0 //VSYNC Start Position[7:0]
WiredHome 134:f028ed71a0af 202 WriteCommand(0x1e, 0x00); //VSTR1 //VSYNC Start Position[8]
WiredHome 134:f028ed71a0af 203 WriteCommand(0x1f, 0x01); //VPWR //VSYNC Polarity ,VSYNC Pulse Width[6:0]
WiredHome 134:f028ed71a0af 204 } else {
WiredHome 134:f028ed71a0af 205 WriteCommand(0x04, 0x82); // PDAT on PCLK falling edge, PCLK = 4 x System Clock
WiredHome 134:f028ed71a0af 206 wait_ms(1);
WiredHome 134:f028ed71a0af 207
WiredHome 134:f028ed71a0af 208 // Horizontal Settings
WiredHome 134:f028ed71a0af 209 screenwidth = width;
WiredHome 134:f028ed71a0af 210 WriteCommand(0x14, width/8 - 1); //HDWR//Horizontal Display Width Setting Bit[6:0]
WiredHome 134:f028ed71a0af 211 WriteCommand(0x15, 0x02); //HNDFCR//Horizontal Non-Display Period fine tune Bit[3:0]
WiredHome 134:f028ed71a0af 212 WriteCommand(0x16, 0x03); //HNDR//Horizontal Non-Display Period Bit[4:0]
WiredHome 134:f028ed71a0af 213 WriteCommand(0x17, 0x01); //HSTR//HSYNC Start Position[4:0]
WiredHome 134:f028ed71a0af 214 WriteCommand(0x18, 0x03); //HPWR//HSYNC Polarity ,The period width of HSYNC.
WiredHome 134:f028ed71a0af 215
WiredHome 134:f028ed71a0af 216 // Vertical Settings
WiredHome 134:f028ed71a0af 217 screenheight = height;
WiredHome 134:f028ed71a0af 218 WriteCommand(0x19, (height-1)&0xFF); //VDHR0 //Vertical Display Height Bit [7:0]
WiredHome 134:f028ed71a0af 219 WriteCommand(0x1a, (height-1)>>8); //VDHR1 //Vertical Display Height Bit [8]
WiredHome 134:f028ed71a0af 220 WriteCommand(0x1b, 0x0F); //VNDR0 //Vertical Non-Display Period Bit [7:0]
WiredHome 134:f028ed71a0af 221 WriteCommand(0x1c, 0x00); //VNDR1 //Vertical Non-Display Period Bit [8]
WiredHome 134:f028ed71a0af 222 WriteCommand(0x1d, 0x0e); //VSTR0 //VSYNC Start Position[7:0]
WiredHome 134:f028ed71a0af 223 WriteCommand(0x1e, 0x06); //VSTR1 //VSYNC Start Position[8]
WiredHome 134:f028ed71a0af 224 WriteCommand(0x1f, 0x01); //VPWR //VSYNC Polarity ,VSYNC Pulse Width[6:0]
WiredHome 134:f028ed71a0af 225 }
WiredHome 79:544eb4964795 226
WiredHome 100:0b084475d5a9 227 portraitmode = false;
WiredHome 133:e36dcfc2d756 228
WiredHome 79:544eb4964795 229 if (width >= 800 && height >= 480 && color_bpp > 8) {
WiredHome 79:544eb4964795 230 WriteCommand(0x20, 0x00); // DPCR - 1-layer mode when the resolution is too high
WiredHome 79:544eb4964795 231 } else {
WiredHome 79:544eb4964795 232 WriteCommand(0x20, 0x80); // DPCR - 2-layer mode
WiredHome 79:544eb4964795 233 }
WiredHome 79:544eb4964795 234
WiredHome 79:544eb4964795 235 // Set display image to Blue on Black as default
WiredHome 79:544eb4964795 236 window(0,0, width, height); // Initialize to full screen
WiredHome 79:544eb4964795 237 SetTextCursorControl();
WiredHome 79:544eb4964795 238 foreground(Blue);
WiredHome 79:544eb4964795 239 background(Black);
WiredHome 79:544eb4964795 240 cls(3);
WiredHome 79:544eb4964795 241
WiredHome 79:544eb4964795 242 Power(poweron);
WiredHome 131:5bd6ba2ee4a1 243 Backlight_u8(poweron);
WiredHome 81:01da2e34283d 244 if (keypadon)
WiredHome 81:01da2e34283d 245 KeypadInit();
WiredHome 124:1690a7ae871c 246 if (touchscreenon) {
WiredHome 124:1690a7ae871c 247 if (useTouchPanel == TP_NONE)
WiredHome 124:1690a7ae871c 248 useTouchPanel = TP_RES;
WiredHome 81:01da2e34283d 249 TouchPanelInit();
WiredHome 124:1690a7ae871c 250 }
WiredHome 79:544eb4964795 251 #ifdef PERF_METRICS
WiredHome 79:544eb4964795 252 performance.start();
WiredHome 79:544eb4964795 253 ClearPerformance();
WiredHome 79:544eb4964795 254 #endif
WiredHome 79:544eb4964795 255 return noerror;
WiredHome 79:544eb4964795 256 }
WiredHome 79:544eb4964795 257
WiredHome 79:544eb4964795 258
WiredHome 79:544eb4964795 259 RetCode_t RA8875::Reset(void)
WiredHome 79:544eb4964795 260 {
WiredHome 79:544eb4964795 261 RetCode_t ret;
WiredHome 79:544eb4964795 262
WiredHome 94:203729061e48 263 #if 0
WiredHome 94:203729061e48 264 if (res != (PinName)NC) {
WiredHome 94:203729061e48 265 res = 0; // Active low - assert reset
WiredHome 94:203729061e48 266 wait_ms(2); // must be > 1024 clock periods. (@25 MHz, this is 40.96 usec)
WiredHome 94:203729061e48 267 res = 1; // de-assert reset
WiredHome 94:203729061e48 268 }
WiredHome 94:203729061e48 269 #endif
WiredHome 94:203729061e48 270 ret = WriteCommand(0x01, 0x01); // Apply Display Off, Reset
WiredHome 94:203729061e48 271 wait_ms(2); // no idea if I need to wait, or how long
WiredHome 79:544eb4964795 272 if (ret == noerror) {
WiredHome 94:203729061e48 273 ret = WriteCommand(0x01, 0x00); // Display off, Remove reset
WiredHome 94:203729061e48 274 wait_ms(2); // no idea if I need to wait, or how long
WiredHome 79:544eb4964795 275 }
WiredHome 79:544eb4964795 276 return ret;
WiredHome 79:544eb4964795 277 }
WiredHome 79:544eb4964795 278
WiredHome 79:544eb4964795 279
WiredHome 79:544eb4964795 280 const char * RA8875::GetErrorMessage(RetCode_t code)
WiredHome 79:544eb4964795 281 {
WiredHome 79:544eb4964795 282 if (code >= LastErrCode)
WiredHome 79:544eb4964795 283 code = bad_parameter;
WiredHome 79:544eb4964795 284 return ErrMessages[code];
WiredHome 79:544eb4964795 285 }
WiredHome 79:544eb4964795 286
WiredHome 79:544eb4964795 287
WiredHome 61:8f3153bf0baa 288 uint16_t RA8875::GetDrawingLayer(void)
WiredHome 61:8f3153bf0baa 289 {
WiredHome 61:8f3153bf0baa 290 return (ReadCommand(0x41) & 0x01);
WiredHome 61:8f3153bf0baa 291 }
WiredHome 43:3becae133285 292
WiredHome 79:544eb4964795 293
WiredHome 143:e872d65a710d 294 RetCode_t RA8875::SelectDrawingLayer(uint16_t layer, uint16_t * prevLayer)
WiredHome 43:3becae133285 295 {
WiredHome 142:6e9bff59878a 296 unsigned char mwcr1 = ReadCommand(0x41); // retain all but the currently selected layer
WiredHome 143:e872d65a710d 297
WiredHome 143:e872d65a710d 298 if (prevLayer)
WiredHome 143:e872d65a710d 299 *prevLayer = mwcr1 & 1;
WiredHome 142:6e9bff59878a 300
WiredHome 142:6e9bff59878a 301 mwcr1 &= ~0x01; // remove the current layer
WiredHome 106:c80828f5dea4 302 if (screenwidth >= 800 && screenheight >= 480 && screenbpp > 8) {
WiredHome 142:6e9bff59878a 303 layer = 0;
WiredHome 43:3becae133285 304 } else if (layer > 1) {
WiredHome 142:6e9bff59878a 305 layer = 0;
WiredHome 43:3becae133285 306 }
WiredHome 143:e872d65a710d 307 return WriteCommand(0x41, mwcr1 | layer);
WiredHome 43:3becae133285 308 }
WiredHome 43:3becae133285 309
WiredHome 44:207594dece70 310
WiredHome 82:f7d300f26540 311 RA8875::LayerMode_T RA8875::GetLayerMode(void)
WiredHome 82:f7d300f26540 312 {
WiredHome 82:f7d300f26540 313 return (LayerMode_T)(ReadCommand(0x52) & 0x7);
WiredHome 82:f7d300f26540 314 }
WiredHome 82:f7d300f26540 315
WiredHome 82:f7d300f26540 316
WiredHome 53:86d24b9480b9 317 RetCode_t RA8875::SetLayerMode(LayerMode_T mode)
WiredHome 44:207594dece70 318 {
WiredHome 53:86d24b9480b9 319 unsigned char ltpr0 = ReadCommand(0x52) & ~0x7; // retain all but the display layer mode
WiredHome 105:4f116006ba1f 320
WiredHome 53:86d24b9480b9 321 if (mode <= (LayerMode_T)6) {
WiredHome 53:86d24b9480b9 322 WriteCommand(0x52, ltpr0 | (mode & 0x7));
WiredHome 53:86d24b9480b9 323 return noerror;
WiredHome 53:86d24b9480b9 324 } else {
WiredHome 53:86d24b9480b9 325 return bad_parameter;
WiredHome 53:86d24b9480b9 326 }
WiredHome 44:207594dece70 327 }
WiredHome 44:207594dece70 328
WiredHome 44:207594dece70 329
WiredHome 44:207594dece70 330 RetCode_t RA8875::SetLayerTransparency(uint8_t layer1, uint8_t layer2)
WiredHome 44:207594dece70 331 {
WiredHome 44:207594dece70 332 if (layer1 > 8)
WiredHome 44:207594dece70 333 layer1 = 8;
WiredHome 44:207594dece70 334 if (layer2 > 8)
WiredHome 44:207594dece70 335 layer2 = 8;
WiredHome 44:207594dece70 336 WriteCommand(0x53, ((layer2 & 0xF) << 4) | (layer1 & 0xF));
WiredHome 44:207594dece70 337 return noerror;
WiredHome 44:207594dece70 338 }
WiredHome 44:207594dece70 339
WiredHome 44:207594dece70 340
WiredHome 53:86d24b9480b9 341 RetCode_t RA8875::SetBackgroundTransparencyColor(color_t color)
WiredHome 53:86d24b9480b9 342 {
WiredHome 133:e36dcfc2d756 343 return _writeColorTrio(0x67, color);
WiredHome 53:86d24b9480b9 344 }
WiredHome 53:86d24b9480b9 345
WiredHome 79:544eb4964795 346
WiredHome 73:f22a18707b5e 347 color_t RA8875::GetBackgroundTransparencyColor(void)
WiredHome 73:f22a18707b5e 348 {
WiredHome 73:f22a18707b5e 349 RGBQUAD q;
WiredHome 105:4f116006ba1f 350
WiredHome 73:f22a18707b5e 351 q.rgbRed = ReadCommand(0x67);
WiredHome 73:f22a18707b5e 352 q.rgbGreen = ReadCommand(0x68);
WiredHome 73:f22a18707b5e 353 q.rgbBlue = ReadCommand(0x69);
WiredHome 73:f22a18707b5e 354 return RGBQuadToRGB16(&q, 0);
WiredHome 73:f22a18707b5e 355 }
WiredHome 73:f22a18707b5e 356
WiredHome 71:dcac8efd842d 357
WiredHome 77:9206c13aa527 358 RetCode_t RA8875::KeypadInit(bool scanEnable, bool longDetect, uint8_t sampleTime, uint8_t scanFrequency,
WiredHome 77:9206c13aa527 359 uint8_t longTimeAdjustment, bool interruptEnable, bool wakeupEnable)
WiredHome 71:dcac8efd842d 360 {
WiredHome 71:dcac8efd842d 361 uint8_t value = 0;
WiredHome 77:9206c13aa527 362
WiredHome 71:dcac8efd842d 363 if (sampleTime > 3 || scanFrequency > 7 || longTimeAdjustment > 3)
WiredHome 71:dcac8efd842d 364 return bad_parameter;
WiredHome 71:dcac8efd842d 365 value |= (scanEnable) ? 0x80 : 0x00;
WiredHome 71:dcac8efd842d 366 value |= (longDetect) ? 0x40 : 0x00;
WiredHome 71:dcac8efd842d 367 value |= (sampleTime & 0x03) << 4;
WiredHome 71:dcac8efd842d 368 value |= (scanFrequency & 0x07);
WiredHome 75:ca78388cfd77 369 WriteCommand(0xC0, value); // KSCR1 - Enable Key Scan (and ignore possibility of an error)
WiredHome 77:9206c13aa527 370
WiredHome 71:dcac8efd842d 371 value = 0;
WiredHome 71:dcac8efd842d 372 value |= (wakeupEnable) ? 0x80 : 0x00;
WiredHome 71:dcac8efd842d 373 value |= (longTimeAdjustment & 0x03) << 2;
WiredHome 75:ca78388cfd77 374 WriteCommand(0xC1, value); // KSCR2 - (and ignore possibility of an error)
WiredHome 77:9206c13aa527 375
WiredHome 75:ca78388cfd77 376 value = ReadCommand(0xF0); // (and ignore possibility of an error)
WiredHome 71:dcac8efd842d 377 value &= ~0x10;
WiredHome 71:dcac8efd842d 378 value |= (interruptEnable) ? 0x10 : 0x00;
WiredHome 75:ca78388cfd77 379 return WriteCommand(0xF0, value); // INT
WiredHome 71:dcac8efd842d 380 }
WiredHome 71:dcac8efd842d 381
WiredHome 79:544eb4964795 382
WiredHome 75:ca78388cfd77 383 RetCode_t RA8875::SetKeyMap(const uint8_t * CodeList)
WiredHome 75:ca78388cfd77 384 {
WiredHome 75:ca78388cfd77 385 pKeyMap = CodeList;
WiredHome 75:ca78388cfd77 386 return noerror;
WiredHome 75:ca78388cfd77 387 }
WiredHome 75:ca78388cfd77 388
WiredHome 79:544eb4964795 389
WiredHome 75:ca78388cfd77 390 bool RA8875::readable(void)
WiredHome 71:dcac8efd842d 391 {
WiredHome 71:dcac8efd842d 392 return (ReadCommand(0xF1) & 0x10); // check KS status - true if kbhit
WiredHome 71:dcac8efd842d 393 }
WiredHome 71:dcac8efd842d 394
WiredHome 79:544eb4964795 395
WiredHome 75:ca78388cfd77 396 uint8_t RA8875::getc(void)
WiredHome 71:dcac8efd842d 397 {
WiredHome 79:544eb4964795 398 //#define GETC_DEV // for development
WiredHome 77:9206c13aa527 399 #ifdef GETC_DEV
WiredHome 75:ca78388cfd77 400 uint8_t keyCode1, keyCode2;
WiredHome 77:9206c13aa527 401 #endif
WiredHome 75:ca78388cfd77 402 uint8_t keyCode3;
WiredHome 75:ca78388cfd77 403 static uint8_t count = 0;
WiredHome 75:ca78388cfd77 404 uint8_t col, row;
WiredHome 75:ca78388cfd77 405 uint8_t key;
WiredHome 123:2f45e80fec5f 406
WiredHome 75:ca78388cfd77 407 while (!readable()) {
WiredHome 71:dcac8efd842d 408 wait_us(POLLWAITuSec);
WiredHome 75:ca78388cfd77 409 // COUNTIDLETIME(POLLWAITuSec); // As it is voluntary to call the getc and pend. Don't tally it.
WiredHome 123:2f45e80fec5f 410 if (idle_callback) {
WiredHome 149:c62c4b2d6a15 411 if (external_abort == (*idle_callback)(getc_wait, 0)) {
WiredHome 123:2f45e80fec5f 412 return 0;
WiredHome 123:2f45e80fec5f 413 }
WiredHome 123:2f45e80fec5f 414 }
WiredHome 71:dcac8efd842d 415 }
WiredHome 71:dcac8efd842d 416 // read the key press number
WiredHome 71:dcac8efd842d 417 uint8_t keyNumReg = ReadCommand(0xC1) & 0x03;
WiredHome 75:ca78388cfd77 418 count++;
WiredHome 75:ca78388cfd77 419 switch (keyNumReg) {
WiredHome 75:ca78388cfd77 420 case 0x01: // one key
WiredHome 75:ca78388cfd77 421 keyCode3 = ReadCommand(0xC2);
WiredHome 77:9206c13aa527 422 #ifdef GETC_DEV
WiredHome 75:ca78388cfd77 423 keyCode2 = 0;
WiredHome 75:ca78388cfd77 424 keyCode1 = 0;
WiredHome 77:9206c13aa527 425 #endif
WiredHome 75:ca78388cfd77 426 break;
WiredHome 75:ca78388cfd77 427 case 0x02: // two keys
WiredHome 75:ca78388cfd77 428 keyCode3 = ReadCommand(0xC3);
WiredHome 77:9206c13aa527 429 #ifdef GETC_DEV
WiredHome 75:ca78388cfd77 430 keyCode2 = ReadCommand(0xC2);
WiredHome 75:ca78388cfd77 431 keyCode1 = 0;
WiredHome 77:9206c13aa527 432 #endif
WiredHome 75:ca78388cfd77 433 break;
WiredHome 75:ca78388cfd77 434 case 0x03: // three keys
WiredHome 75:ca78388cfd77 435 keyCode3 = ReadCommand(0xC4);
WiredHome 77:9206c13aa527 436 #ifdef GETC_DEV
WiredHome 75:ca78388cfd77 437 keyCode2 = ReadCommand(0xC3);
WiredHome 75:ca78388cfd77 438 keyCode1 = ReadCommand(0xC2);
WiredHome 77:9206c13aa527 439 #endif
WiredHome 75:ca78388cfd77 440 break;
WiredHome 75:ca78388cfd77 441 default: // no keys (key released)
WiredHome 75:ca78388cfd77 442 keyCode3 = 0xFF;
WiredHome 77:9206c13aa527 443 #ifdef GETC_DEV
WiredHome 75:ca78388cfd77 444 keyCode2 = 0;
WiredHome 75:ca78388cfd77 445 keyCode1 = 0;
WiredHome 77:9206c13aa527 446 #endif
WiredHome 75:ca78388cfd77 447 break;
WiredHome 75:ca78388cfd77 448 }
WiredHome 75:ca78388cfd77 449 if (keyCode3 == 0xFF)
WiredHome 75:ca78388cfd77 450 key = pKeyMap[0]; // Key value 0
WiredHome 75:ca78388cfd77 451 else {
WiredHome 75:ca78388cfd77 452 row = (keyCode3 >> 4) & 0x03;
WiredHome 75:ca78388cfd77 453 col = (keyCode3 & 7);
WiredHome 75:ca78388cfd77 454 key = row * 5 + col + 1; // Keys value 1 - 20
WiredHome 75:ca78388cfd77 455 if (key > 21) {
WiredHome 75:ca78388cfd77 456 key = 21;
WiredHome 75:ca78388cfd77 457 }
WiredHome 75:ca78388cfd77 458 key = pKeyMap[key];
WiredHome 75:ca78388cfd77 459 key |= (keyCode3 & 0x80); // combine the key held flag
WiredHome 75:ca78388cfd77 460 }
WiredHome 77:9206c13aa527 461 #if GETC_DEV // for Development only
WiredHome 75:ca78388cfd77 462 SetTextCursor(0, 20);
WiredHome 75:ca78388cfd77 463 printf(" Reg: %02x\r\n", keyNumReg);
WiredHome 75:ca78388cfd77 464 printf(" key1: %02x\r\n", keyCode1);
WiredHome 75:ca78388cfd77 465 printf(" key2: %02x\r\n", keyCode2);
WiredHome 75:ca78388cfd77 466 printf(" key3: %02x\r\n", keyCode3);
WiredHome 75:ca78388cfd77 467 printf(" count: %02X\r\n", count);
WiredHome 75:ca78388cfd77 468 printf(" key: %02X\r\n", key);
WiredHome 77:9206c13aa527 469 #endif
WiredHome 75:ca78388cfd77 470 WriteCommand(0xF1, 0x10); // Clear KS status
WiredHome 75:ca78388cfd77 471 return key;
WiredHome 71:dcac8efd842d 472 }
WiredHome 71:dcac8efd842d 473
WiredHome 79:544eb4964795 474
WiredHome 19:3f82c1161fd2 475 #ifdef PERF_METRICS
WiredHome 19:3f82c1161fd2 476 void RA8875::ClearPerformance()
WiredHome 19:3f82c1161fd2 477 {
WiredHome 100:0b084475d5a9 478 int i;
WiredHome 100:0b084475d5a9 479
WiredHome 100:0b084475d5a9 480 for (i=0; i<METRICCOUNT; i++)
WiredHome 19:3f82c1161fd2 481 metrics[i] = 0;
WiredHome 75:ca78388cfd77 482 idletime_usec = 0;
WiredHome 100:0b084475d5a9 483 for (i=0; i<256; i++)
WiredHome 100:0b084475d5a9 484 commandsUsed[i] = 0;
WiredHome 19:3f82c1161fd2 485 }
WiredHome 19:3f82c1161fd2 486
WiredHome 79:544eb4964795 487
WiredHome 19:3f82c1161fd2 488 void RA8875::RegisterPerformance(method_e method)
WiredHome 19:3f82c1161fd2 489 {
WiredHome 19:3f82c1161fd2 490 unsigned long elapsed = performance.read_us();
WiredHome 73:f22a18707b5e 491
WiredHome 19:3f82c1161fd2 492 if (method < METRICCOUNT && elapsed > metrics[method])
WiredHome 19:3f82c1161fd2 493 metrics[method] = elapsed;
WiredHome 19:3f82c1161fd2 494 }
WiredHome 19:3f82c1161fd2 495
WiredHome 79:544eb4964795 496
WiredHome 66:468a11f05580 497 void RA8875::CountIdleTime(uint32_t t)
WiredHome 66:468a11f05580 498 {
WiredHome 75:ca78388cfd77 499 idletime_usec += t;
WiredHome 66:468a11f05580 500 }
WiredHome 44:207594dece70 501
WiredHome 79:544eb4964795 502
WiredHome 41:2956a0a221e5 503 void RA8875::ReportPerformance(Serial & pc)
WiredHome 19:3f82c1161fd2 504 {
WiredHome 100:0b084475d5a9 505 int i;
WiredHome 100:0b084475d5a9 506
WiredHome 41:2956a0a221e5 507 pc.printf("\r\nPerformance Metrics\r\n");
WiredHome 100:0b084475d5a9 508 for (i=0; i<METRICCOUNT; i++) {
WiredHome 41:2956a0a221e5 509 pc.printf("%10d uS %s\r\n", metrics[i], metricsName[i]);
WiredHome 66:468a11f05580 510 }
WiredHome 75:ca78388cfd77 511 pc.printf("%10d uS Idle time polling display for ready.\r\n", idletime_usec);
WiredHome 91:ca5f829e6d27 512 for (i=0; i<256; i++) {
WiredHome 91:ca5f829e6d27 513 if (commandsUsed[i])
WiredHome 100:0b084475d5a9 514 pc.printf("Command %02X used %5d times.\r\n", i, commandsUsed[i]);
WiredHome 91:ca5f829e6d27 515 }
WiredHome 19:3f82c1161fd2 516 }
WiredHome 19:3f82c1161fd2 517 #endif
WiredHome 19:3f82c1161fd2 518
WiredHome 44:207594dece70 519
WiredHome 82:f7d300f26540 520 bool RA8875::Intersect(rect_t rect, point_t p)
WiredHome 82:f7d300f26540 521 {
WiredHome 82:f7d300f26540 522 if (p.x >= min(rect.p1.x, rect.p2.x) && p.x <= max(rect.p1.x, rect.p2.x)
WiredHome 82:f7d300f26540 523 && p.y >= min(rect.p1.y, rect.p2.y) && p.y <= max(rect.p1.y, rect.p2.y))
WiredHome 82:f7d300f26540 524 return true;
WiredHome 82:f7d300f26540 525 else
WiredHome 82:f7d300f26540 526 return false;
WiredHome 82:f7d300f26540 527 }
WiredHome 82:f7d300f26540 528
WiredHome 82:f7d300f26540 529
WiredHome 131:5bd6ba2ee4a1 530 bool RA8875::Intersect(rect_t rect1, rect_t rect2)
WiredHome 131:5bd6ba2ee4a1 531 {
WiredHome 147:3494792458d9 532 #if 1
WiredHome 147:3494792458d9 533 // If one rectangle is on left side of other
WiredHome 147:3494792458d9 534 if (max(rect1.p1.x,rect1.p2.x) < min(rect2.p1.x,rect2.p2.x)
WiredHome 147:3494792458d9 535 || min(rect1.p1.x, rect1.p2.x) > max(rect2.p1.x, rect2.p2.x))
WiredHome 147:3494792458d9 536 return false;
WiredHome 147:3494792458d9 537 // If one rectangle is above other
WiredHome 147:3494792458d9 538 if (max(rect1.p1.y, rect1.p2.y) < min(rect2.p1.y, rect2.p2.y)
WiredHome 147:3494792458d9 539 || min(rect1.p1.y, rect1.p2.y) > max(rect2.p1.y, rect2.p2.y))
WiredHome 147:3494792458d9 540 return false;
WiredHome 147:3494792458d9 541 return true; // all that's left is they overlap
WiredHome 147:3494792458d9 542 #else
WiredHome 131:5bd6ba2ee4a1 543 point_t bl, tr;
WiredHome 131:5bd6ba2ee4a1 544 bl.x = rect2.p1.x;
WiredHome 131:5bd6ba2ee4a1 545 bl.y = rect2.p2.y;
WiredHome 131:5bd6ba2ee4a1 546 tr.x = rect2.p2.x;
WiredHome 131:5bd6ba2ee4a1 547 tr.y = rect2.p1.y;
WiredHome 131:5bd6ba2ee4a1 548 if (Intersect(rect1, rect2.p1) || Intersect(rect1, rect2.p2)
WiredHome 147:3494792458d9 549 || Intersect(rect1, bl) || Intersect(rect1, tr))
WiredHome 131:5bd6ba2ee4a1 550 return true;
WiredHome 131:5bd6ba2ee4a1 551 else
WiredHome 131:5bd6ba2ee4a1 552 return false;
WiredHome 147:3494792458d9 553 #endif
WiredHome 131:5bd6ba2ee4a1 554 }
WiredHome 131:5bd6ba2ee4a1 555
WiredHome 131:5bd6ba2ee4a1 556
WiredHome 147:3494792458d9 557 bool RA8875::Intersect(rect_t * pRect1, const rect_t * pRect2)
WiredHome 147:3494792458d9 558 {
WiredHome 147:3494792458d9 559 if (Intersect(*pRect1, *pRect2)) {
WiredHome 147:3494792458d9 560 rect_t iSect;
WiredHome 147:3494792458d9 561
WiredHome 148:33e99de1aca6 562 iSect.p1.x = max(min(pRect1->p1.x,pRect1->p2.x),min(pRect2->p1.x,pRect2->p2.x));
WiredHome 148:33e99de1aca6 563 iSect.p1.y = max(min(pRect1->p1.y,pRect1->p2.y),min(pRect2->p1.y,pRect2->p2.y));
WiredHome 148:33e99de1aca6 564 iSect.p2.x = min(max(pRect1->p1.x,pRect1->p2.x),max(pRect2->p1.x,pRect2->p2.x));
WiredHome 148:33e99de1aca6 565 iSect.p2.y = min(max(pRect1->p1.y,pRect1->p2.y),max(pRect2->p1.y,pRect2->p2.y));
WiredHome 147:3494792458d9 566 *pRect1 = iSect;
WiredHome 147:3494792458d9 567 return true;
WiredHome 147:3494792458d9 568 } else {
WiredHome 147:3494792458d9 569 return false;
WiredHome 147:3494792458d9 570 }
WiredHome 147:3494792458d9 571 }
WiredHome 147:3494792458d9 572
WiredHome 82:f7d300f26540 573
WiredHome 38:38d503b4fad6 574 RetCode_t RA8875::WriteCommandW(uint8_t command, uint16_t data)
WiredHome 38:38d503b4fad6 575 {
WiredHome 38:38d503b4fad6 576 WriteCommand(command, data & 0xFF);
WiredHome 38:38d503b4fad6 577 WriteCommand(command+1, data >> 8);
WiredHome 38:38d503b4fad6 578 return noerror;
WiredHome 38:38d503b4fad6 579 }
WiredHome 38:38d503b4fad6 580
WiredHome 44:207594dece70 581
WiredHome 19:3f82c1161fd2 582 RetCode_t RA8875::WriteCommand(unsigned char command, unsigned int data)
WiredHome 19:3f82c1161fd2 583 {
WiredHome 91:ca5f829e6d27 584 #ifdef PERF_METRICS
WiredHome 92:ce1ab76e8614 585 if (commandsUsed[command] < 65535)
WiredHome 91:ca5f829e6d27 586 commandsUsed[command]++;
WiredHome 91:ca5f829e6d27 587 #endif
WiredHome 79:544eb4964795 588 _select(true);
WiredHome 83:7bad0068cca0 589 _spiwrite(0x80); // RS:1 (Cmd/Status), RW:0 (Write)
WiredHome 79:544eb4964795 590 _spiwrite(command);
WiredHome 19:3f82c1161fd2 591 if (data <= 0xFF) { // only if in the valid range
WiredHome 79:544eb4964795 592 _spiwrite(0x00);
WiredHome 79:544eb4964795 593 _spiwrite(data);
WiredHome 19:3f82c1161fd2 594 }
WiredHome 79:544eb4964795 595 _select(false);
WiredHome 19:3f82c1161fd2 596 return noerror;
WiredHome 19:3f82c1161fd2 597 }
WiredHome 19:3f82c1161fd2 598
WiredHome 44:207594dece70 599
WiredHome 38:38d503b4fad6 600 RetCode_t RA8875::WriteDataW(uint16_t data)
WiredHome 38:38d503b4fad6 601 {
WiredHome 79:544eb4964795 602 _select(true);
WiredHome 83:7bad0068cca0 603 _spiwrite(0x00); // RS:0 (Data), RW:0 (Write)
WiredHome 79:544eb4964795 604 _spiwrite(data & 0xFF);
WiredHome 79:544eb4964795 605 _spiwrite(data >> 8);
WiredHome 79:544eb4964795 606 _select(false);
WiredHome 38:38d503b4fad6 607 return noerror;
WiredHome 38:38d503b4fad6 608 }
WiredHome 38:38d503b4fad6 609
WiredHome 44:207594dece70 610
WiredHome 19:3f82c1161fd2 611 RetCode_t RA8875::WriteData(unsigned char data)
WiredHome 19:3f82c1161fd2 612 {
WiredHome 79:544eb4964795 613 _select(true);
WiredHome 83:7bad0068cca0 614 _spiwrite(0x00); // RS:0 (Data), RW:0 (Write)
WiredHome 79:544eb4964795 615 _spiwrite(data);
WiredHome 79:544eb4964795 616 _select(false);
WiredHome 19:3f82c1161fd2 617 return noerror;
WiredHome 19:3f82c1161fd2 618 }
WiredHome 19:3f82c1161fd2 619
WiredHome 44:207594dece70 620
WiredHome 19:3f82c1161fd2 621 unsigned char RA8875::ReadCommand(unsigned char command)
WiredHome 19:3f82c1161fd2 622 {
WiredHome 19:3f82c1161fd2 623 WriteCommand(command);
WiredHome 19:3f82c1161fd2 624 return ReadData();
WiredHome 19:3f82c1161fd2 625 }
WiredHome 19:3f82c1161fd2 626
WiredHome 136:224e03d5c31f 627 uint16_t RA8875::ReadCommandW(unsigned char command)
WiredHome 136:224e03d5c31f 628 {
WiredHome 136:224e03d5c31f 629 WriteCommand(command);
WiredHome 136:224e03d5c31f 630 return ReadDataW();
WiredHome 136:224e03d5c31f 631 }
WiredHome 44:207594dece70 632
WiredHome 19:3f82c1161fd2 633 unsigned char RA8875::ReadData(void)
WiredHome 19:3f82c1161fd2 634 {
WiredHome 19:3f82c1161fd2 635 unsigned char data;
WiredHome 73:f22a18707b5e 636
WiredHome 79:544eb4964795 637 _select(true);
WiredHome 83:7bad0068cca0 638 _spiwrite(0x40); // RS:0 (Data), RW:1 (Read)
WiredHome 79:544eb4964795 639 data = _spiread();
WiredHome 79:544eb4964795 640 _select(false);
WiredHome 19:3f82c1161fd2 641 return data;
WiredHome 19:3f82c1161fd2 642 }
WiredHome 19:3f82c1161fd2 643
WiredHome 44:207594dece70 644
WiredHome 41:2956a0a221e5 645 uint16_t RA8875::ReadDataW(void)
WiredHome 41:2956a0a221e5 646 {
WiredHome 41:2956a0a221e5 647 uint16_t data;
WiredHome 73:f22a18707b5e 648
WiredHome 79:544eb4964795 649 _select(true);
WiredHome 83:7bad0068cca0 650 _spiwrite(0x40); // RS:0 (Data), RW:1 (Read)
WiredHome 79:544eb4964795 651 data = _spiread();
WiredHome 79:544eb4964795 652 data |= (_spiread() << 8);
WiredHome 79:544eb4964795 653 _select(false);
WiredHome 41:2956a0a221e5 654 return data;
WiredHome 41:2956a0a221e5 655 }
WiredHome 41:2956a0a221e5 656
WiredHome 44:207594dece70 657
WiredHome 19:3f82c1161fd2 658 unsigned char RA8875::ReadStatus(void)
WiredHome 19:3f82c1161fd2 659 {
WiredHome 19:3f82c1161fd2 660 unsigned char data;
WiredHome 73:f22a18707b5e 661
WiredHome 79:544eb4964795 662 _select(true);
WiredHome 83:7bad0068cca0 663 _spiwrite(0xC0); // RS:1 (Cmd/Status), RW:1 (Read) (Read STSR)
WiredHome 79:544eb4964795 664 data = _spiread();
WiredHome 79:544eb4964795 665 _select(false);
WiredHome 19:3f82c1161fd2 666 return data;
WiredHome 19:3f82c1161fd2 667 }
WiredHome 19:3f82c1161fd2 668
WiredHome 79:544eb4964795 669
WiredHome 66:468a11f05580 670 /// @todo add a timeout and return false, but how long
WiredHome 66:468a11f05580 671 /// to wait since some operations can be very long.
WiredHome 66:468a11f05580 672 bool RA8875::_WaitWhileBusy(uint8_t mask)
WiredHome 66:468a11f05580 673 {
WiredHome 66:468a11f05580 674 int i = 20000/POLLWAITuSec; // 20 msec max
WiredHome 66:468a11f05580 675
WiredHome 67:9f834f0ff97d 676 while (i-- && ReadStatus() & mask) {
WiredHome 66:468a11f05580 677 wait_us(POLLWAITuSec);
WiredHome 68:ab08efabfc88 678 COUNTIDLETIME(POLLWAITuSec);
WiredHome 123:2f45e80fec5f 679 if (idle_callback) {
WiredHome 149:c62c4b2d6a15 680 if (external_abort == (*idle_callback)(status_wait, 0)) {
WiredHome 123:2f45e80fec5f 681 return false;
WiredHome 123:2f45e80fec5f 682 }
WiredHome 123:2f45e80fec5f 683 }
WiredHome 67:9f834f0ff97d 684 }
WiredHome 66:468a11f05580 685 if (i)
WiredHome 66:468a11f05580 686 return true;
WiredHome 66:468a11f05580 687 else
WiredHome 66:468a11f05580 688 return false;
WiredHome 66:468a11f05580 689 }
WiredHome 66:468a11f05580 690
WiredHome 79:544eb4964795 691
WiredHome 66:468a11f05580 692 /// @todo add a timeout and return false, but how long
WiredHome 66:468a11f05580 693 /// to wait since some operations can be very long.
WiredHome 66:468a11f05580 694 bool RA8875::_WaitWhileReg(uint8_t reg, uint8_t mask)
WiredHome 66:468a11f05580 695 {
WiredHome 66:468a11f05580 696 int i = 20000/POLLWAITuSec; // 20 msec max
WiredHome 66:468a11f05580 697
WiredHome 67:9f834f0ff97d 698 while (i-- && ReadCommand(reg) & mask) {
WiredHome 66:468a11f05580 699 wait_us(POLLWAITuSec);
WiredHome 68:ab08efabfc88 700 COUNTIDLETIME(POLLWAITuSec);
WiredHome 123:2f45e80fec5f 701 if (idle_callback) {
WiredHome 149:c62c4b2d6a15 702 if (external_abort == (*idle_callback)(command_wait, 0)) {
WiredHome 123:2f45e80fec5f 703 return false;
WiredHome 123:2f45e80fec5f 704 }
WiredHome 123:2f45e80fec5f 705 }
WiredHome 67:9f834f0ff97d 706 }
WiredHome 66:468a11f05580 707 if (i)
WiredHome 66:468a11f05580 708 return true;
WiredHome 66:468a11f05580 709 else
WiredHome 66:468a11f05580 710 return false;
WiredHome 66:468a11f05580 711 }
WiredHome 66:468a11f05580 712
WiredHome 106:c80828f5dea4 713 // RRRR RGGG GGGB BBBB
WiredHome 106:c80828f5dea4 714 // 4321 0543 2104 3210
WiredHome 106:c80828f5dea4 715 // RRRG GGBB
WiredHome 106:c80828f5dea4 716 // 2102 1010
WiredHome 105:4f116006ba1f 717 uint8_t RA8875::_cvt16to8(color_t c16)
WiredHome 105:4f116006ba1f 718 {
WiredHome 105:4f116006ba1f 719 return ((c16 >> 8) & 0xE0)
WiredHome 105:4f116006ba1f 720 | ((c16 >> 6) & 0x1C)
WiredHome 105:4f116006ba1f 721 | ((c16 >> 3) & 0x03);
WiredHome 105:4f116006ba1f 722 }
WiredHome 105:4f116006ba1f 723
WiredHome 106:c80828f5dea4 724 // RRRG GGBB
WiredHome 106:c80828f5dea4 725 // 2102 1010
WiredHome 106:c80828f5dea4 726 // RRRR RGGG GGGB BBBB
WiredHome 106:c80828f5dea4 727 // 2101 0543 2104 3210
WiredHome 105:4f116006ba1f 728 color_t RA8875::_cvt8to16(uint8_t c8)
WiredHome 105:4f116006ba1f 729 {
WiredHome 106:c80828f5dea4 730 color_t c16;
WiredHome 106:c80828f5dea4 731 color_t temp = (color_t)c8;
WiredHome 106:c80828f5dea4 732
WiredHome 106:c80828f5dea4 733 c16 = ((temp & 0xE0) << 8)
WiredHome 106:c80828f5dea4 734 | ((temp & 0xC0) << 5)
WiredHome 106:c80828f5dea4 735 | ((temp & 0x1C) << 6)
WiredHome 106:c80828f5dea4 736 | ((temp & 0x1C) << 3)
WiredHome 106:c80828f5dea4 737 | ((temp & 0x03) << 3)
WiredHome 106:c80828f5dea4 738 | ((temp & 0x03) << 1)
WiredHome 106:c80828f5dea4 739 | ((temp & 0x03) >> 1);
WiredHome 106:c80828f5dea4 740 c16 = (c16 << 8) | (c16 >> 8);
WiredHome 105:4f116006ba1f 741 return c16;
WiredHome 105:4f116006ba1f 742 }
WiredHome 66:468a11f05580 743
WiredHome 133:e36dcfc2d756 744 RetCode_t RA8875::_writeColorTrio(uint8_t regAddr, color_t color)
WiredHome 133:e36dcfc2d756 745 {
WiredHome 133:e36dcfc2d756 746 RetCode_t rt = noerror;
WiredHome 133:e36dcfc2d756 747
WiredHome 133:e36dcfc2d756 748 if (screenbpp == 16) {
WiredHome 133:e36dcfc2d756 749 WriteCommand(regAddr+0, (color>>11)); // BGCR0
WiredHome 133:e36dcfc2d756 750 WriteCommand(regAddr+1, (unsigned char)(color>>5)); // BGCR1
WiredHome 133:e36dcfc2d756 751 rt = WriteCommand(regAddr+2, (unsigned char)(color)); // BGCR2
WiredHome 133:e36dcfc2d756 752 } else {
WiredHome 133:e36dcfc2d756 753 uint8_t r, g, b;
WiredHome 133:e36dcfc2d756 754
WiredHome 133:e36dcfc2d756 755 // RRRR RGGG GGGB BBBB RGB
WiredHome 133:e36dcfc2d756 756 // RRR GGG B B
WiredHome 133:e36dcfc2d756 757 r = (uint8_t)((color) >> 13);
WiredHome 133:e36dcfc2d756 758 g = (uint8_t)((color) >> 8);
WiredHome 133:e36dcfc2d756 759 b = (uint8_t)((color) >> 3);
WiredHome 133:e36dcfc2d756 760 WriteCommand(regAddr+0, r); // BGCR0
WiredHome 133:e36dcfc2d756 761 WriteCommand(regAddr+1, g); // BGCR1
WiredHome 133:e36dcfc2d756 762 rt = WriteCommand(regAddr+2, b); // BGCR2
WiredHome 133:e36dcfc2d756 763 }
WiredHome 133:e36dcfc2d756 764 return rt;
WiredHome 133:e36dcfc2d756 765 }
WiredHome 133:e36dcfc2d756 766
WiredHome 133:e36dcfc2d756 767 color_t RA8875::_readColorTrio(uint8_t regAddr)
WiredHome 133:e36dcfc2d756 768 {
WiredHome 133:e36dcfc2d756 769 color_t color;
WiredHome 133:e36dcfc2d756 770 uint8_t r, g, b;
WiredHome 133:e36dcfc2d756 771
WiredHome 133:e36dcfc2d756 772 r = ReadCommand(regAddr+0);
WiredHome 133:e36dcfc2d756 773 g = ReadCommand(regAddr+1);
WiredHome 133:e36dcfc2d756 774 b = ReadCommand(regAddr+2);
WiredHome 133:e36dcfc2d756 775 if (screenbpp == 16) {
WiredHome 133:e36dcfc2d756 776 // 000R RRRR 00GG GGGG 000B BBBB
WiredHome 133:e36dcfc2d756 777 // RRRR RGGG GGGB BBBB
WiredHome 133:e36dcfc2d756 778 color = (r & 0x1F) << 11;
WiredHome 133:e36dcfc2d756 779 color |= (g & 0x3F) << 5;
WiredHome 133:e36dcfc2d756 780 color |= (b & 0x1F);
WiredHome 133:e36dcfc2d756 781 } else {
WiredHome 133:e36dcfc2d756 782 // RRRG GGBB
WiredHome 133:e36dcfc2d756 783 // RRRR RGGG GGGB BBBB
WiredHome 133:e36dcfc2d756 784 color = (r & 0x07) << 13;
WiredHome 133:e36dcfc2d756 785 color |= (g & 0x07) << 8;
WiredHome 133:e36dcfc2d756 786 color |= (b & 0x03) << 3;
WiredHome 133:e36dcfc2d756 787 }
WiredHome 133:e36dcfc2d756 788 return color;
WiredHome 133:e36dcfc2d756 789 }
WiredHome 133:e36dcfc2d756 790
WiredHome 133:e36dcfc2d756 791
WiredHome 37:f19b7e7449dc 792 dim_t RA8875::fontwidth(void)
WiredHome 19:3f82c1161fd2 793 {
WiredHome 19:3f82c1161fd2 794 if (font == NULL)
WiredHome 55:dfbabef7003e 795 return (((ReadCommand(0x22) >> 2) & 0x3) + 1) * 8;
WiredHome 19:3f82c1161fd2 796 else
WiredHome 98:ecebed9b80b2 797 return extFontWidth;
WiredHome 19:3f82c1161fd2 798 }
WiredHome 19:3f82c1161fd2 799
WiredHome 44:207594dece70 800
WiredHome 37:f19b7e7449dc 801 dim_t RA8875::fontheight(void)
WiredHome 19:3f82c1161fd2 802 {
WiredHome 19:3f82c1161fd2 803 if (font == NULL)
WiredHome 23:a50ded45dbaf 804 return (((ReadCommand(0x22) >> 0) & 0x3) + 1) * 16;
WiredHome 19:3f82c1161fd2 805 else
WiredHome 98:ecebed9b80b2 806 return extFontHeight;
WiredHome 19:3f82c1161fd2 807 }
WiredHome 19:3f82c1161fd2 808
WiredHome 44:207594dece70 809
WiredHome 37:f19b7e7449dc 810 RetCode_t RA8875::locate(textloc_t column, textloc_t row)
WiredHome 19:3f82c1161fd2 811 {
WiredHome 32:0e4f2ae512e2 812 return SetTextCursor(column * fontwidth(), row * fontheight());
WiredHome 19:3f82c1161fd2 813 }
WiredHome 19:3f82c1161fd2 814
WiredHome 44:207594dece70 815
WiredHome 19:3f82c1161fd2 816 int RA8875::columns(void)
WiredHome 19:3f82c1161fd2 817 {
WiredHome 105:4f116006ba1f 818 return screenwidth / fontwidth();
WiredHome 19:3f82c1161fd2 819 }
WiredHome 19:3f82c1161fd2 820
WiredHome 44:207594dece70 821
WiredHome 19:3f82c1161fd2 822 int RA8875::rows(void)
WiredHome 19:3f82c1161fd2 823 {
WiredHome 105:4f116006ba1f 824 return screenheight / fontheight();
WiredHome 19:3f82c1161fd2 825 }
WiredHome 19:3f82c1161fd2 826
WiredHome 44:207594dece70 827
WiredHome 38:38d503b4fad6 828 dim_t RA8875::width(void)
WiredHome 19:3f82c1161fd2 829 {
WiredHome 90:d113d71ae4f0 830 if (portraitmode)
WiredHome 90:d113d71ae4f0 831 return screenheight;
WiredHome 90:d113d71ae4f0 832 else
WiredHome 90:d113d71ae4f0 833 return screenwidth;
WiredHome 19:3f82c1161fd2 834 }
WiredHome 19:3f82c1161fd2 835
WiredHome 44:207594dece70 836
WiredHome 38:38d503b4fad6 837 dim_t RA8875::height(void)
WiredHome 19:3f82c1161fd2 838 {
WiredHome 90:d113d71ae4f0 839 if (portraitmode)
WiredHome 90:d113d71ae4f0 840 return screenwidth;
WiredHome 90:d113d71ae4f0 841 else
WiredHome 90:d113d71ae4f0 842 return screenheight;
WiredHome 19:3f82c1161fd2 843 }
WiredHome 19:3f82c1161fd2 844
WiredHome 44:207594dece70 845
WiredHome 43:3becae133285 846 dim_t RA8875::color_bpp(void)
WiredHome 43:3becae133285 847 {
WiredHome 105:4f116006ba1f 848 return screenbpp;
WiredHome 43:3becae133285 849 }
WiredHome 43:3becae133285 850
WiredHome 103:7e0464ca6c5c 851 RetCode_t RA8875::SetTextCursor(point_t p)
WiredHome 103:7e0464ca6c5c 852 {
WiredHome 103:7e0464ca6c5c 853 return SetTextCursor(p.x, p.y);
WiredHome 103:7e0464ca6c5c 854 }
WiredHome 44:207594dece70 855
WiredHome 37:f19b7e7449dc 856 RetCode_t RA8875::SetTextCursor(loc_t x, loc_t y)
WiredHome 19:3f82c1161fd2 857 {
WiredHome 98:ecebed9b80b2 858 INFO("SetTextCursor(%d, %d)", x, y);
WiredHome 75:ca78388cfd77 859 cursor_x = x; // set these values for non-internal fonts
WiredHome 75:ca78388cfd77 860 cursor_y = y;
WiredHome 38:38d503b4fad6 861 WriteCommandW(0x2A, x);
WiredHome 38:38d503b4fad6 862 WriteCommandW(0x2C, y);
WiredHome 19:3f82c1161fd2 863 return noerror;
WiredHome 19:3f82c1161fd2 864 }
WiredHome 19:3f82c1161fd2 865
WiredHome 103:7e0464ca6c5c 866 point_t RA8875::GetTextCursor(void)
WiredHome 103:7e0464ca6c5c 867 {
WiredHome 103:7e0464ca6c5c 868 point_t p;
WiredHome 103:7e0464ca6c5c 869
WiredHome 103:7e0464ca6c5c 870 p.x = GetTextCursor_X();
WiredHome 103:7e0464ca6c5c 871 p.y = GetTextCursor_Y();
WiredHome 103:7e0464ca6c5c 872 return p;
WiredHome 103:7e0464ca6c5c 873 }
WiredHome 44:207594dece70 874
WiredHome 37:f19b7e7449dc 875 loc_t RA8875::GetTextCursor_Y(void)
WiredHome 29:422616aa04bd 876 {
WiredHome 98:ecebed9b80b2 877 loc_t y;
WiredHome 98:ecebed9b80b2 878
WiredHome 29:422616aa04bd 879 if (font == NULL)
WiredHome 98:ecebed9b80b2 880 y = ReadCommand(0x2C) | (ReadCommand(0x2D) << 8);
WiredHome 29:422616aa04bd 881 else
WiredHome 98:ecebed9b80b2 882 y = cursor_y;
WiredHome 98:ecebed9b80b2 883 INFO("GetTextCursor_Y = %d", y);
WiredHome 98:ecebed9b80b2 884 return y;
WiredHome 29:422616aa04bd 885 }
WiredHome 29:422616aa04bd 886
WiredHome 44:207594dece70 887
WiredHome 37:f19b7e7449dc 888 loc_t RA8875::GetTextCursor_X(void)
WiredHome 29:422616aa04bd 889 {
WiredHome 98:ecebed9b80b2 890 loc_t x;
WiredHome 98:ecebed9b80b2 891
WiredHome 29:422616aa04bd 892 if (font == NULL)
WiredHome 98:ecebed9b80b2 893 x = ReadCommand(0x2A) | (ReadCommand(0x2B) << 8);
WiredHome 29:422616aa04bd 894 else
WiredHome 98:ecebed9b80b2 895 x = cursor_x;
WiredHome 98:ecebed9b80b2 896 INFO("GetTextCursor_X = %d", x);
WiredHome 98:ecebed9b80b2 897 return x;
WiredHome 29:422616aa04bd 898 }
WiredHome 29:422616aa04bd 899
WiredHome 44:207594dece70 900
WiredHome 24:8ca861acf12d 901 RetCode_t RA8875::SetTextCursorControl(cursor_t cursor, bool blink)
WiredHome 23:a50ded45dbaf 902 {
WiredHome 23:a50ded45dbaf 903 unsigned char mwcr0 = ReadCommand(0x40) & 0x0F; // retain direction, auto-increase
WiredHome 43:3becae133285 904 unsigned char mwcr1 = ReadCommand(0x41) & 0x01; // retain currently selected layer
WiredHome 24:8ca861acf12d 905 unsigned char horz = 0;
WiredHome 24:8ca861acf12d 906 unsigned char vert = 0;
WiredHome 73:f22a18707b5e 907
WiredHome 24:8ca861acf12d 908 mwcr0 |= 0x80; // text mode
WiredHome 24:8ca861acf12d 909 if (cursor != NOCURSOR)
WiredHome 24:8ca861acf12d 910 mwcr0 |= 0x40; // visible
WiredHome 23:a50ded45dbaf 911 if (blink)
WiredHome 24:8ca861acf12d 912 mwcr0 |= 0x20; // blink
WiredHome 23:a50ded45dbaf 913 WriteCommand(0x40, mwcr0); // configure the cursor
WiredHome 43:3becae133285 914 WriteCommand(0x41, mwcr1); // close the graphics cursor
WiredHome 24:8ca861acf12d 915 WriteCommand(0x44, 0x1f); // The cursor flashing cycle
WiredHome 24:8ca861acf12d 916 switch (cursor) {
WiredHome 24:8ca861acf12d 917 case IBEAM:
WiredHome 24:8ca861acf12d 918 horz = 0x01;
WiredHome 24:8ca861acf12d 919 vert = 0x1F;
WiredHome 24:8ca861acf12d 920 break;
WiredHome 24:8ca861acf12d 921 case UNDER:
WiredHome 24:8ca861acf12d 922 horz = 0x07;
WiredHome 24:8ca861acf12d 923 vert = 0x01;
WiredHome 24:8ca861acf12d 924 break;
WiredHome 24:8ca861acf12d 925 case BLOCK:
WiredHome 24:8ca861acf12d 926 horz = 0x07;
WiredHome 24:8ca861acf12d 927 vert = 0x1F;
WiredHome 24:8ca861acf12d 928 break;
WiredHome 24:8ca861acf12d 929 case NOCURSOR:
WiredHome 24:8ca861acf12d 930 default:
WiredHome 24:8ca861acf12d 931 break;
WiredHome 24:8ca861acf12d 932 }
WiredHome 24:8ca861acf12d 933 WriteCommand(0x4e, horz); // The cursor size horz
WiredHome 24:8ca861acf12d 934 WriteCommand(0x4f, vert); // The cursor size vert
WiredHome 23:a50ded45dbaf 935 return noerror;
WiredHome 23:a50ded45dbaf 936 }
WiredHome 23:a50ded45dbaf 937
WiredHome 44:207594dece70 938
WiredHome 19:3f82c1161fd2 939 RetCode_t RA8875::SetTextFont(RA8875::font_t font)
WiredHome 19:3f82c1161fd2 940 {
WiredHome 19:3f82c1161fd2 941 if (/*font >= RA8875::ISO8859_1 && */ font <= RA8875::ISO8859_4) {
WiredHome 19:3f82c1161fd2 942 WriteCommand(0x21, (unsigned int)(font));
WiredHome 19:3f82c1161fd2 943 return noerror;
WiredHome 19:3f82c1161fd2 944 } else {
WiredHome 19:3f82c1161fd2 945 return bad_parameter;
WiredHome 19:3f82c1161fd2 946 }
WiredHome 19:3f82c1161fd2 947 }
WiredHome 19:3f82c1161fd2 948
WiredHome 44:207594dece70 949
WiredHome 84:e102021864b5 950 RetCode_t RA8875::SetOrientation(RA8875::orientation_t angle)
WiredHome 84:e102021864b5 951 {
WiredHome 84:e102021864b5 952 uint8_t fncr1Val = ReadCommand(0x22);
WiredHome 84:e102021864b5 953 uint8_t dpcrVal = ReadCommand(0x20);
WiredHome 84:e102021864b5 954
WiredHome 84:e102021864b5 955 fncr1Val &= ~0x10; // remove the old direction bit
WiredHome 84:e102021864b5 956 dpcrVal &= ~0x0C; // remove the old scan direction bits
WiredHome 84:e102021864b5 957 switch (angle) {
WiredHome 84:e102021864b5 958 case RA8875::normal:
WiredHome 84:e102021864b5 959 //fncr1Val |= 0x10;
WiredHome 84:e102021864b5 960 //dpcrVal |= 0x00;
WiredHome 90:d113d71ae4f0 961 portraitmode = false;
WiredHome 84:e102021864b5 962 break;
WiredHome 84:e102021864b5 963 case RA8875::rotate_90:
WiredHome 84:e102021864b5 964 fncr1Val |= 0x10;
WiredHome 84:e102021864b5 965 dpcrVal |= 0x08;
WiredHome 90:d113d71ae4f0 966 portraitmode = true;
WiredHome 84:e102021864b5 967 break;
WiredHome 84:e102021864b5 968 case RA8875::rotate_180:
WiredHome 84:e102021864b5 969 //fncr1Val |= 0x00;
WiredHome 84:e102021864b5 970 dpcrVal |= 0x0C;
WiredHome 90:d113d71ae4f0 971 portraitmode = false;
WiredHome 84:e102021864b5 972 break;
WiredHome 84:e102021864b5 973 case RA8875::rotate_270:
WiredHome 84:e102021864b5 974 fncr1Val |= 0x10;
WiredHome 84:e102021864b5 975 dpcrVal |= 0x04;
WiredHome 90:d113d71ae4f0 976 portraitmode = true;
WiredHome 84:e102021864b5 977 break;
WiredHome 84:e102021864b5 978 default:
WiredHome 84:e102021864b5 979 return bad_parameter;
WiredHome 84:e102021864b5 980 }
WiredHome 100:0b084475d5a9 981 INFO("Orientation: %d, %d", angle, portraitmode);
WiredHome 84:e102021864b5 982 WriteCommand(0x22, fncr1Val);
WiredHome 84:e102021864b5 983 return WriteCommand(0x20, dpcrVal);
WiredHome 84:e102021864b5 984 }
WiredHome 84:e102021864b5 985
WiredHome 84:e102021864b5 986
WiredHome 19:3f82c1161fd2 987 RetCode_t RA8875::SetTextFontControl(fill_t fillit,
WiredHome 73:f22a18707b5e 988 RA8875::HorizontalScale hScale,
WiredHome 73:f22a18707b5e 989 RA8875::VerticalScale vScale,
WiredHome 73:f22a18707b5e 990 RA8875::alignment_t alignment)
WiredHome 19:3f82c1161fd2 991 {
WiredHome 73:f22a18707b5e 992 if (hScale >= 1 && hScale <= 4 &&
WiredHome 73:f22a18707b5e 993 vScale >= 1 && vScale <= 4) {
WiredHome 84:e102021864b5 994 uint8_t fncr1Val = ReadCommand(0x22);
WiredHome 84:e102021864b5 995
WiredHome 98:ecebed9b80b2 996 fncr1Val &= ~0x10; // do not disturb the rotate flag
WiredHome 19:3f82c1161fd2 997 if (alignment == align_full)
WiredHome 84:e102021864b5 998 fncr1Val |= 0x80;
WiredHome 19:3f82c1161fd2 999 if (fillit == NOFILL)
WiredHome 84:e102021864b5 1000 fncr1Val |= 0x40;
WiredHome 84:e102021864b5 1001 fncr1Val |= ((hScale - 1) << 2);
WiredHome 84:e102021864b5 1002 fncr1Val |= ((vScale - 1) << 0);
WiredHome 84:e102021864b5 1003 return WriteCommand(0x22, fncr1Val);
WiredHome 19:3f82c1161fd2 1004 } else {
WiredHome 19:3f82c1161fd2 1005 return bad_parameter;
WiredHome 19:3f82c1161fd2 1006 }
WiredHome 19:3f82c1161fd2 1007 }
WiredHome 19:3f82c1161fd2 1008
WiredHome 44:207594dece70 1009
WiredHome 19:3f82c1161fd2 1010 RetCode_t RA8875::SetTextFontSize(RA8875::HorizontalScale hScale, RA8875::VerticalScale vScale)
WiredHome 19:3f82c1161fd2 1011 {
WiredHome 19:3f82c1161fd2 1012 unsigned char reg = ReadCommand(0x22);
WiredHome 73:f22a18707b5e 1013
WiredHome 40:04aa280dfa39 1014 if (vScale == -1)
WiredHome 40:04aa280dfa39 1015 vScale = hScale;
WiredHome 19:3f82c1161fd2 1016 if (hScale >= 1 && hScale <= 4 && vScale >= 1 && vScale <= 4) {
WiredHome 19:3f82c1161fd2 1017 reg &= 0xF0; // keep the high nibble as is.
WiredHome 19:3f82c1161fd2 1018 reg |= ((hScale - 1) << 2);
WiredHome 19:3f82c1161fd2 1019 reg |= ((vScale - 1) << 0);
WiredHome 19:3f82c1161fd2 1020 WriteCommand(0x22, reg);
WiredHome 19:3f82c1161fd2 1021 return noerror;
WiredHome 19:3f82c1161fd2 1022 } else {
WiredHome 19:3f82c1161fd2 1023 return bad_parameter;
WiredHome 19:3f82c1161fd2 1024 }
WiredHome 19:3f82c1161fd2 1025 }
WiredHome 19:3f82c1161fd2 1026
WiredHome 127:db7f2c704693 1027 RetCode_t RA8875::GetTextFontSize(RA8875::HorizontalScale * hScale, RA8875::VerticalScale * vScale)
WiredHome 127:db7f2c704693 1028 {
WiredHome 127:db7f2c704693 1029 unsigned char reg = ReadCommand(0x22);
WiredHome 127:db7f2c704693 1030
WiredHome 127:db7f2c704693 1031 if (hScale)
WiredHome 127:db7f2c704693 1032 *hScale = 1 + (reg >> 2) & 0x03;
WiredHome 127:db7f2c704693 1033 if (vScale)
WiredHome 127:db7f2c704693 1034 *vScale = 1 + reg & 0x03;
WiredHome 127:db7f2c704693 1035 return noerror;
WiredHome 127:db7f2c704693 1036 }
WiredHome 44:207594dece70 1037
WiredHome 19:3f82c1161fd2 1038 int RA8875::_putc(int c)
WiredHome 19:3f82c1161fd2 1039 {
WiredHome 29:422616aa04bd 1040 if (font == NULL) {
WiredHome 29:422616aa04bd 1041 return _internal_putc(c);
WiredHome 29:422616aa04bd 1042 } else {
WiredHome 29:422616aa04bd 1043 return _external_putc(c);
WiredHome 29:422616aa04bd 1044 }
WiredHome 29:422616aa04bd 1045 }
WiredHome 29:422616aa04bd 1046
WiredHome 44:207594dece70 1047
WiredHome 101:e0aad446094a 1048
WiredHome 101:e0aad446094a 1049 // Questions to ponder -
WiredHome 101:e0aad446094a 1050 // - if we choose to wrap to the next line, because the character won't fit on the current line,
WiredHome 101:e0aad446094a 1051 // should it erase the space to the width of the screen (in case there is leftover junk there)?
WiredHome 101:e0aad446094a 1052 // - it currently wraps from the bottom of the screen back to the top. I have pondered what
WiredHome 101:e0aad446094a 1053 // it might take to scroll the screen - but haven't thought hard enough about it.
WiredHome 101:e0aad446094a 1054 //
WiredHome 29:422616aa04bd 1055 int RA8875::_external_putc(int c)
WiredHome 29:422616aa04bd 1056 {
WiredHome 19:3f82c1161fd2 1057 if (c) {
WiredHome 19:3f82c1161fd2 1058 if (c == '\r') {
WiredHome 111:efe436c43aba 1059 cursor_x = windowrect.p1.x;
WiredHome 29:422616aa04bd 1060 } else if (c == '\n') {
WiredHome 98:ecebed9b80b2 1061 cursor_y += extFontHeight;
WiredHome 29:422616aa04bd 1062 } else {
WiredHome 109:7b94f06f085b 1063 dim_t charWidth, charHeight;
WiredHome 101:e0aad446094a 1064 const uint8_t * charRecord;
WiredHome 101:e0aad446094a 1065
WiredHome 101:e0aad446094a 1066 charRecord = getCharMetrics(c, &charWidth, &charHeight);
WiredHome 101:e0aad446094a 1067 //int advance = charwidth(c);
WiredHome 111:efe436c43aba 1068 INFO("(%d,%d) - (%d,%d):(%d,%d), charWidth: %d '%c", cursor_x, cursor_y,
WiredHome 111:efe436c43aba 1069 windowrect.p1.x, windowrect.p1.y, windowrect.p2.x, windowrect.p2.y,
WiredHome 111:efe436c43aba 1070 charWidth, c);
WiredHome 101:e0aad446094a 1071 if (charRecord) {
WiredHome 101:e0aad446094a 1072 //cursor_x += advance;
WiredHome 111:efe436c43aba 1073 if (cursor_x + charWidth >= windowrect.p2.x) {
WiredHome 111:efe436c43aba 1074 cursor_x = windowrect.p1.x;
WiredHome 101:e0aad446094a 1075 cursor_y += charHeight;
WiredHome 29:422616aa04bd 1076 }
WiredHome 111:efe436c43aba 1077 if (cursor_y + charHeight >= windowrect.p2.y) {
WiredHome 111:efe436c43aba 1078 cursor_y = windowrect.p1.y; // @todo Should it scroll?
WiredHome 101:e0aad446094a 1079 }
WiredHome 101:e0aad446094a 1080 (void)character(cursor_x, cursor_y, c);
WiredHome 101:e0aad446094a 1081 cursor_x += charWidth;
WiredHome 29:422616aa04bd 1082 }
WiredHome 29:422616aa04bd 1083 }
WiredHome 29:422616aa04bd 1084 }
WiredHome 29:422616aa04bd 1085 return c;
WiredHome 29:422616aa04bd 1086 }
WiredHome 29:422616aa04bd 1087
WiredHome 44:207594dece70 1088
WiredHome 29:422616aa04bd 1089 int RA8875::_internal_putc(int c)
WiredHome 29:422616aa04bd 1090 {
WiredHome 29:422616aa04bd 1091 if (c) {
WiredHome 29:422616aa04bd 1092 unsigned char mwcr0;
WiredHome 73:f22a18707b5e 1093
WiredHome 29:422616aa04bd 1094 mwcr0 = ReadCommand(0x40);
WiredHome 29:422616aa04bd 1095 if ((mwcr0 & 0x80) == 0x00) {
WiredHome 29:422616aa04bd 1096 WriteCommand(0x40, 0x80 | mwcr0); // Put in Text mode if not already
WiredHome 29:422616aa04bd 1097 }
WiredHome 29:422616aa04bd 1098 if (c == '\r') {
WiredHome 37:f19b7e7449dc 1099 loc_t x;
WiredHome 19:3f82c1161fd2 1100 x = ReadCommand(0x30) | (ReadCommand(0x31) << 8); // Left edge of active window
WiredHome 38:38d503b4fad6 1101 WriteCommandW(0x2A, x);
WiredHome 19:3f82c1161fd2 1102 } else if (c == '\n') {
WiredHome 37:f19b7e7449dc 1103 loc_t y;
WiredHome 19:3f82c1161fd2 1104 y = ReadCommand(0x2C) | (ReadCommand(0x2D) << 8); // current y location
WiredHome 19:3f82c1161fd2 1105 y += fontheight();
WiredHome 47:d96a09269f91 1106 if (y >= height()) // @TODO after bottom of active window, then scroll window?
WiredHome 19:3f82c1161fd2 1107 y = 0;
WiredHome 38:38d503b4fad6 1108 WriteCommandW(0x2C, y);
WiredHome 19:3f82c1161fd2 1109 } else {
WiredHome 29:422616aa04bd 1110 WriteCommand(0x02); // RA8875 Internal Fonts
WiredHome 79:544eb4964795 1111 _select(true);
WiredHome 29:422616aa04bd 1112 WriteData(c);
WiredHome 66:468a11f05580 1113 _WaitWhileBusy(0x80);
WiredHome 79:544eb4964795 1114 _select(false);
WiredHome 19:3f82c1161fd2 1115 }
WiredHome 19:3f82c1161fd2 1116 }
WiredHome 19:3f82c1161fd2 1117 return c;
WiredHome 19:3f82c1161fd2 1118 }
WiredHome 19:3f82c1161fd2 1119
WiredHome 44:207594dece70 1120
WiredHome 32:0e4f2ae512e2 1121 RetCode_t RA8875::_StartGraphicsStream(void)
WiredHome 32:0e4f2ae512e2 1122 {
WiredHome 32:0e4f2ae512e2 1123 WriteCommand(0x40,0x00); // Graphics write mode
WiredHome 32:0e4f2ae512e2 1124 WriteCommand(0x02); // Prepare for streaming data
WiredHome 32:0e4f2ae512e2 1125 return noerror;
WiredHome 32:0e4f2ae512e2 1126 }
WiredHome 32:0e4f2ae512e2 1127
WiredHome 44:207594dece70 1128
WiredHome 32:0e4f2ae512e2 1129 RetCode_t RA8875::_EndGraphicsStream(void)
WiredHome 32:0e4f2ae512e2 1130 {
WiredHome 32:0e4f2ae512e2 1131 return noerror;
WiredHome 32:0e4f2ae512e2 1132 }
WiredHome 32:0e4f2ae512e2 1133
WiredHome 44:207594dece70 1134
WiredHome 55:dfbabef7003e 1135 RetCode_t RA8875::_putp(color_t pixel)
WiredHome 32:0e4f2ae512e2 1136 {
WiredHome 38:38d503b4fad6 1137 WriteDataW((pixel>>8) | (pixel<<8));
WiredHome 73:f22a18707b5e 1138 return noerror;
WiredHome 32:0e4f2ae512e2 1139 }
WiredHome 29:422616aa04bd 1140
WiredHome 44:207594dece70 1141
WiredHome 37:f19b7e7449dc 1142 void RA8875::puts(loc_t x, loc_t y, const char * string)
WiredHome 19:3f82c1161fd2 1143 {
WiredHome 19:3f82c1161fd2 1144 SetTextCursor(x,y);
WiredHome 19:3f82c1161fd2 1145 puts(string);
WiredHome 19:3f82c1161fd2 1146 }
WiredHome 19:3f82c1161fd2 1147
WiredHome 44:207594dece70 1148
WiredHome 19:3f82c1161fd2 1149 void RA8875::puts(const char * string)
WiredHome 19:3f82c1161fd2 1150 {
WiredHome 37:f19b7e7449dc 1151 if (font == NULL) {
WiredHome 100:0b084475d5a9 1152 WriteCommand(0x40,0x80); // Put in Text mode if internal font
WiredHome 37:f19b7e7449dc 1153 }
WiredHome 19:3f82c1161fd2 1154 if (*string != '\0') {
WiredHome 29:422616aa04bd 1155 while (*string) { // @TODO calling individual _putc is slower... optimizations?
WiredHome 19:3f82c1161fd2 1156 _putc(*string++);
WiredHome 19:3f82c1161fd2 1157 }
WiredHome 19:3f82c1161fd2 1158 }
WiredHome 19:3f82c1161fd2 1159 }
WiredHome 19:3f82c1161fd2 1160
WiredHome 44:207594dece70 1161
WiredHome 37:f19b7e7449dc 1162 RetCode_t RA8875::SetGraphicsCursor(loc_t x, loc_t y)
WiredHome 19:3f82c1161fd2 1163 {
WiredHome 38:38d503b4fad6 1164 WriteCommandW(0x46, x);
WiredHome 38:38d503b4fad6 1165 WriteCommandW(0x48, y);
WiredHome 19:3f82c1161fd2 1166 return noerror;
WiredHome 19:3f82c1161fd2 1167 }
WiredHome 19:3f82c1161fd2 1168
WiredHome 136:224e03d5c31f 1169 RetCode_t RA8875::SetGraphicsCursor(point_t p)
WiredHome 136:224e03d5c31f 1170 {
WiredHome 136:224e03d5c31f 1171 return SetGraphicsCursor(p.x, p.y);
WiredHome 136:224e03d5c31f 1172 }
WiredHome 136:224e03d5c31f 1173
WiredHome 136:224e03d5c31f 1174 point_t RA8875::GetGraphicsCursor(void)
WiredHome 136:224e03d5c31f 1175 {
WiredHome 136:224e03d5c31f 1176 point_t p;
WiredHome 136:224e03d5c31f 1177
WiredHome 136:224e03d5c31f 1178 p.x = ReadCommandW(0x46);
WiredHome 136:224e03d5c31f 1179 p.y = ReadCommandW(0x48);
WiredHome 136:224e03d5c31f 1180 return p;
WiredHome 136:224e03d5c31f 1181 }
WiredHome 44:207594dece70 1182
WiredHome 41:2956a0a221e5 1183 RetCode_t RA8875::SetGraphicsCursorRead(loc_t x, loc_t y)
WiredHome 41:2956a0a221e5 1184 {
WiredHome 41:2956a0a221e5 1185 WriteCommandW(0x4A, x);
WiredHome 41:2956a0a221e5 1186 WriteCommandW(0x4C, y);
WiredHome 41:2956a0a221e5 1187 return noerror;
WiredHome 41:2956a0a221e5 1188 }
WiredHome 41:2956a0a221e5 1189
WiredHome 111:efe436c43aba 1190 RetCode_t RA8875::window(rect_t r)
WiredHome 111:efe436c43aba 1191 {
WiredHome 111:efe436c43aba 1192 return window(r.p1.x, r.p1.y, r.p2.x + 1 - r.p1.x, r.p2.y + 1 - r.p1.y);
WiredHome 111:efe436c43aba 1193 }
WiredHome 44:207594dece70 1194
WiredHome 37:f19b7e7449dc 1195 RetCode_t RA8875::window(loc_t x, loc_t y, dim_t width, dim_t height)
WiredHome 19:3f82c1161fd2 1196 {
WiredHome 111:efe436c43aba 1197 INFO("window(%d,%d,%d,%d)", x, y, width, height);
WiredHome 111:efe436c43aba 1198 if (width == (dim_t)-1)
WiredHome 111:efe436c43aba 1199 width = screenwidth - x;
WiredHome 111:efe436c43aba 1200 if (height == (dim_t)-1)
WiredHome 111:efe436c43aba 1201 height = screenheight - y;
WiredHome 111:efe436c43aba 1202 windowrect.p1.x = x;
WiredHome 111:efe436c43aba 1203 windowrect.p1.y = y;
WiredHome 111:efe436c43aba 1204 windowrect.p2.x = x + width - 1;
WiredHome 111:efe436c43aba 1205 windowrect.p2.y = y + height - 1;
WiredHome 37:f19b7e7449dc 1206 GraphicsDisplay::window(x,y, width,height);
WiredHome 38:38d503b4fad6 1207 WriteCommandW(0x30, x);
WiredHome 38:38d503b4fad6 1208 WriteCommandW(0x32, y);
WiredHome 38:38d503b4fad6 1209 WriteCommandW(0x34, (x+width-1));
WiredHome 38:38d503b4fad6 1210 WriteCommandW(0x36, (y+height-1));
WiredHome 111:efe436c43aba 1211 //SetTextCursor(x,y);
WiredHome 111:efe436c43aba 1212 //SetGraphicsCursor(x,y);
WiredHome 19:3f82c1161fd2 1213 return noerror;
WiredHome 19:3f82c1161fd2 1214 }
WiredHome 19:3f82c1161fd2 1215
WiredHome 44:207594dece70 1216
WiredHome 61:8f3153bf0baa 1217 RetCode_t RA8875::cls(uint16_t layers)
WiredHome 19:3f82c1161fd2 1218 {
WiredHome 61:8f3153bf0baa 1219 RetCode_t ret;
WiredHome 73:f22a18707b5e 1220
WiredHome 19:3f82c1161fd2 1221 PERFORMANCE_RESET;
WiredHome 61:8f3153bf0baa 1222 if (layers == 0) {
WiredHome 61:8f3153bf0baa 1223 ret = clsw(FULLWINDOW);
WiredHome 61:8f3153bf0baa 1224 } else if (layers > 3) {
WiredHome 61:8f3153bf0baa 1225 ret = bad_parameter;
WiredHome 61:8f3153bf0baa 1226 } else {
WiredHome 61:8f3153bf0baa 1227 uint16_t prevLayer = GetDrawingLayer();
WiredHome 61:8f3153bf0baa 1228 if (layers & 1) {
WiredHome 61:8f3153bf0baa 1229 SelectDrawingLayer(0);
WiredHome 61:8f3153bf0baa 1230 clsw(FULLWINDOW);
WiredHome 61:8f3153bf0baa 1231 }
WiredHome 61:8f3153bf0baa 1232 if (layers & 2) {
WiredHome 61:8f3153bf0baa 1233 SelectDrawingLayer(1);
WiredHome 61:8f3153bf0baa 1234 clsw(FULLWINDOW);
WiredHome 61:8f3153bf0baa 1235 }
WiredHome 142:6e9bff59878a 1236 SelectDrawingLayer(prevLayer);
WiredHome 61:8f3153bf0baa 1237 }
WiredHome 135:af519fe4ba91 1238 ret = SetTextCursor(0,0);
WiredHome 135:af519fe4ba91 1239 ret = locate(0,0);
WiredHome 19:3f82c1161fd2 1240 REGISTERPERFORMANCE(PRF_CLS);
WiredHome 61:8f3153bf0baa 1241 return ret;
WiredHome 19:3f82c1161fd2 1242 }
WiredHome 19:3f82c1161fd2 1243
WiredHome 44:207594dece70 1244
WiredHome 19:3f82c1161fd2 1245 RetCode_t RA8875::clsw(RA8875::Region_t region)
WiredHome 19:3f82c1161fd2 1246 {
WiredHome 19:3f82c1161fd2 1247 PERFORMANCE_RESET;
WiredHome 19:3f82c1161fd2 1248 WriteCommand(0x8E, (region == ACTIVEWINDOW) ? 0xC0 : 0x80);
WiredHome 131:5bd6ba2ee4a1 1249 if (!_WaitWhileReg(0x8E, 0x80)) {
WiredHome 131:5bd6ba2ee4a1 1250 REGISTERPERFORMANCE(PRF_CLS);
WiredHome 131:5bd6ba2ee4a1 1251 return external_abort;
WiredHome 131:5bd6ba2ee4a1 1252 }
WiredHome 19:3f82c1161fd2 1253 REGISTERPERFORMANCE(PRF_CLS);
WiredHome 19:3f82c1161fd2 1254 return noerror;
WiredHome 19:3f82c1161fd2 1255 }
WiredHome 19:3f82c1161fd2 1256
WiredHome 44:207594dece70 1257
WiredHome 87:ee2240581aa7 1258 RetCode_t RA8875::pixel(point_t p, color_t color)
WiredHome 87:ee2240581aa7 1259 {
WiredHome 87:ee2240581aa7 1260 return pixel(p.x, p.y, color);
WiredHome 87:ee2240581aa7 1261 }
WiredHome 87:ee2240581aa7 1262
WiredHome 87:ee2240581aa7 1263 RetCode_t RA8875::pixel(point_t p)
WiredHome 87:ee2240581aa7 1264 {
WiredHome 87:ee2240581aa7 1265 return pixel(p.x, p.y);
WiredHome 87:ee2240581aa7 1266 }
WiredHome 87:ee2240581aa7 1267
WiredHome 37:f19b7e7449dc 1268 RetCode_t RA8875::pixel(loc_t x, loc_t y, color_t color)
WiredHome 19:3f82c1161fd2 1269 {
WiredHome 62:ba5d33438fda 1270 RetCode_t ret;
WiredHome 73:f22a18707b5e 1271
WiredHome 62:ba5d33438fda 1272 PERFORMANCE_RESET;
WiredHome 62:ba5d33438fda 1273 ret = pixelStream(&color, 1, x,y);
WiredHome 62:ba5d33438fda 1274 REGISTERPERFORMANCE(PRF_DRAWPIXEL);
WiredHome 62:ba5d33438fda 1275 return ret;
WiredHome 19:3f82c1161fd2 1276 }
WiredHome 19:3f82c1161fd2 1277
WiredHome 44:207594dece70 1278
WiredHome 37:f19b7e7449dc 1279 RetCode_t RA8875::pixel(loc_t x, loc_t y)
WiredHome 19:3f82c1161fd2 1280 {
WiredHome 19:3f82c1161fd2 1281 RetCode_t ret;
WiredHome 73:f22a18707b5e 1282
WiredHome 19:3f82c1161fd2 1283 PERFORMANCE_RESET;
WiredHome 19:3f82c1161fd2 1284 color_t color = GetForeColor();
WiredHome 62:ba5d33438fda 1285 ret = pixelStream(&color, 1, x, y);
WiredHome 41:2956a0a221e5 1286 REGISTERPERFORMANCE(PRF_DRAWPIXEL);
WiredHome 19:3f82c1161fd2 1287 return ret;
WiredHome 19:3f82c1161fd2 1288 }
WiredHome 19:3f82c1161fd2 1289
WiredHome 44:207594dece70 1290
WiredHome 41:2956a0a221e5 1291 RetCode_t RA8875::pixelStream(color_t * p, uint32_t count, loc_t x, loc_t y)
WiredHome 41:2956a0a221e5 1292 {
WiredHome 41:2956a0a221e5 1293 PERFORMANCE_RESET;
WiredHome 41:2956a0a221e5 1294 SetGraphicsCursor(x, y);
WiredHome 109:7b94f06f085b 1295 _StartGraphicsStream();
WiredHome 79:544eb4964795 1296 _select(true);
WiredHome 79:544eb4964795 1297 _spiwrite(0x00); // Cmd: write data
WiredHome 41:2956a0a221e5 1298 while (count--) {
WiredHome 105:4f116006ba1f 1299 if (screenbpp == 16) {
WiredHome 105:4f116006ba1f 1300 _spiwrite(*p >> 8);
WiredHome 105:4f116006ba1f 1301 _spiwrite(*p & 0xFF);
WiredHome 105:4f116006ba1f 1302 } else {
WiredHome 105:4f116006ba1f 1303 _spiwrite(_cvt16to8(*p));
WiredHome 105:4f116006ba1f 1304 }
WiredHome 41:2956a0a221e5 1305 p++;
WiredHome 41:2956a0a221e5 1306 }
WiredHome 79:544eb4964795 1307 _select(false);
WiredHome 109:7b94f06f085b 1308 _EndGraphicsStream();
WiredHome 41:2956a0a221e5 1309 REGISTERPERFORMANCE(PRF_PIXELSTREAM);
WiredHome 41:2956a0a221e5 1310 return(noerror);
WiredHome 41:2956a0a221e5 1311 }
WiredHome 41:2956a0a221e5 1312
WiredHome 109:7b94f06f085b 1313 RetCode_t RA8875::booleanStream(loc_t x, loc_t y, dim_t w, dim_t h, const uint8_t * boolStream)
WiredHome 109:7b94f06f085b 1314 {
WiredHome 109:7b94f06f085b 1315 PERFORMANCE_RESET;
WiredHome 111:efe436c43aba 1316 rect_t restore = windowrect;
WiredHome 111:efe436c43aba 1317
WiredHome 109:7b94f06f085b 1318 window(x, y, w, h);
WiredHome 109:7b94f06f085b 1319 SetGraphicsCursor(x, y);
WiredHome 109:7b94f06f085b 1320 _StartGraphicsStream();
WiredHome 109:7b94f06f085b 1321 _select(true);
WiredHome 109:7b94f06f085b 1322 _spiwrite(0x00); // Cmd: write data
WiredHome 109:7b94f06f085b 1323 while (h--) {
WiredHome 109:7b94f06f085b 1324 uint8_t pixels = w;
WiredHome 109:7b94f06f085b 1325 uint8_t bitmask = 0x01;
WiredHome 109:7b94f06f085b 1326
WiredHome 109:7b94f06f085b 1327 while (pixels) {
WiredHome 109:7b94f06f085b 1328 uint8_t byte = *boolStream;
WiredHome 111:efe436c43aba 1329 //INFO("byte, mask: %02X, %02X", byte, bitmask);
WiredHome 109:7b94f06f085b 1330 color_t c = (byte & bitmask) ? _foreground : _background;
WiredHome 109:7b94f06f085b 1331 if (screenbpp == 16) {
WiredHome 109:7b94f06f085b 1332 _spiwrite(c >> 8);
WiredHome 109:7b94f06f085b 1333 _spiwrite(c & 0xFF);
WiredHome 109:7b94f06f085b 1334 } else {
WiredHome 109:7b94f06f085b 1335 _spiwrite(_cvt16to8(c));
WiredHome 109:7b94f06f085b 1336 }
WiredHome 109:7b94f06f085b 1337 bitmask <<= 1;
WiredHome 109:7b94f06f085b 1338 if (pixels > 1 && bitmask == 0) {
WiredHome 109:7b94f06f085b 1339 bitmask = 0x01;
WiredHome 109:7b94f06f085b 1340 boolStream++;
WiredHome 109:7b94f06f085b 1341 }
WiredHome 109:7b94f06f085b 1342 pixels--;
WiredHome 109:7b94f06f085b 1343 }
WiredHome 109:7b94f06f085b 1344 boolStream++;
WiredHome 109:7b94f06f085b 1345 }
WiredHome 109:7b94f06f085b 1346 _select(false);
WiredHome 109:7b94f06f085b 1347 _EndGraphicsStream();
WiredHome 111:efe436c43aba 1348 window(restore);
WiredHome 109:7b94f06f085b 1349 REGISTERPERFORMANCE(PRF_BOOLSTREAM);
WiredHome 109:7b94f06f085b 1350 return(noerror);
WiredHome 109:7b94f06f085b 1351 }
WiredHome 44:207594dece70 1352
WiredHome 41:2956a0a221e5 1353 color_t RA8875::getPixel(loc_t x, loc_t y)
WiredHome 41:2956a0a221e5 1354 {
WiredHome 41:2956a0a221e5 1355 color_t pixel;
WiredHome 73:f22a18707b5e 1356
WiredHome 41:2956a0a221e5 1357 PERFORMANCE_RESET;
WiredHome 41:2956a0a221e5 1358 WriteCommand(0x40,0x00); // Graphics write mode
WiredHome 41:2956a0a221e5 1359 SetGraphicsCursorRead(x, y);
WiredHome 41:2956a0a221e5 1360 WriteCommand(0x02);
WiredHome 79:544eb4964795 1361 _select(true);
WiredHome 79:544eb4964795 1362 _spiwrite(0x40); // Cmd: read data
WiredHome 79:544eb4964795 1363 _spiwrite(0x00); // dummy read
WiredHome 105:4f116006ba1f 1364 if (screenbpp == 16) {
WiredHome 105:4f116006ba1f 1365 pixel = _spiread();
WiredHome 105:4f116006ba1f 1366 pixel |= (_spiread() << 8);
WiredHome 105:4f116006ba1f 1367 } else {
WiredHome 105:4f116006ba1f 1368 pixel = _cvt8to16(_spiread());
WiredHome 105:4f116006ba1f 1369 }
WiredHome 79:544eb4964795 1370 _select(false);
WiredHome 41:2956a0a221e5 1371 REGISTERPERFORMANCE(PRF_READPIXEL);
WiredHome 41:2956a0a221e5 1372 return pixel;
WiredHome 41:2956a0a221e5 1373 }
WiredHome 41:2956a0a221e5 1374
WiredHome 44:207594dece70 1375
WiredHome 41:2956a0a221e5 1376 RetCode_t RA8875::getPixelStream(color_t * p, uint32_t count, loc_t x, loc_t y)
WiredHome 41:2956a0a221e5 1377 {
WiredHome 41:2956a0a221e5 1378 color_t pixel;
WiredHome 86:e86b355940f4 1379 RetCode_t ret = noerror;
WiredHome 73:f22a18707b5e 1380
WiredHome 41:2956a0a221e5 1381 PERFORMANCE_RESET;
WiredHome 86:e86b355940f4 1382 ret = WriteCommand(0x40,0x00); // Graphics write mode
WiredHome 86:e86b355940f4 1383 ret = SetGraphicsCursorRead(x, y);
WiredHome 86:e86b355940f4 1384 ret = WriteCommand(0x02);
WiredHome 79:544eb4964795 1385 _select(true);
WiredHome 79:544eb4964795 1386 _spiwrite(0x40); // Cmd: read data
WiredHome 79:544eb4964795 1387 _spiwrite(0x00); // dummy read
WiredHome 106:c80828f5dea4 1388 if (screenbpp == 16)
WiredHome 106:c80828f5dea4 1389 _spiwrite(0x00); // dummy read is only necessary when in 16-bit mode
WiredHome 41:2956a0a221e5 1390 while (count--) {
WiredHome 105:4f116006ba1f 1391 if (screenbpp == 16) {
WiredHome 105:4f116006ba1f 1392 pixel = _spiread();
WiredHome 105:4f116006ba1f 1393 pixel |= (_spiread() << 8);
WiredHome 105:4f116006ba1f 1394 } else {
WiredHome 105:4f116006ba1f 1395 pixel = _cvt8to16(_spiread());
WiredHome 105:4f116006ba1f 1396 }
WiredHome 41:2956a0a221e5 1397 *p++ = pixel;
WiredHome 41:2956a0a221e5 1398 }
WiredHome 79:544eb4964795 1399 _select(false);
WiredHome 41:2956a0a221e5 1400 REGISTERPERFORMANCE(PRF_READPIXELSTREAM);
WiredHome 86:e86b355940f4 1401 return ret;
WiredHome 41:2956a0a221e5 1402 }
WiredHome 41:2956a0a221e5 1403
WiredHome 44:207594dece70 1404
WiredHome 83:7bad0068cca0 1405 RetCode_t RA8875::line(point_t p1, point_t p2)
WiredHome 83:7bad0068cca0 1406 {
WiredHome 83:7bad0068cca0 1407 return line(p1.x, p1.y, p2.x, p2.y);
WiredHome 83:7bad0068cca0 1408 }
WiredHome 83:7bad0068cca0 1409
WiredHome 83:7bad0068cca0 1410
WiredHome 83:7bad0068cca0 1411 RetCode_t RA8875::line(point_t p1, point_t p2, color_t color)
WiredHome 83:7bad0068cca0 1412 {
WiredHome 83:7bad0068cca0 1413 return line(p1.x, p1.y, p2.x, p2.y, color);
WiredHome 83:7bad0068cca0 1414 }
WiredHome 83:7bad0068cca0 1415
WiredHome 83:7bad0068cca0 1416
WiredHome 37:f19b7e7449dc 1417 RetCode_t RA8875::line(loc_t x1, loc_t y1, loc_t x2, loc_t y2, color_t color)
WiredHome 19:3f82c1161fd2 1418 {
WiredHome 19:3f82c1161fd2 1419 foreground(color);
WiredHome 19:3f82c1161fd2 1420 return line(x1,y1,x2,y2);
WiredHome 19:3f82c1161fd2 1421 }
WiredHome 19:3f82c1161fd2 1422
WiredHome 44:207594dece70 1423
WiredHome 37:f19b7e7449dc 1424 RetCode_t RA8875::line(loc_t x1, loc_t y1, loc_t x2, loc_t y2)
WiredHome 19:3f82c1161fd2 1425 {
WiredHome 19:3f82c1161fd2 1426 PERFORMANCE_RESET;
WiredHome 62:ba5d33438fda 1427 if (x1 == x2 && y1 == y2) {
WiredHome 60:2dfd574f63bd 1428 pixel(x1, y1);
WiredHome 62:ba5d33438fda 1429 } else {
WiredHome 60:2dfd574f63bd 1430 WriteCommandW(0x91, x1);
WiredHome 60:2dfd574f63bd 1431 WriteCommandW(0x93, y1);
WiredHome 60:2dfd574f63bd 1432 WriteCommandW(0x95, x2);
WiredHome 60:2dfd574f63bd 1433 WriteCommandW(0x97, y2);
WiredHome 60:2dfd574f63bd 1434 unsigned char drawCmd = 0x00; // Line
WiredHome 60:2dfd574f63bd 1435 WriteCommand(0x90, drawCmd);
WiredHome 60:2dfd574f63bd 1436 WriteCommand(0x90, 0x80 + drawCmd); // Start drawing.
WiredHome 131:5bd6ba2ee4a1 1437 if (!_WaitWhileReg(0x90, 0x80)) {
WiredHome 131:5bd6ba2ee4a1 1438 REGISTERPERFORMANCE(PRF_DRAWLINE);
WiredHome 131:5bd6ba2ee4a1 1439 return external_abort;
WiredHome 131:5bd6ba2ee4a1 1440 }
WiredHome 60:2dfd574f63bd 1441 }
WiredHome 19:3f82c1161fd2 1442 REGISTERPERFORMANCE(PRF_DRAWLINE);
WiredHome 19:3f82c1161fd2 1443 return noerror;
WiredHome 19:3f82c1161fd2 1444 }
WiredHome 19:3f82c1161fd2 1445
WiredHome 144:ba002c4b21b3 1446
WiredHome 144:ba002c4b21b3 1447 RetCode_t RA8875::ThickLine(point_t p1, point_t p2, dim_t thickness, color_t color)
WiredHome 144:ba002c4b21b3 1448 {
WiredHome 144:ba002c4b21b3 1449 if (thickness == 1) {
WiredHome 144:ba002c4b21b3 1450 line(p1,p2, color);
WiredHome 144:ba002c4b21b3 1451 } else {
WiredHome 144:ba002c4b21b3 1452 int dx = abs(p2.x-p1.x), sx = p1.x<p2.x ? 1 : -1;
WiredHome 144:ba002c4b21b3 1453 int dy = abs(p2.y-p1.y), sy = p1.y<p2.y ? 1 : -1;
WiredHome 144:ba002c4b21b3 1454 int err = (dx>dy ? dx : -dy)/2, e2;
WiredHome 144:ba002c4b21b3 1455
WiredHome 144:ba002c4b21b3 1456 for (;;) {
WiredHome 144:ba002c4b21b3 1457 fillcircle(p1.x, p1.y, thickness/2, color);
WiredHome 144:ba002c4b21b3 1458 if (p1.x==p2.x && p1.y==p2.y)
WiredHome 144:ba002c4b21b3 1459 break;
WiredHome 144:ba002c4b21b3 1460 e2 = err;
WiredHome 144:ba002c4b21b3 1461 if (e2 >-dx)
WiredHome 144:ba002c4b21b3 1462 { err -= dy; p1.x += sx; }
WiredHome 144:ba002c4b21b3 1463 if (e2 < dy)
WiredHome 144:ba002c4b21b3 1464 { err += dx; p1.y += sy; }
WiredHome 144:ba002c4b21b3 1465 }
WiredHome 144:ba002c4b21b3 1466 }
WiredHome 144:ba002c4b21b3 1467 return noerror;
WiredHome 144:ba002c4b21b3 1468 }
WiredHome 144:ba002c4b21b3 1469
WiredHome 144:ba002c4b21b3 1470
WiredHome 107:f9ccffcb84f1 1471 //
WiredHome 107:f9ccffcb84f1 1472 // Rectangle functions all mostly helpers to the basic rectangle function
WiredHome 107:f9ccffcb84f1 1473 //
WiredHome 107:f9ccffcb84f1 1474
WiredHome 81:01da2e34283d 1475 RetCode_t RA8875::fillrect(rect_t r, color_t color, fill_t fillit)
WiredHome 81:01da2e34283d 1476 {
WiredHome 81:01da2e34283d 1477 return rect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, color, fillit);
WiredHome 81:01da2e34283d 1478 }
WiredHome 44:207594dece70 1479
WiredHome 73:f22a18707b5e 1480 RetCode_t RA8875::fillrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1481 color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1482 {
WiredHome 19:3f82c1161fd2 1483 return rect(x1,y1,x2,y2,color,fillit);
WiredHome 19:3f82c1161fd2 1484 }
WiredHome 19:3f82c1161fd2 1485
WiredHome 81:01da2e34283d 1486 RetCode_t RA8875::rect(rect_t r, color_t color, fill_t fillit)
WiredHome 81:01da2e34283d 1487 {
WiredHome 81:01da2e34283d 1488 return rect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, color, fillit);
WiredHome 81:01da2e34283d 1489 }
WiredHome 44:207594dece70 1490
WiredHome 73:f22a18707b5e 1491 RetCode_t RA8875::rect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1492 color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1493 {
WiredHome 19:3f82c1161fd2 1494 foreground(color);
WiredHome 19:3f82c1161fd2 1495 return rect(x1,y1,x2,y2,fillit);
WiredHome 19:3f82c1161fd2 1496 }
WiredHome 19:3f82c1161fd2 1497
WiredHome 73:f22a18707b5e 1498 RetCode_t RA8875::rect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1499 fill_t fillit)
WiredHome 19:3f82c1161fd2 1500 {
WiredHome 85:022bba13c5c4 1501 RetCode_t ret = noerror;
WiredHome 19:3f82c1161fd2 1502 PERFORMANCE_RESET;
WiredHome 85:022bba13c5c4 1503 // check for bad_parameter
WiredHome 105:4f116006ba1f 1504 if (x1 < 0 || x1 >= screenwidth || x2 < 0 || x2 >= screenwidth
WiredHome 105:4f116006ba1f 1505 || y1 < 0 || y1 >= screenheight || y2 < 0 || y2 >= screenheight) {
WiredHome 85:022bba13c5c4 1506 ret = bad_parameter;
WiredHome 100:0b084475d5a9 1507 } else {
WiredHome 85:022bba13c5c4 1508 if (x1 == x2 && y1 == y2) {
WiredHome 85:022bba13c5c4 1509 pixel(x1, y1);
WiredHome 85:022bba13c5c4 1510 } else if (x1 == x2) {
WiredHome 85:022bba13c5c4 1511 line(x1, y1, x2, y2);
WiredHome 85:022bba13c5c4 1512 } else if (y1 == y2) {
WiredHome 85:022bba13c5c4 1513 line(x1, y1, x2, y2);
WiredHome 85:022bba13c5c4 1514 } else {
WiredHome 85:022bba13c5c4 1515 WriteCommandW(0x91, x1);
WiredHome 85:022bba13c5c4 1516 WriteCommandW(0x93, y1);
WiredHome 85:022bba13c5c4 1517 WriteCommandW(0x95, x2);
WiredHome 85:022bba13c5c4 1518 WriteCommandW(0x97, y2);
WiredHome 85:022bba13c5c4 1519 unsigned char drawCmd = 0x10; // Rectangle
WiredHome 85:022bba13c5c4 1520 if (fillit == FILL)
WiredHome 85:022bba13c5c4 1521 drawCmd |= 0x20;
WiredHome 85:022bba13c5c4 1522 WriteCommand(0x90, drawCmd);
WiredHome 85:022bba13c5c4 1523 ret = WriteCommand(0x90, 0x80 + drawCmd); // Start drawing.
WiredHome 131:5bd6ba2ee4a1 1524 if (!_WaitWhileReg(0x90, 0x80)) {
WiredHome 131:5bd6ba2ee4a1 1525 REGISTERPERFORMANCE(PRF_DRAWRECTANGLE);
WiredHome 131:5bd6ba2ee4a1 1526 return external_abort;
WiredHome 131:5bd6ba2ee4a1 1527 }
WiredHome 85:022bba13c5c4 1528 }
WiredHome 19:3f82c1161fd2 1529 }
WiredHome 19:3f82c1161fd2 1530 REGISTERPERFORMANCE(PRF_DRAWRECTANGLE);
WiredHome 85:022bba13c5c4 1531 return ret;
WiredHome 19:3f82c1161fd2 1532 }
WiredHome 19:3f82c1161fd2 1533
WiredHome 44:207594dece70 1534
WiredHome 107:f9ccffcb84f1 1535 //
WiredHome 107:f9ccffcb84f1 1536 // rounded rectangle functions are mostly helpers to the base round rect
WiredHome 107:f9ccffcb84f1 1537 //
WiredHome 107:f9ccffcb84f1 1538
WiredHome 107:f9ccffcb84f1 1539 RetCode_t RA8875::fillroundrect(rect_t r, dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome 107:f9ccffcb84f1 1540 {
WiredHome 107:f9ccffcb84f1 1541 return roundrect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, radius1, radius2, color, fillit);
WiredHome 107:f9ccffcb84f1 1542 }
WiredHome 107:f9ccffcb84f1 1543
WiredHome 73:f22a18707b5e 1544 RetCode_t RA8875::fillroundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1545 dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1546 {
WiredHome 19:3f82c1161fd2 1547 foreground(color);
WiredHome 19:3f82c1161fd2 1548 return roundrect(x1,y1,x2,y2,radius1,radius2,fillit);
WiredHome 19:3f82c1161fd2 1549 }
WiredHome 19:3f82c1161fd2 1550
WiredHome 107:f9ccffcb84f1 1551 RetCode_t RA8875::roundrect(rect_t r, dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome 107:f9ccffcb84f1 1552 {
WiredHome 107:f9ccffcb84f1 1553 return roundrect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, radius1, radius2, color, fillit);
WiredHome 107:f9ccffcb84f1 1554 }
WiredHome 44:207594dece70 1555
WiredHome 73:f22a18707b5e 1556 RetCode_t RA8875::roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1557 dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1558 {
WiredHome 19:3f82c1161fd2 1559 foreground(color);
WiredHome 19:3f82c1161fd2 1560 return roundrect(x1,y1,x2,y2,radius1,radius2,fillit);
WiredHome 19:3f82c1161fd2 1561 }
WiredHome 19:3f82c1161fd2 1562
WiredHome 44:207594dece70 1563
WiredHome 73:f22a18707b5e 1564 RetCode_t RA8875::roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1565 dim_t radius1, dim_t radius2, fill_t fillit)
WiredHome 19:3f82c1161fd2 1566 {
WiredHome 19:3f82c1161fd2 1567 RetCode_t ret = noerror;
WiredHome 73:f22a18707b5e 1568
WiredHome 19:3f82c1161fd2 1569 PERFORMANCE_RESET;
WiredHome 105:4f116006ba1f 1570 if (x1 < 0 || x1 >= screenwidth || x2 < 0 || x2 >= screenwidth
WiredHome 105:4f116006ba1f 1571 || y1 < 0 || y1 >= screenheight || y2 < 0 || y2 >= screenheight) {
WiredHome 85:022bba13c5c4 1572 ret = bad_parameter;
WiredHome 85:022bba13c5c4 1573 } else if (x1 > x2 || y1 > y2 || (radius1 > (x2-x1)/2) || (radius2 > (y2-y1)/2) ) {
WiredHome 21:3c1efb192927 1574 ret = bad_parameter;
WiredHome 21:3c1efb192927 1575 } else if (x1 == x2 && y1 == y2) {
WiredHome 19:3f82c1161fd2 1576 pixel(x1, y1);
WiredHome 19:3f82c1161fd2 1577 } else if (x1 == x2) {
WiredHome 19:3f82c1161fd2 1578 line(x1, y1, x2, y2);
WiredHome 19:3f82c1161fd2 1579 } else if (y1 == y2) {
WiredHome 19:3f82c1161fd2 1580 line(x1, y1, x2, y2);
WiredHome 19:3f82c1161fd2 1581 } else {
WiredHome 38:38d503b4fad6 1582 WriteCommandW(0x91, x1);
WiredHome 38:38d503b4fad6 1583 WriteCommandW(0x93, y1);
WiredHome 38:38d503b4fad6 1584 WriteCommandW(0x95, x2);
WiredHome 38:38d503b4fad6 1585 WriteCommandW(0x97, y2);
WiredHome 38:38d503b4fad6 1586 WriteCommandW(0xA1, radius1);
WiredHome 38:38d503b4fad6 1587 WriteCommandW(0xA3, radius2);
WiredHome 21:3c1efb192927 1588 // Should not need this...
WiredHome 38:38d503b4fad6 1589 WriteCommandW(0xA5, 0);
WiredHome 38:38d503b4fad6 1590 WriteCommandW(0xA7, 0);
WiredHome 19:3f82c1161fd2 1591 unsigned char drawCmd = 0x20; // Rounded Rectangle
WiredHome 19:3f82c1161fd2 1592 if (fillit == FILL)
WiredHome 19:3f82c1161fd2 1593 drawCmd |= 0x40;
WiredHome 19:3f82c1161fd2 1594 WriteCommand(0xA0, drawCmd);
WiredHome 19:3f82c1161fd2 1595 WriteCommand(0xA0, 0x80 + drawCmd); // Start drawing.
WiredHome 131:5bd6ba2ee4a1 1596 if (!_WaitWhileReg(0xA0, 0x80)) {
WiredHome 131:5bd6ba2ee4a1 1597 REGISTERPERFORMANCE(PRF_DRAWROUNDEDRECTANGLE);
WiredHome 131:5bd6ba2ee4a1 1598 return external_abort;
WiredHome 131:5bd6ba2ee4a1 1599 }
WiredHome 19:3f82c1161fd2 1600 }
WiredHome 19:3f82c1161fd2 1601 REGISTERPERFORMANCE(PRF_DRAWROUNDEDRECTANGLE);
WiredHome 19:3f82c1161fd2 1602 return ret;
WiredHome 19:3f82c1161fd2 1603 }
WiredHome 19:3f82c1161fd2 1604
WiredHome 44:207594dece70 1605
WiredHome 107:f9ccffcb84f1 1606 //
WiredHome 107:f9ccffcb84f1 1607 // triangle functions
WiredHome 107:f9ccffcb84f1 1608 //
WiredHome 107:f9ccffcb84f1 1609
WiredHome 73:f22a18707b5e 1610 RetCode_t RA8875::triangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1611 loc_t x3, loc_t y3, color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1612 {
WiredHome 20:6e2e4a8372eb 1613 RetCode_t ret;
WiredHome 20:6e2e4a8372eb 1614
WiredHome 105:4f116006ba1f 1615 if (x1 < 0 || x1 >= screenwidth || x2 < 0 || x2 >= screenwidth || x3 < 0 || x3 >= screenwidth
WiredHome 105:4f116006ba1f 1616 || y1 < 0 || y1 >= screenheight || y2 < 0 || y2 >= screenheight || y3 < 0 || y3 >= screenheight)
WiredHome 85:022bba13c5c4 1617 ret = bad_parameter;
WiredHome 19:3f82c1161fd2 1618 foreground(color);
WiredHome 20:6e2e4a8372eb 1619 ret = triangle(x1,y1,x2,y2,x3,y3,fillit);
WiredHome 20:6e2e4a8372eb 1620 return ret;
WiredHome 19:3f82c1161fd2 1621 }
WiredHome 19:3f82c1161fd2 1622
WiredHome 44:207594dece70 1623
WiredHome 73:f22a18707b5e 1624 RetCode_t RA8875::filltriangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1625 loc_t x3, loc_t y3, color_t color, fill_t fillit)
WiredHome 73:f22a18707b5e 1626 {
WiredHome 73:f22a18707b5e 1627 RetCode_t ret;
WiredHome 73:f22a18707b5e 1628
WiredHome 73:f22a18707b5e 1629 foreground(color);
WiredHome 73:f22a18707b5e 1630 ret = triangle(x1,y1,x2,y2,x3,y3,fillit);
WiredHome 73:f22a18707b5e 1631 return ret;
WiredHome 73:f22a18707b5e 1632 }
WiredHome 73:f22a18707b5e 1633
WiredHome 73:f22a18707b5e 1634
WiredHome 73:f22a18707b5e 1635 RetCode_t RA8875::triangle(loc_t x1, loc_t y1 ,loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1636 loc_t x3, loc_t y3, fill_t fillit)
WiredHome 19:3f82c1161fd2 1637 {
WiredHome 19:3f82c1161fd2 1638 RetCode_t ret = noerror;
WiredHome 73:f22a18707b5e 1639
WiredHome 19:3f82c1161fd2 1640 PERFORMANCE_RESET;
WiredHome 19:3f82c1161fd2 1641 if (x1 == x2 && y1 == y2 && x1 == x3 && y1 == y3) {
WiredHome 19:3f82c1161fd2 1642 pixel(x1, y1);
WiredHome 19:3f82c1161fd2 1643 } else {
WiredHome 38:38d503b4fad6 1644 WriteCommandW(0x91, x1);
WiredHome 38:38d503b4fad6 1645 WriteCommandW(0x93, y1);
WiredHome 38:38d503b4fad6 1646 WriteCommandW(0x95, x2);
WiredHome 38:38d503b4fad6 1647 WriteCommandW(0x97, y2);
WiredHome 38:38d503b4fad6 1648 WriteCommandW(0xA9, x3);
WiredHome 38:38d503b4fad6 1649 WriteCommandW(0xAB, y3);
WiredHome 19:3f82c1161fd2 1650 unsigned char drawCmd = 0x01; // Triangle
WiredHome 19:3f82c1161fd2 1651 if (fillit == FILL)
WiredHome 19:3f82c1161fd2 1652 drawCmd |= 0x20;
WiredHome 19:3f82c1161fd2 1653 WriteCommand(0x90, drawCmd);
WiredHome 19:3f82c1161fd2 1654 WriteCommand(0x90, 0x80 + drawCmd); // Start drawing.
WiredHome 131:5bd6ba2ee4a1 1655 if (!_WaitWhileReg(0x90, 0x80)) {
WiredHome 131:5bd6ba2ee4a1 1656 REGISTERPERFORMANCE(PRF_DRAWTRIANGLE);
WiredHome 131:5bd6ba2ee4a1 1657 return external_abort;
WiredHome 131:5bd6ba2ee4a1 1658 }
WiredHome 19:3f82c1161fd2 1659 }
WiredHome 19:3f82c1161fd2 1660 REGISTERPERFORMANCE(PRF_DRAWTRIANGLE);
WiredHome 19:3f82c1161fd2 1661 return ret;
WiredHome 19:3f82c1161fd2 1662 }
WiredHome 19:3f82c1161fd2 1663
WiredHome 83:7bad0068cca0 1664
WiredHome 83:7bad0068cca0 1665 RetCode_t RA8875::circle(point_t p, dim_t radius,
WiredHome 83:7bad0068cca0 1666 color_t color, fill_t fillit)
WiredHome 83:7bad0068cca0 1667 {
WiredHome 83:7bad0068cca0 1668 foreground(color);
WiredHome 83:7bad0068cca0 1669 return circle(p.x,p.y,radius,fillit);
WiredHome 83:7bad0068cca0 1670 }
WiredHome 83:7bad0068cca0 1671
WiredHome 83:7bad0068cca0 1672
WiredHome 83:7bad0068cca0 1673 RetCode_t RA8875::fillcircle(point_t p, dim_t radius,
WiredHome 83:7bad0068cca0 1674 color_t color, fill_t fillit)
WiredHome 83:7bad0068cca0 1675 {
WiredHome 83:7bad0068cca0 1676 foreground(color);
WiredHome 83:7bad0068cca0 1677 return circle(p.x,p.y,radius,fillit);
WiredHome 83:7bad0068cca0 1678 }
WiredHome 83:7bad0068cca0 1679
WiredHome 83:7bad0068cca0 1680
WiredHome 83:7bad0068cca0 1681 RetCode_t RA8875::circle(point_t p, dim_t radius, fill_t fillit)
WiredHome 83:7bad0068cca0 1682 {
WiredHome 83:7bad0068cca0 1683 return circle(p.x,p.y,radius,fillit);
WiredHome 83:7bad0068cca0 1684 }
WiredHome 83:7bad0068cca0 1685
WiredHome 83:7bad0068cca0 1686
WiredHome 73:f22a18707b5e 1687 RetCode_t RA8875::circle(loc_t x, loc_t y, dim_t radius,
WiredHome 73:f22a18707b5e 1688 color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1689 {
WiredHome 19:3f82c1161fd2 1690 foreground(color);
WiredHome 19:3f82c1161fd2 1691 return circle(x,y,radius,fillit);
WiredHome 19:3f82c1161fd2 1692 }
WiredHome 19:3f82c1161fd2 1693
WiredHome 44:207594dece70 1694
WiredHome 73:f22a18707b5e 1695 RetCode_t RA8875::fillcircle(loc_t x, loc_t y, dim_t radius,
WiredHome 73:f22a18707b5e 1696 color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1697 {
WiredHome 19:3f82c1161fd2 1698 foreground(color);
WiredHome 19:3f82c1161fd2 1699 return circle(x,y,radius,fillit);
WiredHome 19:3f82c1161fd2 1700 }
WiredHome 19:3f82c1161fd2 1701
WiredHome 44:207594dece70 1702
WiredHome 37:f19b7e7449dc 1703 RetCode_t RA8875::circle(loc_t x, loc_t y, dim_t radius, fill_t fillit)
WiredHome 19:3f82c1161fd2 1704 {
WiredHome 19:3f82c1161fd2 1705 RetCode_t ret = noerror;
WiredHome 73:f22a18707b5e 1706
WiredHome 19:3f82c1161fd2 1707 PERFORMANCE_RESET;
WiredHome 105:4f116006ba1f 1708 if (radius <= 0 || (x - radius) < 0 || (x + radius) > screenwidth
WiredHome 105:4f116006ba1f 1709 || (y - radius) < 0 || (y + radius) > screenheight) {
WiredHome 19:3f82c1161fd2 1710 ret = bad_parameter;
WiredHome 19:3f82c1161fd2 1711 } else if (radius == 1) {
WiredHome 19:3f82c1161fd2 1712 pixel(x,y);
WiredHome 19:3f82c1161fd2 1713 } else {
WiredHome 38:38d503b4fad6 1714 WriteCommandW(0x99, x);
WiredHome 38:38d503b4fad6 1715 WriteCommandW(0x9B, y);
WiredHome 19:3f82c1161fd2 1716 WriteCommand(0x9d, radius & 0xFF);
WiredHome 19:3f82c1161fd2 1717 unsigned char drawCmd = 0x00; // Circle
WiredHome 19:3f82c1161fd2 1718 if (fillit == FILL)
WiredHome 19:3f82c1161fd2 1719 drawCmd |= 0x20;
WiredHome 19:3f82c1161fd2 1720 WriteCommand(0x90, drawCmd);
WiredHome 19:3f82c1161fd2 1721 WriteCommand(0x90, 0x40 + drawCmd); // Start drawing.
WiredHome 131:5bd6ba2ee4a1 1722 if (!_WaitWhileReg(0x90, 0x40)) {
WiredHome 131:5bd6ba2ee4a1 1723 REGISTERPERFORMANCE(PRF_DRAWCIRCLE);
WiredHome 131:5bd6ba2ee4a1 1724 return external_abort;
WiredHome 131:5bd6ba2ee4a1 1725 }
WiredHome 19:3f82c1161fd2 1726 }
WiredHome 19:3f82c1161fd2 1727 REGISTERPERFORMANCE(PRF_DRAWCIRCLE);
WiredHome 19:3f82c1161fd2 1728 return ret;
WiredHome 19:3f82c1161fd2 1729 }
WiredHome 19:3f82c1161fd2 1730
WiredHome 44:207594dece70 1731
WiredHome 37:f19b7e7449dc 1732 RetCode_t RA8875::ellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1733 {
WiredHome 19:3f82c1161fd2 1734 foreground(color);
WiredHome 25:9556a3a9b7cc 1735 return ellipse(x,y,radius1,radius2,fillit);
WiredHome 19:3f82c1161fd2 1736 }
WiredHome 19:3f82c1161fd2 1737
WiredHome 44:207594dece70 1738
WiredHome 37:f19b7e7449dc 1739 RetCode_t RA8875::fillellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome 25:9556a3a9b7cc 1740 {
WiredHome 25:9556a3a9b7cc 1741 foreground(color);
WiredHome 25:9556a3a9b7cc 1742 return ellipse(x,y,radius1,radius2,fillit);
WiredHome 25:9556a3a9b7cc 1743 }
WiredHome 44:207594dece70 1744
WiredHome 73:f22a18707b5e 1745
WiredHome 37:f19b7e7449dc 1746 RetCode_t RA8875::ellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, fill_t fillit)
WiredHome 19:3f82c1161fd2 1747 {
WiredHome 19:3f82c1161fd2 1748 RetCode_t ret = noerror;
WiredHome 73:f22a18707b5e 1749
WiredHome 19:3f82c1161fd2 1750 PERFORMANCE_RESET;
WiredHome 105:4f116006ba1f 1751 if (radius1 <= 0 || radius2 <= 0 || (x - radius1) < 0 || (x + radius1) > screenwidth
WiredHome 105:4f116006ba1f 1752 || (y - radius2) < 0 || (y + radius2) > screenheight) {
WiredHome 85:022bba13c5c4 1753 ret = bad_parameter;
WiredHome 25:9556a3a9b7cc 1754 } else if (radius1 == 1 && radius2 == 1) {
WiredHome 19:3f82c1161fd2 1755 pixel(x, y);
WiredHome 19:3f82c1161fd2 1756 } else {
WiredHome 38:38d503b4fad6 1757 WriteCommandW(0xA5, x);
WiredHome 38:38d503b4fad6 1758 WriteCommandW(0xA7, y);
WiredHome 38:38d503b4fad6 1759 WriteCommandW(0xA1, radius1);
WiredHome 38:38d503b4fad6 1760 WriteCommandW(0xA3, radius2);
WiredHome 19:3f82c1161fd2 1761 unsigned char drawCmd = 0x00; // Ellipse
WiredHome 19:3f82c1161fd2 1762 if (fillit == FILL)
WiredHome 19:3f82c1161fd2 1763 drawCmd |= 0x40;
WiredHome 19:3f82c1161fd2 1764 WriteCommand(0xA0, drawCmd);
WiredHome 19:3f82c1161fd2 1765 WriteCommand(0xA0, 0x80 + drawCmd); // Start drawing.
WiredHome 131:5bd6ba2ee4a1 1766 if (!_WaitWhileReg(0xA0, 0x80)) {
WiredHome 131:5bd6ba2ee4a1 1767 REGISTERPERFORMANCE(PRF_DRAWELLIPSE);
WiredHome 131:5bd6ba2ee4a1 1768 return external_abort;
WiredHome 131:5bd6ba2ee4a1 1769 }
WiredHome 19:3f82c1161fd2 1770 }
WiredHome 19:3f82c1161fd2 1771 REGISTERPERFORMANCE(PRF_DRAWELLIPSE);
WiredHome 19:3f82c1161fd2 1772 return ret;
WiredHome 19:3f82c1161fd2 1773 }
WiredHome 19:3f82c1161fd2 1774
WiredHome 44:207594dece70 1775
WiredHome 68:ab08efabfc88 1776 RetCode_t RA8875::frequency(unsigned long Hz, unsigned long Hz2)
WiredHome 19:3f82c1161fd2 1777 {
WiredHome 66:468a11f05580 1778 spiwritefreq = Hz;
WiredHome 68:ab08efabfc88 1779 if (Hz2 != 0)
WiredHome 68:ab08efabfc88 1780 spireadfreq = Hz2;
WiredHome 68:ab08efabfc88 1781 else
WiredHome 68:ab08efabfc88 1782 spireadfreq = Hz/2;
WiredHome 68:ab08efabfc88 1783 _setWriteSpeed(true);
WiredHome 19:3f82c1161fd2 1784 // __ ___
WiredHome 19:3f82c1161fd2 1785 // Clock ___A Rising edge latched
WiredHome 19:3f82c1161fd2 1786 // ___ ____
WiredHome 19:3f82c1161fd2 1787 // Data ___X____
WiredHome 19:3f82c1161fd2 1788 spi.format(8, 3); // 8 bits and clock to data phase 0
WiredHome 19:3f82c1161fd2 1789 return noerror;
WiredHome 19:3f82c1161fd2 1790 }
WiredHome 19:3f82c1161fd2 1791
WiredHome 68:ab08efabfc88 1792 void RA8875::_setWriteSpeed(bool writeSpeed)
WiredHome 68:ab08efabfc88 1793 {
WiredHome 68:ab08efabfc88 1794 if (writeSpeed) {
WiredHome 68:ab08efabfc88 1795 spi.frequency(spiwritefreq);
WiredHome 68:ab08efabfc88 1796 spiWriteSpeed = true;
WiredHome 68:ab08efabfc88 1797 } else {
WiredHome 68:ab08efabfc88 1798 spi.frequency(spireadfreq);
WiredHome 68:ab08efabfc88 1799 spiWriteSpeed = false;
WiredHome 68:ab08efabfc88 1800 }
WiredHome 68:ab08efabfc88 1801 }
WiredHome 44:207594dece70 1802
WiredHome 131:5bd6ba2ee4a1 1803
WiredHome 131:5bd6ba2ee4a1 1804
WiredHome 131:5bd6ba2ee4a1 1805 RetCode_t RA8875::BlockMove(uint8_t dstLayer, uint8_t dstDataSelect, point_t dstPoint,
WiredHome 131:5bd6ba2ee4a1 1806 uint8_t srcLayer, uint8_t srcDataSelect, point_t srcPoint,
WiredHome 137:9e09f6081ef1 1807 dim_t bte_width, dim_t bte_height,
WiredHome 131:5bd6ba2ee4a1 1808 uint8_t bte_op_code, uint8_t bte_rop_code)
WiredHome 131:5bd6ba2ee4a1 1809 {
WiredHome 131:5bd6ba2ee4a1 1810 uint8_t cmd;
WiredHome 131:5bd6ba2ee4a1 1811
WiredHome 131:5bd6ba2ee4a1 1812 PERFORMANCE_RESET;
WiredHome 137:9e09f6081ef1 1813 ///@todo range check and error return rather than to secretly fix
WiredHome 131:5bd6ba2ee4a1 1814 srcPoint.x &= 0x3FF; // prevent high bits from doing unexpected things
WiredHome 131:5bd6ba2ee4a1 1815 srcPoint.y &= 0x1FF;
WiredHome 131:5bd6ba2ee4a1 1816 dstPoint.x &= 0x3FF;
WiredHome 131:5bd6ba2ee4a1 1817 dstPoint.y &= 0x1FF;
WiredHome 131:5bd6ba2ee4a1 1818 WriteCommandW(0x54, srcPoint.x);
WiredHome 137:9e09f6081ef1 1819 WriteCommandW(0x56, ((dim_t)(srcLayer & 1) << 15) | srcPoint.y);
WiredHome 131:5bd6ba2ee4a1 1820 WriteCommandW(0x58, dstPoint.x);
WiredHome 137:9e09f6081ef1 1821 WriteCommandW(0x5A, ((dim_t)(dstLayer & 1) << 15) | dstPoint.y);
WiredHome 131:5bd6ba2ee4a1 1822 WriteCommandW(0x5C, bte_width);
WiredHome 131:5bd6ba2ee4a1 1823 WriteCommandW(0x5E, bte_height);
WiredHome 131:5bd6ba2ee4a1 1824 WriteCommand(0x51, ((bte_rop_code & 0x0F) << 4) | (bte_op_code & 0x0F));
WiredHome 131:5bd6ba2ee4a1 1825 cmd = ((srcDataSelect & 1) << 6) | ((dstDataSelect & 1) << 5);
WiredHome 131:5bd6ba2ee4a1 1826 WriteCommand(0x50, 0x80 | cmd); // enable the BTE
WiredHome 131:5bd6ba2ee4a1 1827 if (!_WaitWhileBusy(0x40)) {
WiredHome 131:5bd6ba2ee4a1 1828 REGISTERPERFORMANCE(PRF_BLOCKMOVE);
WiredHome 131:5bd6ba2ee4a1 1829 return external_abort;
WiredHome 131:5bd6ba2ee4a1 1830 }
WiredHome 131:5bd6ba2ee4a1 1831 REGISTERPERFORMANCE(PRF_BLOCKMOVE);
WiredHome 131:5bd6ba2ee4a1 1832 return noerror;
WiredHome 131:5bd6ba2ee4a1 1833 }
WiredHome 131:5bd6ba2ee4a1 1834
WiredHome 131:5bd6ba2ee4a1 1835
WiredHome 19:3f82c1161fd2 1836 RetCode_t RA8875::Power(bool on)
WiredHome 19:3f82c1161fd2 1837 {
WiredHome 19:3f82c1161fd2 1838 WriteCommand(0x01, (on) ? 0x80 : 0x00);
WiredHome 19:3f82c1161fd2 1839 return noerror;
WiredHome 19:3f82c1161fd2 1840 }
WiredHome 19:3f82c1161fd2 1841
WiredHome 44:207594dece70 1842
WiredHome 131:5bd6ba2ee4a1 1843 RetCode_t RA8875::Backlight_u8(uint8_t brightness)
WiredHome 19:3f82c1161fd2 1844 {
WiredHome 19:3f82c1161fd2 1845 static bool is_enabled = false;
WiredHome 131:5bd6ba2ee4a1 1846
WiredHome 19:3f82c1161fd2 1847 if (brightness == 0) {
WiredHome 19:3f82c1161fd2 1848 WriteCommand(0x8a); // Disable the PWM
WiredHome 19:3f82c1161fd2 1849 WriteData(0x00);
WiredHome 19:3f82c1161fd2 1850 is_enabled = false;
WiredHome 19:3f82c1161fd2 1851 } else if (!is_enabled) {
WiredHome 19:3f82c1161fd2 1852 WriteCommand(0x8a); // Enable the PWM
WiredHome 19:3f82c1161fd2 1853 WriteData(0x80);
WiredHome 19:3f82c1161fd2 1854 WriteCommand(0x8a); // Not sure why this is needed, but following the pattern
WiredHome 19:3f82c1161fd2 1855 WriteData(0x81); // open PWM (SYS_CLK / 2 as best I can tell)
WiredHome 19:3f82c1161fd2 1856 is_enabled = true;
WiredHome 19:3f82c1161fd2 1857 }
WiredHome 19:3f82c1161fd2 1858 WriteCommand(0x8b, brightness); // Brightness parameter 0xff-0x00
WiredHome 19:3f82c1161fd2 1859 return noerror;
WiredHome 19:3f82c1161fd2 1860 }
WiredHome 19:3f82c1161fd2 1861
WiredHome 86:e86b355940f4 1862 uint8_t RA8875::GetBacklight_u8(void)
WiredHome 86:e86b355940f4 1863 {
WiredHome 86:e86b355940f4 1864 return ReadCommand(0x8b);
WiredHome 86:e86b355940f4 1865 }
WiredHome 44:207594dece70 1866
WiredHome 19:3f82c1161fd2 1867 RetCode_t RA8875::Backlight(float brightness)
WiredHome 19:3f82c1161fd2 1868 {
WiredHome 19:3f82c1161fd2 1869 unsigned char b;
WiredHome 73:f22a18707b5e 1870
WiredHome 29:422616aa04bd 1871 if (brightness >= 1.0)
WiredHome 19:3f82c1161fd2 1872 b = 255;
WiredHome 29:422616aa04bd 1873 else if (brightness <= 0.0)
WiredHome 19:3f82c1161fd2 1874 b = 0;
WiredHome 19:3f82c1161fd2 1875 else
WiredHome 19:3f82c1161fd2 1876 b = (unsigned char)(brightness * 255);
WiredHome 19:3f82c1161fd2 1877 return Backlight_u8(b);
WiredHome 19:3f82c1161fd2 1878 }
WiredHome 19:3f82c1161fd2 1879
WiredHome 86:e86b355940f4 1880 float RA8875::GetBacklight(void)
WiredHome 86:e86b355940f4 1881 {
WiredHome 86:e86b355940f4 1882 return (float)(GetBacklight_u8())/255;
WiredHome 86:e86b355940f4 1883 }
WiredHome 44:207594dece70 1884
WiredHome 98:ecebed9b80b2 1885 RetCode_t RA8875::SelectUserFont(const uint8_t * _font)
WiredHome 98:ecebed9b80b2 1886 {
WiredHome 98:ecebed9b80b2 1887 INFO("Cursor(%d,%d) %p", cursor_x, cursor_y, _font);
WiredHome 98:ecebed9b80b2 1888 INFO("Text C(%d,%d)", GetTextCursor_X(), GetTextCursor_Y());
WiredHome 98:ecebed9b80b2 1889 if (_font) {
WiredHome 98:ecebed9b80b2 1890 HexDump("Font Memory", _font, 16);
WiredHome 98:ecebed9b80b2 1891 extFontHeight = _font[6];
WiredHome 98:ecebed9b80b2 1892 uint32_t totalWidth = 0;
WiredHome 98:ecebed9b80b2 1893 uint16_t firstChar = _font[3] * 256 + _font[2];
WiredHome 98:ecebed9b80b2 1894 uint16_t lastChar = _font[5] * 256 + _font[4];
WiredHome 98:ecebed9b80b2 1895 uint16_t i;
WiredHome 98:ecebed9b80b2 1896
WiredHome 98:ecebed9b80b2 1897 for (i=firstChar; i<=lastChar; i++) {
WiredHome 98:ecebed9b80b2 1898 // 8 bytes of preamble to the first level lookup table
WiredHome 98:ecebed9b80b2 1899 uint16_t offsetToCharLookup = 8 + 4 * (i - firstChar); // 4-bytes: width(pixels), 16-bit offset from table start, 0
WiredHome 98:ecebed9b80b2 1900 totalWidth += _font[offsetToCharLookup];
WiredHome 98:ecebed9b80b2 1901 }
WiredHome 98:ecebed9b80b2 1902 extFontWidth = totalWidth / (lastChar - firstChar);
WiredHome 98:ecebed9b80b2 1903 INFO("Font Metrics: Avg W: %2d, H: %2d, First:%d, Last:%d", extFontWidth, extFontHeight, firstChar, lastChar);
WiredHome 98:ecebed9b80b2 1904 }
WiredHome 98:ecebed9b80b2 1905 SetTextCursor(GetTextCursor_X(), GetTextCursor_Y()); // soft-font cursor -> hw cursor
WiredHome 98:ecebed9b80b2 1906 font = _font;
WiredHome 98:ecebed9b80b2 1907 return GraphicsDisplay::SelectUserFont(_font);
WiredHome 98:ecebed9b80b2 1908 }
WiredHome 44:207594dece70 1909
WiredHome 19:3f82c1161fd2 1910 RetCode_t RA8875::background(color_t color)
WiredHome 19:3f82c1161fd2 1911 {
WiredHome 37:f19b7e7449dc 1912 GraphicsDisplay::background(color);
WiredHome 133:e36dcfc2d756 1913 return _writeColorTrio(0x60, color);
WiredHome 19:3f82c1161fd2 1914 }
WiredHome 19:3f82c1161fd2 1915
WiredHome 44:207594dece70 1916
WiredHome 19:3f82c1161fd2 1917 RetCode_t RA8875::background(unsigned char r, unsigned char g, unsigned char b)
WiredHome 19:3f82c1161fd2 1918 {
WiredHome 37:f19b7e7449dc 1919 background(RGB(r,g,b));
WiredHome 19:3f82c1161fd2 1920 return noerror;
WiredHome 19:3f82c1161fd2 1921 }
WiredHome 19:3f82c1161fd2 1922
WiredHome 44:207594dece70 1923
WiredHome 19:3f82c1161fd2 1924 RetCode_t RA8875::foreground(color_t color)
WiredHome 19:3f82c1161fd2 1925 {
WiredHome 37:f19b7e7449dc 1926 GraphicsDisplay::foreground(color);
WiredHome 133:e36dcfc2d756 1927 return _writeColorTrio(0x63, color);
WiredHome 19:3f82c1161fd2 1928 }
WiredHome 19:3f82c1161fd2 1929
WiredHome 44:207594dece70 1930
WiredHome 37:f19b7e7449dc 1931 RetCode_t RA8875::foreground(unsigned char r, unsigned char g, unsigned char b)
WiredHome 19:3f82c1161fd2 1932 {
WiredHome 37:f19b7e7449dc 1933 foreground(RGB(r,g,b));
WiredHome 19:3f82c1161fd2 1934 return noerror;
WiredHome 19:3f82c1161fd2 1935 }
WiredHome 19:3f82c1161fd2 1936
WiredHome 44:207594dece70 1937
WiredHome 37:f19b7e7449dc 1938 color_t RA8875::GetForeColor(void)
WiredHome 19:3f82c1161fd2 1939 {
WiredHome 133:e36dcfc2d756 1940 return _readColorTrio(0x63);
WiredHome 19:3f82c1161fd2 1941 }
WiredHome 19:3f82c1161fd2 1942
WiredHome 44:207594dece70 1943
WiredHome 19:3f82c1161fd2 1944 color_t RA8875::DOSColor(int i)
WiredHome 73:f22a18707b5e 1945 {
WiredHome 73:f22a18707b5e 1946 const color_t colors[16] = {
WiredHome 19:3f82c1161fd2 1947 Black, Blue, Green, Cyan,
WiredHome 19:3f82c1161fd2 1948 Red, Magenta, Brown, Gray,
WiredHome 19:3f82c1161fd2 1949 Charcoal, BrightBlue, BrightGreen, BrightCyan,
WiredHome 19:3f82c1161fd2 1950 Orange, Pink, Yellow, White
WiredHome 73:f22a18707b5e 1951 };
WiredHome 85:022bba13c5c4 1952 if (i >= 0 && i < 16)
WiredHome 19:3f82c1161fd2 1953 return colors[i];
WiredHome 19:3f82c1161fd2 1954 else
WiredHome 19:3f82c1161fd2 1955 return 0;
WiredHome 73:f22a18707b5e 1956 }
WiredHome 19:3f82c1161fd2 1957
WiredHome 44:207594dece70 1958
WiredHome 73:f22a18707b5e 1959 const char * RA8875::DOSColorNames(int i)
WiredHome 73:f22a18707b5e 1960 {
WiredHome 73:f22a18707b5e 1961 const char * names[16] = {
WiredHome 19:3f82c1161fd2 1962 "Black", "Blue", "Green", "Cyan",
WiredHome 19:3f82c1161fd2 1963 "Red", "Magenta", "Brown", "Gray",
WiredHome 19:3f82c1161fd2 1964 "Charcoal", "BrightBlue", "BrightGreen", "BrightCyan",
WiredHome 19:3f82c1161fd2 1965 "Orange", "Pink", "Yellow", "White"
WiredHome 73:f22a18707b5e 1966 };
WiredHome 85:022bba13c5c4 1967 if (i >= 0 && i < 16)
WiredHome 19:3f82c1161fd2 1968 return names[i];
WiredHome 19:3f82c1161fd2 1969 else
WiredHome 19:3f82c1161fd2 1970 return NULL;
WiredHome 73:f22a18707b5e 1971 }
WiredHome 19:3f82c1161fd2 1972
WiredHome 19:3f82c1161fd2 1973
WiredHome 19:3f82c1161fd2 1974 ///////////////////////////////////////////////////////////////
WiredHome 19:3f82c1161fd2 1975 // Private functions
WiredHome 19:3f82c1161fd2 1976
WiredHome 79:544eb4964795 1977 unsigned char RA8875::_spiwrite(unsigned char data)
WiredHome 19:3f82c1161fd2 1978 {
WiredHome 19:3f82c1161fd2 1979 unsigned char retval;
WiredHome 73:f22a18707b5e 1980
WiredHome 68:ab08efabfc88 1981 if (!spiWriteSpeed)
WiredHome 68:ab08efabfc88 1982 _setWriteSpeed(true);
WiredHome 19:3f82c1161fd2 1983 retval = spi.write(data);
WiredHome 19:3f82c1161fd2 1984 return retval;
WiredHome 19:3f82c1161fd2 1985 }
WiredHome 19:3f82c1161fd2 1986
WiredHome 44:207594dece70 1987
WiredHome 79:544eb4964795 1988 unsigned char RA8875::_spiread(void)
WiredHome 19:3f82c1161fd2 1989 {
WiredHome 19:3f82c1161fd2 1990 unsigned char retval;
WiredHome 19:3f82c1161fd2 1991 unsigned char data = 0;
WiredHome 73:f22a18707b5e 1992
WiredHome 68:ab08efabfc88 1993 if (spiWriteSpeed)
WiredHome 68:ab08efabfc88 1994 _setWriteSpeed(false);
WiredHome 19:3f82c1161fd2 1995 retval = spi.write(data);
WiredHome 19:3f82c1161fd2 1996 return retval;
WiredHome 19:3f82c1161fd2 1997 }
WiredHome 19:3f82c1161fd2 1998
WiredHome 44:207594dece70 1999
WiredHome 79:544eb4964795 2000 RetCode_t RA8875::_select(bool chipsel)
WiredHome 19:3f82c1161fd2 2001 {
WiredHome 19:3f82c1161fd2 2002 cs = (chipsel == true) ? 0 : 1;
WiredHome 19:3f82c1161fd2 2003 return noerror;
WiredHome 19:3f82c1161fd2 2004 }
WiredHome 19:3f82c1161fd2 2005
WiredHome 44:207594dece70 2006
WiredHome 72:ecffe56af969 2007 RetCode_t RA8875::PrintScreen(uint16_t layer, loc_t x, loc_t y, dim_t w, dim_t h, const char *Name_BMP)
WiredHome 72:ecffe56af969 2008 {
WiredHome 74:686faa218914 2009 (void)layer;
WiredHome 96:40b74dd3695b 2010
WiredHome 96:40b74dd3695b 2011 // AttachPrintHandler(this, RA8875::_printCallback);
WiredHome 96:40b74dd3695b 2012 // return PrintScreen(x,y,w,h);
WiredHome 74:686faa218914 2013 return PrintScreen(x, y, w, h, Name_BMP);
WiredHome 72:ecffe56af969 2014 }
WiredHome 72:ecffe56af969 2015
WiredHome 96:40b74dd3695b 2016 RetCode_t RA8875::_printCallback(RA8875::filecmd_t cmd, uint8_t * buffer, uint16_t size)
WiredHome 96:40b74dd3695b 2017 {
WiredHome 96:40b74dd3695b 2018 HexDump("CB", buffer, size);
WiredHome 96:40b74dd3695b 2019 switch(cmd) {
WiredHome 96:40b74dd3695b 2020 case RA8875::OPEN:
WiredHome 96:40b74dd3695b 2021 //pc.printf("About to write %lu bytes\r\n", *(uint32_t *)buffer);
WiredHome 96:40b74dd3695b 2022 _printFH = fopen("file.bmp", "w+b");
WiredHome 96:40b74dd3695b 2023 if (_printFH == 0)
WiredHome 96:40b74dd3695b 2024 return file_not_found;
WiredHome 96:40b74dd3695b 2025 break;
WiredHome 96:40b74dd3695b 2026 case RA8875::WRITE:
WiredHome 96:40b74dd3695b 2027 //pc.printf(" Write %4u bytes\r\n", size);
WiredHome 96:40b74dd3695b 2028 fwrite(buffer, 1, size, _printFH);
WiredHome 96:40b74dd3695b 2029 break;
WiredHome 96:40b74dd3695b 2030 case RA8875::CLOSE:
WiredHome 96:40b74dd3695b 2031 //pc.printf(" close\r\n");
WiredHome 96:40b74dd3695b 2032 fclose(_printFH);
WiredHome 96:40b74dd3695b 2033 _printFH = 0;
WiredHome 96:40b74dd3695b 2034 break;
WiredHome 96:40b74dd3695b 2035 default:
WiredHome 96:40b74dd3695b 2036 //pc.printf("Unexpected callback %d\r\n", cmd);
WiredHome 96:40b74dd3695b 2037 return file_not_found;
WiredHome 96:40b74dd3695b 2038 //break;
WiredHome 96:40b74dd3695b 2039 }
WiredHome 96:40b74dd3695b 2040 return noerror;
WiredHome 96:40b74dd3695b 2041 }
WiredHome 96:40b74dd3695b 2042
WiredHome 96:40b74dd3695b 2043 RetCode_t RA8875::PrintScreen(loc_t x, loc_t y, dim_t w, dim_t h)
WiredHome 96:40b74dd3695b 2044 {
WiredHome 96:40b74dd3695b 2045 BITMAPFILEHEADER BMP_Header;
WiredHome 96:40b74dd3695b 2046 BITMAPINFOHEADER BMP_Info;
WiredHome 96:40b74dd3695b 2047 uint8_t * lineBuffer = NULL;
WiredHome 96:40b74dd3695b 2048 color_t * pixelBuffer = NULL;
WiredHome 96:40b74dd3695b 2049 color_t * pixelBuffer2 = NULL;
WiredHome 96:40b74dd3695b 2050
WiredHome 98:ecebed9b80b2 2051 INFO("(%d,%d) - (%d,%d)", x,y,w,h);
WiredHome 105:4f116006ba1f 2052 if (x >= 0 && x < screenwidth
WiredHome 105:4f116006ba1f 2053 && y >= 0 && y < screenheight
WiredHome 105:4f116006ba1f 2054 && w > 0 && x + w <= screenwidth
WiredHome 105:4f116006ba1f 2055 && h > 0 && y + h <= screenheight) {
WiredHome 96:40b74dd3695b 2056
WiredHome 96:40b74dd3695b 2057 BMP_Header.bfType = BF_TYPE;
WiredHome 96:40b74dd3695b 2058 BMP_Header.bfSize = (w * h * sizeof(RGBQUAD)) + sizeof(BMP_Header) + sizeof(BMP_Header);
WiredHome 96:40b74dd3695b 2059 BMP_Header.bfReserved1 = 0;
WiredHome 96:40b74dd3695b 2060 BMP_Header.bfReserved2 = 0;
WiredHome 96:40b74dd3695b 2061 BMP_Header.bfOffBits = sizeof(BMP_Header) + sizeof(BMP_Header);
WiredHome 96:40b74dd3695b 2062
WiredHome 96:40b74dd3695b 2063 BMP_Info.biSize = sizeof(BMP_Info);
WiredHome 96:40b74dd3695b 2064 BMP_Info.biWidth = w;
WiredHome 96:40b74dd3695b 2065 BMP_Info.biHeight = h;
WiredHome 96:40b74dd3695b 2066 BMP_Info.biPlanes = 1;
WiredHome 96:40b74dd3695b 2067 BMP_Info.biBitCount = 24;
WiredHome 96:40b74dd3695b 2068 BMP_Info.biCompression = BI_RGB;
WiredHome 96:40b74dd3695b 2069 BMP_Info.biSizeImage = 0;
WiredHome 96:40b74dd3695b 2070 BMP_Info.biXPelsPerMeter = 0;
WiredHome 96:40b74dd3695b 2071 BMP_Info.biYPelsPerMeter = 0;
WiredHome 96:40b74dd3695b 2072 BMP_Info.biClrUsed = 0;
WiredHome 96:40b74dd3695b 2073 BMP_Info.biClrImportant = 0;
WiredHome 96:40b74dd3695b 2074
WiredHome 96:40b74dd3695b 2075 // Allocate the memory we need to proceed
WiredHome 96:40b74dd3695b 2076 int lineBufSize = ((24 * w + 7)/8);
WiredHome 145:5eb2492acdda 2077 lineBuffer = (uint8_t *)swMalloc(lineBufSize);
WiredHome 96:40b74dd3695b 2078 if (lineBuffer == NULL) {
WiredHome 96:40b74dd3695b 2079 ERR("Not enough RAM for PrintScreen lineBuffer");
WiredHome 96:40b74dd3695b 2080 return(not_enough_ram);
WiredHome 96:40b74dd3695b 2081 }
WiredHome 96:40b74dd3695b 2082
WiredHome 96:40b74dd3695b 2083 #define DOUBLEBUF /* one larger buffer instead of two */
WiredHome 96:40b74dd3695b 2084
WiredHome 96:40b74dd3695b 2085 #ifdef DOUBLEBUF
WiredHome 96:40b74dd3695b 2086 // In the "#else", pixelBuffer2 malloc returns a value,
WiredHome 96:40b74dd3695b 2087 // but is actually causing a failure later.
WiredHome 96:40b74dd3695b 2088 // This test helps determine if it is truly out of memory,
WiredHome 96:40b74dd3695b 2089 // or if malloc is broken.
WiredHome 145:5eb2492acdda 2090 pixelBuffer = (color_t *)swMalloc(2 * w * sizeof(color_t));
WiredHome 96:40b74dd3695b 2091 pixelBuffer2 = pixelBuffer + (w * sizeof(color_t));
WiredHome 96:40b74dd3695b 2092 #else
WiredHome 145:5eb2492acdda 2093 pixelBuffer = (color_t *)swMalloc(w * sizeof(color_t));
WiredHome 145:5eb2492acdda 2094 pixelBuffer2 = (color_t *)swMalloc(w * sizeof(color_t));
WiredHome 96:40b74dd3695b 2095 #endif
WiredHome 96:40b74dd3695b 2096 if (pixelBuffer == NULL || pixelBuffer2 == NULL) {
WiredHome 96:40b74dd3695b 2097 ERR("Not enough RAM for pixelBuffer");
WiredHome 96:40b74dd3695b 2098 #ifndef DOUBLEBUF
WiredHome 96:40b74dd3695b 2099 if (pixelBuffer2)
WiredHome 145:5eb2492acdda 2100 swFree(pixelBuffer2);
WiredHome 96:40b74dd3695b 2101 #endif
WiredHome 96:40b74dd3695b 2102 if (pixelBuffer)
WiredHome 145:5eb2492acdda 2103 swFree(pixelBuffer);
WiredHome 145:5eb2492acdda 2104 swFree(lineBuffer);
WiredHome 96:40b74dd3695b 2105 return(not_enough_ram);
WiredHome 96:40b74dd3695b 2106 }
WiredHome 96:40b74dd3695b 2107
WiredHome 96:40b74dd3695b 2108 // Get the file primed...
WiredHome 96:40b74dd3695b 2109 privateCallback(OPEN, (uint8_t *)&BMP_Header.bfSize, 4);
WiredHome 96:40b74dd3695b 2110
WiredHome 96:40b74dd3695b 2111 // Be optimistic - don't check for errors.
WiredHome 96:40b74dd3695b 2112 HexDump("BMP_Header", (uint8_t *)&BMP_Header, sizeof(BMP_Header));
WiredHome 96:40b74dd3695b 2113 //fwrite(&BMP_Header, sizeof(char), sizeof(BMP_Header), Image);
WiredHome 96:40b74dd3695b 2114 privateCallback(WRITE, (uint8_t *)&BMP_Header, sizeof(BMP_Header));
WiredHome 96:40b74dd3695b 2115
WiredHome 96:40b74dd3695b 2116 HexDump("BMP_Info", (uint8_t *)&BMP_Info, sizeof(BMP_Info));
WiredHome 96:40b74dd3695b 2117 //fwrite(&BMP_Info, sizeof(char), sizeof(BMP_Info), Image);
WiredHome 96:40b74dd3695b 2118 privateCallback(WRITE, (uint8_t *)&BMP_Info, sizeof(BMP_Info));
WiredHome 96:40b74dd3695b 2119
WiredHome 96:40b74dd3695b 2120 //color_t transparency = GetBackgroundTransparencyColor();
WiredHome 96:40b74dd3695b 2121 LayerMode_T ltpr0 = GetLayerMode();
WiredHome 96:40b74dd3695b 2122
WiredHome 96:40b74dd3695b 2123 uint16_t prevLayer = GetDrawingLayer();
WiredHome 96:40b74dd3695b 2124 // If only one of the layers is visible, select that layer
WiredHome 96:40b74dd3695b 2125 switch(ltpr0) {
WiredHome 96:40b74dd3695b 2126 case ShowLayer0:
WiredHome 96:40b74dd3695b 2127 SelectDrawingLayer(0);
WiredHome 96:40b74dd3695b 2128 break;
WiredHome 96:40b74dd3695b 2129 case ShowLayer1:
WiredHome 96:40b74dd3695b 2130 SelectDrawingLayer(1);
WiredHome 96:40b74dd3695b 2131 break;
WiredHome 96:40b74dd3695b 2132 default:
WiredHome 96:40b74dd3695b 2133 break;
WiredHome 96:40b74dd3695b 2134 }
WiredHome 96:40b74dd3695b 2135
WiredHome 96:40b74dd3695b 2136 // Read the display from the last line toward the top
WiredHome 96:40b74dd3695b 2137 // so we can write the file in one pass.
WiredHome 96:40b74dd3695b 2138 for (int j = h - 1; j >= 0; j--) {
WiredHome 149:c62c4b2d6a15 2139 if (idle_callback) {
WiredHome 149:c62c4b2d6a15 2140 (*idle_callback)(progress, (h - 1 - j) * 100 / (h - 1));
WiredHome 149:c62c4b2d6a15 2141 }
WiredHome 149:c62c4b2d6a15 2142
WiredHome 96:40b74dd3695b 2143 if (ltpr0 >= 2) // Need to combine the layers...
WiredHome 96:40b74dd3695b 2144 SelectDrawingLayer(0); // so read layer 0 first
WiredHome 96:40b74dd3695b 2145 // Read one line of pixels to a local buffer
WiredHome 96:40b74dd3695b 2146 if (getPixelStream(pixelBuffer, w, x,y+j) != noerror) {
WiredHome 96:40b74dd3695b 2147 ERR("getPixelStream error, and no recovery handler...");
WiredHome 96:40b74dd3695b 2148 }
WiredHome 96:40b74dd3695b 2149 if (ltpr0 >= 2) { // Need to combine the layers...
WiredHome 96:40b74dd3695b 2150 SelectDrawingLayer(1); // so read layer 1 next
WiredHome 96:40b74dd3695b 2151 if (getPixelStream(pixelBuffer2, w, x,y+j) != noerror) {
WiredHome 96:40b74dd3695b 2152 ERR("getPixelStream error, and no recovery handler...");
WiredHome 96:40b74dd3695b 2153 }
WiredHome 96:40b74dd3695b 2154 }
WiredHome 96:40b74dd3695b 2155 INFO("1st Color: %04X", pixelBuffer[0]);
WiredHome 96:40b74dd3695b 2156 HexDump("Raster", (uint8_t *)pixelBuffer, w);
WiredHome 96:40b74dd3695b 2157 // Convert the local buffer to RGBQUAD format
WiredHome 96:40b74dd3695b 2158 int lb = 0;
WiredHome 96:40b74dd3695b 2159 for (int i=0; i<w; i++) {
WiredHome 96:40b74dd3695b 2160 RGBQUAD q0 = RGB16ToRGBQuad(pixelBuffer[x+i]); // Scale to 24-bits
WiredHome 96:40b74dd3695b 2161 RGBQUAD q1 = RGB16ToRGBQuad(pixelBuffer2[x+i]); // Scale to 24-bits
WiredHome 96:40b74dd3695b 2162 switch (ltpr0) {
WiredHome 96:40b74dd3695b 2163 case 0:
WiredHome 96:40b74dd3695b 2164 case 1:
WiredHome 96:40b74dd3695b 2165 case 2: // lighten-overlay (@TODO Not supported yet)
WiredHome 96:40b74dd3695b 2166 case 6: // Floating Windows (@TODO not sure how to support)
WiredHome 96:40b74dd3695b 2167 default: // Reserved...
WiredHome 96:40b74dd3695b 2168 lineBuffer[lb++] = q0.rgbBlue;
WiredHome 96:40b74dd3695b 2169 lineBuffer[lb++] = q0.rgbGreen;
WiredHome 96:40b74dd3695b 2170 lineBuffer[lb++] = q0.rgbRed;
WiredHome 96:40b74dd3695b 2171 break;
WiredHome 96:40b74dd3695b 2172 case 3: // transparent mode (@TODO Read the background color register for transparent)
WiredHome 96:40b74dd3695b 2173 case 4: // boolean or
WiredHome 96:40b74dd3695b 2174 lineBuffer[lb++] = q0.rgbBlue | q1.rgbBlue;
WiredHome 96:40b74dd3695b 2175 lineBuffer[lb++] = q0.rgbGreen | q1.rgbGreen;
WiredHome 96:40b74dd3695b 2176 lineBuffer[lb++] = q0.rgbRed | q1.rgbRed;
WiredHome 96:40b74dd3695b 2177 break;
WiredHome 96:40b74dd3695b 2178 case 5: // boolean AND
WiredHome 96:40b74dd3695b 2179 lineBuffer[lb++] = q0.rgbBlue & q1.rgbBlue;
WiredHome 96:40b74dd3695b 2180 lineBuffer[lb++] = q0.rgbGreen & q1.rgbGreen;
WiredHome 96:40b74dd3695b 2181 lineBuffer[lb++] = q0.rgbRed & q1.rgbRed;
WiredHome 96:40b74dd3695b 2182 break;
WiredHome 96:40b74dd3695b 2183 }
WiredHome 96:40b74dd3695b 2184 }
WiredHome 96:40b74dd3695b 2185 if (j == h - 1) {
WiredHome 96:40b74dd3695b 2186 HexDump("Line", lineBuffer, lineBufSize);
WiredHome 96:40b74dd3695b 2187 }
WiredHome 96:40b74dd3695b 2188 // Write to disk
WiredHome 96:40b74dd3695b 2189 //fwrite(lineBuffer, sizeof(char), lb, Image);
WiredHome 96:40b74dd3695b 2190 privateCallback(WRITE, (uint8_t *)lineBuffer, lb);
WiredHome 96:40b74dd3695b 2191 }
WiredHome 96:40b74dd3695b 2192 SelectDrawingLayer(prevLayer);
WiredHome 96:40b74dd3695b 2193 //fclose(Image);
WiredHome 96:40b74dd3695b 2194 privateCallback(CLOSE, NULL, 0);
WiredHome 96:40b74dd3695b 2195
WiredHome 96:40b74dd3695b 2196 #ifndef DOUBLEBUF
WiredHome 96:40b74dd3695b 2197 if (pixelBuffer2)
WiredHome 145:5eb2492acdda 2198 swFree(pixelBuffer2);
WiredHome 96:40b74dd3695b 2199 #endif
WiredHome 96:40b74dd3695b 2200 if (pixelBuffer)
WiredHome 145:5eb2492acdda 2201 swFree(pixelBuffer);
WiredHome 145:5eb2492acdda 2202 swFree(lineBuffer);
WiredHome 96:40b74dd3695b 2203 INFO("Image closed");
WiredHome 96:40b74dd3695b 2204 return noerror;
WiredHome 96:40b74dd3695b 2205 } else {
WiredHome 96:40b74dd3695b 2206 return bad_parameter;
WiredHome 96:40b74dd3695b 2207 }
WiredHome 96:40b74dd3695b 2208 }
WiredHome 79:544eb4964795 2209
WiredHome 72:ecffe56af969 2210 RetCode_t RA8875::PrintScreen(loc_t x, loc_t y, dim_t w, dim_t h, const char *Name_BMP)
WiredHome 72:ecffe56af969 2211 {
WiredHome 72:ecffe56af969 2212 BITMAPFILEHEADER BMP_Header;
WiredHome 72:ecffe56af969 2213 BITMAPINFOHEADER BMP_Info;
WiredHome 86:e86b355940f4 2214 uint8_t * lineBuffer = NULL;
WiredHome 86:e86b355940f4 2215 color_t * pixelBuffer = NULL;
WiredHome 86:e86b355940f4 2216 color_t * pixelBuffer2 = NULL;
WiredHome 86:e86b355940f4 2217
WiredHome 72:ecffe56af969 2218 INFO("(%d,%d) - (%d,%d) %s", x,y,w,h,Name_BMP);
WiredHome 105:4f116006ba1f 2219 if (x >= 0 && x < screenwidth
WiredHome 105:4f116006ba1f 2220 && y >= 0 && y < screenheight
WiredHome 105:4f116006ba1f 2221 && w > 0 && x + w <= screenwidth
WiredHome 105:4f116006ba1f 2222 && h > 0 && y + h <= screenheight) {
WiredHome 72:ecffe56af969 2223
WiredHome 72:ecffe56af969 2224 BMP_Header.bfType = BF_TYPE;
WiredHome 72:ecffe56af969 2225 BMP_Header.bfSize = (w * h * sizeof(RGBQUAD)) + sizeof(BMP_Header) + sizeof(BMP_Header);
WiredHome 72:ecffe56af969 2226 BMP_Header.bfReserved1 = 0;
WiredHome 72:ecffe56af969 2227 BMP_Header.bfReserved2 = 0;
WiredHome 72:ecffe56af969 2228 BMP_Header.bfOffBits = sizeof(BMP_Header) + sizeof(BMP_Header);
WiredHome 73:f22a18707b5e 2229
WiredHome 72:ecffe56af969 2230 BMP_Info.biSize = sizeof(BMP_Info);
WiredHome 72:ecffe56af969 2231 BMP_Info.biWidth = w;
WiredHome 72:ecffe56af969 2232 BMP_Info.biHeight = h;
WiredHome 72:ecffe56af969 2233 BMP_Info.biPlanes = 1;
WiredHome 72:ecffe56af969 2234 BMP_Info.biBitCount = 24;
WiredHome 72:ecffe56af969 2235 BMP_Info.biCompression = BI_RGB;
WiredHome 72:ecffe56af969 2236 BMP_Info.biSizeImage = 0;
WiredHome 72:ecffe56af969 2237 BMP_Info.biXPelsPerMeter = 0;
WiredHome 72:ecffe56af969 2238 BMP_Info.biYPelsPerMeter = 0;
WiredHome 72:ecffe56af969 2239 BMP_Info.biClrUsed = 0;
WiredHome 72:ecffe56af969 2240 BMP_Info.biClrImportant = 0;
WiredHome 72:ecffe56af969 2241
WiredHome 86:e86b355940f4 2242 // Allocate the memory we need to proceed
WiredHome 86:e86b355940f4 2243 int lineBufSize = ((24 * w + 7)/8);
WiredHome 145:5eb2492acdda 2244 lineBuffer = (uint8_t *)swMalloc(lineBufSize);
WiredHome 86:e86b355940f4 2245 if (lineBuffer == NULL) {
WiredHome 86:e86b355940f4 2246 ERR("Not enough RAM for PrintScreen lineBuffer");
WiredHome 86:e86b355940f4 2247 return(not_enough_ram);
WiredHome 86:e86b355940f4 2248 }
WiredHome 86:e86b355940f4 2249
WiredHome 86:e86b355940f4 2250 #define DOUBLEBUF /* one larger buffer instead of two */
WiredHome 86:e86b355940f4 2251
WiredHome 86:e86b355940f4 2252 #ifdef DOUBLEBUF
WiredHome 86:e86b355940f4 2253 // In the "#else", pixelBuffer2 malloc returns a value,
WiredHome 86:e86b355940f4 2254 // but is actually causing a failure later.
WiredHome 86:e86b355940f4 2255 // This test helps determine if it is truly out of memory,
WiredHome 86:e86b355940f4 2256 // or if malloc is broken.
WiredHome 145:5eb2492acdda 2257 pixelBuffer = (color_t *)swMalloc(2 * w * sizeof(color_t));
WiredHome 86:e86b355940f4 2258 pixelBuffer2 = pixelBuffer + (w * sizeof(color_t));
WiredHome 86:e86b355940f4 2259 #else
WiredHome 145:5eb2492acdda 2260 pixelBuffer = (color_t *)swMalloc(w * sizeof(color_t));
WiredHome 145:5eb2492acdda 2261 pixelBuffer2 = (color_t *)swMalloc(w * sizeof(color_t));
WiredHome 86:e86b355940f4 2262 #endif
WiredHome 86:e86b355940f4 2263 if (pixelBuffer == NULL || pixelBuffer2 == NULL) {
WiredHome 86:e86b355940f4 2264 ERR("Not enough RAM for pixelBuffer");
WiredHome 86:e86b355940f4 2265 #ifndef DOUBLEBUF
WiredHome 86:e86b355940f4 2266 if (pixelBuffer2)
WiredHome 145:5eb2492acdda 2267 swFree(pixelBuffer2);
WiredHome 86:e86b355940f4 2268 #endif
WiredHome 86:e86b355940f4 2269 if (pixelBuffer)
WiredHome 145:5eb2492acdda 2270 swFree(pixelBuffer);
WiredHome 145:5eb2492acdda 2271 swFree(lineBuffer);
WiredHome 86:e86b355940f4 2272 return(not_enough_ram);
WiredHome 86:e86b355940f4 2273 }
WiredHome 86:e86b355940f4 2274
WiredHome 72:ecffe56af969 2275 FILE *Image = fopen(Name_BMP, "wb");
WiredHome 72:ecffe56af969 2276 if (!Image) {
WiredHome 86:e86b355940f4 2277 ERR("Can't open file for write");
WiredHome 86:e86b355940f4 2278 #ifndef DOUBLEBUF
WiredHome 86:e86b355940f4 2279 if (pixelBuffer2)
WiredHome 145:5eb2492acdda 2280 swFree(pixelBuffer2);
WiredHome 86:e86b355940f4 2281 #endif
WiredHome 86:e86b355940f4 2282 if (pixelBuffer)
WiredHome 145:5eb2492acdda 2283 swFree(pixelBuffer);
WiredHome 145:5eb2492acdda 2284 swFree(lineBuffer);
WiredHome 72:ecffe56af969 2285 return(file_not_found);
WiredHome 72:ecffe56af969 2286 }
WiredHome 72:ecffe56af969 2287
WiredHome 72:ecffe56af969 2288 // Be optimistic - don't check for errors.
WiredHome 93:6fbc516de05e 2289 HexDump("BMP_Header", (uint8_t *)&BMP_Header, sizeof(BMP_Header));
WiredHome 95:ef538bd687c0 2290 fwrite(&BMP_Header, sizeof(char), sizeof(BMP_Header), Image);
WiredHome 73:f22a18707b5e 2291
WiredHome 93:6fbc516de05e 2292 HexDump("BMP_Info", (uint8_t *)&BMP_Info, sizeof(BMP_Info));
WiredHome 95:ef538bd687c0 2293 fwrite(&BMP_Info, sizeof(char), sizeof(BMP_Info), Image);
WiredHome 73:f22a18707b5e 2294
WiredHome 95:ef538bd687c0 2295 //color_t transparency = GetBackgroundTransparencyColor();
WiredHome 95:ef538bd687c0 2296 LayerMode_T ltpr0 = GetLayerMode();
WiredHome 73:f22a18707b5e 2297
WiredHome 73:f22a18707b5e 2298 uint16_t prevLayer = GetDrawingLayer();
WiredHome 73:f22a18707b5e 2299 // If only one of the layers is visible, select that layer
WiredHome 73:f22a18707b5e 2300 switch(ltpr0) {
WiredHome 95:ef538bd687c0 2301 case ShowLayer0:
WiredHome 73:f22a18707b5e 2302 SelectDrawingLayer(0);
WiredHome 73:f22a18707b5e 2303 break;
WiredHome 95:ef538bd687c0 2304 case ShowLayer1:
WiredHome 73:f22a18707b5e 2305 SelectDrawingLayer(1);
WiredHome 73:f22a18707b5e 2306 break;
WiredHome 73:f22a18707b5e 2307 default:
WiredHome 73:f22a18707b5e 2308 break;
WiredHome 73:f22a18707b5e 2309 }
WiredHome 73:f22a18707b5e 2310
WiredHome 72:ecffe56af969 2311 // Read the display from the last line toward the top
WiredHome 72:ecffe56af969 2312 // so we can write the file in one pass.
WiredHome 72:ecffe56af969 2313 for (int j = h - 1; j >= 0; j--) {
WiredHome 149:c62c4b2d6a15 2314 if (idle_callback) {
WiredHome 149:c62c4b2d6a15 2315 (*idle_callback)(progress, (h - 1 - j) * 100 / (h - 1));
WiredHome 149:c62c4b2d6a15 2316 }
WiredHome 149:c62c4b2d6a15 2317
WiredHome 73:f22a18707b5e 2318 if (ltpr0 >= 2) // Need to combine the layers...
WiredHome 73:f22a18707b5e 2319 SelectDrawingLayer(0); // so read layer 0 first
WiredHome 72:ecffe56af969 2320 // Read one line of pixels to a local buffer
WiredHome 72:ecffe56af969 2321 if (getPixelStream(pixelBuffer, w, x,y+j) != noerror) {
WiredHome 72:ecffe56af969 2322 ERR("getPixelStream error, and no recovery handler...");
WiredHome 72:ecffe56af969 2323 }
WiredHome 73:f22a18707b5e 2324 if (ltpr0 >= 2) { // Need to combine the layers...
WiredHome 86:e86b355940f4 2325 SelectDrawingLayer(1); // so read layer 1 next
WiredHome 73:f22a18707b5e 2326 if (getPixelStream(pixelBuffer2, w, x,y+j) != noerror) {
WiredHome 73:f22a18707b5e 2327 ERR("getPixelStream error, and no recovery handler...");
WiredHome 73:f22a18707b5e 2328 }
WiredHome 73:f22a18707b5e 2329 }
WiredHome 93:6fbc516de05e 2330 INFO("1st Color: %04X", pixelBuffer[0]);
WiredHome 93:6fbc516de05e 2331 HexDump("Raster", (uint8_t *)pixelBuffer, w);
WiredHome 72:ecffe56af969 2332 // Convert the local buffer to RGBQUAD format
WiredHome 72:ecffe56af969 2333 int lb = 0;
WiredHome 72:ecffe56af969 2334 for (int i=0; i<w; i++) {
WiredHome 73:f22a18707b5e 2335 RGBQUAD q0 = RGB16ToRGBQuad(pixelBuffer[x+i]); // Scale to 24-bits
WiredHome 73:f22a18707b5e 2336 RGBQUAD q1 = RGB16ToRGBQuad(pixelBuffer2[x+i]); // Scale to 24-bits
WiredHome 73:f22a18707b5e 2337 switch (ltpr0) {
WiredHome 73:f22a18707b5e 2338 case 0:
WiredHome 73:f22a18707b5e 2339 case 1:
WiredHome 73:f22a18707b5e 2340 case 2: // lighten-overlay (@TODO Not supported yet)
WiredHome 73:f22a18707b5e 2341 case 6: // Floating Windows (@TODO not sure how to support)
WiredHome 73:f22a18707b5e 2342 default: // Reserved...
WiredHome 73:f22a18707b5e 2343 lineBuffer[lb++] = q0.rgbBlue;
WiredHome 73:f22a18707b5e 2344 lineBuffer[lb++] = q0.rgbGreen;
WiredHome 73:f22a18707b5e 2345 lineBuffer[lb++] = q0.rgbRed;
WiredHome 73:f22a18707b5e 2346 break;
WiredHome 73:f22a18707b5e 2347 case 3: // transparent mode (@TODO Read the background color register for transparent)
WiredHome 73:f22a18707b5e 2348 case 4: // boolean or
WiredHome 73:f22a18707b5e 2349 lineBuffer[lb++] = q0.rgbBlue | q1.rgbBlue;
WiredHome 73:f22a18707b5e 2350 lineBuffer[lb++] = q0.rgbGreen | q1.rgbGreen;
WiredHome 73:f22a18707b5e 2351 lineBuffer[lb++] = q0.rgbRed | q1.rgbRed;
WiredHome 73:f22a18707b5e 2352 break;
WiredHome 73:f22a18707b5e 2353 case 5: // boolean AND
WiredHome 73:f22a18707b5e 2354 lineBuffer[lb++] = q0.rgbBlue & q1.rgbBlue;
WiredHome 73:f22a18707b5e 2355 lineBuffer[lb++] = q0.rgbGreen & q1.rgbGreen;
WiredHome 73:f22a18707b5e 2356 lineBuffer[lb++] = q0.rgbRed & q1.rgbRed;
WiredHome 73:f22a18707b5e 2357 break;
WiredHome 73:f22a18707b5e 2358 }
WiredHome 72:ecffe56af969 2359 }
WiredHome 95:ef538bd687c0 2360 if (j == h - 1) {
WiredHome 73:f22a18707b5e 2361 HexDump("Line", lineBuffer, lineBufSize);
WiredHome 95:ef538bd687c0 2362 }
WiredHome 72:ecffe56af969 2363 // Write to disk
WiredHome 72:ecffe56af969 2364 fwrite(lineBuffer, sizeof(char), lb, Image);
WiredHome 72:ecffe56af969 2365 }
WiredHome 73:f22a18707b5e 2366 SelectDrawingLayer(prevLayer);
WiredHome 72:ecffe56af969 2367 fclose(Image);
WiredHome 86:e86b355940f4 2368 #ifndef DOUBLEBUF
WiredHome 86:e86b355940f4 2369 if (pixelBuffer2)
WiredHome 145:5eb2492acdda 2370 swFree(pixelBuffer2);
WiredHome 86:e86b355940f4 2371 #endif
WiredHome 86:e86b355940f4 2372 if (pixelBuffer)
WiredHome 145:5eb2492acdda 2373 swFree(pixelBuffer);
WiredHome 145:5eb2492acdda 2374 swFree(lineBuffer);
WiredHome 73:f22a18707b5e 2375 INFO("Image closed");
WiredHome 72:ecffe56af969 2376 return noerror;
WiredHome 72:ecffe56af969 2377 } else {
WiredHome 72:ecffe56af969 2378 return bad_parameter;
WiredHome 72:ecffe56af969 2379 }
WiredHome 72:ecffe56af969 2380 }
WiredHome 72:ecffe56af969 2381
WiredHome 72:ecffe56af969 2382
WiredHome 72:ecffe56af969 2383 // ##########################################################################
WiredHome 72:ecffe56af969 2384 // ##########################################################################
WiredHome 72:ecffe56af969 2385 // ##########################################################################
WiredHome 72:ecffe56af969 2386
WiredHome 23:a50ded45dbaf 2387 #ifdef TESTENABLE
WiredHome 23:a50ded45dbaf 2388
WiredHome 98:ecebed9b80b2 2389 #include "BPG_Arial08x08.h"
WiredHome 98:ecebed9b80b2 2390 #include "BPG_Arial20x20.h"
WiredHome 37:f19b7e7449dc 2391
WiredHome 23:a50ded45dbaf 2392 // ______________ ______________ ______________ _______________
WiredHome 23:a50ded45dbaf 2393 // /_____ _____/ / ___________/ / ___________/ /_____ ______/
WiredHome 23:a50ded45dbaf 2394 // / / / / / / / /
WiredHome 23:a50ded45dbaf 2395 // / / / /___ / /__________ / /
WiredHome 23:a50ded45dbaf 2396 // / / / ____/ /__________ / / /
WiredHome 23:a50ded45dbaf 2397 // / / / / / / / /
WiredHome 23:a50ded45dbaf 2398 // / / / /__________ ___________/ / / /
WiredHome 23:a50ded45dbaf 2399 // /__/ /_____________/ /_____________/ /__/
WiredHome 23:a50ded45dbaf 2400 //
WiredHome 23:a50ded45dbaf 2401 // Everything from here down is test code.
WiredHome 75:ca78388cfd77 2402 //
WiredHome 41:2956a0a221e5 2403 bool SuppressSlowStuff = false;
WiredHome 23:a50ded45dbaf 2404
WiredHome 49:c5182231d1b9 2405 void TextWrapTest(RA8875 & display, Serial & pc)
WiredHome 49:c5182231d1b9 2406 {
WiredHome 49:c5182231d1b9 2407 if (!SuppressSlowStuff)
WiredHome 49:c5182231d1b9 2408 pc.printf("Text Wrap Test\r\n");
WiredHome 49:c5182231d1b9 2409 display.background(Black);
WiredHome 49:c5182231d1b9 2410 display.foreground(Blue);
WiredHome 49:c5182231d1b9 2411 display.cls();
WiredHome 49:c5182231d1b9 2412 display.Backlight_u8(255);
WiredHome 100:0b084475d5a9 2413 display.puts("Text Wrap Test.\r\n");
WiredHome 52:e6039a823420 2414 for (int i=1; i<60; i++) {
WiredHome 52:e6039a823420 2415 display.printf("L%2d\n", i % 17);
WiredHome 49:c5182231d1b9 2416 if (!SuppressSlowStuff)
WiredHome 52:e6039a823420 2417 wait_ms(100);
WiredHome 49:c5182231d1b9 2418 }
WiredHome 49:c5182231d1b9 2419 if (!SuppressSlowStuff)
WiredHome 49:c5182231d1b9 2420 wait_ms(3000);
WiredHome 49:c5182231d1b9 2421 }
WiredHome 49:c5182231d1b9 2422
WiredHome 75:ca78388cfd77 2423
WiredHome 75:ca78388cfd77 2424 void ShowKey(RA8875 & display, int key)
WiredHome 75:ca78388cfd77 2425 {
WiredHome 75:ca78388cfd77 2426 loc_t col, row;
WiredHome 75:ca78388cfd77 2427 dim_t r1 = 25;
WiredHome 75:ca78388cfd77 2428 color_t color = (key & 0x80) ? Red : Green;
WiredHome 75:ca78388cfd77 2429
WiredHome 75:ca78388cfd77 2430 key &= 0x7F; // remove the long-press flag
WiredHome 75:ca78388cfd77 2431 row = (key - 1) / 5;
WiredHome 75:ca78388cfd77 2432 col = (key - 1) % 5;
WiredHome 75:ca78388cfd77 2433 if (col > 5) col = 5;
WiredHome 75:ca78388cfd77 2434 if (row > 4) row = 4;
WiredHome 75:ca78388cfd77 2435 display.circle(450 - + (2 * r1) * col, 200 - (2 * r1) * row, r1-2, color, FILL);
WiredHome 75:ca78388cfd77 2436 }
WiredHome 75:ca78388cfd77 2437
WiredHome 75:ca78388cfd77 2438 void HideKey(RA8875 & display, int key)
WiredHome 75:ca78388cfd77 2439 {
WiredHome 75:ca78388cfd77 2440 loc_t col, row;
WiredHome 75:ca78388cfd77 2441 dim_t r1 = 25;
WiredHome 75:ca78388cfd77 2442
WiredHome 75:ca78388cfd77 2443 row = (key - 1) / 5;
WiredHome 75:ca78388cfd77 2444 col = (key - 1) % 5;
WiredHome 75:ca78388cfd77 2445 if (col > 5) col = 5;
WiredHome 75:ca78388cfd77 2446 if (row > 4) row = 4;
WiredHome 75:ca78388cfd77 2447 display.background(Black);
WiredHome 75:ca78388cfd77 2448 display.circle(450 - (2 * r1) * col, 200 - (2 * r1) * row, r1-2, Black, FILL);
WiredHome 75:ca78388cfd77 2449 display.circle(450 - (2 * r1) * col, 200 - (2 * r1) * row, r1-2, Blue);
WiredHome 75:ca78388cfd77 2450 }
WiredHome 75:ca78388cfd77 2451
WiredHome 75:ca78388cfd77 2452 void KeyPadTest(RA8875 & display, Serial & pc)
WiredHome 75:ca78388cfd77 2453 {
WiredHome 75:ca78388cfd77 2454 const uint8_t myMap[22] = {
WiredHome 77:9206c13aa527 2455 0,
WiredHome 75:ca78388cfd77 2456 'a', 'b', 'c', 'd', 'e',
WiredHome 75:ca78388cfd77 2457 'f', 'g', 'h', 'i', 'j',
WiredHome 75:ca78388cfd77 2458 'k', 'l', 'm', 'n', 'o',
WiredHome 75:ca78388cfd77 2459 'p', 'q', 'r', 's', 't',
WiredHome 75:ca78388cfd77 2460 'x'
WiredHome 75:ca78388cfd77 2461 };
WiredHome 77:9206c13aa527 2462
WiredHome 75:ca78388cfd77 2463 display.background(Black);
WiredHome 75:ca78388cfd77 2464 display.foreground(Blue);
WiredHome 75:ca78388cfd77 2465 display.cls();
WiredHome 75:ca78388cfd77 2466 display.Backlight_u8(255);
WiredHome 100:0b084475d5a9 2467 display.puts("KeyPad Test. Touch the keypad...");
WiredHome 75:ca78388cfd77 2468 pc.printf("\r\n"
WiredHome 75:ca78388cfd77 2469 "Raw KeyPad Test. Keypad returns the key-number.\r\n"
WiredHome 75:ca78388cfd77 2470 "Press [most] any PC keyboard key to advance to next test.\r\n");
WiredHome 75:ca78388cfd77 2471 RetCode_t ret = display.KeypadInit(true, true, 3, 7, 3);
WiredHome 75:ca78388cfd77 2472 if (ret != noerror)
WiredHome 75:ca78388cfd77 2473 pc.printf("returncode from KeypadInit is %d\r\n", ret);
WiredHome 75:ca78388cfd77 2474 int lastKey = 0;
WiredHome 75:ca78388cfd77 2475 while (!pc.readable()) {
WiredHome 75:ca78388cfd77 2476 if (display.readable()) {
WiredHome 75:ca78388cfd77 2477 int key = display.getc();
WiredHome 75:ca78388cfd77 2478 if (key) {
WiredHome 75:ca78388cfd77 2479 if (((key & 0x7F) != lastKey) && (lastKey != 0))
WiredHome 75:ca78388cfd77 2480 HideKey(display, lastKey);
WiredHome 75:ca78388cfd77 2481 ShowKey(display, key);
WiredHome 75:ca78388cfd77 2482 lastKey = key & 0x7F;
WiredHome 75:ca78388cfd77 2483 } else {
WiredHome 75:ca78388cfd77 2484 // erase the last one
WiredHome 75:ca78388cfd77 2485 if (lastKey)
WiredHome 75:ca78388cfd77 2486 HideKey(display, lastKey);
WiredHome 75:ca78388cfd77 2487 }
WiredHome 75:ca78388cfd77 2488 }
WiredHome 75:ca78388cfd77 2489 }
WiredHome 75:ca78388cfd77 2490 (void)pc.getc();
WiredHome 75:ca78388cfd77 2491 pc.printf("\r\n"
WiredHome 75:ca78388cfd77 2492 "Map KeyPad Test. Keypad returns the remapped key 'a' - 't'.\r\n"
WiredHome 75:ca78388cfd77 2493 "Press [most] any PC keyboard key to advance to exit test.\r\n");
WiredHome 75:ca78388cfd77 2494 display.SetKeyMap(myMap);
WiredHome 75:ca78388cfd77 2495 while (!pc.readable()) {
WiredHome 75:ca78388cfd77 2496 if (display.readable()) {
WiredHome 75:ca78388cfd77 2497 int key = display.getc();
WiredHome 75:ca78388cfd77 2498 bool longPress = key & 0x80;
WiredHome 75:ca78388cfd77 2499 display.SetTextCursor(0, 120);
WiredHome 75:ca78388cfd77 2500 display.printf("Long Press: %d\r\n", longPress);
WiredHome 75:ca78388cfd77 2501 display.printf(" Remapped: %c %02X\r\n", (key) ? key & 0x7F : ' ', key);
WiredHome 75:ca78388cfd77 2502 }
WiredHome 75:ca78388cfd77 2503 }
WiredHome 75:ca78388cfd77 2504 (void)pc.getc();
WiredHome 75:ca78388cfd77 2505 display.SetKeyMap();
WiredHome 75:ca78388cfd77 2506 pc.printf("\r\n");
WiredHome 75:ca78388cfd77 2507 }
WiredHome 75:ca78388cfd77 2508
WiredHome 23:a50ded45dbaf 2509 void TextCursorTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2510 {
WiredHome 75:ca78388cfd77 2511 const char * iCursor = "The I-Beam cursor should be visible for this text.\r\n";
WiredHome 75:ca78388cfd77 2512 const char * uCursor = "The Underscore cursor should be visible for this text.\r\n";
WiredHome 75:ca78388cfd77 2513 const char * bCursor = "The Block cursor should be visible for this text.\r\n";
WiredHome 37:f19b7e7449dc 2514 const char * bbCursor = "The Blinking Block cursor should be visible for this text.\r\n";
WiredHome 23:a50ded45dbaf 2515 const char * p;
WiredHome 100:0b084475d5a9 2516 int delay = 60;
WiredHome 73:f22a18707b5e 2517
WiredHome 41:2956a0a221e5 2518 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2519 pc.printf("Text Cursor Test\r\n");
WiredHome 73:f22a18707b5e 2520 else
WiredHome 41:2956a0a221e5 2521 delay = 0;
WiredHome 23:a50ded45dbaf 2522 display.background(Black);
WiredHome 23:a50ded45dbaf 2523 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2524 display.cls();
WiredHome 25:9556a3a9b7cc 2525 display.Backlight_u8(255);
WiredHome 100:0b084475d5a9 2526 display.puts("Text Cursor Test.");
WiredHome 73:f22a18707b5e 2527
WiredHome 23:a50ded45dbaf 2528 // visible, non-blinking
WiredHome 24:8ca861acf12d 2529 display.SetTextCursor(0,20);
WiredHome 53:86d24b9480b9 2530 display.SetTextCursorControl(RA8875::IBEAM, false);
WiredHome 24:8ca861acf12d 2531 p = iCursor;
WiredHome 23:a50ded45dbaf 2532 while (*p) {
WiredHome 24:8ca861acf12d 2533 display._putc(*p++);
WiredHome 41:2956a0a221e5 2534 wait_ms(delay);
WiredHome 24:8ca861acf12d 2535 }
WiredHome 24:8ca861acf12d 2536
WiredHome 53:86d24b9480b9 2537 display.SetTextCursorControl(RA8875::UNDER, false);
WiredHome 24:8ca861acf12d 2538 p = uCursor;
WiredHome 24:8ca861acf12d 2539 while (*p) {
WiredHome 24:8ca861acf12d 2540 display._putc(*p++);
WiredHome 41:2956a0a221e5 2541 wait_ms(delay);
WiredHome 23:a50ded45dbaf 2542 }
WiredHome 73:f22a18707b5e 2543
WiredHome 53:86d24b9480b9 2544 display.SetTextCursorControl(RA8875::BLOCK, false);
WiredHome 24:8ca861acf12d 2545 p = bCursor;
WiredHome 24:8ca861acf12d 2546 while (*p) {
WiredHome 24:8ca861acf12d 2547 display._putc(*p++);
WiredHome 41:2956a0a221e5 2548 wait_ms(delay);
WiredHome 24:8ca861acf12d 2549 }
WiredHome 24:8ca861acf12d 2550
WiredHome 53:86d24b9480b9 2551 display.SetTextCursorControl(RA8875::BLOCK, true);
WiredHome 24:8ca861acf12d 2552 p = bbCursor;
WiredHome 24:8ca861acf12d 2553 while (*p) {
WiredHome 24:8ca861acf12d 2554 display._putc(*p++);
WiredHome 41:2956a0a221e5 2555 wait_ms(delay);
WiredHome 24:8ca861acf12d 2556 }
WiredHome 41:2956a0a221e5 2557 wait_ms(delay * 20);
WiredHome 53:86d24b9480b9 2558 display.SetTextCursorControl(RA8875::NOCURSOR, false);
WiredHome 23:a50ded45dbaf 2559 }
WiredHome 23:a50ded45dbaf 2560
WiredHome 44:207594dece70 2561
WiredHome 23:a50ded45dbaf 2562 void BacklightTest(RA8875 & display, Serial & pc, float ramptime)
WiredHome 23:a50ded45dbaf 2563 {
WiredHome 29:422616aa04bd 2564 char buf[60];
WiredHome 41:2956a0a221e5 2565 unsigned int w = (ramptime * 1000)/ 256;
WiredHome 41:2956a0a221e5 2566 int delay = 200;
WiredHome 41:2956a0a221e5 2567
WiredHome 41:2956a0a221e5 2568 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2569 pc.printf("Backlight Test - ramp over %f sec.\r\n", ramptime);
WiredHome 41:2956a0a221e5 2570 else {
WiredHome 41:2956a0a221e5 2571 delay = 0;
WiredHome 41:2956a0a221e5 2572 w = 0;
WiredHome 41:2956a0a221e5 2573 }
WiredHome 23:a50ded45dbaf 2574 display.Backlight_u8(0);
WiredHome 29:422616aa04bd 2575 display.background(White);
WiredHome 23:a50ded45dbaf 2576 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2577 display.cls();
WiredHome 100:0b084475d5a9 2578 display.puts("RA8875 Backlight Test - Ramp up.");
WiredHome 41:2956a0a221e5 2579 wait_ms(delay);
WiredHome 38:38d503b4fad6 2580 for (int i=0; i <= 255; i++) {
WiredHome 141:2ec78a50dc98 2581 snprintf(buf, sizeof(buf), "%3d, %4d", i, w);
WiredHome 37:f19b7e7449dc 2582 display.puts(100,100,buf);
WiredHome 23:a50ded45dbaf 2583 display.Backlight_u8(i);
WiredHome 29:422616aa04bd 2584 wait_ms(w);
WiredHome 23:a50ded45dbaf 2585 }
WiredHome 23:a50ded45dbaf 2586 }
WiredHome 23:a50ded45dbaf 2587
WiredHome 44:207594dece70 2588
WiredHome 23:a50ded45dbaf 2589 void BacklightTest2(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2590 {
WiredHome 41:2956a0a221e5 2591 int delay = 20;
WiredHome 41:2956a0a221e5 2592
WiredHome 41:2956a0a221e5 2593 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2594 pc.printf("Backlight Test 2\r\n");
WiredHome 41:2956a0a221e5 2595 else
WiredHome 41:2956a0a221e5 2596 delay = 0;
WiredHome 41:2956a0a221e5 2597
WiredHome 23:a50ded45dbaf 2598 // Dim it out at the end of the tests.
WiredHome 37:f19b7e7449dc 2599 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2600 display.puts(0,0, "Ramp Backlight down.");
WiredHome 23:a50ded45dbaf 2601 // Ramp it off
WiredHome 23:a50ded45dbaf 2602 for (int i=255; i != 0; i--) {
WiredHome 23:a50ded45dbaf 2603 display.Backlight_u8(i);
WiredHome 41:2956a0a221e5 2604 wait_ms(delay);
WiredHome 23:a50ded45dbaf 2605 }
WiredHome 23:a50ded45dbaf 2606 display.Backlight_u8(0);
WiredHome 23:a50ded45dbaf 2607 }
WiredHome 23:a50ded45dbaf 2608
WiredHome 44:207594dece70 2609
WiredHome 23:a50ded45dbaf 2610 void ExternalFontTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2611 {
WiredHome 41:2956a0a221e5 2612 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2613 pc.printf("External Font Test\r\n");
WiredHome 23:a50ded45dbaf 2614 display.background(Black);
WiredHome 23:a50ded45dbaf 2615 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2616 display.cls();
WiredHome 100:0b084475d5a9 2617 display.puts("External Font Test.");
WiredHome 23:a50ded45dbaf 2618 display.Backlight(1);
WiredHome 37:f19b7e7449dc 2619
WiredHome 98:ecebed9b80b2 2620 display.SelectUserFont(BPG_Arial08x08);
WiredHome 73:f22a18707b5e 2621 display.puts(0,30, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\r\n");
WiredHome 37:f19b7e7449dc 2622
WiredHome 98:ecebed9b80b2 2623 display.SelectUserFont(BPG_Arial20x20);
WiredHome 37:f19b7e7449dc 2624 display.puts("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\r\n");
WiredHome 98:ecebed9b80b2 2625
WiredHome 98:ecebed9b80b2 2626 display.SelectUserFont();
WiredHome 73:f22a18707b5e 2627
WiredHome 37:f19b7e7449dc 2628 display.puts("Normal font again.");
WiredHome 37:f19b7e7449dc 2629 //display.window(0,0, display.width(), display.height());
WiredHome 23:a50ded45dbaf 2630 }
WiredHome 23:a50ded45dbaf 2631
WiredHome 44:207594dece70 2632
WiredHome 23:a50ded45dbaf 2633 void DOSColorTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2634 {
WiredHome 41:2956a0a221e5 2635 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2636 pc.printf("DOS Color Test\r\n");
WiredHome 23:a50ded45dbaf 2637 display.background(Black);
WiredHome 23:a50ded45dbaf 2638 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2639 display.cls();
WiredHome 100:0b084475d5a9 2640 display.puts("DOS Colors - Fore");
WiredHome 23:a50ded45dbaf 2641 display.puts(280,0, "Back");
WiredHome 23:a50ded45dbaf 2642 display.background(Gray);
WiredHome 23:a50ded45dbaf 2643 for (int i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2644 display.foreground(display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2645 display.puts(160, i*16, display.DOSColorNames(i));
WiredHome 23:a50ded45dbaf 2646 display.background(Black);
WiredHome 23:a50ded45dbaf 2647 }
WiredHome 23:a50ded45dbaf 2648 display.foreground(White);
WiredHome 23:a50ded45dbaf 2649 for (int i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2650 display.background(display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2651 display.puts(360, i*16, display.DOSColorNames(i));
WiredHome 23:a50ded45dbaf 2652 display.foreground(White);
WiredHome 23:a50ded45dbaf 2653 }
WiredHome 23:a50ded45dbaf 2654 }
WiredHome 23:a50ded45dbaf 2655
WiredHome 44:207594dece70 2656
WiredHome 23:a50ded45dbaf 2657 void WebColorTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2658 {
WiredHome 41:2956a0a221e5 2659 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2660 pc.printf("Web Color Test\r\n");
WiredHome 23:a50ded45dbaf 2661 display.background(Black);
WiredHome 23:a50ded45dbaf 2662 display.foreground(Blue);
WiredHome 32:0e4f2ae512e2 2663 display.window(0,0, display.width(), display.height());
WiredHome 23:a50ded45dbaf 2664 display.cls();
WiredHome 59:fb40aad4efd4 2665 display.SetTextFontSize(1,1);
WiredHome 59:fb40aad4efd4 2666 display.puts(200,0, "Web Color Test");
WiredHome 59:fb40aad4efd4 2667 display.SetTextCursor(0,0);
WiredHome 59:fb40aad4efd4 2668 display.puts(" ");
WiredHome 59:fb40aad4efd4 2669 for (int i=0; i<16; i++)
WiredHome 59:fb40aad4efd4 2670 display.printf("%X", i&0xF);
WiredHome 59:fb40aad4efd4 2671 display.puts("\r\n0 ");
WiredHome 23:a50ded45dbaf 2672 for (int i=0; i<sizeof(WebColors)/sizeof(WebColors[0]); i++) {
WiredHome 23:a50ded45dbaf 2673 display.background(WebColors[i]);
WiredHome 23:a50ded45dbaf 2674 display.puts(" ");
WiredHome 59:fb40aad4efd4 2675 if (i % 16 == 15 && i < 255) {
WiredHome 59:fb40aad4efd4 2676 display.printf("\r\n%X ", ((i+1)/16));
WiredHome 59:fb40aad4efd4 2677 }
WiredHome 23:a50ded45dbaf 2678 }
WiredHome 23:a50ded45dbaf 2679 display.SetTextFontSize(1,1);
WiredHome 23:a50ded45dbaf 2680 }
WiredHome 23:a50ded45dbaf 2681
WiredHome 44:207594dece70 2682
WiredHome 37:f19b7e7449dc 2683 void PixelTest(RA8875 & display, Serial & pc)
WiredHome 37:f19b7e7449dc 2684 {
WiredHome 37:f19b7e7449dc 2685 int i, c, x, y;
WiredHome 37:f19b7e7449dc 2686
WiredHome 41:2956a0a221e5 2687 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2688 pc.printf("Pixel Test\r\n");
WiredHome 37:f19b7e7449dc 2689 display.background(Black);
WiredHome 37:f19b7e7449dc 2690 display.foreground(Blue);
WiredHome 37:f19b7e7449dc 2691 display.cls();
WiredHome 100:0b084475d5a9 2692 display.puts("Pixel Test");
WiredHome 37:f19b7e7449dc 2693 for (i=0; i<1000; i++) {
WiredHome 37:f19b7e7449dc 2694 x = rand() % 480;
WiredHome 37:f19b7e7449dc 2695 y = 16 + rand() % (272-16);
WiredHome 37:f19b7e7449dc 2696 c = rand() % 16;
WiredHome 37:f19b7e7449dc 2697 //pc.printf(" (%d,%d) - %d\r\n", x,y,r1);
WiredHome 37:f19b7e7449dc 2698 display.pixel(x,y, display.DOSColor(c));
WiredHome 37:f19b7e7449dc 2699 }
WiredHome 37:f19b7e7449dc 2700 }
WiredHome 37:f19b7e7449dc 2701
WiredHome 44:207594dece70 2702
WiredHome 23:a50ded45dbaf 2703 void LineTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2704 {
WiredHome 23:a50ded45dbaf 2705 int i, x, y, x2, y2;
WiredHome 23:a50ded45dbaf 2706
WiredHome 41:2956a0a221e5 2707 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2708 pc.printf("Line Test\r\n");
WiredHome 23:a50ded45dbaf 2709 display.background(Black);
WiredHome 23:a50ded45dbaf 2710 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2711 display.cls();
WiredHome 100:0b084475d5a9 2712 display.puts("Line Test");
WiredHome 23:a50ded45dbaf 2713 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2714 // Lines
WiredHome 23:a50ded45dbaf 2715 x = rand() % 480;
WiredHome 23:a50ded45dbaf 2716 y = rand() % 272;
WiredHome 23:a50ded45dbaf 2717 x2 = rand() % 480;
WiredHome 23:a50ded45dbaf 2718 y2 = rand() % 272;
WiredHome 23:a50ded45dbaf 2719 display.line(x,y, x2,y2, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2720 }
WiredHome 62:ba5d33438fda 2721 display.foreground(BrightRed);
WiredHome 62:ba5d33438fda 2722 display.foreground(BrightGreen);
WiredHome 62:ba5d33438fda 2723 display.foreground(BrightBlue);
WiredHome 62:ba5d33438fda 2724 display.line(55,50, 79,74, BrightRed);
WiredHome 62:ba5d33438fda 2725 display.line(57,50, 81,74, BrightGreen);
WiredHome 62:ba5d33438fda 2726 display.line(59,50, 83,74, BrightBlue);
WiredHome 62:ba5d33438fda 2727 // horz
WiredHome 62:ba5d33438fda 2728 display.line(30,40, 32,40, BrightRed);
WiredHome 62:ba5d33438fda 2729 display.line(30,42, 32,42, BrightGreen);
WiredHome 62:ba5d33438fda 2730 display.line(30,44, 32,44, BrightBlue);
WiredHome 62:ba5d33438fda 2731 // vert
WiredHome 62:ba5d33438fda 2732 display.line(20,40, 20,42, BrightRed);
WiredHome 62:ba5d33438fda 2733 display.line(22,40, 22,42, BrightGreen);
WiredHome 62:ba5d33438fda 2734 display.line(24,40, 24,42, BrightBlue);
WiredHome 62:ba5d33438fda 2735 // compare point to line-point
WiredHome 62:ba5d33438fda 2736 display.pixel(20,50, BrightRed);
WiredHome 62:ba5d33438fda 2737 display.pixel(22,50, BrightGreen);
WiredHome 62:ba5d33438fda 2738 display.pixel(24,50, BrightBlue);
WiredHome 62:ba5d33438fda 2739 display.line(20,52, 20,52, BrightRed);
WiredHome 62:ba5d33438fda 2740 display.line(22,52, 22,52, BrightGreen);
WiredHome 62:ba5d33438fda 2741 display.line(24,52, 24,52, BrightBlue);
WiredHome 73:f22a18707b5e 2742
WiredHome 62:ba5d33438fda 2743 // point
WiredHome 62:ba5d33438fda 2744 display.line(50,50, 50,50, Red);
WiredHome 62:ba5d33438fda 2745 display.line(52,52, 52,52, Green);
WiredHome 62:ba5d33438fda 2746 display.line(54,54, 54,54, Blue);
WiredHome 62:ba5d33438fda 2747 display.line(60,60, 60,60, BrightRed);
WiredHome 62:ba5d33438fda 2748 display.line(62,62, 62,62, BrightGreen);
WiredHome 62:ba5d33438fda 2749 display.line(64,64, 64,64, BrightBlue);
WiredHome 62:ba5d33438fda 2750 display.line(70,70, 70,70, DarkRed);
WiredHome 62:ba5d33438fda 2751 display.line(72,72, 72,72, DarkGreen);
WiredHome 62:ba5d33438fda 2752 display.line(74,74, 74,74, DarkBlue);
WiredHome 23:a50ded45dbaf 2753 }
WiredHome 23:a50ded45dbaf 2754
WiredHome 44:207594dece70 2755
WiredHome 23:a50ded45dbaf 2756 void RectangleTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2757 {
WiredHome 23:a50ded45dbaf 2758 int i, x1,y1, x2,y2;
WiredHome 23:a50ded45dbaf 2759
WiredHome 41:2956a0a221e5 2760 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2761 pc.printf("Rectangle Test\r\n");
WiredHome 23:a50ded45dbaf 2762 display.background(Black);
WiredHome 23:a50ded45dbaf 2763 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2764 display.cls();
WiredHome 100:0b084475d5a9 2765 display.puts("Rectangle Test");
WiredHome 23:a50ded45dbaf 2766 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2767 x1 = rand() % 240;
WiredHome 23:a50ded45dbaf 2768 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2769 x2 = rand() % 240;
WiredHome 23:a50ded45dbaf 2770 y2 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2771 display.rect(x1,y1, x2,y2, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2772
WiredHome 23:a50ded45dbaf 2773 x1 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 2774 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2775 x2 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 2776 y2 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2777 display.rect(x1,y1, x2,y2, FILL);
WiredHome 23:a50ded45dbaf 2778 }
WiredHome 23:a50ded45dbaf 2779 }
WiredHome 23:a50ded45dbaf 2780
WiredHome 44:207594dece70 2781
WiredHome 44:207594dece70 2782 void LayerTest(RA8875 & display, Serial & pc)
WiredHome 44:207594dece70 2783 {
WiredHome 44:207594dece70 2784 loc_t i, x1,y1, x2,y2, r1,r2;
WiredHome 44:207594dece70 2785
WiredHome 44:207594dece70 2786 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2787 pc.printf("Layer Test\r\n");
WiredHome 44:207594dece70 2788
WiredHome 50:2c4f474a2453 2789 display.SelectDrawingLayer(0);
WiredHome 44:207594dece70 2790 display.background(Black);
WiredHome 44:207594dece70 2791 display.foreground(Blue);
WiredHome 44:207594dece70 2792 display.cls();
WiredHome 100:0b084475d5a9 2793 display.puts("Layer 0");
WiredHome 44:207594dece70 2794 for (i=0; i<16; i++) {
WiredHome 44:207594dece70 2795 x1 = rand() % 240;
WiredHome 44:207594dece70 2796 y1 = 50 + rand() % 200;
WiredHome 44:207594dece70 2797 x2 = x1 + rand() % 100;
WiredHome 44:207594dece70 2798 y2 = y1 + rand() % 100;
WiredHome 44:207594dece70 2799 r1 = rand() % (x2 - x1)/2;
WiredHome 44:207594dece70 2800 r2 = rand() % (y2 - y1)/2;
WiredHome 44:207594dece70 2801 display.roundrect(x1,y1, x2,y2, r1,r2, display.DOSColor(i));
WiredHome 44:207594dece70 2802 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2803 wait_ms(20);
WiredHome 44:207594dece70 2804 }
WiredHome 44:207594dece70 2805 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2806 wait_ms(1000);
WiredHome 44:207594dece70 2807
WiredHome 50:2c4f474a2453 2808 display.SelectDrawingLayer(1);
WiredHome 44:207594dece70 2809 display.background(Black);
WiredHome 44:207594dece70 2810 display.foreground(Yellow);
WiredHome 44:207594dece70 2811 display.cls();
WiredHome 44:207594dece70 2812 display.puts(240,0, "Layer 1");
WiredHome 44:207594dece70 2813 for (i=0; i<16; i++) {
WiredHome 44:207594dece70 2814 x1 = 300 + rand() % 100;
WiredHome 44:207594dece70 2815 y1 = 70 + rand() % 200;
WiredHome 44:207594dece70 2816 r1 = rand() % min(y1 - 20, 100);
WiredHome 44:207594dece70 2817 display.circle(x1,y1,r1, display.DOSColor(i));
WiredHome 44:207594dece70 2818 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2819 wait_ms(20);
WiredHome 44:207594dece70 2820 }
WiredHome 56:7a85d226ad0d 2821 display.SetLayerMode(RA8875::ShowLayer1); // Show it after the build-up
WiredHome 44:207594dece70 2822 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2823 wait_ms(2000);
WiredHome 44:207594dece70 2824
WiredHome 50:2c4f474a2453 2825 display.SelectDrawingLayer(0);
WiredHome 56:7a85d226ad0d 2826 display.SetLayerMode(RA8875::ShowLayer0); // Show Layer 0 again
WiredHome 44:207594dece70 2827 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2828 wait_ms(1000);
WiredHome 53:86d24b9480b9 2829 display.SetLayerMode(RA8875::TransparentMode); // Transparent mode
WiredHome 44:207594dece70 2830 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2831 wait_ms(1000);
WiredHome 44:207594dece70 2832 for (i=0; i<=8; i++) {
WiredHome 44:207594dece70 2833 display.SetLayerTransparency(i, 8-i);
WiredHome 44:207594dece70 2834 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2835 wait_ms(200);
WiredHome 44:207594dece70 2836 }
WiredHome 73:f22a18707b5e 2837
WiredHome 44:207594dece70 2838 // Restore before we exit
WiredHome 44:207594dece70 2839 display.SetLayerTransparency(0, 0);
WiredHome 56:7a85d226ad0d 2840 display.SetLayerMode(RA8875::ShowLayer0); // Restore to layer 0
WiredHome 44:207594dece70 2841 }
WiredHome 44:207594dece70 2842
WiredHome 44:207594dece70 2843
WiredHome 23:a50ded45dbaf 2844 void RoundRectTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2845 {
WiredHome 37:f19b7e7449dc 2846 loc_t i, x1,y1, x2,y2, r1,r2;
WiredHome 23:a50ded45dbaf 2847
WiredHome 41:2956a0a221e5 2848 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2849 pc.printf("Round Rectangle Test\r\n");
WiredHome 23:a50ded45dbaf 2850 display.background(Black);
WiredHome 23:a50ded45dbaf 2851 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2852 display.cls();
WiredHome 100:0b084475d5a9 2853 display.puts("Rounded Rectangle Test");
WiredHome 73:f22a18707b5e 2854
WiredHome 23:a50ded45dbaf 2855 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2856 x1 = rand() % 240;
WiredHome 23:a50ded45dbaf 2857 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2858 x2 = x1 + rand() % 100;
WiredHome 23:a50ded45dbaf 2859 y2 = y1 + rand() % 100;
WiredHome 23:a50ded45dbaf 2860 r1 = rand() % (x2 - x1)/2;
WiredHome 23:a50ded45dbaf 2861 r2 = rand() % (y2 - y1)/2;
WiredHome 23:a50ded45dbaf 2862 display.roundrect(x1,y1, x2,y2, 5,8, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2863
WiredHome 23:a50ded45dbaf 2864 x1 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 2865 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2866 x2 = x1 + rand() % 100;
WiredHome 23:a50ded45dbaf 2867 y2 = y1 + rand() % 100;
WiredHome 23:a50ded45dbaf 2868 r1 = rand() % (x2 - x1)/2;
WiredHome 23:a50ded45dbaf 2869 r2 = rand() % (y2 - y1)/2;
WiredHome 23:a50ded45dbaf 2870 display.roundrect(x1,y1, x2,y2, r1,r2, FILL);
WiredHome 23:a50ded45dbaf 2871 }
WiredHome 23:a50ded45dbaf 2872 }
WiredHome 23:a50ded45dbaf 2873
WiredHome 44:207594dece70 2874
WiredHome 23:a50ded45dbaf 2875 void TriangleTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2876 {
WiredHome 23:a50ded45dbaf 2877 int i, x1, y1, x2, y2, x3, y3;
WiredHome 23:a50ded45dbaf 2878
WiredHome 41:2956a0a221e5 2879 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2880 pc.printf("Triangle Test\r\n");
WiredHome 23:a50ded45dbaf 2881 display.background(Black);
WiredHome 23:a50ded45dbaf 2882 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2883 display.cls();
WiredHome 23:a50ded45dbaf 2884 display.puts(0,0, "Triangle Test");
WiredHome 23:a50ded45dbaf 2885
WiredHome 23:a50ded45dbaf 2886 x1 = 150;
WiredHome 23:a50ded45dbaf 2887 y1 = 2;
WiredHome 23:a50ded45dbaf 2888 x2 = 190;
WiredHome 23:a50ded45dbaf 2889 y2 = 7;
WiredHome 23:a50ded45dbaf 2890 x3 = 170;
WiredHome 23:a50ded45dbaf 2891 y3 = 16;
WiredHome 23:a50ded45dbaf 2892 display.triangle(x1,y1, x2,y2, x3,y3);
WiredHome 23:a50ded45dbaf 2893
WiredHome 23:a50ded45dbaf 2894 x1 = 200;
WiredHome 23:a50ded45dbaf 2895 y1 = 2;
WiredHome 23:a50ded45dbaf 2896 x2 = 240;
WiredHome 23:a50ded45dbaf 2897 y2 = 7;
WiredHome 23:a50ded45dbaf 2898 x3 = 220;
WiredHome 23:a50ded45dbaf 2899 y3 = 16;
WiredHome 23:a50ded45dbaf 2900 display.filltriangle(x1,y1, x2,y2, x3,y3, BrightRed);
WiredHome 23:a50ded45dbaf 2901
WiredHome 23:a50ded45dbaf 2902 x1 = 300;
WiredHome 23:a50ded45dbaf 2903 y1 = 2;
WiredHome 23:a50ded45dbaf 2904 x2 = 340;
WiredHome 23:a50ded45dbaf 2905 y2 = 7;
WiredHome 23:a50ded45dbaf 2906 x3 = 320;
WiredHome 23:a50ded45dbaf 2907 y3 = 16;
WiredHome 23:a50ded45dbaf 2908 display.triangle(x1,y1, x2,y2, x3,y3, NOFILL);
WiredHome 23:a50ded45dbaf 2909
WiredHome 23:a50ded45dbaf 2910 x1 = 400;
WiredHome 23:a50ded45dbaf 2911 y1 = 2;
WiredHome 23:a50ded45dbaf 2912 x2 = 440;
WiredHome 23:a50ded45dbaf 2913 y2 = 7;
WiredHome 23:a50ded45dbaf 2914 x3 = 420;
WiredHome 23:a50ded45dbaf 2915 y3 = 16;
WiredHome 23:a50ded45dbaf 2916 display.triangle(x1,y1, x2,y2, x3,y3, Blue);
WiredHome 23:a50ded45dbaf 2917
WiredHome 23:a50ded45dbaf 2918 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2919 x1 = rand() % 240;
WiredHome 23:a50ded45dbaf 2920 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2921 x2 = rand() % 240;
WiredHome 23:a50ded45dbaf 2922 y2 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2923 x3 = rand() % 240;
WiredHome 23:a50ded45dbaf 2924 y3 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2925 display.triangle(x1,y1, x2,y2, x3,y3, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2926 x1 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 2927 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2928 x2 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 2929 y2 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2930 x3 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 2931 y3 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2932 display.triangle(x1,y1, x2,y2, x3,y3, FILL);
WiredHome 23:a50ded45dbaf 2933 }
WiredHome 23:a50ded45dbaf 2934 }
WiredHome 23:a50ded45dbaf 2935
WiredHome 44:207594dece70 2936
WiredHome 23:a50ded45dbaf 2937 void CircleTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2938 {
WiredHome 23:a50ded45dbaf 2939 int i, x, y, r1;
WiredHome 23:a50ded45dbaf 2940
WiredHome 41:2956a0a221e5 2941 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2942 pc.printf("Circle Test\r\n");
WiredHome 23:a50ded45dbaf 2943 display.background(Black);
WiredHome 23:a50ded45dbaf 2944 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2945 display.cls();
WiredHome 100:0b084475d5a9 2946 display.puts("Circle Test");
WiredHome 23:a50ded45dbaf 2947 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2948 x = 100 + rand() % 100;
WiredHome 23:a50ded45dbaf 2949 y = 70 + rand() % 200;
WiredHome 23:a50ded45dbaf 2950 r1 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2951 //pc.printf(" (%d,%d) - %d\r\n", x,y,r1);
WiredHome 23:a50ded45dbaf 2952 display.circle(x,y,r1, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2953
WiredHome 23:a50ded45dbaf 2954 x = 300 + rand() % 100;
WiredHome 23:a50ded45dbaf 2955 y = 70 + rand() % 200;
WiredHome 23:a50ded45dbaf 2956 r1 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2957 //pc.printf(" (%d,%d) - %d FILL\r\n", x,y,r1);
WiredHome 23:a50ded45dbaf 2958 display.circle(x,y,r1, display.DOSColor(i), FILL);
WiredHome 23:a50ded45dbaf 2959 }
WiredHome 23:a50ded45dbaf 2960 }
WiredHome 23:a50ded45dbaf 2961
WiredHome 44:207594dece70 2962
WiredHome 23:a50ded45dbaf 2963 void EllipseTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2964 {
WiredHome 23:a50ded45dbaf 2965 int i,x,y,r1,r2;
WiredHome 23:a50ded45dbaf 2966
WiredHome 41:2956a0a221e5 2967 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2968 pc.printf("Ellipse Test\r\n");
WiredHome 23:a50ded45dbaf 2969 display.background(Black);
WiredHome 23:a50ded45dbaf 2970 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2971 display.cls();
WiredHome 100:0b084475d5a9 2972 display.puts("Ellipse Test");
WiredHome 23:a50ded45dbaf 2973 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2974 x = 100 + rand() % 100;
WiredHome 23:a50ded45dbaf 2975 y = 70 + rand() % 200;
WiredHome 23:a50ded45dbaf 2976 r1 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2977 r2 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2978 display.ellipse(x,y,r1,r2, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2979
WiredHome 23:a50ded45dbaf 2980 x = 300 + rand() % 100;
WiredHome 23:a50ded45dbaf 2981 y = 70 + rand() % 200;
WiredHome 23:a50ded45dbaf 2982 r1 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2983 r2 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2984 display.ellipse(x,y,r1,r2, FILL);
WiredHome 23:a50ded45dbaf 2985 }
WiredHome 23:a50ded45dbaf 2986 }
WiredHome 23:a50ded45dbaf 2987
WiredHome 44:207594dece70 2988
WiredHome 37:f19b7e7449dc 2989 void TestGraphicsBitmap(RA8875 & display, Serial & pc)
WiredHome 37:f19b7e7449dc 2990 {
WiredHome 37:f19b7e7449dc 2991 LocalFileSystem local("local");
WiredHome 41:2956a0a221e5 2992 if (!SuppressSlowStuff)
WiredHome 73:f22a18707b5e 2993 pc.printf("Bitmap File Load\r\n");
WiredHome 37:f19b7e7449dc 2994 display.background(Black);
WiredHome 37:f19b7e7449dc 2995 display.foreground(Blue);
WiredHome 37:f19b7e7449dc 2996 display.cls();
WiredHome 100:0b084475d5a9 2997 display.puts("Graphics Test, loading /local/TestPat.bmp");
WiredHome 37:f19b7e7449dc 2998 wait(3);
WiredHome 37:f19b7e7449dc 2999
WiredHome 37:f19b7e7449dc 3000 int r = display.RenderBitmapFile(0,0, "/local/TestPat.bmp");
WiredHome 59:fb40aad4efd4 3001 if (!SuppressSlowStuff)
WiredHome 59:fb40aad4efd4 3002 pc.printf(" returned %d\r\n", r);
WiredHome 37:f19b7e7449dc 3003 }
WiredHome 37:f19b7e7449dc 3004
WiredHome 44:207594dece70 3005
WiredHome 77:9206c13aa527 3006 void TouchPanelTest(RA8875 & display, Serial & pc)
WiredHome 77:9206c13aa527 3007 {
WiredHome 77:9206c13aa527 3008 Timer t;
WiredHome 98:ecebed9b80b2 3009 int x, y;
WiredHome 78:faf49c381591 3010 tpMatrix_t calmatrix;
WiredHome 78:faf49c381591 3011
WiredHome 77:9206c13aa527 3012 display.background(Black);
WiredHome 77:9206c13aa527 3013 display.foreground(Blue);
WiredHome 77:9206c13aa527 3014 display.cls();
WiredHome 100:0b084475d5a9 3015 display.puts("Touch Panel Test\r\n");
WiredHome 78:faf49c381591 3016 pc.printf("Touch Panel Test\r\n");
WiredHome 77:9206c13aa527 3017 display.TouchPanelInit();
WiredHome 78:faf49c381591 3018 pc.printf(" TP: c - calibrate, r - restore, t - test\r\n");
WiredHome 78:faf49c381591 3019 int c = pc.getc();
WiredHome 78:faf49c381591 3020 if (c == 'c') {
WiredHome 78:faf49c381591 3021 point_t pTest[3] =
WiredHome 78:faf49c381591 3022 { { 50, 50 }, {450, 150}, {225,250} };
WiredHome 78:faf49c381591 3023 point_t pSample[3];
WiredHome 78:faf49c381591 3024 for (int i=0; i<3; i++) {
WiredHome 78:faf49c381591 3025 display.foreground(Blue);
WiredHome 78:faf49c381591 3026 display.printf(" (%3d,%3d) => ", pTest[i].x, pTest[i].y);
WiredHome 78:faf49c381591 3027 display.line(pTest[i].x-10, pTest[i].y, pTest[i].x+10, pTest[i].y, White);
WiredHome 78:faf49c381591 3028 display.line(pTest[i].x, pTest[i].y-10, pTest[i].x, pTest[i].y+10, White);
WiredHome 79:544eb4964795 3029 while (!display.TouchPanelA2DFiltered(&x, &y))
WiredHome 78:faf49c381591 3030 wait_ms(20);
WiredHome 78:faf49c381591 3031 pSample[i].x = x;
WiredHome 78:faf49c381591 3032 pSample[i].y = y;
WiredHome 78:faf49c381591 3033 display.line(pTest[i].x-10, pTest[i].y, pTest[i].x+10, pTest[i].y, Black);
WiredHome 78:faf49c381591 3034 display.line(pTest[i].x, pTest[i].y-10, pTest[i].x, pTest[i].y+10, Black);
WiredHome 78:faf49c381591 3035 display.foreground(Blue);
WiredHome 78:faf49c381591 3036 display.printf(" (%4d,%4d)\r\n", x,y);
WiredHome 79:544eb4964795 3037 while (display.TouchPanelA2DFiltered(&x, &y))
WiredHome 78:faf49c381591 3038 wait_ms(20);
WiredHome 78:faf49c381591 3039 wait(2);
WiredHome 78:faf49c381591 3040 }
WiredHome 81:01da2e34283d 3041 display.TouchPanelComputeCalibration(pTest, pSample, &calmatrix);
WiredHome 78:faf49c381591 3042 display.printf(" Writing calibration to tpcal.cfg\r\n");
WiredHome 78:faf49c381591 3043 FILE * fh = fopen("/local/tpcal.cfg", "wb");
WiredHome 78:faf49c381591 3044 if (fh) {
WiredHome 78:faf49c381591 3045 fwrite(&calmatrix, sizeof(calmatrix), 1, fh);
WiredHome 78:faf49c381591 3046 fclose(fh);
WiredHome 78:faf49c381591 3047 }
WiredHome 78:faf49c381591 3048 display.printf(" Calibration is complete.");
WiredHome 78:faf49c381591 3049 } else if (c == 'r') {
WiredHome 78:faf49c381591 3050 display.printf(" Reading calibration from tpcal.cfg\r\n");
WiredHome 78:faf49c381591 3051 FILE * fh = fopen("/local/tpcal.cfg", "rb");
WiredHome 78:faf49c381591 3052 if (fh) {
WiredHome 78:faf49c381591 3053 fread(&calmatrix, sizeof(calmatrix), 1, fh);
WiredHome 78:faf49c381591 3054 fclose(fh);
WiredHome 78:faf49c381591 3055 }
WiredHome 78:faf49c381591 3056 display.printf(" Calibration is complete.");
WiredHome 78:faf49c381591 3057 display.TouchPanelSetMatrix(&calmatrix);
WiredHome 77:9206c13aa527 3058 }
WiredHome 77:9206c13aa527 3059 t.start();
WiredHome 77:9206c13aa527 3060 do {
WiredHome 77:9206c13aa527 3061 point_t point = {0, 0};
WiredHome 79:544eb4964795 3062 if (display.TouchPanelReadable(&point)) {
WiredHome 77:9206c13aa527 3063 display.pixel(point.x, point.y, Red);
WiredHome 77:9206c13aa527 3064 }
WiredHome 77:9206c13aa527 3065 } while (t.read_ms() < 30000);
WiredHome 77:9206c13aa527 3066 pc.printf(">");
WiredHome 77:9206c13aa527 3067 }
WiredHome 77:9206c13aa527 3068
WiredHome 77:9206c13aa527 3069
WiredHome 41:2956a0a221e5 3070 void SpeedTest(RA8875 & display, Serial & pc)
WiredHome 41:2956a0a221e5 3071 {
WiredHome 41:2956a0a221e5 3072 Timer t;
WiredHome 41:2956a0a221e5 3073 SuppressSlowStuff = true;
WiredHome 41:2956a0a221e5 3074 pc.printf("\r\nSpeedTest disables delays, runs tests, reports overall time.\r\n");
WiredHome 41:2956a0a221e5 3075 t.start();
WiredHome 41:2956a0a221e5 3076 // do stuff fast
WiredHome 41:2956a0a221e5 3077 TextCursorTest(display, pc);
WiredHome 49:c5182231d1b9 3078 TextWrapTest(display, pc);
WiredHome 41:2956a0a221e5 3079 BacklightTest(display, pc, 0);
WiredHome 41:2956a0a221e5 3080 BacklightTest2(display, pc);
WiredHome 41:2956a0a221e5 3081 ExternalFontTest(display, pc);
WiredHome 41:2956a0a221e5 3082 DOSColorTest(display, pc);
WiredHome 41:2956a0a221e5 3083 WebColorTest(display, pc);
WiredHome 41:2956a0a221e5 3084 PixelTest(display, pc);
WiredHome 41:2956a0a221e5 3085 LineTest(display, pc);
WiredHome 41:2956a0a221e5 3086 RectangleTest(display, pc);
WiredHome 41:2956a0a221e5 3087 RoundRectTest(display, pc);
WiredHome 41:2956a0a221e5 3088 TriangleTest(display, pc);
WiredHome 41:2956a0a221e5 3089 CircleTest(display, pc);
WiredHome 41:2956a0a221e5 3090 EllipseTest(display, pc);
WiredHome 44:207594dece70 3091 LayerTest(display, pc);
WiredHome 41:2956a0a221e5 3092 //TestGraphicsBitmap(display, pc);
WiredHome 41:2956a0a221e5 3093 pc.printf("SpeedTest completed in %d msec\r\n", t.read_ms());
WiredHome 73:f22a18707b5e 3094 #ifdef PERF_METRICS
WiredHome 41:2956a0a221e5 3095 display.ReportPerformance(pc);
WiredHome 73:f22a18707b5e 3096 #endif
WiredHome 41:2956a0a221e5 3097 SuppressSlowStuff = false;
WiredHome 41:2956a0a221e5 3098 }
WiredHome 41:2956a0a221e5 3099
WiredHome 44:207594dece70 3100
WiredHome 41:2956a0a221e5 3101 void PrintScreen(RA8875 & display, Serial & pc)
WiredHome 41:2956a0a221e5 3102 {
WiredHome 41:2956a0a221e5 3103 if (!SuppressSlowStuff)
WiredHome 73:f22a18707b5e 3104 pc.printf("PrintScreen\r\n");
WiredHome 41:2956a0a221e5 3105 display.PrintScreen( 0,0, 480,272, "/local/Capture.bmp");
WiredHome 41:2956a0a221e5 3106 }
WiredHome 41:2956a0a221e5 3107
WiredHome 44:207594dece70 3108
WiredHome 23:a50ded45dbaf 3109 void RunTestSet(RA8875 & lcd, Serial & pc)
WiredHome 23:a50ded45dbaf 3110 {
WiredHome 23:a50ded45dbaf 3111 int q = 0;
WiredHome 23:a50ded45dbaf 3112 int automode = 0;
WiredHome 49:c5182231d1b9 3113 const unsigned char modelist[] = "BDWtGLlFROTPCEbw"; // auto-test in this order.
WiredHome 23:a50ded45dbaf 3114
WiredHome 23:a50ded45dbaf 3115 while(1) {
WiredHome 23:a50ded45dbaf 3116 pc.printf("\r\n"
WiredHome 41:2956a0a221e5 3117 "B - Backlight up b - backlight dim\r\n"
WiredHome 41:2956a0a221e5 3118 "D - DOS Colors W - Web Colors\r\n"
WiredHome 41:2956a0a221e5 3119 "t - text cursor G - Graphics Bitmap\r\n"
WiredHome 41:2956a0a221e5 3120 "L - Lines F - external Font\r\n"
WiredHome 41:2956a0a221e5 3121 "R - Rectangles O - rOund rectangles\r\n"
WiredHome 41:2956a0a221e5 3122 "T - Triangles P - Pixels \r\n"
WiredHome 41:2956a0a221e5 3123 "C - Circles E - Ellipses\r\n"
WiredHome 41:2956a0a221e5 3124 "A - Auto Test mode S - Speed Test\r\n"
WiredHome 77:9206c13aa527 3125 "K - Keypad Test s - touch screen test\r\n"
WiredHome 41:2956a0a221e5 3126 "p - print screen r - reset \r\n"
WiredHome 49:c5182231d1b9 3127 "l - layer test w - wrapping text \r\n"
WiredHome 73:f22a18707b5e 3128 #ifdef PERF_METRICS
WiredHome 41:2956a0a221e5 3129 "0 - clear performance 1 - report performance\r\n"
WiredHome 73:f22a18707b5e 3130 #endif
WiredHome 23:a50ded45dbaf 3131 "> ");
WiredHome 23:a50ded45dbaf 3132 if (automode == -1 || pc.readable()) {
WiredHome 23:a50ded45dbaf 3133 automode = -1;
WiredHome 37:f19b7e7449dc 3134 q = pc.getc();
WiredHome 37:f19b7e7449dc 3135 while (pc.readable())
WiredHome 37:f19b7e7449dc 3136 pc.getc();
WiredHome 23:a50ded45dbaf 3137 } else if (automode >= 0) {
WiredHome 23:a50ded45dbaf 3138 q = modelist[automode];
WiredHome 23:a50ded45dbaf 3139 }
WiredHome 23:a50ded45dbaf 3140 switch(q) {
WiredHome 73:f22a18707b5e 3141 #ifdef PERF_METRICS
WiredHome 41:2956a0a221e5 3142 case '0':
WiredHome 41:2956a0a221e5 3143 lcd.ClearPerformance();
WiredHome 41:2956a0a221e5 3144 break;
WiredHome 41:2956a0a221e5 3145 case '1':
WiredHome 41:2956a0a221e5 3146 lcd.ReportPerformance(pc);
WiredHome 41:2956a0a221e5 3147 break;
WiredHome 73:f22a18707b5e 3148 #endif
WiredHome 23:a50ded45dbaf 3149 case 'A':
WiredHome 23:a50ded45dbaf 3150 automode = 0;
WiredHome 23:a50ded45dbaf 3151 break;
WiredHome 23:a50ded45dbaf 3152 case 'B':
WiredHome 41:2956a0a221e5 3153 BacklightTest(lcd, pc, 2);
WiredHome 23:a50ded45dbaf 3154 break;
WiredHome 23:a50ded45dbaf 3155 case 'b':
WiredHome 23:a50ded45dbaf 3156 BacklightTest2(lcd, pc);
WiredHome 23:a50ded45dbaf 3157 break;
WiredHome 23:a50ded45dbaf 3158 case 'D':
WiredHome 23:a50ded45dbaf 3159 DOSColorTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3160 break;
WiredHome 75:ca78388cfd77 3161 case 'K':
WiredHome 75:ca78388cfd77 3162 KeyPadTest(lcd, pc);
WiredHome 75:ca78388cfd77 3163 break;
WiredHome 23:a50ded45dbaf 3164 case 'W':
WiredHome 23:a50ded45dbaf 3165 WebColorTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3166 break;
WiredHome 23:a50ded45dbaf 3167 case 't':
WiredHome 23:a50ded45dbaf 3168 TextCursorTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3169 break;
WiredHome 49:c5182231d1b9 3170 case 'w':
WiredHome 49:c5182231d1b9 3171 TextWrapTest(lcd, pc);
WiredHome 49:c5182231d1b9 3172 break;
WiredHome 23:a50ded45dbaf 3173 case 'F':
WiredHome 23:a50ded45dbaf 3174 ExternalFontTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3175 break;
WiredHome 23:a50ded45dbaf 3176 case 'L':
WiredHome 23:a50ded45dbaf 3177 LineTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3178 break;
WiredHome 44:207594dece70 3179 case 'l':
WiredHome 44:207594dece70 3180 LayerTest(lcd, pc);
WiredHome 44:207594dece70 3181 break;
WiredHome 23:a50ded45dbaf 3182 case 'R':
WiredHome 23:a50ded45dbaf 3183 RectangleTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3184 break;
WiredHome 23:a50ded45dbaf 3185 case 'O':
WiredHome 23:a50ded45dbaf 3186 RoundRectTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3187 break;
WiredHome 41:2956a0a221e5 3188 case 'p':
WiredHome 41:2956a0a221e5 3189 PrintScreen(lcd, pc);
WiredHome 41:2956a0a221e5 3190 break;
WiredHome 41:2956a0a221e5 3191 case 'S':
WiredHome 41:2956a0a221e5 3192 SpeedTest(lcd, pc);
WiredHome 41:2956a0a221e5 3193 break;
WiredHome 77:9206c13aa527 3194 case 's':
WiredHome 77:9206c13aa527 3195 TouchPanelTest(lcd, pc);
WiredHome 77:9206c13aa527 3196 break;
WiredHome 23:a50ded45dbaf 3197 case 'T':
WiredHome 23:a50ded45dbaf 3198 TriangleTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3199 break;
WiredHome 37:f19b7e7449dc 3200 case 'P':
WiredHome 37:f19b7e7449dc 3201 PixelTest(lcd, pc);
WiredHome 37:f19b7e7449dc 3202 break;
WiredHome 37:f19b7e7449dc 3203 case 'G':
WiredHome 37:f19b7e7449dc 3204 TestGraphicsBitmap(lcd, pc);
WiredHome 37:f19b7e7449dc 3205 break;
WiredHome 23:a50ded45dbaf 3206 case 'C':
WiredHome 23:a50ded45dbaf 3207 CircleTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3208 break;
WiredHome 23:a50ded45dbaf 3209 case 'E':
WiredHome 23:a50ded45dbaf 3210 EllipseTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3211 break;
WiredHome 23:a50ded45dbaf 3212 case 'r':
WiredHome 23:a50ded45dbaf 3213 pc.printf("Resetting ...\r\n");
WiredHome 23:a50ded45dbaf 3214 wait_ms(20);
WiredHome 23:a50ded45dbaf 3215 mbed_reset();
WiredHome 23:a50ded45dbaf 3216 break;
WiredHome 75:ca78388cfd77 3217 case ' ':
WiredHome 75:ca78388cfd77 3218 break;
WiredHome 23:a50ded45dbaf 3219 default:
WiredHome 23:a50ded45dbaf 3220 printf("huh?\n");
WiredHome 23:a50ded45dbaf 3221 break;
WiredHome 23:a50ded45dbaf 3222 }
WiredHome 23:a50ded45dbaf 3223 if (automode >= 0) {
WiredHome 23:a50ded45dbaf 3224 automode++;
WiredHome 23:a50ded45dbaf 3225 if (automode >= sizeof(modelist))
WiredHome 23:a50ded45dbaf 3226 automode = 0;
WiredHome 23:a50ded45dbaf 3227 wait_ms(2000);
WiredHome 23:a50ded45dbaf 3228 }
WiredHome 23:a50ded45dbaf 3229 wait_ms(200);
WiredHome 23:a50ded45dbaf 3230 }
WiredHome 23:a50ded45dbaf 3231 }
WiredHome 23:a50ded45dbaf 3232
WiredHome 79:544eb4964795 3233 #endif // TESTENABLE