Kerry Martin / RA8875

KSM edits to RA8875

Dependents:   Liz_Test_Code

RA8875.cpp@135:af519fe4ba91, 2016-11-13 (annotated)

Committer:
WiredHome
Date:
Sun Nov 13 02:06:30 2016 +0000
Revision:
135:af519fe4ba91
Parent:
134:f028ed71a0af
Child:
136:224e03d5c31f
cls resets the cursor

Who changed what in which revision?

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