David Smart / RA8875 Featured

Library to control a Graphics TFT connected to 4-wire SPI - revised for the Raio RA8875 Display Controller.

Dependents:   FRDM_RA8875_mPaint RA8875_Demo RA8875_KeyPadDemo SignalGenerator ... more

Fork of SPI_TFT by Peter Drescher

See Components - RA8875 Based Display

Enhanced touch-screen support - where it previous supported both the Resistive Touch and Capacitive Touch based on the FT5206 Touch Controller, now it also has support for the GSL1680 Touch Controller.

Offline Help Manual (Windows chm)

/media/uploads/WiredHome/ra8875.zip.bin (download, rename to .zip and unzip)

RA8875.cpp@152:a013ac0133e4, 2017-11-06 (annotated)

Committer:
WiredHome
Date:
Mon Nov 06 01:41:55 2017 +0000
Revision:
152:a013ac0133e4
Parent:
150:35a4db3081c1
Child:
153:8a85efb3eb71
Initial support for GIF rendering

Who changed what in which revision?

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