David Smart / RA8875 Featured

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

Dependents:   FRDM_RA8875_mPaint RA8875_Demo RA8875_KeyPadDemo SignalGenerator ... more

Fork of SPI_TFT by Peter Drescher

See Components - RA8875 Based Display

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

Offline Help Manual (Windows chm)

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

RA8875.cpp@125:7a0b70f56550, 2016-08-01 (annotated)

Committer:
WiredHome
Date:
Mon Aug 01 22:31:42 2016 +0000
Revision:
125:7a0b70f56550
Parent:
124:1690a7ae871c
Child:
127:db7f2c704693
Minor documentation tweaks

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