David Smart / RA8875 Featured

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

Dependents:   FRDM_RA8875_mPaint RA8875_Demo RA8875_KeyPadDemo SignalGenerator ... more

Fork of SPI_TFT by Peter Drescher

See Components - RA8875 Based Display

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

Offline Help Manual (Windows chm)

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

RA8875.cpp@133:e36dcfc2d756, 2016-10-17 (annotated)

Committer:
WiredHome
Date:
Mon Oct 17 00:42:47 2016 +0000
Revision:
133:e36dcfc2d756
Parent:
131:5bd6ba2ee4a1
Child:
134:f028ed71a0af
Revised how it sets the foreground and background color to correct a defect when in 8-bit mode.

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