Kerry Martin / RA8875

KSM edits to RA8875

Dependents:   Liz_Test_Code

RA8875.cpp@162:a2d7f1988711, 2019-02-11 (annotated)

Committer:
WiredHome
Date:
Mon Feb 11 03:44:42 2019 +0000
Revision:
162:a2d7f1988711
Parent:
157:1565f38ca44b
Child:
163:17526689a3ed
PrintScreen - bug fixes in header info and symmetry of RGB16toRGBQuad and RGBQuadToRGB16

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