Kerry Martin / RA8875

KSM edits to RA8875

Dependents:   Liz_Test_Code

RA8875.cpp@150:35a4db3081c1, 2017-09-24 (annotated)

Committer:
WiredHome
Date:
Sun Sep 24 02:09:57 2017 +0000
Revision:
150:35a4db3081c1
Parent:
149:c62c4b2d6a15
Child:
151:ae94daaaf8ad
Child:
152:a013ac0133e4
callback functions is conditional on mbed version. Somewhere below 128 it does not use the extra callback api.

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