Kerry Martin / RA8875

KSM edits to RA8875

Dependents:   Liz_Test_Code

RA8875.cpp@148:33e99de1aca6, 2017-06-13 (annotated)

Committer:
WiredHome
Date:
Tue Jun 13 23:12:26 2017 +0000
Revision:
148:33e99de1aca6
Parent:
147:3494792458d9
Child:
149:c62c4b2d6a15
Final fix on the computation of the Intersection of two rectangles, when you want to access to the resulting intersection. Prior versions worked if only if point1 was the top-left and point2 the bottom-right. This version works for any corner pair.

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