Kerry Martin / RA8875

KSM edits to RA8875

Dependents:   Liz_Test_Code

RA8875.cpp@144:ba002c4b21b3, 2017-05-06 (annotated)

Committer:
WiredHome
Date:
Sat May 06 20:14:48 2017 +0000
Revision:
144:ba002c4b21b3
Parent:
143:e872d65a710d
Child:
146:373d59f08357
Added ThickLine API

Who changed what in which revision?

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