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@153:8a85efb3eb71, 2018-07-29 (annotated)

Committer:
WiredHome
Date:
Sun Jul 29 00:32:51 2018 +0000
Revision:
153:8a85efb3eb71
Parent:
152:a013ac0133e4
Child:
154:ad2450fc3dc3
Soft Fonts and very preliminary GIF support.

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