Kerry Martin / RA8875

KSM edits to RA8875

Dependents:   Liz_Test_Code

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