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@127:db7f2c704693, 2016-08-06 (annotated)

Committer:
WiredHome
Date:
Sat Aug 06 20:04:23 2016 +0000
Revision:
127:db7f2c704693
Parent:
125:7a0b70f56550
Child:
131:5bd6ba2ee4a1
Added GetUserFont and GetTextFontSize apis, which were helpful for saving and restoring settings on the fly.

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 127:db7f2c704693 890 RetCode_t RA8875::GetTextFontSize(RA8875::HorizontalScale * hScale, RA8875::VerticalScale * vScale)
WiredHome 127:db7f2c704693 891 {
WiredHome 127:db7f2c704693 892 unsigned char reg = ReadCommand(0x22);
WiredHome 127:db7f2c704693 893
WiredHome 127:db7f2c704693 894 if (hScale)
WiredHome 127:db7f2c704693 895 *hScale = 1 + (reg >> 2) & 0x03;
WiredHome 127:db7f2c704693 896 if (vScale)
WiredHome 127:db7f2c704693 897 *vScale = 1 + reg & 0x03;
WiredHome 127:db7f2c704693 898 return noerror;
WiredHome 127:db7f2c704693 899 }
WiredHome 44:207594dece70 900
WiredHome 19:3f82c1161fd2 901 int RA8875::_putc(int c)
WiredHome 19:3f82c1161fd2 902 {
WiredHome 29:422616aa04bd 903 if (font == NULL) {
WiredHome 29:422616aa04bd 904 return _internal_putc(c);
WiredHome 29:422616aa04bd 905 } else {
WiredHome 29:422616aa04bd 906 return _external_putc(c);
WiredHome 29:422616aa04bd 907 }
WiredHome 29:422616aa04bd 908 }
WiredHome 29:422616aa04bd 909
WiredHome 44:207594dece70 910
WiredHome 101:e0aad446094a 911
WiredHome 101:e0aad446094a 912 // Questions to ponder -
WiredHome 101:e0aad446094a 913 // - if we choose to wrap to the next line, because the character won't fit on the current line,
WiredHome 101:e0aad446094a 914 // should it erase the space to the width of the screen (in case there is leftover junk there)?
WiredHome 101:e0aad446094a 915 // - it currently wraps from the bottom of the screen back to the top. I have pondered what
WiredHome 101:e0aad446094a 916 // it might take to scroll the screen - but haven't thought hard enough about it.
WiredHome 101:e0aad446094a 917 //
WiredHome 29:422616aa04bd 918 int RA8875::_external_putc(int c)
WiredHome 29:422616aa04bd 919 {
WiredHome 19:3f82c1161fd2 920 if (c) {
WiredHome 19:3f82c1161fd2 921 if (c == '\r') {
WiredHome 111:efe436c43aba 922 cursor_x = windowrect.p1.x;
WiredHome 29:422616aa04bd 923 } else if (c == '\n') {
WiredHome 98:ecebed9b80b2 924 cursor_y += extFontHeight;
WiredHome 29:422616aa04bd 925 } else {
WiredHome 109:7b94f06f085b 926 dim_t charWidth, charHeight;
WiredHome 101:e0aad446094a 927 const uint8_t * charRecord;
WiredHome 101:e0aad446094a 928
WiredHome 101:e0aad446094a 929 charRecord = getCharMetrics(c, &charWidth, &charHeight);
WiredHome 101:e0aad446094a 930 //int advance = charwidth(c);
WiredHome 111:efe436c43aba 931 INFO("(%d,%d) - (%d,%d):(%d,%d), charWidth: %d '%c", cursor_x, cursor_y,
WiredHome 111:efe436c43aba 932 windowrect.p1.x, windowrect.p1.y, windowrect.p2.x, windowrect.p2.y,
WiredHome 111:efe436c43aba 933 charWidth, c);
WiredHome 101:e0aad446094a 934 if (charRecord) {
WiredHome 101:e0aad446094a 935 //cursor_x += advance;
WiredHome 111:efe436c43aba 936 if (cursor_x + charWidth >= windowrect.p2.x) {
WiredHome 111:efe436c43aba 937 cursor_x = windowrect.p1.x;
WiredHome 101:e0aad446094a 938 cursor_y += charHeight;
WiredHome 29:422616aa04bd 939 }
WiredHome 111:efe436c43aba 940 if (cursor_y + charHeight >= windowrect.p2.y) {
WiredHome 111:efe436c43aba 941 cursor_y = windowrect.p1.y; // @todo Should it scroll?
WiredHome 101:e0aad446094a 942 }
WiredHome 101:e0aad446094a 943 (void)character(cursor_x, cursor_y, c);
WiredHome 101:e0aad446094a 944 cursor_x += charWidth;
WiredHome 29:422616aa04bd 945 }
WiredHome 29:422616aa04bd 946 }
WiredHome 29:422616aa04bd 947 }
WiredHome 29:422616aa04bd 948 return c;
WiredHome 29:422616aa04bd 949 }
WiredHome 29:422616aa04bd 950
WiredHome 44:207594dece70 951
WiredHome 29:422616aa04bd 952 int RA8875::_internal_putc(int c)
WiredHome 29:422616aa04bd 953 {
WiredHome 29:422616aa04bd 954 if (c) {
WiredHome 29:422616aa04bd 955 unsigned char mwcr0;
WiredHome 73:f22a18707b5e 956
WiredHome 29:422616aa04bd 957 mwcr0 = ReadCommand(0x40);
WiredHome 29:422616aa04bd 958 if ((mwcr0 & 0x80) == 0x00) {
WiredHome 29:422616aa04bd 959 WriteCommand(0x40, 0x80 | mwcr0); // Put in Text mode if not already
WiredHome 29:422616aa04bd 960 }
WiredHome 29:422616aa04bd 961 if (c == '\r') {
WiredHome 37:f19b7e7449dc 962 loc_t x;
WiredHome 19:3f82c1161fd2 963 x = ReadCommand(0x30) | (ReadCommand(0x31) << 8); // Left edge of active window
WiredHome 38:38d503b4fad6 964 WriteCommandW(0x2A, x);
WiredHome 19:3f82c1161fd2 965 } else if (c == '\n') {
WiredHome 37:f19b7e7449dc 966 loc_t y;
WiredHome 19:3f82c1161fd2 967 y = ReadCommand(0x2C) | (ReadCommand(0x2D) << 8); // current y location
WiredHome 19:3f82c1161fd2 968 y += fontheight();
WiredHome 47:d96a09269f91 969 if (y >= height()) // @TODO after bottom of active window, then scroll window?
WiredHome 19:3f82c1161fd2 970 y = 0;
WiredHome 38:38d503b4fad6 971 WriteCommandW(0x2C, y);
WiredHome 19:3f82c1161fd2 972 } else {
WiredHome 29:422616aa04bd 973 WriteCommand(0x02); // RA8875 Internal Fonts
WiredHome 79:544eb4964795 974 _select(true);
WiredHome 29:422616aa04bd 975 WriteData(c);
WiredHome 66:468a11f05580 976 _WaitWhileBusy(0x80);
WiredHome 79:544eb4964795 977 _select(false);
WiredHome 19:3f82c1161fd2 978 }
WiredHome 19:3f82c1161fd2 979 }
WiredHome 19:3f82c1161fd2 980 return c;
WiredHome 19:3f82c1161fd2 981 }
WiredHome 19:3f82c1161fd2 982
WiredHome 44:207594dece70 983
WiredHome 32:0e4f2ae512e2 984 RetCode_t RA8875::_StartGraphicsStream(void)
WiredHome 32:0e4f2ae512e2 985 {
WiredHome 32:0e4f2ae512e2 986 WriteCommand(0x40,0x00); // Graphics write mode
WiredHome 32:0e4f2ae512e2 987 WriteCommand(0x02); // Prepare for streaming data
WiredHome 32:0e4f2ae512e2 988 return noerror;
WiredHome 32:0e4f2ae512e2 989 }
WiredHome 32:0e4f2ae512e2 990
WiredHome 44:207594dece70 991
WiredHome 32:0e4f2ae512e2 992 RetCode_t RA8875::_EndGraphicsStream(void)
WiredHome 32:0e4f2ae512e2 993 {
WiredHome 32:0e4f2ae512e2 994 return noerror;
WiredHome 32:0e4f2ae512e2 995 }
WiredHome 32:0e4f2ae512e2 996
WiredHome 44:207594dece70 997
WiredHome 55:dfbabef7003e 998 RetCode_t RA8875::_putp(color_t pixel)
WiredHome 32:0e4f2ae512e2 999 {
WiredHome 38:38d503b4fad6 1000 WriteDataW((pixel>>8) | (pixel<<8));
WiredHome 73:f22a18707b5e 1001 return noerror;
WiredHome 32:0e4f2ae512e2 1002 }
WiredHome 29:422616aa04bd 1003
WiredHome 44:207594dece70 1004
WiredHome 37:f19b7e7449dc 1005 void RA8875::puts(loc_t x, loc_t y, const char * string)
WiredHome 19:3f82c1161fd2 1006 {
WiredHome 19:3f82c1161fd2 1007 SetTextCursor(x,y);
WiredHome 19:3f82c1161fd2 1008 puts(string);
WiredHome 19:3f82c1161fd2 1009 }
WiredHome 19:3f82c1161fd2 1010
WiredHome 44:207594dece70 1011
WiredHome 19:3f82c1161fd2 1012 void RA8875::puts(const char * string)
WiredHome 19:3f82c1161fd2 1013 {
WiredHome 37:f19b7e7449dc 1014 if (font == NULL) {
WiredHome 100:0b084475d5a9 1015 WriteCommand(0x40,0x80); // Put in Text mode if internal font
WiredHome 37:f19b7e7449dc 1016 }
WiredHome 19:3f82c1161fd2 1017 if (*string != '\0') {
WiredHome 29:422616aa04bd 1018 while (*string) { // @TODO calling individual _putc is slower... optimizations?
WiredHome 19:3f82c1161fd2 1019 _putc(*string++);
WiredHome 19:3f82c1161fd2 1020 }
WiredHome 19:3f82c1161fd2 1021 }
WiredHome 19:3f82c1161fd2 1022 }
WiredHome 19:3f82c1161fd2 1023
WiredHome 44:207594dece70 1024
WiredHome 37:f19b7e7449dc 1025 RetCode_t RA8875::SetGraphicsCursor(loc_t x, loc_t y)
WiredHome 19:3f82c1161fd2 1026 {
WiredHome 38:38d503b4fad6 1027 WriteCommandW(0x46, x);
WiredHome 38:38d503b4fad6 1028 WriteCommandW(0x48, y);
WiredHome 19:3f82c1161fd2 1029 return noerror;
WiredHome 19:3f82c1161fd2 1030 }
WiredHome 19:3f82c1161fd2 1031
WiredHome 44:207594dece70 1032
WiredHome 41:2956a0a221e5 1033 RetCode_t RA8875::SetGraphicsCursorRead(loc_t x, loc_t y)
WiredHome 41:2956a0a221e5 1034 {
WiredHome 41:2956a0a221e5 1035 WriteCommandW(0x4A, x);
WiredHome 41:2956a0a221e5 1036 WriteCommandW(0x4C, y);
WiredHome 41:2956a0a221e5 1037 return noerror;
WiredHome 41:2956a0a221e5 1038 }
WiredHome 41:2956a0a221e5 1039
WiredHome 111:efe436c43aba 1040 RetCode_t RA8875::window(rect_t r)
WiredHome 111:efe436c43aba 1041 {
WiredHome 111:efe436c43aba 1042 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 1043 }
WiredHome 44:207594dece70 1044
WiredHome 37:f19b7e7449dc 1045 RetCode_t RA8875::window(loc_t x, loc_t y, dim_t width, dim_t height)
WiredHome 19:3f82c1161fd2 1046 {
WiredHome 111:efe436c43aba 1047 INFO("window(%d,%d,%d,%d)", x, y, width, height);
WiredHome 111:efe436c43aba 1048 if (width == (dim_t)-1)
WiredHome 111:efe436c43aba 1049 width = screenwidth - x;
WiredHome 111:efe436c43aba 1050 if (height == (dim_t)-1)
WiredHome 111:efe436c43aba 1051 height = screenheight - y;
WiredHome 111:efe436c43aba 1052 windowrect.p1.x = x;
WiredHome 111:efe436c43aba 1053 windowrect.p1.y = y;
WiredHome 111:efe436c43aba 1054 windowrect.p2.x = x + width - 1;
WiredHome 111:efe436c43aba 1055 windowrect.p2.y = y + height - 1;
WiredHome 37:f19b7e7449dc 1056 GraphicsDisplay::window(x,y, width,height);
WiredHome 38:38d503b4fad6 1057 WriteCommandW(0x30, x);
WiredHome 38:38d503b4fad6 1058 WriteCommandW(0x32, y);
WiredHome 38:38d503b4fad6 1059 WriteCommandW(0x34, (x+width-1));
WiredHome 38:38d503b4fad6 1060 WriteCommandW(0x36, (y+height-1));
WiredHome 111:efe436c43aba 1061 //SetTextCursor(x,y);
WiredHome 111:efe436c43aba 1062 //SetGraphicsCursor(x,y);
WiredHome 19:3f82c1161fd2 1063 return noerror;
WiredHome 19:3f82c1161fd2 1064 }
WiredHome 19:3f82c1161fd2 1065
WiredHome 44:207594dece70 1066
WiredHome 61:8f3153bf0baa 1067 RetCode_t RA8875::cls(uint16_t layers)
WiredHome 19:3f82c1161fd2 1068 {
WiredHome 61:8f3153bf0baa 1069 RetCode_t ret;
WiredHome 73:f22a18707b5e 1070
WiredHome 19:3f82c1161fd2 1071 PERFORMANCE_RESET;
WiredHome 61:8f3153bf0baa 1072 if (layers == 0) {
WiredHome 61:8f3153bf0baa 1073 ret = clsw(FULLWINDOW);
WiredHome 61:8f3153bf0baa 1074 ret = SetTextCursor(0,0);
WiredHome 61:8f3153bf0baa 1075 } else if (layers > 3) {
WiredHome 61:8f3153bf0baa 1076 ret = bad_parameter;
WiredHome 61:8f3153bf0baa 1077 } else {
WiredHome 61:8f3153bf0baa 1078 uint16_t prevLayer = GetDrawingLayer();
WiredHome 61:8f3153bf0baa 1079 if (layers & 1) {
WiredHome 61:8f3153bf0baa 1080 SelectDrawingLayer(0);
WiredHome 61:8f3153bf0baa 1081 clsw(FULLWINDOW);
WiredHome 61:8f3153bf0baa 1082 }
WiredHome 61:8f3153bf0baa 1083 if (layers & 2) {
WiredHome 61:8f3153bf0baa 1084 SelectDrawingLayer(1);
WiredHome 61:8f3153bf0baa 1085 clsw(FULLWINDOW);
WiredHome 61:8f3153bf0baa 1086 }
WiredHome 61:8f3153bf0baa 1087 ret = SelectDrawingLayer(prevLayer);
WiredHome 61:8f3153bf0baa 1088 }
WiredHome 19:3f82c1161fd2 1089 REGISTERPERFORMANCE(PRF_CLS);
WiredHome 61:8f3153bf0baa 1090 return ret;
WiredHome 19:3f82c1161fd2 1091 }
WiredHome 19:3f82c1161fd2 1092
WiredHome 44:207594dece70 1093
WiredHome 19:3f82c1161fd2 1094 RetCode_t RA8875::clsw(RA8875::Region_t region)
WiredHome 19:3f82c1161fd2 1095 {
WiredHome 19:3f82c1161fd2 1096 PERFORMANCE_RESET;
WiredHome 19:3f82c1161fd2 1097 WriteCommand(0x8E, (region == ACTIVEWINDOW) ? 0xC0 : 0x80);
WiredHome 66:468a11f05580 1098 _WaitWhileReg(0x8E, 0x80);
WiredHome 19:3f82c1161fd2 1099 REGISTERPERFORMANCE(PRF_CLS);
WiredHome 19:3f82c1161fd2 1100 return noerror;
WiredHome 19:3f82c1161fd2 1101 }
WiredHome 19:3f82c1161fd2 1102
WiredHome 44:207594dece70 1103
WiredHome 87:ee2240581aa7 1104 RetCode_t RA8875::pixel(point_t p, color_t color)
WiredHome 87:ee2240581aa7 1105 {
WiredHome 87:ee2240581aa7 1106 return pixel(p.x, p.y, color);
WiredHome 87:ee2240581aa7 1107 }
WiredHome 87:ee2240581aa7 1108
WiredHome 87:ee2240581aa7 1109 RetCode_t RA8875::pixel(point_t p)
WiredHome 87:ee2240581aa7 1110 {
WiredHome 87:ee2240581aa7 1111 return pixel(p.x, p.y);
WiredHome 87:ee2240581aa7 1112 }
WiredHome 87:ee2240581aa7 1113
WiredHome 37:f19b7e7449dc 1114 RetCode_t RA8875::pixel(loc_t x, loc_t y, color_t color)
WiredHome 19:3f82c1161fd2 1115 {
WiredHome 62:ba5d33438fda 1116 RetCode_t ret;
WiredHome 73:f22a18707b5e 1117
WiredHome 62:ba5d33438fda 1118 PERFORMANCE_RESET;
WiredHome 62:ba5d33438fda 1119 ret = pixelStream(&color, 1, x,y);
WiredHome 62:ba5d33438fda 1120 REGISTERPERFORMANCE(PRF_DRAWPIXEL);
WiredHome 62:ba5d33438fda 1121 return ret;
WiredHome 19:3f82c1161fd2 1122 }
WiredHome 19:3f82c1161fd2 1123
WiredHome 44:207594dece70 1124
WiredHome 37:f19b7e7449dc 1125 RetCode_t RA8875::pixel(loc_t x, loc_t y)
WiredHome 19:3f82c1161fd2 1126 {
WiredHome 19:3f82c1161fd2 1127 RetCode_t ret;
WiredHome 73:f22a18707b5e 1128
WiredHome 19:3f82c1161fd2 1129 PERFORMANCE_RESET;
WiredHome 19:3f82c1161fd2 1130 color_t color = GetForeColor();
WiredHome 62:ba5d33438fda 1131 ret = pixelStream(&color, 1, x, y);
WiredHome 41:2956a0a221e5 1132 REGISTERPERFORMANCE(PRF_DRAWPIXEL);
WiredHome 19:3f82c1161fd2 1133 return ret;
WiredHome 19:3f82c1161fd2 1134 }
WiredHome 19:3f82c1161fd2 1135
WiredHome 44:207594dece70 1136
WiredHome 41:2956a0a221e5 1137 RetCode_t RA8875::pixelStream(color_t * p, uint32_t count, loc_t x, loc_t y)
WiredHome 41:2956a0a221e5 1138 {
WiredHome 41:2956a0a221e5 1139 PERFORMANCE_RESET;
WiredHome 41:2956a0a221e5 1140 SetGraphicsCursor(x, y);
WiredHome 109:7b94f06f085b 1141 _StartGraphicsStream();
WiredHome 79:544eb4964795 1142 _select(true);
WiredHome 79:544eb4964795 1143 _spiwrite(0x00); // Cmd: write data
WiredHome 41:2956a0a221e5 1144 while (count--) {
WiredHome 105:4f116006ba1f 1145 if (screenbpp == 16) {
WiredHome 105:4f116006ba1f 1146 _spiwrite(*p >> 8);
WiredHome 105:4f116006ba1f 1147 _spiwrite(*p & 0xFF);
WiredHome 105:4f116006ba1f 1148 } else {
WiredHome 105:4f116006ba1f 1149 _spiwrite(_cvt16to8(*p));
WiredHome 105:4f116006ba1f 1150 }
WiredHome 41:2956a0a221e5 1151 p++;
WiredHome 41:2956a0a221e5 1152 }
WiredHome 79:544eb4964795 1153 _select(false);
WiredHome 109:7b94f06f085b 1154 _EndGraphicsStream();
WiredHome 41:2956a0a221e5 1155 REGISTERPERFORMANCE(PRF_PIXELSTREAM);
WiredHome 41:2956a0a221e5 1156 return(noerror);
WiredHome 41:2956a0a221e5 1157 }
WiredHome 41:2956a0a221e5 1158
WiredHome 109:7b94f06f085b 1159 RetCode_t RA8875::booleanStream(loc_t x, loc_t y, dim_t w, dim_t h, const uint8_t * boolStream)
WiredHome 109:7b94f06f085b 1160 {
WiredHome 109:7b94f06f085b 1161 PERFORMANCE_RESET;
WiredHome 111:efe436c43aba 1162 rect_t restore = windowrect;
WiredHome 111:efe436c43aba 1163
WiredHome 109:7b94f06f085b 1164 window(x, y, w, h);
WiredHome 109:7b94f06f085b 1165 SetGraphicsCursor(x, y);
WiredHome 109:7b94f06f085b 1166 _StartGraphicsStream();
WiredHome 109:7b94f06f085b 1167 _select(true);
WiredHome 109:7b94f06f085b 1168 _spiwrite(0x00); // Cmd: write data
WiredHome 109:7b94f06f085b 1169 while (h--) {
WiredHome 109:7b94f06f085b 1170 uint8_t pixels = w;
WiredHome 109:7b94f06f085b 1171 uint8_t bitmask = 0x01;
WiredHome 109:7b94f06f085b 1172
WiredHome 109:7b94f06f085b 1173 while (pixels) {
WiredHome 109:7b94f06f085b 1174 uint8_t byte = *boolStream;
WiredHome 111:efe436c43aba 1175 //INFO("byte, mask: %02X, %02X", byte, bitmask);
WiredHome 109:7b94f06f085b 1176 color_t c = (byte & bitmask) ? _foreground : _background;
WiredHome 109:7b94f06f085b 1177 if (screenbpp == 16) {
WiredHome 109:7b94f06f085b 1178 _spiwrite(c >> 8);
WiredHome 109:7b94f06f085b 1179 _spiwrite(c & 0xFF);
WiredHome 109:7b94f06f085b 1180 } else {
WiredHome 109:7b94f06f085b 1181 _spiwrite(_cvt16to8(c));
WiredHome 109:7b94f06f085b 1182 }
WiredHome 109:7b94f06f085b 1183 bitmask <<= 1;
WiredHome 109:7b94f06f085b 1184 if (pixels > 1 && bitmask == 0) {
WiredHome 109:7b94f06f085b 1185 bitmask = 0x01;
WiredHome 109:7b94f06f085b 1186 boolStream++;
WiredHome 109:7b94f06f085b 1187 }
WiredHome 109:7b94f06f085b 1188 pixels--;
WiredHome 109:7b94f06f085b 1189 }
WiredHome 109:7b94f06f085b 1190 boolStream++;
WiredHome 109:7b94f06f085b 1191 }
WiredHome 109:7b94f06f085b 1192 _select(false);
WiredHome 109:7b94f06f085b 1193 _EndGraphicsStream();
WiredHome 111:efe436c43aba 1194 window(restore);
WiredHome 109:7b94f06f085b 1195 REGISTERPERFORMANCE(PRF_BOOLSTREAM);
WiredHome 109:7b94f06f085b 1196 return(noerror);
WiredHome 109:7b94f06f085b 1197 }
WiredHome 44:207594dece70 1198
WiredHome 41:2956a0a221e5 1199 color_t RA8875::getPixel(loc_t x, loc_t y)
WiredHome 41:2956a0a221e5 1200 {
WiredHome 41:2956a0a221e5 1201 color_t pixel;
WiredHome 73:f22a18707b5e 1202
WiredHome 41:2956a0a221e5 1203 PERFORMANCE_RESET;
WiredHome 41:2956a0a221e5 1204 //WriteCommand(0x45,0x00); // read left->right, top->bottom
WiredHome 41:2956a0a221e5 1205 WriteCommand(0x40,0x00); // Graphics write mode
WiredHome 41:2956a0a221e5 1206 SetGraphicsCursorRead(x, y);
WiredHome 41:2956a0a221e5 1207 WriteCommand(0x02);
WiredHome 79:544eb4964795 1208 _select(true);
WiredHome 79:544eb4964795 1209 _spiwrite(0x40); // Cmd: read data
WiredHome 79:544eb4964795 1210 _spiwrite(0x00); // dummy read
WiredHome 105:4f116006ba1f 1211 if (screenbpp == 16) {
WiredHome 105:4f116006ba1f 1212 pixel = _spiread();
WiredHome 105:4f116006ba1f 1213 pixel |= (_spiread() << 8);
WiredHome 105:4f116006ba1f 1214 } else {
WiredHome 105:4f116006ba1f 1215 pixel = _cvt8to16(_spiread());
WiredHome 105:4f116006ba1f 1216 }
WiredHome 79:544eb4964795 1217 _select(false);
WiredHome 41:2956a0a221e5 1218 REGISTERPERFORMANCE(PRF_READPIXEL);
WiredHome 41:2956a0a221e5 1219 return pixel;
WiredHome 41:2956a0a221e5 1220 }
WiredHome 41:2956a0a221e5 1221
WiredHome 44:207594dece70 1222
WiredHome 41:2956a0a221e5 1223 RetCode_t RA8875::getPixelStream(color_t * p, uint32_t count, loc_t x, loc_t y)
WiredHome 41:2956a0a221e5 1224 {
WiredHome 41:2956a0a221e5 1225 color_t pixel;
WiredHome 86:e86b355940f4 1226 RetCode_t ret = noerror;
WiredHome 73:f22a18707b5e 1227
WiredHome 41:2956a0a221e5 1228 PERFORMANCE_RESET;
WiredHome 86:e86b355940f4 1229 ret = WriteCommand(0x40,0x00); // Graphics write mode
WiredHome 86:e86b355940f4 1230 ret = SetGraphicsCursorRead(x, y);
WiredHome 86:e86b355940f4 1231 ret = WriteCommand(0x02);
WiredHome 79:544eb4964795 1232 _select(true);
WiredHome 79:544eb4964795 1233 _spiwrite(0x40); // Cmd: read data
WiredHome 79:544eb4964795 1234 _spiwrite(0x00); // dummy read
WiredHome 106:c80828f5dea4 1235 if (screenbpp == 16)
WiredHome 106:c80828f5dea4 1236 _spiwrite(0x00); // dummy read is only necessary when in 16-bit mode
WiredHome 41:2956a0a221e5 1237 while (count--) {
WiredHome 105:4f116006ba1f 1238 if (screenbpp == 16) {
WiredHome 105:4f116006ba1f 1239 pixel = _spiread();
WiredHome 105:4f116006ba1f 1240 pixel |= (_spiread() << 8);
WiredHome 105:4f116006ba1f 1241 } else {
WiredHome 105:4f116006ba1f 1242 pixel = _cvt8to16(_spiread());
WiredHome 105:4f116006ba1f 1243 }
WiredHome 41:2956a0a221e5 1244 *p++ = pixel;
WiredHome 41:2956a0a221e5 1245 }
WiredHome 79:544eb4964795 1246 _select(false);
WiredHome 41:2956a0a221e5 1247 REGISTERPERFORMANCE(PRF_READPIXELSTREAM);
WiredHome 86:e86b355940f4 1248 return ret;
WiredHome 41:2956a0a221e5 1249 }
WiredHome 41:2956a0a221e5 1250
WiredHome 44:207594dece70 1251
WiredHome 83:7bad0068cca0 1252 RetCode_t RA8875::line(point_t p1, point_t p2)
WiredHome 83:7bad0068cca0 1253 {
WiredHome 83:7bad0068cca0 1254 return line(p1.x, p1.y, p2.x, p2.y);
WiredHome 83:7bad0068cca0 1255 }
WiredHome 83:7bad0068cca0 1256
WiredHome 83:7bad0068cca0 1257
WiredHome 83:7bad0068cca0 1258 RetCode_t RA8875::line(point_t p1, point_t p2, color_t color)
WiredHome 83:7bad0068cca0 1259 {
WiredHome 83:7bad0068cca0 1260 return line(p1.x, p1.y, p2.x, p2.y, color);
WiredHome 83:7bad0068cca0 1261 }
WiredHome 83:7bad0068cca0 1262
WiredHome 83:7bad0068cca0 1263
WiredHome 37:f19b7e7449dc 1264 RetCode_t RA8875::line(loc_t x1, loc_t y1, loc_t x2, loc_t y2, color_t color)
WiredHome 19:3f82c1161fd2 1265 {
WiredHome 19:3f82c1161fd2 1266 foreground(color);
WiredHome 19:3f82c1161fd2 1267 return line(x1,y1,x2,y2);
WiredHome 19:3f82c1161fd2 1268 }
WiredHome 19:3f82c1161fd2 1269
WiredHome 44:207594dece70 1270
WiredHome 37:f19b7e7449dc 1271 RetCode_t RA8875::line(loc_t x1, loc_t y1, loc_t x2, loc_t y2)
WiredHome 19:3f82c1161fd2 1272 {
WiredHome 19:3f82c1161fd2 1273 PERFORMANCE_RESET;
WiredHome 62:ba5d33438fda 1274 if (x1 == x2 && y1 == y2) {
WiredHome 60:2dfd574f63bd 1275 pixel(x1, y1);
WiredHome 62:ba5d33438fda 1276 } else {
WiredHome 60:2dfd574f63bd 1277 WriteCommandW(0x91, x1);
WiredHome 60:2dfd574f63bd 1278 WriteCommandW(0x93, y1);
WiredHome 60:2dfd574f63bd 1279 WriteCommandW(0x95, x2);
WiredHome 60:2dfd574f63bd 1280 WriteCommandW(0x97, y2);
WiredHome 60:2dfd574f63bd 1281 unsigned char drawCmd = 0x00; // Line
WiredHome 60:2dfd574f63bd 1282 WriteCommand(0x90, drawCmd);
WiredHome 60:2dfd574f63bd 1283 WriteCommand(0x90, 0x80 + drawCmd); // Start drawing.
WiredHome 66:468a11f05580 1284 _WaitWhileReg(0x90, 0x80);
WiredHome 60:2dfd574f63bd 1285 }
WiredHome 19:3f82c1161fd2 1286 REGISTERPERFORMANCE(PRF_DRAWLINE);
WiredHome 19:3f82c1161fd2 1287 return noerror;
WiredHome 19:3f82c1161fd2 1288 }
WiredHome 19:3f82c1161fd2 1289
WiredHome 107:f9ccffcb84f1 1290 //
WiredHome 107:f9ccffcb84f1 1291 // Rectangle functions all mostly helpers to the basic rectangle function
WiredHome 107:f9ccffcb84f1 1292 //
WiredHome 107:f9ccffcb84f1 1293
WiredHome 81:01da2e34283d 1294 RetCode_t RA8875::fillrect(rect_t r, color_t color, fill_t fillit)
WiredHome 81:01da2e34283d 1295 {
WiredHome 81:01da2e34283d 1296 return rect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, color, fillit);
WiredHome 81:01da2e34283d 1297 }
WiredHome 44:207594dece70 1298
WiredHome 73:f22a18707b5e 1299 RetCode_t RA8875::fillrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1300 color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1301 {
WiredHome 19:3f82c1161fd2 1302 return rect(x1,y1,x2,y2,color,fillit);
WiredHome 19:3f82c1161fd2 1303 }
WiredHome 19:3f82c1161fd2 1304
WiredHome 81:01da2e34283d 1305 RetCode_t RA8875::rect(rect_t r, color_t color, fill_t fillit)
WiredHome 81:01da2e34283d 1306 {
WiredHome 81:01da2e34283d 1307 return rect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, color, fillit);
WiredHome 81:01da2e34283d 1308 }
WiredHome 44:207594dece70 1309
WiredHome 73:f22a18707b5e 1310 RetCode_t RA8875::rect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1311 color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1312 {
WiredHome 19:3f82c1161fd2 1313 foreground(color);
WiredHome 19:3f82c1161fd2 1314 return rect(x1,y1,x2,y2,fillit);
WiredHome 19:3f82c1161fd2 1315 }
WiredHome 19:3f82c1161fd2 1316
WiredHome 73:f22a18707b5e 1317 RetCode_t RA8875::rect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1318 fill_t fillit)
WiredHome 19:3f82c1161fd2 1319 {
WiredHome 85:022bba13c5c4 1320 RetCode_t ret = noerror;
WiredHome 19:3f82c1161fd2 1321 PERFORMANCE_RESET;
WiredHome 85:022bba13c5c4 1322 // check for bad_parameter
WiredHome 105:4f116006ba1f 1323 if (x1 < 0 || x1 >= screenwidth || x2 < 0 || x2 >= screenwidth
WiredHome 105:4f116006ba1f 1324 || y1 < 0 || y1 >= screenheight || y2 < 0 || y2 >= screenheight) {
WiredHome 85:022bba13c5c4 1325 ret = bad_parameter;
WiredHome 100:0b084475d5a9 1326 } else {
WiredHome 85:022bba13c5c4 1327 if (x1 == x2 && y1 == y2) {
WiredHome 85:022bba13c5c4 1328 pixel(x1, y1);
WiredHome 85:022bba13c5c4 1329 } else if (x1 == x2) {
WiredHome 85:022bba13c5c4 1330 line(x1, y1, x2, y2);
WiredHome 85:022bba13c5c4 1331 } else if (y1 == y2) {
WiredHome 85:022bba13c5c4 1332 line(x1, y1, x2, y2);
WiredHome 85:022bba13c5c4 1333 } else {
WiredHome 85:022bba13c5c4 1334 WriteCommandW(0x91, x1);
WiredHome 85:022bba13c5c4 1335 WriteCommandW(0x93, y1);
WiredHome 85:022bba13c5c4 1336 WriteCommandW(0x95, x2);
WiredHome 85:022bba13c5c4 1337 WriteCommandW(0x97, y2);
WiredHome 85:022bba13c5c4 1338 unsigned char drawCmd = 0x10; // Rectangle
WiredHome 85:022bba13c5c4 1339 if (fillit == FILL)
WiredHome 85:022bba13c5c4 1340 drawCmd |= 0x20;
WiredHome 85:022bba13c5c4 1341 WriteCommand(0x90, drawCmd);
WiredHome 85:022bba13c5c4 1342 ret = WriteCommand(0x90, 0x80 + drawCmd); // Start drawing.
WiredHome 85:022bba13c5c4 1343 _WaitWhileReg(0x90, 0x80);
WiredHome 85:022bba13c5c4 1344 }
WiredHome 19:3f82c1161fd2 1345 }
WiredHome 19:3f82c1161fd2 1346 REGISTERPERFORMANCE(PRF_DRAWRECTANGLE);
WiredHome 85:022bba13c5c4 1347 return ret;
WiredHome 19:3f82c1161fd2 1348 }
WiredHome 19:3f82c1161fd2 1349
WiredHome 44:207594dece70 1350
WiredHome 107:f9ccffcb84f1 1351 //
WiredHome 107:f9ccffcb84f1 1352 // rounded rectangle functions are mostly helpers to the base round rect
WiredHome 107:f9ccffcb84f1 1353 //
WiredHome 107:f9ccffcb84f1 1354
WiredHome 107:f9ccffcb84f1 1355 RetCode_t RA8875::fillroundrect(rect_t r, dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome 107:f9ccffcb84f1 1356 {
WiredHome 107:f9ccffcb84f1 1357 return roundrect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, radius1, radius2, color, fillit);
WiredHome 107:f9ccffcb84f1 1358 }
WiredHome 107:f9ccffcb84f1 1359
WiredHome 73:f22a18707b5e 1360 RetCode_t RA8875::fillroundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1361 dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1362 {
WiredHome 19:3f82c1161fd2 1363 foreground(color);
WiredHome 19:3f82c1161fd2 1364 return roundrect(x1,y1,x2,y2,radius1,radius2,fillit);
WiredHome 19:3f82c1161fd2 1365 }
WiredHome 19:3f82c1161fd2 1366
WiredHome 107:f9ccffcb84f1 1367 RetCode_t RA8875::roundrect(rect_t r, dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome 107:f9ccffcb84f1 1368 {
WiredHome 107:f9ccffcb84f1 1369 return roundrect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, radius1, radius2, color, fillit);
WiredHome 107:f9ccffcb84f1 1370 }
WiredHome 44:207594dece70 1371
WiredHome 73:f22a18707b5e 1372 RetCode_t RA8875::roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1373 dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1374 {
WiredHome 19:3f82c1161fd2 1375 foreground(color);
WiredHome 19:3f82c1161fd2 1376 return roundrect(x1,y1,x2,y2,radius1,radius2,fillit);
WiredHome 19:3f82c1161fd2 1377 }
WiredHome 19:3f82c1161fd2 1378
WiredHome 44:207594dece70 1379
WiredHome 73:f22a18707b5e 1380 RetCode_t RA8875::roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1381 dim_t radius1, dim_t radius2, fill_t fillit)
WiredHome 19:3f82c1161fd2 1382 {
WiredHome 19:3f82c1161fd2 1383 RetCode_t ret = noerror;
WiredHome 73:f22a18707b5e 1384
WiredHome 19:3f82c1161fd2 1385 PERFORMANCE_RESET;
WiredHome 105:4f116006ba1f 1386 if (x1 < 0 || x1 >= screenwidth || x2 < 0 || x2 >= screenwidth
WiredHome 105:4f116006ba1f 1387 || y1 < 0 || y1 >= screenheight || y2 < 0 || y2 >= screenheight) {
WiredHome 85:022bba13c5c4 1388 ret = bad_parameter;
WiredHome 85:022bba13c5c4 1389 } else if (x1 > x2 || y1 > y2 || (radius1 > (x2-x1)/2) || (radius2 > (y2-y1)/2) ) {
WiredHome 21:3c1efb192927 1390 ret = bad_parameter;
WiredHome 21:3c1efb192927 1391 } else if (x1 == x2 && y1 == y2) {
WiredHome 19:3f82c1161fd2 1392 pixel(x1, y1);
WiredHome 19:3f82c1161fd2 1393 } else if (x1 == x2) {
WiredHome 19:3f82c1161fd2 1394 line(x1, y1, x2, y2);
WiredHome 19:3f82c1161fd2 1395 } else if (y1 == y2) {
WiredHome 19:3f82c1161fd2 1396 line(x1, y1, x2, y2);
WiredHome 19:3f82c1161fd2 1397 } else {
WiredHome 38:38d503b4fad6 1398 WriteCommandW(0x91, x1);
WiredHome 38:38d503b4fad6 1399 WriteCommandW(0x93, y1);
WiredHome 38:38d503b4fad6 1400 WriteCommandW(0x95, x2);
WiredHome 38:38d503b4fad6 1401 WriteCommandW(0x97, y2);
WiredHome 38:38d503b4fad6 1402 WriteCommandW(0xA1, radius1);
WiredHome 38:38d503b4fad6 1403 WriteCommandW(0xA3, radius2);
WiredHome 21:3c1efb192927 1404 // Should not need this...
WiredHome 38:38d503b4fad6 1405 WriteCommandW(0xA5, 0);
WiredHome 38:38d503b4fad6 1406 WriteCommandW(0xA7, 0);
WiredHome 19:3f82c1161fd2 1407 unsigned char drawCmd = 0x20; // Rounded Rectangle
WiredHome 19:3f82c1161fd2 1408 if (fillit == FILL)
WiredHome 19:3f82c1161fd2 1409 drawCmd |= 0x40;
WiredHome 19:3f82c1161fd2 1410 WriteCommand(0xA0, drawCmd);
WiredHome 19:3f82c1161fd2 1411 WriteCommand(0xA0, 0x80 + drawCmd); // Start drawing.
WiredHome 66:468a11f05580 1412 _WaitWhileReg(0xA0, 0x80);
WiredHome 19:3f82c1161fd2 1413 }
WiredHome 19:3f82c1161fd2 1414 REGISTERPERFORMANCE(PRF_DRAWROUNDEDRECTANGLE);
WiredHome 19:3f82c1161fd2 1415 return ret;
WiredHome 19:3f82c1161fd2 1416 }
WiredHome 19:3f82c1161fd2 1417
WiredHome 44:207594dece70 1418
WiredHome 107:f9ccffcb84f1 1419 //
WiredHome 107:f9ccffcb84f1 1420 // triangle functions
WiredHome 107:f9ccffcb84f1 1421 //
WiredHome 107:f9ccffcb84f1 1422
WiredHome 73:f22a18707b5e 1423 RetCode_t RA8875::triangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1424 loc_t x3, loc_t y3, color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1425 {
WiredHome 20:6e2e4a8372eb 1426 RetCode_t ret;
WiredHome 20:6e2e4a8372eb 1427
WiredHome 105:4f116006ba1f 1428 if (x1 < 0 || x1 >= screenwidth || x2 < 0 || x2 >= screenwidth || x3 < 0 || x3 >= screenwidth
WiredHome 105:4f116006ba1f 1429 || y1 < 0 || y1 >= screenheight || y2 < 0 || y2 >= screenheight || y3 < 0 || y3 >= screenheight)
WiredHome 85:022bba13c5c4 1430 ret = bad_parameter;
WiredHome 19:3f82c1161fd2 1431 foreground(color);
WiredHome 20:6e2e4a8372eb 1432 ret = triangle(x1,y1,x2,y2,x3,y3,fillit);
WiredHome 20:6e2e4a8372eb 1433 return ret;
WiredHome 19:3f82c1161fd2 1434 }
WiredHome 19:3f82c1161fd2 1435
WiredHome 44:207594dece70 1436
WiredHome 73:f22a18707b5e 1437 RetCode_t RA8875::filltriangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1438 loc_t x3, loc_t y3, color_t color, fill_t fillit)
WiredHome 73:f22a18707b5e 1439 {
WiredHome 73:f22a18707b5e 1440 RetCode_t ret;
WiredHome 73:f22a18707b5e 1441
WiredHome 73:f22a18707b5e 1442 foreground(color);
WiredHome 73:f22a18707b5e 1443 ret = triangle(x1,y1,x2,y2,x3,y3,fillit);
WiredHome 73:f22a18707b5e 1444 return ret;
WiredHome 73:f22a18707b5e 1445 }
WiredHome 73:f22a18707b5e 1446
WiredHome 73:f22a18707b5e 1447
WiredHome 73:f22a18707b5e 1448 RetCode_t RA8875::triangle(loc_t x1, loc_t y1 ,loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1449 loc_t x3, loc_t y3, fill_t fillit)
WiredHome 19:3f82c1161fd2 1450 {
WiredHome 19:3f82c1161fd2 1451 RetCode_t ret = noerror;
WiredHome 73:f22a18707b5e 1452
WiredHome 19:3f82c1161fd2 1453 PERFORMANCE_RESET;
WiredHome 19:3f82c1161fd2 1454 if (x1 == x2 && y1 == y2 && x1 == x3 && y1 == y3) {
WiredHome 19:3f82c1161fd2 1455 pixel(x1, y1);
WiredHome 19:3f82c1161fd2 1456 } else {
WiredHome 38:38d503b4fad6 1457 WriteCommandW(0x91, x1);
WiredHome 38:38d503b4fad6 1458 WriteCommandW(0x93, y1);
WiredHome 38:38d503b4fad6 1459 WriteCommandW(0x95, x2);
WiredHome 38:38d503b4fad6 1460 WriteCommandW(0x97, y2);
WiredHome 38:38d503b4fad6 1461 WriteCommandW(0xA9, x3);
WiredHome 38:38d503b4fad6 1462 WriteCommandW(0xAB, y3);
WiredHome 19:3f82c1161fd2 1463 unsigned char drawCmd = 0x01; // Triangle
WiredHome 19:3f82c1161fd2 1464 if (fillit == FILL)
WiredHome 19:3f82c1161fd2 1465 drawCmd |= 0x20;
WiredHome 19:3f82c1161fd2 1466 WriteCommand(0x90, drawCmd);
WiredHome 19:3f82c1161fd2 1467 WriteCommand(0x90, 0x80 + drawCmd); // Start drawing.
WiredHome 66:468a11f05580 1468 _WaitWhileReg(0x90, 0x80);
WiredHome 19:3f82c1161fd2 1469 }
WiredHome 19:3f82c1161fd2 1470 REGISTERPERFORMANCE(PRF_DRAWTRIANGLE);
WiredHome 19:3f82c1161fd2 1471 return ret;
WiredHome 19:3f82c1161fd2 1472 }
WiredHome 19:3f82c1161fd2 1473
WiredHome 83:7bad0068cca0 1474
WiredHome 83:7bad0068cca0 1475 RetCode_t RA8875::circle(point_t p, dim_t radius,
WiredHome 83:7bad0068cca0 1476 color_t color, fill_t fillit)
WiredHome 83:7bad0068cca0 1477 {
WiredHome 83:7bad0068cca0 1478 foreground(color);
WiredHome 83:7bad0068cca0 1479 return circle(p.x,p.y,radius,fillit);
WiredHome 83:7bad0068cca0 1480 }
WiredHome 83:7bad0068cca0 1481
WiredHome 83:7bad0068cca0 1482
WiredHome 83:7bad0068cca0 1483 RetCode_t RA8875::fillcircle(point_t p, dim_t radius,
WiredHome 83:7bad0068cca0 1484 color_t color, fill_t fillit)
WiredHome 83:7bad0068cca0 1485 {
WiredHome 83:7bad0068cca0 1486 foreground(color);
WiredHome 83:7bad0068cca0 1487 return circle(p.x,p.y,radius,fillit);
WiredHome 83:7bad0068cca0 1488 }
WiredHome 83:7bad0068cca0 1489
WiredHome 83:7bad0068cca0 1490
WiredHome 83:7bad0068cca0 1491 RetCode_t RA8875::circle(point_t p, dim_t radius, fill_t fillit)
WiredHome 83:7bad0068cca0 1492 {
WiredHome 83:7bad0068cca0 1493 return circle(p.x,p.y,radius,fillit);
WiredHome 83:7bad0068cca0 1494 }
WiredHome 83:7bad0068cca0 1495
WiredHome 83:7bad0068cca0 1496
WiredHome 73:f22a18707b5e 1497 RetCode_t RA8875::circle(loc_t x, loc_t y, dim_t radius,
WiredHome 73:f22a18707b5e 1498 color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1499 {
WiredHome 19:3f82c1161fd2 1500 foreground(color);
WiredHome 19:3f82c1161fd2 1501 return circle(x,y,radius,fillit);
WiredHome 19:3f82c1161fd2 1502 }
WiredHome 19:3f82c1161fd2 1503
WiredHome 44:207594dece70 1504
WiredHome 73:f22a18707b5e 1505 RetCode_t RA8875::fillcircle(loc_t x, loc_t y, dim_t radius,
WiredHome 73:f22a18707b5e 1506 color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1507 {
WiredHome 19:3f82c1161fd2 1508 foreground(color);
WiredHome 19:3f82c1161fd2 1509 return circle(x,y,radius,fillit);
WiredHome 19:3f82c1161fd2 1510 }
WiredHome 19:3f82c1161fd2 1511
WiredHome 44:207594dece70 1512
WiredHome 37:f19b7e7449dc 1513 RetCode_t RA8875::circle(loc_t x, loc_t y, dim_t radius, fill_t fillit)
WiredHome 19:3f82c1161fd2 1514 {
WiredHome 19:3f82c1161fd2 1515 RetCode_t ret = noerror;
WiredHome 73:f22a18707b5e 1516
WiredHome 19:3f82c1161fd2 1517 PERFORMANCE_RESET;
WiredHome 105:4f116006ba1f 1518 if (radius <= 0 || (x - radius) < 0 || (x + radius) > screenwidth
WiredHome 105:4f116006ba1f 1519 || (y - radius) < 0 || (y + radius) > screenheight) {
WiredHome 19:3f82c1161fd2 1520 ret = bad_parameter;
WiredHome 19:3f82c1161fd2 1521 } else if (radius == 1) {
WiredHome 19:3f82c1161fd2 1522 pixel(x,y);
WiredHome 19:3f82c1161fd2 1523 } else {
WiredHome 38:38d503b4fad6 1524 WriteCommandW(0x99, x);
WiredHome 38:38d503b4fad6 1525 WriteCommandW(0x9B, y);
WiredHome 19:3f82c1161fd2 1526 WriteCommand(0x9d, radius & 0xFF);
WiredHome 19:3f82c1161fd2 1527 unsigned char drawCmd = 0x00; // Circle
WiredHome 19:3f82c1161fd2 1528 if (fillit == FILL)
WiredHome 19:3f82c1161fd2 1529 drawCmd |= 0x20;
WiredHome 19:3f82c1161fd2 1530 WriteCommand(0x90, drawCmd);
WiredHome 19:3f82c1161fd2 1531 WriteCommand(0x90, 0x40 + drawCmd); // Start drawing.
WiredHome 66:468a11f05580 1532 _WaitWhileReg(0x90, 0x40);
WiredHome 19:3f82c1161fd2 1533 }
WiredHome 19:3f82c1161fd2 1534 REGISTERPERFORMANCE(PRF_DRAWCIRCLE);
WiredHome 19:3f82c1161fd2 1535 return ret;
WiredHome 19:3f82c1161fd2 1536 }
WiredHome 19:3f82c1161fd2 1537
WiredHome 44:207594dece70 1538
WiredHome 37:f19b7e7449dc 1539 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 1540 {
WiredHome 19:3f82c1161fd2 1541 foreground(color);
WiredHome 25:9556a3a9b7cc 1542 return ellipse(x,y,radius1,radius2,fillit);
WiredHome 19:3f82c1161fd2 1543 }
WiredHome 19:3f82c1161fd2 1544
WiredHome 44:207594dece70 1545
WiredHome 37:f19b7e7449dc 1546 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 1547 {
WiredHome 25:9556a3a9b7cc 1548 foreground(color);
WiredHome 25:9556a3a9b7cc 1549 return ellipse(x,y,radius1,radius2,fillit);
WiredHome 25:9556a3a9b7cc 1550 }
WiredHome 44:207594dece70 1551
WiredHome 73:f22a18707b5e 1552
WiredHome 37:f19b7e7449dc 1553 RetCode_t RA8875::ellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, fill_t fillit)
WiredHome 19:3f82c1161fd2 1554 {
WiredHome 19:3f82c1161fd2 1555 RetCode_t ret = noerror;
WiredHome 73:f22a18707b5e 1556
WiredHome 19:3f82c1161fd2 1557 PERFORMANCE_RESET;
WiredHome 105:4f116006ba1f 1558 if (radius1 <= 0 || radius2 <= 0 || (x - radius1) < 0 || (x + radius1) > screenwidth
WiredHome 105:4f116006ba1f 1559 || (y - radius2) < 0 || (y + radius2) > screenheight) {
WiredHome 85:022bba13c5c4 1560 ret = bad_parameter;
WiredHome 25:9556a3a9b7cc 1561 } else if (radius1 == 1 && radius2 == 1) {
WiredHome 19:3f82c1161fd2 1562 pixel(x, y);
WiredHome 19:3f82c1161fd2 1563 } else {
WiredHome 38:38d503b4fad6 1564 WriteCommandW(0xA5, x);
WiredHome 38:38d503b4fad6 1565 WriteCommandW(0xA7, y);
WiredHome 38:38d503b4fad6 1566 WriteCommandW(0xA1, radius1);
WiredHome 38:38d503b4fad6 1567 WriteCommandW(0xA3, radius2);
WiredHome 19:3f82c1161fd2 1568 unsigned char drawCmd = 0x00; // Ellipse
WiredHome 19:3f82c1161fd2 1569 if (fillit == FILL)
WiredHome 19:3f82c1161fd2 1570 drawCmd |= 0x40;
WiredHome 19:3f82c1161fd2 1571 WriteCommand(0xA0, drawCmd);
WiredHome 19:3f82c1161fd2 1572 WriteCommand(0xA0, 0x80 + drawCmd); // Start drawing.
WiredHome 66:468a11f05580 1573 _WaitWhileReg(0xA0, 0x80);
WiredHome 19:3f82c1161fd2 1574 }
WiredHome 19:3f82c1161fd2 1575 REGISTERPERFORMANCE(PRF_DRAWELLIPSE);
WiredHome 19:3f82c1161fd2 1576 return ret;
WiredHome 19:3f82c1161fd2 1577 }
WiredHome 19:3f82c1161fd2 1578
WiredHome 44:207594dece70 1579
WiredHome 68:ab08efabfc88 1580 RetCode_t RA8875::frequency(unsigned long Hz, unsigned long Hz2)
WiredHome 19:3f82c1161fd2 1581 {
WiredHome 66:468a11f05580 1582 spiwritefreq = Hz;
WiredHome 68:ab08efabfc88 1583 if (Hz2 != 0)
WiredHome 68:ab08efabfc88 1584 spireadfreq = Hz2;
WiredHome 68:ab08efabfc88 1585 else
WiredHome 68:ab08efabfc88 1586 spireadfreq = Hz/2;
WiredHome 68:ab08efabfc88 1587 _setWriteSpeed(true);
WiredHome 19:3f82c1161fd2 1588 // __ ___
WiredHome 19:3f82c1161fd2 1589 // Clock ___A Rising edge latched
WiredHome 19:3f82c1161fd2 1590 // ___ ____
WiredHome 19:3f82c1161fd2 1591 // Data ___X____
WiredHome 19:3f82c1161fd2 1592 spi.format(8, 3); // 8 bits and clock to data phase 0
WiredHome 19:3f82c1161fd2 1593 return noerror;
WiredHome 19:3f82c1161fd2 1594 }
WiredHome 19:3f82c1161fd2 1595
WiredHome 68:ab08efabfc88 1596 void RA8875::_setWriteSpeed(bool writeSpeed)
WiredHome 68:ab08efabfc88 1597 {
WiredHome 68:ab08efabfc88 1598 if (writeSpeed) {
WiredHome 68:ab08efabfc88 1599 spi.frequency(spiwritefreq);
WiredHome 68:ab08efabfc88 1600 spiWriteSpeed = true;
WiredHome 68:ab08efabfc88 1601 } else {
WiredHome 68:ab08efabfc88 1602 spi.frequency(spireadfreq);
WiredHome 68:ab08efabfc88 1603 spiWriteSpeed = false;
WiredHome 68:ab08efabfc88 1604 }
WiredHome 68:ab08efabfc88 1605 }
WiredHome 44:207594dece70 1606
WiredHome 19:3f82c1161fd2 1607 RetCode_t RA8875::Power(bool on)
WiredHome 19:3f82c1161fd2 1608 {
WiredHome 19:3f82c1161fd2 1609 WriteCommand(0x01, (on) ? 0x80 : 0x00);
WiredHome 19:3f82c1161fd2 1610 return noerror;
WiredHome 19:3f82c1161fd2 1611 }
WiredHome 19:3f82c1161fd2 1612
WiredHome 44:207594dece70 1613
WiredHome 19:3f82c1161fd2 1614 RetCode_t RA8875::Backlight_u8(unsigned char brightness)
WiredHome 19:3f82c1161fd2 1615 {
WiredHome 19:3f82c1161fd2 1616 static bool is_enabled = false;
WiredHome 19:3f82c1161fd2 1617 if (brightness == 0) {
WiredHome 19:3f82c1161fd2 1618 WriteCommand(0x8a); // Disable the PWM
WiredHome 19:3f82c1161fd2 1619 WriteData(0x00);
WiredHome 19:3f82c1161fd2 1620 is_enabled = false;
WiredHome 19:3f82c1161fd2 1621 } else if (!is_enabled) {
WiredHome 19:3f82c1161fd2 1622 WriteCommand(0x8a); // Enable the PWM
WiredHome 19:3f82c1161fd2 1623 WriteData(0x80);
WiredHome 19:3f82c1161fd2 1624 WriteCommand(0x8a); // Not sure why this is needed, but following the pattern
WiredHome 19:3f82c1161fd2 1625 WriteData(0x81); // open PWM (SYS_CLK / 2 as best I can tell)
WiredHome 19:3f82c1161fd2 1626 is_enabled = true;
WiredHome 19:3f82c1161fd2 1627 }
WiredHome 19:3f82c1161fd2 1628 WriteCommand(0x8b, brightness); // Brightness parameter 0xff-0x00
WiredHome 19:3f82c1161fd2 1629 return noerror;
WiredHome 19:3f82c1161fd2 1630 }
WiredHome 19:3f82c1161fd2 1631
WiredHome 86:e86b355940f4 1632 uint8_t RA8875::GetBacklight_u8(void)
WiredHome 86:e86b355940f4 1633 {
WiredHome 86:e86b355940f4 1634 return ReadCommand(0x8b);
WiredHome 86:e86b355940f4 1635 }
WiredHome 44:207594dece70 1636
WiredHome 19:3f82c1161fd2 1637 RetCode_t RA8875::Backlight(float brightness)
WiredHome 19:3f82c1161fd2 1638 {
WiredHome 19:3f82c1161fd2 1639 unsigned char b;
WiredHome 73:f22a18707b5e 1640
WiredHome 29:422616aa04bd 1641 if (brightness >= 1.0)
WiredHome 19:3f82c1161fd2 1642 b = 255;
WiredHome 29:422616aa04bd 1643 else if (brightness <= 0.0)
WiredHome 19:3f82c1161fd2 1644 b = 0;
WiredHome 19:3f82c1161fd2 1645 else
WiredHome 19:3f82c1161fd2 1646 b = (unsigned char)(brightness * 255);
WiredHome 19:3f82c1161fd2 1647 return Backlight_u8(b);
WiredHome 19:3f82c1161fd2 1648 }
WiredHome 19:3f82c1161fd2 1649
WiredHome 86:e86b355940f4 1650 float RA8875::GetBacklight(void)
WiredHome 86:e86b355940f4 1651 {
WiredHome 86:e86b355940f4 1652 return (float)(GetBacklight_u8())/255;
WiredHome 86:e86b355940f4 1653 }
WiredHome 44:207594dece70 1654
WiredHome 98:ecebed9b80b2 1655 RetCode_t RA8875::SelectUserFont(const uint8_t * _font)
WiredHome 98:ecebed9b80b2 1656 {
WiredHome 98:ecebed9b80b2 1657 INFO("Cursor(%d,%d) %p", cursor_x, cursor_y, _font);
WiredHome 98:ecebed9b80b2 1658 INFO("Text C(%d,%d)", GetTextCursor_X(), GetTextCursor_Y());
WiredHome 98:ecebed9b80b2 1659 if (_font) {
WiredHome 98:ecebed9b80b2 1660 HexDump("Font Memory", _font, 16);
WiredHome 98:ecebed9b80b2 1661 extFontHeight = _font[6];
WiredHome 98:ecebed9b80b2 1662 uint32_t totalWidth = 0;
WiredHome 98:ecebed9b80b2 1663 uint16_t firstChar = _font[3] * 256 + _font[2];
WiredHome 98:ecebed9b80b2 1664 uint16_t lastChar = _font[5] * 256 + _font[4];
WiredHome 98:ecebed9b80b2 1665 uint16_t i;
WiredHome 98:ecebed9b80b2 1666
WiredHome 98:ecebed9b80b2 1667 for (i=firstChar; i<=lastChar; i++) {
WiredHome 98:ecebed9b80b2 1668 // 8 bytes of preamble to the first level lookup table
WiredHome 98:ecebed9b80b2 1669 uint16_t offsetToCharLookup = 8 + 4 * (i - firstChar); // 4-bytes: width(pixels), 16-bit offset from table start, 0
WiredHome 98:ecebed9b80b2 1670 totalWidth += _font[offsetToCharLookup];
WiredHome 98:ecebed9b80b2 1671 }
WiredHome 98:ecebed9b80b2 1672 extFontWidth = totalWidth / (lastChar - firstChar);
WiredHome 98:ecebed9b80b2 1673 INFO("Font Metrics: Avg W: %2d, H: %2d, First:%d, Last:%d", extFontWidth, extFontHeight, firstChar, lastChar);
WiredHome 98:ecebed9b80b2 1674 }
WiredHome 98:ecebed9b80b2 1675 SetTextCursor(GetTextCursor_X(), GetTextCursor_Y()); // soft-font cursor -> hw cursor
WiredHome 98:ecebed9b80b2 1676 font = _font;
WiredHome 98:ecebed9b80b2 1677 return GraphicsDisplay::SelectUserFont(_font);
WiredHome 98:ecebed9b80b2 1678 }
WiredHome 44:207594dece70 1679
WiredHome 19:3f82c1161fd2 1680 RetCode_t RA8875::background(color_t color)
WiredHome 19:3f82c1161fd2 1681 {
WiredHome 37:f19b7e7449dc 1682 GraphicsDisplay::background(color);
WiredHome 19:3f82c1161fd2 1683 WriteCommand(0x60, (color>>11)); // BGCR0
WiredHome 19:3f82c1161fd2 1684 WriteCommand(0x61, (unsigned char)(color>>5)); // BGCR0
WiredHome 19:3f82c1161fd2 1685 WriteCommand(0x62, (unsigned char)(color)); // BGCR0
WiredHome 19:3f82c1161fd2 1686 return noerror;
WiredHome 19:3f82c1161fd2 1687 }
WiredHome 19:3f82c1161fd2 1688
WiredHome 44:207594dece70 1689
WiredHome 19:3f82c1161fd2 1690 RetCode_t RA8875::background(unsigned char r, unsigned char g, unsigned char b)
WiredHome 19:3f82c1161fd2 1691 {
WiredHome 37:f19b7e7449dc 1692 background(RGB(r,g,b));
WiredHome 19:3f82c1161fd2 1693 return noerror;
WiredHome 19:3f82c1161fd2 1694 }
WiredHome 19:3f82c1161fd2 1695
WiredHome 44:207594dece70 1696
WiredHome 19:3f82c1161fd2 1697 RetCode_t RA8875::foreground(color_t color)
WiredHome 19:3f82c1161fd2 1698 {
WiredHome 37:f19b7e7449dc 1699 GraphicsDisplay::foreground(color);
WiredHome 19:3f82c1161fd2 1700 WriteCommand(0x63, (unsigned char)(color>>11));
WiredHome 19:3f82c1161fd2 1701 WriteCommand(0x64, (unsigned char)(color>>5));
WiredHome 19:3f82c1161fd2 1702 WriteCommand(0x65, (unsigned char)(color));
WiredHome 19:3f82c1161fd2 1703 return noerror;
WiredHome 19:3f82c1161fd2 1704 }
WiredHome 19:3f82c1161fd2 1705
WiredHome 44:207594dece70 1706
WiredHome 37:f19b7e7449dc 1707 RetCode_t RA8875::foreground(unsigned char r, unsigned char g, unsigned char b)
WiredHome 19:3f82c1161fd2 1708 {
WiredHome 37:f19b7e7449dc 1709 foreground(RGB(r,g,b));
WiredHome 19:3f82c1161fd2 1710 return noerror;
WiredHome 19:3f82c1161fd2 1711 }
WiredHome 19:3f82c1161fd2 1712
WiredHome 44:207594dece70 1713
WiredHome 37:f19b7e7449dc 1714 color_t RA8875::GetForeColor(void)
WiredHome 19:3f82c1161fd2 1715 {
WiredHome 19:3f82c1161fd2 1716 color_t color;
WiredHome 73:f22a18707b5e 1717
WiredHome 19:3f82c1161fd2 1718 color = (ReadCommand(0x63) & 0x1F) << 11;
WiredHome 19:3f82c1161fd2 1719 color |= (ReadCommand(0x64) & 0x3F) << 5;
WiredHome 19:3f82c1161fd2 1720 color |= (ReadCommand(0x65) & 0x1F);
WiredHome 19:3f82c1161fd2 1721 return color;
WiredHome 19:3f82c1161fd2 1722 }
WiredHome 19:3f82c1161fd2 1723
WiredHome 44:207594dece70 1724
WiredHome 19:3f82c1161fd2 1725 color_t RA8875::DOSColor(int i)
WiredHome 73:f22a18707b5e 1726 {
WiredHome 73:f22a18707b5e 1727 const color_t colors[16] = {
WiredHome 19:3f82c1161fd2 1728 Black, Blue, Green, Cyan,
WiredHome 19:3f82c1161fd2 1729 Red, Magenta, Brown, Gray,
WiredHome 19:3f82c1161fd2 1730 Charcoal, BrightBlue, BrightGreen, BrightCyan,
WiredHome 19:3f82c1161fd2 1731 Orange, Pink, Yellow, White
WiredHome 73:f22a18707b5e 1732 };
WiredHome 85:022bba13c5c4 1733 if (i >= 0 && i < 16)
WiredHome 19:3f82c1161fd2 1734 return colors[i];
WiredHome 19:3f82c1161fd2 1735 else
WiredHome 19:3f82c1161fd2 1736 return 0;
WiredHome 73:f22a18707b5e 1737 }
WiredHome 19:3f82c1161fd2 1738
WiredHome 44:207594dece70 1739
WiredHome 73:f22a18707b5e 1740 const char * RA8875::DOSColorNames(int i)
WiredHome 73:f22a18707b5e 1741 {
WiredHome 73:f22a18707b5e 1742 const char * names[16] = {
WiredHome 19:3f82c1161fd2 1743 "Black", "Blue", "Green", "Cyan",
WiredHome 19:3f82c1161fd2 1744 "Red", "Magenta", "Brown", "Gray",
WiredHome 19:3f82c1161fd2 1745 "Charcoal", "BrightBlue", "BrightGreen", "BrightCyan",
WiredHome 19:3f82c1161fd2 1746 "Orange", "Pink", "Yellow", "White"
WiredHome 73:f22a18707b5e 1747 };
WiredHome 85:022bba13c5c4 1748 if (i >= 0 && i < 16)
WiredHome 19:3f82c1161fd2 1749 return names[i];
WiredHome 19:3f82c1161fd2 1750 else
WiredHome 19:3f82c1161fd2 1751 return NULL;
WiredHome 73:f22a18707b5e 1752 }
WiredHome 19:3f82c1161fd2 1753
WiredHome 19:3f82c1161fd2 1754
WiredHome 19:3f82c1161fd2 1755 ///////////////////////////////////////////////////////////////
WiredHome 19:3f82c1161fd2 1756 // Private functions
WiredHome 19:3f82c1161fd2 1757
WiredHome 79:544eb4964795 1758 unsigned char RA8875::_spiwrite(unsigned char data)
WiredHome 19:3f82c1161fd2 1759 {
WiredHome 19:3f82c1161fd2 1760 unsigned char retval;
WiredHome 73:f22a18707b5e 1761
WiredHome 68:ab08efabfc88 1762 if (!spiWriteSpeed)
WiredHome 68:ab08efabfc88 1763 _setWriteSpeed(true);
WiredHome 19:3f82c1161fd2 1764 retval = spi.write(data);
WiredHome 19:3f82c1161fd2 1765 return retval;
WiredHome 19:3f82c1161fd2 1766 }
WiredHome 19:3f82c1161fd2 1767
WiredHome 44:207594dece70 1768
WiredHome 79:544eb4964795 1769 unsigned char RA8875::_spiread(void)
WiredHome 19:3f82c1161fd2 1770 {
WiredHome 19:3f82c1161fd2 1771 unsigned char retval;
WiredHome 19:3f82c1161fd2 1772 unsigned char data = 0;
WiredHome 73:f22a18707b5e 1773
WiredHome 68:ab08efabfc88 1774 if (spiWriteSpeed)
WiredHome 68:ab08efabfc88 1775 _setWriteSpeed(false);
WiredHome 19:3f82c1161fd2 1776 retval = spi.write(data);
WiredHome 19:3f82c1161fd2 1777 return retval;
WiredHome 19:3f82c1161fd2 1778 }
WiredHome 19:3f82c1161fd2 1779
WiredHome 44:207594dece70 1780
WiredHome 79:544eb4964795 1781 RetCode_t RA8875::_select(bool chipsel)
WiredHome 19:3f82c1161fd2 1782 {
WiredHome 19:3f82c1161fd2 1783 cs = (chipsel == true) ? 0 : 1;
WiredHome 19:3f82c1161fd2 1784 return noerror;
WiredHome 19:3f82c1161fd2 1785 }
WiredHome 19:3f82c1161fd2 1786
WiredHome 44:207594dece70 1787
WiredHome 72:ecffe56af969 1788 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 1789 {
WiredHome 74:686faa218914 1790 (void)layer;
WiredHome 96:40b74dd3695b 1791
WiredHome 96:40b74dd3695b 1792 // AttachPrintHandler(this, RA8875::_printCallback);
WiredHome 96:40b74dd3695b 1793 // return PrintScreen(x,y,w,h);
WiredHome 74:686faa218914 1794 return PrintScreen(x, y, w, h, Name_BMP);
WiredHome 72:ecffe56af969 1795 }
WiredHome 72:ecffe56af969 1796
WiredHome 96:40b74dd3695b 1797 RetCode_t RA8875::_printCallback(RA8875::filecmd_t cmd, uint8_t * buffer, uint16_t size)
WiredHome 96:40b74dd3695b 1798 {
WiredHome 96:40b74dd3695b 1799 HexDump("CB", buffer, size);
WiredHome 96:40b74dd3695b 1800 switch(cmd) {
WiredHome 96:40b74dd3695b 1801 case RA8875::OPEN:
WiredHome 96:40b74dd3695b 1802 //pc.printf("About to write %lu bytes\r\n", *(uint32_t *)buffer);
WiredHome 96:40b74dd3695b 1803 _printFH = fopen("file.bmp", "w+b");
WiredHome 96:40b74dd3695b 1804 if (_printFH == 0)
WiredHome 96:40b74dd3695b 1805 return file_not_found;
WiredHome 96:40b74dd3695b 1806 break;
WiredHome 96:40b74dd3695b 1807 case RA8875::WRITE:
WiredHome 96:40b74dd3695b 1808 //pc.printf(" Write %4u bytes\r\n", size);
WiredHome 96:40b74dd3695b 1809 fwrite(buffer, 1, size, _printFH);
WiredHome 96:40b74dd3695b 1810 break;
WiredHome 96:40b74dd3695b 1811 case RA8875::CLOSE:
WiredHome 96:40b74dd3695b 1812 //pc.printf(" close\r\n");
WiredHome 96:40b74dd3695b 1813 fclose(_printFH);
WiredHome 96:40b74dd3695b 1814 _printFH = 0;
WiredHome 96:40b74dd3695b 1815 break;
WiredHome 96:40b74dd3695b 1816 default:
WiredHome 96:40b74dd3695b 1817 //pc.printf("Unexpected callback %d\r\n", cmd);
WiredHome 96:40b74dd3695b 1818 return file_not_found;
WiredHome 96:40b74dd3695b 1819 //break;
WiredHome 96:40b74dd3695b 1820 }
WiredHome 96:40b74dd3695b 1821 return noerror;
WiredHome 96:40b74dd3695b 1822 }
WiredHome 96:40b74dd3695b 1823
WiredHome 96:40b74dd3695b 1824 RetCode_t RA8875::PrintScreen(loc_t x, loc_t y, dim_t w, dim_t h)
WiredHome 96:40b74dd3695b 1825 {
WiredHome 96:40b74dd3695b 1826 BITMAPFILEHEADER BMP_Header;
WiredHome 96:40b74dd3695b 1827 BITMAPINFOHEADER BMP_Info;
WiredHome 96:40b74dd3695b 1828 uint8_t * lineBuffer = NULL;
WiredHome 96:40b74dd3695b 1829 color_t * pixelBuffer = NULL;
WiredHome 96:40b74dd3695b 1830 color_t * pixelBuffer2 = NULL;
WiredHome 96:40b74dd3695b 1831
WiredHome 98:ecebed9b80b2 1832 INFO("(%d,%d) - (%d,%d)", x,y,w,h);
WiredHome 105:4f116006ba1f 1833 if (x >= 0 && x < screenwidth
WiredHome 105:4f116006ba1f 1834 && y >= 0 && y < screenheight
WiredHome 105:4f116006ba1f 1835 && w > 0 && x + w <= screenwidth
WiredHome 105:4f116006ba1f 1836 && h > 0 && y + h <= screenheight) {
WiredHome 96:40b74dd3695b 1837
WiredHome 96:40b74dd3695b 1838 BMP_Header.bfType = BF_TYPE;
WiredHome 96:40b74dd3695b 1839 BMP_Header.bfSize = (w * h * sizeof(RGBQUAD)) + sizeof(BMP_Header) + sizeof(BMP_Header);
WiredHome 96:40b74dd3695b 1840 BMP_Header.bfReserved1 = 0;
WiredHome 96:40b74dd3695b 1841 BMP_Header.bfReserved2 = 0;
WiredHome 96:40b74dd3695b 1842 BMP_Header.bfOffBits = sizeof(BMP_Header) + sizeof(BMP_Header);
WiredHome 96:40b74dd3695b 1843
WiredHome 96:40b74dd3695b 1844 BMP_Info.biSize = sizeof(BMP_Info);
WiredHome 96:40b74dd3695b 1845 BMP_Info.biWidth = w;
WiredHome 96:40b74dd3695b 1846 BMP_Info.biHeight = h;
WiredHome 96:40b74dd3695b 1847 BMP_Info.biPlanes = 1;
WiredHome 96:40b74dd3695b 1848 BMP_Info.biBitCount = 24;
WiredHome 96:40b74dd3695b 1849 BMP_Info.biCompression = BI_RGB;
WiredHome 96:40b74dd3695b 1850 BMP_Info.biSizeImage = 0;
WiredHome 96:40b74dd3695b 1851 BMP_Info.biXPelsPerMeter = 0;
WiredHome 96:40b74dd3695b 1852 BMP_Info.biYPelsPerMeter = 0;
WiredHome 96:40b74dd3695b 1853 BMP_Info.biClrUsed = 0;
WiredHome 96:40b74dd3695b 1854 BMP_Info.biClrImportant = 0;
WiredHome 96:40b74dd3695b 1855
WiredHome 96:40b74dd3695b 1856 // Allocate the memory we need to proceed
WiredHome 96:40b74dd3695b 1857 int lineBufSize = ((24 * w + 7)/8);
WiredHome 96:40b74dd3695b 1858 lineBuffer = (uint8_t *)malloc(lineBufSize);
WiredHome 96:40b74dd3695b 1859 if (lineBuffer == NULL) {
WiredHome 96:40b74dd3695b 1860 ERR("Not enough RAM for PrintScreen lineBuffer");
WiredHome 96:40b74dd3695b 1861 return(not_enough_ram);
WiredHome 96:40b74dd3695b 1862 }
WiredHome 96:40b74dd3695b 1863
WiredHome 96:40b74dd3695b 1864 #define DOUBLEBUF /* one larger buffer instead of two */
WiredHome 96:40b74dd3695b 1865
WiredHome 96:40b74dd3695b 1866 #ifdef DOUBLEBUF
WiredHome 96:40b74dd3695b 1867 // In the "#else", pixelBuffer2 malloc returns a value,
WiredHome 96:40b74dd3695b 1868 // but is actually causing a failure later.
WiredHome 96:40b74dd3695b 1869 // This test helps determine if it is truly out of memory,
WiredHome 96:40b74dd3695b 1870 // or if malloc is broken.
WiredHome 96:40b74dd3695b 1871 pixelBuffer = (color_t *)malloc(2 * w * sizeof(color_t));
WiredHome 96:40b74dd3695b 1872 pixelBuffer2 = pixelBuffer + (w * sizeof(color_t));
WiredHome 96:40b74dd3695b 1873 #else
WiredHome 96:40b74dd3695b 1874 pixelBuffer = (color_t *)malloc(w * sizeof(color_t));
WiredHome 96:40b74dd3695b 1875 pixelBuffer2 = (color_t *)malloc(w * sizeof(color_t));
WiredHome 96:40b74dd3695b 1876 #endif
WiredHome 96:40b74dd3695b 1877 if (pixelBuffer == NULL || pixelBuffer2 == NULL) {
WiredHome 96:40b74dd3695b 1878 ERR("Not enough RAM for pixelBuffer");
WiredHome 96:40b74dd3695b 1879 #ifndef DOUBLEBUF
WiredHome 96:40b74dd3695b 1880 if (pixelBuffer2)
WiredHome 96:40b74dd3695b 1881 free(pixelBuffer2);
WiredHome 96:40b74dd3695b 1882 #endif
WiredHome 96:40b74dd3695b 1883 if (pixelBuffer)
WiredHome 96:40b74dd3695b 1884 free(pixelBuffer);
WiredHome 96:40b74dd3695b 1885 free(lineBuffer);
WiredHome 96:40b74dd3695b 1886 return(not_enough_ram);
WiredHome 96:40b74dd3695b 1887 }
WiredHome 96:40b74dd3695b 1888
WiredHome 96:40b74dd3695b 1889 // Get the file primed...
WiredHome 96:40b74dd3695b 1890 privateCallback(OPEN, (uint8_t *)&BMP_Header.bfSize, 4);
WiredHome 96:40b74dd3695b 1891
WiredHome 96:40b74dd3695b 1892 // Be optimistic - don't check for errors.
WiredHome 96:40b74dd3695b 1893 HexDump("BMP_Header", (uint8_t *)&BMP_Header, sizeof(BMP_Header));
WiredHome 96:40b74dd3695b 1894 //fwrite(&BMP_Header, sizeof(char), sizeof(BMP_Header), Image);
WiredHome 96:40b74dd3695b 1895 privateCallback(WRITE, (uint8_t *)&BMP_Header, sizeof(BMP_Header));
WiredHome 96:40b74dd3695b 1896
WiredHome 96:40b74dd3695b 1897 HexDump("BMP_Info", (uint8_t *)&BMP_Info, sizeof(BMP_Info));
WiredHome 96:40b74dd3695b 1898 //fwrite(&BMP_Info, sizeof(char), sizeof(BMP_Info), Image);
WiredHome 96:40b74dd3695b 1899 privateCallback(WRITE, (uint8_t *)&BMP_Info, sizeof(BMP_Info));
WiredHome 96:40b74dd3695b 1900
WiredHome 96:40b74dd3695b 1901 //color_t transparency = GetBackgroundTransparencyColor();
WiredHome 96:40b74dd3695b 1902 LayerMode_T ltpr0 = GetLayerMode();
WiredHome 96:40b74dd3695b 1903
WiredHome 96:40b74dd3695b 1904 uint16_t prevLayer = GetDrawingLayer();
WiredHome 96:40b74dd3695b 1905 // If only one of the layers is visible, select that layer
WiredHome 96:40b74dd3695b 1906 switch(ltpr0) {
WiredHome 96:40b74dd3695b 1907 case ShowLayer0:
WiredHome 96:40b74dd3695b 1908 SelectDrawingLayer(0);
WiredHome 96:40b74dd3695b 1909 break;
WiredHome 96:40b74dd3695b 1910 case ShowLayer1:
WiredHome 96:40b74dd3695b 1911 SelectDrawingLayer(1);
WiredHome 96:40b74dd3695b 1912 break;
WiredHome 96:40b74dd3695b 1913 default:
WiredHome 96:40b74dd3695b 1914 break;
WiredHome 96:40b74dd3695b 1915 }
WiredHome 96:40b74dd3695b 1916
WiredHome 96:40b74dd3695b 1917 // Read the display from the last line toward the top
WiredHome 96:40b74dd3695b 1918 // so we can write the file in one pass.
WiredHome 96:40b74dd3695b 1919 for (int j = h - 1; j >= 0; j--) {
WiredHome 96:40b74dd3695b 1920 if (ltpr0 >= 2) // Need to combine the layers...
WiredHome 96:40b74dd3695b 1921 SelectDrawingLayer(0); // so read layer 0 first
WiredHome 96:40b74dd3695b 1922 // Read one line of pixels to a local buffer
WiredHome 96:40b74dd3695b 1923 if (getPixelStream(pixelBuffer, w, x,y+j) != noerror) {
WiredHome 96:40b74dd3695b 1924 ERR("getPixelStream error, and no recovery handler...");
WiredHome 96:40b74dd3695b 1925 }
WiredHome 96:40b74dd3695b 1926 if (ltpr0 >= 2) { // Need to combine the layers...
WiredHome 96:40b74dd3695b 1927 SelectDrawingLayer(1); // so read layer 1 next
WiredHome 96:40b74dd3695b 1928 if (getPixelStream(pixelBuffer2, w, x,y+j) != noerror) {
WiredHome 96:40b74dd3695b 1929 ERR("getPixelStream error, and no recovery handler...");
WiredHome 96:40b74dd3695b 1930 }
WiredHome 96:40b74dd3695b 1931 }
WiredHome 96:40b74dd3695b 1932 INFO("1st Color: %04X", pixelBuffer[0]);
WiredHome 96:40b74dd3695b 1933 HexDump("Raster", (uint8_t *)pixelBuffer, w);
WiredHome 96:40b74dd3695b 1934 // Convert the local buffer to RGBQUAD format
WiredHome 96:40b74dd3695b 1935 int lb = 0;
WiredHome 96:40b74dd3695b 1936 for (int i=0; i<w; i++) {
WiredHome 96:40b74dd3695b 1937 RGBQUAD q0 = RGB16ToRGBQuad(pixelBuffer[x+i]); // Scale to 24-bits
WiredHome 96:40b74dd3695b 1938 RGBQUAD q1 = RGB16ToRGBQuad(pixelBuffer2[x+i]); // Scale to 24-bits
WiredHome 96:40b74dd3695b 1939 switch (ltpr0) {
WiredHome 96:40b74dd3695b 1940 case 0:
WiredHome 96:40b74dd3695b 1941 case 1:
WiredHome 96:40b74dd3695b 1942 case 2: // lighten-overlay (@TODO Not supported yet)
WiredHome 96:40b74dd3695b 1943 case 6: // Floating Windows (@TODO not sure how to support)
WiredHome 96:40b74dd3695b 1944 default: // Reserved...
WiredHome 96:40b74dd3695b 1945 lineBuffer[lb++] = q0.rgbBlue;
WiredHome 96:40b74dd3695b 1946 lineBuffer[lb++] = q0.rgbGreen;
WiredHome 96:40b74dd3695b 1947 lineBuffer[lb++] = q0.rgbRed;
WiredHome 96:40b74dd3695b 1948 break;
WiredHome 96:40b74dd3695b 1949 case 3: // transparent mode (@TODO Read the background color register for transparent)
WiredHome 96:40b74dd3695b 1950 case 4: // boolean or
WiredHome 96:40b74dd3695b 1951 lineBuffer[lb++] = q0.rgbBlue | q1.rgbBlue;
WiredHome 96:40b74dd3695b 1952 lineBuffer[lb++] = q0.rgbGreen | q1.rgbGreen;
WiredHome 96:40b74dd3695b 1953 lineBuffer[lb++] = q0.rgbRed | q1.rgbRed;
WiredHome 96:40b74dd3695b 1954 break;
WiredHome 96:40b74dd3695b 1955 case 5: // boolean AND
WiredHome 96:40b74dd3695b 1956 lineBuffer[lb++] = q0.rgbBlue & q1.rgbBlue;
WiredHome 96:40b74dd3695b 1957 lineBuffer[lb++] = q0.rgbGreen & q1.rgbGreen;
WiredHome 96:40b74dd3695b 1958 lineBuffer[lb++] = q0.rgbRed & q1.rgbRed;
WiredHome 96:40b74dd3695b 1959 break;
WiredHome 96:40b74dd3695b 1960 }
WiredHome 96:40b74dd3695b 1961 }
WiredHome 96:40b74dd3695b 1962 if (j == h - 1) {
WiredHome 96:40b74dd3695b 1963 HexDump("Line", lineBuffer, lineBufSize);
WiredHome 96:40b74dd3695b 1964 }
WiredHome 96:40b74dd3695b 1965 // Write to disk
WiredHome 96:40b74dd3695b 1966 //fwrite(lineBuffer, sizeof(char), lb, Image);
WiredHome 96:40b74dd3695b 1967 privateCallback(WRITE, (uint8_t *)lineBuffer, lb);
WiredHome 96:40b74dd3695b 1968 }
WiredHome 96:40b74dd3695b 1969 SelectDrawingLayer(prevLayer);
WiredHome 96:40b74dd3695b 1970 //fclose(Image);
WiredHome 96:40b74dd3695b 1971 privateCallback(CLOSE, NULL, 0);
WiredHome 96:40b74dd3695b 1972
WiredHome 96:40b74dd3695b 1973 #ifndef DOUBLEBUF
WiredHome 96:40b74dd3695b 1974 if (pixelBuffer2)
WiredHome 96:40b74dd3695b 1975 free(pixelBuffer2);
WiredHome 96:40b74dd3695b 1976 #endif
WiredHome 96:40b74dd3695b 1977 if (pixelBuffer)
WiredHome 96:40b74dd3695b 1978 free(pixelBuffer);
WiredHome 96:40b74dd3695b 1979 free(lineBuffer);
WiredHome 96:40b74dd3695b 1980 INFO("Image closed");
WiredHome 96:40b74dd3695b 1981 return noerror;
WiredHome 96:40b74dd3695b 1982 } else {
WiredHome 96:40b74dd3695b 1983 return bad_parameter;
WiredHome 96:40b74dd3695b 1984 }
WiredHome 96:40b74dd3695b 1985 }
WiredHome 79:544eb4964795 1986
WiredHome 72:ecffe56af969 1987 RetCode_t RA8875::PrintScreen(loc_t x, loc_t y, dim_t w, dim_t h, const char *Name_BMP)
WiredHome 72:ecffe56af969 1988 {
WiredHome 72:ecffe56af969 1989 BITMAPFILEHEADER BMP_Header;
WiredHome 72:ecffe56af969 1990 BITMAPINFOHEADER BMP_Info;
WiredHome 86:e86b355940f4 1991 uint8_t * lineBuffer = NULL;
WiredHome 86:e86b355940f4 1992 color_t * pixelBuffer = NULL;
WiredHome 86:e86b355940f4 1993 color_t * pixelBuffer2 = NULL;
WiredHome 86:e86b355940f4 1994
WiredHome 72:ecffe56af969 1995 INFO("(%d,%d) - (%d,%d) %s", x,y,w,h,Name_BMP);
WiredHome 105:4f116006ba1f 1996 if (x >= 0 && x < screenwidth
WiredHome 105:4f116006ba1f 1997 && y >= 0 && y < screenheight
WiredHome 105:4f116006ba1f 1998 && w > 0 && x + w <= screenwidth
WiredHome 105:4f116006ba1f 1999 && h > 0 && y + h <= screenheight) {
WiredHome 72:ecffe56af969 2000
WiredHome 72:ecffe56af969 2001 BMP_Header.bfType = BF_TYPE;
WiredHome 72:ecffe56af969 2002 BMP_Header.bfSize = (w * h * sizeof(RGBQUAD)) + sizeof(BMP_Header) + sizeof(BMP_Header);
WiredHome 72:ecffe56af969 2003 BMP_Header.bfReserved1 = 0;
WiredHome 72:ecffe56af969 2004 BMP_Header.bfReserved2 = 0;
WiredHome 72:ecffe56af969 2005 BMP_Header.bfOffBits = sizeof(BMP_Header) + sizeof(BMP_Header);
WiredHome 73:f22a18707b5e 2006
WiredHome 72:ecffe56af969 2007 BMP_Info.biSize = sizeof(BMP_Info);
WiredHome 72:ecffe56af969 2008 BMP_Info.biWidth = w;
WiredHome 72:ecffe56af969 2009 BMP_Info.biHeight = h;
WiredHome 72:ecffe56af969 2010 BMP_Info.biPlanes = 1;
WiredHome 72:ecffe56af969 2011 BMP_Info.biBitCount = 24;
WiredHome 72:ecffe56af969 2012 BMP_Info.biCompression = BI_RGB;
WiredHome 72:ecffe56af969 2013 BMP_Info.biSizeImage = 0;
WiredHome 72:ecffe56af969 2014 BMP_Info.biXPelsPerMeter = 0;
WiredHome 72:ecffe56af969 2015 BMP_Info.biYPelsPerMeter = 0;
WiredHome 72:ecffe56af969 2016 BMP_Info.biClrUsed = 0;
WiredHome 72:ecffe56af969 2017 BMP_Info.biClrImportant = 0;
WiredHome 72:ecffe56af969 2018
WiredHome 86:e86b355940f4 2019 // Allocate the memory we need to proceed
WiredHome 86:e86b355940f4 2020 int lineBufSize = ((24 * w + 7)/8);
WiredHome 86:e86b355940f4 2021 lineBuffer = (uint8_t *)malloc(lineBufSize);
WiredHome 86:e86b355940f4 2022 if (lineBuffer == NULL) {
WiredHome 86:e86b355940f4 2023 ERR("Not enough RAM for PrintScreen lineBuffer");
WiredHome 86:e86b355940f4 2024 return(not_enough_ram);
WiredHome 86:e86b355940f4 2025 }
WiredHome 86:e86b355940f4 2026
WiredHome 86:e86b355940f4 2027 #define DOUBLEBUF /* one larger buffer instead of two */
WiredHome 86:e86b355940f4 2028
WiredHome 86:e86b355940f4 2029 #ifdef DOUBLEBUF
WiredHome 86:e86b355940f4 2030 // In the "#else", pixelBuffer2 malloc returns a value,
WiredHome 86:e86b355940f4 2031 // but is actually causing a failure later.
WiredHome 86:e86b355940f4 2032 // This test helps determine if it is truly out of memory,
WiredHome 86:e86b355940f4 2033 // or if malloc is broken.
WiredHome 86:e86b355940f4 2034 pixelBuffer = (color_t *)malloc(2 * w * sizeof(color_t));
WiredHome 86:e86b355940f4 2035 pixelBuffer2 = pixelBuffer + (w * sizeof(color_t));
WiredHome 86:e86b355940f4 2036 #else
WiredHome 86:e86b355940f4 2037 pixelBuffer = (color_t *)malloc(w * sizeof(color_t));
WiredHome 86:e86b355940f4 2038 pixelBuffer2 = (color_t *)malloc(w * sizeof(color_t));
WiredHome 86:e86b355940f4 2039 #endif
WiredHome 86:e86b355940f4 2040 if (pixelBuffer == NULL || pixelBuffer2 == NULL) {
WiredHome 86:e86b355940f4 2041 ERR("Not enough RAM for pixelBuffer");
WiredHome 86:e86b355940f4 2042 #ifndef DOUBLEBUF
WiredHome 86:e86b355940f4 2043 if (pixelBuffer2)
WiredHome 86:e86b355940f4 2044 free(pixelBuffer2);
WiredHome 86:e86b355940f4 2045 #endif
WiredHome 86:e86b355940f4 2046 if (pixelBuffer)
WiredHome 86:e86b355940f4 2047 free(pixelBuffer);
WiredHome 86:e86b355940f4 2048 free(lineBuffer);
WiredHome 86:e86b355940f4 2049 return(not_enough_ram);
WiredHome 86:e86b355940f4 2050 }
WiredHome 86:e86b355940f4 2051
WiredHome 72:ecffe56af969 2052 FILE *Image = fopen(Name_BMP, "wb");
WiredHome 72:ecffe56af969 2053 if (!Image) {
WiredHome 86:e86b355940f4 2054 ERR("Can't open file for write");
WiredHome 86:e86b355940f4 2055 #ifndef DOUBLEBUF
WiredHome 86:e86b355940f4 2056 if (pixelBuffer2)
WiredHome 86:e86b355940f4 2057 free(pixelBuffer2);
WiredHome 86:e86b355940f4 2058 #endif
WiredHome 86:e86b355940f4 2059 if (pixelBuffer)
WiredHome 86:e86b355940f4 2060 free(pixelBuffer);
WiredHome 86:e86b355940f4 2061 free(lineBuffer);
WiredHome 72:ecffe56af969 2062 return(file_not_found);
WiredHome 72:ecffe56af969 2063 }
WiredHome 72:ecffe56af969 2064
WiredHome 72:ecffe56af969 2065 // Be optimistic - don't check for errors.
WiredHome 93:6fbc516de05e 2066 HexDump("BMP_Header", (uint8_t *)&BMP_Header, sizeof(BMP_Header));
WiredHome 95:ef538bd687c0 2067 fwrite(&BMP_Header, sizeof(char), sizeof(BMP_Header), Image);
WiredHome 73:f22a18707b5e 2068
WiredHome 93:6fbc516de05e 2069 HexDump("BMP_Info", (uint8_t *)&BMP_Info, sizeof(BMP_Info));
WiredHome 95:ef538bd687c0 2070 fwrite(&BMP_Info, sizeof(char), sizeof(BMP_Info), Image);
WiredHome 73:f22a18707b5e 2071
WiredHome 95:ef538bd687c0 2072 //color_t transparency = GetBackgroundTransparencyColor();
WiredHome 95:ef538bd687c0 2073 LayerMode_T ltpr0 = GetLayerMode();
WiredHome 73:f22a18707b5e 2074
WiredHome 73:f22a18707b5e 2075 uint16_t prevLayer = GetDrawingLayer();
WiredHome 73:f22a18707b5e 2076 // If only one of the layers is visible, select that layer
WiredHome 73:f22a18707b5e 2077 switch(ltpr0) {
WiredHome 95:ef538bd687c0 2078 case ShowLayer0:
WiredHome 73:f22a18707b5e 2079 SelectDrawingLayer(0);
WiredHome 73:f22a18707b5e 2080 break;
WiredHome 95:ef538bd687c0 2081 case ShowLayer1:
WiredHome 73:f22a18707b5e 2082 SelectDrawingLayer(1);
WiredHome 73:f22a18707b5e 2083 break;
WiredHome 73:f22a18707b5e 2084 default:
WiredHome 73:f22a18707b5e 2085 break;
WiredHome 73:f22a18707b5e 2086 }
WiredHome 73:f22a18707b5e 2087
WiredHome 72:ecffe56af969 2088 // Read the display from the last line toward the top
WiredHome 72:ecffe56af969 2089 // so we can write the file in one pass.
WiredHome 72:ecffe56af969 2090 for (int j = h - 1; j >= 0; j--) {
WiredHome 73:f22a18707b5e 2091 if (ltpr0 >= 2) // Need to combine the layers...
WiredHome 73:f22a18707b5e 2092 SelectDrawingLayer(0); // so read layer 0 first
WiredHome 72:ecffe56af969 2093 // Read one line of pixels to a local buffer
WiredHome 72:ecffe56af969 2094 if (getPixelStream(pixelBuffer, w, x,y+j) != noerror) {
WiredHome 72:ecffe56af969 2095 ERR("getPixelStream error, and no recovery handler...");
WiredHome 72:ecffe56af969 2096 }
WiredHome 73:f22a18707b5e 2097 if (ltpr0 >= 2) { // Need to combine the layers...
WiredHome 86:e86b355940f4 2098 SelectDrawingLayer(1); // so read layer 1 next
WiredHome 73:f22a18707b5e 2099 if (getPixelStream(pixelBuffer2, w, x,y+j) != noerror) {
WiredHome 73:f22a18707b5e 2100 ERR("getPixelStream error, and no recovery handler...");
WiredHome 73:f22a18707b5e 2101 }
WiredHome 73:f22a18707b5e 2102 }
WiredHome 93:6fbc516de05e 2103 INFO("1st Color: %04X", pixelBuffer[0]);
WiredHome 93:6fbc516de05e 2104 HexDump("Raster", (uint8_t *)pixelBuffer, w);
WiredHome 72:ecffe56af969 2105 // Convert the local buffer to RGBQUAD format
WiredHome 72:ecffe56af969 2106 int lb = 0;
WiredHome 72:ecffe56af969 2107 for (int i=0; i<w; i++) {
WiredHome 73:f22a18707b5e 2108 RGBQUAD q0 = RGB16ToRGBQuad(pixelBuffer[x+i]); // Scale to 24-bits
WiredHome 73:f22a18707b5e 2109 RGBQUAD q1 = RGB16ToRGBQuad(pixelBuffer2[x+i]); // Scale to 24-bits
WiredHome 73:f22a18707b5e 2110 switch (ltpr0) {
WiredHome 73:f22a18707b5e 2111 case 0:
WiredHome 73:f22a18707b5e 2112 case 1:
WiredHome 73:f22a18707b5e 2113 case 2: // lighten-overlay (@TODO Not supported yet)
WiredHome 73:f22a18707b5e 2114 case 6: // Floating Windows (@TODO not sure how to support)
WiredHome 73:f22a18707b5e 2115 default: // Reserved...
WiredHome 73:f22a18707b5e 2116 lineBuffer[lb++] = q0.rgbBlue;
WiredHome 73:f22a18707b5e 2117 lineBuffer[lb++] = q0.rgbGreen;
WiredHome 73:f22a18707b5e 2118 lineBuffer[lb++] = q0.rgbRed;
WiredHome 73:f22a18707b5e 2119 break;
WiredHome 73:f22a18707b5e 2120 case 3: // transparent mode (@TODO Read the background color register for transparent)
WiredHome 73:f22a18707b5e 2121 case 4: // boolean or
WiredHome 73:f22a18707b5e 2122 lineBuffer[lb++] = q0.rgbBlue | q1.rgbBlue;
WiredHome 73:f22a18707b5e 2123 lineBuffer[lb++] = q0.rgbGreen | q1.rgbGreen;
WiredHome 73:f22a18707b5e 2124 lineBuffer[lb++] = q0.rgbRed | q1.rgbRed;
WiredHome 73:f22a18707b5e 2125 break;
WiredHome 73:f22a18707b5e 2126 case 5: // boolean AND
WiredHome 73:f22a18707b5e 2127 lineBuffer[lb++] = q0.rgbBlue & q1.rgbBlue;
WiredHome 73:f22a18707b5e 2128 lineBuffer[lb++] = q0.rgbGreen & q1.rgbGreen;
WiredHome 73:f22a18707b5e 2129 lineBuffer[lb++] = q0.rgbRed & q1.rgbRed;
WiredHome 73:f22a18707b5e 2130 break;
WiredHome 73:f22a18707b5e 2131 }
WiredHome 72:ecffe56af969 2132 }
WiredHome 95:ef538bd687c0 2133 if (j == h - 1) {
WiredHome 73:f22a18707b5e 2134 HexDump("Line", lineBuffer, lineBufSize);
WiredHome 95:ef538bd687c0 2135 }
WiredHome 72:ecffe56af969 2136 // Write to disk
WiredHome 72:ecffe56af969 2137 fwrite(lineBuffer, sizeof(char), lb, Image);
WiredHome 72:ecffe56af969 2138 }
WiredHome 73:f22a18707b5e 2139 SelectDrawingLayer(prevLayer);
WiredHome 72:ecffe56af969 2140 fclose(Image);
WiredHome 86:e86b355940f4 2141 #ifndef DOUBLEBUF
WiredHome 86:e86b355940f4 2142 if (pixelBuffer2)
WiredHome 86:e86b355940f4 2143 free(pixelBuffer2);
WiredHome 86:e86b355940f4 2144 #endif
WiredHome 86:e86b355940f4 2145 if (pixelBuffer)
WiredHome 86:e86b355940f4 2146 free(pixelBuffer);
WiredHome 72:ecffe56af969 2147 free(lineBuffer);
WiredHome 73:f22a18707b5e 2148 INFO("Image closed");
WiredHome 72:ecffe56af969 2149 return noerror;
WiredHome 72:ecffe56af969 2150 } else {
WiredHome 72:ecffe56af969 2151 return bad_parameter;
WiredHome 72:ecffe56af969 2152 }
WiredHome 72:ecffe56af969 2153 }
WiredHome 72:ecffe56af969 2154
WiredHome 72:ecffe56af969 2155
WiredHome 72:ecffe56af969 2156 // ##########################################################################
WiredHome 72:ecffe56af969 2157 // ##########################################################################
WiredHome 72:ecffe56af969 2158 // ##########################################################################
WiredHome 72:ecffe56af969 2159
WiredHome 23:a50ded45dbaf 2160 #ifdef TESTENABLE
WiredHome 23:a50ded45dbaf 2161
WiredHome 98:ecebed9b80b2 2162 #include "BPG_Arial08x08.h"
WiredHome 98:ecebed9b80b2 2163 #include "BPG_Arial20x20.h"
WiredHome 37:f19b7e7449dc 2164
WiredHome 23:a50ded45dbaf 2165 // ______________ ______________ ______________ _______________
WiredHome 23:a50ded45dbaf 2166 // /_____ _____/ / ___________/ / ___________/ /_____ ______/
WiredHome 23:a50ded45dbaf 2167 // / / / / / / / /
WiredHome 23:a50ded45dbaf 2168 // / / / /___ / /__________ / /
WiredHome 23:a50ded45dbaf 2169 // / / / ____/ /__________ / / /
WiredHome 23:a50ded45dbaf 2170 // / / / / / / / /
WiredHome 23:a50ded45dbaf 2171 // / / / /__________ ___________/ / / /
WiredHome 23:a50ded45dbaf 2172 // /__/ /_____________/ /_____________/ /__/
WiredHome 23:a50ded45dbaf 2173 //
WiredHome 23:a50ded45dbaf 2174 // Everything from here down is test code.
WiredHome 75:ca78388cfd77 2175 //
WiredHome 41:2956a0a221e5 2176 bool SuppressSlowStuff = false;
WiredHome 23:a50ded45dbaf 2177
WiredHome 49:c5182231d1b9 2178 void TextWrapTest(RA8875 & display, Serial & pc)
WiredHome 49:c5182231d1b9 2179 {
WiredHome 49:c5182231d1b9 2180 if (!SuppressSlowStuff)
WiredHome 49:c5182231d1b9 2181 pc.printf("Text Wrap Test\r\n");
WiredHome 49:c5182231d1b9 2182 display.background(Black);
WiredHome 49:c5182231d1b9 2183 display.foreground(Blue);
WiredHome 49:c5182231d1b9 2184 display.cls();
WiredHome 49:c5182231d1b9 2185 display.Backlight_u8(255);
WiredHome 100:0b084475d5a9 2186 display.puts("Text Wrap Test.\r\n");
WiredHome 52:e6039a823420 2187 for (int i=1; i<60; i++) {
WiredHome 52:e6039a823420 2188 display.printf("L%2d\n", i % 17);
WiredHome 49:c5182231d1b9 2189 if (!SuppressSlowStuff)
WiredHome 52:e6039a823420 2190 wait_ms(100);
WiredHome 49:c5182231d1b9 2191 }
WiredHome 49:c5182231d1b9 2192 if (!SuppressSlowStuff)
WiredHome 49:c5182231d1b9 2193 wait_ms(3000);
WiredHome 49:c5182231d1b9 2194 }
WiredHome 49:c5182231d1b9 2195
WiredHome 75:ca78388cfd77 2196
WiredHome 75:ca78388cfd77 2197 void ShowKey(RA8875 & display, int key)
WiredHome 75:ca78388cfd77 2198 {
WiredHome 75:ca78388cfd77 2199 loc_t col, row;
WiredHome 75:ca78388cfd77 2200 dim_t r1 = 25;
WiredHome 75:ca78388cfd77 2201 color_t color = (key & 0x80) ? Red : Green;
WiredHome 75:ca78388cfd77 2202
WiredHome 75:ca78388cfd77 2203 key &= 0x7F; // remove the long-press flag
WiredHome 75:ca78388cfd77 2204 row = (key - 1) / 5;
WiredHome 75:ca78388cfd77 2205 col = (key - 1) % 5;
WiredHome 75:ca78388cfd77 2206 if (col > 5) col = 5;
WiredHome 75:ca78388cfd77 2207 if (row > 4) row = 4;
WiredHome 75:ca78388cfd77 2208 display.circle(450 - + (2 * r1) * col, 200 - (2 * r1) * row, r1-2, color, FILL);
WiredHome 75:ca78388cfd77 2209 }
WiredHome 75:ca78388cfd77 2210
WiredHome 75:ca78388cfd77 2211 void HideKey(RA8875 & display, int key)
WiredHome 75:ca78388cfd77 2212 {
WiredHome 75:ca78388cfd77 2213 loc_t col, row;
WiredHome 75:ca78388cfd77 2214 dim_t r1 = 25;
WiredHome 75:ca78388cfd77 2215
WiredHome 75:ca78388cfd77 2216 row = (key - 1) / 5;
WiredHome 75:ca78388cfd77 2217 col = (key - 1) % 5;
WiredHome 75:ca78388cfd77 2218 if (col > 5) col = 5;
WiredHome 75:ca78388cfd77 2219 if (row > 4) row = 4;
WiredHome 75:ca78388cfd77 2220 display.background(Black);
WiredHome 75:ca78388cfd77 2221 display.circle(450 - (2 * r1) * col, 200 - (2 * r1) * row, r1-2, Black, FILL);
WiredHome 75:ca78388cfd77 2222 display.circle(450 - (2 * r1) * col, 200 - (2 * r1) * row, r1-2, Blue);
WiredHome 75:ca78388cfd77 2223 }
WiredHome 75:ca78388cfd77 2224
WiredHome 75:ca78388cfd77 2225 void KeyPadTest(RA8875 & display, Serial & pc)
WiredHome 75:ca78388cfd77 2226 {
WiredHome 75:ca78388cfd77 2227 const uint8_t myMap[22] = {
WiredHome 77:9206c13aa527 2228 0,
WiredHome 75:ca78388cfd77 2229 'a', 'b', 'c', 'd', 'e',
WiredHome 75:ca78388cfd77 2230 'f', 'g', 'h', 'i', 'j',
WiredHome 75:ca78388cfd77 2231 'k', 'l', 'm', 'n', 'o',
WiredHome 75:ca78388cfd77 2232 'p', 'q', 'r', 's', 't',
WiredHome 75:ca78388cfd77 2233 'x'
WiredHome 75:ca78388cfd77 2234 };
WiredHome 77:9206c13aa527 2235
WiredHome 75:ca78388cfd77 2236 display.background(Black);
WiredHome 75:ca78388cfd77 2237 display.foreground(Blue);
WiredHome 75:ca78388cfd77 2238 display.cls();
WiredHome 75:ca78388cfd77 2239 display.Backlight_u8(255);
WiredHome 100:0b084475d5a9 2240 display.puts("KeyPad Test. Touch the keypad...");
WiredHome 75:ca78388cfd77 2241 pc.printf("\r\n"
WiredHome 75:ca78388cfd77 2242 "Raw KeyPad Test. Keypad returns the key-number.\r\n"
WiredHome 75:ca78388cfd77 2243 "Press [most] any PC keyboard key to advance to next test.\r\n");
WiredHome 75:ca78388cfd77 2244 RetCode_t ret = display.KeypadInit(true, true, 3, 7, 3);
WiredHome 75:ca78388cfd77 2245 if (ret != noerror)
WiredHome 75:ca78388cfd77 2246 pc.printf("returncode from KeypadInit is %d\r\n", ret);
WiredHome 75:ca78388cfd77 2247 int lastKey = 0;
WiredHome 75:ca78388cfd77 2248 while (!pc.readable()) {
WiredHome 75:ca78388cfd77 2249 if (display.readable()) {
WiredHome 75:ca78388cfd77 2250 int key = display.getc();
WiredHome 75:ca78388cfd77 2251 if (key) {
WiredHome 75:ca78388cfd77 2252 if (((key & 0x7F) != lastKey) && (lastKey != 0))
WiredHome 75:ca78388cfd77 2253 HideKey(display, lastKey);
WiredHome 75:ca78388cfd77 2254 ShowKey(display, key);
WiredHome 75:ca78388cfd77 2255 lastKey = key & 0x7F;
WiredHome 75:ca78388cfd77 2256 } else {
WiredHome 75:ca78388cfd77 2257 // erase the last one
WiredHome 75:ca78388cfd77 2258 if (lastKey)
WiredHome 75:ca78388cfd77 2259 HideKey(display, lastKey);
WiredHome 75:ca78388cfd77 2260 }
WiredHome 75:ca78388cfd77 2261 }
WiredHome 75:ca78388cfd77 2262 }
WiredHome 75:ca78388cfd77 2263 (void)pc.getc();
WiredHome 75:ca78388cfd77 2264 pc.printf("\r\n"
WiredHome 75:ca78388cfd77 2265 "Map KeyPad Test. Keypad returns the remapped key 'a' - 't'.\r\n"
WiredHome 75:ca78388cfd77 2266 "Press [most] any PC keyboard key to advance to exit test.\r\n");
WiredHome 75:ca78388cfd77 2267 display.SetKeyMap(myMap);
WiredHome 75:ca78388cfd77 2268 while (!pc.readable()) {
WiredHome 75:ca78388cfd77 2269 if (display.readable()) {
WiredHome 75:ca78388cfd77 2270 int key = display.getc();
WiredHome 75:ca78388cfd77 2271 bool longPress = key & 0x80;
WiredHome 75:ca78388cfd77 2272 display.SetTextCursor(0, 120);
WiredHome 75:ca78388cfd77 2273 display.printf("Long Press: %d\r\n", longPress);
WiredHome 75:ca78388cfd77 2274 display.printf(" Remapped: %c %02X\r\n", (key) ? key & 0x7F : ' ', key);
WiredHome 75:ca78388cfd77 2275 }
WiredHome 75:ca78388cfd77 2276 }
WiredHome 75:ca78388cfd77 2277 (void)pc.getc();
WiredHome 75:ca78388cfd77 2278 display.SetKeyMap();
WiredHome 75:ca78388cfd77 2279 pc.printf("\r\n");
WiredHome 75:ca78388cfd77 2280 }
WiredHome 75:ca78388cfd77 2281
WiredHome 23:a50ded45dbaf 2282 void TextCursorTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2283 {
WiredHome 75:ca78388cfd77 2284 const char * iCursor = "The I-Beam cursor should be visible for this text.\r\n";
WiredHome 75:ca78388cfd77 2285 const char * uCursor = "The Underscore cursor should be visible for this text.\r\n";
WiredHome 75:ca78388cfd77 2286 const char * bCursor = "The Block cursor should be visible for this text.\r\n";
WiredHome 37:f19b7e7449dc 2287 const char * bbCursor = "The Blinking Block cursor should be visible for this text.\r\n";
WiredHome 23:a50ded45dbaf 2288 const char * p;
WiredHome 100:0b084475d5a9 2289 int delay = 60;
WiredHome 73:f22a18707b5e 2290
WiredHome 41:2956a0a221e5 2291 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2292 pc.printf("Text Cursor Test\r\n");
WiredHome 73:f22a18707b5e 2293 else
WiredHome 41:2956a0a221e5 2294 delay = 0;
WiredHome 23:a50ded45dbaf 2295 display.background(Black);
WiredHome 23:a50ded45dbaf 2296 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2297 display.cls();
WiredHome 25:9556a3a9b7cc 2298 display.Backlight_u8(255);
WiredHome 100:0b084475d5a9 2299 display.puts("Text Cursor Test.");
WiredHome 73:f22a18707b5e 2300
WiredHome 23:a50ded45dbaf 2301 // visible, non-blinking
WiredHome 24:8ca861acf12d 2302 display.SetTextCursor(0,20);
WiredHome 53:86d24b9480b9 2303 display.SetTextCursorControl(RA8875::IBEAM, false);
WiredHome 24:8ca861acf12d 2304 p = iCursor;
WiredHome 23:a50ded45dbaf 2305 while (*p) {
WiredHome 24:8ca861acf12d 2306 display._putc(*p++);
WiredHome 41:2956a0a221e5 2307 wait_ms(delay);
WiredHome 24:8ca861acf12d 2308 }
WiredHome 24:8ca861acf12d 2309
WiredHome 53:86d24b9480b9 2310 display.SetTextCursorControl(RA8875::UNDER, false);
WiredHome 24:8ca861acf12d 2311 p = uCursor;
WiredHome 24:8ca861acf12d 2312 while (*p) {
WiredHome 24:8ca861acf12d 2313 display._putc(*p++);
WiredHome 41:2956a0a221e5 2314 wait_ms(delay);
WiredHome 23:a50ded45dbaf 2315 }
WiredHome 73:f22a18707b5e 2316
WiredHome 53:86d24b9480b9 2317 display.SetTextCursorControl(RA8875::BLOCK, false);
WiredHome 24:8ca861acf12d 2318 p = bCursor;
WiredHome 24:8ca861acf12d 2319 while (*p) {
WiredHome 24:8ca861acf12d 2320 display._putc(*p++);
WiredHome 41:2956a0a221e5 2321 wait_ms(delay);
WiredHome 24:8ca861acf12d 2322 }
WiredHome 24:8ca861acf12d 2323
WiredHome 53:86d24b9480b9 2324 display.SetTextCursorControl(RA8875::BLOCK, true);
WiredHome 24:8ca861acf12d 2325 p = bbCursor;
WiredHome 24:8ca861acf12d 2326 while (*p) {
WiredHome 24:8ca861acf12d 2327 display._putc(*p++);
WiredHome 41:2956a0a221e5 2328 wait_ms(delay);
WiredHome 24:8ca861acf12d 2329 }
WiredHome 41:2956a0a221e5 2330 wait_ms(delay * 20);
WiredHome 53:86d24b9480b9 2331 display.SetTextCursorControl(RA8875::NOCURSOR, false);
WiredHome 23:a50ded45dbaf 2332 }
WiredHome 23:a50ded45dbaf 2333
WiredHome 44:207594dece70 2334
WiredHome 23:a50ded45dbaf 2335 void BacklightTest(RA8875 & display, Serial & pc, float ramptime)
WiredHome 23:a50ded45dbaf 2336 {
WiredHome 29:422616aa04bd 2337 char buf[60];
WiredHome 41:2956a0a221e5 2338 unsigned int w = (ramptime * 1000)/ 256;
WiredHome 41:2956a0a221e5 2339 int delay = 200;
WiredHome 41:2956a0a221e5 2340
WiredHome 41:2956a0a221e5 2341 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2342 pc.printf("Backlight Test - ramp over %f sec.\r\n", ramptime);
WiredHome 41:2956a0a221e5 2343 else {
WiredHome 41:2956a0a221e5 2344 delay = 0;
WiredHome 41:2956a0a221e5 2345 w = 0;
WiredHome 41:2956a0a221e5 2346 }
WiredHome 23:a50ded45dbaf 2347 display.Backlight_u8(0);
WiredHome 29:422616aa04bd 2348 display.background(White);
WiredHome 23:a50ded45dbaf 2349 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2350 display.cls();
WiredHome 100:0b084475d5a9 2351 display.puts("RA8875 Backlight Test - Ramp up.");
WiredHome 41:2956a0a221e5 2352 wait_ms(delay);
WiredHome 38:38d503b4fad6 2353 for (int i=0; i <= 255; i++) {
WiredHome 29:422616aa04bd 2354 sprintf(buf, "%3d, %4d", i, w);
WiredHome 37:f19b7e7449dc 2355 display.puts(100,100,buf);
WiredHome 23:a50ded45dbaf 2356 display.Backlight_u8(i);
WiredHome 29:422616aa04bd 2357 wait_ms(w);
WiredHome 23:a50ded45dbaf 2358 }
WiredHome 23:a50ded45dbaf 2359 }
WiredHome 23:a50ded45dbaf 2360
WiredHome 44:207594dece70 2361
WiredHome 23:a50ded45dbaf 2362 void BacklightTest2(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2363 {
WiredHome 41:2956a0a221e5 2364 int delay = 20;
WiredHome 41:2956a0a221e5 2365
WiredHome 41:2956a0a221e5 2366 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2367 pc.printf("Backlight Test 2\r\n");
WiredHome 41:2956a0a221e5 2368 else
WiredHome 41:2956a0a221e5 2369 delay = 0;
WiredHome 41:2956a0a221e5 2370
WiredHome 23:a50ded45dbaf 2371 // Dim it out at the end of the tests.
WiredHome 37:f19b7e7449dc 2372 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2373 display.puts(0,0, "Ramp Backlight down.");
WiredHome 23:a50ded45dbaf 2374 // Ramp it off
WiredHome 23:a50ded45dbaf 2375 for (int i=255; i != 0; i--) {
WiredHome 23:a50ded45dbaf 2376 display.Backlight_u8(i);
WiredHome 41:2956a0a221e5 2377 wait_ms(delay);
WiredHome 23:a50ded45dbaf 2378 }
WiredHome 23:a50ded45dbaf 2379 display.Backlight_u8(0);
WiredHome 23:a50ded45dbaf 2380 }
WiredHome 23:a50ded45dbaf 2381
WiredHome 44:207594dece70 2382
WiredHome 23:a50ded45dbaf 2383 void ExternalFontTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2384 {
WiredHome 41:2956a0a221e5 2385 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2386 pc.printf("External Font Test\r\n");
WiredHome 23:a50ded45dbaf 2387 display.background(Black);
WiredHome 23:a50ded45dbaf 2388 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2389 display.cls();
WiredHome 100:0b084475d5a9 2390 display.puts("External Font Test.");
WiredHome 23:a50ded45dbaf 2391 display.Backlight(1);
WiredHome 37:f19b7e7449dc 2392
WiredHome 98:ecebed9b80b2 2393 display.SelectUserFont(BPG_Arial08x08);
WiredHome 73:f22a18707b5e 2394 display.puts(0,30, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\r\n");
WiredHome 37:f19b7e7449dc 2395
WiredHome 98:ecebed9b80b2 2396 display.SelectUserFont(BPG_Arial20x20);
WiredHome 37:f19b7e7449dc 2397 display.puts("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\r\n");
WiredHome 98:ecebed9b80b2 2398
WiredHome 98:ecebed9b80b2 2399 display.SelectUserFont();
WiredHome 73:f22a18707b5e 2400
WiredHome 37:f19b7e7449dc 2401 display.puts("Normal font again.");
WiredHome 37:f19b7e7449dc 2402 //display.window(0,0, display.width(), display.height());
WiredHome 23:a50ded45dbaf 2403 }
WiredHome 23:a50ded45dbaf 2404
WiredHome 44:207594dece70 2405
WiredHome 23:a50ded45dbaf 2406 void DOSColorTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2407 {
WiredHome 41:2956a0a221e5 2408 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2409 pc.printf("DOS Color Test\r\n");
WiredHome 23:a50ded45dbaf 2410 display.background(Black);
WiredHome 23:a50ded45dbaf 2411 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2412 display.cls();
WiredHome 100:0b084475d5a9 2413 display.puts("DOS Colors - Fore");
WiredHome 23:a50ded45dbaf 2414 display.puts(280,0, "Back");
WiredHome 23:a50ded45dbaf 2415 display.background(Gray);
WiredHome 23:a50ded45dbaf 2416 for (int i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2417 display.foreground(display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2418 display.puts(160, i*16, display.DOSColorNames(i));
WiredHome 23:a50ded45dbaf 2419 display.background(Black);
WiredHome 23:a50ded45dbaf 2420 }
WiredHome 23:a50ded45dbaf 2421 display.foreground(White);
WiredHome 23:a50ded45dbaf 2422 for (int i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2423 display.background(display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2424 display.puts(360, i*16, display.DOSColorNames(i));
WiredHome 23:a50ded45dbaf 2425 display.foreground(White);
WiredHome 23:a50ded45dbaf 2426 }
WiredHome 23:a50ded45dbaf 2427 }
WiredHome 23:a50ded45dbaf 2428
WiredHome 44:207594dece70 2429
WiredHome 23:a50ded45dbaf 2430 void WebColorTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2431 {
WiredHome 41:2956a0a221e5 2432 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2433 pc.printf("Web Color Test\r\n");
WiredHome 23:a50ded45dbaf 2434 display.background(Black);
WiredHome 23:a50ded45dbaf 2435 display.foreground(Blue);
WiredHome 32:0e4f2ae512e2 2436 display.window(0,0, display.width(), display.height());
WiredHome 23:a50ded45dbaf 2437 display.cls();
WiredHome 59:fb40aad4efd4 2438 display.SetTextFontSize(1,1);
WiredHome 59:fb40aad4efd4 2439 display.puts(200,0, "Web Color Test");
WiredHome 59:fb40aad4efd4 2440 display.SetTextCursor(0,0);
WiredHome 59:fb40aad4efd4 2441 display.puts(" ");
WiredHome 59:fb40aad4efd4 2442 for (int i=0; i<16; i++)
WiredHome 59:fb40aad4efd4 2443 display.printf("%X", i&0xF);
WiredHome 59:fb40aad4efd4 2444 display.puts("\r\n0 ");
WiredHome 23:a50ded45dbaf 2445 for (int i=0; i<sizeof(WebColors)/sizeof(WebColors[0]); i++) {
WiredHome 23:a50ded45dbaf 2446 display.background(WebColors[i]);
WiredHome 23:a50ded45dbaf 2447 display.puts(" ");
WiredHome 59:fb40aad4efd4 2448 if (i % 16 == 15 && i < 255) {
WiredHome 59:fb40aad4efd4 2449 display.printf("\r\n%X ", ((i+1)/16));
WiredHome 59:fb40aad4efd4 2450 }
WiredHome 23:a50ded45dbaf 2451 }
WiredHome 23:a50ded45dbaf 2452 display.SetTextFontSize(1,1);
WiredHome 23:a50ded45dbaf 2453 }
WiredHome 23:a50ded45dbaf 2454
WiredHome 44:207594dece70 2455
WiredHome 37:f19b7e7449dc 2456 void PixelTest(RA8875 & display, Serial & pc)
WiredHome 37:f19b7e7449dc 2457 {
WiredHome 37:f19b7e7449dc 2458 int i, c, x, y;
WiredHome 37:f19b7e7449dc 2459
WiredHome 41:2956a0a221e5 2460 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2461 pc.printf("Pixel Test\r\n");
WiredHome 37:f19b7e7449dc 2462 display.background(Black);
WiredHome 37:f19b7e7449dc 2463 display.foreground(Blue);
WiredHome 37:f19b7e7449dc 2464 display.cls();
WiredHome 100:0b084475d5a9 2465 display.puts("Pixel Test");
WiredHome 37:f19b7e7449dc 2466 for (i=0; i<1000; i++) {
WiredHome 37:f19b7e7449dc 2467 x = rand() % 480;
WiredHome 37:f19b7e7449dc 2468 y = 16 + rand() % (272-16);
WiredHome 37:f19b7e7449dc 2469 c = rand() % 16;
WiredHome 37:f19b7e7449dc 2470 //pc.printf(" (%d,%d) - %d\r\n", x,y,r1);
WiredHome 37:f19b7e7449dc 2471 display.pixel(x,y, display.DOSColor(c));
WiredHome 37:f19b7e7449dc 2472 }
WiredHome 37:f19b7e7449dc 2473 }
WiredHome 37:f19b7e7449dc 2474
WiredHome 44:207594dece70 2475
WiredHome 23:a50ded45dbaf 2476 void LineTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2477 {
WiredHome 23:a50ded45dbaf 2478 int i, x, y, x2, y2;
WiredHome 23:a50ded45dbaf 2479
WiredHome 41:2956a0a221e5 2480 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2481 pc.printf("Line Test\r\n");
WiredHome 23:a50ded45dbaf 2482 display.background(Black);
WiredHome 23:a50ded45dbaf 2483 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2484 display.cls();
WiredHome 100:0b084475d5a9 2485 display.puts("Line Test");
WiredHome 23:a50ded45dbaf 2486 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2487 // Lines
WiredHome 23:a50ded45dbaf 2488 x = rand() % 480;
WiredHome 23:a50ded45dbaf 2489 y = rand() % 272;
WiredHome 23:a50ded45dbaf 2490 x2 = rand() % 480;
WiredHome 23:a50ded45dbaf 2491 y2 = rand() % 272;
WiredHome 23:a50ded45dbaf 2492 display.line(x,y, x2,y2, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2493 }
WiredHome 62:ba5d33438fda 2494 display.foreground(BrightRed);
WiredHome 62:ba5d33438fda 2495 display.foreground(BrightGreen);
WiredHome 62:ba5d33438fda 2496 display.foreground(BrightBlue);
WiredHome 62:ba5d33438fda 2497 display.line(55,50, 79,74, BrightRed);
WiredHome 62:ba5d33438fda 2498 display.line(57,50, 81,74, BrightGreen);
WiredHome 62:ba5d33438fda 2499 display.line(59,50, 83,74, BrightBlue);
WiredHome 62:ba5d33438fda 2500 // horz
WiredHome 62:ba5d33438fda 2501 display.line(30,40, 32,40, BrightRed);
WiredHome 62:ba5d33438fda 2502 display.line(30,42, 32,42, BrightGreen);
WiredHome 62:ba5d33438fda 2503 display.line(30,44, 32,44, BrightBlue);
WiredHome 62:ba5d33438fda 2504 // vert
WiredHome 62:ba5d33438fda 2505 display.line(20,40, 20,42, BrightRed);
WiredHome 62:ba5d33438fda 2506 display.line(22,40, 22,42, BrightGreen);
WiredHome 62:ba5d33438fda 2507 display.line(24,40, 24,42, BrightBlue);
WiredHome 62:ba5d33438fda 2508 // compare point to line-point
WiredHome 62:ba5d33438fda 2509 display.pixel(20,50, BrightRed);
WiredHome 62:ba5d33438fda 2510 display.pixel(22,50, BrightGreen);
WiredHome 62:ba5d33438fda 2511 display.pixel(24,50, BrightBlue);
WiredHome 62:ba5d33438fda 2512 display.line(20,52, 20,52, BrightRed);
WiredHome 62:ba5d33438fda 2513 display.line(22,52, 22,52, BrightGreen);
WiredHome 62:ba5d33438fda 2514 display.line(24,52, 24,52, BrightBlue);
WiredHome 73:f22a18707b5e 2515
WiredHome 62:ba5d33438fda 2516 // point
WiredHome 62:ba5d33438fda 2517 display.line(50,50, 50,50, Red);
WiredHome 62:ba5d33438fda 2518 display.line(52,52, 52,52, Green);
WiredHome 62:ba5d33438fda 2519 display.line(54,54, 54,54, Blue);
WiredHome 62:ba5d33438fda 2520 display.line(60,60, 60,60, BrightRed);
WiredHome 62:ba5d33438fda 2521 display.line(62,62, 62,62, BrightGreen);
WiredHome 62:ba5d33438fda 2522 display.line(64,64, 64,64, BrightBlue);
WiredHome 62:ba5d33438fda 2523 display.line(70,70, 70,70, DarkRed);
WiredHome 62:ba5d33438fda 2524 display.line(72,72, 72,72, DarkGreen);
WiredHome 62:ba5d33438fda 2525 display.line(74,74, 74,74, DarkBlue);
WiredHome 23:a50ded45dbaf 2526 }
WiredHome 23:a50ded45dbaf 2527
WiredHome 44:207594dece70 2528
WiredHome 23:a50ded45dbaf 2529 void RectangleTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2530 {
WiredHome 23:a50ded45dbaf 2531 int i, x1,y1, x2,y2;
WiredHome 23:a50ded45dbaf 2532
WiredHome 41:2956a0a221e5 2533 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2534 pc.printf("Rectangle Test\r\n");
WiredHome 23:a50ded45dbaf 2535 display.background(Black);
WiredHome 23:a50ded45dbaf 2536 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2537 display.cls();
WiredHome 100:0b084475d5a9 2538 display.puts("Rectangle Test");
WiredHome 23:a50ded45dbaf 2539 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2540 x1 = rand() % 240;
WiredHome 23:a50ded45dbaf 2541 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2542 x2 = rand() % 240;
WiredHome 23:a50ded45dbaf 2543 y2 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2544 display.rect(x1,y1, x2,y2, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2545
WiredHome 23:a50ded45dbaf 2546 x1 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 2547 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2548 x2 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 2549 y2 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2550 display.rect(x1,y1, x2,y2, FILL);
WiredHome 23:a50ded45dbaf 2551 }
WiredHome 23:a50ded45dbaf 2552 }
WiredHome 23:a50ded45dbaf 2553
WiredHome 44:207594dece70 2554
WiredHome 44:207594dece70 2555 void LayerTest(RA8875 & display, Serial & pc)
WiredHome 44:207594dece70 2556 {
WiredHome 44:207594dece70 2557 loc_t i, x1,y1, x2,y2, r1,r2;
WiredHome 44:207594dece70 2558
WiredHome 44:207594dece70 2559 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2560 pc.printf("Layer Test\r\n");
WiredHome 44:207594dece70 2561
WiredHome 50:2c4f474a2453 2562 display.SelectDrawingLayer(0);
WiredHome 44:207594dece70 2563 display.background(Black);
WiredHome 44:207594dece70 2564 display.foreground(Blue);
WiredHome 44:207594dece70 2565 display.cls();
WiredHome 100:0b084475d5a9 2566 display.puts("Layer 0");
WiredHome 44:207594dece70 2567 for (i=0; i<16; i++) {
WiredHome 44:207594dece70 2568 x1 = rand() % 240;
WiredHome 44:207594dece70 2569 y1 = 50 + rand() % 200;
WiredHome 44:207594dece70 2570 x2 = x1 + rand() % 100;
WiredHome 44:207594dece70 2571 y2 = y1 + rand() % 100;
WiredHome 44:207594dece70 2572 r1 = rand() % (x2 - x1)/2;
WiredHome 44:207594dece70 2573 r2 = rand() % (y2 - y1)/2;
WiredHome 44:207594dece70 2574 display.roundrect(x1,y1, x2,y2, r1,r2, display.DOSColor(i));
WiredHome 44:207594dece70 2575 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2576 wait_ms(20);
WiredHome 44:207594dece70 2577 }
WiredHome 44:207594dece70 2578 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2579 wait_ms(1000);
WiredHome 44:207594dece70 2580
WiredHome 50:2c4f474a2453 2581 display.SelectDrawingLayer(1);
WiredHome 44:207594dece70 2582 display.background(Black);
WiredHome 44:207594dece70 2583 display.foreground(Yellow);
WiredHome 44:207594dece70 2584 display.cls();
WiredHome 44:207594dece70 2585 display.puts(240,0, "Layer 1");
WiredHome 44:207594dece70 2586 for (i=0; i<16; i++) {
WiredHome 44:207594dece70 2587 x1 = 300 + rand() % 100;
WiredHome 44:207594dece70 2588 y1 = 70 + rand() % 200;
WiredHome 44:207594dece70 2589 r1 = rand() % min(y1 - 20, 100);
WiredHome 44:207594dece70 2590 display.circle(x1,y1,r1, display.DOSColor(i));
WiredHome 44:207594dece70 2591 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2592 wait_ms(20);
WiredHome 44:207594dece70 2593 }
WiredHome 56:7a85d226ad0d 2594 display.SetLayerMode(RA8875::ShowLayer1); // Show it after the build-up
WiredHome 44:207594dece70 2595 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2596 wait_ms(2000);
WiredHome 44:207594dece70 2597
WiredHome 50:2c4f474a2453 2598 display.SelectDrawingLayer(0);
WiredHome 56:7a85d226ad0d 2599 display.SetLayerMode(RA8875::ShowLayer0); // Show Layer 0 again
WiredHome 44:207594dece70 2600 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2601 wait_ms(1000);
WiredHome 53:86d24b9480b9 2602 display.SetLayerMode(RA8875::TransparentMode); // Transparent mode
WiredHome 44:207594dece70 2603 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2604 wait_ms(1000);
WiredHome 44:207594dece70 2605 for (i=0; i<=8; i++) {
WiredHome 44:207594dece70 2606 display.SetLayerTransparency(i, 8-i);
WiredHome 44:207594dece70 2607 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2608 wait_ms(200);
WiredHome 44:207594dece70 2609 }
WiredHome 73:f22a18707b5e 2610
WiredHome 44:207594dece70 2611 // Restore before we exit
WiredHome 44:207594dece70 2612 display.SetLayerTransparency(0, 0);
WiredHome 56:7a85d226ad0d 2613 display.SetLayerMode(RA8875::ShowLayer0); // Restore to layer 0
WiredHome 44:207594dece70 2614 }
WiredHome 44:207594dece70 2615
WiredHome 44:207594dece70 2616
WiredHome 23:a50ded45dbaf 2617 void RoundRectTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2618 {
WiredHome 37:f19b7e7449dc 2619 loc_t i, x1,y1, x2,y2, r1,r2;
WiredHome 23:a50ded45dbaf 2620
WiredHome 41:2956a0a221e5 2621 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2622 pc.printf("Round Rectangle Test\r\n");
WiredHome 23:a50ded45dbaf 2623 display.background(Black);
WiredHome 23:a50ded45dbaf 2624 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2625 display.cls();
WiredHome 100:0b084475d5a9 2626 display.puts("Rounded Rectangle Test");
WiredHome 73:f22a18707b5e 2627
WiredHome 23:a50ded45dbaf 2628 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2629 x1 = rand() % 240;
WiredHome 23:a50ded45dbaf 2630 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2631 x2 = x1 + rand() % 100;
WiredHome 23:a50ded45dbaf 2632 y2 = y1 + rand() % 100;
WiredHome 23:a50ded45dbaf 2633 r1 = rand() % (x2 - x1)/2;
WiredHome 23:a50ded45dbaf 2634 r2 = rand() % (y2 - y1)/2;
WiredHome 23:a50ded45dbaf 2635 display.roundrect(x1,y1, x2,y2, 5,8, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2636
WiredHome 23:a50ded45dbaf 2637 x1 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 2638 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2639 x2 = x1 + rand() % 100;
WiredHome 23:a50ded45dbaf 2640 y2 = y1 + rand() % 100;
WiredHome 23:a50ded45dbaf 2641 r1 = rand() % (x2 - x1)/2;
WiredHome 23:a50ded45dbaf 2642 r2 = rand() % (y2 - y1)/2;
WiredHome 23:a50ded45dbaf 2643 display.roundrect(x1,y1, x2,y2, r1,r2, FILL);
WiredHome 23:a50ded45dbaf 2644 }
WiredHome 23:a50ded45dbaf 2645 }
WiredHome 23:a50ded45dbaf 2646
WiredHome 44:207594dece70 2647
WiredHome 23:a50ded45dbaf 2648 void TriangleTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2649 {
WiredHome 23:a50ded45dbaf 2650 int i, x1, y1, x2, y2, x3, y3;
WiredHome 23:a50ded45dbaf 2651
WiredHome 41:2956a0a221e5 2652 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2653 pc.printf("Triangle Test\r\n");
WiredHome 23:a50ded45dbaf 2654 display.background(Black);
WiredHome 23:a50ded45dbaf 2655 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2656 display.cls();
WiredHome 23:a50ded45dbaf 2657 display.puts(0,0, "Triangle Test");
WiredHome 23:a50ded45dbaf 2658
WiredHome 23:a50ded45dbaf 2659 x1 = 150;
WiredHome 23:a50ded45dbaf 2660 y1 = 2;
WiredHome 23:a50ded45dbaf 2661 x2 = 190;
WiredHome 23:a50ded45dbaf 2662 y2 = 7;
WiredHome 23:a50ded45dbaf 2663 x3 = 170;
WiredHome 23:a50ded45dbaf 2664 y3 = 16;
WiredHome 23:a50ded45dbaf 2665 display.triangle(x1,y1, x2,y2, x3,y3);
WiredHome 23:a50ded45dbaf 2666
WiredHome 23:a50ded45dbaf 2667 x1 = 200;
WiredHome 23:a50ded45dbaf 2668 y1 = 2;
WiredHome 23:a50ded45dbaf 2669 x2 = 240;
WiredHome 23:a50ded45dbaf 2670 y2 = 7;
WiredHome 23:a50ded45dbaf 2671 x3 = 220;
WiredHome 23:a50ded45dbaf 2672 y3 = 16;
WiredHome 23:a50ded45dbaf 2673 display.filltriangle(x1,y1, x2,y2, x3,y3, BrightRed);
WiredHome 23:a50ded45dbaf 2674
WiredHome 23:a50ded45dbaf 2675 x1 = 300;
WiredHome 23:a50ded45dbaf 2676 y1 = 2;
WiredHome 23:a50ded45dbaf 2677 x2 = 340;
WiredHome 23:a50ded45dbaf 2678 y2 = 7;
WiredHome 23:a50ded45dbaf 2679 x3 = 320;
WiredHome 23:a50ded45dbaf 2680 y3 = 16;
WiredHome 23:a50ded45dbaf 2681 display.triangle(x1,y1, x2,y2, x3,y3, NOFILL);
WiredHome 23:a50ded45dbaf 2682
WiredHome 23:a50ded45dbaf 2683 x1 = 400;
WiredHome 23:a50ded45dbaf 2684 y1 = 2;
WiredHome 23:a50ded45dbaf 2685 x2 = 440;
WiredHome 23:a50ded45dbaf 2686 y2 = 7;
WiredHome 23:a50ded45dbaf 2687 x3 = 420;
WiredHome 23:a50ded45dbaf 2688 y3 = 16;
WiredHome 23:a50ded45dbaf 2689 display.triangle(x1,y1, x2,y2, x3,y3, Blue);
WiredHome 23:a50ded45dbaf 2690
WiredHome 23:a50ded45dbaf 2691 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2692 x1 = rand() % 240;
WiredHome 23:a50ded45dbaf 2693 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2694 x2 = rand() % 240;
WiredHome 23:a50ded45dbaf 2695 y2 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2696 x3 = rand() % 240;
WiredHome 23:a50ded45dbaf 2697 y3 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2698 display.triangle(x1,y1, x2,y2, x3,y3, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2699 x1 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 2700 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2701 x2 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 2702 y2 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2703 x3 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 2704 y3 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2705 display.triangle(x1,y1, x2,y2, x3,y3, FILL);
WiredHome 23:a50ded45dbaf 2706 }
WiredHome 23:a50ded45dbaf 2707 }
WiredHome 23:a50ded45dbaf 2708
WiredHome 44:207594dece70 2709
WiredHome 23:a50ded45dbaf 2710 void CircleTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2711 {
WiredHome 23:a50ded45dbaf 2712 int i, x, y, r1;
WiredHome 23:a50ded45dbaf 2713
WiredHome 41:2956a0a221e5 2714 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2715 pc.printf("Circle Test\r\n");
WiredHome 23:a50ded45dbaf 2716 display.background(Black);
WiredHome 23:a50ded45dbaf 2717 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2718 display.cls();
WiredHome 100:0b084475d5a9 2719 display.puts("Circle Test");
WiredHome 23:a50ded45dbaf 2720 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2721 x = 100 + rand() % 100;
WiredHome 23:a50ded45dbaf 2722 y = 70 + rand() % 200;
WiredHome 23:a50ded45dbaf 2723 r1 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2724 //pc.printf(" (%d,%d) - %d\r\n", x,y,r1);
WiredHome 23:a50ded45dbaf 2725 display.circle(x,y,r1, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2726
WiredHome 23:a50ded45dbaf 2727 x = 300 + rand() % 100;
WiredHome 23:a50ded45dbaf 2728 y = 70 + rand() % 200;
WiredHome 23:a50ded45dbaf 2729 r1 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2730 //pc.printf(" (%d,%d) - %d FILL\r\n", x,y,r1);
WiredHome 23:a50ded45dbaf 2731 display.circle(x,y,r1, display.DOSColor(i), FILL);
WiredHome 23:a50ded45dbaf 2732 }
WiredHome 23:a50ded45dbaf 2733 }
WiredHome 23:a50ded45dbaf 2734
WiredHome 44:207594dece70 2735
WiredHome 23:a50ded45dbaf 2736 void EllipseTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2737 {
WiredHome 23:a50ded45dbaf 2738 int i,x,y,r1,r2;
WiredHome 23:a50ded45dbaf 2739
WiredHome 41:2956a0a221e5 2740 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2741 pc.printf("Ellipse Test\r\n");
WiredHome 23:a50ded45dbaf 2742 display.background(Black);
WiredHome 23:a50ded45dbaf 2743 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2744 display.cls();
WiredHome 100:0b084475d5a9 2745 display.puts("Ellipse Test");
WiredHome 23:a50ded45dbaf 2746 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2747 x = 100 + rand() % 100;
WiredHome 23:a50ded45dbaf 2748 y = 70 + rand() % 200;
WiredHome 23:a50ded45dbaf 2749 r1 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2750 r2 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2751 display.ellipse(x,y,r1,r2, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2752
WiredHome 23:a50ded45dbaf 2753 x = 300 + rand() % 100;
WiredHome 23:a50ded45dbaf 2754 y = 70 + rand() % 200;
WiredHome 23:a50ded45dbaf 2755 r1 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2756 r2 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2757 display.ellipse(x,y,r1,r2, FILL);
WiredHome 23:a50ded45dbaf 2758 }
WiredHome 23:a50ded45dbaf 2759 }
WiredHome 23:a50ded45dbaf 2760
WiredHome 44:207594dece70 2761
WiredHome 37:f19b7e7449dc 2762 void TestGraphicsBitmap(RA8875 & display, Serial & pc)
WiredHome 37:f19b7e7449dc 2763 {
WiredHome 37:f19b7e7449dc 2764 LocalFileSystem local("local");
WiredHome 41:2956a0a221e5 2765 if (!SuppressSlowStuff)
WiredHome 73:f22a18707b5e 2766 pc.printf("Bitmap File Load\r\n");
WiredHome 37:f19b7e7449dc 2767 display.background(Black);
WiredHome 37:f19b7e7449dc 2768 display.foreground(Blue);
WiredHome 37:f19b7e7449dc 2769 display.cls();
WiredHome 100:0b084475d5a9 2770 display.puts("Graphics Test, loading /local/TestPat.bmp");
WiredHome 37:f19b7e7449dc 2771 wait(3);
WiredHome 37:f19b7e7449dc 2772
WiredHome 37:f19b7e7449dc 2773 int r = display.RenderBitmapFile(0,0, "/local/TestPat.bmp");
WiredHome 59:fb40aad4efd4 2774 if (!SuppressSlowStuff)
WiredHome 59:fb40aad4efd4 2775 pc.printf(" returned %d\r\n", r);
WiredHome 37:f19b7e7449dc 2776 }
WiredHome 37:f19b7e7449dc 2777
WiredHome 44:207594dece70 2778
WiredHome 77:9206c13aa527 2779 void TouchPanelTest(RA8875 & display, Serial & pc)
WiredHome 77:9206c13aa527 2780 {
WiredHome 77:9206c13aa527 2781 Timer t;
WiredHome 98:ecebed9b80b2 2782 int x, y;
WiredHome 78:faf49c381591 2783 tpMatrix_t calmatrix;
WiredHome 78:faf49c381591 2784
WiredHome 77:9206c13aa527 2785 display.background(Black);
WiredHome 77:9206c13aa527 2786 display.foreground(Blue);
WiredHome 77:9206c13aa527 2787 display.cls();
WiredHome 100:0b084475d5a9 2788 display.puts("Touch Panel Test\r\n");
WiredHome 78:faf49c381591 2789 pc.printf("Touch Panel Test\r\n");
WiredHome 77:9206c13aa527 2790 display.TouchPanelInit();
WiredHome 78:faf49c381591 2791 pc.printf(" TP: c - calibrate, r - restore, t - test\r\n");
WiredHome 78:faf49c381591 2792 int c = pc.getc();
WiredHome 78:faf49c381591 2793 if (c == 'c') {
WiredHome 78:faf49c381591 2794 point_t pTest[3] =
WiredHome 78:faf49c381591 2795 { { 50, 50 }, {450, 150}, {225,250} };
WiredHome 78:faf49c381591 2796 point_t pSample[3];
WiredHome 78:faf49c381591 2797 for (int i=0; i<3; i++) {
WiredHome 78:faf49c381591 2798 display.foreground(Blue);
WiredHome 78:faf49c381591 2799 display.printf(" (%3d,%3d) => ", pTest[i].x, pTest[i].y);
WiredHome 78:faf49c381591 2800 display.line(pTest[i].x-10, pTest[i].y, pTest[i].x+10, pTest[i].y, White);
WiredHome 78:faf49c381591 2801 display.line(pTest[i].x, pTest[i].y-10, pTest[i].x, pTest[i].y+10, White);
WiredHome 79:544eb4964795 2802 while (!display.TouchPanelA2DFiltered(&x, &y))
WiredHome 78:faf49c381591 2803 wait_ms(20);
WiredHome 78:faf49c381591 2804 pSample[i].x = x;
WiredHome 78:faf49c381591 2805 pSample[i].y = y;
WiredHome 78:faf49c381591 2806 display.line(pTest[i].x-10, pTest[i].y, pTest[i].x+10, pTest[i].y, Black);
WiredHome 78:faf49c381591 2807 display.line(pTest[i].x, pTest[i].y-10, pTest[i].x, pTest[i].y+10, Black);
WiredHome 78:faf49c381591 2808 display.foreground(Blue);
WiredHome 78:faf49c381591 2809 display.printf(" (%4d,%4d)\r\n", x,y);
WiredHome 79:544eb4964795 2810 while (display.TouchPanelA2DFiltered(&x, &y))
WiredHome 78:faf49c381591 2811 wait_ms(20);
WiredHome 78:faf49c381591 2812 wait(2);
WiredHome 78:faf49c381591 2813 }
WiredHome 81:01da2e34283d 2814 display.TouchPanelComputeCalibration(pTest, pSample, &calmatrix);
WiredHome 78:faf49c381591 2815 display.printf(" Writing calibration to tpcal.cfg\r\n");
WiredHome 78:faf49c381591 2816 FILE * fh = fopen("/local/tpcal.cfg", "wb");
WiredHome 78:faf49c381591 2817 if (fh) {
WiredHome 78:faf49c381591 2818 fwrite(&calmatrix, sizeof(calmatrix), 1, fh);
WiredHome 78:faf49c381591 2819 fclose(fh);
WiredHome 78:faf49c381591 2820 }
WiredHome 78:faf49c381591 2821 display.printf(" Calibration is complete.");
WiredHome 78:faf49c381591 2822 } else if (c == 'r') {
WiredHome 78:faf49c381591 2823 display.printf(" Reading calibration from tpcal.cfg\r\n");
WiredHome 78:faf49c381591 2824 FILE * fh = fopen("/local/tpcal.cfg", "rb");
WiredHome 78:faf49c381591 2825 if (fh) {
WiredHome 78:faf49c381591 2826 fread(&calmatrix, sizeof(calmatrix), 1, fh);
WiredHome 78:faf49c381591 2827 fclose(fh);
WiredHome 78:faf49c381591 2828 }
WiredHome 78:faf49c381591 2829 display.printf(" Calibration is complete.");
WiredHome 78:faf49c381591 2830 display.TouchPanelSetMatrix(&calmatrix);
WiredHome 77:9206c13aa527 2831 }
WiredHome 77:9206c13aa527 2832 t.start();
WiredHome 77:9206c13aa527 2833 do {
WiredHome 77:9206c13aa527 2834 point_t point = {0, 0};
WiredHome 79:544eb4964795 2835 if (display.TouchPanelReadable(&point)) {
WiredHome 77:9206c13aa527 2836 display.pixel(point.x, point.y, Red);
WiredHome 77:9206c13aa527 2837 }
WiredHome 77:9206c13aa527 2838 } while (t.read_ms() < 30000);
WiredHome 77:9206c13aa527 2839 pc.printf(">");
WiredHome 77:9206c13aa527 2840 }
WiredHome 77:9206c13aa527 2841
WiredHome 77:9206c13aa527 2842
WiredHome 41:2956a0a221e5 2843 void SpeedTest(RA8875 & display, Serial & pc)
WiredHome 41:2956a0a221e5 2844 {
WiredHome 41:2956a0a221e5 2845 Timer t;
WiredHome 41:2956a0a221e5 2846 SuppressSlowStuff = true;
WiredHome 41:2956a0a221e5 2847 pc.printf("\r\nSpeedTest disables delays, runs tests, reports overall time.\r\n");
WiredHome 41:2956a0a221e5 2848 t.start();
WiredHome 41:2956a0a221e5 2849 // do stuff fast
WiredHome 41:2956a0a221e5 2850 TextCursorTest(display, pc);
WiredHome 49:c5182231d1b9 2851 TextWrapTest(display, pc);
WiredHome 41:2956a0a221e5 2852 BacklightTest(display, pc, 0);
WiredHome 41:2956a0a221e5 2853 BacklightTest2(display, pc);
WiredHome 41:2956a0a221e5 2854 ExternalFontTest(display, pc);
WiredHome 41:2956a0a221e5 2855 DOSColorTest(display, pc);
WiredHome 41:2956a0a221e5 2856 WebColorTest(display, pc);
WiredHome 41:2956a0a221e5 2857 PixelTest(display, pc);
WiredHome 41:2956a0a221e5 2858 LineTest(display, pc);
WiredHome 41:2956a0a221e5 2859 RectangleTest(display, pc);
WiredHome 41:2956a0a221e5 2860 RoundRectTest(display, pc);
WiredHome 41:2956a0a221e5 2861 TriangleTest(display, pc);
WiredHome 41:2956a0a221e5 2862 CircleTest(display, pc);
WiredHome 41:2956a0a221e5 2863 EllipseTest(display, pc);
WiredHome 44:207594dece70 2864 LayerTest(display, pc);
WiredHome 41:2956a0a221e5 2865 //TestGraphicsBitmap(display, pc);
WiredHome 41:2956a0a221e5 2866 pc.printf("SpeedTest completed in %d msec\r\n", t.read_ms());
WiredHome 73:f22a18707b5e 2867 #ifdef PERF_METRICS
WiredHome 41:2956a0a221e5 2868 display.ReportPerformance(pc);
WiredHome 73:f22a18707b5e 2869 #endif
WiredHome 41:2956a0a221e5 2870 SuppressSlowStuff = false;
WiredHome 41:2956a0a221e5 2871 }
WiredHome 41:2956a0a221e5 2872
WiredHome 44:207594dece70 2873
WiredHome 41:2956a0a221e5 2874 void PrintScreen(RA8875 & display, Serial & pc)
WiredHome 41:2956a0a221e5 2875 {
WiredHome 41:2956a0a221e5 2876 if (!SuppressSlowStuff)
WiredHome 73:f22a18707b5e 2877 pc.printf("PrintScreen\r\n");
WiredHome 41:2956a0a221e5 2878 display.PrintScreen( 0,0, 480,272, "/local/Capture.bmp");
WiredHome 41:2956a0a221e5 2879 }
WiredHome 41:2956a0a221e5 2880
WiredHome 44:207594dece70 2881
WiredHome 23:a50ded45dbaf 2882 void RunTestSet(RA8875 & lcd, Serial & pc)
WiredHome 23:a50ded45dbaf 2883 {
WiredHome 23:a50ded45dbaf 2884 int q = 0;
WiredHome 23:a50ded45dbaf 2885 int automode = 0;
WiredHome 49:c5182231d1b9 2886 const unsigned char modelist[] = "BDWtGLlFROTPCEbw"; // auto-test in this order.
WiredHome 23:a50ded45dbaf 2887
WiredHome 23:a50ded45dbaf 2888 while(1) {
WiredHome 23:a50ded45dbaf 2889 pc.printf("\r\n"
WiredHome 41:2956a0a221e5 2890 "B - Backlight up b - backlight dim\r\n"
WiredHome 41:2956a0a221e5 2891 "D - DOS Colors W - Web Colors\r\n"
WiredHome 41:2956a0a221e5 2892 "t - text cursor G - Graphics Bitmap\r\n"
WiredHome 41:2956a0a221e5 2893 "L - Lines F - external Font\r\n"
WiredHome 41:2956a0a221e5 2894 "R - Rectangles O - rOund rectangles\r\n"
WiredHome 41:2956a0a221e5 2895 "T - Triangles P - Pixels \r\n"
WiredHome 41:2956a0a221e5 2896 "C - Circles E - Ellipses\r\n"
WiredHome 41:2956a0a221e5 2897 "A - Auto Test mode S - Speed Test\r\n"
WiredHome 77:9206c13aa527 2898 "K - Keypad Test s - touch screen test\r\n"
WiredHome 41:2956a0a221e5 2899 "p - print screen r - reset \r\n"
WiredHome 49:c5182231d1b9 2900 "l - layer test w - wrapping text \r\n"
WiredHome 73:f22a18707b5e 2901 #ifdef PERF_METRICS
WiredHome 41:2956a0a221e5 2902 "0 - clear performance 1 - report performance\r\n"
WiredHome 73:f22a18707b5e 2903 #endif
WiredHome 23:a50ded45dbaf 2904 "> ");
WiredHome 23:a50ded45dbaf 2905 if (automode == -1 || pc.readable()) {
WiredHome 23:a50ded45dbaf 2906 automode = -1;
WiredHome 37:f19b7e7449dc 2907 q = pc.getc();
WiredHome 37:f19b7e7449dc 2908 while (pc.readable())
WiredHome 37:f19b7e7449dc 2909 pc.getc();
WiredHome 23:a50ded45dbaf 2910 } else if (automode >= 0) {
WiredHome 23:a50ded45dbaf 2911 q = modelist[automode];
WiredHome 23:a50ded45dbaf 2912 }
WiredHome 23:a50ded45dbaf 2913 switch(q) {
WiredHome 73:f22a18707b5e 2914 #ifdef PERF_METRICS
WiredHome 41:2956a0a221e5 2915 case '0':
WiredHome 41:2956a0a221e5 2916 lcd.ClearPerformance();
WiredHome 41:2956a0a221e5 2917 break;
WiredHome 41:2956a0a221e5 2918 case '1':
WiredHome 41:2956a0a221e5 2919 lcd.ReportPerformance(pc);
WiredHome 41:2956a0a221e5 2920 break;
WiredHome 73:f22a18707b5e 2921 #endif
WiredHome 23:a50ded45dbaf 2922 case 'A':
WiredHome 23:a50ded45dbaf 2923 automode = 0;
WiredHome 23:a50ded45dbaf 2924 break;
WiredHome 23:a50ded45dbaf 2925 case 'B':
WiredHome 41:2956a0a221e5 2926 BacklightTest(lcd, pc, 2);
WiredHome 23:a50ded45dbaf 2927 break;
WiredHome 23:a50ded45dbaf 2928 case 'b':
WiredHome 23:a50ded45dbaf 2929 BacklightTest2(lcd, pc);
WiredHome 23:a50ded45dbaf 2930 break;
WiredHome 23:a50ded45dbaf 2931 case 'D':
WiredHome 23:a50ded45dbaf 2932 DOSColorTest(lcd, pc);
WiredHome 23:a50ded45dbaf 2933 break;
WiredHome 75:ca78388cfd77 2934 case 'K':
WiredHome 75:ca78388cfd77 2935 KeyPadTest(lcd, pc);
WiredHome 75:ca78388cfd77 2936 break;
WiredHome 23:a50ded45dbaf 2937 case 'W':
WiredHome 23:a50ded45dbaf 2938 WebColorTest(lcd, pc);
WiredHome 23:a50ded45dbaf 2939 break;
WiredHome 23:a50ded45dbaf 2940 case 't':
WiredHome 23:a50ded45dbaf 2941 TextCursorTest(lcd, pc);
WiredHome 23:a50ded45dbaf 2942 break;
WiredHome 49:c5182231d1b9 2943 case 'w':
WiredHome 49:c5182231d1b9 2944 TextWrapTest(lcd, pc);
WiredHome 49:c5182231d1b9 2945 break;
WiredHome 23:a50ded45dbaf 2946 case 'F':
WiredHome 23:a50ded45dbaf 2947 ExternalFontTest(lcd, pc);
WiredHome 23:a50ded45dbaf 2948 break;
WiredHome 23:a50ded45dbaf 2949 case 'L':
WiredHome 23:a50ded45dbaf 2950 LineTest(lcd, pc);
WiredHome 23:a50ded45dbaf 2951 break;
WiredHome 44:207594dece70 2952 case 'l':
WiredHome 44:207594dece70 2953 LayerTest(lcd, pc);
WiredHome 44:207594dece70 2954 break;
WiredHome 23:a50ded45dbaf 2955 case 'R':
WiredHome 23:a50ded45dbaf 2956 RectangleTest(lcd, pc);
WiredHome 23:a50ded45dbaf 2957 break;
WiredHome 23:a50ded45dbaf 2958 case 'O':
WiredHome 23:a50ded45dbaf 2959 RoundRectTest(lcd, pc);
WiredHome 23:a50ded45dbaf 2960 break;
WiredHome 41:2956a0a221e5 2961 case 'p':
WiredHome 41:2956a0a221e5 2962 PrintScreen(lcd, pc);
WiredHome 41:2956a0a221e5 2963 break;
WiredHome 41:2956a0a221e5 2964 case 'S':
WiredHome 41:2956a0a221e5 2965 SpeedTest(lcd, pc);
WiredHome 41:2956a0a221e5 2966 break;
WiredHome 77:9206c13aa527 2967 case 's':
WiredHome 77:9206c13aa527 2968 TouchPanelTest(lcd, pc);
WiredHome 77:9206c13aa527 2969 break;
WiredHome 23:a50ded45dbaf 2970 case 'T':
WiredHome 23:a50ded45dbaf 2971 TriangleTest(lcd, pc);
WiredHome 23:a50ded45dbaf 2972 break;
WiredHome 37:f19b7e7449dc 2973 case 'P':
WiredHome 37:f19b7e7449dc 2974 PixelTest(lcd, pc);
WiredHome 37:f19b7e7449dc 2975 break;
WiredHome 37:f19b7e7449dc 2976 case 'G':
WiredHome 37:f19b7e7449dc 2977 TestGraphicsBitmap(lcd, pc);
WiredHome 37:f19b7e7449dc 2978 break;
WiredHome 23:a50ded45dbaf 2979 case 'C':
WiredHome 23:a50ded45dbaf 2980 CircleTest(lcd, pc);
WiredHome 23:a50ded45dbaf 2981 break;
WiredHome 23:a50ded45dbaf 2982 case 'E':
WiredHome 23:a50ded45dbaf 2983 EllipseTest(lcd, pc);
WiredHome 23:a50ded45dbaf 2984 break;
WiredHome 23:a50ded45dbaf 2985 case 'r':
WiredHome 23:a50ded45dbaf 2986 pc.printf("Resetting ...\r\n");
WiredHome 23:a50ded45dbaf 2987 wait_ms(20);
WiredHome 23:a50ded45dbaf 2988 mbed_reset();
WiredHome 23:a50ded45dbaf 2989 break;
WiredHome 75:ca78388cfd77 2990 case ' ':
WiredHome 75:ca78388cfd77 2991 break;
WiredHome 23:a50ded45dbaf 2992 default:
WiredHome 23:a50ded45dbaf 2993 printf("huh?\n");
WiredHome 23:a50ded45dbaf 2994 break;
WiredHome 23:a50ded45dbaf 2995 }
WiredHome 23:a50ded45dbaf 2996 if (automode >= 0) {
WiredHome 23:a50ded45dbaf 2997 automode++;
WiredHome 23:a50ded45dbaf 2998 if (automode >= sizeof(modelist))
WiredHome 23:a50ded45dbaf 2999 automode = 0;
WiredHome 23:a50ded45dbaf 3000 wait_ms(2000);
WiredHome 23:a50ded45dbaf 3001 }
WiredHome 23:a50ded45dbaf 3002 wait_ms(200);
WiredHome 23:a50ded45dbaf 3003 }
WiredHome 23:a50ded45dbaf 3004 }
WiredHome 23:a50ded45dbaf 3005
WiredHome 79:544eb4964795 3006 #endif // TESTENABLE